«Программирование в среде Турбо Паскаль»

Программирование в среде Турбо Паскаль (fb2) - Программирование в среде Турбо Паскаль 1738K скачать: (fb2) - (epub) - (mobi) - Дмитрий Борисович Поляков - Игорь Юрьевич Круглов

Д. Б. Поляков, И.Ю. Круглов Программирование в среде Турбо Паскаль

(версия 5.5)

Москва

Издательство МАИ

А/О «РОСВУЗНАУКА»

1992

Рецензенты:

доктор технических наук профессор В.А.ИВАНОВ,

кандидат технических наук Ю.Н.СТЕПАНОВ

От авторов

Авторам этой книги хорошо известен информационный «голод», который сопутствует освоению сначала персональной ЭВМ (ПЭВМ), потом ее программных средств. С ростом парка ввезенных и произведенных в нашей стране ПЭВМ стал ощущаться острый недостаток специальной литературы. Как следствие этого, колоссальное время тратится на накопление опыта работы с ПЭВМ, освоение «вслепую» сложных программных продуктов, особенно трансляторов с языков высокого уровня. В силу специфики распространения программ их оригинальные описания — почти «букинистическая редкость», что часто приводит к ситуации, когда богатейшие возможности ПЭВМ остаются практически невостребованными. Эта книга — попытка помочь тем, кто собирается освоить язык и систему программирования Турбо Паскаль версии 5.5, созданные американской фирмой Borland International. Книга предназначена в первую очередь пользователям ПЭВМ, знакомым в той или иной степени с основами языка Паскаль. Книга не должна показаться сложной и тем, кто имеет опыт работы с Бейсиком, Си или каким-либо другим процедурным языком. Авторы старались наиболее полно изложить язык Турбо Паскаль, подчеркнуть практические стороны и особенности его применения, а также привести различные приемы программирования на нем.

Хотя имеется несколько версий Турбо Паскаля, изложение материала привязано к версии языка 5.5, последней в момент написания книги. Версия 5.5 отличается от версии 5.0 тем, что расширен синтаксис языка (введена возможность объектно-ориентированного программирования) и модифицирован системный модуль Overlay. По сравнению же с версией 4.0 произошли большие изменения (исчезли цепочки, появились оверлеи, расширились наборы процедур и т.п.) Многое из того, что верно для Турбо Паскаля версии 3.0 (а именно для нее написано огромное число книг по Турбо Паскалю за рубежом и подавляющее число у нас), совершенно не годится для последующих версий. Все сказанное можно отнести и к интегрированной среде программирования.

Авторы не проводили специального тестирования, но с большой вероятностью та часть книги, которая касается самого языка (без объектного программирования) и работы в среде MS-DOS, не будет бесполезной и для работающих с системой Quick Pascal 1.0 фирмы Microsoft.

- 4 -

Изложение ведется для операционной системы (ОС) MS-DOS, но подразумевается работа в среде любой совместимой с ней ОС, в том числе PC-DOS, АДОС, Альфа-ДОС и т.п. Несколько слов о многочисленных примерах и тестах по ходу изложения материала. Авторы старались приводить нетривиальные примеры, которые могли бы иметь самостоятельную ценность или хотя бы быть полезными читателю. Однако возможности протестировать их всех в различных версиях ОС (от 2.0 до 4.01 их слишком много!) и на различных моделях ПЭВМ не было. Примеры проверены в среде MS-DOS 3.20 и 3.30 (наиболее распространенных на момент написания книги) на ПЭВМ с высокой степенью совместимости с IBM PC/XT, AT/16 МГц и на IBM PS/2 (модель 50).

Поскольку авторам неизвестно об адаптации пакетов Турбо Паскаль версии 5.0 или 5.5 для использования на ПЭВМ ЕС или «Искра» и из-за отличия этих машин от стандарта IBM (особенно в блоке клавиатуры), нельзя с полной уверенностью адресовать эту книгу пользователям именно этих машин. Авторы ориентировались на пользователей пакетов, работающих на импортных ПЭВМ, количество которых в стране весьма значительно. Вследствие этого сохранены английские названия служебных клавиш и английский синтаксис команд ОС и самой среды Турбо Паскаль.

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

В заключение авторы выражают признательность коллегам: А.Ю. Самсонову за помощь при написании главы «Объектно-ориентированное программирование», Г.П. Шушпанову за ценный вклад в создание главы «Ссылки, динамические переменные и структуры данных» и ряда практических примеров, а также Н.А. Семеновой и Н.А. Калитиной, напечатавшим весь текст книги.

Часть 1 этой книги написана И.Ю. Кругловым. Он же является автором глав 19 и 22. Части 2 и 3, а также главы 15, 16, 20 и 21 написаны Д.Б. Поляковым. Совместно подготовлены введение, главы 17, 18 и приложения.

При изготовлении файла использован (исправлено, дополнено) сайт -prog.ru/2_23369_glava--integrirovannaya-sreda.html.

w_cat.

Введение

Система программирования Турбо Паскаль (версия 5.5) в состоянии удовлетворить практически любые требования при работе на ПЭВМ IBM PC и совместимых с ними. Язык Турбо Паскаль является структурированным языком высокого уровня, на котором можно написать программу практически неограниченного размера и любого назначения. Описываемая версия Турбо Паскаля представляет собой полную среду для профессионального программирования, обладающую очень высокими характеристиками. Среди них:

— совместимость со стандартом ANSI Pascal;

— наличие системных библиотечных модулей, являющихся органической составляющей языка (System, DOS, CRT, Graph и др.);

— расширение языка, превращающее его в инструмент объектно-ориентированного программирования (ООП);

— наличие новых встроенных процедур и функций (в том числе Inc и Dec);

— наличие версий компилятора, как встроенного в интегрированную среду программирования, так и автономного (для трансляции программ большого размера);

— высокая скорость компиляции ;

— генерация оптимизированного кода, обеспечивающая быстрое выполнение программ; — редактор связей, удаляющий неиспользуемые части кода на этапе компиляции (создается код минимального размера);

— возможность создания отдельно компилируемых блоков; — возможность условной компиляции программ;

— поддержка математических сопроцессоров 80X87 (8087, 80287);

— наличие расширенного набора числовых целых типов и типов данных с плавающей запятой стандарта IEEE (с одинарной точностью, с двойной точностью, с повышенной точностью) в случае использования сопроцессоров 80X87.

Кроме того, в системе реализованы следующие возможности:

— эффективный интерфейс с языками Turbo Assembler и Turbo С на уровне объектного кода;

- 6 -

— интегрированный отладчик на уровне исходного текста, обеспечивающий полную проверку переменных, структур данных и выражений по шагам или в заданных точках программы и присваивание новых значений переменным и структурам данных в процессе отладки;

— полная эмуляция операций с плавающей запятой сопроцессоров 80X87, позволяющая использовать типы данных в формате с плавающей запятой (IEEE) даже при отсутствии сопроцессоров 80X87;

— использование оверлеев на основе программных модулей, а также развитая подсистема управления оверлеями, дающая возможность управлять размещением их в памяти;

— поддержка средств расширенной памяти (EMS), включая возможность загрузки оверлея в нее, и использование этой памяти интегрированной средой программирования Структура книги такова, что читая ее, можно постепенно начинать работу с системой Турбо Паскаль, с каждым разделом усваивая новые понятия.

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

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

Приступая к чтению, необходимо иметь представление о принципах работы ПЭВМ фирмы IBM (и совместимых с ними) под управлением ОС MS-DOS; знать, как запускаются на выполнение программы, как копируются и удаляются файлы и как используются другие базовые команды ОС. Если нет уверенности в своих знаниях, советуем потратить некоторое время на освоение компьютера и просмотреть книги по ОС MS-DOS. Для понимании общей идеологии построения системы сначала кратко рассмотрим функции ее составных частей. Пакет Турбо Паскаль содержит в себе два компилятора: автономный и встроенный в интегрированную среду программирования.

- 7 -

Интерактивная интегрированная среда программирования сочетает возможности редактора текстов, компилятора и отладчика. Она поддерживает систему меню, оконный интерфейс, управление конфигурацией системы и контекстную систему подсказки (см. часть 1 «Работа в среде программирования Турбо Паскаль»). Сама среда программирования включается запуском файла TURBO.EXE.

При работе в автономном режиме компиляции (с использованием командной строки или командных файлов) для создания и изменения исходного текста программы можно использовать любой текстовый редактор. После этого нужно запустить автономный компилятор с помощью команды MS-DOS или командного файла, задав имя файла программы, написанной на Турбо Паскале, и режимы компиляции (см. Приложение 2). Этот компилятор представлен файлом ТРС.ЕХЕ.

Встроенный отладчик позволяет легко выполнять программы по шагам, проверяя или модифицируя при этом переменные и ячейки памяти, устанавливая точки останова и прерывая выполнение программы с помощью специальной комбинации клавиш (CtrH-Break). Развитием принципов структурного программирования является введение в Турбо Паскаль понятия модуля. Модуль представляет собой часть исходного текста, которую можно откомпилировать как самостоятельное целое. Его можно рассматривать как библиотеку данных и программного кода. Модули обеспечивают описание интерфейса между своими процедурами и данными и другими программами, которые используют эти модули. Они могут применяться в программах, а также в других модулях. Подробно обо всем этом рассказывается в разд. 6.10 «Модули. Структура модулей». В системе Турбо Паскаль имеются стандартные библиотеки, которые оформлены в виде таких модулей. Они содержат процедуры различного функционального назначения:

SYSTEM — стандартные процедуры языка;

DOS — работа с функциями ОС MS-DOS;

CRT — работа с клавиатурой и дисплеем;

PRINTER — легкий доступ к принтеру;

GRAPH — графические процедуры;

OVERLAY — поддержка и администрирование оверлейных структур;

TURB03 — обеспечение совместимости с версией языка 3.0;

GRAPH3 — графические процедуры, реализованные в версии языка 3.0.

- 8 -

К этому списку можно добавить весьма полезный модуль, представленный в исходном пакете системы, но не описанный в ее руководстве: WIN — быстрая и удобная работа с окнами.

Все эти модули (кроме TURB03 и GRAPH3) рассматриваются в дальнейшем в разделах, носящих соответствующие названия. Модули, обеспечивающие совместимость с Турбо Паскалем версии 3.0 нужны только тем, кто имеет богатую библиотеку текстов программ именно для этой версии. Во всех остальных случаях они мало интересны, поскольку не предлагают ничего нового в основной набор средств языка.

В состав системы программирования входит ряд автономных программ-утилит: TPUMOVER, MAKE, TOUCH, BINOBJ, THELP и GREP. Их использование сильно сокращает рутинную, а в некоторых случаях и невыполнимую иным способом, работу по администрированию библиотеки, автономной компиляции, преобразованию файлов и их сравнению. Краткое их описание содержится в Приложении 4 (описание утилиты THELP см. в разд. 1.4 «Интерактивная справка»).

Часть I. РАБОТА В СРЕДЕ ПРОГРАММИРОВАНИЯ ТУРБО ПАСКАЛЬ

Глава 1. Интегрированная среда

Работа с Турбо Паскалем версии 5.5 начинается после запуска на выполнение файла TURBO.EXE. На экране появляется исходное изображение (рис. 1.1).

Рис. 1.1

В верхней части экрана появляется меню (рис. 1.2):

Рис. 1.2

Приведенные выше слова составляют основное меню среды программирования. Активизировать это меню можно нажатием клавиши

- 10 -

F10. Каждое слово в основном меню (кроме Edit) представляет собой заголовок вертикального подменю, которое может появляться под ним. Клавишами управления курсором («стрелка влево» и «стрелка вправо») можно выбрать любой пункт основного меню и, нажимая затем клавишу ввода (Enter или Return) или клавишу «стрелка вниз», активизировать соответствующее ему подменю.

Область под основным меню изначально разделена на два окна: Edit и Watch. Окно Edit — это рабочее пространство для работы с текстом программы, а в окне Watch появляется специфическая информация, необходимая при отладке программ. Переключение между этими окнами возможно в любой момент работы с системой. Например, для перехода в окно Edit достаточно из основного меню выбрать пункт Edit или нажать комбинацию клавиш Alt+E. Индикацией того, что окно Edit стало активным, служит изменение обрамляющей рамки этого окна (одинарная линия заменяется двойной) и появление мигающего курсора внутри него. После этого можно приступать к работе с исходным текстом программы. Переключение на окно Watch и обратно осуществляется нажатием клавиши F6.

Есть еще одно окно, доступное в Турбо Паскале, — это окно Output, в котором можно просмотреть результат выполнения программы. Из окна Watch можно попасть в окно Output, нажав комбинацию клавиш Alt+F6. Еще одно нажатие Alt+F6 возвращает обратно в окно Watch, а нажатие F6 активизирует Edit. Другой способ увидеть результат работы программы, заключается в переключении на полноэкранный вариант окна Output комбинацией клавиш Alt+F5. Вернуться обратно можно, нажав любую клавишу.

В нижней строке экрана находится строка-подсказка, на которой указано соответствие между функциональной клавиатурой и выполняемыми действиями (рис. 1.3).

Рис. 1.3

В документации по Турбо Паскалю, прилагаемой к пакету, эти ключи называются «горячими» (Hot keys). С их помощью многие действия можно производить «в обход» системы меню. Содержание этой строки зависит от режима, в котором находится среда программирования. Ниже приводится таблица базовых функций, присвоенных функциональной клавиатуре (табл. 1.1).

- 11 -

Клавиши

Функция

F1

Активизирует окно контекстной помощи

F2

Записывает программу, находящуюся в окне Edit на диск

F3

Запрашивает команду Load для чтения файла с диска в окно Edit

F4

Отладочная операция. Включает выполнение программы до строки, в которой находится курсор, и ее приостановку

F5

Расширяет текущее окно до полного экрана.

F6

Переключает между окнами Edit, Watch и Output (в зависимости от текущего окна)

F7

Отладочная операция. Включает выполнение программы по строкам текста в режиме трассировки (т.е. прослеживает действие программы и внутри процедур или функций)

F8

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

F9

Выполняет операцию Make (один из способов компиляции программы)

F10

Переключает между выбранным экраном и верхней строкой меню

Редактор Турбо Паскаля представляет собой полную программу текстового процессора. В добавление к основным функциям редактирования (таким, как вставка и удаление), можно выполнять и более сложные действия: поиск и замену строки символов, блоковые операции. Редактор Турбо Паскаля совместим с текстовым редактором WordStar.

После набора текста программы в редакторе, можно провести ее компиляцию и запуск на выполнение нажав лишь комбинацию клавиш Ctrl+F9. Результатом этой компиляции является компактный и эффективный исполняемый код.

1.1. Окно просмотра результатов Output

Скомпилированная программа сразу готова к работе: в окне Output будут выводиться все сообщения и запросы программы. Если она не запрашивает ввода данных с клавиатуры, то выходной экран виден до

- 12 -

тех пор, пока выполняется сама программа. После ее завершения происходит возврат в систему. Если требуется еще раз посмотреть, что вывела на экран программа, то нужно нажать на клавиши Alt+F5. На экране появится результат работы программы в таком виде, как если бы она была запущена под управлением MS-DOS.

Другая возможность просмотреть результат — это переход в окно Output и увеличение его размеров до полного экрана. Для этого необходимо произвести следующие действия:

1) нажать клавишу F6 (активизация окна Watch);

2) нажать комбинацию клавиш Alt+F6 для замены окна Watch на окно Output;

3) нажать клавишу F5 для расширения его до полного экрана.

В этом случае верхняя строка меню и нижняя строка помощи остается на экране. Для возврата требуется выполнить перечисленные действия в обратном порядке (F5, Alt+F6, F6).

В языке Турбо Паскаль реализовано несколько процедур, позволяющих управлять появлением текста на экране. Например, процедуры WriteLn и Write, выводящие информацию на дисплей; GotoXY, устанавливающая курсор в указанном месте; ClrScr, очищающая экран от текущей информации. Эффект от действия этих и других процедур (см. гл.15 «Модуль CRT») полностью проявляется в окне Output.

1.2. Окно просмотра переменных Watch

Это окно предназначено для отладка программ. В нем можно наблюдать изменение значений всех переменных при ее пошаговом выполнении. Окно Watch является важной частью отладчика Турбо Паскаля — инструмента для локализации и исправления ошибок в построении программы.

Для выбора переменных и выражений, которые необходимо наблюдать в окне Watch, можно пользоваться подменю Break/Watch основного меню. Для этого система устанавливается в один из режимов построкового выполнения (клавишей F7 или F8).

1.3. Структура меню

Главное меню Турбо Паскаля появляется в верхней строке экрана и содержит семь пунктов. Из окон Edit, Watch или Output можно активизировать меню, нажав клавишу F10. После этого используется два способа выбора пунктов из него:

1. Нажатие клавиши управления курсором (← и →) для перехода на следующий пункт я затем клавиши ввода для появления соответствующего вертикального подменю.

2. Нажатие клавиши с буквой, соответствующей выделенной букве нужного пункта: F,E,R,C,0,D или В.

Один из семи пунктов главного меню — Edit (редактирование текста) активизирует окно Edit и устанавливает мигающий курсор. После этого можно набирать текст программы. Другие пункты главного меню работают следующим образом: после выбора пункта под ним появляется подменю, в котором перечислены возможные команды или опции. Например, пункт File (работа с файлами) имеет подменю, показанное на рис. 1.4:

Рис. 1.4

Выбор пункта из подменю осуществляется аналогично выбору пункта из главного меню, однако клавиши управления курсором другие: стрелки вверх-вниз. Выбор также можно сделать, нажав соответствующую выделенной литере клавишу. Например, для выбора команды Load нужно нажать клавишу L.

Из уровня главного меню наиболее короткий путь к выполнению необходимой команды — последовательное нажатие двух клавиш с литерами, соответствующими нужным пунктам меню. Например, чтобы выполнить команду Quit, надо нажать последовательно клавиши F и Q. Эта команда выгрузит систему программирования из памяти. С другой стороны, можно использовать короткие команды, указанные в нижней строке экрана (для Quit — это Alt+X). Таким образом, Турбо Паскаль поддерживает два способа работы с системой: через меню и через короткие команды (функциональные клавиши и их комбинации с Alt и Ctrl).

- 14 -

1.3.1. Пункт File (работа с файлами)

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

1.3.1.1. Команда загрузки файла Load (F3). Эта команда задает чтение файла программы с диска и загрузку его в редактор системы. После того как файл попадает в редактор, его можно модифицировать, компилировать, запускать на выполнение. При выборе этой команды на экране появится изображение, показанное на рис. 1.5.

Рис. 1.5

Если известно имя файла, то нужно набрать его и, нажав клавишу ввода, загрузить в окно Edit. Имя файла может не содержать полный путь к нему, если этот файл находится в текущем каталоге. Можно также набирать имя файла без расширения — загрузчик сам добавит к нему по умолчанию расширение PAS. Если необходимый файл находится в другом каталоге, то нужно набрать полное его имя с маршрутом к нему, например:

Е:\TURBO55\PAS\TEST.PAS

Если же загрузчик не обнаружил файла с указанным именем, то система откроет новый файл с точно таким же названием.

Всегда можно воспользоваться и предложенным в окне групповым именем. В этом случае при нажатии клавиши ввода система покажет список файлов с расширением .PAS в текущем каталоге (рис. 1.6).

Рис. 1.6

- 15 -

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

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

1.3.1.2. Команда восстановления «истории» Pick (Alt+F3). Эта команда позволяет вернуться к работе с одним из файлов, который уже был загружен в редактор. Она показывает список из девяти файлов, отсортированных по порядку последних обращений к ним (рис. 1.7).

Рис. 1.7

Выбрав ее нажатием клавиши P (или Alt+F3 из основного меню), можно получить список, из которого выбирается файл для загрузки в редактор. Есть и другая возможность работы с Pick (правда, не такая полная): если находясь в редакторе, нажать комбинацию клавиш Alt+F6, то в него автоматически загрузится файл, с которым перед этим работали (т.е. верхний пункт в окне Pick). Этим обеспечивается подобие «двухоконности» редактора системы.

При выборе последней строки в этом списке (-load file-), выполняется команда Load. Обычно список Pick файлов теряется при выходе из системы. Однако его можно сохранить, записав на диск. Как это сделать, показано в описании пункта Options главного меню (разд. 1.3.5).

1.3.1.3. Команда открытия нового файла New. Эта команда удаляет текущий файл из редактора и устанавливает имя нового файла NONAME.PAS. Если текущий файл не был записан на диск после последней корректировки, то система выдаст запрос (рис. 1.8).

- 16 -

Рис. 1.8

Получив ответ «Y», система запишет текущий файл на диск, а получив ответ «N», система только удалит этот файл из редактора, и все изменения, внесенные в него, потеряются. Это очень важная альтернатива. Пользуясь ею, можно любым образом модифицировать программу и наблюдать, как она работает. А потом, ответив на запрос «N», оставить ее первоначальный вариант на диске неизменным.

1.3.1.4. Команда записи файла Save (F2). Эта команда записывает текущий файл из редактора на диск. В режиме редактирования ее можно выполнить, кроме обычного пути, нажатием клавиши F2. Система записывает файл с тем же именем, с которым он и был прочитан. Исключение составляет файл NONAME.PAS. Система предоставляет возможность его переименования, выдав сообщение (рис. 1.9).

Рис. 1.9

Если в ответ нажать клавишу ввода, то этот файл запишется с именем NONAME.PAS. Иначе, нужно набирать новое имя. При этом имя NONAME.PAS исчезнет. Если файл должен быть записан не в текущий каталог, то необходимо набрать его полное имя (можно без расширения — система сама его добавит).

При записи на диск уже существующего файла старая его версия переименовывается: вместо расширения .PAS она получает расши-

- 17 -

рение .ВАК. Это иногда бывает полезным — всегда имеется новая версия программы и предыдущая. Тем не менее существует возможность отключить такой режим записи (см. разд. 1.3.5).

1.3.1.5. Команда записи с новым именем Write To. Эта команда записывает файл, находящийся в окне Edit на диск, заменяя имя (и, возможно, каталог) этого файла. На экране появляется прямоугольник (рис. 1.10).

Рис. 1.10

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

1.3.1.6. Команда просмотра каталога Directory. Эта команда показывает содержимое текущего каталога. По умолчанию маской для выбора файлов является групповое имя *.*. Однако можно выбрать каталог и маску через окно запроса. Двигая прямоугольник выделения в окне списка содержимого каталога, можно открывать подкаталоги, если они есть, и свободно передвигаться по всей структуре диска. Если выбран какой-либо файл и нажата клавиша ввода, то этот файл будет прочитан и загружен в редактор. Фактически, эта команда может быть альтернативой команде Load при загрузке программ в систему.

1.3.1.7. Команда смены каталога Change Dir. Используя эту команду, можно сменить текущий каталог или диск. На экране появится окно для ввода имени нового каталога. После выполнения этой команды любые действия с файлами будут производиться по умолчанию в новом каталоге.

1.3.1.8. Команда временного выхода в MS-DOS — OS Shell. Эта команда позволяет работать в среде MS-DOS без выгрузки системы Турбо Паскаль. Выполнение этой команды влечет за собой очистку экрана и выдачу приглашения (PROMPT) MS-DOS. При этом происходит как бы выход из среды программирования в MS-DOS. После этого можно задавать любые команды MS-DOS: COPY,

- 18 -

RENAME, FORMAT и др., а также запускать любые программы, объем которых не превышает объема оставшейся памяти. Ограничения на размер возникают из-за того, что система Турбо Паскаль из памяти не выгружается (занимаемый ею объем составляет примерно 235К). Вернуться обратно в Edit можно, набрав в командной строке MS-DOS команду выхода EXIT. Все содержимое экрана DOS попадет при этом в окно Output.

Если какие-либо программы запускались в этом режиме, то прежде чем вернуться в Турбо Паскаль, необходимо убедиться, что они завершили свою работу. Особенно это касается вызовов в режиме OS Shell программ типа Norton Commander. Запуск резидентных программ в нем категорически противопоказан (это может сбить работу среды программирования).

1.3.1.9. Команда выхода из среды Quit. Эта команда позволяет выйти из системы (аналогичный результат получается, если нажата комбинация клавиш Alt+X). Команда производит выгрузку из памяти системы Турбо Паскаль. Чтобы войти обратно, надо запустить на выполнение в MS-DOS файл TURBO.EXE. Если в редакторе к моменту выхода остался незаписанный на диск файл, то система выдаст запрос (рис. 1.11).

Рис. 1.11

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

1.3.2. Пункт Edit (работа с редактором)

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

- 19 -

Line 1 Col 1 Insert Indent Tab Fill Unindent C:NONAME.PAS

Здесь:

Line и Col показывает текущее положение курсора в тексте (строка и колонка соответственно). Вначале курсор находится в левом верхнем углу текста (line 1, Col 1);

надпись Insert показывает, что установлен режим вставки при вводе символов. Если ее нет, то включен режим замещения (режимы переключаются клавишей Ins);

надпись Indent показывает, что включен (нажатием Ctrl+O I или Ctrl+Q I) режим автоматического отступа. При этом после нажатия клавиши ввода курсор установится в ту же колонку, с которой начиналась предыдущая строка;

надпись Tab говорит о том, что при нажатии клавиши TAB в текст будет вставлен символ табуляции (код ASCII 9). В противном случае будет вставлено заданное число пробелов (по умолчанию — 8); режим управляется комбинацией клавиш Ctrl+O T;

режим Fill (он управляется нажатием Ctrl+O F) задает оптимальную замену последовательностей пробелов символами табуляции при записи файла на диск;

если установлен режим Unindent (нажатием Ctrl+O U), то при нажатии клавиши удаления Backspace будут удалены все пробелы и знаки табуляции, отделяющие текущий символ от позиции начала предыдущей строки;

C:NONAME.PAS — имя текущего файла (т.е. файла, с которым производится работа).

Полный перечень команд редактора находится в Приложении 5. Сочетания клавиш типа Ctrl+O U должны набираться следующим образом: держа клавишу Ctrl нажатой, нажимают последовательно клавиши O и U.

Рассмотрим некоторые наиболее сложные группы команд.

1.3.2.1. Работа с блоками. Для обозначения начала блока надо поставить курсор на символ, являющийся первым в блоке и нажать Ctrl+K, а для обозначения конца блока (Ctrl+K K) курсор должен находиться непосредственно за его последним символом. Блок обычно выделяется цветом. После того как блок обозначен, его можно скопировать (командой Ctrl+K C) или перенести (Ctrl+K V) в позицию, заданную курсором. Удалить блок из текста можно командой Ctrl+K Y, а отменить выделение — командой Ctrl+K H (она же восстановит выделение вновь). При записи блока на диск (Ctrl+K W) Турбо Паскаль присоединяет автоматически к имени файла расширение .PAS. При чтении блока с диска (Ctrl+K R) Турбо Паскаль в запросе имени будет предлагать имя последнего записанного на диск блока.

- 20 -

1.3.2.2. Поиск и замена. При работе команд поиска строки в тексте (Ctrl+Q F) и поиска/замены (Ctrl+Q A) Турбо Паскаль в специальной строке запрашивает строку поиска (при поиске/замене еще и строку-замену), а затем режимы поиска, выдав запрос «Options:». Здесь можно ввести строку, содержащую любую комбинацию символов B,G,U,L,N,W и цифр. Они служат для задания режима работы этих команд:

символ B задает поиск назад, начиная от позиции курсора (обычно поиск производится вперед от текущей позиции курсора);

символ G задает режим глобального поиска, т.е. заданная строка ищется от начала файла до его конца. При завершении поиска, курсор устанавливается на последнее найденное определение. Сочетание символов B и G задает глобальный поиск от конца файла до его начала;

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

символ L задает поиск определения внутри обозначенного блока;

символ N (если указан) отменяет запросы подтверждения замены после нахождения заданной строки. Работает только в режиме поиска/замены;

символ W задает поиск отдельных слов, полностью совпадающих с определением (по умолчанию производится поиск любого сочетания, совпадающего с определением, даже если оно является частью другого слова);

цифра, указанная в запросе Options, указывает, на какой по счету найденной строке-определении приостановить поиск.

1.3.2.3. Расстановка маркеров. Маркеры — это специально помеченные командами Ctrl+K n (где n — цифровая клавиша — номер маркера в пределах от 1 до 5) позиции в тексте, в которые всегда можно быстро переместить курсор командой Ctrl+Q n.

1.3.2.4. Восстановление строки. После изменения содержания какой-либо строки текста можно восстановить его командой Ctrl+Q L, при условии, что курсор не покидал эту строку. После удаления редактируемой строки эта команда не работает.

1.3.3. Пункт Run (запуск на выполнение)

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

- 21 -

Рис. 1.12

комбинации функциональных клавиш. Это сделано для быстрого доступа к командам. Рассмотрим их подробнее.

1.3.3.1. Команда выполнения Run (Ctrl+F9). Эта команда инициализирует запуск текущей программы. Если программа еще не откомпилирована или после компиляции в нее были внесены изменения, то команда Run сначала компилирует ее. В конце работы программы окно Output заменяется экраном среды. Если требуется еще раз взглянуть на результат работы программы, то надо нажать комбинацию клавиш Alt+F5 (аналогичный результат дает команда User screen в этом же пункте меню). Если система находится в режиме отладки, то по команде Run программа будет далее выполняться в обычном режиме.

1.3.3.2. Команда прекращения отладки Program Reset (Ctrl+F2). После этой команды процесс отладки программы прекращается. При этом система не освобождает всю память, которую занимал код программы при отладке, поэтому точки останова и переменные просмотра (см. разд. 1.3.7.1) остаются.

1.3.3.3. Команда выполнения до курсора Go To Cursor (F4). С помощью этой команды можно запустить программу в работу. Ее выполнение будет происходить до тех пор, пока отладчик не достигнет строки, в которой находится курсор в окне Edit (при этом сама эта строка выполняться не будет). Таким образом, появляется возможность начинать отладку с любого места программы, например из процедуры, в которой предполагается ошибка.

Воспользоваться командой Go To Cursor можно в любой момент работы системы с редактором или отладчиком. При этом в режиме отладки программа выполнится без остановок (за исключением явно заданных точек останова) до курсора. В режиме редактирования по команде F4 будет произведена компиляция программы и ее запуск.

1.3.3.4. Команда детальной трассировки Trace Into (F7). Во время пошаговой отладки команда Trace Into задает выполнение текущей строки программы. Для того чтобы проследить за логикой выполнения программы или за изменением некоторых переменных при выполнении определенных строк, необходимо подавать эту

- 22 -

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

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

1.3.3.5. Команда выполнения по строкам Step Over (F8). Эта команда очень похожа по управлению и действиям на команду Trace Into, однако не совершает «заходов» в процедуры и функции, просто выполняет их как одну строку основной программы.

1.3.3.6. Команда просмотра результатов User Screen (Alt+F5). С помощью этой команды можно просматривать результат не только на текстовом экране, но и на графическом, что бывает очень полезно при работе с модулем Graph (см. гл. 19 «Модуль Graph»).

1.3.4. Пункт Compile (компиляция)

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

Рис. 1.13

Команды Compile, Make и Build — это три возможных пути для компиляции программ, состоящих из нескольких файлов. Дело в том, что результат работы команд Make и Build зависит от порядка внесения изменений в тексты программ, компилируемых совместно, а также от состояния опции Primary File в этом же меню. В связи с этим было бы полезно рассмотреть все команды пункта Compile подробно.

1.3.4.1. Команда компиляции Compile (Alt+F9). Эта команда инициализирует компиляцию и всегда обрабатывает текущий файл, находящийся в данный момент в окне Edit. При этом на экране

- 23 -

появляется окно информации о процессе (рис. 1.14). В нем показывается количество обработанных строк, объем доступной оперативной памяти и т.д.

Рис. 1.14

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

Success : Press any key

Успешно : Нажните любую клавишу

Если же была обнаружена ошибка, то Турбо Паскаль активизирует редактор и его курсор устанавливается в ту строку, в которой она была сделана. Расшифровку ошибки можно увидеть в верхней строке окна редактора. Заметим, что компилятор прекращает свою работу, как только обнаруживается ошибка. Исправив ее, можно обнаружить другую ошибку, расположенную ниже по тексту. Так можно проверить весь текст программы до конца, исправляя каждый раз ошибки. Детальное описание ошибки можно получить, нажав F1.

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

- 24 -

1.3.4.3. Команда общей компиляции Build. Команда Build производит компиляцию всех доступных системе текстов, составляющих программу, независимо от того, были ли они корректированы после компиляции или нет.

1.3.4.4. Опция назначения первого файла Primary file. Опция Primary file значительно упрощает работу с множеством файлов. Используя ее, можно указывать системе на главный файл в многофайловой программе. При этом любая команда компиляции будет обрабатывать именно этот файл, а не тот, что загружен в текущий момент в редактор. Файл, который ранее находился в редакторе, после компиляции восстановится в нем (правда, только в том случае, если не было ошибок).

Чтобы указать системе на первый файл, нужно выбирать пункт Compile главного меню, затем пункт Primary file. Турбо Паскаль покажет входное окно, указанное в описании команды Load (см. разд. 1.3.1.1). Выбор файла производится так же. После того как выбран файл, его имя будет все время появляться в окне информации о процессе, например:

Primary file (Первый файл): MAINPR.PAS

Теперь, если воспользоваться командами компиляции, то Турбо Паскаль сначала прочитает и загрузит в память Primary file, а затем начнет его компилировать.

Прежде чем закончить работу с одним программным проектом и приступить к другому, нужно удалить старое имя Primary file. Для этого выбирается в меню опция Primary file и нажимается клавиша пробела или комбинация клавиш Ctrl+Y. Имя Primary file при этом стирается из окна выбора файла.

1.3.4.5. Опция установки EXE- и TPU-файлов Destination. Эта опция используется для указания системе, куда должен быть помещен скомпилированный файл. В опции Destination определены две альтернативы: Memory и Disk (память и диск). По умолчанию коды компиляции сохраняются в памяти. Это очень удобно, так как можно производить изменения в программе и тут же видеть их результат. Ради такой работы, собственно, и была создана система Турбо Паскаль. Если же выбрана опция Disk, то выполняемые EXE-файлы и модули (TPU-файлы) всегда записываются на диск. Это необходимо для получения программы, которая может работать непосредственно под управлением MS-DOS.

1.3.4.6. Команда указания строки ошибки Find Error. Это важная команда для автономного компилятора. Тем не менее опишем ее здесь. Если во время выполнения программы по команде Run при включенном отладчике была обнаружена ошибка, то отладчик активизирует редактор, найдет строку, во время выполнения которой

- 25 -

произошла ошибка, установит туда курсор и выдаст в верхней строке окна Edit сообщение об ошибке (рис. 1.15).

Если же программа была запущена под управлением MS-DOS

Рис. 1.15

или из среды программирования при отключенном отладчике, то в случае ошибки ее выполнение прервется и на экране появится сообщение следующего вида:

Runtime error 200 at 20B0:8236

Ошибка выполнения 200 по адресу 20B0:8236

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

1) запомнить адрес, выданный в сообщении (лучше записать);

2) войти в систему Турбо Паскаль;

3) загрузить текст этой программы в редактор;

4) включить режим отладки (см. разд. 1.3.5.1);

5) откомпилировать программу (Alt+F9);

6) выбрать пункт Compile основного меню и в нем дать команду Find Error;

7) ввести запомненный (записанный) адрес в окна ввода адреса (рис. 1.16). После нажатия клавиши ввода в этом окне система быстро

Рис. 1.16

- 26 -

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

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

Рис. 1.17

1.3.5. Пункт Options (установка параметров системы)

Этот пункт позволяет управлять характеристиками компилятора и самой среды Турбо Паскаль. Меню Options содержит семь пунктов (рис. 1.18).

Рис. 1.18

Первые четыре опции — Compiler, Linker, Environment и Directories — имеют еще одно подменю, содержащее несколько директив. Остальные опции необходимы только в специальных ситуациях.

1.3.5.1. Установки компилятора Compiler. Меню, появляющееся при выборе этой команды, показано на рис. 1.19. Пункты в меню

- 27 -

Рис. 1.19

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

Выражение «директива компилятора» означает, что инструкции даются компилятору во время обработки текста программы. Подробно о ее синтаксисе рассказывается в разд. 3.3 «Комментарии и ключи компиляции» и разд. 3.4 «Условная компиляция программ».

Режим проверки диапазонов Range Checking. Когда компиляция программы происходит в режиме Range Checking On (включен), исполняемый код формируется так, что при выполнении программы происходит контроль:

1) выхода индекса массива за его границы;

2) переполнения переменных типа String;

3) переполнения разрядной сетки числовых переменных;

4) некорректная инициализация данных типа «объект».

Как только происходит нарушение, программа прекращает свою работу и генерируется ошибка выполнения (Runtime error).

По умолчанию режим Range Checking находится в состоянии Off (выключен). Однако при отладке программы очень полезно включить этот режим (On), так как это увеличит ее эффективность. После отладки рекомендуется восстановить состояние Off.

Режим проверки стека Stack Checking. Стек — это область памяти, в которой программы обычно сохраняют значения локальных переменных во время работы процедур или функций.

- 28 -

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

Размер стека в Турбо Паскале по умолчанию принимается равным 16K. Для изменения этого значения используется опция Memory Sizes рассматриваемого подменю настройки компилятора.

Режим проверки ввода-вывода I/O Checking. В этом режиме компилятором генерируются коды проверки ошибок ввода-вывода. По умолчанию он включен, и программа будет генерировать ошибку выполнения. Под ошибкой ввода-вывода подразумевается любое аварийное прерывание при обращении к любому периферийному устройству центрального процессора ПЭВМ (чтение-запись на дисках, печать на принтере, ввод с клавиатуры и т.д.).

Обнаружение такой ошибки, так же как и всех других, обычно прекращает выполнение всей программы. Однако Турбо Паскаль поддерживает специальные средства обработки ошибок ввода-вывода. Подробно они будут описаны в разд. 12.11 «Обработка ошибок ввода-вывода».

Режим генерации «дальних» вызовов Force Far Calls. Этот режим применяется в специальных приложениях программирования. «Дальний» вызов (длинный адрес, Far Call) — это полная адресация для части процедур и функций, размещаемых в разных сегментах памяти отдельно от основного программного сегмента. («Дальний» вызов содержит в себе, кроме относительного адреса сегмента, необходимого внутри 64-килобайтного блока, еще и базовый адрес внешнего сегмента.)

Обычное состояние режима Force Far Calls – Off. При этом компилятор генерирует только «ближние» (near) вызовы. Если же состояние – On, то дальние вызовы генерируются для всех процедур и функций программы. Например, дальние вызовы обязательны при генерации оверлейного кода (см. гл. 18 «Модуль Overlay»).

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

- 29 -

Чтобы получить модуль, который планируется использовать как оверлейный, необходимо включить этот режим. По умолчанию состояние Overlay Allowed — Off. Более подробно этот вопрос будет рассмотрен в гл. 18 «Модуль Overlay».

Опция установки единицы обработки данных Align Data. Эта опция управляет режимом доступа к данным в компьютерах на базе микропроцессоров семейства 80Х86. По умолчанию используется режим Word как наиболее эффективный. Рекомендуем использовать режим по умолчанию. Более подробно об этом см. Приложение 2.

Режим проверки строк-переменных Var-String Checking. Этот режим определяет, как точно компилятор будет проверять значения типа String, передаваемые в процедуры и функции. По умолчанию он имеет значение Strict (точно). При этом строковые переменные, которые передаются по ссылке, должны точно соответствовать типу формальных VAR-параметров, определенных в заголовке вызываемых процедур или функций. Если это не так, то генерируется ошибка выполнения. Если же этот режим имеет значение Relaxed (ослабленная), то длина строкового аргумента передается процедуре или функции без сравнения ее с длиной формального параметра.

Режим проведения логических операций Boolean Evolution. Этот режим определяет метод работы Турбо Паскаля с логическими выражениями, использующими операторы AND и OR. Он имеет два состояния. Первое по умолчанию — Short Circuit (короткие вычисления). При этом коды формируются по следующим правилам:

1. В выражении «a AND b», если «f=False», то значение b не вычисляется.

2. В выражении «a OR b», если «a=True», то значение b не вычисляется.

И наоборот, полное вычисление операндов в логических выражениях производится при втором состоянии — Complete (полностью).

Режим использования сопроцессора Numeric Processing. Язык Турбо Паскаль может генерировать коды, которые управляют работой сопроцессоров 8087 и 80287. Если такой микропроцессор установлен на применяемой ПЭВМ, то программы, использующие эти коды, будут работать быстрее, особенно если в них много математических расчетов, и могут использовать расширенный набор типов с плавающей точкой (см. разд. 9.5).

Режим Numeric Processing определяет, будет или нет использоваться расширенный набор типов данных. Если режим включен в состояние Software (программное исполнение), то нет; если же он — в состоянии 8087/80287, то да. По умолчанию режим Numeric Processing устанавливается в Software.

- 30 -

Режим генерации эмулирующих кодов Emulation. Этот режим работает только в том случае, если Numeric Processing установлен в 8087/80287. При этом можно включать в выполняемые коды эмуляцию или отключать ее. По умолчанию этот режим включен. В этом случае Турбо Паскаль проверяет наличие в ПЭВМ сопроцессора. Если он есть, то используются коды управления сопроцессором. Если же сопроцессора нет в ПЭВМ, то используются коды эмуляции и программа работает медленнее. В том случае, если режим Emulation выключен, a Numeric Processing — в состоянии 8087/80287, программа будет проверять наличие сопроцессора, и если его нет, то ее выполнение прекращается.

Режим генерации отладочной информации Debug Information. Этот режим включает генерацию отладочной информации, необходимой для работы встроенного отладчика. Если он включен (по умолчанию), то компилятор генерирует коды, необходимые для нормальной работы этого отладчика (при этом опция Integrated Debugging в меню пункта Debug должна быть так же установлена в состояние On). Кроме того, эта информация позволяет Турбо Паскалю определять строку, в которой произошла ошибка выполнения программы.

Если режим Debug Information установить в состояние Off, то нельзя будет определить, в какой строке произошла эта ошибка. Более того, нельзя воспользоваться командами из меню пункта Run — Trace into, Step over и Go To Cursor, а также невозможно воспользоваться точками останова, которые задаются в меню пункта Break/Watch.

Запись информации о локальных переменных Local Symbols. По этой опции компилятор определяет, надо ли генерировать информацию о константах и переменных, находящихся внутри процедур и функций программы. Когда опция установлена в состояние On (по умолчанию), компилятор позволяет производить проверку значений переменных внутри процедур и функций во время отладки. Если же опция установлена в состояние Off, то нельзя посмотреть значения переменных и констант в окне Watch. Заметим, что если режим Debug Information выключен, то установки в Local Symbols игнорируются.

Задание условных ключевых слов Conditional Defines. Язык Турбо Паскаль поддерживает условную компиляцию, при использовании которой можно включать или игнорировать как отдельные строки, так и целые блоки в программе. Этой возможностью можно управлять через специальную группу директив компилятора. Они представляют собой структуры IF/ELSE/ENDIF, которые и используются для выделения блоков строк, являющихся в этом случае субъектами условной компиляции.

- 31 -

Можно использовать пункт Conditional Defines для определения ключевого слова при использовании директив $IFDEF или $IFNDEF. Результат этих условных директив зависит от определения слова (см. разд. 3.4).

Определение размеров памяти Memory Sizes. С помощью этой опции можно задать потребные ресурсы памяти для работы программы. Подробно этот вопрос обсуждается в разд. 11.4 и 16.6 и в Приложении 2 (директива $M).

1.3.5.2. Опция Linker (компоновщик). При компиляции программы Турбо Паскаль автоматически компонует все процедуры и функции, которые составляют программу. При этом связываются между собой объектные коды программы и коды модулей-библиотек. Подменю опции Linker имеет два пункта, позволяющих регулировать этот процесс (рис. 1.20).

Рис. 1.20

Режим генерации таблицы распределения памяти Map File. Когда этот режим включен, а опция Destination пункта Compile принимает значение Disk, Турбо Паскаль генерирует на диске специальный текстовый файл, содержащий информацию об откомпилированной программе. Этот файл создается во время компиляции в EXE-файл и носит то же имя, но с другим расширением — .MAP. В этом файле содержится информация о переменных, процедурах и функциях, их адресах при выполнении, объеме занимаемой ими памяти и т.п. Степень детализации этой информации задается переключателем режимов: Off (выключено), Segments (по сегментам), Publics (все глобальные переменные), Detailed (детально). По умолчанию устанавливается Off.

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

- 32 -

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

Вот это и позволяет сделать опция Link Buffer. Как уже говорилось, по умолчанию Link Buffer находится в состоянии Memory. Поставив указатель на эту опцию и нажав клавишу ввода, можно сменить установку на Disk.

1.3.5.3. Опция установки условий работы среды Environment. При выборе этой опции на экране появляется меню, содержащее комбинацию ключей On/Off, входных параметров и одного подменю (рис. 1.21).

Рис. 1.21

Все они позволяют управлять «поведением» среды Турбо Паскаль.

Опция Config Auto Save. Эта опция задает автоматическую запись конфигурации. Если она включена (On), то на диске сохраняется конфигурация среды разработки на момент выхода из нее. При последующем входе в среду это состояние читается с диска и восстанавливается. Это позволит как бы не прерывать работы в среде. По умолчанию опция находится в состоянии Off.

Опция Edit Auto Save. Эта опция задаст автоматическую запись состояния редактора. Если она находится в состоянии On, то перед выполнением программы ее текст будет сохранен на диске. Это может спасти от потери программы при неисправимой ошибке выполнения (например, при зависании системы). Кроме того, программа будет сохраняться при выполнении команды OS Shell пункта File основного меню. По умолчанию опция находится в состоянии Off.

Опция Backup Files. Эта опция используется для задания резервирования файлов. Если она — в состоянии On, то при сохранении файла на диске система предыдущую его версию сохранит с тем же именем, но с расширением BAK. Таким образом, всегда на диске

- 33 -

имеются две последние версии программы. По умолчанию опция находится в состоянии On.

Опция Tab Size. С помощью этой опции можно изменить принятый по умолчанию шаг горизонтальной табуляции, равный восьми позициям. Если нажата клавиша ввода на этой опции, то на экране появится окно ввода, в котором можно указать число в диапазоне от 2 до 16 для установки нового шага табуляции.

Опция Zoom Windows. Эта опция используется для расширения окна. Она позволяет раздвигать окно на весь экран. Действительна только для окон Edit, Watch и Output. По умолчанию находится в состоянии Off. При этом на экране видны одновременно два окна Edit и Watch или Edit и Output.

Опция Screen Size. Эта опция позволяет максимально использовать возможности контроллера дисплея (см. гл.15 «Модуль CRT»), a также выбрать количество видимых текстовых строк на экране: 25 (для всех) и 43 (для EGA) или 50 (для VGA).

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

Рис. 1.22

Их можно изменять, выбрав соответствующий пункт меню. При этом в опциях Include, Unit и Object можно указать по нескольку каталогов, разделяя пути к ним точкой с запятой (как в команде

- 34 -

MS-DOS PATH). При этом Турбо Паскаль будет производить поиск необходимых файлов в текущем каталоге, затем, если они не найдены, осуществлять их поиск последовательно во всех каталогах, указанных для данного типа файла.

Приведем краткое описание каждого пункта опции Directories:

Turbo — указывает компилятору местонахождение системных файлов, в том числе файла конфигурации и Help-файла.

ЕХЕ & TPU — указывает компилятору, в каком каталоге создавать выполняемые коды программ, а также записывать TPU-файлы (модули), создаваемые при компиляции программ, имеющих заголовок UNIT.

Include — указывает компилятору, где искать файлы, определяемые директивой включения в тексте основной программы {$I ИмяФайла}.

Unit — если в программе использовались модули (они указываются директивой USES), то Турбо Паскаль при компиляции будет искать их в каталогах, указанных в этом пункте.

Object — указывает компилятору Турбо Паскаля, где искать OBJ-файлы для программ, использующих внешние ассемблерные процедуры и функции. (Они обычно объявляются в тексте директивой {$L ИмяФайла}.)

Pick file name — указывает имя файла, в котором сохраняется при выходе из среды Турбо Паскаля список последних девяти файлов, с которыми работал редактор (см. команду File/Pick). Имя этого файла по умолчанию принимается TURBO.PCK. Изменить его можно, выбрав курсором эту опцию и нажав клавишу ввода. После этого в окне ввода набирается имя нового файла. При входе в среду содержание этого файла читается системой из текущего каталога, и список Pick восстанавливает свое последнее состояние.

1.3.5.4. Опция установки командных параметров Parameters. Эта опция поможет в разработке и тестировании программ, использующих при запуске в командной строке дополнительные параметры. Для получения их программой в Турбо Паскале имеются специальные функции ParamStr и ParamCount. Если запускается EXE-программа, то она запрашивает параметры, которые вводятся с клавиатуры. А вот если программа запускается на выполнение из среды, то описываемая опция позволяет автоматически решить проблему этого ввода. Задав в окне ввода параметры один раз, можно тестировать программу много раз, не повторяя этой операции.

1.3.5.5. Команды управления файлами конфигурации Save/Retrieve Options. В них записываются все опции и установки, которые устанавливаются в пункте Options главного меню. При этом можно создавать столько файлов, сколько нужно для работы (обычно их число равно числу программных проектов, находящихся в работе или числу пользователей). Для этого используется команда Save Options. Каждый из этих файлов будет иметь расширение .TP (по умолчанию имя файла — TURBO.TP).

Если необходимо установить параметры системы, хранящиеся в созданном файле, то используется команда Retrieve Options.

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

Команда чтения состояния Retrieve options. Если системе задать выполнение этой команды, то на экране появится окно запроса имени с уже готовым шаблоном: *.ТР. Если нажать клавишу ввода, то на экране появится список доступных файлов конфигурации, находящихся в текущем каталоге. После этого выбирается нужный и нажимается клавиша ввода. При этом в системе все опции перейдут в состояние, указанное в этом файле.

Следующие два пункта главного меню Debug и Break/Watch содержат команды и опции, относящиеся к системе отладки среды программирования Турбо Паскаль.

1.3.6. Пункт Debug (установки отладчика)

В меню Debug представлено семь пунктов (рис. 1.23).

Рис. 1.23

- 36 -

Часть из этих пунктов управляет «поведением» компилятора, другие позволяют проводить определенные действия во время отладки. Два пункта работают при определенных обстоятельствах: пункт Call Stack используется только во время отладки, а пункт Find Procedure доступен только после того, как программа откомпилирована.

1.3.6.1. Оценка значений переменных Evaluate (Ctrl+F4). Во время отладки эта команда позволяет просмотреть значения переменных и выражений в программе, не обращаясь к окну Watch. При этом можно не только просмотреть значение переменной, но и задать новое, чтобы проследить, как изменится дальнейший ход программы.

После этой команды на экране появляется окно, содержащее три горизонтальных поля (рис. 1.24).

Рис. 1.24

В поле Evaluate вводится имя переменной или выражение, значение которого нужно посмотреть. Находясь в редакторе, можно подвести курсор к нужному имени переменной или к началу выражения в тексте и нажать Ctrl+F4. Если вслед за этим сразу нажать стрелку курсора вправо, то можно расширить взятую в окно Evaluate строку текста.

После нажатия клавиши ввода в поле Result появляется их текущее значение. Просмотр можно задавать в любом формате: десятичном, шестнадцатеричном, символьном и т.д. Делается это следующим образом: после имени переменной ставится запятая, а затем символ спецификации формата или их сочетание. Например, пусть объявлена константа

CONST

dec : Array [1..10] of Integer =

(10, 20, 30, 40, 50, 60, 70, 80, 90, 100);

Задав в окне Evaluate строку

Dec

- 37 -

в окне Result получим

(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)

а задав строку по-другому:

dec[2], 4H

в окне Result получим значения

$14, $1Е, $28, $32.

Такой формат результата получен, так как был задан показ четырех значений массива dec в шестнадцатеричном формате, начиная со второго элемента. Приведем таблицу символов спецификации и их функций (табл. 1.2).

После получения значения переменной в окне Result можно нажать два раза клавишу управления курсором «вниз» или клавиши TAB, в поле New — набрать новое ее значение, а затем продолжать проводить отладку командами Trace Into, Step Over или Go To Cursor.

Таблица 1.2

Спецификация формата

Функция

$

Шестнадцатеричное значение. Имеет такое же действие, как спецификатор формата H

C

Символ. Задает специальный символ для управляющих символов (значения кода ASCII от 0 до 31). По умолчанию такие символы выводятся их номерами в таблице кода ASCII в виде #xx. Влияет на все символы и строки

D

Десятичное значение. Все целые значения выводятся на экран в десятичном виде. Влияет на простые выражения целого типа, а также на структуры (массивы и записи), содержащие целые значения

H

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

- 38 -

R

Запись. Выводит на экран имена полей записи, например (x:1;y:10;z:5) вместо (1, 10, 5). Влияет только на переменные типа 'запись'

X

Шестнадцатеричное значение. Действует так же, как спецификатор формата H

Fn

Выражение с плавающей запятой, где n – это целое значение от 2 до 18, задающее число выводимых на экран значащих цифр; по умолчанию это значение равно 11. Влияет только на значения в формате с плавающей точкой

P

Указатель. Выводит указатели в формате 'сегмент:смещение', а не в принятом по умолчанию формате Ptr(seg,ofs). Например, на экран выводится 3ЕА0:0020 вместо Ptr($3EA0,$20). Влияет только на значения типа 'указатель'

S

Строки. Показывает управляющие символы кода ASCII (коды от 0 до 31) в виде значений кода ASCII. При этом используется синтаксис #хх. Поскольку этот формат принят по умолчанию, использовать спецификатор S полезно только в сочетании со спецификатором M

M

Память. Выводит на экран содержимое ячеек памяти переменной. Выражение должно представлять собой конструкцию, которую допускается использовать в левой части оператора присваивания (т.е. конструкцию, обозначающую адрес памяти). В противном случае спецификатор М игнорируется. По умолчанию каждый байт переменной показывается в виде двух шестнадцатеричных цифр. Добавление спецификатора формата D приводит к тому, что байты будут выводиться в десятичном представлении, а добавление спецификаторов H, $ и X задает вывод байтов в шестнадцатеричном виде с предшествующим символом $. Спецификаторы формата C или S приводят к тому, что переменная будет выводиться в виде строки (со специальными символами или без них). По умолчанию число выводимых байтов соответствует размеру переменной, но для точного задания числа выводимых байтов можно использовать счетчик повторения

- 39 -

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

2*5 или 12 DIV 8,

и в поле Result появится ответ: 10 или 1, соответственно.

1.3.6.2. Просмотр состояния стека Call Stack (Ctrl+F3). В любой момент отладки программы эта команда показывает список процедур и функций, получивших управление на данный момент. Например, в теле основной программы команда Call Stack показывает пустой список. С помощью этой команды можно узнать также, каким путем программа дошла до выполнения этой процедуры или функции, не пользуясь командами Step Over и Trace Into.

1.3.6.3. Команда нахождения процедуры Find Procedure. Эта команда является удобным средством для нахождения любой процедуры или функции в тексте программы. Работает она (только после того, как программа откомпилирована) следующим образом: выбор этой команды вызывает появление на экране окна ввода, озаглавленного «Enter subprogram symbol» (введите имя подпрограммы). Если в этом окне набрать имя процедуры или функции, то редактор немедленно покажет на экране ее начало.

Очень удобно использовать команду Find Procedure для проведения корректировки программы во внешнем файле (подключаемой к основной программе директивой {$I Имяфайла} или находящейся в составе модуля). Необходимый файл тут же загружается в редактор, и Турбо Паскаль показывает начало процедуры.

1.3.6.4. Опция установки отладчика Integrated Debugging. Эта опция имеет два состояния — On и Off (по умолчанию — On). В этом случае доступны абсолютно все возможности встроенного отладчика: можно устанавливать точки останова и проходить программу по строкам. Переключение опции в состояние Off отключает отладчик.

1.3.6.5. Генерация кода для автономного отладчика Stand-Alone Debugging. Эта опция имеет два состояния — On и Off (по умолчанию — Off). Ее включают в состояние On в том случае, если нужно воспользоваться внешним отладчиком Turbo Debugger, разработанным фирмой Borland International. Эта опция имеет смысл только при компиляции на диск. При этом Турбо Паскаль включает всю необходимую информацию прямо в ЕХЕ-файл.

Turbo Debugger может понадобиться, если разрабатывается какой-нибудь большой пакет программ, который не в состоянии рабо-

- 40 -

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

1.3.6.6. Опция режимов переключения экрана Display Swapping. Эта опция позволяет указывать среде программирования, как управлять во время отладки экраном, на котором отображается результат работы программы. Она имеет три состояния: None, Smart и Always. По умолчанию установлен Smart, т.е. Турбо Паскаль переключается на выходной экран только, когда необходимо выполнить оператор вывода на экран, а затем переключается обратно. Это очень удобно для большинства отладок. Если установлен режим Always, то система в любом случае переключает на короткое время экран после выполнения очередной строки. Если же установлен режим None, то выходной экран будет накладываться прямо на экран среды Турбо Паскаль. Это лучшее состояние опции, если программа не имеет вывода на экран. Если же все-таки вывод на экран есть, то картинка, представленная средой программирования, может быть разрушена. В связи с этим в пункт Debug включена еще одна команда.

1.3.6.7. Команда регенерации изображения Refresh Display. Эта команда восстанавливает экран среды программирования. Для исполнения этой команды набирается следующая последовательность клавиш: Alt+D и затем R. Другим способом правильное изображение восстановить невозможно.

1.3.7. Пункт Break/Watch (точки останова/обзор)

Этот пункт главного меню обеспечивает доступ к управлению двумя важнейшими возможностями отладчика: точками останова и просмотром переменных. На экране появляется меню (рис. 1.25).

Рис. 1.25

1.3.7.1. Добавление выражения Add Watch (Ctrl+F7). Эта команда используется для добавления новых имен переменных или выражений в окно Watch. На экране появляется окно Add Watch, в

- 41 -

которое нужно ввести имя переменной. Однако, если курсор редактора установить на нужное имя и дать команду Add Watch, то после нажатия клавиши ввода имя автоматически появится в этом окне. Затем нужно еще раз нажать клавишу ввода, после чего переменная появится в окне Watch.

Значение переменной постоянно отображается в окне Watch, и при использовании одного из пошаговых режимов отладки можно наблюдать за ее изменением непрерывно. Окно Watch может увеличиваться в высоту с каждым новым вводом до восьми строк. После этого можно листать это окно для просмотра переменных, находящихся за его пределами: для перехода из окна Edit в окно Watch нажимается клавиша F6. Затем, чтобы листать содержимое окна, используются клавиши управления курсором «вверх-вниз».

В это же время можно добавлять новые переменные и выражения в окно. Для этого нажимается клавиша Ins, и на экране появится окно Add Watch. Дальнейшие действия уже известны. Все сказанное о формате переменных в команде Evaluate относится и к окну Watch.

1.3.7.2. Удаление выражения из окна просмотра Delete Watch. Эта команда удаляет текущее выражение из окна Watch. Обычно текущим выражением является то, которое первым вводится в это окно. Оно маркировано точкой, расположенной перед выражением в окне.

Текущее выражение можно менять, перейдя в окно Watch и используя клавиши управления курсором для перемещения выделяющей строки по строкам. То выражение, на котором находится эта строка, и является текущим. Внутри окна Watch удаление выражений происходит после нажатия клавиши Del.

Удаление всех выражений одновременно из окна Watch производится выбором команды Remove all watches.

1.3.7.3. Редактирование выражения Edit Watch. Эта команда показывает текущее выражение Watch в окне Edit Watch. В нем можно редактировать выражение в любой момент. Нажав клавишу ввода можно «узаконить» это изменение, а нажав клавишу Esc отменить команду.

Внутри окна Watch эта команда вызывается следующим образом: выделяющая строка устанавливается на нужное выражение и нажимается клавиша ввода. Выделенное выражение появится в окне Edit Watch.

1.3.7.4. Включение и выключение точек останова Toggle Breakpoint (Ctrl+FS). Эта команда определяет текущую строку программы, находящейся в окне Edit, как точку останова, т.е. точку, в которой выполнение программы будет приостановлено. Чтобы пра-

- 42 -

вильно определить для системы точку останова, нужно установить курсор в строку, на которой выполнение программы должно приостановиться, затем нажать комбинацию клавиш Alt+D и T (или просто комбинацию клавиш Ctrl+F8). Турбо Паскаль при этом выделит эту строку ярким фоном (обычно красного цвета).

Эта же команда используется для исключения точки останова. Последовательность действий при этом такая же.

1.3.7.5. Выключение всех точек останова Clear All Breakpoints. Эта команда снимает все точки останова, установленные до этого.

1.3.7.6. Команда View Next Breakpoint. По этой команде редактор листает программу до следующей точки останова в тексте без ее выполнения. Если точка находится во внешнем файле, то Турбо Паскаль загружает этот файл в редактор так, чтобы в окне Edit появилась строка точки останова. После того как будет достигнута последняя точка, следующая команда View Next Breakpoint покажет в окне Edit первую точку останова.

1.4. Интерактивная справка

В интегрированной среде Турбо Паскаль встроена система краткой справки. С ее помощью можно вывести на экран краткое описание опций, которые появляются в меню. Чтобы получить пояснение к опции, достаточно установить выделяющий курсор в меню на нее и нажать клавишу F1. Турбо Паскаль автоматически открывает текстовое окно на экране, в котором содержится краткое описание выбранной опции. Например, на рисунке 1.26 показана справка по команде Run пункта Run главного меню.

Рис. 1.26

- 43 -

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

Более того, если это описание процедуры или функции языка Турбо Паскаль, то будут показаны примеры их использования. Можно легко воспользоваться этими примерами, не набирая их в редакторе. При нажатии клавиши C активизируется курсор в окне справки. Подведя его к началу нужного фрагмента примера, следует нажать клавишу B. Таким образом, начинается выделение блока. После увеличения его до необходимых размеров курсором нужно нажать клавишу ввода, и фрагмент примера, находящийся в блоке, будет скопирован в текущую позицию курсора редактора. Эта уникальная возможность позволяет увидеть, как создатели языка Турбо Паскаль представляют правильное использование процедур и функций. Пользуйтесь этим!

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

Среди всех достоинств этой справочной системы есть еще и такая: она помнит множество всех справочных окон, которые были вызваны и может их показывать в обратном порядке при нажатии комбинации клавиш Alt+F1.

Заметим, что в отличие от версии 5.0 в системе Турбо Паскаль версии 5.5 реализована автономная система интерактивной справки THELP. Это резидентная утилита, позволяющая писать программы на языке Турбо Паскаль в любом редакторе текстов. Активизация справочной системы производится нажатием клавиши 5 на цифровой клавиатуре ПЭВМ. Она предоставляет все возможности краткой

- 44 -

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

Таблица 1.3

Ключ

Действие по ключу

Клавиши управления курсором

Перемещение указателя по определениям справочника управления курсором

PgUp/PgDn

Листание страниц текущего определения справочника

Enter

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

Esc

Конец сеанса работы со справочником

F1

Показ сводки общих определений системы Турбо Паскаль

Alt+F1

Показ в обратном порядке последних 20 страниц справки

Ctrl+F1

Справка по ключам работы THELP

F

Выбор нового файла справки .HLP. Если этого файла нет или он имеет неправильный формат, то THELP выдаст двойной звуковой сигнал

J

Переход на новую страницу справочника (максимально 9999)

K

Выбор нового определения в справочнике

I

Включение ключевого слова в текст под курсором

P

Включение текущей страницы справочника в текст под курсором

S

Запись текущей страницы справочника в файл на диске

При работе эта утилита занимает в ОЗУ 8,2К.

- 45 -

Глава 2. Настройка системы

2.1. Система настройки среды программирования

В состав вспомогательных утилит Турбо Паскаля входит еще одна, о которой не упоминалось во введении, — это TINST.EXE. Ее задача — настройка всех элементов интегрированной среды: опции компилятора, размера экрана, команд редактора, распределения цветов в среде, рабочих директорий и т.д. Эта утилита изменяет информацию непосредственно внутри файла TURBO.EXE.

После запуска на выполнение этой утилиты на экране появится меню (рис. 2.1).

Рис. 2.1

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

Editor Commands — устанавливает соответствие между комбинациями клавиш и выполняемыми действиями редактора;

Mode for display — настраивает видеорежимы интегрированной среды. Поскольку адаптер дисплея в ПЭВМ меняется реже, чем программное обеспечение, то если система уже работает на нем, изменять опции в этом меню не рекомендуется;

- 46 -

Set Colors — настраивает цвета на экране в наиболее подходящей гамме;

Resize windows — изменяет соотношение размеров окон Edit и Output /Watch;

Quit/Save — записывает все изменения, внесенные описываемой утилитой непосредственно в файл TURBO.EXE и заканчивает ее работу.

В пункте Option есть некоторые добавления, существенные с точки зрения использования памяти при работе интегрированной среды:

1. В пункте меню Environment, который устанавливает режимы сохранения файлов и конфигурации, добавлена опция Full Graphics Save. Если она находится в состоянии Off, то для работы системы освобождается 8K памяти, которые по умолчанию (On) используются как буфер для сохранения графического экрана. Значение опции Off оптимально, если не пользоваться графическими режимами адаптера дисплея.

2. Там же есть опция Editor Buffer Size, которая устанавливает размер буфера для редактора. По умолчанию его размер 64K, однако его можно уменьшать вплоть до 20000 байт. Таким образом, если планируется работать с небольшими текстами, можно «сэкономить» 45534 байт для компилятора. Примерный объем, занимаемый текстом программы, можно вычислить исходя из соображений, что полный экран монитора (в режиме 80х25) занимает 2000 байт, а степень его заполнения при написании программ на Паскале равна примерно 30%. Таким образом, программа длиной в 25 строк будет занимать примерно 700 байт.

3. Следующая опция Make use of EMS Memory (по умолчанию — On) задает редактору использование в качестве буфера блока 64К расширяемой памяти (стандарта EMS). При загрузке среда Турбо Паскаль проверяет наличие расширяемой памяти стандарта EMS и соответствующего драйвера в MS-DOS и, если они есть, организует в EMS-памяти буфер редактора. В противном случае этот буфер будет организован в основной памяти.

При помощи команды Editor Commands главного меню можно произвести перенастройку клавиш управления редактором. Однако авторам в процессе длительной работы с пакетом Турбо Паскаль воспользоваться ею так и не пришлось, так как эти клавиши в основном совпадают с комбинациями во многих известных редак-

- 47 -

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

Как и предыдущая, команда Set Colors дает полную свободу в выборе цветовой гаммы, в которой будет представлено рабочее поле интегрированной среды. Имеются четыре альтернативы:

— раздельное задание цвета для каждого определения среды фона экрана, цвета текста, цвета меню, цвета окон запросов и т.д. Рекомендуется использовать зеленые (Green) буквы на черном (Black) фоне для текста и коричневое поле для строки меню и подсказки. При длительной работе на ПЭВМ эти цвета наименее утомительны для зрения;

— выбор цветовой гаммы по умолчанию;

— выбор альтернативной цветовой гаммы по умолчанию;

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

2.2. Принятые в системе расширения имен файлов

Система Турбо Паскаль воспринимает все виды расширений в именах файлов, используемых в среде MS-DOS. Они обычно зависят от области применения или от вида программы. Турбо Паскаль по умолчанию использует несколько выделенных расширений для имен файлов:

TPU — файл модуля, содержащий подобие объектного кода модуля и (необязательно) отладочную информацию.

TPL — файл библиотек Турбо Паскаля. Стандартный набор модулей языка находится в файле TURBO.TPL. Этот файл можно модифицировать с помощью утилиты TPUMOVER.EXE (см. Приложение 4).

TP и CFG — файлы конфигурации для TURBO.EXE и TPC.EXE. Эти файлы позволяют сохранить значения различных опций, установленных для компиляторов. Файлы с расширением .TP могут иметь различные имена, но файл TPC.CFG (см. Приложение 3) в текущем каталоге может быть только один.

PCK — расширение файла истории работ Турбо Паскаля. Этот файл указателя содержит информацию о состоянии редактора, и поэтому после перерыва в сеансе работы с системой редактор восстановит свое последнее состояние.

- 48 -

PAS — стандартное расширение для файлов, содержащих исходный текст на Паскале.

BAK — расширение резервной копии исходного файла. Редактор интегрированной среды программирования всегда переименовывает существующий файл на диске в файл резервной копии, если на диск записывается измененная копия этого файла. Система позволяет установить или отменить генерацию файлов с расширением .BAK.

EXE — выполняемый файл, построенный компилятором.

MAP — расширение справочного файла, генерируемого системой, если опция Options/Compiler/Map File установлена в значение On.

HLP — файл с упакованными текстами для справочной системы (TURBO.HLP)

- 49 -

Часть II. Язык Турбо Паскаль

Глава 3. Построение программ

В этой главе рассмотрены алфавит и ключевые слова языка, правила написания идентификаторов, а также особенности построение программ на Турбо Паскале и его отличия от стандартного Паскаля. Здесь же приведены правила условной компиляции программ.

3.1. Алфавит языка и зарезервированные слова

Как и любой другой язык программирования, Турбо Паскаль имеет свой алфавит — набор символов, разрешенных к использованию и воспринимаемых компилятором. В алфавит языка входят:

1. Латинские строчные и прописные буквы:

A, B,..., Z и a, b,..., z

2. Цифры от 0 до 9.

3. Символ подчеркивания «_» (код ASCII номер 95). Из этих символов (и только из них!) конструируются идентификаторы — имена типов, переменных, констант, процедур, функций и модулей, а также меток переходов. Имя может состоять из любого числа перечисленных выше символов, но должно начинаться с буквы, например:

X CharVar My_Int_Var C_Dd16_32m

Прописные и строчные буквы не различаются: идентификаторы FILENAME и filename — это одно и тоже. Длина имен формально не ограничена, но различаются в них «лишь» первые 63 символа (остальные игнорируются).

4. Символ «пробел» (код 32). Пробел является разделителем в языке. Если между двумя буквами имени или ключевого слова стоит пробел, то две буквы будут считаться принадлежащими разным именам (словам). Пробелы отделяют

- 50 -

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

C:=2+2; и C := 2 + 2 ;

для компилятора эквивалентны.

5. Символы с кодами ASCII от 0 до 31 (управляющие коды). Они могут участвовать в написании значений символьных и строчных констант. Некоторые из них (7, 10, 13, 8, 26) имеют специальный смысл при проведении ряда операций с ними. Символы, замыкающие строку (коды 13 и 10), и символ табуляции (код 9) также могут быть разделителями:

C := 2+2;

эквивалентно построению

C := 2

+

2;

6. Специальные символы, участвующие в построении конструкций языка:

+ - * / = < > [ ] . , ( ) : ;^ @ { } $ # '

7. Составные символы, воспринимаемые как один символ:

<= >= := (* *) (. .) ..

Разделители (пробелы) между элементами составных символов недопустимы.

Как видно, символы из расширенного кода ASCII, т.е. символы с номерами от 128 до 255 (а именно в этот диапазон входит алфавит кириллицы на IBM-совместимых ПЭВМ), а также некоторые другие из основного набора клавиатуры ( !, %, и др.) не входят в алфавит языка. Тем не менее они могут использоваться в тексте программы, но только в виде значений констант символов и (или) строк, а также в тексте комментариев. В имена (идентификаторы) эти символы входить не могут. Обычно это не вызывает проблем. Главное, что можно выводить знаки кириллицы и псевдографики на экран и принимать их с клавиатуры.

Турбо Паскаль имеет большое количество зарезервированных (или ключевых) слов. Эти слова не могут быть использованы в качестве имен (идентификаторов) в программе. Попытка нарушить

- 51 -

этот запрет вызовет ошибку при обработке программы компилятором языка. Список зарезервированных слов Турбо Паскаля таков:

ABSOLUTE AND ARRAY BEGIN CASE CONST CONSTRUCTOR DESTRUCTOR DIV DO DOWNTO ELSE END

EXTERNAL FILE FOR FORWARD FUNCTION GOTO IF IMPLEMENTATION IN INLINE INTERFACE INTERRUPT LABEL

MOD NIL NOT OBJECT OF OR PACKED PROCEDURE PROGRAM RECORD REPEAT SET SHL

SHR STRING THEN TO TYPE UNIT UNTIL USES VAR VIRTUAL WHILE WITH XOR

Примечание: Зарезервированное слово PACKED (упакованный) в Турбо Паскале игнорируется.

3.2. Общая структура программ

Самая короткая программа на Турбо Паскале выглядит следующим образом:

| BEGIN

| END.

Более длинные программы обрастают различными смысловыми блоками: описаниями меток переходов, константами, объявлениями типов и переменных, затем процедурами и функциями. Порядок размещения их в тексте программы для Турбо Паскаля может быть таким же жестким, что и для стандартного Паскаля. Написанная по правилам стандарта языка программа будет иметь в своем полном варианте структуру, показанную на рис. 3.1.

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

PROGRAM Имя ( input, output, ... )

здесь не является необходимой.

- 52 -

| PROGRAM Имя_программы;

| USES

| Список используемых библиотек (модулей);

| LABEL

| Список меток в основном блоке программы;

| CONST

| Определение констант программы;

| TYPE

| Описание типов;

| VAR

| Определене глобальных переменных программы;

| ОПРЕДЕЛЕНИЕ ПРОЦЕДУР (заголовки и, возможно, тела процедур);

| ОПРЕДЕЛЕНИЕ ФУНКЦИЙ (заголовки и, возможно, тела функций);

| BEGIN

| Основной блок программы

| END.

Рис. 3.1

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

USES

CRT, DOS, Graph;

{ подключены три библиотеки с соответствующими именами }

Если библиотеки не используются, то директива USES не ставится.

Блок описания меток LABEL содержит перечисленные через запятую метки переходов, установленные в основном блоке программы. Блоков LABEL может быть сколько угодно (лишь бы метки не повторялись), и стоять они могут где угодно до начала основного блока. Метки могут обозначаться целым числом в диапазоне 0...9999 или символьными конструкциями длиной не более 63 букв, например:

- 53 -

LABEL

Loop, 1, 123, m1, m2, Stop;

{описываем шесть различных меток }

Если метки не используются, то блоки LABEL отсутствуют.

Блок объявления констант CONST так же, как блок LABEL может располагаться в любом месте программы. Таких блоков может быть несколько или может не быть вообще. В них размещаются определения констант различных видов.

Необязательный, как и все предыдущие, блок описания типов TYPE содержит определения вводимых программистом новых типов, в том числе для описания типов «объект». В этом блоке могут быть использованы константы из блока CONST. Если это так, то блок TYPE может быть расположен где угодно, но не выше соответствующего блока CONST. Если же описания типов ни с чем не связаны, то они могут быть помещены в любом месте между другими блоками, но выше того места, где будут использованы.

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

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

Основной блок — это собственно программа, использующая все, что было описано и объявлено. Он обязательно начинается словом BEGIN и заканчивается END с точкой. После основного блока, вернее после завершающей его точки, любой текст игнорируется. Поэтому основной блок всегда замыкает программу.

Язык Турбо Паскаль предоставляет гораздо большую гибкость в организации текста программы, чем стандарт языка: структура программы на рис. 3.2 более читаема и удобна, чем жесткая последовательность блоков на рис. 3.1.

Существуют, однако, ограничения на перемещения блоков в программе. Программа компилируется последовательно, и все что в

- 54 -

| PROGRAM Сложная_программа;

| USES

| Подключаемые библиотеки (модули);

| CONST Константы и переменные для

| VAR выполнения математических расчетов

| Определения процедур и функций

| математических расчетов

| CONST Константы, типы и переменные,

| TYPE нужные для графического представления

| VAR результатов расчетов

| Определения процедур и функций

| построения графиков

| LABEL Метки, константы и переменные,

| CONST используемые только в основном

| VAR блоке программы

| BEGIN

| Основной блок программы

| END.

Рис. 3.2

ней вводится, должно быть объявлено, до того как будет использовано. Так, переменные из самого нижнего блока VAR (см. рис. 3.2) будут недоступны в определяемых выше процедурах. Попытка использовать их в процедурах вызовет ошибку и остановку компиляции. Исправить такую ошибку просто: надо перенести нужные переменные в блок VAR перед процедурами.

Компилятор Турбо Паскаля накладывает некоторые ограничения на текст программ. Так, длина строки не может превысить 126 символов, а объем файла программы (текста) — 64K (максимально).

3.3. Комментарии и ключи компиляции

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

{ текст комментария }

или в круглые скобки со знаком умножения (звездочкой):

(* текст комментария *)

- 55 -

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

{ пример пересечения (* комментариев } — так нельзя *),

но могут быть вложенными. При этом внешний и внутренний комментарии должны быть заключены в разные скобки:

(* внешний охватывает { внутренний } комментарий *)

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

{

много

строк

комментариев

}

Турбо Паскаль позволяет программе (тексту) управлять режимом компиляции: включать или выключать контроль ошибок, использовать или эмулировать математический сопроцессор, изменять распределение памяти и др. Для изменения режима используются ключи компиляции: специальные комментарии, содержащие символ «$» и букву-ключ с последующим знаком «+» (включить режим) или «-» (выключить). Например:

{$R-} отключить проверку диапазонов индексов массивов;

{$N+} использовать сопроцессор 80Х87 и т.д.

Список ключей компиляции приведен в Приложении 2. Можно объединять ключи в один комментарий:

{$N+,R-}

Открывающие скобки, символ «$» и ключ должны быть написаны без пробелов между ними. Подобные конструкции можно вставлять в программу, и при компиляции она сама будет задавать режим работы компилятора. Ключи подразделяются на глобальные (раз установленный режим уже не может измениться) или локальные (можно изменять режимы для разных частей программы). Глобальные ключи должны стоять в начале программы, а локальные — где угодно программисту. Стартовые значения ключей (значения по умолчанию) задаются в среде программирования посредством меню Options/Compiler.

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

{$I ИмяФайлаВключения}

- 56 -

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

{$I incproc.pas}, или, что то же самое,

{$I incproc},

{$I c:\pascal\pas\graf.inc},

{$I ..\USER\Block1.blk}

Текст включаемого блока должен удовлетворять двум условиям: будучи подставленным на место соответствующей команды {$I...}, он обязан вписаться в структуру и смысл программы без ошибок и должен содержать законченный смысловой фрагмент. Последнее означает, что блок от BEGIN до END (например, тело процедуры) должен храниться целиком в одном файле.

Включаемые тексты сами могут содержать команды {$I...}, вставляющие как бы уже дважды вложенные тексты, а те, в свою очередь, тоже могут содержать директивы {$I...}. Максимальный уровень подобной вложенности равен восьми.

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

{$L code.obj}

или, что то же самое,

{$L code} {$L c:\pascal\obj\grafproc.obj}

Обычно после директивы {$L...} в тексте программы сразу ставятся описания внешних процедур и функций, реализованных в подключенном коде.

К той же серии компонующих структуру программы ключей можно отнести команду объявления оверлейных (перекрывающихся) наборов процедур и функций:

- 57 -

{$O ИмяОверлейногоМодуляНаДиске}

Подробную информацию об оверлейных структурах смотрите в гл. 18 «Модуль Overlay».

3.4. Условная компиляция программ

Принципы условной компиляции тесно связаны с построением программ на Турбо Паскале. Разрешая группировать блоки VAR, TYPE и прочие по функциональным признакам и размещать их в различных местах программы, Турбо Паскаль предоставляет еще и средства управления порядком компиляции (не путать с режимами!). Любой, кто отлаживал свои программы, знает, как исключить из работы фрагмент текста: надо оформить его как комментарий или обойти оператором перехода типа GOTO. Но все это нарушает исходный текст. Турбо Паскаль вводит особый набор ключей компиляции для решения подобных вопросов. Их немного:

{$DEFINE КлючевоеСлово } задание ключевого слова,

{$UNDEF КлючевоеСлово } сброс ключевого слова,

{$IFDEF КлючевоеСлово } проверка задания слова,

{$IFNDEF КлючевоеСлово } проверка отсутствия задания ключевого слова,

{$IFOPT КлючИзнак } проверка режима компиляции,

{$ELSE) альтернативная ветвь,

{$ENDIF) обязательный конец условия.

Ключ $DEFINE определяет (задает) условное ключевое слово, которое становится активным и известным компилятору и по которому будут срабатывать другие ключи: $IFDEF — проверка условия активности этого слова и $IFNDEF — проверка отсутствия его задания (рис. 3.3).

| { $DEFINE variant0 }

| BEGIN

| {$IFDEF variant0 }

| WriteLn ( 'Вариант программы номер 0' );

| {$ENDIF)

| {$IFNDEF variant0 }

| WriteLn ( 'Ненулевая версия программы' );

| {$ENDIF}

| END.

Рис. 3.3

- 58 -

Если в тексте программы определено ключевое слово (здесь variant0), то будет откомпилирован блок, зависящий от активности этого слова, т.е. заключенный между ключами {$IFDEF variant0} и {$ENDIF}. Альтернативный вариант блока будет компилироваться только, когда ключевое слово variant0 неопределено (пассивно). На это указывают обрамляющие его ключи {$IFNDEF variant0}...{$ENDIF}. Но если, например, изменить в тексте ключа $DEFINE слово variant0 на variant1 и заново откомпилировать программу, то все получится наоборот: будет пропущен первый блок (его слово не определено), но откомпилирован второй (условие отсутствия слова выполняется).

Можно заметить, что обязательная директива {$ENDIF} всегда замыкает блок, начатый ключом {$IF...}. Пример на рис. 3.3 можно без ущерба для смысла переписать в ином виде (рис. 3.4).

| { SDEFINE variant0}

| BEGIN

| {$IFDEF variant0 }

| WriteLn ( 'Вариант программы номер 0');

| {$ELSE}

| WriteLn ('Ненулевая версия программы');

| {$ENDIF}

| END.

Рис. 3.4

Здесь задействован ключ {$ELSE}, направляющий ход компиляции в альтернативное русло, если не выполняется условие предшествующего ключа {$IF...}. Для такого сложного условия ключ конца все равно будет один.

Блоки, компилируемые условно, могут содержать любое число операторов. Части программы, находящиеся вне блоков условной компиляции {$IF...}...{$ENDIF}, никак не зависят от ключевых слов. Само ключевое слово может содержать сколько угодно символов (только латинских и цифр), хотя распознаются только первые 63 из них. Ключевые слова имеют смысл только в ключах-командах условной компиляции и никак не перекликаются с идентификаторами самой программы.

Однажды объявленное ключевое слово можно отменить по ходу процесса компиляции (перевести из активного состояния в пассивное) ключом

- 59 -

{$UNDEF КлючевоеСлово}

После такой строки в тексте слово считается не заданным.

До сих пор речь шла о вводимых программистом ключевых словах. Кроме них, всегда определены три слова:

VER55 — ключевое слово версии компилятора (языка); для версий 5.0 и 4.0 оно было другим — VER50 и VER40 соответственно;

MSDOS — ключевое слово типа ОС; в MS-DOS, PC-DOS или их аналогах это слово именно такое;

CPU86 — ключевое слово семейства центрального процессора; если он не из семейства 80X86, то это слово будет другим.

К этому списку слов может быть добавлено еще одно, если компилятор обнаружил наличие математического сопроцессора 80X87:

CPU87 — ключевое слово, определенное, если в ПЭВМ имеется математический сопроцессор.

Ключевое слово сопроцессора позволяет установить порядок компиляции в зависимости от комплектации ПЭВМ:

{$IFDEF CPU87 -

{$N+ включаем режим использования сопроцессора }

TYPE

объявляем типы с повышенной точностью;

{$ELSE}

{$N- не используем возможности сопроцессора }

TYPE

объявляем типы с обычной точностью:

{$ENDIF}

В списке ключей условной компиляции был еще один ключ {$IFOPT}. Принцип его работы такой же, как и ключа {$IFDEF}. Отличие состоит лишь в условии срабатывания. Здесь им является состояние какого-либо ключа режима компиляции. Например, если программа компилируется в режиме {$N+}, заданном в тексте или умолчанием, то условие {$IFOPT N+} — истинно, a {$IFOPT N-} — ложно.

Теперь есть возможность управлять ходом компиляции, опираясь на состояние различных режимов. Ключ {$IFOPT} может иметь альтернативную ветвь {$ELSE} и по-прежнему обязан иметь закрывающую блок условной компиляции директиву {$ENDIF}.

Напомним, что все ключи условной компиляции имеют смысл только в процессе компиляции программ и не принимают участия в выполнении их.

- 60 -

Глава 4. Введение в систему типов языка

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

Объявление новых типов в программе на Паскале происходит в блоке описания типов TYPE. Алгоритм объявления нового типа прост: ставится ключевое слово TYPE, и за ним следует перечисление новых имен типов, которые будут введены, и конструкций из уже известных или ранее введенных типов, непосредственно определяющих новый тип. Схематично это выглядит так:

TYPE

НовыйТип1 = Массив целых чисел;

НовыйТип2 = Множество символов;

...

НовыйТип101 = Целое число;

НовыйТип102 = Перечисленные здесь значения;

В реальной программе, конечно, слева должны стоять имена — названия новых типов (идентификаторы введенных типов), а справа — определяющие тип зарезервированные слова и имена образующих типов. Между именем и его определением обязателен знак равенства «=» (не путать со знаком присваивания «:=»). Также обязательна точка с запятой «;» после завершения определения каждого нового типа. Концом блока описания типов считается начало любого другого блока (например, VAR, CONST, BEGIN) или описание заголовков процедур и (или) функций.

Какие же возможные типы данных и способы их развития предоставляет Турбо Паскаль? Система типов Турбо Паскаля значительно шире, чем в стандартном Паскале. В первую очередь, это обусловливается большим количеством базовых (простых) типов языка. Так, одних только целочисленных типов вводится пять (с математическим сопроцессором — все шесть)!

Основной (стандартный) набор простых, т.е. определяющих тип только одного отдельного значения, типов таков:

- 61 -

1. Числовые типы:

короткое целое без знака — Byte (0..255);

короткое целое со знаком — ShortInt (-128..127);

целое без знака — Word (0..65535);

целое со знаком — Integer (-32768..32767);

длинное целое со знаком — LongInt (-2147483648..2147483647);

вещественное — Real (точность 11-12 знаков после запятой).

2. Логический тип — Boolean.

3. Символьный тип — Char.

4. Строковый тип — String, String[n].

5. Адресный тип (указатель) — Pointer.

6. Перечислимый тип.

7. Ограниченный тип (диапазон).

Все эти типы могут участвовать в определении сложных типов. Обращаем внимание на отсутствие типа ALPHA, встречающегося во многих реализациях Паскаля. Здесь его заменяет более универсальный и гибкий тип String. Список числовых типов может быть расширен за счет использования математического сопроцессора. Подробно они будут рассмотрены в гл. 9 «Математические возможности Турбо Паскаля».

Набор сложных типов, определяющих структуры из простых типов весьма широк:

1) массив — Array ... of ...;

2) множество — Set of ...;

3) файлы (3 вида) — Text, File, File of ... ;

4) запись — RECORD;

5) объект — OBJECT;

6) ссылка — ^БазовыйТип.

Кроме того, Турбо Паскаль вводит особый тип, называемый процедурным. Он не имеет отношения к данным и используется для организации работы процедур и функций. Файлы в системе типов Турбо Паскаля могут быть трех различных типов: текстовые (Text), обобщенные или бестиповые (File), и компонентные или типизированные (File of ...). Из них только последний является действительно сложным, т.е. составным из прочих типов. Типы Text и File предопределены в языке и включены в этот список больше для наглядности. Некоторой натяжкой является включение ссылок в список сложных типов. Вводится принципиально новый тип — объекты. С их включением язык Турбо Паскаль обрел возможности, присущие до этого только объектно-ориентированным языкам (C++, Smalltalk).

- 62 -

Сложные типы достаточно сложны, чтобы их можно было кратко рассмотреть по ходу введения в систему типов. Подробно мы их обсудим в разд. 4.2 и гл. 7, 11, 12, 13.

4.1. Простые типы языка

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

4.1.1. Целочисленные типы

Обилие целочисленных типов позволяет эффективно использовать память ПЭВМ и более гибко вводить целочисленные переменные в программу. Целочисленные типы отличаются размером при хранении в памяти (Byte и ShortInt — 1 байт, Word и Integer — 2 байта, LongInt — 4 байта) и способом кодировки значений (с представлением знака или без него). Типы без знака переводят допустимый диапазон значений целиком в неотрицательную область.

Целочисленные значения записываются в программе привычным способом:

123 4 -5 -63333 +10000

Число должно быть записано без всяких преобразований. Будет ошибкой задать целое число следующим образом:

1Е+2 (в смысле 100), или 123.0

Знак «+» перед числом может опускаться. Турбо Паскаль разрешает записывать целые значения в шестнадцатеричном формате, используя префикс $:

$FF $9 $FFFFAB0D

Регистр букв A, B, ..., F значения не имеет. Разрешается непосредственно приписывать знак числа, если значения (со знаком или без) не превышают допустимый для данного типа диапазон: от -$80 до +$7F для типа ShortInt, и от -$8000 до +$7FFF для типа Integer. Отрицательные значения для переменных типа LongInt могут быть записаны аналогичным способом. Но здесь есть особенность. Для этого типа отрицательные значения могут записываться и как целые величины без знака. При этом запись отрицательных значений в

- 63 -

шестнадцатеричном формате должна соответствовать обратному отсчету от максимального для размера LongInt положительного числа. Например, число $FFFFFFFF (условное максимальное положительное значение, размещающееся в четырех байтах) трактуется как значение типа LongInt, равное -1. Число $FFFFFFFE (это $FFFFFFFF-l) будет соответствовать уже -2 и т.д. Следуя этой схеме, значение, например -65, в шестнадцатеричном формате для типа LongInt вычислится так: от числа $FFFFFFFF, соответствующего значению -1, нужно «вычесть» еще 64:

$FFFFFFFF - 64 = $FFFFFFFF - $40 = $FFFFFFBF.

Мы специально рассмотрели запись отрицательных чисел в шестнадцатеричном формате, потому что встроенный отладчик Турбо Паскаля при выводе отрицательных целых значений в формате H приводит их к длине LongInt и выводит в обратном отсчете. Здесь необходимо сделать небольшое техническое замечание. Целые значения типов Word, Integer и LongInt хранятся в памяти в «перевернутом» виде: первым идет наименее значащий байт, а последним — наиболее значащий. Так, если мы запишем в переменную W типа Word значение $0102, то оно будет храниться как два байта $02 и $01. Аналогично, если переменной L типа LongInt присвоить значение $01020304, то оно расположится в памяти как четыре байта : $04, $03, $02, $01. Эта машинная «кухня» не важна при работе с переменными — они позволяют вообще не знать механизмов хранения данных. Но при прямом доступе в память или преобразовании данных (что разрешается языком Турбо Паскаль) эти технические подробности становятся необходимыми.

4.1.2. Вещественные числа

Вещественные значения (значения типа Real) могут записываться несколькими способами:

 

-1.456

 0.00239

-120.00

.09

66777

0

-10

+123

123E+2

-1.4E-19

5E4

0.1234E+31

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

-1.4E-19 = -1.4 * (10 в степени -19).

Написание буквы E может быть как прописным, так и строчным. Без

- 64 -

использования типов повышенной точности, работающих с математическим сопроцессором 80Х87, степень может иметь не более двух цифр (в диапазоне (-38) ... (+38)), но при использования этих типов — уже до четырех цифр:

1.23456789+0120

Знак числа + может опускаться, в том числе и в экспоненте. В вещественную переменную можно записать шестнадцатеричную константу. При этом она преобразуется в вещественную форму.

4.1.3. Логический тип

Логический тип Boolean состоит из двух значений: False (ложно) и True (истинно). Слова False и True определены в языке и являются, по сути, логическими константами. Регистр букв в их написании несущественен: FALSE = false. Значения этого типа участвуют во всевозможных условных операторах языка. С логическим типом связан ряд операций языка, реализующий Булеву алгебру (логические НЕ, И, ИЛИ и др.)

4.1.4. Символьный тип

Символьный тип Char — это тип данных, состоящих из одного символа (знака, буквы, кода). Традиционная запись символьного значения представляет собой собственно символ, заключенных в одиночные кавычки: 'ж', 'z' '.' ' ' (пробел) и т.п. В Турбо Паскале имеются альтернативные способы представления символов. Все они будут рассмотрены в гл. 8 «Обработка символов и строк». Значением типа Char может быть любой символ из набора ASCII — однако на каждый из них можно «написать» на клавиатуре.

4.1.5. Строковый тип

Очень важным и полезным является тип динамических строк String. (здесь «динамические» означает переменной длины). Можно задать, например, тип String[126] — и переменные такого типа смогут иметь в себе строки длиной от 0 до 126 символов. В Турбо Паскале строки — это больше, чем просто массив символов. К ним прилагается библиотека средств, позволяющих делать со строками буквально все, что угодно. Значения типа «строка» в простейшем случае записываются как обычные текстовые строчки, заключенные в одиночные кавычки:

- 65 -

'строчка '

'строка из цифр 12345'

'В кавычках может стоять любой символ, кроме кода 13'

's'

'' (пустая строка)

'Это - '' - одиночная кавычка в строке'

4.1.6. Адресный тип

Язык Турбо Паскаль объявляет специальный адресный тип — Pointer. Значением этого типа является адрес ячейки памяти, представленный по правилом MS-DOS. Тип Pointer — сугубо внутренний. Его значения нельзя вывести на печати или записать в переменную, как мы записываем числовые значения. Вместо этого всегда приходится использовать специальные функции для преобразования условной общепринятой записи адресов памяти в формат типа Pointer и наоборот.

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

4.1.7. Перечислимые типы

Перечислимый тип — это такой тип данных, при котором количество всех возможных значений ограничено (конечно). Например, тип Word соответствует этому определению. В нем 65536 значений — от 0 до 65535. И уж точно перечислимыми являются типы: Byte — 256 значений от 0 до 255 и Char — в нем 256 символов с кодами от 0 до 255. Можно перечислить и все значения типов ShortInt, Integer и даже LongInt. Только перечисление начнется не с нуля, а с отрицательного целого значения.

Есть и еще один предопределенный перечислимый тип — Boolean. У него всего два значения — False и True. Принято, что номер False внутри языка равен 0, а номер True равен 1. Перечислимый тип можно расписать в ряд по значениям. Тип Char можно было расписать в синтаксисе Паскаля как

TYPE

Char = ( симв0, симв1..., симв64, 'A', 'B', 'C', ...симв255);

тип Byte выглядел бы так:

Byte = (0, 1, 2,...,254, 255);

- 66 -

а логический тип — как

Boolean = ( False, True );

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

| TYPE

| Personages = ( NifNif, NufNuf, NafNaf );

| Test = ( Level0, Level1, Level2, Level4, Level5);

| MusicCard = ( IBM, Yamaha, ATARI, other, None);

| Boolean3 = (false_, Nolnfo_, true_);

Значения в скобках — это значения новых типов. Можно теперь объявлять переменные этих типов, а их значениями можно индексировать массивы или организовывать по ним циклы. Но всегда переменная такого типа сможет содержать только те значения, которые указаны в его перечислении.

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

Идентификаторы не могут повторяться в одной программе. Заметьте, как введен тип Boolean3 для моделирования трехзначной логики: чтобы избежать использования уже задействованных имен True и False, они чуть-чуть видоизменены. Регистр написания идентификаторов по-прежнему не играет роли. Максимальное число элементов в одном вводимом перечислении равно 65535.

Применение вводимых перечислимых типов имеет ряд преимуществ:

1) улучшается смысловая читаемость программы;

2) более четко проводится контроль значений;

3) перечислимые типы имеют очень компактное машинное представление.

Недостатком применения перечислимых типов является то, что значения из перечислимого типа (атомы) не могут быть выведены на экран или принтер и не могут быть явно введены с клавиатуры. Бороться с этим недостатком можно, но посредством не очень красивых приемов. Обычно, чтобы все-таки иметь возможность вывода на экран, вводят массивы, проиндексированные атомами. Каждый их элемент есть строковое написание соответствующего атома (например, для атома NoInfo_ — строка 'Nolnfo_').

- 67 -

Для работы с перечислимыми типами в Турбо Паскале используются общепринятые функции Ord, Pred и Succ. Рассмотрим их действие.

Любой перечислимый тип имеет внутреннюю нумерацию. Первый элемент всегда имеет номер 0; второй — номер 1 и т.д. Порядок нумерации соответствует порядку перечисления. Номер каждого элемента можно получить функцией Ord(X) : LongInt, возвращающей целое число в формате длинного целого, где X — значение перечислимого типа или содержащая его переменная. Так, для введенного выше типа Test:

Ord(Level0) даст 0,

Ord(Level1) даст 1,

...

Ord(Level5) даст 5.

Применительно к целым типам функция Ord не имеет особого смысла и возвращает значение аргумента:

Ord(0) = 0

Ord(-100) =-100

но для значений Char она вернет их код:

Ord('0') = 48,

Ord(' ') = 32,

Ord('Б') = 129.

Для логических значений

Ord(False) = 0 и Ord( True ) = 1.

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

X : = ИмяПеречислимогоТипа(ПорядковыйНомер)

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

Succ(X) — возвращает следующее за X значение в перечислимом типе;

Pred(X) — возвращает предыдущее значение в перечислимом типе.

Так, для нашего типа Boolеаn3

Succ(false_) = noinfo_ = Pred( true_).

Функции Succ и Pred применимы и к значениям целочисленных типов:

- 68 -

Succ(15) = 16, Succ(-15) = -14,

Pred(15) = 14, Pred(-15) = -16.

и очень эффективно работают в выражениях вида (N-1)*N*(N+1), которые могут быть переписаны как Pred(N)*N*Succ(N).

Не определены (запрещены) значения:

Succ(последний элемент перечисления)

и

Pred(первый элемент перечисления).

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

True > False

в типе Boolean,

NoInfo_ < true_

в типе Boolean3,

'z' > 'a'

в типе Char.

Знаки сравнения могут быть и нестрогими.

4.1.8. Ограниченные типы (диапазоны)

Еще одним вводимым типом языка является диапазон. Используя его, мы можем определить тип, который будет содержать значения только из ограниченного поддиапазона некоего базового типа. Базовым типом, из которого вычленяются диапазоны, может быть любой целочисленный тип, тип Char и любой из введенных программистом перечислимых типов.

Для введения нового типа — диапазона — надо в блоке описания типов TYPE указать имя этого типа и границы диапазона через две точки подряд:

| TYPE

| Century = 1..20; { диапазон целочисленного типа }

| CapsLetters = 'А'..'Я'; { заглавные буквы из типа Char }

| TestOK = Level3..Level5; { часть перечислимого типа Test }

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

- 69 -

Это еще больше усиливает контроль данных при выполнении программы. Значения переменных типа «диапазон» могут выводиться на экран и вводиться с клавиатуры, только если этот диапазон взят из базового типа, выводимого на экран или вводимого с клавиатуры. В приведенном примере сугубо «внутренними» значениями будут только значения, принадлежащие к типу TestOK, как диапазону невыводимого перечислимого типа Test. Будет ошибкой задать нижнее значение диапазона большим, чем верхнее.

При конструировании диапазона в описании типа можно использовать несложные арифметические выражения для вычисления границ. Но при этом надо следить, чтобы запись выражения не начиналась со скобки (скобка — это признак начала перечисления):

| TYPE

| IntervalNo = (2*3+2)*2 .. (5+123); {неверно! }

| IntervalYes = 2*(2*3+2) .. (5+123); { правильно }

4.2. Сложные типы языка

Среди сложных типов первым традиционно рассматривается массив — упорядоченная структура однотипных данных, хранящая их последовательно. Массив обязательно имеет размеры, определяющие, сколько элементов хранится в структуре. До любого элемента в массиве можно добраться по его индексу.

Тип «массив» определяется конструкцией

Array [диапазон] of ТипЭлементов;

Диапазон в квадратных скобках указывает значения индексов первого и последнего элемента в структуре. Примеры объявления типов:

| TYPE

| Array01to10 = Array[ 1..10] of Real;

| Array11to20 = Array [11..20] of Real;

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

Пусть определены переменные именно таких типов (скажем, a01to10 и a11to20). Доступ к i-му элементу массивов осуществляется через запись индекса в квадратных скобках сразу за именем массива: a01to10[i] или a11to20[i].

Возможно объявление таких конструкций, как массив массивов (это будет, по сути, матрица) или других структур. Подробнее массивы будут рассмотрены в разд. 7.1 «Массивы (Array) и работа с ними».

- 70 -

Другим сложным типом является множество, конструируемое специальной фразой

Set of БазовыйПеречислимыйТип.

Данные типа «множество» — это наборы значений некоего базового перечислимого типа, перечисленные через запятую в квадратных скобках. Так, если базовым считать введенный ранее перечислимый тип Test, то значение типа

Set of Test

может содержать произвольные выборки значений типа Test:

[Level0]

[Level3, Leve4]

[Level1..Level5],

и т.п., а также

[] — пустое множество.

Множество отличается от массива тем, что не надо заранее указывать количество элементов в нем, используя индексацию. Множество может расширяться или сокращаться по ходу программы. В Паскале определены операции над множествами, аналогичные математическим: объединение множеств, поиск пересечения их (взятие разности множеств), выявление подмножеств и др. Излишне говорить, что такой тип данных существенно расширяет гибкость языка. Подробно множества описываются в разд. 7.3 «Тип «множество» (Set). Операции с множествами».

Файловый тип — это «окно в мир» для программы на Турбо Паскале. Именно с помощью файловой системы осуществляется весь ввод и вывод информации программой. Этим вопросам в книге посвящена гл. 12, здесь же ограничимся общим определением файла. Файл (любого типа) — это последовательность данных, расположенных вне рабочей памяти программы (на магнитном диске, на экране, на принтере, в другом компьютере в сети ПЭВМ или где-нибудь еще). Некоторые файлы могут только выдавать информацию (например, клавиатура). Другие файлы могут только принимать ее, например, устройство печати. Напечатанный принтером лист — это зримый образ выведенного программой файла. Третьи файлы позволяют и считывать из себя информацию, и записывать ее. Примером является обычный файл на диске. Определяя файлы в программе, мы можем через них общаться с периферией ПЭВМ, и в том числе накапливать данные и впоследствии обращаться к ним.

- 71 -

Файловые типы Турбо Паскаля (Text, File of... и File) различаются только типами данных, содержащихся в конкретных файлах программы. Задавая в программе структуры данных типа «файл», мы определяем тип этих данных, но не оговариваем их количество в файле. Теоретически файл может быть бесконечной последовательностью данных; практически же на все случаи жизни в ПЭВМ найдутся ограничения, в том числе и на длину файла.

Следующий сложный тип языка — записи. Для тех, кто не знаком с языком Паскаль, это слово поначалу ассоциируется не с тем, что оно на самом деле обозначает. Да, запись может быть записью на диске. Но в исходном значении — это структура данных, аналогичная таблице. У обычной таблицы есть имя, и у каждого ее поля тоже есть имя. Похожим образом в типе данных «запись» указываются названия полей и тем самым вводятся в работу табличные структуры данных. Мы можем, например, ввести тип данных, аналогичный анкете (т.е. той же таблице):

| TYPE

| PERSON=RECORD

| F_I_O_ : String; { фамилия, имя, отчество}

| Ves.Rost : Real; { вес и рост}

| Telephone : Longint { номер телефона}

| END;

В этом определении слово RECORD открывает набор имен полей таблицы-анкеты и типов значений в этих полях, a END — закрывает его, т.е. пара RECORD...END конструирует тип «запись». Тип PERSON теперь задает таблицу из строки (F_I_O_), двух чисел с дробной частью (Ves, Rost) и одного целого числа. Все они называются полями записи типа Person. Далее мы можем ввести в программе переменную Nekto типа Person, и под именем Nekto будет пониматься анкета-таблица с конкретными значениями. Доступ к полям таблицы производится дописыванием к имени всей таблицы имени нужного поля. Имя переменной-записи (оно же имя таблицы) и имя поля разделяются точкой:

Nekto.F_I_O_ — значение строки с фамилией, именем, отчеством;

Nekto.Ves — значение поля Ves.

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

- 72 -

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

Очередной тип, который мы рассмотрим — это объекты. Объект (object) — это принципиально новый тип, вводимый Турбо Паскалем, начиная с версии 5.5 языка. Но это не только новый тип. Это новый подход к программированию. Что такое объект? Представьте себе, что мы сгруппировали некие данные в запись. Это удобно, ибо разнотипные значения теперь хранятся «под одной крышей». В программе эти данные обрабатываются какими-либо методами. Очень часто бывает, что эти методы годны только для обработки полей нашей записи и не работают с другими данными. Но раз так, то не будет ли рациональнее внести методы в список полей самой записи? Как только мы это проделаем, получим новый тип данных — объект.

В программе объекты описываются почти так же, как записи:

TYPE

DataWithMethods = OBJECT

Поле данных 1: его Тип;

Поле данных 2: его Тип;

...

Метод 1;

Метод 2;

Метод 3;

...

END;

Список полей и методов должен начинаться словом OBJECT и заканчиваться END (все об объектах читайте в гл. 13 «Объектно-ориентированное программирование»).

Таким образом, объект — это замкнутый мир данных и средств их обработки. Методы, реализуемые как процедуры и функции, имеют смысл и могут применяться только к полям данных этого же объекта. В то же время объекты привносят новые подходы к построению программ. Вводится такое понятие, как наследование признаков объектов. Это значит, что можно построить ряд все более и более сложных объектов, каждый из которых наследует свойства (данные и методы их обработки) предшественника и является его развитием. А объявив в программе такой ряд объектов, можно будет построить процедуры, которые смогут работать (запускать методы) с любым объектом этого ряда. (Возможность использовать одну процедуру для целого ряда взаимосвязанных через наследование объектов называется полиморфизмом.)

Язык Паскаль традиционно считается хорошим инструментом структурного программирования. Турбо Паскаль дает возможность

- 73 -

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

Последним среди сложных типов Турбо Паскаля является ссылочный тип. В разд. 4.1.6 рассматривался тип Pointer — адресный тип. Его значения — это указатели на какую-либо ячейку рабочей памяти ПЭВМ. Причем не оговаривается, какое значение и какого типа в этой ячейке может содержаться — оно может быть каким угодно. Но известно, что структуры данных, занимающие более одной ячейки памяти, располагаются последовательно: в виде сплошной цепочки значений. Поэтому, чтобы просто адрес можно было назвать адресом какой-либо структуры данных, надо, кроме адреса первой ячейки структуры, знать еще ее тип и размер. Ссылочный тип — это тот же адресный тип, но «знающий» размер и структуру того куска памяти, на который будет организован указатель. Такие «знающие» указатели называются ссылками. Чтобы описать ссылочный тип, мы должны указать имя базового типа, т.е. тип той структуры (а именно он определяет размер и расположение данных), на которую будет указывать ссылка, и поставить перед ним знак «^», например:

| TYPE

| Dim100 = Array[1..100] of Integer; { просто массив }

| Dim100SS = ^Dim100; { ссылка на структуру типа Dim100 }

Значения типа Dim100SS (ссылки на массив) будут содержать адрес начала массива в памяти. А так как ссылка (пусть она имеет имя SS) «знает», на что она указывает, можно через нее обращаться к элементам массива. Для этого снова используется знак «^», но ставится он уже после имени переменной:

SS^ — массив типа Dim100,

SS^[2] — второй элемент массива SS^, но

SS — адрес массива в памяти.

- 74 -

Узнав все это, изучающие Паскаль обычно спрашивают, зачем столько сложностей. Есть ведь обычные массивы, и можно с ними работать, не вводя промежуточные ссылочные типы. Конечно, можно. Но использование ссылочного типа дает нам уникальную возможность располагать данные там, где мы хотим, а не там, где им предпишет компилятор. Турбо Паскаль вводит специальный набор средств для организации структур данных по ходу выполнения программы. Используя его совместно со ссылками, мы можем явно указать, где будет размещена структура данных, можем разместить ее в свободной от программы памяти ПЭВМ и впоследствии удалить оттуда. Все это позволяет очень гибко использовать отнюдь не безграничные ресурсы памяти ПЭВМ.

Такова вкратце система сложных типов Турбо Паскаля. Она достаточно развита, чтобы решать большинство практических задач. На ее основе всегда можно сконструировать структуры данных «недостающих» типов, например списки, двоичные деревья и многое другое.

- 75 -

Глава 5. Константы и переменные

В этой главе описываются константы и переменные в синтаксисе Турбо Паскаля. Во многих случаях правила объявления констант и переменных значительно расширяют стандарт Паскаля и предоставляют программисту нетрадиционные способы обработки данных. Здесь же будут подробно рассмотрены совмещение переменных и описание перемененных со стартовыми значениями.

5.1. Простые константы

Раздел описания констант CONST программы позволяет вводить различного вида константы. Константы — это не более чем средство для сокращения рутинных действии над текстом программы и одновременно улучшения ее читаемости. Пусть описаны типы:

| TYPE

| Diapazon = 14..27; { диапазон }

| Massiv1 = Array [14..27] of Real; { тип массив }

| Massiv2 = Array [15..28] of Integer; { другой массив }

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

| CONST

| Lower = 14;

| Upper = 27;

| TYPE

| Diapason = Lower ..Upper;

| Massiv1 = Array [Lower..Upper] of Real;

| Massiv2 = Array [Lower+1 .. Upper+1] of Integer;

Теперь в той же ситуации достаточно поправить два числа. В этом примере Lower и Upper простые константы (есть и сложные разновидности констант, но они рассматриваются совместно с переменными).

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

- 76 -

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

Константы описываются в блоке CONST (или в блоках, если их несколько). Синтаксис их прост:

CONST

ИмяКонстанть1 = Значение1;

ИмяКонстанты2 = Значение2;

и т.п. или

ИмяКонстанты = ЗначениеВыраженияСтоящегоСправа;

Имя и значение константы разделяются знаком равенства «=» (но не знаком присваивания «:=»). После задания константы обязательна точка с запятой. Концом блока констант считается начало любого другого блока или описания процедур и функций.

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

| CONST

| Min = 0; { константа — целое число }

| Мах = 500; { константа — целое число }

| е = 2.7; { константа — вещественное число}

| SpecChar = '\'; { константа — символ }

| HelpStr = 'Нажмите клавишу F1'; { константа — строка }

| NoAddress = nil; { константа — адрес }

| OK = True; { логическая константа истинно }

| { Можно задавать простые константы типа множество: }

| Alpha = [ 'А'..'Я' ];

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

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

- 77 -

| Interval = Мах - Min + 1;

| Key = Chr(27); { символ с кодом 27 }

| e2 = е*е;

| BigHelpString = HelpStr + 'для подсказки';

| Flag = Ptr($0000, $00F0); { задание адреса }

В выражениях могут использоваться все математические операции (+,-,/,*,div,mod), поразрядные (битовые) действия, логические операторы (not, and, or, xor) и операции отношения (=,<,> и т.п., включая операцию in для множеств). Из стандартных функций Турбо Паскаля в выражениях констант могут участвовать только такие:

Abs(X) — абсолютное значение числа X;

Round(X) — округление X до ближайшего целого числа;

Trunc(X) — отсечение дробной части значения X;

Chr(X) — символ с кодом номер X;

Ord(X) — номер значения X в его перечислимом типе;

Pred(X) — значение, предшествующее X в его типе;

Succ(X) — значение, следующее за X в его типе;

Odd(X) — логическая функция проверки нечетности X;

SizeOf (X) — размер типа с именем X;

Length (X) — длина строки X;

Ptr(S,O) — функция задания адреса;

Lo(X), Hi(X) и Swap(X) — операции с машинными словами.

Этот же набор допускается при построении выражений в окнах отладки (Watch и Evaluate).

Все выражения вычисляются при компиляции, а затем лишь подставляются всюду вместо идентификаторов констант. Нельзя ввести простую (именно простую) константу: массив или запись. Турбо Паскаль вводит особый тип констант — типизированных — и позволяет работать с константами сложных типов (кроме файлов). Но такие сложные константы в силу особенности их реализации в языке, по сути, уже являются переменными и рассматриваются вместе с ними.

5.2. Переменные

Переменные вводятся в программу для хранения и передачи данных внутри нее. Любая переменная имеет имя (идентификатор). По правилам Турбо Паскаля имя переменной должно начинаться с буквы и может содержать буквы (только латинские), цифры и знак подчеркивания. Длина имени — почти любая (до 126 символов), но

- 78 -

различаются имена по первым 63 символам. Имена объявляемых в программе переменных должны быть перечислены в блоках описания VAR:

VAR

Имя1 : ИмяТипаОднойПеременной;

Имя2 : ИмяТипаДругойПеременной;

...

Имя9 : КонструкцияТипаПеременной;

Каждому имени переменной в блоке VAR должен ставится в соответствие ее тип. Имя и тип разделяются двоеточием. После объявления и описания переменной должен стоять символ «;». Концом блока описания будет начало какого-либо другого блока программы или описание процедур и функций.

Имя типа может быть именем предопределенного в языке типа или введенного программистом в предыдущем блоке описания типов TYPE. Но разрешается составлять типы по ходу объявления переменных:

| VAR

| X : Real; { вещественная переменная }

| T : Test; { переменная введенного ранее типа Test }

| i, j, k : Integer; { три целые переменные }

| Subr : 1..10; { целая ограниченная переменная }

| Dim : Array [0..99] of Byte; { переменная типа массив }

| S1, S2, { четыре переменные типа }

| S3, S4 : Set of Char; { множество символов }

| PointRec : RECORD

| X,Y : Real { запись с двумя полями }

| END;

Однотипные переменные могут перечисляться через запятую перед объявлением их типа. Никаких правил умолчания при задании типа (как в Фортране, например) или особого обозначения (как в Бейсике) нет. Все переменные должны быть описаны соответствующим типом.

Переменные подразделяются на глобальные и локальные. Глобальные — это переменные, которые объявлены в разделах VAR вне процедур и функций. Переменные, которые вводятся внутри процедур и функций, называются локальными. Среди глобальных переменных не может быть двух с одинаковым именем. Локальные же переменные, которые известны и имеют смысл только внутри процедур или функций, могут дублировать глобальные имена. При этом внутри подпрограмм

- 79 -

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

Все глобальные переменные хранят свои значения в так называемом сегменте данных. Его максимальный объем теоретически равен 65520 байт (почти 64К), но практически он всегда меньше на 1...2К. Таким образом, сумма размеров всех объявленных глобальных переменных должна быть меньше, чем 63К. Если этого мало, то используются ссылки и динамические переменные.

Локальные переменные существуют только при работе объявляющих процедур или функций и хранят свои значения в специально отводимой области памяти, называемой стеком. После окончания работы процедуры или функции ее локальные переменные освобождают стек. Размер стека можно менять от 1024 байт (1К) до тех же 65520 байт, используя ключ компилятора $М. По умолчанию он равен 16384 байт (16К). Это максимальный объем всех локальных переменных, работающих одновременно.

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

| Var

| i,j : Byte; {два раза по 1 байту}

| D : Array [1..10] of Char; { десять однобайтных элементов}

| R : Real; { шесть байтов }

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

Рис. 5.1

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

5.2.1. Совмещение адресов директивой absolute

Турбо Паскаль позволяет управлять при необходимости размещением значений переменных в памяти (ОЗУ). Для этой цели

- 80 -

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

| TYPE

| ByteArray1_10 = Array [1..10] of Byte;

| VAR

| Memory : Byte absolute $0000:$0417;

| SystemV : ByteArray1_10 absolute $B800:$0000;

| MemWord : Word absolute $0:$2;

He вдаваясь в подробности задания самого адреса $...:$..., важно отметить, как будут размещены в дальнейшем значения переменных. Все они, вместо того чтобы в порядке следования разместиться в сегменте данных, будут хранить свои значения в явно заданных (абсолютных) адресах. Причем адрес, указываемый после слова absolute, задает первый байт значения. Так, переменная Memory будет хранить и выдавать текущее значение байта системной памяти. Она же будет изменять его присваиваниями типа

Memory := 16;

{ Теперь байт по адресу $0:$417 содержит значение 16. }

Массив SystemV будет начинаться в памяти с указанного ему абсолютного адреса. В данном случае абсолютный адрес будет адресом первого элемента массива, и в этой ячейке будет хранится значение System[1]. Следующий элемент будет расположен сразу за первым в порядке возрастания адреса. Последний, десятый, элемент массива System будет соответствовать значению, хранящемуся в десятой, начиная с абсолютного адреса, ячейке памяти. И, наконец, значение длиной в слово (Word — 2 байта) MemWord будет соответствовать двум последовательным байтам памяти, первый из которых задан его абсолютным адресом в директиве absolute.

Другой формат использования слова absolute служит для совмещения описываемой переменной не с абсолютным адресом ячейки, а с адресом уже объявленной ранее переменной:

| TYPE

| RArray4Type = Array [1..4] of Real;

| Rec4Type = RECORD x1,y1,x2,y2 : Real

| END;

| VAR

| X : Word;

| Y : Word absolute X;

- 81 -

{ массив из четырех значений типа Real: }

dim : RArray4Type;

{ запись из четырех значений типа Real: }

rec : Rec4Type absolute dim;

В этом примере имена X и Y — разные идентификаторы одного и того же значения. Изменение значения X равносильно изменению значения Y, ибо после объявления Y с указанием 'absolute X', ее значение будет располагаться в тех же ячейках памяти, что и X. Но для X до этого будет отведено место обычным путем — в сегменте данных. Можно совмещать разнотипные переменные, как это сделано с dim и rec. Запись с четырьмя полями вещественного типа совмещена со значением массива из четырех таких же чисел. После объявления 'absolute dim' становятся эквивалентными обращения

dim[1] и rec.x1,

dim[2] и rec.y1,

dim[3] и rec.x2,

dim[4] и rec.y2 .

Разрешение подобных совмещений открывает большие возможности для передачи значений между различными частями программ и их использования. Директива absolute — это подобие средств организации COMMON-блоков и оператора EQUIVALENCE в языке Фортран.

При совмещении переменных сложных типов (например, dim и rec) их типы не должны конструироваться по ходу объявления, а обязаны быть введены ранее в блоке TYPE. Нарушение этого правила компилятором практически не анализируется, а последствия его могут быть самыми неприятными, вплоть до «зависания» ПЭВМ (особенно при работе с сопроцессором).

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

| VAR

| St : String[30];

| StLen : Byte absolute St;

Здесь значение StLen совмещено со значением текущей длины строки St, которое хранится в элементе строки St[0]. Не рекомендуется совмещать большие по длине переменные с меньшими. Если в последнем примере запись значения в StLen может попортить лишь строку St, то в случае

- 82 -

| VAR

| StLen : Byte;

| St : String absolute StLen;

Другие объявления;

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

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

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

5.2.2. Переменные со стартовым значением или типизированные константы

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

Выполнить это требование можно, начиная программу со «скучной» переписи переменных

х := 0; у := 10;

ch := 'z';

Особенно неприятно задавать значения массивов и записей, так как это надо делать поэлементно.

Турбо Паскаль предлагает решение этой проблемы, позволяя объявлять переменные и тут же записывать в них стартовые значения. Единственное условие: из раздела описания VAR они должны переместиться в раздел (блок) CONST. Рассмотрим объявление сложных или типизированных констант (они же переменные со стартовым значением).

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

Простые значения задаются переменным обычным приравниванием после описания типа:

- 83 -

| CONST

| R : Real = 1.1523;

| i : Integer = -10;

| S : String[10] = 'Привет!';

| P1 : Pointer = nil;

| P2 : Pointer = Ptr($A000:$1000);

| Done : Boolean = True;

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

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

| TYPE

| Dim1x10 : Array [1..10] of Real;

| Dim4x3x2 : Array [1..4, 1..3, 1..2] of Word;

{** это то же самое, что и задание: **}

{**Array [1..4] of Array [1..3] of Array [1..2] of Word **}

| CONST

| D1x10 : Dim1x10 =

| (0, 2.1, 3, 4.5, 6, 7.70, 8., 9.0, 10, 3456.6);

| D4x3x2 : Dim4x3x2 = (((1,2), (11,22), (111,222)),

| ((3,4), (33,44), (333,444)),

| ((5,6), (55,66), (555,666)),

| ((7,8), (77,88), (777,888)));

Здесь самым глубоким по уровню вложенности в задании переменной D4x3x2 (многомерного массива) оказывается самый дальний в описании типа массив — двухэлементный массив значений Word. Более высокий уровень — это уже массив из трех двухэлементных массивов, а вся структура переменной D4x3x2 состоит из четырех наборов по три массива из двух чисел.

Тот же способ использования скобок применяется и при задании значений типа «запись». Только надо явно указывать имя поля перед его значением:

- 84 -

| TYPE

| RecType = RECORD { тип запись }

| x, y : LongInt;

| ch : Char;

| dim : Array [1..3] of Byte

| END;

| CONST

| Rec : RecType = ( x : 123654; у : -898; ch : 'A';

| dim : (10, 20, 30));

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

В принципе, можно конструировать тип прямо в описании переменной, например:

| CONST

| XSet : Set Of Char = [ 'а', 'б', 'в' ];

но предпочтительнее использовать введенное ранее имя этого типа.

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

| CONST

| CharArray : Array [1..5] of Char='abcde'; {пять символов}

Типизированные константы (переменные со стартовым значением) могут быть и глобальными, и локальными, как любые другие переменные. Но даже если объявляется переменная со значением внутри процедуры, т.е. заведомо локальная, то ее значение будет размещено не в стеке, а в сегменте данных. (Об этом подробнее см. разд. 6.9.6.2 «Статические локальные переменные».)

Особенностью компилятора Турбо Паскаль (точнее, его редактора связей — компоновщика) является то, что в выполнимый код программы не входят те переменные, которые объявлены, но не используются. То же самое имеет место и для типизированных констант. Но минимальным «отсекаемым» компоновщиком куском текста программы может быть лишь блок описания CONST или VAR. Поэтому, если заведомо известно, что не все объявляемые переменные будут использоваться одновременно, лучше разбивать их на различные блоки объявлений:

- 85 -

| VAR

| x1, х2, хЗ : Real;

| VAR

| y1, y2, y3 : Integer;

| CONST

| Dim1 : Array [4..8] of Char = '4567';

| CONST

| Dim10tladka : Array [1..10] of Char = '0123456789';

и т.д.

Смысл программы это не изменит, а компоновщик сможет доказать свою эффективность.

5.3. Операция присваивания и совместимость типов и значений

Если в программе объявлены переменные, то подразумевается, что они будут получать свои значения по ходу ее выполнения. Единственный способ поместить значение в переменную — это использовать операцию присваивания в программе:

Переменная := Значение;

Оператор присваивания — это составной символ «:=». Его можно читать как «становится равным». В операции присваивания слева всегда стоит имя переменной, а справа — то, что представляет собой ее значение (значение как таковое или выражение либо вызов функции, но может быть и другая переменная). После выполнения присваивания переменная слева получает новое значение.

Турбо Паскаль, являясь языком с сильной системой типов, требует соблюдения определенных правил совместимости типов переменных и значений справа и слева от оператора «:=».

Очевидно, что не может быть проблем с присваиванием, если типы переменной и значений идентичны (тождественны). Два типа Type1 и Туре2 считаются идентичными, если:

1. Типы Type1 и Туре2 описаны одним и тем же идентификатором типа, например:

| TYPE

| Тype1 = Boolean;

| Type2 = Boolean;

здесь Type1 и Type2 идентичны. Но в случае

- 86 -

| TYPE

| Type1 = Array [1..2] of Boolean;

| Type2 = Array [1..2] of Boolean;

типы Type1 и Type2 не будут идентичными, поскольку конструкции Array...of..., хотя и одинаковы, но не являются идентификаторами, т.е. обособленными именами. Переменные типов Type1 и Type2 не смогут в последнем случае обмениваться значениями.

2. Типы Type1 и Type2 описаны как эквивалентные. Это означает, что, например, при описании

| TYPE

| Type1 = Array [1..2] of Boolean;

| Type2 = Type1;

| Type3 = Type2;

значения типов Type1, Type2 и Type3 будут полностью совместимы. Аналогичная картина возникает и при объявлении переменных. Если переменные причислены к одному и тому же типу

VAR

x1, x2, xЗ : Type1;

то они совместимы. Если Type1 — идентификатор типа, а не конструкция, то совместимость сохранится и при объявлении вида

| VAR

| x1 : Type1;

| x2 : Type1;

| x3 : Type2;

Здесь Type2 идентичен типу Type1, но будут несовместимы переменные x1 и x2:

| VAR

| x1 : Array [1..2] of Real;

| x2 : Array [1..2] of Real;

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

— оба типа являются одинаковыми;

— оба типа являются вещественными типами;

— оба типа являются целочисленными;

- 87 -

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

— оба типа являются поддиапазонами одного и того же базового типа;

— оба типа являются множественными типами с совместимыми базовыми типами;

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

— один тип является указателем (Pointer), а другой — указателем или ссылкой.

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

Существует еще один вид совместимости: совместимость по присваиванию, т.е. правила присваивания значения V2 (собственно значение, переменная или выражение) переменной V1. Они действительны только для операций присваивания и являются немногим более широкими, чем правила совместимости по типам. Значение V2 типа Type1 может быть присвоено переменной V1 типа Type2, если выполняется одно из условий:

1. Type1 и Type2 — тождественные типы, и ни один из них не является файловым типом или структурным типом, содержащим компонент с файловым типом.

2. Type1 и Type2 — совместимые перечислимые типы, и значения типа Type2 попадают в диапазон возможных значений Type1.

3. Type1 и Type2 — вещественные типы, и значения типа Type2 попадают в диапазон возможных значений Typel.

4. Typel — вещественный тип, а Type2 — целочисленный тип.

5. Type1 и Type2 — строковые типы.

6. Type1 — строковый тип, а Type2 — символьный тип.

7. Type1 и Type2 — совместимые множественные типы, и все члены значения множества типа Type2 попадают в диапазон возможных значений Type1.

8. Type1 и Type2 — совместимые адресные типы.

9 Тип объекта Type2 совместим по присваиванию с типом объекта Type1, если Type2 находится в области типа объекта Type1.

10. Тип ссылки Ptr2, указывающий на тип объекта Type2, совместим по присваиванию с типом ссылки Ptr1, указывающим на тип объекта Type1, если Type2 находится в области типа объекта Type1.

- 88 -

Последние два правила, относящиеся к данным типа «объект», не слишком очевидны. Более подробное их описание приводится в гл. 13 «Объектно-ориентированное программирование».

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

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

| VAR

| B :Byte;

| W : Word;

| I : Integer;

| R : Real;

...

| R := В*I+W;

На этот счет существуют четкие правила внутреннего преобразования типов значений — участников операций:

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

2. Выражение справа в операторе присваивания вычисляется независимо от размера переменной слева.

Если результат выражения «не вписывается» в тип переменной слева от знака «:=», то может возникнуть ошибка переполнения. В случае вещественной переменной слева при переполнении возникнет ошибка счета 205 (Floating Point overflow). Но если слева стоит целочисленная переменная, то при режиме компиляции {$R+} возникнет ошибка нарушения диапазона 201 (Range Check Error), а при {$R-} программа не прервется, но значение в переменной будет «обрезано» ее диапазоном и перестанет соответствовать выражению справа. Последний случай чреват труднодиагностируемыми ошибками в результатах счета программы.

- 89 -

Другим примером опасности может стать вывод значений выражений оператором Write (или в общем случае подстановка выражений в вызовы процедур или функций):

| VAR

| A, B : Word;

| BEGIN

| A:= 55000;

| B:= A-256;

| Write(A+B);

| END.

Эта программа должна вычислить значение A+B и вывести его на экран. Но она этого не сделает. В режиме компиляции {$R+} запуск программы даст ошибку 201, поскольку общий для A и B тип Word не вмещает их сумму (его «потолок» равен 65535). В режиме {$R-} программа напечатает заведомую ложь.

Выход из подобных ситуаций прост. Надо объявлять хотя бы одного участника выражения более длинным (емким) типом. Так, если описать A как LongInt, то общим для A и B типом станет LongInt, и в нем уместится достаточно большое значение суммы. Можно даже просто, не изменяя объявления переменной, переписать последний оператор в виде

Write(LongInt(A) + B);

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

5.4. Изменение (приведение) типов и значений

В Турбо Паскале имеется очень мощное средство, позволяющее обойти всевозможные ограничения на совместимость типов или значений: определена операция приведения типа. Она применима только к переменным и значениям. Суть этой операции в следующем. Определяя тип, мы определяем форму хранения информации в ОЗУ, и переменная данного типа будет представлена в памяти заранее известной структурой. Но если «взглянуть» на ее образ в памяти с точки зрения машинного представления другого типа, то можно будет трактовать то же самое значение как принадлежащее другому типу. Для этого достаточно использовать конструкцию

ИмяТипа( ПеременнаяИлиЗначение )

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

- 90 -

| TYPE

| Arr4Byte = Array[1..4] of Byte; { массив из 4-х байтов }

| Arr2Word = Array[1..2] of Word; { массив из двух слов }

| RecType = RECORD

| Word1, Word2 : Word { запись из двух слов }

| END;

| VAR

| L : LongInt; { четырехбайтовое целое со знаком }

| S : ShortInt; { однобайтовое целое со знаком }

| В : Byte; { однобайтовое целое без знака }

| W : Word; { двухбайтовое целое без знака }

| a4 : Arr4Byte; { массив из четырех байтов }

| a2 : Arr2Word; { массив из двух слов по два байта }

| Rec : RecType; { запись из двух слов по два байта }

| BEGIN

| L := 123456; { некое значение переменной L }

| S := -2; { некое значение переменной S }

| a2 := arr2Word( L ); { два слова L перешли в массив a2 }

| a4 := arr4Byte( L ); {четыре байта L перешли в a4 }

| W := RecType( L ).Word1; { доступ к L по частям

| W := arr2Word( L )[ 1 ];

| RecType(L).Word1 := 0; { обнуление первого слова в L }

| B := Byte( S ); { если S=-2, то B станет 254 }

| B := Arr4Byte( a2 )[1]; { запись в B значения первого }

{полуслова массива a2 }

| END.

Приведение типов не переопределяет типы переменных. Оно лишь дает возможность нарушить правила совмещения типов при условии, что соответствующие значения совместимы в машинном представлении. При преобразовании типа переменной ее размер всегда должен быть равен размеру типа, к которому приводится значение. Если после приведения переменной к структуре мы хотим воспользоваться отдельным ее элементом, то просто приписываем индекс (для массивов) или поле (для записей). Вообще говоря, конструкцию ИмяТипа( Переменная ) можно условно считать именем некой необъявленной переменной типа «ИмяТипа» и со значением, хранимым в «Переменной». Приведение типа переменной может стоять как слева, так и справа, т.е. может участвовать в выражениях. Допускается вложенность преобразований при условии сохранения размеров. Как видно из примера, можно изменять определенные байты общей структуры переменной в памяти независимо от ее типа.

- 91 -

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

Integer( 'Y' ) { код символа 'Y' в формате Integer }

Boolean( 1 ) { это логическое значение True }

LongInt( 1 ) { значение 1, размещенное в четырех байтах}

Char ( 130-1 ) { символ с кодом ASCII номер 129 }

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

При приведении значения в более широкий тип (например, LongInt(1)) значения будут целиком записаны в младшие (наименее значащие) байты, что сохранит само значение. В противоположном случае, когда значение приводится к более короткому типу, от него берутся уже не все, а лишь самые младшие байты. При этом старшие байты игнорируются, и приведенное значение не равно исходному. Например, выражение Byte( 534 ) равно 22, поскольку значение 534 кодируется в тип Word и раскладывается на младший и старший байты как 22 + 2*256. Младший байт (22) мы получим, а старший (со значением 2) проигнорируем.

Преобразование типа значения внешне похоже на преобразование типа переменной. Но эффект от него несколько иной (за счет возможности изменения размера), и ограничения на применение другие. В частности, как задаваемый тип, так и тип значения (выражения) должны быть перечислимыми (это все целочисленные типы, тип Char, Boolean и вводимые перечисления) или адресными (адресные значения хранятся как значения LongInt). По понятным причинам преобразование значения не может появиться в левой части присваивания.

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

Приведение типов как переменных, так и значений — нетривиальная операция. Она подразумевает достаточно высокий уровень знаний технических подробностей языка. Например, нужно знать, как хранятся структуры (массивы, записи, множества), адреса, числа, строки в памяти, какие размеры им отводятся. Приведение

- 92 -

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

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

- 93 -

Глава 6. Управляющие структуры языка

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

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

6.1. Простой и составной операторы

Оператор в программе — это единое неделимое предложение, выполняющее какое-либо действие. Типичный простой оператор — оператор присваивания. Другим примером может служить вызов какой-либо процедуры в программе. Важно, что под любым оператором подразумевается действие (присваивание, сравнение величин, вызов подпрограммы, переход по программе и т.п.). Блоки описания типов, переменных, констант, меток и составляющие их предложения не являются в этом смысле операторами.

Два последовательных оператора обязательно должны разделяться точкой с запятой «;». Этот символ имеет смысл конца оператора, и он же разделяет операторы при записи в одну строку, например:

a:=11; b:=a*a; Write(a,b);

Отсюда вовсе не следует, что можно не закрывать символом «;» единственные в строке операторы.

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

Составной оператор — это последовательность операторов, перед которой стоит слово BEGIN, а после — слово END. Между любыми двумя операторами должна стоять точка с запятой. Она сама по себе не является оператором и поэтому может отсутствовать между оператором и словом END. Зарезервированное слово BEGIN тоже не является оператором (как и все остальные зарезервированные слова), и после него точка с запятой не ставится. Так, чтобы оформить

- 94 -

три приведенных выше оператора в один, но составной, нужно как бы заключить их в операторные скобки BEGIN...END:

| BEGIN

| a:=11;

| b:=a*a;

| Write(a,b)

| END;

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

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

6.2. Условный оператор (IF...THEN...ELSE)

Условный оператор IF...THEN...ELSE (если...то...иначе) имеет структуру

If Условие THEN Оператор1 ELSE Оператор2;

и служит для организации процесса вычислений в зависимости от какого-либо логического условия. Под условием понимается логическое значение True (истинно) или False (ложно), представленное константой, переменной или логическим выражением, например:

IF True THEN ...; { крайний и бесполезный случай условия }

IF LogicalVar THEN ...; { условие — логическая переменная }

IF not LogicalVar THEN ...; {условие — логическое выражение}

IF x > 5 THEN ...; { условие — результат операции сравнения}

Если условие представлено значением True, то выполняется оператор (простой или составной), следующий за словом THEN. Но если условие не выполняется, т.е. представлено значением False, то будет выполняться оператор (может быть простым или составным), следующий за словом ELSE. Например:

- 95 -

| IF x>5

| THEN { ветвь при x>5 - истинно }

| BEGIN

| x:=x+5; y:=1 { некий составной оператор }

| end

| ELSE { ветвь при x>5 - ложно }

| y:=-1; { простой оператор }

В примере между ключевыми словами нет точек с запятой. Более того, их появление было бы ошибкой, что будет показано ниже. Но точка с запятой в конце всего оператора (после завершения ветви ELSE) обязательна. Она отделяет условный оператор от остальных, следующих за ним по тексту. Альтернативную ветвь ELSE можно опускать, если в ней нет необходимости. В таком «усеченном» условном операторе в случае невыполнения условия ничего не происходит, и выполняется следующий за условным оператор. Имеет «право на жизнь» условный оператор с ветвями, содержащими пустые операторы, например такой:

IF LogicFunc(x) THEN ;

Он полезен в случаях, когда условием является возвращаемое значение какой-либо логической функции, имеющей побочный эффект. Например, известны библиотеки подпрограмм (Turbo Power Toolbox), где для создания окна на экране дисплея имеются функции, собственно строящие окно и возвращающие логическое значение в зависимости от результата построения. Приведенная выше конструкция позволяет проявиться побочному эффекту, игнорируя возвращаемое значение.

Условные операторы могут быть вложенными друг в друга:

IF Условие

THEN { Условие выполняется }

if ПодУсловие { ПодУсловие выполняется }

then

BEGIN

...

end

else { ПодУсловие не выполняется }

BEGIN

...

end

ELSE { Условие не выполняется }

BEGIN

...

end;

- 96 -

Еще раз обращаем внимание на отсутствие точки с запятой между ключевыми словами до самого внешнего слова END.

При вложениях условных операторов самое главное — не запутаться в вариантах сочетаний условий (отчасти этому может помочь ступенчатая форма записи операторов). Всегда действует правило: альтернатива ELSE считается принадлежащей ближайшему условному оператору IF, не имеющему ветви ELSE. Именно это правило заложено в компилятор, и, как следствие этого, есть риск создать неправильно понимаемые условия. Например:

IF Условие1

THEN

if Условие2

then ОператорА

ELSE

ОператорБ;

По записи похоже, что ОператорБ будет выполняться только при невыполнении Условия1. Но в действительности он будет отнесен к Условию2 и выполнится лишь при выполнении Условия1 и невыполнении Условия2. Попытка закрыть вложенный условный оператор установкой «;» после ОператораА лишь ухудшит положение. Выход здесь таков: нужно представить вложенное условие как составной оператор

IF Условие1

THEN

BEGIN

if Условие2

then ОператорА

end

ELSE

ОператорБ;

и для ветви ELSE ближайшим «незакрытым» оператором IF окажется оператор с Условием1.

В условии оператора IF может стоять достаточно сложное логическое выражение. В нем придется учитывать приоритет различных логических и математических операций, а также текущую схему компиляции логических выражений в Турбо Паскале. (Подробнее об этом см. разд. 9.3 «Логические вычисления и операции отношения».)

6.3. Оператор варианта (CASE)

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

- 97 -

операторы (простые или составные). Если вариантов всего два, то можно обойтись и оператором IF. Но если их, например, десять? В этом случае оптимален оператор варианта CASE. Структура оператора CASE имеет вид

CASE УправляющаяПеременнаяИлиВыражение OF

НаборЗначений1 : Оператор1;

НаборЗначений2 : Оператор2;

НаборЗначенийЗ : ОператорЗ;

...

НаборЗначенийN : ОператорN

ELSE

АльтернативныйВсемНаборамОператор

END;

Между служебными словами CASE и OF должна стоять переменная или выражение (оно вычислится при исполнении оператора CASE). Тип переменной (или значения выражения) может быть только перечислимым (включая типы Char и Boolean), диапазоном или целочисленным одного из типов Byte, ShortInt, Integer или Word. Все прочие типы не будут пропущены компилятором Турбо Паскаля. Набор значений — это конкретные значения управляющей переменной или выражения, при которых необходимо выполнить соответствующий оператор, игнорируя остальные варианты. Если в наборе несколько значений, то они разделяются между собой запятыми. Можно указывать диапазоны значений. Между набором значений и соответствующим ему оператором обязательно должно ставиться двоеточие «:».

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

Завершает оператор CASE слово END. По-прежнему перед ELSE и END необязательна точка с запятой. Рассмотрим пример оператора варианта (в нем Err — переменная типа Word):

| CASE Err OF

| 0 : WriteLn( 'Нормальное завершение программы' );

| 2, 4, 6 : begin

| WriteLn('Ошибка при работе с файлом');

| WriteLn('Повторите действия снова.')

| end;

- 98 -

| 7..99 : WriteLn( 'Ошибка с кодом ', Err )

| ELSE {case}

| WriteLn( 'Код ошибки=,Err,' См. описание')

| END; {case}

Здесь в зависимости от значения переменной Err выводится на экран операторами WriteLn текст соответствующего сообщения. Наличие варианта ELSE (Err не равна 0, 2, 4, 6 и не входит в диапазон 7..99) гарантирует выдачу сообщения в любом случае.

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

Оператор варианта CASE очень удобен и, как правило, более эффективен, чем несколько операторов IF того же назначения. Эффективность его в смысле скорости будет максимальной, если размещать наиболее вероятные значения (или их наборы) первыми в порядке следования.

6.4. Оператор цикла с предусловием (WHILE)

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

Рассмотрим оператор цикла с предусловием, записываемый как

WHILE Условие DO Оператор;

Конструкция WHILE...DO переводится как «пока...делать». Оператор (простой или составной), стоящий после служебного слова DO и называемый телом цикла, будет выполняться циклически, пока выполняется логическое условие, т.е. пока значение «Условия» равно True. Само условие цикла может быть логической константой, переменной или выражением с логическим результатом.

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

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

- 99 -

выражений и значений, определенных еще до первого выполнения тела цикла. Поясним сказанное примером, вычисляющим значение факториала 10! (рис. 6.1).

| VAR

| Factorial, N : Integer;

| BEGIN

| Factorial := 1; { стартовое значение факториала = 0! }

| N:=1; {стартовое значение для условия цикла}

| WHILE N<=10 DO

| begin { начало тела цикла WHILE }

| Factorial:=Factorial*N; { вычисление факториала N! }

| N := N + 1 { N должно меняться в цикле }

| end; { конец тела цикла WHILE }

| WriteLn( Factorial ); { вывод результата расчета }

| END.

Рис. 6.1

Обратите внимание на присваивание N:=1 перед циклом. Без него значение N может быть любым, и условие может быть некорректным, не говоря уже о самом значении факториала. Значение N меняется внутри цикла. При этом гораздо безопаснее так писать тело цикла, чтобы оператор, влияющий на условие, был последним в теле. Это гарантирует от нежелательных переборов. Если, скажем, на рис. 6.1 поставить строку N:=N+1; перед вычислением значения Factorial, то результатом программы будет значение 11!. Исправить оплошность можно, заменив стартовое значение N на 0, а условие — на N<10. Но от этого программа вряд ли станет нагляднее. Поскольку циклу WHILE «все равно», что происходит в его теле, тело может содержать другие, вложенные, циклы.

6.5. Оператор цикла с постусловием (REPEAT...UNTIL)

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

- 100 -

Оформляется такой цикл с помощью служебных слов REPEAT и UNTIL (повторять до):

REPEAT

Оператор1;

Оператор2;

...

ОператорN

UNTIL Условие;

Первое из них объявляет цикл и открывает его тело, а второе — закрывает тело и содержит условие окончания цикла. Тело цикла может быть пустым или содержать один и более операторов. В последнем случае слова BEGIN и END не нужны: их роль играют слова REPEAT и UNTIL.

Условие — это логическое значение, переменная или выражение с логическим результатом. Но работает оно здесь совсем не так, как в цикле WHILE. Если в цикле WHILE подразумевается алгоритм «пока условие истинно, выполнять операторы тела цикла», то цикл REPEAT...UNTIL соответствует алгоритму «выполнять тело цикла, пока не станет истинным условие».

Иными словами, в цикле с REPEAT...UNTIL условием продолжения итераций будет невыполнение условия (его значение False). Хорошей иллюстрацией к вышесказанному может быть конструкция «вечного цикла»:

REPEAT UNTIL False;

Этот цикл пустой и никогда не прекращающийся. Он хорош только в случае, когда нужно заблокировать программу, и, возможно, весь компьютер. (Но если отбросить шутки, то можно и его пристроить в дело. Обычно так организуются программы с повторяющимися действиями: вначале программы ставится REPEAT, а в конце — UNTIL False. А прервать цикл можно специальными операторами: Exit, Halt. Это имеет смысл, если условий завершения программы много или они очень сложны.)

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

6.6. Оператор цикла с параметром (FOR...DO)

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

- 101 -

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

FOR ПараметрЦикла:=МладшееЗнач TO СтаршееЗнач DO Оператор;

или

FOR ПараметрЦикла := СтаршееЗнач DOWNTO МладшееЗнач DO

Оператор;

Слова FOR...TO (DOWNTO)...DO можно перевести как «для параметра от...до...делать».

Оператор, представляющий собой тело цикла, может быть простым, составным или пустым. В последнем случае за словом DO сразу ставится точка с запятой. Параметр цикла, а также диапазон его изменения (от стартового до конечного значения включительно) может быть только целочисленного или перечислимого типа. Сам параметр должен быть описан совместно с прочими переменными. Шаг цикла FOR всегда постоянный и равен «интервалу» между двумя ближайшими значениями типа параметра цикла. Изменение параметра цикла может быть возрастающим, но может быть и убывающим. В первом случае МладшееЗначение должно быть не больше чем Старшее, а во втором — наоборот. Примеры оформления циклов с параметром приведены на рис. 6.2.

| VAR

| i : Integer; { описание параметров циклов}

| c : Char;

| b : Boolean;

| e : (elem1, elem2, elem3 ); {вводимый перечислимый тип}

| BEGIN

| FOR i:= -10 TO 10 DO Writeln(i);

| FOR i:= 10 DOWNTO -10 DO Writeln(i);

| FOR c:= 'a' TO 'r' DO Writeln(с);

| FOR b:=True DOWNTO False DO Writeln(b);

| FOR e:= elem1 TO elem3 DO Writeln(Ord(e));

| END.

Рис. 6.2

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

- 102 -

чения в заголовке цикла. На месте старших и младших значений могут стоять константы (как на рис. 6.2), а могут и переменные или выражения, совместимые по присваиванию с параметром цикла. Выполнение цикла начинается с присваивания параметру стартового значения. Затем следует проверка, не превосходит ли параметр конечное значение (случай с TO) или не является ли он меньше конечного значения (случай с DOWNTO). Если результат проверки утвердительный, то цикл считается завершенным и управление передается следующему за телом цикла оператору. В противном случае выполняется тело цикла, и после этого параметр меняет свое значение на следующее, согласно заголовку цикла. Далее снова производится проверка значения параметра цикла, т.е. алгоритм повторяется. Из этого следует, что будут проигнорированы циклы

FOR i := 5 ТО 4 DO ...;

FOR i : = 4 DOWNTO 5 DO ...;

а цикл

FOR i := N TO N DO ...;

выполнит операторы своего тела строго один раз.

Запрещается изменять параметр цикла и его старшее и младшее значения (если они заданы переменными или выражениями с ними) изнутри тела цикла. Кроме того, параметр цикла не может участвовать в построении диапазонов этого же цикла. Компилятор таких «незаконных» действий не замечает, но программа, содержащая цикл с заголовком типа

FOR i := i-5 TO i+5 DO ...

не заслуживает никакого доверия, даже если запускается. Если же необходимо досрочно завершить цикл FOR (для чего велик соблазн искусственно «подрастить» параметр цикла), то можно воспользоваться оператором перехода Goto (о нем см. следующий раздел). В техническом описании Турбо Паскаля отмечается, что после завершения цикла FOR значение его параметра не определено. При экспериментальной проверке этого факта скорее всего получится обратный результат: параметр будет иметь конечное значение своего диапазона. Тем не менее, не следует опираться на это в своих программах. Лучше переприсвоить значение параметра после окончания цикла — так будет корректнее. Исключение — выход из цикла переходом Goto. В этом случае значение переменной (параметра цикла) останется таким же, каким было на момент выполнения оператора Goto.

- 103 -

Циклы с параметром — очень быстрые и генерируют компактный выполнимый код. Но всем им присущ один традиционный в Паскале недостаток — параметр должен принадлежать к перечислимому типу, а шаг не может быть изменен. Так, в первых двух циклах на рис. 6.2 шагом будет значение +1 и -1 соответственно, в цикле от 'а' до 'г' параметр C примет последовательные значения 'а', 'б', 'в', 'г', т.е. каждый следующий элемент — это значение функции Succ(C). Следствием этого являются проблемы организации циклов с шагом, отличным, например, от 1, а тем более циклов с вещественным параметром.

Для разрешения таких проблем приходится использовать обходные пути: обращаться к циклам с условиями. Так, цикл с вещественным параметром r от 3,20 до 4,10 с шагом 0,05 можно запрограммировать циклом WHILE:

r:=3.20;

WHILE r<=4.10 do

BEGIN

...

r := r + 0.05

end;

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

6.7. Оператор безусловного перехода Goto

Оператор Goto, имеющийся во многих алгоритмических языках, включая и Турбо Паскаль, можно с полным правом назвать «злосчастным». В разгар моды на структурное программирование он подвергся сильным гонениям, ибо было доказано, что можно вообще программировать без него. Из-за того же Goto здорово доставалось Фортрану и раннему Бейсику, большей частью справедливо, так как от пары десятков переходов вдоль и поперек программа не становится более понятной.

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

Полный синтаксис оператора перехода — это

Goto Метка;

- 104 -

где метка — описанный в блоке LABEL идентификатор (цифры от 0 до 9999 или собственно идентификатор). Метка может стоять в программе «где угодно» между операторами. При этом каждая метка может появиться только один раз (рис. 6.3):

| LABEL

| m10, m20, StopLabel, 1;

| VAR

| i : ShortInt;

| BEGIN

| 0001:

| IF i<10 THEN Goto m10 ELSE Goto m20;

| ...

| m10 : WriteLn('i меньше 10');

| Goto StopLabel;

| m20 : i := i - 1;

| ...

| Goto 1;

| StopLabel:

| END.

Рис. 6.3

Метка от оператора должна отделяться символом «:». Если метка обозначается цифрой, то предшествующие нули не являются значащими. Так, на рис. 6.3 метки 1 и 0001 эквивалентны. Обычно метки размещаются у операторов, но могут стоять и у слова END, что означает переход на конец текущего блока BEGIN...END (на рисунке это еще и выход из программы). Перед BEGIN метки не ставятся. Следует избегать переходов (и расстановки меток), передающих управление внутрь составных операторов циклов, да и вообще переходов в составные операторы, вложенные в тот, где выполняется оператор Goto. Другое дело — выход из вложенных операторов во внешние. В таких случаях применение Goto — достаточно безопасный и максимально эффективный способ вернуть управление внешнему оператору.

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

- 105 -

При практическом программировании на Паскале необходимость в использовании оператора Goto возникает не часто (если, конечно, не писать стилем Фортрана или Бейсика на Паскале). Иногда один переход позволяет избежать очень широких циклов, но злоупотребление переходами не будет признаком высокой культуры программирования.

6.8. Операторы Exit и Halt

Турбо Паскаль обладает средствами безусловного выхода из программных блоков (процедур, функций, основного блока программы). Это очень удобно, так как позволяет завершить программу или процедуру без предварительных переходов по меткам. К таким операторам завершения относятся вызовы системных процедур Exit и Halt.

Вызов Exit завершает работу своего программного блока. Если выполняется Exit в процедуре, то выполнение ее завершится и ход программы вернется к следующему за вызовом этой процедуры оператору. При этом процедура вернет значения, которые успели вычислиться к моменту выполнения Exit (если она должна их возвратить). Сама программа не прервется. Но если Exit выполняется в основном блоке программы, выход из него будет эквивалентен нормальному ее завершению. Процедура Exit — в некотором роде избыточная. Ее действие полностью эквивалентно безусловному переходу (Goto) на метку, стоящую перед последним словом END содержащей ее процедуры, функции или основного блока. Но использование Exit позволяет избежать лишней возни с метками и улучшает читаемость программ. Таким образом, Exit — это средство выхода из программного блока, а не из составного оператора, например цикла FOR. Вызов Exit может быть в трижды вложенном цикле процедуры, но его действие все равно будет относится к процедуре, как к программному блоку.

Процедура Halt, или более полно Halt(n), действует более грубо и менее разборчиво. Независимо от того, где она находится, ее выполнение завершает работу программы с кодом завершения n. Этот код впоследствии может быть проанализирован, в частности, командой IF ERRORLEVEL в среде MS-DOS. Значение ERRORLEVEL после остановки программы будет равно значению n. Значение n=0 соответствует нормальному коду завершения. Вызов процедуры Halt без параметра эквивалентен вызову Halt(0).

- 106 -

На основе процедуры Halt можно легко построить программу, например ASK.PAS, для организации диалога в ВАТ-файлах MS-DOS (рис. 6.4).

| VAR i : Word; { ======ПРОГРАММА ASK.PAS ======== }

| BEGIN

| { ...вывод на экран текста альтернатив выбора... }

| Write( 'Введите Ваш выбор: ');

| ReadLn(i); { ввод номера альтернативы с экрана)

| Halt(i) { остановка программы и назначение }

| END. { ERRORLEVEL в MS-DOS номера i }

Рис. 6.4

Теперь в ВАТ-файле надо запускать откомпилированную программу ASK.EXE и сразу после нее анализировать, что будет находиться в переменной MS-DOS ERRORLEVEL.

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

6.9. Процедуры и функции

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

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

PROCEDURE ИмяПроцедуры;

становится процедурой, и вместо этого составного оператора в основном блоке может подставляться одно лишь ИмяПроцедуры.

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

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

ИмяПроцедуры(Параметр1, Параметр2,);

- 107 -

PROCEDURE ИмяПроцедуры (ПарамЗнач1 : ТипЗнач1;

ПарамЗнач2 : ТипЗнач2;

VAR ПарамПерем1 : ТипПерем1;

VAR ПарамПерем2 : ТипПерем2; ... );

LABEL

Перечисление меток внутри тела процедуры

CONST

Описание локальных констант процедуры

TYPE

Описание локальных типов

VAR

Описание локальных переменных

Описание вложенных процедур и (или) функций

BEGIN

Тело процедуры

END;

Рис. 6.5

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

FUNCTION ИмяФункции( Список параметров ) :

ИмяСкалярногоТипаЗначенияФункций;

Что и как может возвращать функция при ее вызове, мы рассмотрим чуть позже.

Нетрудно заметить, что структура подпрограмм копирует структуру программы в целом (не считая заголовка и завершающей точки с запятой вместо точки после END). Порядок следования разделов описаний подчиняется тем же правилам, по которым строится вся программа.

6.9.1. Параметры. Глобальные и локальные описания

Поскольку процедуры и функции должны обладать определенной независимостью в смысле использования переменных (а также типов и констант), при их введении в программу возникает разделение данных и их типов на глобальные и локальные. Глобальные константы, типы, переменные — это те, которые объявлены в программе вне процедур или функций. Наоборот, локальные — это константы, типы и переменные, существующие только внутри процедур или функций, и объявленные либо в списке параметров (только переменные), либо в разделах CONST, TYPE, VAR внутри процедуры или функции.

- 108 -

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

PROGRAM Main;

| VAR

| Xmain, Ymain : LongInt; {глобальные переменные}

| Res : Real;

| PROCEDURE Proc1( a,b : Word; VAR Result : Real );

| VAR

| Res : Real; { локальная Res, закрывающая глобальную }

| BEGIN

| Res := a*a + b*b; { локальные действия }

| Result:= Xmain+Ymain*Res; {работают глобальные значения}

| Xmain := Xmain+1; { модифицируется глобальное значение}

| END;

TYPE

CONST Другие глобальные объявления, уже

VAR недоступные из процедуры Proc1;

BEGIN

Основной блок, в котором может вызываться Proc1

END.

Рис. 6.6

При совпадении имен локальной и глобальной переменных (типов, констант) сильнее оказывается локальное имя, и именно оно используется внутри подпрограммы. Так, существует неписанное правило: если подпрограмма содержит в себе циклы FOR, то параметры циклов должны быть описаны как локальные переменные. Это предупредит неразбериху при циклическом вызове процедур.

Мы уже отмечали, что параметры, описываемые в заголовке процедур и функций, по сути, являются локальными переменными. Но кроме того, они обеспечивают обмен значениями между вызывающими и вызываемыми частями программы (т.е. теми же процедурами или функциями). Описываемые в заголовке объявления подпрограммы параметры называются формальными, а те, которые подставляются на их место при вызове, — фактическими, ибо они при выполнении как бы замещают все вхождения в подпрограмму своих формальных «двойников».

- 109 -

Параметры подпрограмм разделяются на параметры-значения и параметры-переменные. Параметры-значения — это локальные переменные подпрограммы, стартовые значения которых задаются при вызове подпрограммы из внешних блоков (а те локальные переменные, которые описаны в разделе VAR между заголовком и телом подпрограммы, должны получать свои значения присваиванием внутри тела подпрограммы). Параметры-значения, описанные в заголовке, могут изменять свои значения наряду с прочими переменными, но эти изменения будут строго локальными и никак не передадутся в вызывающие операторы. Для того чтобы подпрограмма изменила значение переданной ей переменной, нужно объявлять соответствующие параметры как параметры-переменные, вставляя слово VAR перед их описанием в заголовках. Рассмотрим внутренний механизм передачи параметров подпрограмм. При вызове процедуры или функции каждой локальной переменной, описанной внутри процедуры, и каждому параметру-значению отводится место для хранения данных в специальной области памяти, называемой стеком. Эти места принадлежат переменным ровно столько времени, сколько выполняется подпрограмма. Причем ячейки, соответствующие параметрам-значениям, сразу заполняются конкретным содержимым, заданным в вызове подпрограммы. По-другому организуются параметры-переменные. Вместо копии значения подпрограмма получает разрешение работать с тем местом, где постоянно (т.е. все время работы самого вызывающего программного блока) хранится значение переменной, указанной в вызове на месте параметра-переменной. Все действия с параметром-переменной в подпрограмме на самом деле являются действиями над подставленной в вызов переменной.

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

Рассмотрим пример процедуры (рис. 6.7), принимающей любое число и возвращающей его квадрат. Если значение квадрата числа превышает значение 100, то оно считается равным 100. При этом должен устанавливаться глобальный «флаг».

На рис. 6.7 отмечены оба способа обмена данными с процедурой: непосредственной модификацией глобальных переменных и передачей переменной через VAR-параметр. Обратите внимание на использование локальной переменной X. Подобные приемы иногда позволяют не вводить лишних локальных переменных.

- 110 -

| VAR

| GlobalFlag : Boolean; {глобальный флаг}

| PROCEDURE GetSQR( X : Real; VAR Sq : Real );

| { процедура не имеет локальных переменных, кроме X }

| CONST

| SQRMAX =100; { локальная простая константа }

| BEGIN { начало тела процедуры }

| { В X запишется квадрат его последнего значения: }

| X := X * X;

| { Результат сравнения запишется в глобальный флаг: }

| GlobalFlag := ( X > SQRMAX );

| if GlobalFlag then

| X:=SQRMAX; { ограничение X }

| Sq := X { возвращение значения }

| END; { конец тела процедуры }

| VAR

| SqGlobal : Real;

| BEGIN { основной (вызывающий) блок }

| GetSQR ( 5, SqGlobal );

| WriteLn( SqGlobal, ' Флаг: ', GlobalFlag )

| END.

Рис. 6.7

Оставим ненадолго процедуры и рассмотрим функции. Идентификатор функции возвращает после вызова скалярное значение заданного типа. Для присвоения функции значения ее имя должно хотя бы однажды появиться в левой части оператора присваивания в теле самой функции. Вызов функции производится уже не обособленно, а в том месте, где необходимо значение функции (в выражениях, вызовах других подпрограмм и т.п.). Например, процедуру GetSQR на рис. 6.7 можно переписать в виде функции (рис. 6.8).

| VAR GlobalFlag : Boolean; { глобальный флаг }

| FUNCTION GetSQR( X : Real ) : Real;

| CONST SQRMAX =100;

| BEGIN

| X := X*X;

| GlobalFlag:=(X>SQRMAX);

| if GlobalFlag then X:=SQRMAX;

| GetSQR := X { возвращение значения }

| END;

Рис. 6.8

- 111 -

| BEGIN { основной (вызывающий) блок }

| WriteLn( GetSQR( 5 ), ' Флаг: ', GlobalFlag )

| END.

Рис. 6.8 (окончание)

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

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

Большое значение имеет соблюдение правил соответствия типов при подстановке параметров. Нельзя (да и не получится — компилятор не пропустит!) конструировать типы в описаниях параметров. Можно использовать только уже известные идентификаторы типов. То же самое можно сказать о типе возвращаемого значения функции. И, конечно, число и порядок следования параметров в вызове должен соответствовать описанию процедуры или функции. Кроме того, в Турбо Паскале существует правило, требующее, чтобы параметры, имеющие файловый тип (или сложный тип с файловыми компонентами), были обязательно описаны как VAR-параметры.

Процедуры и функции могут быть вложенными друг в друга (см. рис. 6.5). Число уровней вложенности может быть достаточно большим, но на практике не превышает второго уровня. Вложенная процедура или функция относится к охватывающей ее подпрограмме точно так же, как сама подпрограмма относится к основной программе. Вложенные процедуры или функции могут вызываться только внутри охватывающей подпрограммы. Переменные, вводимые в них, будут по-прежнему локальными, а глобальными будут считаться все локальные переменные охватывающей подпрограммы и, как и ранее, все действительно глобальные переменные (а также типы и константы), объявленные в основной программе перед описанием подпрограмм.

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

- 112 -

6.9.2. Опережающее описание процедур и функций

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

PROCEDURE ИмяПроцедуры(параметры); FORWARD;

FUNCTION ИмяФункции( параметры ) : ТипЗначения; FORWARD;

......

PROCEDURE ИмяПроцедуры; { список параметров уже не нужен }

Тело процедуры

FUNCTION ИмяФункции; { достаточно указать только имя }

Тело функции

......

Эта директива объявляет заголовок подпрограммы, откладывая описание содержимого «на потом». Местоположение этого описания уже не играет роли, и в нем можно не указывать параметры, а ограничиться лишь именем подпрограммы. Основное описание не может иметь никаких директив (FORWARD, EXTERNAL и др.).

Директива FORWARD существует в языке в основном для развязки закольцованных вызовов. Так, ситуацию на рис. 6.9 можно разрешить только с ее помощью:

PROCEDURE a( у : TypeXY ); FORWARD;

PROCEDURE b( x : TypeXY );

BEGIN

...

a(p); {процедура b вызывает a}

END;

PROCEDURE a;

BEGIN

...

b( q ); {но сама a вызывает b }

END;

Рис. 6.9

- 113 -

6.9.3. Объявление внешних процедур

Турбо Паскаль — язык не слишком коммуникабельный по отношению к прочим языкам. Он не поддерживает генерацию объектных файлов в формате OBJ и вследствие этого не может поставлять написанные на нем процедуры и функции для связи с другими языками. Единственное, что можно — это использовать при компиляции и компоновке программ на Турбо Паскале внешние подпрограммы в виде OBJ-файлов, созданных другими компиляторами. OBJ-файлы должны при этом удовлетворять определенным требованиям к используемой модели памяти и способу передачи значений. Гарантируется совместимость кодов, полученных компилятором Turbo Assembler. He должно быть проблем и с кодами от ассемблера MASM или ему подобных. Возможен импорт объектных кодов, полученных в Turbo C и других языках, но на практике он труднореализуем.

Команды подстыковки объектных файлов в программу на Турбо Паскале задаются директивами компилятора {$L ИмяФайла.OBJ}, установленными в подходящих местах программы. А те процедуры и функции, которые реализованы в этих файлах, должны быть объявлены своими заголовками и специальным словом EXTERNAL, например:

{$L memlib.obj} { включение объектного кода }

procedure MemProc1; external;

PROCEDURE MemProc2( X,Y : Byte ); EXTERNAL;

FUNCTION MemFunc1( X :Byte; VAR Y :Byte ): Word; EXTERNAL;

Подключенные таким образом внешние функции или процедуры в дальнейшем ничем не отличаются от написанных в тексте. Обычно директиву включения OBJ-файла и объявления внешних подпрограмм удобно размещать рядом. Порядок следования директивы $L и описаний заголовков может быть произвольным.

6.9.4. Процедуры и функции как параметры

Отличительной особенностью Турбо Паскаля является разрешение передавать в процедуры и функции имена других подпрограмм, оформляя их как параметры. И точно так же, как передавалось значение, может передаваться некая функция его обработки. Особенно важным это становится при программной реализации алгоритмов вычислительной математики (хотя можно назвать и ряд других областей). Например, становится возможным написать процедуру интегрирования любой функции вида f(t) по следующей

- 114 -

схеме (рис. 6.10). Неочевидным здесь может показаться только введение функционального типа и то, как он определяется.

PROCEDURE Integrate LowerLimit, UpperLimit : Real;

VAR

Result : Real;

Funct : Функциональный тип);

VAR Описание локальных переменных процедуры

t : Real;

BEGIN

Численное интегрирование по t от LowerLimit до

Upper limit функции Funct, причем для получения

значения функции при заданном аргументе t достаточно

сделать вызов Funct(t).

Результат интегрирования должен быть возвращен через

параметр-переменную Result.

END;

Рис. 6.10

Функциональный или процедурный тип (в зависимости от того что описывается) — отнюдь не тип возвращаемого значения, а тип заголовка подпрограммы в целом. Так, на рис. 6.10 параметр Func есть одноместная функция вида f(t), возвращающая вещественное значение. Класс таких функций может быть описан типом

| TYPE

RealFunctionType = function ( t : Real ) : Real;

В этом описании имя подпрограммы не ставится — оно здесь не играет роли. Но обязательно перечисляются типы параметров и, если тип описывает функцию, тип результата. Идентификаторы параметров могут быть выбраны произвольно. Основная смысловая нагрузка падает на их типы и порядок следования. Тип, к которому могла бы принадлежать процедура Integral (см. рис. 6.10), должен был бы выглядеть примерно так:

| TYPE

ProcType = procedure ( А, В : Real; VAR X : Real;

f : RealFunctionType );

а тип процедуры без параметров:

NoParamProcType = procedure;

После объявления процедурного (функционального) типа его можно использовать в описаниях параметров подпрограмм. И, ко-

- 115 -

нечно, необходимо написать те реальные процедуры и функции, которые будут передаваться как параметры. Требование к ним одно: они должны компилироваться в режиме {$F+}. Поскольку по умолчанию принят режим {$F-}, такие процедуры обрамляются парой соответствующих директив. На рис. 6.11 дан пример функции, принадлежащей введенному выше типу RealFunctionType.

| { $F+} { включение режима $F+ }

| FUNCTION SinExp ( tt : Real ) : Real;

| BEGIN

| SinExp := Sin(tt)*Exp(tt)

| END;

| {$F-} { восстановление режима по умолчанию }

Рис. 6.11

Такая функция может быть подставлена в вызов подпрограммы на рис. 6.10:

Integral( 0, 1, Res1, SinExp )

и мы получим в переменной Res1 значение интеграла в пределах [0,1]. Не всякую функцию (процедуру) можно подставить в вызов. Нельзя подставлять: во-первых, процедуры с директивами inline и interrupt (из-за особенностей их машинного представления); во-вторых, вложенные процедуры или функции; в-третьих, стандартные процедуры и функции, входящие в системные библиотеки Турбо Паскаля. Нельзя, например, взять интеграл функции синуса:

Integral(0, 1, Res2, Sin)

хотя встроенная функция Sin внешне подходит по типу параметра. Последнее ограничение легко обходится переопределением функции (рис. 6.12).

| { $F+}

| FUNCTION Sin2( X : Real ) : Real;

| BEGIN

| Sin2 := Sin( X )

| END;

| {$F-}

Рис. 6.12

- 116 -

Теперь вызов процедуры интегрирования переписывается как

Integral( 0, 1, Res2, Sin2 )

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

6.9.5. Переменные-процедуры и функции

Рассмотрим программу на рис. 6.13. В ней вводятся две переменные-процедуры P1 и P2 и демонстрируются возможные действия с ними.

| TYPE DemoProcType = procedure ( А,В : Word );

| VAR

| Р1, Р2 : DemoProcType; { переменные-процедуры} P : Pointer; { просто указатель }

| { Значения переменных-процедур : }

| {$F+}

| PROCEDURE Demo1( X,Y : Word );

| BEGIN WriteLn( 'x+y=', x+y ) END;

| PROCEDURE Demo2( X,Y : Word );

| BEGIN WriteLn( 'x-y=', x-y ) END;

| {$F-}

| BEGIN { основной блок программы }

| P1 := Demo1; { присваивание значений переменным }

| P2 := Demo2;

| P1( 1, 1 ); { то же самое, что и вызов Demo1(1,1) }

| P2( 2, 2 ); { то же самое, что и вызов Demo2(2,2) }

| { Ниже в указатель Р запишется адрес процедуры Р1: }

| DemoProcType( P ) := P1;

| DemoProcType(P)( 1, 1 ); { то же, что и вызов Р1(1,1) }

| { Так значение указателя Р передается переменной : }

| @P2 := Р;

| Р2( 2,2 ); { процедура Р2 в итоге стала равна Р1 }

| END.

Рис. 6.13

Процедурные переменные по формату совместимы с переменными типа Pointer и после приведения типов могут обмениваться с ними значениями. Для того чтобы переменная-процедура понималась как указатель на адрес подпрограммы в ОЗУ, она должна предваряться оператором @. Советуем не злоупотреблять операциями обмена значений таких переменных, тем более с приведениями типов. Програм-

- 117 -

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

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

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

TYPE

ProcType = ПроцедурныйИлиФункциональныйТип;

DemoRecType = RECORD

X,Y : Word;

Op : ProcType;

END;

VAR

Rec1,Rec2 : DemoRecType;

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

Обращаем внимание на еще одну особенность работы с процедурными переменными. Если надо убедиться, что процедуры или функции, понимаемые под двумя переменными, одинаковы, то операция сравнения запишется (для переменных Rec1.Op и Rec2.Op) как

IF @Rec1.Op = @Rec2.Op then ... ;

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

6.9.6. Специальные приемы программирования

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

- 118 -

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

| TYPE

| Vector100Type = Array[1..100] of Real; {вектор }

| MatrixType = Array[1..10,1..10] of Real; { матрица }

| Matrix2Type = Array[1..50,1..2 ] of Real; { матрица }

| VAR

| V : Vector100Туре: { область памяти на 100 элементов }

| PROCEDURE P1;

| VAR M : MatrixType absolute V; { M совмещается с V }

| BEGIN

| В процедуре возможны обращения M[ i,j ], эквивалентные

| обращениям V[(i-1)*10+j]

| END;

| PROCEDURE P2;

| VAR M2 : Matrix2Type absolute V; { M2 совмещается с V }

| BEGIN

| В процедуре возможны обращения M2[ i,j ], эквивалентные

| обращениям V(i-1)*2+j]

| END;

| PROCEDURE P3;

| VAR V3 : Vector100Type absolute V; {V3 совмещается с V}

| BEGIN

| Обращения V3[i] в процедуре эквивалентны обращениям V[i]

| END;

| BEGIN

| Основной блок, содержащий вызовы P1, P2, P3 и, может быть,

| обращения к общей переменной (области памяти) V

| END.

Рис. 6.14

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

- 119 -

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

6.9.6.2. Статические локальные переменные. Обыкновенные локальные переменные в подпрограммах всегда «забывают» свое значение в момент окончания работы соответствующей подпрограммы. А при повторном вызове стартовые значения локальных переменных совершенно случайны. И если надо сохранять от вызова к вызову какую-нибудь локальную информацию, то ни в коем случае нельзя полагаться на локальные переменные, описанные в разделах VAR процедур и функций или как параметры-значения в заголовках. Для сохранности между вызовами информация должна храниться вне подпрограммы, т.е. в виде значения глобальной переменной (переменных). Но в этом случае приходится отводить глобальные переменные, по сути, под локальные данные. Турбо Паскаль позволяет решать эту проблему, используя статические локальные переменные или, что то же самое, локальные переменные со стартовым значением. Они вводятся как типизированные константы (рис. 6.15) по тем же правилам, что и их глобальные аналоги (см. разд. 5.2.2).

| PROCEDURE XXXX( ...);

| VAR ... { обычные локальные переменные }

| CONST { статические локальные переменные }

| A : Word = 240;

| B : Real = 41.3;

| ARR : Array[-1..1] of Char=('ф', 'х', 'ц');

| BEGIN

| Тело процедуры, в котором могут изменяться значения

| A, B, Arr и других переменных

| END.

Рис. 6.15

Особенность переменных, объявленных таким образом, заключается в том, что, хотя по методу доступа они являются строго локальными, свои значения они хранят вместе с глобальными переменными (в сегменте данных). Поэтому значения переменных A, B и Arr на рис. 16.15 сохранятся неизменными до следующего вызова процедуры и после него. В них можно накапливать значения при многократных обращениях к процедурам или функциям, их можно использовать как флаги каких-либо событий и т.п.

- 120 -

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

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

PROCEDURE PDemo ( VAR V1,V2 );

FUNCTION FDemo ( A : Integer; VAR V ) : Real;

Бестиповыми могут быть только параметры-переменные (т.е. те, которые передаются как адрес, а не как значение). Объявленные выше переменные V1, V2 и V могут иметь любой тип. Через них можно передавать подпрограммам строки, массивы, записи или другие данные. Но при этом процедура или функция должна явно задавать тип, к которому внутри нее приравниваются бестиповые переменные. Рассмотрим пример функции, суммирующей N элементов произвольных одномерных числовых массивов (рис. 6.16).

| PROGRAM Demo_Sum;

| VAR

| B1 : Array [-100.. 100] of Byte;

| B2 : Array [ 0 .. 999] of Byte;

| B3 : Array [ 'a'..'z'] of Byte;

| S : String;

| {$R-} { выключаем режим проверки индексов массивов }

| FUNCTION Sum( VAR X; N : Word ) : LongInt;

| TYPE

| XType = Array [ 1..1 ] of Byte;

| VAR

| Summa : Longint; i : Word;

| BEGIN

| Summa := 0;

| for i:=1 to N do

| Summa := Summa* XType( X )[i];

| Sum := Summa

| END;

Рис. 6.16

- 121 -

| { $R+} { можно при необходимости восстановить режим }

| BEGIN

| { Заполнение каким-либо образом массивов B1, B2 и B3; }

| ...

| S := '123456789';

| { печать суммы всех значений элементов массива B1 : }

| WriteLn( Sum( B1, 201));

| { сумма элементов B2 с 100-го по 200-й включительно: }

| WriteLn( Sum( B2[100], 101));

| { сумма 10 элементов массива B3, начиная с 'b'-го : }

| WriteLn( Sum( B3['b'], 10));

| {печать суммы кодов символов строки S с '1'-го по '9'-й}

| WriteLn( Sum( S[1], 9));

| END.

Рис 6.16 (окончание)

Как видно, функция Sum не боится несовместимости типов. Но она будет корректно работать только с массивами, элементами которых являются значения типа Byte. Мы сами задали это ограничение, определив тип XType, к которому впоследствии приводим все, что передается процедуре через параметр X. Обращаем внимание на диапазон описания массива XType: 1..1. Если режим компиляции $R имеет знак минус (состояние по умолчанию), то можно обратиться к массиву с практически любым индексом i и будет получен i-й элемент, считая от первого. Мы задаем индексы 1..1 чисто в иллюстративных целях. Можно было записать

| TYPE

ХТуре = Array [ 0..65520 ] of Byte;

забронировав максимальное число элементов (описание типа без объявления переменной не влияет на потребление памяти программой). В таком случае состояние ключа компиляции $R не играет роли. Функция Sum может начать отсчитывать элементы с любого номера (см. рис. 6.16). Можно даже послать в нее строку, и ее содержимое будет принято за байты (а не символы) и тоже просуммировано. Несложно написать обратную процедуру для заполнения произвольной части различных массивов. Надо лишь, чтобы базовый тип этих массивов совпадал с тем, который вводится внутри процедуры для приведения бестипового параметра. И, конечно, вовсе не обязательно ограничиваться одними массивами. Рассмотренный пример можно распространить и на записи, и на ссылки, и на

- 122 -

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

6.9.6.4. Рекурсия. Использование рекурсии — традиционное преимущество языка Паскаль. Турбо Паскаль в полной мере позволяет строить рекурсивные алгоритмы. Под рекурсией понимается вызов функции (процедуры) из тела этой же самой функции (процедуры).

Рекурсивность часто используется в математике. Так, многие определения математических формул рекурсивны. В качестве примера можно привести формулу вычисления факториала:

и целой степени числа:

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

| FUNCTION Fact( n : Word ) : Longlnt;

| BEGIN

| if n=0

| then Fact := 1

| else Fact := n * Fact( n-1 );

| END;

и степени n числа x:

| FUNCTION IntPower( x : Real; n : Word ) : Real;

| BEGIN

| if n=0

| then IntPower := 1

| else IntPower := x * IntPower( x, n-1);

| END;

Если в функцию передаются n>0, то происходит следующее: запоминаются известные значения членов выражения в ветви ELSE (для факториала это n, для степени — x), а для вычисления неизвестных вызываются те же функции, но с «предшествующими»

- 123 -

аргументами. При этом вновь запоминаются (но в другом месте памяти!) известные значения членов и происходят вызовы. Так происходит до тех пор, пока выражение не станет полностью определенным (в наших примерах — это присваивание в ветви THEN), после чего алгоритм начинает «раскручиваться» в обратную сторону, изымая из памяти «отложенные» значения. Поскольку при этом на каждом очередном шаге все члены выражений уже будут известны, через n таких, «обратных» шагов мы получим конечный результат.

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

Зачастую внесение рекурсивности в программы придает им изящность. Но всегда оно же «заставляет» программы расходовать больше памяти. Дело в том, что каждый «отложенный» вызов функции или процедуры — это свой набор значений всех локальных переменных этой функции, размещенных в стеке. Если будет, например, 100 рекурсивных вызовов функции, то в памяти должны разместиться 100 наборов локальных переменных этой функции. В Турбо Паскале размер стека (он регулируется первым параметром директивы компилятора $M) не может превышать 64К — а это не так уж много.

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

| FUNCTION IntPower(x : Real; n : Word ) : Real;

| VAR

| i : Word; m : Real;

| BEGIN

| m : = 1;

| for i:=1 to n do

| m:=m*x;

| IntPower := m

| END;

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

Отметим, что в общем случае класс функций вида

- 124 -

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

В заключение несколько слов о работе оператора Exit в рекурсивных процедурах. Он срабатывает всегда на один «уровень» глубины рекурсии. Таким образом, выйти из рекурсивной подпрограммы до ее естественного завершения довольно непросто.

Все сказанное выше будет также верно и для так называемой косвенной рекурсии — когда подпрограмма A вызывает подпрограмму B, а в B содержится вызов A. Только расход памяти будет еще больше из-за необходимости сохранения локальных переменных B.

6.10. Модули. Структура модулей

Модуль (UNIT) в Турбо Паскале — это специальным образом оформленная библиотека определений типов, констант, переменных, а также процедур и функций. Модуль в отличие от программы не может быть запущен на выполнение самостоятельно: он может только участвовать в построении программы или другого модуля. Но в отличие от фрагментов, подключаемых к программе при компиляции директивой {$1 ИмяФайла}, модули предварительно компилируются независимо от использующей их программы. Результатом компиляции модуля является файл с расширением .TPU (Turbo Pascal Unit). Для того чтобы подключить модуль к программе (или другому модулю), необходимо и достаточно указать его имя в директиве USES.

Все системные библиотеки Турбо Паскаля реализованы как модули, и чтобы воспользоваться, например, библиотеками функций операционной системы DOS и графики Graph, нужно только указать директиву

USES

DOS, Graph;

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

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

- 125 -

построения собственных библиотек процедур и функций, которые впоследствии могут подключаться к разным программам, не требуя при этом никаких переделок. Во-вторых, именно модульность позволяет создавать программы практически любого размера. Дело в том, что ни программа, ни модуль, не могут произвести выполнимый код объемом более 64K, если они не используют при построении другие модули. В то же время сумма объемов модулей, составляющих программу, ограничена лишь объемом ОЗУ ПЭВМ, и то, если не используется оверлейная структура. Общая структура модуля приводится на рис. 6.17.

UNIT ИмяМодуля;

INTERFACE ← начало раздела объявлений

USES { используемые при объявлениях модули: }

Имя_Модуля1, Имя_Модуля2, ... ;

CONST Блок объявления библиотечных констант

TYPE Блок объявления библиотечных типов

VAR Блок объявления библиотечных переменных

Заголовки библиотечных процедур и (или) функций

IMPLEMENTATION ← начало раздела реализации

USES { используемые при реализации модули:}

Имя_Модуля101, Имя_Модуля202, ... ;

CONST Блок объявления внутренних констант

TYPE Блок объявления внутренних типов

VAR Блок объявления внутренних переменных

LABEL Блок описания меток блока инициализации

BEGIN

Блок инициализации модуля

END.

Рис. 6.17

Модуль разделяется на четыре части:

— заголовок модуля (UNIT имя);

— раздел объявлений или интерфейс (INTERFACE);

— раздел реализации (IMPLEMENTATION);

— раздел инициализации (между BEGIN и END).

Все блоки, составляющие эти разделы (см. рис. 6.17), являются необязательными, и могут отсутствовать (как могут и появляться неоднократно). Обязательные слова, входящие в модуль, продемонстрированы на рис. 6.18, где показан пустой модуль.

- 126 -

UNIT Пустой;

INTERFACE

IMPLEMENTATION

END.

Рис. 6.18

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

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

Имя модуля как идентификатор имеет до 64 значащих символов. Но имя файла на диске не может превышать длину в восемь символов! Тем не менее имя модуля не обязательно ограничивать восемью символами. Пусть их будет больше, но при этом первые восемь должны совпадать с именем файла. А в основной программе в директиве USES должно стоять полное имя, как и в заголовке самого модуля.

Раздел объявлений, начинающийся словом INTERFACE, содержит описания типов, констант и переменных, которые будут привноситься в программу при подключении модуля. В нем же описываются заголовки процедур и функций, составляющих собственно библиотеку подпрограмм. В разделе обявлений указываются только заголовки, потому что информация о содержимом подпрограмм модуля не нужна на этапе компиляции, а используется только при компоновке программы. Исключение составляют процедуры с директивой inline (см. разд. 14.7.2). Они могут целиком задаваться в разделе объявлений. Недопустимы заголовки с директивами interrupt (см. разд. 16.6) и forward.

Если при объявлении типов, данных или подпрограмм используются константы и типы, введенные в других модулях (библиотеках), то эти модули должны быть перечислены в директиве USES сразу после ключевого слова INTERFACE. В модулях директива USES может появляться дважды. Второй раз — в разделе реализации. Рекомендуется указывать в разделе объявлений только те модули, которые необходимы. Прочие лучше подсоединить в другом месте.

- 127 -

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

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

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

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

Раздел инициализации завершает текст модуля. Если он отсутствует, то просто ставится слово END с точкой после конца последнего тела подпрограммы раздела реализации. В противном случае ставится слово BEGIN, и далее программируются действия, которые будут произведены перед выполнением основной программы (работа скомпилированной программы всегда начинается с выполнения блоков инициализации используемых ею модулей, и лишь потом выполняется основной блок самой программы). Обычно в разделе инициализации происходит заполнение стартовыми значениями библиотечных переменных и какие-нибудь одноразовые действия, которые должны выполниться именно в начале программы. На рис. 6.19 приводится пример модуля с инициализацией.

6.11. Особенности работы с модулями

Порядок подключения модулей в программу, вообще говоря, существенен. Подключение модулей происходит по ходу их перечисления: слева направо. В этом же порядке срабатывают блоки инициализации. (Инициализация происходит только при работе программы. При подключении модуля к модулю инициализации не будет.) Некоторые коммерческие пакеты библиотек на Турбо Паскале, реализованные в виде модулей, требуют соблюдения определенного порядка их перечисления при подключении. Первыми обыч-

- 128 -

| UNIT Colors; { Модуль, вводящий цветовые константы }

| INTERFACE

| TYPE

| ColorType = Array[0..15] of Byte;{определено 16 цветов}

| CONST

| Black : Byte = 0; Blue : Byte = 1;

| Green : Byte = 2; Cyan : Byte = 3;

| Red : Byte = 4; Magenta : Byte = 5;

| Brown : Byte = 6; LightGray : Byte = 7;

| DarkGray : Byte = 8; LightBlue : Byte = 9;

| LightGreen : Byte = 10; LightCyan : Byte = 11;

| LightRed : Byte = 12; LightMagenta : Byte = 13;

| Yellow : Byte = 14; White : Byte = 15;

| VAR

| CurrColors: ColorType absolute Black; {текущие значения}

| PROCEDURE SetMonoColors; (настройка цветов на режим MONO}

| PROCEDURE SetColorColors; (настройка цветов в режим ЦВЕТ}

| IMPLEMENTATION

| CONST ( значения констант для режимов: }

| ColorColors : ColorType =

| (0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15);

| MonoColors : ColorType =

| (0,1,7,7,7,7,7,7,7,7, 7, 7, 7, 7,15,15);

| PROCEDURE SetMonoColors;

| BEGIN

| CurrColors := MonoColors;

| END;

| PROCEDURE SetColorColors;

| BEGIN

| CurrColors := ColorColors;

| END;

| VAR

| ch : Char;

| BEGIN

| { Запрос и настройка на соответствующий режим: }

| Write('Тип Вашего монитора(Ц-цветной, М-монохромный)?');

| ReadLn( ch ):

| if ch in ['M', 'm','М', 'м']

| then

| SetMonoColors;

| END.

| Примечание: для того чтобы модуль корректно вводил константы надо, чтобы в директиве USES программы он стоял после модуля CRT.

Рис. 6.19

- 129 -

но подключают системные модули Турбо Паскаля (из библиотеки TURBO.TPL) и лишь затем все остальные, хранящиеся в виде TPU-или даже PAS-файлов.

Порядок подключения может влиять на доступность библиотечных типов, данных и даже процедур. Например, если модули U1 и U2 описывают в разделах объявлений одноименные тип T, переменную V и процедуру P, но реализуют их по-разному, то после подключения модулей директивой

USES

U1, U2;

обращения к T, V и P будут эквивалентны обращениям к содержимому библиотеки U2. Более того, если далее в основной программе эти имена объявляются заново, то они «замещают» собой имена, относящиеся к модулю. (Заметим, что повтор идентификаторов в модулях и программе не является ошибкой, но всегда будет неверным введение одинаковых имен в пределах одного модуля или программы.) Тем не менее доступ к содержимому любого модуля всегда возможен, если перед идентификатором уточнять его местонахождение, указывая имя модуля. Так, если нам нужны T, V и P именно из модуля U1, то обращаться к ним надо, как к

U1.T, U1.V и U1.P( ... ).

Переменная V из модуля U2 должна превратиться в U2.V и т.д.

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

Другой особенностью использования модулей является решение проблемы закольцованности. Иногда может возникнуть ситуация, когда модуль U1 использует что-либо из модуля U2 и в то же время U2 обращается к процедурам модуля U1. Решение подобных проблем зависит от того, в каком разделе возникла закольцованность. Если оба модуля подключают друг друга директивой USES в разделе IMPLEMENTATION, то закольцованность автоматически разрешается компилятором Турбо Паскаля. Но если хотя бы один из модулей подключает другой в разделе INTERFACE, то разрешать противоречие придется программным путем. Проблема будет решена, если ввести третий модуль и поместить в него все те типы, переменные или подпрограммы из первых двух модулей, которые ссылаются друг на друга. После этого надо их удалить из обоих исходных модулей, а взамен подключить созданный из них третий модуль.

- 130 -

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

| UNIT Conmon;

| INTERFACE

| TYPE

| ComArrayType = Array [0..99] of LongInt;

| CONST

| MaxSize = 100;

| VAR

| ComArray : ComArrayType;

| Flag : Byte;

| {и т.п.}

| IMPLEMENTATION

| END.

Рис. 6.20

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

6.12. Система библиотечных модулей языка

В системе Турбо Паскаль определен ряд стандартных модулей TPU Они обеспечивают функции ввода-вывода, работы со строками, управления экраном дисплея, работы с принтером и т.п. В процессе работы компилятора система генерирует коды только для строк, не содержащих вызов каких-либо функций, а вместо генерации кодов для этих функций подключает (уже в процессе компоновки) соответствующий стандартный модуль. Рассмотрим назначение этих модулей подробнее:

1. SYSTEM TPU включает все стандартные процедуры и функции, которые объявлены в стандартном ANSI Паскале (Ln, Exp, Sin, Cos и т.д.), а также обеспечивает работу с командной строкой. По сути, это системная библиотека Турбо Паскаля.

2. DOS.TPU включает стандартные процедуры для работы с функциями операционной системы MS-DOS и объявления вспомогательных глобальных переменных.

3. CRT.TPU содержит библиотеку процедур, которые работают с клавиатурой и дисплеем, обеспечивая полное управление ими и получение информации об их состоянии.

- 131 -

4. PRINTER.TPU обеспечивает быстрый и легкий доступ к принтеру.

5. GRAPH.TPU дает возможность использовать более пятидесяти графических высокоуровневых процедур.

6. OVERLAY.TPU обеспечивает полную поддержку и администрирование оверлейных структур программ.

7. WIN.TPU является приложением к модулю CRT. Предоставляет новые возможности при работе с окнами.

8. TURBO3.TPU, GRAPH3.TPU обеспечивают совместимость программ, написанных на Турбо Паскале версии 3.0 и использующих его процедуры, функции и глобальные переменные. В нашей книге эти модули рассматриваться не будут.

Ряд модулей включаются в библиотеку поддержки языка Турбо Паскаль, которая именуется TURBO.TPL (Turbo Pascal Library). Состав этой библиотеки может изменяться с помощью утилиты TPUMOVER.EXE. Помните: модуль SYSTEM.TPU всегда должен быть в составе TURBO.TPL.

Подключение модулей TPU к программе осуществляется на этапе трансляции строкой примерно следующего вида:

USES

DOS, CRT, Printer;

Модуль System не надо объявлять — он включается в тело программы по умолчанию.

Многие из системных модулей вводят глобальные переменные, которые размещаются в той же области памяти (сегменте данных) что и глобальные переменные использующей модули программы. При этом уменьшается объем свободного пространства для хранения переменных (сегмент данных ограничен размером 64K). Потребление сегмента данных системными модулями показано в таблице:

Модуль -- Объем привносимых переменных

System -- 664 байт

CRT -- 20 байт

DOS -- 6 байт

Printer -- 256 байт

Overlay -- 24 байт

Graph -- 1070 байт

Turbo3 -- 256 байт

Graph3 -- 0 байт

- 132 -

Часть III. Средства языка Турбо Паскаль

Глава 7. Массивы, записи и множества в деталях

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

7.1. Массивы (Array) и работа с ними

Массив — это регулярная структура данных, объявляемая специальной конструкцией языка

Array [ диапазоны индексов ] of ТипКомпонентов

Наиболее часто массив используют для хранения значений векторов, например:

VAR

V : Array [ 1..3 ] of Real;

объявляя тем самым структуру из трех значений типа Real, проиндексированных заданным диапазоном целых чисел (V[1], V[2] и V[3]). Если индексация компонентов (элементов) массива задается числовым диапазоном, как в приведенном примере, то надо соблюдать лишь два требования: во-первых, диапазон не должен принадлежать типу LongInt, т.е. он обязан «уместиться» максимум в типе Word, a во-вторых, произведение количества компонентов массива, задаваемого диапазоном индексов, на размер компонента в байтах, не может превышать 65520 байт (почти 64K). Последнее требование является общим не только для всех массивов, но и для прочих структур данных. Таким образом, могут быть описаны массивы

- 133 -

Array [9..99] of Char; { массив из 91 элемента }

Array [-10.. 10] of LongInt; { массив из 21 элемента }

Это очень удобно, так как позволяет не заботиться о приведении индексов к диапазону 1..N, как, например, приходится поступать при работе с Фортраном или некоторыми версиями Бейсика.

В общем случае ничто не обязывает объявлять диапазон индексов массива числами. В качестве индексов можно использовать любые перечислимые типы, как встроенные, так и вводимые. Индексы могут задаваться по-прежнему диапазоном, а если диапазон соответствует всему типу, то можно вместо него просто записать имя этого перечислимого типа:

TYPE

Monthtype = ( January, February, March, April, May );

ComplectType = Array [ MonthType ] of Word;

SpringType = Array [ March..May ] of Word;

VAR

Complect : ComplectType; { пять элементов типа Word }

Spring : SpringType; { три элемента типа Word }

Alpha : Array [ 'A'..'z'] of Char;

Switch : Array [Boolean] of Byte; { два элемента }

Элементы массивов будут индексироваться значениями заданных перечислимых типов или их диапазонов: Complect [January] — первый, a Spring[May] — последний элементы в своих массивах; аналогичен смысл обращений Alpha [ 'А' ] и Switch [True].

Рассмотренные массивы — одномерные, т.е. такие, у которых компоненты — скаляры. Разрешено объявлять массивы массивов:

TYPE

VectorType = Array [ 1..3 ] of Real; { вектор }

MatrixType = Array [ 1..10] of VectorType; { матрица10x3 }

Описание типа двумерного массива MatrixType могло быть записано по-другому:

TYPE

MatrixType = Array [ 1..10] of Array [ 1..3 ] of Real;

или как

MatrixType = Array [ 1..10, 1..3 ] of Real;

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

- 134 -

Каждое измерение совершенно не зависит от остальных, и можно объявлять массивы с разными индексами:

VAR

M : Array [ -10..0, 'A'..'C', Boolean ] of Byte;

Эквивалентная запись:

M : Array [-10..0] of

Array [ 'A'..'C' ] of

Array [Boolean] of Byte;

Интересно, что тип элемента массива M зависит от числа указанных при нем индексов. Так,

M[0] — массив-матрица типа Array['A'..'C',Boolean] of Byte,

М[0, 'B'] — вектор типа Array[Boolean] of Byte,

M[0, 'B', False] — значение типа Byte.

Если будут использоваться различные уровни «детализации» многомерных массивов, то надо будет позаботиться о совместимости по типу. Так, при приведенном выше описании массива M нельзя реально поставить подмассив M[0] в оператор присваивания, так как это не по правилам совместимости. Надо переписать объявление типа примерно так:

TYPE

ArrayBType = Array[Boolean] of Byte;

ArrayCType = Array ['A'..'C' ] of ArrayBType;

ArrayMType = Array [-10..0] of ArrayCType;

VAR

B : ArrayBType;

C : ArrayCType;

M : ArrayMType;

и лишь после этого будут разрешены присваивания вида

M[ -1 ] := C;

B := M[ -1, 'A' ];

Подобные вопросы совместимости можно обойти, используя приведение типов, а также специальную процедуру Move Турбо Паскаля, но это будет не повышением эффективности программы, а скорее свидетельством непродуманного объявления типов в ней.

Турбо Паскаль позволяет записывать индексы не через запятую, а как бы изолировано:

M[ -3, 'B', True ] эквивалентно M[ -3 ][ 'B' ][ True ]

- 135 -

Компонентом массива может быть не только другой массив, но и запись, и указатель, и какой-либо другой тип. Если R — массив записей (RECORD), то доступ к полю каждой записи производится после указания индекса:

R[ i ].ПолеЗаписи

В памяти ПЭВМ массивы хранятся как сплошные последовательности компонентов, причем быстрее всего изменяется самый «дальний» индекс, если их несколько. В примере задания стартового значения многомерному массиву (см. разд. 5.2.2) порядок перечисления элементов (без учета скобок) соответствует порядку размещения значений в памяти. Адрес начала массива в памяти соответствует адресу его первого элемента (элемента с минимальными значениями индексов).

Турбо Паскаль имеет специальный режим компиляции, задаваемый ключом $R. Если вся программа или фрагмент ее компилировался в режиме {$R+}, то при обращении к элементам массивов будет проверяться принадлежность значения индекса объявленному диапазону, и в случае нарушения границ диапазона программа прервется с выдачей ошибки 201 (Range check Error). Напротив, в режиме {$R-} никаких проверок не производится, и некорректное значение индекса извлечет «как ни в чем не бывало» какое-нибудь значение — но, увы, не принадлежащее данному массиву. Обычно программу отлаживают в режимах $R+, а эксплуатируют при режиме $R-. Это несколько уменьшает размер ЕХЕ-файла и время его выполнения.

К двум совместимым массивам A и B применима только операция присваивания:

A := B;

которая копирует поэлементно массив B в массив A.

Всевозможные математические действия над массивами (матрицами) необходимо реализовывать самим или использовать специальные библиотеки (например, Turbo Numeric Toolbox).

Для совместимости с другими версиями Паскаля Турбо Паскаль допускает использование составных символов (. и .) вместо квадратных скобок:

M[ 0 ] эквивалентно M(. 0 .)

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

- 136 -

VAR

X : PACKED Array [ 1..100 ] of Real;

В Турбо Паскале данные и так хранятся максимально плотно, и слово PACKED практически игнорируется. Мы рекомендуем избегать его включения в тексты программ.

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

7.2. Тип «запись» (Record) и оператор присоединения With

Для компактного представления комбинаций разнотипных данных их можно объединять в структуры-записи. Каждая запись состоит из объявленного числа полей. Тип «запись» определяется конструкцией

RECORD

Поле1 : ТипПоля1;

Поле2 : ТипПоля2;

...

ПолеN : ТипПоляN

END;

Если тип нескольких полей совпадает, то имена полей могут быть просто перечислены, например:

| TYPE

| PointRecType = RECORD

| x,y : Integer

| END;

После объявления в программе переменной типа «запись»

| VAR

| Point : PointRecType;

к каждому ее полю можно обратиться, указав сначала идентификатор переменной-записи, а затем через точку — имя поля: Point.x и Point.y — значения полей записи (но просто Point — уже комбинация двух значений).

- 137 -

Независимо от количества объявленных переменных данного типа, поля каждой из них будут называться одинаково, как они названы в описании типа. Поскольку имена полей «скрыты» внутри типа, они могут дублировать «внешние» переменные и поля в других описаниях записей, например:

| TYPE

| PointRecType = RECORD

| X,Y : Integer

| END;

| ColorPointRecType = RECORD

| X,Y : Integer; Color:Word

| END;

| VAR

| X, Y : Integer;

| Point : PointRecType;

| ColorPoint : ColorPointRecType;

В программе X, PointX и ColorPoint.X — совершенно разные значения. Поле записи может иметь практически любой тип (массив, другая запись, множество). Доступ к вложенным элементам таких структур осуществляется по тем же правилам, что и обычно:

Переменная_СложнаяЗапись.ЕеПоле_Запись.ПолеПоляЗаписи

или

Переменная_С_полем_массивом.ПолеМассив[i]

Порядок описания полей в определении записи задает их порядок хранения в памяти. Так, значения полей переменной ColorPoint хранятся как шесть последовательных байтов:

2 ( это X, тип Integer) + 2 ( Y, тип Integer) + 2 (для Color типа Word).

Запись может иметь вариантную часть. Это означает, что можно задать в пределах одного типа несколько различных структур. Непосредственный выбор структуры будет определяться контекстом или каким-либо сигнальным значением. Вариантные поля указываются после того, как перечислены поля фиксированные. Вариантные поля и оформляются особым образом. Рассмотрим пример описания типа VRecType — записи с вариантами.

| TYPE

| VRecType = RECORD { тип записи с вариантами }

| Number : Byte; { номер измерения длины }

| case Measure : Char of { признак единицы длины }

| 'д','Д' (inches : Word); {длина в дюймах}

| 'с','С' (cantimeters : LongInt); { длина в см }

| '?' (Comment1, Comment2 : String[16]) { тексты }

| END;

- 138 -

В данном случае в записи имеется обычное фиксированное поле Number. Другое фиксированное поле — Measure. Оно всегда присутствует в структуре записи, но параллельно с этим выполняет роль селектора (иногда его называют полем тега от английского «Tag Field»). Поле-селектор обрамляется словами CASE и OF, и за ним следует перечисление вариантов третьего поля, взятых в круглые скобки. Какой именно вариант поля будет принят при работе с записью, обозначается содержимым селектора (Measure в приведенном примере). Значения селектора, указывающие на тот или иной вариант, записываются перед соответствующими вариантами (аналогично тому, как это происходит в операторе выбора CASE). Пусть объявлена переменная VRec типа VRecType. В зависимости от содержимого поля-селектора Measure будут корректно работать поля записи, показанные в табл. 7.1.

Таблица 7.1

Measure =

'д' или 'Д'

'с' или 'С'

'?'

прочие

Поля Vrec, к которым обращение будет корректным.

Number

Measure

inches

Number

Measure

cantimeters

Number

Measure

Comment1

Comment2

Number

Measure

Важно понимать, что в любое время доступны поля только одного из всех возможных вариантов, описанных в типе (или ни одно из них). Все варианты располагаются в одном и том же месте памяти при хранении, а размер этого места определяется самым объемным из вариантов. Так, запись типа VRecType будет храниться как 36 байт (1 байт — Number, 1 байт — Measure и 2*(16+1) байт на самый длинный вариант — с типом поля String[16]) независимо от выбора варианта.

Следствием такого способа хранения вариантов является опасность наложения значений при неправильных действиях с записями:

| VAR

| VRec : VRecType;

| BEGIN

| VRec.Measure := 'Д'; { выбираем дюймы }

| VRec.Inches := 32; { запишем 32 дюйма }

{ Теперь, не изменяя значения поля Comment1, опросим его: }

| WriteLn(VRec.Comment1);

| WriteLn(VRec.Comment1);

| END.

- 139 -

Результатом будет печать значения числа 32 в формате String. Подобные ошибки никак не диагностируются, и вся ответственность ложится на программиста. Хуже того, поле-селектор — не более чем указание, какое поле соответствует его значению. Можно, игнорируя поле-селектора, обращаться к любому из полей-вариантов. Но поскольку значение для всех вариантов одно, оно будет трактоваться по-разному согласно типу каждого поля.

Несмотря на подобные неприятности, использование записей с вариантами и полем-селектором иногда очень удобно (если, конечно, не ошибаться). Например, если есть набор изделий с параметрами в различных системах измерения, то его можно представить в программе как массив записей с типом, подобным VRecType. Корректно заполнив поле каждой записи в массиве, мы можем потом легко опрашивать их: сначала значение поля селектора, а затем в зависимости от его значения один из вариантов хранения длины или комментария, например для массива AVRec из 100 записей типа VRecType:

| for i:=1 to 100 do

| case AVRec[i].Measure of

| 'д','Д' :WriteLn('Длина в дюймах ', AVRec[i].inches);

| 'с','С' :WriteLn('Длина в см ', AVRec[i].cantimeters);

| '?' :WriteLn('Нет данных из-за', AVRec[i].Comment1);

| end; {case}

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

| TYPE

| VRecType = RECORD { тип записи с вариантами }

| Number : Byte; { номер измерения длины )

| case Byte of { признак единицы длины }

| 1 : (inches : Word); { длина в дюймах}

| 2 : (cantimeters : LongInt); { длина в см }

| 3 : (Comment1, Comment2 : String[16]) { тексты }

| END;

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

- 140 -

типа — чистая условность. Они могут быть любыми, но только не повторяющимися. Обычно для двух вариантов в CASE вписывают тип Boolean (значения True и False), для большего числа вариантов — любой целочисленный тип.

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

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

| TYPE

| CharArrayType = Array [1..4] of Char;

| VAR

| V4 : RECORD

| case Boolean of

| True : ( С : CharArrayType );

| False : ( B1, B2, B3, B4 : Byte );

| END;

Размер переменной V4 — четыре байта (оба варианта равны). Обращение к V4.C — это обращение к массиву из четырех символов к V4.C[1] — к первому элементу этого массива. Но одновременно можно обратиться и к ASCII-кодам элементов V4.C[1], V4.C[2], .... V4.C[4], используя поля V4.B1, V4.B2 V4.B4.

Переменная типа «запись» может участвовать только в операциях присваивания. Но поле записи может принимать участие во всех операциях, применимых к типу этого поля. Для облегчения работы с полями записей в языке вводится оператор присоединения. Его синтаксис таков:

WITH ИмяПеременной_Записи DO Оператор;

Внутри оператора (он может быть и составным) обращение к полям записи уже производится без указания идентификатора самой переменной:

| VAR

| DemoRec : RECORD X,Y : Integer END;

| ...

| WITH DemoRec DO

| BEGIN

| X:=0; Y:=120

| END; {with}

Внутри области действия оператора WITH могут указываться и

- 141 -

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

| PROGRAM MAIN;

| VAR

| X, Y : Integer;

| RecXY : RECORD X,Y: Integer END;

| BEGIN

| X:=10; Y:=20; { значения переменных X и Y }

| WITH RecXY DO BEGIN { работаем с записью RecXY }

| X := 3.14*X; { Где какой X и Y ? }

| Y := 3.14*Y

| END; {with}

| ...

| END.

Рис. 7.1

На рис. 7.1 действия внутри оператора WITH проводятся только над полями записи RecXY. Чтобы сохранить оператор WITH и «развязать» имена X и Y, надо к переменным X и Y приписать так называемый квалификатор — имя программы или модуля (UNIT), в которой они объявлены (для этого программа должна иметь заголовок). Так, оператор присоединения с рис. 7.1 можно исправить следующим образом:

| WITH RecXY DO

| BEGIN

| X := 3.14*Main.X;

| Y := 3.14*Main.Y

| END;

и проблема исчезнет.

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

WITH ИмяЗаписи, Поле_3апись Do

BEGIN

Обращения к именам полей Поля_3аписи,

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

ИмяЗаписи.Поле_3апись.

END; {with}

- 142 -

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

7.3. Тип «множество» (Set). Операции с множествами

Турбо Паскаль поддерживает все основные операции с множествами. Множество, если оно не является пустым, всегда содержит что-то, и говоря «множество», необходимо указывать — «чего?». В Паскале множества определяются как наборы значений из некоего скалярного (перечислимого) типа. Скалярные типы — Byte и Char вводятся языком, они — перечислимые (их элементы можно поштучно назвать) и могут служить основой для построения множеств. Если же их станет мало, то всегда можно ввести свой скалярный тип, например:

TYPE

VideoAdapterType = (MDA, Hercules, AGA, CGA, MCGA, EGA, VGA, Other, NotDetected);

и использовать переменную

VAR

VideoAdapter : VideoAdapterType;

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

В описании множества как типа используется конструкция Set of и следующее за ней указание базового типа, т.е. того скалярного типа, из элементов которого составлено множество. Способов задания множеств несколько:

TYPE

SetOfChar = Set of Char; { множество из символов }

SetOfByte = Set of Byte; { множество из чисел }

SetOfVideo = Set of VideoAdapterType;

{ множество из названий видеоадаптеров }

SetOfDigit = Set of 0..9;

{ множество из чисел от 0 до 9 }

SetOfDChar = Set of '0'..'9';

{ множество из символов '0','1',...,'9'}

SetOfVA = Set of CGA..VGA;

{ подмножество названий видеоадаптеров }

- 143 -

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

Если перечислимый тип вводится только для подстановки его имени в Set of, то можно на нем сэкономить и перечислить значения сразу в конструкции Set of. Не забудьте круглые скобки!

TYPE

SetOfVideo = Set of (MDA, Hercules, AGA, CGA, MCGA,

EGA, VGA, Other, NоtDetected);

SetOfGlasn = Set of ('А', 'И', 'О', 'У', 'Э');

Можно опустить фазу описания типа в разделе TYPE и сразу задавать его в разделе описания переменных:

VAR

V1 : Set of ...

В Турбо Паскале разрешено определять множества, состоящие не более чем из 256 элементов. Столько же элементов содержат типы Byte и Char, и это же число является ограничением количества элементов в любом другом перечислимом базовом типе множества, задаваемом программистом. Каждый элемент множества имеет сопоставимый номер. Для типа Byte номер равен значению числа, в типе Char номером символа является его ASCII-код. Всегда нумерация идет от 0 до 255. По этой причине не являются базовыми для множеств типы ShortInt, Word, Integer, LongInt.

Множества имеют весьма компактное машинное представление: 1 — элемент расходует 1 бит. Поэтому для хранения 256 элементов достаточно 32 байт (для меньшего диапазона значений множеств цифра будет еще меньше).

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

SByte := [1, 2, 3, 4, 10, 20, 30, 40];

SChar := ['а', 'б','в'];

SChar := ['г'];

SVideo = [ CGA, AGA, MCGA];

SDiap := [1..4]; {то же, что [1, 2, 3, 4]}

SComp := [1..4, 5, 7, 10..20];

SCharS := ['а..п', 'р..я']; Empty := [];

Пустое множество записывается как [].

- 144 -

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

SetVar := ['а', 'б', 'а', 'а'];

эквивалентно однократному его упоминанию.

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

VAR

X : Byte; S : Set of Byte;

...

X := 3;

S := [ 1, 2, X ];

S := S + [ X+1 ]; {и т.п. }

Операции, применимые к множествам, сведены в табл. 7.2.

Таблица 7.2

Название

Форма

Комментарий

=

Проверка на равенство

S1=S2

Результатом будет логическое равенство значение, равное True, если S1 и S2 состоят из одинаковых элементов независимо от порядка следования, и False в противном случае

<>

Проверка на неравенство

S1<>S2

Результатом будет логическое неравенство значение, равное True, если S1 и S2 отличаются хотя бы одним элементом, False в противном случае

<=

Проверка на подмножество

S1<=S2

Результатом будет логическое подмножество значение, равное True, если все элементы S1 содержатся и в S2 независимо от их порядка следования, и равное False в противном случае

>=

Проверка на надмножество

S1>=S2

Результатом будет логическое надмножество значение, равное True, если все элементы S2 содержатся в S1 , и False в противном случае

- 145 -

in

Проверка вхождения элемента в множество

E in [...] E in S1

Результатом будет логическое значение True, если значение E принадлежит базовому типу множества и входит в множество [ ... ] (S1). Если множество не содержит в себе значения E, то результатом будет False

+

Объединение множеств

S1+S2

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

-

Разность множеств

S1-S2

Результатом операции взятия разности S1-S2 будет множество, составленное из элементов, входящих в S1, но не входящих в S2

*

Пересечение множеств

S1*S2

Результатом пересечения будет множеств множество, состоящее только из тех элементов S1 и S2, которые содержатся одновременно и в S1, и в S2

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

Операции сопоставления всегда двухместные. Результатом операции сопоставления будет логическое значение True или False. В этом смысле они близки операциям сравнения. Рассмотрим некоторые примеры сопоставлений (в них X — обозначение переменной базового типа множества, a S — обозначение некоего непустого сопоставимого множества) (рис. 7.2).

Операция проверки вхождения в множество in бывает очень полезна при проверке попадания в диапазоны перечислимых типов:

if Ch in ['а', 'х', 'А', 'Х'] then ...

if J in [ 100..200 ] then ...

В подобных конструкциях можно указывать множество-константу

- 146 -

ИСТИННО

ЛОЖНО

[ 1, 2, 3] = [ 1, 3, 2]

[ 5, X ] = [ X, 5 ]

[] = []

[ 1, 2 ] <> [ 1 ]

[ 5, X ] <> [ 5, Х+1 ]

['a','b'] <= [ 'a'..'z' ]

[] >= S

[X, Х+1] >= [ Х+1 ]

5 in [0..5]

[] in [0..5]

[ 1, 2 ] = [1]

[ 5, X ] = 5, Х+1 ]

[] = [1]

[ 1, 2, 3] <> [1, 3, 2]

[ 5, X ] <> X, 5 ]

['0'..'9']<=[a]…[z]

[]>=S

[1..3]>=[0..4]

X in [X-1, X-2]

X in []

Рис. 7.2

справа от оператора in, не вводя промежуточных описаний переменных-множеств .

Вторая группа операций над множествами реализует математические действия над ними: объединение (сумма), разность (дополнение) и пересечение множеств. Результатом операций всегда будет множество. В табл. 7.2 указаны два множества в записи, но их может быть и больше. Некоторые примеры операций приведены на рис. 7.3. Операции объединения и пересечения не зависят от мест операндов, но

[1, 2, 3, 4, 4 ] + [ 3, 4, 4, 5, 6] даст [1, 2, 3, 4, 5, 6] ([1..6])

[ '1', '2' ] + [ '8', '9' ] даст [ '1', '2', '8', '9' ]

[ X ] + [] даст [X]

[ X ] + [ Х+1 ] + [ Х+2 ] даст [ X .. Х+2 ]

[ 1, 2, 3, 4, 4] - [3, 4, 4, 5, 6] даст [ 1, 2 ]

[ '1', '2' ] - ['8', '9'] даст [ '1', '2' ]

[ X ]-[] даст [ X ]

[] - [ X ] даст []

[ 1, 2, 3, 4, 4 ] * [3, 4, 4, 5, 6] даст [ 3, 4 ]

[ '1', '2'] * [ '8', '9' ] даст []

[ X ] * [] даст []

[ A ] * [ A, B ] * [ A, B, С ] даст [ А ]

Рис. 7.3

- 147 -

результат операции дополнения чувствителен к порядку следования, и S1-S2 не будет в общем случае равно S2-S1. Поэтому результат выражений типа S1-S2-S3 будет зависеть от порядка вычислений (слева направо или наоборот), устанавливаемых компилятором. Обычно принято вычислять слева направо, но лучше не закладывать так явно в программу особенности компиляторов, в том числе не искать «многоместных» разностей. Их лучше вычислять через промежуточные переменные.

Достоинства множеств очевидны: гибкость представления наборов значений (правда, ограниченных типов и размеров), удобство их анализа. Механизм работы с множествами Турбо Паскаля соответствует базовым математическим действиям с конечными множествами. Значения типа «множество» очень компактно кодируются, и множество из 256 элементов займет всего лишь 32 байта. Множества хорошо работают там, где нужно проводить анализ однотипных выборок значений или накапливать произвольно поступающие значения.

Недостатки множеств — это обратная сторона их достоинств. За компактность представления приходится платить невозможностью вывода множеств на экран, хотя отладчик это проделывает. Причем, эта проблема трудноразрешима, ибо отсутствует механизм изъятия элемента из множества. Довод, что и в математике такое действие не определено, малоутешителен. Можно только убедиться в его наличии в множестве. Ввод множеств возможен только по элементам, как на рис. 7.4.

| VAR

| S : Set of Char; { переменная-множество }

| C : Char; { элемент множества }

| BEGIN

| S := []; С := #0; { обнуление значений }

| while C<> '.' do begin

| { цикл до ввода '.' : }

| ReadLn( C ); { чтение символа в C и }

| S := S + [ С ] { добавление его к S }

| end; {while}

| S := S - [ '.' ] { можно выбросить точку }

| ...

| END.

Рис. 7.4

Несмотря на эти недостатки, множества — удобный инструмент обработки данных и оптимальный для некоторых приложений способ хранения данных.

- 148 -

Глава 8. Обработка символов и строк

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

8.1. Символьный и строковый типы (Char и String)

Язык Турбо Паскаль поддерживает стандартный символьный тип Char и, кроме того, динамические строки, описываемые типом String или String[ n ].

Значение типа Char — это непустой символ из алфавита ПЭВМ, заключенный в одинарные кавычки, например, ' ', 'А', '7' и т.п. Кроме этой, классической, формы записи символов, Турбо Паскаль вводит еще две. Одна из них — представление символа его кодом ASCII с помощью специального префикса # :

#97 = Chr(97) = 'а' (символ 'а'),

#0 = Chr(0) (нулевой символ),

#32 = Chr(32) = ' ' (пробел).

Символы, имеющие коды от 1 до 31 (управляющие), могут быть представлены их «клавиатурными» обозначениями — значком «^» и буквой алфавита с тем же номером (для диапазона кодов 1...26) или служебным знаком (для диапазона 27...31):

^A = #1 = Chr(1) – код 1,

^B = #2 = Chr( 2) – код 2,

...

^ = #26 = Chr(26) – код 26.

^[ = #27 = Chr(27) – код 27,

…

^_ = #31 = Chr(31) – код 31,

в том числе ^G — звонок (7), ^I — TAB (код 9), ^J — LF (код 10), ^M — CR (код 13) и т.п.

Рассмотрим более подробно строковый тип. Максимальная длина строки составляет 255 символов. Строки называются динамическими, поскольку могут иметь различные длины в пределах объявленных границ. Например, введя переменные

- 149 -

VAR

S32 : String[ 32];

S255 : String[255];

мы можем хранить в S32 строчные значения, длиной не более 32 символов, а в S255 — не более 255. Описание String без указания длины отводит место, как и описание String[255].

Тип String без длины является базовым строковым типом, и он совместим со всеми производными строковыми типами.

При попытке записать в переменную строку длиннее, чем объявлено в описании, «лишняя» часть будет отсечена. Можно присваивать пустые строки. Их обозначение (две одинарные кавычки подряд).

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

'abcde-абвгд'

'123 ? 321'

' '

''''

Последняя конструкция есть строка из одной одинарной кавычки.

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

^G 'После сигнала нажмите '^J' клавишу пробела '^M^J

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

Более общим способом включения символов (любых) в строку является их запись по ASCII-коду через префикс #. Механизм включения в строку остался тем же:

'Номер п/п'#179' Ф.И.О. '#179' Должность '#179

#7#32#179#32#32#179 (то же, что ^G'| |')

Строки различных длин совместимы между собой в операторах присваивания и сравнения, но «капризно» ведут себя при передаче в процедуры и функции. Если тип объявленного строкового параметра в процедуре или функции является производным от типа String, то при вызове процедуры или обращении к функции тип передаваемой строки должен совпадать с типом параметра. Имеется ключ компилятора $V, управляющий режимом проверки типов соответствующих формальных и фактических параметров-строк. В режиме {$V+} такая проверка проводится и при несогласованности типов выдает сообщение об ошибке. Но если отключить ее, то можно подстав-

- 150 -

лять в вызовы процедур и функций фактические параметры, имеющие другой, отличающийся от формальных, производный от String тип. При этом во время работы программы могут возникнуть наложения значений одних строк на другие и путаница в значениях. Для того чтобы писать процедуры, работающие со строками любых строковых типов, нужно описывать формальные параметры исключительно типом String и компилировать программу в режиме {$V-}. Это даст процедурам и функциям гибкость и безопасность данных.

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

FUNCTION Xstr( S : String[32] ) : String[6];

совершенно неправильно. Корректно оно выглядит таким образом:

TYPE

String32 = String[32];

String6 = String[6];

...

FUNCTION Xstr( S : String32 ) : String6;

Можно, вообще говоря, рассматривать строки как массив символов. Турбо Паскаль разрешает такую трактовку, и любой символ в строке можно изъять по его номеру (рис. 8.1).

| VAR

| i : Byte;

| S : String[20];

| BEGIN

| S := 'Массив символов.....';

| for i:=1 to 20 do WriteLn( S[i]);

| ReadLn {Пауза до нажатия клавиши ввода}

| END.

Рис. 8.1

Отдельный символ совместим по типу со значением Char. Иными словами, можно совершать присваивания, представленные на рис. 8.2.

Каждая строка всегда «знает», сколько символов в ней содержится в данный момент. Символ S[0] содержит код, равный числу символов в значении S, т.е. длина строки S всегда равна Ord(S[0]). Эту особенность надо помнить при заполнении длинных строк

- 151 -

| VAR

| ch : Char;

| st : String;

| BEGIN

| st := 'Hello';

| ch := st[1]; { ch = H }

| st[2] := 'E'; { st = 'HEllo' }

| ch := 'x';

| st := ch; { st = 'x' }

| END.

Рис. 8.2

одинаковым символом. В самом деле, не писать же в программе S := '... и далее, например, 80 пробелов в кавычках! Проблему заполнения решает встроенная процедура FillChar:

VAR St : String;

...

FillChar( St[1], 80, ' ' );

St[0] := Chr(80); {!!!}

Здесь St[1] указывает, что надо заполнять строку с первого элемента. Можно начать заполнение и с любого другого элемента. В данном случае строка заполняется с начала 80 пробелами (' ' или #32). Очень важен последующий оператор: так как строка «закрашивается» принудительно, ей надо сообщить, сколько символов в ней стало, т.е. записать в St[0] символ с кодом, равным ее новой длине.

Первоначально строка содержит «мусор», и всегда рекомендуется перед использованием инициализировать строки пустыми значениями или чем-либо еще.

При использовании процедуры FillChar всегда есть риск «выскочить» за пределы, отводимые данной строке, и заполнять символом рабочую память данных. Компилятор таких ошибок не замечает, и вся ответственность ложится на программиста.

8.2. Операции над символами

Символы можно лишь присваивать и сравнивать друг с другом. При сравнении символов они считаются равными, если равны их ASCII-коды; и один символ больше другого, если имеет больший ASCII-код:

Символы можно лишь присваивать и сравнивать друг с другом. При сравнении символов они считаются равными, если равны их ASCII-коды; и один символ больше другого, если имеет больший ASCII-код:

- 152 -

'R' = 'R'

'r' > 'R' (код 114 > кода 82)

Операции сравнения записываются традиционным способом:

<, <=, =, >=, >, <>.

Каждый символ можно рассматривать как элемент множества Set of Char и применять к нему операцию проверки на включение in:

Var Ch : Char;

. . .

ch := 'a';

if Ch in ['a'..'z'] then . . .

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

Таблица 8.1

Функция : Тип

Назначение

Chr( X : Byte) : Char

Возвращает символ ASCII - кода X

Ord( C:Char) : Byte

Возвращает ASCII — код символа C

Pred( C : Char) : Char

Выдает предшествующий C символ

Succ( C : Char) : Char

Выдает последующий за С символ

UpCase(C : Char) : Char

Переводит символы 'a'..'z' в верхний регистр 'A'..'Z'

Функции Succ и Pred хороши для последовательного перебора символов. Следует только помнить, что не определены значения Succ(#255) и Pred(#0).

Функция UpCase переводит в верхний регистр символы латинского алфавита, возвращая все остальные, в том числе и кириллицу, в исходном виде.

8.3. Операции над строками

Строки можно присваивать, сливать и сравнивать. Слияние строк записывается в естественном виде (рис. 8.3). Если сумма получается длиннее, чем описанная длина левой части оператора присваивания, излишек отсекается.

Сравнение строк происходит посимвольно, начиная от первого символа в строке. Строки равны, если имеют одинаковую длину и посимвольно эквивалентны:

- 153 -

| VAR

| S1, S2, S3 : String;

| BEGIN

| S1 := 'Вам ';

| S2 := 'привет';

| S3 := S1 + S2; { S3 = 'Вам привет' }

| S3 := S3 + ' !'; { S3 = 'Вам привет !' }

| END.

Рис. 8.3

'abcd' = 'abcd' --> TRUE,

'abcd' <> 'abcde' --> TRUE,

'abcd' <> ' abcd' --> TRUE.

Если при посимвольном сравнении окажется, что один символ больше другого (его код больше), то строка, его содержащая, тоже считается большей. Остатки строк и их длины не играют роли. Любой символ всегда больше «пустого места»:

'abcd' > 'abcD' ( так как 'd'>'D' ),

'abcd' > 'abc ' ( так как 'd'>' ' ),

'aBcd' < 'ab' ( так как 'B'<'b' ),

' ' > '' ( так как #32 > '' ).

Можно, конечно, использовать нестрогие отношения: >= и <=.

Для работы со строками реализовано большое количество процедур и функций (табл. 8.2):

Таблица 8.2

Процедуры и функции

Назначение

РЕДАКТИРОВАНИЕ СТРОК

Length(S:String) : Byte

Выдает текущую длину строки

Concat(S1, S2,…,Sn) : String

Возвращает конкатенацию или слияние строк S1 … Sn

Copy(S:String ; Start, Len : Integer) : String

Возвращает подстроку длиной Len, начинающуюся с позиции Start строки S

Delete(Var S : String; Start, Len : Integer)

Удаляет из S подстроку длиной Len, начинающуюся с позиции Start строки S

- 154 -

Insert(VAR S : String; SubS: String; Start: Integer)

Вставляет в S подстроку SubS, начиная с позиции Start

Pos(SubS, S : String) : Byte

Ищет вхождение подстроки SubS в строке S и возвращает номер первого символа SubS в S или 0, если S не содержит SubS

ПРОЦЕДУРЫ ПРЕОБРАЗОВАНИЯ

Str(X[ :F[:n]]; VAR S : String)

Преобразует числовое значение X в строковое S. Возможно задание формата для X

Val( S : String; VAR X; VAR ErrCode : Integer)

Преобразует строковое значение S (строку цифр) в значение числовой переменной X

8.3.1. Редактирование строк

Функция Length(S : String) возвращает текущую длину строки S. Вообще говоря, можно вместо нее пользоваться конструкцией Ord( S[0] ), что то же самое.

Функция Concat производит слияние переданных в нее строк. Вместо нее всегда можно пользоваться операцией «+»:

S3 := Concat( S1,S2 ); { то же, что S3 := S1 + S2 }

S3 := Concat( S3,S1,S2 ); { то же, что S3 := S3 + S1 + S2 }

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

8.3.1.3. Функция Сору(S : String; Start, Len : Integer) позволяет выделить из строки последовательность из Len символов, начиная с символа Start. Если Start больше длины всей строки S, то функция вернет пустую строку, а если Len больше, чем число символов от Start до конца строки S, то вернется остаток строки S от Start до конца. Например:

SCopy = Сору( 'АВС***123', 4, 3 ) { SСору='***' }

SCopy = Copy( 'ABC', 4, 3 ) { SCopy=' '}

SCopy = Copy( 'ABC***123', 4,11 ) { SCopy='***123' }

- 155 -

Используя процедуру Copy, построим игровой пример появления строки на экране (рис. 8.4).

| USES CRT; { используется модуль CRT }

| { Процедура выводит строку S в позиции (X,Y), }

| { с эффектом раздвижения и звуковым сигналом. }

| PROCEDURE ExplodeString(X,Y: Byte; S: String; С: Word );

| VAR

| i,L2 : Byte;

| BEGIN

| L2 := (Length(S) div 2 ) + 1; { середина строки }

| if X < L2 then

| X:=L2; { настройка X }

| for i:=0 to L2-1 do

| begin { цикл вывода: }

| GotoXY( X-i, Y ); { начало строки }

| { Вывод расширяющейся центральной части строки: }

| Write( Copy( S, L2-i, 2*i+1 ));

| Sound(i*50); { подача звука }

| Delay(С); { задержка С мс }

| NoSound { отмена звука }

| end { конец цикла }

| END;

| { ========= ПРИМЕР ИСПОЛЬЗОВАНИЯ ПРОЦЕДУРЫ ======== }

| BEGIN

| ClrScr; { очистка экрана }

| ExplodeString( 40, 12, '12345678900987654321', 30);

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 8.4

8.3.1.4. Процедура Delete( VAR S : String; Start, Len : Integer ) видоизменяет сроку S, стирая Len символов, начиная с символа с номером Start:

S := 'СТРОКА';

Delete(S, 2, 4); {S='CA'}

После стирания подстроки ее оставшиеся части как бы склеиваются.

Если Start=0 или превышает длину строки S, то строка не изменится. Также не изменит строку значение Len=0. При Len, большем чем остаток строки, будет удалена подстрока от Start и до конца S. Это можно использовать при «подрезании» строк до заданной величины:

- 156 -

Delete( S, 16, 255)

Здесь строки S длиною менее 17 символов пройдут через процедуру неизменными, а все остальные будут укорочены до длины в 16 символов.

8.3.1.5. Процедура Insert( Subs : String; VAR S : String; Start: Integer) выполняет работу, противоположную той, что делает Delete. Insert вставляет подстроку Subs в строку S, начиная с позиции Start:

S: = 'Начало-конец';

Insert( 'середина-', S, 8 );

{ теперь S = 'Начало-середина-конец' }

Если измененная строка S оказывается слишком длинной, то она автоматически укорачивается до объявленной длины S (при этом, как всегда, «теряется» правый конец).

Пример использования пары процедур Insert и Delete можно увидеть на рис, 8.5, где приводится функция создания строки с текстом посередине.

| { Функция возвращает строку длиной Len, заполненную символом Ch, со вставленной в середину подстрокой S }

| FUNCTION CenterStr( S: String; Len: Byte; Ch: Char ) : String;

| VAR

| fs : String; { промежуточная строка-буфер }

| ls, l2 : Byte; { вспомогательные переменные }

| BEGIN

| FillChar(fs[1], Len, Ch); { заполнение строки fs Ch }

| fs[0] := Chr( Len ); { восстановление длины fs }

| ls := Length( S ); { длина входной подстроки S }

| if ls>=Len then

| begin { если некорректны параметры}

| CenterStr:=S; Exit { то ничего с S не делается }

| end;

| l2 := ( Len-ls } div 2 +1;{место начала вставки в fs }

| Delete( fs, l2, ls ); {очистка места в центре fs }

| Insert( S, fs, l2 ); {и вставка туда строки S }

| CenterStr := fs {итоговое значение функции }

| END;

| {=== ПРИМЕР ВЫЗОВА ФУНКЦИИ ===}

| BEGIN

| WriteLn(CenterStr( 'Работает!', 80, '='));

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 8.5

- 157 -

8.3.1.6. Функции Pos(Subs, S : String) : Byte возвращает номер символа в строке S, с которого начинается включение в S подстроки Subs. Если же S не содержит в себе Subs, то функция вернет 0. Пример использования функции дан на рис. 8.6, где построена модификация процедуры преобразования Str.

| { Процедура преобразования числа X в строку S}

| { Вход : X — числовое значение; }

| { F — полная длина поля числа; }

| { N — число цифр после запятой. }

| { Выход: строка S, в которой предшествующие }

| { числу пробелы заменены на 0. }

| PROCEDURE ZStr( X : Real; F,N : Byte; VAR S : String );

| VAR p : Byte;

| BEGIN

| Str( X:F:N, S ); { строка с пробелами }

| { Цикл замены пробелов на нули : }

| while Pos(' ', S) > 0 do S[Pos(' ', S)] := '0';

| p := Pos('-',S); { позиция минуса в числе }

| if р <> 0 then begin

{ Если минус имеется, то }

| S[p] := '0'; S[1] := '-' { переместить его в нача-}

| end; { ло строки S. }

| END;

| { ======= ПРИМЕРЫ ВЫЗОВОВ ФУНКЦИИ ======= }

| CONST

| r : Real = 123.456;

| b : Byte = 15;

| i : Integer = -3200;

| St : String = ' ';

| BEGIN

| ZStr( r, 10, 5, St ); WriteLn( St ); { 0123.4560 }

| ZStr{ b, 10, 1, St ); WriteLn( St ); { 0000015.0 }

| ZStr( i, 10, 0, St ); WriteLn( St ); { -00003200 }

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 8.6

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

P := Pos( 'noo', 'Boonoonoonoos');

завершит свою работу, вернув значение 4, хотя есть еще и 7, и 10.

- 158 -

На рис. 8.7 приведен вариант функции, использующей функцию Pos и возвращающей позицию любого вхождения Subs в S, если оно существует.

| { Функция возвращает номер символа, с которого начинается N-e вхождение подстроки Subs в строку S. Одновременно возвращается общее число вхождений Count. При неудаче поиска функция возвращает значение 0. }

| FUNCTION PosN( Subs, S : String; N : Byte;

| VAR Count : Byte ) : Byte;

| VAR

| p, PN : Byte; { вспомогательные переменные }

| BEGIN

| Count:=0; PN:=0;

| repeat { Цикл по вхождениям : }

| p := Pos( Subs, S ); { поиск вхождения }

| if Count<N then Inc(PN,p);{ суммирование позиций }

| Inc( Count ); { счетчик вхождений }

| Delete( S, 1, p ) { уменьшение строки }

| until p=0; { конец цикла, если р=0 }

| Dec( Count ); { надо уменьшить Count }

| if N<=Count { N не больше, чем Count? }

| then PosN := PN {Да, возвращаем позицию }

| else PosN := 0; { Нет, возвращаем 0 }

| END;

| VAR { ===== ПРИМЕР ВЫЗОВА ФУНКЦИИ ===== }

| C : Byte; {количество вхождений подстроки в строку }

| BEGIN

| WriteLn('3-я позиция noo в Boonoonoonoos начинается',

| ' с символа ', PosN('noo','Boonoonoonoos',3,С):3);

| WriteLn( 'Всего найдено вхождений : ', С );

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 8.7

8.3.2. Преобразование строк

8.3.2.1. Процедура Str( X [: Width [: dec ] ]; VAR S : String)

служит для преобразования числовых значений в строковые. Это, в частности, необходимо для работы с процедурами модуля Graph OutText и OutTextXY. X может быть переменной или значением целого или вещественного типов. Можно задавать поля формата, указывая ширину поля для числа и число знаков после десятичной

- 159 -

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

в режиме {$N-}: -1.234567E+10,

в режиме {$N+}: -1.2346Е+0010.

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

Str(6.66 : 8 : 2, S); { S=' 6.66' }

Str(6.66 : -8 : 2, S); { S='6.66' }

Str(6.66 : 8 : 0, S); { S=' 7' }

Можно задать значения полей формата целочисленными переменными или константами:

VAR

F, n : Integer;

S : String;

...

F:=-5; n:=1;

Str( -123.456 : F : n, S);

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

{$IFOPT N+}

CONST FORMAT_E =14; { формат: +n.nnnnnE+NNNN }

{$ELSE}

CONST FORMAT_E =12; { формат: +n.nnnnnE+NN }

{$ENDIF}

...

Str(x : FORMAT_E, S);

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

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

Str(1.234567:6:4, S); {S='1.2346'}

Само значение числа при этом не изменится.

- 160 -

8.3.2.2. Процедура Val(S : String; VAR V; VAR ErrCode : Integer) преобразует числовые значения, записанные в строке S в числовую переменную V. Если преобразование возможно, то переменная ErrCode равна нулю, в противном случае она содержит номер символа в S, на котором процедура застопорилась. Тип V должен соответствовать содержимому строки S. Если в S имеется точка или степень числа Е+nn, то V должна быть вещественного типа, в остальных случаях может быть и целой. Массу сложностей доставляют проблемы переполнения: если S='60000', a V в вызове процедуры будет подставлена типа Byte, то что получится в итоге?

Возможны два варианта. Первый — при работе программы проверяются диапазоны и индексы (режим $R+); при переполнении возникнет фатальная ошибка счета, и программа прервется. Второй — проверка отключена (режим $R-); все зависит от типа V: если он вещественный или LongInt, то при переполнении ErrCode<>0, a V содержит числовой «мусор». Но если V имеет тип «короче» чем LongInt, то ErrCode при переполнении молчит (равно 0), а в V записывается результат переполнения, мало похожий на содержимое S. Не слишком «прозрачно», не так ли? В техническом описании языка после изложения всего этого дается совет, как обойти все эти условности. При преобразовании строк с целыми числами рекомендуется на место V подставлять переменную типа LongInt. Пусть надо перевести строку S с целым значением в переменную WordV типа Word. Схема будет такой:

{$r-}

VAR LongV : LongInt; WordV : Word;

…

WordV := 0; { начальная очистка WordV }

Val( S, LongV, ErrCode }; { вызов преобразования }

if ErrCode=0

then begin { в S записано число }

if ( LongV >= 0 ) and ( LongV <= 65535 )

then { Все в порядке! }

WordV := LongV

else { Иначе несовместимость! }

WriteLn('Ошибка диапазона при преобразовании ',LongV );

end {then}

else { содержимое S не годится }

WriteLn('Ошибка в строке ',S,' в символе ',S[ErrCode]);

При преобразовании строк в другие целые типы достаточно лишь менять диапазон разрешенных значений в операторе IF.

- 161 -

Глава 9. Математические возможности Турбо Паскаля

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

9.1. Базовые операции

Математические выражения в алгоритмической записи состоят из операций и операндов. Большинство операций в языке Турбо Паскаль являются бинарными, т.е. содержат два операнда. Некоторые операции являются унарными и содержат только один операнд. В бинарных операциях используется обычное двухместное алгебраическое представление. В унарных операциях операция всегда предшествует операнду, например: -b.

В сложных выражениях порядок, в котором выполняются операции, соответствует приоритету операций (табл. 9.1).

Таблица 9.1

Первый (высший) приоритет

Унарные операции

Название

Тип операндов

Тип результата

@

Взятие адреса

Любой

Pointer

-

+

Унарный минус

Унарный плюс

Целый Вещественный

Целый Вещественный

Целый Вещественный

Целый Вещественный

not

not

Логическое 'НЕ'

Поразрядное 'НЕ'

Логический

Целый

Логический

Целый

- 162 -

Второй приоритет

Бинарные операции

*

Операция умножения

Целый*Целый

Целый*Вещественный

Вещественный*Целый

Вещественный*Вещественный

Целый

Вещественный

Вещественный

Вещественный

/

Операция деления

Целый/Целый

Целый/Вещественный

Вещественный/Целый

Вещественный/Вещественный

Вещественный

Вещественный

Вещественный

Вещественный

div

Целочисленное деление

Целый div Целый

Целый

mod

Остаток от деления нацело

Целый mod Целый

and

and

Логическое 'И'

Поразрядное 'И'

Логический

Целый

Логический

Целый

shl

shr

Циклический сдвиг влево

Циклический сдвиг вправо

Целый

Целый

Целый

Целый

Третий приоритет

Бинарные операции

+

Операция сложения

Целый+Целый

Целый+Вещественный

Вещественный+Целый

Вещественный+Вещественный

Целый

Вещественный

Вещественный

Вещественный

- 163 -

–

Операция вычитания

Целый–Целый

Целый–Вещественный

Вещественный-Целый

Вещественный– Вещественный

Целый

Вещественный

Вещественный

Вещественный

or

or

Логическое 'ИЛИ'

Поразрядное 'ИЛИ'

Логический

Целый

Логический

Целый

xor

xor

Логическое исключающее 'ИЛИ'

Поразрядное исключающее 'ИЛИ'

Логический

Целый

Логический

Целый

Четвертый (низший) приоритет

Бинарные операции

=

<>

<

>

<=

>=

Операции отношения

Число и число

Строка и число

Строка и литера

Pointer и Pointer

Множества

Логический

in

Вхождение в множество

Элементарный и множество

Логический

Примечания:

1. Под вещественными понимаются тип Real и вещественные типы, поддерживаемые математическим сопроцессором (типы с повышенной точностью).

2. Под целыми понимаются целочисленные типы языка.

3. В таблице указан оператор @, не имеющий никакого отношения к математике. Он включен только для показа его приоритета.

При вычислениях сначала применяются операции наивысшего порядка, затем более низкого. Операции равного приоритета вычисляются слева направо:

2*3/4/5 = ((2 * 3)/4)/5

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

Значение выражения X/Y всегда будет вещественного типа, независимо от типов операндов. Если Y равно 0, то произойдет фатальная ошибка (номер 200) и останов программы.

- 164 -

Значение выражение i div j представляет собой математическое частное i/j, округленное в меньшую сторону до значения целого типа. Если j равно 0, то результатом будет фатальная ошибка.

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

i mod j = i - (i div j) * j

Знак результата операции mod будет тем же, что и знак i. Если j равно нулю, то результатом будет фатальная ошибка.

9.2. Битовая арифметика

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

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

Ограничение на битовые операции одно: они должны применяться только над целыми типами — Byte, ShortInt, Word, Integer, LongInt и совместимыми с ними. Именно эти типы кодируют значения в правильные двоичные числа, как в школьном учебнике по информатике. (То, что в памяти некоторые целые типы хранят свои байты значений в обратном порядке, никак не влияет на поразрядные действия и логику работы с ними. Все особенности учитываются самими поразрядными операциями, и мы можем о них даже не вспоминать.) Например, значения 4 и 250 типа Byte представляются как двоичные наборы 00000100 и 11111010, число 65535 типа Word — это уже 16 бит: 11111111 11111111 и т.д.

Общая формула для значений типов Byte и Word имеет вид

Byte : Значение = B7*27 + B6*2б + B5*25 +...+ B1*2* + B0;

Word : Значение = B15*215 + B14*214+...+B7*27 +...+ B0.

Множители B0, B1 и т.п. — это значения соответствующих битов, равные либо 0, либо 1, а числовые множители — это 2 в степени номера бита.

- 165 -

Внутреннее отличие имеют представления целых типов со знаком: ShortInt, Integer и LongInt. По размеру тип ShortInt равен типу Byte, a Integer — типу Word. Но они могут хранить отрицательные целые числа, правда, меньшие по абсолютному значению чем 255 и 65535:

ShortInt : -128 ..127 ( 8 бит ),

Integer : -32768 .. 32767 ( 16 бит ),

LongInt : -2147483648 .. 2147483647 ( 32 бит ).

Самый левый бит в представлении отрицательного числа всегда равен 1, если значение отрицательное, и 0 в противном случае. Формула перевода битов в значение для типов ShortInt, Integer, LongInt такова:

Shortlnt : Знач= -B7*27 + B6*26 + B5*25 +...+ B1*21 + B0;

Integer : Знач=-B15*215 + B14*214+...+B7*27 +...+ B0;

LongInt : Знач=-B31*231 + B30*230+...+B15*215 +...+ B0;

Примеры кодировки отрицательных чисел для типа ShortInt (бит знака числа отделен здесь пробелом) :

-1 :1 1111111 ( -1*128 + 127 )

-2 : 1 1111110 ( -1*128 + 126 )

-3 : 1 1111101 ( -1*128 + 125 )

-125 : 1 0000011 ( -1*128 + 3 )

-128 : 1 0000000 ( -1*128 + 0 )

Если в кодировании положительных значений абсолютное значение числа тем больше, чем больше единиц в его записи, то для отрицательных значений нули и единицы как бы поменяются местами — и абсолютное значение числа тем больше, чем больше будет в записи нулей. Поэтому, например, двоичное представление того же числа -128 в формате Integer (это уже 16 бит) будет 11111111 10000000.

Вещественные типы кодируются каждый раз по-разному, но всегда достаточно сложно: одна группа битов составляет мантиссу числа, вторая — порядок, да еще знак... Битовые операции к вещественным числам (типам) не применяются.

Посмотреть двоичную форму представления целых чисел можно с помощью функции (рис. 9.1). Операции shl и shr из примера на рис. 9.1 будут рассмотрены чуть позже.

- 166 -

| { ФУНКЦИЯ ПЕРЕВОДА ЦЕЛОГО ЧИСЛА В ДВОИЧНОЕ ПРЕДСТАВЛЕНИЕ}

| { X - целое число (можно передавать и другие типы ) }

| { NumOfBits - число позиций в двоичном представлении }

| FUNCTION Binary( X:LongInt; NumOfBits : Byte ) : String;

| VAR

| bit, i : Byte; { вспомогательные переменные }

| s : String[32];

| BEGIN

| s: = ' '; { обязательная чистка строки }

| for i:=0 to 31 do begin { цикл перевода }

| bit := ( X shl i ) shr ( 31 ); { выделение бита }

| s := s + Chr( Ord( '0' ) + bit ) { запись в строку }

| end; {for} { конец цикла }

| Delete( s, 1, 32-NumOfBits ); { отсечение лишних битов}

| Binary := s { возвращаемая строка }

| END;

| VAR i : Integer; {=== ПРИМЕР ВЫЗОВА === }

| BEGIN

| for i:=-5 to 5 do

| WriteLn(i:7, '--> ', Binary( i, 8*SizeOf(i)));

| Readln { пауза до нажатия клавиши ввода }

| END.

Рис. 9.1

Итак, какие же действия предоставляет поразрядная арифметика? Первая группа — это логические операции над битами (табл. 9.2).

Таблица 9.2

Операции

Название

Форма записи

Приоритет

not

Поразрядное отрицание

not A

1 (высший)

and

Логическое умножение

A1 and A2

or

Логическое сложение

A1 or A2

xor

Исключающее 'ИЛИ'

A1 xor A2

4 (низший)

Not — поразрядное отрицание — «переворачивает» значение каждого бита на противоположное. Так, если A в двоичном виде представляется как 01101100, то not A станет 10010011:

not [1] = 0

not [0] = 1

Квадратные скобки вокруг аргументов обозначают действие над одним битом.

- 167 -

And — так называемое логическое умножение или поразрядная операция 'И':

[0] and [1] = [1] and [0] = [0]

[0] and [0] = [0]

[1] and [1] = [1]

Здесь аргументы специально взяты в скобки — их надо рассматривать как отдельные единичные биты; реальные же примеры не столь очевидны:

(6 and 4) = 4

(6 and 1) = 0

и т.п. Все станет ясно, если 6 и 4 представить как двоичные числа:

0000110 (6) 0000110 (6)

and 0000100 (4) и and 0000001 (1)

______________ ______________

0000100 (4) 0000000 (0)

Впрочем, вовсе не обязательно записывать числа в виде нулей и единиц. Операция and в 99% случаев нужна для двух целей: проверить наличие битов или убрать ( т.е. обнулить) некоторые из них.

Такая проверка нужна, когда число является набором флагов. Например, большое число системных ячеек памяти ПЭВМ содержит сведения о конфигурации машины или ее состоянии. При этом один байт может трактоваться так: бит 6 равен 1 — значит включен режим CapsLock, бит 4 равен 0 — следовательно какой-либо другой режим Lock выключен и т.д. Пусть A содержит этот самый байт с восемью флагами, и надо проверить состояние бита номер 5 (нумерация идет справа налево, от 0 до 7). Единица в бите 5 дает число 25 = 32. Это второй аргумент. Если в A в пятом бите есть единица, то должно выполниться условие

( A and 32 ) = 32

Осталось оформить все это в оператор IF. Можно проверить наличие сразу нескольких «включенных» битов, например, 5-го, 2-го и 0-го. Число с единицами в этих позициях и нулями в остальных равно 2+2 + 1 = 32+4+1 = 37. Если A среди прочих имеет единицы в битах 5, 2 и 0, то в этом случае будет истинным выражение

( A and 37 ) = 37

Исключение или выключение битов достигается следующим образом. Пусть надо исключить бит 3 из переменной A типа Byte (здесь важно знать тип, в который «умещается» текущее значение A). Исключить — значит, задать нулем. Первым делом определяется

- 168 -

число, в котором все биты равны 1, кроме бита номер 3. Для типа Byte оно равно (255 – 23) = 247, где 255 — максимальное значение, вписываемое в байт. Если теперь это число логически умножить на A, то единицы в 247 никак не повлияют на состояние битов в переменной A, а ноль в третьем бите заместит любое значение в A на том же месте. Таким образом, можно записать

A := A and (255 – 8);

чтобы получить значение A с отключенным 3-м битом.

Все это верно и для нескольких битов сразу: если надо исключить биты 3 и 7, то просто запишем

A := A and (255 – 8 – 128);

где 8 = 23 и 128 = 27.

Or — логическое сложение; оно же операция 'ИЛИ', определяется следующими действиями над битами:

[1] or [0] = [0] or [1] = [1]

[0] or [0] = [0]

[1] or [1] = [1]

Квадратные скобки обозначают один бит. Эта операция может с успехом применяться при включении (установки в 1) отдельных битов двоичного представления целых чисел. Так, если надо, чтобы бит 4 значения A стал равным единице, а остальные не изменились, то следует записать

A := A or 16;

где 16 = 24 . При этом не имеет значения, что было в 4-м бите значения A. В любом случае там появится единица.

Аналогичным образом можно включать сразу несколько битов, например, 4-й, 1-й и 0-й:

A := A or (16 + 2 + 1);

Кроме перечисленных, введена еще одна операция xor — исключающее 'ИЛИ' (математическое название — «сложение по модулю 2»). Эта операция возвращает 0, если оба ее аргумента равны, и 1 в противном случае:

[1] xor [1] = [0]

[0] xor [0] = [0]

[1] xor [0] = [0] xor [1] = [1]

Операцию xor можно с успехом применять при смене значения бита (или нескольких битов) на противоположные. Пусть необходимо

- 169 -

переключить состояние бита 5 числа А. Это будет сделано операцией A xor 32 , где 32 = 25.

Исключающее 'ИЛИ' обладает одной особенностью: примененное дважды к одной и той же переменной, оно восстановит ее исходное значение, т.е. всегда выполняется равенство:

A = ( A xor B ) xor B

Следующая группа поразрядных операций — циклические сдвиги (табл. 9.3).

Таблица 9.3

Операция

Название

Форма записи

shl

Циклический сдвиг влево на N позиций

A shl N

shr

Циклический сдвиг вправо на N позиций

A shr N

Приоритет операций shl и shr одинаков и среди всех остальных невысок (см. табл. 9.1). Поэтому, как правило, выражения сдвига должны быть заключены в скобки.

Суть операций shr и shl одинакова: они сдвигают двоичную последовательность значения A на N ячеек (битов) вправо или влево. При этом те биты, которые «уходят» за край разрядности (8, 16 и 32 в зависимости от значения A), теряются, а освободившееся место с другой стороны заполняется нулями (всегда при сдвиге влево и иногда вправо) или единицами (только при сдвиге вправо отрицательных значений типа ShortInt, Integer и LongInt). Например, число с двоичным представлением 11011011 будет трансформироваться при сдвигах влево следующим образом:

( 11011011 shl 0 ) = 11011011

( 11011011 shl 1 ) = 10110110

( 11011011 shl 2 ) = 01101100

( 11011011 shl 3 ) = 11011000

( 11011011 shl 4 ) = 10110000

...

( 11011011 shl 7 ) = 10000000 ( 11011011 shl 8 } = 00000000

Если бы число имело значение типа Word от 256 до 65535, то эффект был бы тем же, только биты «переезжали» бы в поле длиной 16 бит. Для LongInt поле составит 32 бита. При применении операций shl и shr к отрицательным величинам типов ShortInt, Integer, LongInt освобождаемое слева место заполняется единицами.

- 170 -

Конечно, операции сдвига достаточно специфичны и реально нужны только при обработке битовых последовательностей. Пример их использования был дан на рис. 9.1. Там каждый бит последовательно сдвигается к самому левому краю, стирая тем самым все впереди стоящие биты, а затем возвращается в самую правую позицию, стирая тем самым все стоящие правее его биты. В итоге получаем число, равное 0 или 1, в зависимости от содержимого очередного бита.

Операция shl может заменять умножение целых чисел на степени двойки:

J shl 1 = J*2

J shl 2 = J*4

J shl 3 = J*8

Сжатие и кодирование информации. Обычная емкость памяти ПЭВМ (640K) — не так уж велика, как может показаться. Часто вопросы эффективного хранения данных становятся важными для работоспособности программ. Пусть, к примеру, нужно хранить в памяти выборку целых чисел со значениями от 0 до 15, состоящую из 80000 чисел. Так как минимальный тип для каждого числа применительно к Турбо Паскалю — Byte, то всего понадобится 80000 байт. Массив на 80000 байт не пропустит компилятор (максимум, что он сможет «переварить», — это 64K). Кроме того, для представления значения от 0 до 15 достаточно четырех битов, а отводится восемь.

Именно здесь заложена идея и принцип сжатия информации: в одном байте можно уместить два четырехбитовых значения. Тогда понадобится всего 40000 байт, что дает двукратный выигрыш! При этом потери заключаются в необходимости кодирования и декодирования значений. Процедуры преобразования могут иметь вид, показанный на рис. 9.2.

Если бы значения в выборке были целыми и имели диапазон 0..3 (т.е. занимали два бита), то можно было бы в один байт уместить четыре таких значения и т.д. Логика останется той же, изменятся лишь параметры в процедурах преобразования.

К сожалению, подобный подход нельзя применить к вещественным значениям. Единственное, что можно посоветовать — это посмотреть, нужны ли именно вещественные формы хранения данных. Так, если хранится массив вещественных (Real — 6 байт на элемент) значений размеров чего-либо в метрах с точностью до сантиметра, и самое длинное измерение не превосходит 2,55 м, то гораздо эффективнее будет хранить их как массив размеров в сантиметрах. И одно значение будет свободно размещаться в одном байте! Тип Byte занимает 1 байт — экономия шестикратная.

- 171 -

| { Процедура кодирования X1 и X2 в один байт (X1, X2<=15) }

| PROCEDURE Code2to1( X1,X2 : Byte; VAR X1X2 : Byte );

| BEGIN

| X1X2 := X1 + (X2 shl 4 )

| END;

| {Процедура декодирования X1 и X2 из одного байта }

| PROCEDURE DeCode1to2{ X1X2 : Byte; VAR X1,X2 : Byte );

| BEGIN

| X1 := X1X2 and 15; { X1X2 and $F }

| X2 := X1X2 shr 4

| END; VAR {== ПРИМЕР ВЫЗОВА ==}

| C, C1, C2 : Byte;

| BEGIN

| Code2to1(8,7, C);

| WriteLn('8 и 7 - кодируются в —> ',C);

| DeCode1to2(C, C1, C2);

| WriteLn(C:3, — декодируются в --> ',C1:-3,' и ',C2);

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 9.2

9.3. Логические вычисления и операции отношения

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

В Турбо Паскале введены четыре логических операции (табл. 9.4, где L1 и L2 — логические константы, переменные или выражения, равные True или False).

Таблица 9.4

Название

Запись

Результат операции

not

Логическое 'НЕ' (отрицание)

not A1

Логическое значение, противоположное значению L1

and

Логическое 'И' (конъюнкция)

L1 и L2

Логическое значение True, если L1 и L2 равны True, и False во всех остальных случаях

- 172 -

or

Логическое 'ИЛИ' (дизъюнкция)

L1 or L2

Логическое значение True, если хотя бы одно из значений L1 или L2 равно True, и False, если L1 и L2 равны False

xor

Логическое исключающее 'ИЛИ'

L1 xor L2

Логическое значение True, если значения L1 и L2 различны, и False, если они равны

Результат операции всегда имеет тип Boolean и может иметь только одно из двух значений : True (истинно) или False (ложно). Логические операции имеют различные приоритеты (см. табл. 9.1), и в случае, если L1 и L2 сами являются логическими выражениями, лучше расставлять скобки, явно задавая порядок логических вычислений. Так, например, запись

not L1 and L2

будет воспринята компилятором как

(not L1) and L2,

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

not (L1 and L2).

С порядком логических вычислений тесно связана особая возможность Турбо Паскаля — поддержка двух различных моделей генерации кода для операций or и and — полное вычисление и вычисление по короткой схеме (частичное вычисление). При полном вычислении подразумевается, что каждый член логического выражения, построенного с помощью операций or и and, всегда будет вычисляться, даже если результат всего выражения уже известен. Вычисление по короткой схеме прекращается, как только результат всего выражения становится очевиден. Во многих случаях эта модель более удобна, поскольку она обеспечивает минимальное время выполнения и, как правило, минимальный объем кода. Вычисление по короткой схеме делает возможными такие конструкции, которые в противном случае были бы недопустимы, например:

if ( J <> 0 ) and ( ( 2/J ) > х ) then ... ;

while ( i <= Length(S) ) and ( S[i] <> ' ' ) do ... ;

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

- 173 -

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

if LogFunc(x) and LogFunc2(x) then ... ;

где LogFuncl и LogFunc2 — кроме анализа значения x, производят модификацию данных или выдачу сообщений.

Схема вычисления задается с помощью ключа компилятора $B. Обычно значением по умолчанию является состояние {$B-} (установленное в меню настройки компилятора Options/Compiler). В этом случае генерируется код с вычислением по короткой схеме. В случае директивы {$B+} генерируется код с полным вычислением.

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

Типы операндов и результаты операций отношения (сравнения) приведены в табл. 9.5. Сравнивать можно совместимые простые значения, указатели, символы, строки. Подобие операций сравнения существует и для множеств. Результат операции отношения — всегда логическое значение True или False.

Таблица 9.5

Название

Запись

Результат операции

=

Равно

X1 = X2

Логическое значение True, значения X1 и X2 равны, и False в противоположном случае

<>

Не равно

X1 <> X2

Логическое значение True, если значения X1 и X2 различны, и False в противном случае

<

Меньше чем

X1 < X2

Логическое значение True, если значение X1 меньше значения X2 в смысле, определенном для типа этих значений, и False в противном случае

- 174 -

>

Больше чем

X1 > X2

Логическое значение True, если значение X1 больше значения X2 в смысле, определенном для типа этих значений, и False в противном случае

<=

Меньше или равно

X1<=X2

Логическое значение True, если значение X1 не больше значения X2 в смысле, определенном для типа этих значений, и False в противном случае

>=

Больше или равно

X1>=X2

Логическое значение True, если значение X1 не меньше значения X2 в смысле, определенном для типа этих значений, и False в противном случае

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

Обычно логические выражения встречаются в программе либо в операторах управления с условием (IF, WHILE, REPEAT...UNTIL и др.), либо в присваивании значений в логические переменные. С помощью приведения типов можно вставлять логические выражения прямо в числовые. Например, если надо ограничить величину X, например, значением 15, то обычно строится конструкция

if X>15 then X:=X-15;

Но если учесть, что False хранится как байт со значением 0, a True — как байт со значением 1, то можно обойтись без if:

X := X - 15 * Byte( X>15 );

Здесь 15 вычтется только, если (X>15)=True, что значит 1. Иначе же, вычтется 15*0. Можно и из байтов делать логические значения приведением к типу Boolean. Но тут надо помнить, что

Boolean( X ) = False, если X=0,

Boolean( X ) = True , если X<>0.

Значение X должно иметь тип Byte. Как видно, ненулевое значение всегда «истинно».

- 175 -

Еще одно замечание: при сравнении вещественных значений нельзя быть уверенным в его корректности. Например, выражения X и ( 2.23 * X / 2.23 ) формально тождественны, но из-за ошибок округления в вещественном типе будут различаться. Еще большие проблемы возникают при работе с расширенным набором вещественных типов, разрешенных при наличии математического сопроцессора 80X87. Советуем посмотреть разд. 9.5, посвященный использованию сопроцессора, где рассказывается, как бороться с подобными трудностями.

9.4. Математические процедуры и функции

Системная библиотека математических процедур и функций Турбо Паскаля приведена в таблицах 9.6 и 9.7.

Таблица 9.6

МАТЕМАТИЧЕСКИЕ ФУНКЦИИ

Вызов функции

Тип аргумента

Тип значения

Назначение функции

Abs(X)

Целый/вещественный

Как у аргумента

Абсолютное значение X

Pi

—

Вещественный

Значение числа 'Пи'

Sin(X)

Вещественный

Вещественный

Синус X радиан

Cos(X)

Вещественный

Вещественный

Косинус X радиан

ArcTan(X)

Вещественный

Вещественный

Арктангенс X радиан

Sqrt(X)

Целый/Вещественный

Как у аргумента

Квадратный корень из X, X>0

Sqr(X)

Целый/Вещественный

Как у аргумента

Значение квадрата X

Exp(X)

Вещественный

Вещественный

Значение e в степени X

Ln(X)

Вещественный

Вещественный

Натуральный логарифм X, X>0

Trunc(X)

Вещественный

LongInt

Целая часть значения X

Frac(X)

Вещественный

Вещественный

Дробная часть значения X

Int(X)

Вещественный

Вещественный

Целая часть значения X

- 176 -

Round(X)

Вещественный

LongInt

'Правильное' округление X до ближайшего целого

Random

—

Вещественный

Случайное число (0…1)

Random(X)

Word

Word

Случайное число (0…X)

Odd(X)

Целый

Логический

Возвращает True, если X – нечетное число

Таблица 9.7

МАТЕМАТИЧЕСКИЕ ПРОЦЕДУРЫ

Описание

Назначение

Randomize

Гарантирует несовпадение последовательностей случайных чисел, выдаваемых функцией Random

Inc(VAR X : Целое)

Увеличивает значение X на 1

Dec(VAR X : Целое)

Уменьшает значение X на 1

Inc(VAR X : Целое; N : Целое)

Увеличивает значение X на N

Dec(VAR X : Целое; N : Целое)

Уменьшает значение X на N

Необходимо сделать следующие замечания к таблицам: под целым типом понимается один из целочисленных типов языка — от Byte и ShortInt до LongInt; под вещественным типом понимается тип Real или иной тип с плавающей точкой (при использовании сопроцессора), если речь идет о входном значении; возвращаемое функцией вещественное значение соответствует типу Real, если не используется математический сопроцессор (ключ компилятора {$N-}) или типу Extended, если сопроцессор используется (ключ {$N+}).

Математические функции очень чувствительны к диапазону своих аргументов. Кроме того, возвращаемые значения целых типов должны в них умещаться, иначе возможны фатальные последствия. Большинство из приведенных функций являются стандартными для языков программирования и не нуждаются в комментариях. Однако ряд функций является специфическим. Рассмотрим их.

- 177 -

9.4.1. Обсуждение математических функций языка

9.4.1.1. Функция Pi. Эта функция генерирует число «Пи» с точностью, зависящей от наличия сопроцессора и содержит 10 или 14 знаков после запятой. Она может использоваться в вычислениях как константа, но не может быть подставлена в вычислимые константы раздела CONST!

9.4.1.2. Функция ArcTan(X). Она возвращает главное значение арктангенса (в диапазоне от -Pi/2 до +Pi/2). Это не всегда удобно, и можно определить функцию арктангенса угла наклона отрезка, один конец которого соответствует началу координат, а другой задан координатами X и Y (рис. 9.3).

{ Функция возвращает значение угла наклона отрезка (0,0)-(X,Y) к оси X в радианах. Возвращаемое значение находится в диапазоне 0..2*Pi и учитывает знаки значений X и Y. }

| FUNCTION ATAN2( X,Y : Real ) : Real;

| VAR a : Real;

| BEGIN

| if X=0 then a:=Pi/2

| else a:=Abs( ArcTan( Y/X ) );

| case ( Byte(X>0) + Byte(Y>=0) ) of

| 2 : ATAN2 := a;

| 1 : if X>0 then ATAN2 := 2*Pi-a

| else ATAN2 := Pi - a;

| 0 : ATAN2 := Pi + a

| end {case}

| END;

{==== ПРОВЕРКА РАБОТОСПОСОБНОСТИ ФУНКЦИИ ====}

| CONST { константа перевода радиан в градусы }

| R2D = 180/3.1415926;

| VAR

| i : Integer;

| x, sx, ex : Real;

| BEGIN

| for i:=0 to 360 do begin

{ цикл по градусам }

| x:=i/R2D; { перевод в радианы }

| sx:=Sinx); cx:=Cos(x); { синус и косинус i }

| x:=ATAN2(cx,sx)*R2D; { угол в градусах }

| WriteLn(i:3, 'град. Функция возвращает: ', x:-10:6 )

| end; { конец цикла по i }

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 9.3

- 178 -

Эта функция возвращает корректное значение угла в диапазоне от 0 до 2*Pi, что гораздо удобнее в технических расчетах.

9.4.1.3. Доопределение функций. Часто ощущается нехватка функций arccos и arcsin. Но их нетрудно написать самим (рис. 9.4).

| { Функция возвращает главное значение arcCos X (в рад) }

| FUNCTION ArcCos( x : Real ): Real;

| BEGIN

| if x=0

| then ArcCos:=Pi/2

| else ArcCos:=ArcTan(Sqrt(1-Sqr(x)) / x) + Pi*Byte(x<0)

| END;

| {Функция возвращает главное значение арксинуса X(в рад)}

| FUNCTION ArcSin( x : Real ) : Real;

| BEGIN

| if Abs(x)=1

| then ArcSin:=0

| else ArcSin:=ArcTan(x / Sqrt( 1-Sqr(x) ) )

| END;

Рис. 9.4

Аналогичным образом можно построить библиотеку любых необходимых математических функций, сделав в итоге свой собственный математический модуль. Все необходимые «кирпичики» имеются в базовом наборе языка. Так, например, можно ввести десятичный логарифм (рис. 9.5) или степенную функцию (рис. 9.6).

| { Функция возвращает значение десятичного логарифма }

| FUNCTION Log10( x : Real ) : Real;

| BEGIN

| Log10:= Ln(x)/Ln(10)

| END;

Рис. 9.5

| { Функция возвращает значение A в степени X (A>0) }

| FUNCTION Pwr(a,x : Real ) : Real;

| BEGIN

| Pwr := Exp( x * Ln(a) )

| END;

Рис. 9.6

- 179 -

9.4.1.4. Функции Frac, Int и Trunc. Эти функции соответствуют математическим функциям взятия дробной и целой части числа соответственно. Помните, что

Frac( X ) = X - Int( X )

и знак X переходит на значение функции Frac.

Функция Trunc отличается от Int только типом возвращаемого значения. Int записывает целое число в вещественном формате (после точки — нули), a Trunc — в целочисленном. Такая двойственность необходима для совместимости в операторах присваивания.

9.4.1.5. Функция Round. Эта функция округляет число X до ближайшего целого числа с избытком:

Round (5.5) = 6 Round (-5.5) = -6

Round (5.9) = 6 Round (-1.51) = -2

Round (5.49) = 5 Round (-1.4) = -1

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

9.4.2. Генераторы случайных чисел

С функцией-генератором случайных чисел Random связано много условностей. Она всегда возвращает равномерно распределенное случайное число. Диапазон или, вернее, интервал распределения таких чисел задается видом вызова функции. Если Random вызывается без аргумента, то она вернет вещественное случайное число r в диапазоне 0 <= r < 1. Но если вызов содержал аргумент N типа Word — Random( N ), то вернется случайная величина (целая!) из диапазона 0 <= r < N. При N=0 функция вырождается и возвращает константу 0.

У функции-генератора случайных чисел Random есть одна неприятная особенность: при последовательных запусках программы выдавать одинаковые случайные последовательности. Другими словами, пока программа работает, любое обращение к Random даст вполне «случайное» значение (период повторяемости, конечно, есть, но очень большой). Но если запустить программу второй раз, то ее вычисления в точности повторят предыдущий запуск: «случайные» значения будут теми же, что и в прошлый раз. А это значит, что многократный запуск программ, моделирующих случайные процессы наберет статистику, одинаковую с единичным прогоном. Во избежание этого рекомендуем включать в начало программы вызов процедуры Randomize. Эта процедура записывает случайное число (взятое со встроенного таймера) в так называемую «затравку» случай-

- 180 -

ной последовательности, сбивая тем самым ее на новые числа. Того же эффекта можно достичь, если записывать произвольное (но каждый раз разное!) значение в системную переменную RandSeed типа LongInt.

Функции Random генерируют случайную равномерно распределенную на интервале последовательность чисел. На ее основе можно сконструировать последовательности с другими законами распределения. Наиболее часто требуется нормальное распределение. Один из вариантов генератора показан на рис. 9.7.

| { Функция Gauss возвращает случайное вещественное число }

| {распределенное по нормальному закону с математическим }

| {ожиданием mo и средне-квадратическим отклонением Sigma}

| FUNCTION Gauss( mo, Sigma : Real ) : Real;

| VAR

| a, b, r, sq : Real;

| BEGIN

| repeat

| a := 2 * Random - 1;

| b := 2 * Random - 1;

| r := Sqr(a) + Sqr(b)

| until ( r < 1 );

| sq := Sqrt( -2 * Ln(r)/r);

| Gauss := mo + Sigma*a*sq

| END;

Рис. 9.7

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

9.4.3. Оптимизация сложения и вычитания

Процедуры Inc и Dec (аналогичные названия имеют команды ассемблера) введены в язык для оптимизации операций сложения и вычитания целых чисел. При компиляции Inc(i) даст более эффективный и быстрый код, чем традиционное i := i + 1. Выигрыш составит до 30%, что очень важно при использовании в циклических процессах.

9.5. Использование математического сопроцессора 80X87

Применение сопроцессора значительно увеличивает точность математических расчетов и ускоряет их выполнение. Дело лишь в малом — наличии его и умении использовать.

- 181 -

Чтобы программа могла задействовать возможности сопроцессора, она должна в своем начале иметь директиву (ключ режима компилятора) $N+ :

{$N+ программа для 80X87}

PROGRAM Name;

USES

...

Режим компиляции $N+ является глобальным и не может меняться в дальнейшем. При создании модулей (UNIT), ориентированных на работу с сопроцессором, т.е. использующих вводимые им типы, указание ключа $N+ в них необязательно. Важно лишь, чтобы он был в главной программе, включающей в себя эти модули.

При необходимости отключить сопроцессор должен указываться ключ $N-. При этом программа может перестать компилироваться (компилятор «забудет» типы чисел с повышенной точностью).

Если в ПЭВМ установлен сопроцессор, то компилятор сам определяет ключевое слово CPU87 для условной компиляции. Это можно использовать для автоматического выбора режима компиляции:

{$IFDEF CPU87} {$N+} {$ELSE} {$N-} {$ENDIF}

Приведенная выше конструкция определяет, как будет скомпилирован текст — в расчете на сопроцессор или без него.

После компиляции выполнение программы всякий раз начинается с проверки наличия сопроцессора и определения его типа. Результат проверки записывается в предопределенную переменную системной библиотеки — Test8087 типа Byte (табл. 9.8).

Таблица 9.8

Значения Test8087

Расшифровка

0

Сопроцессор не обнаружен

1

Подключен 8087

2

Подключен 80287

3

Подключен 80387

Если программа компилировалась в режиме {$N+}, а значение Test8087 получилось равным 0, то программа остановится с выдачей сообщения о необходимости сопроцессора. Существует, однако, средство отключить автоматическую проверку наличия сопроцессора при запуске программы. Надо ввести системную переменную MS-DOS с именем 87 и значениями Y (от YES — да) и N (от NO — нет). Лучше всего это сделать в файле AUTOEXEC.BAT, вставив строку

- 182 -

SET 87=Y (или N)

Значение системной переменной MS-DOS 87, равное Y, прикажет считать сопроцессор подключенным, а N — соответственно отключенным. Вообще говоря, лучше не обманывать технику и программы. Приберегите эту методику (с SET 87=) на самый крайний случай.

Турбо Паскаль дает возможность эмулировать работу сопроцессора программным путем. Это означает, что можно создать программу, которая будет работать с высокой точностью независимо от наличия сопроцессора. Обнаружен сопроцессор — хорошо, он и будет нагружен, нет сопроцессора — вся точность будет получена имитацией его. Понятно, что в последнем случае будут потери во времени счета, и немалые. Включением эмуляции управляет ключ $Е. Он имеет смысл только рядом с ключом $N. Возможны такие их сочетания:

{$N+, E+} — подключение библиотеки для эмуляции сопроцессора; при его отсутствии точность обеспечивается программно за счет скорости; {$N+, E-} — программа сможет работать только на машинах с сопроцессором;

{$N-,E+} и {$N-,E-} — сопроцессор не используется, ключ эмуляции игнорируется. Программа работает только с обычной точностью и скоростью.

Если в программу вставлен внешний код директивой {$L Имя-Файла.OBJ}, то для работы с сопроцессором этот код должен быть получен с учетом использования инструкций 80X87.

Преимущества от использования сопроцессора — это, в первую очередь, скорость вычислений, которая может вырасти в несколько раз. Второе преимущество — увеличение точности вычислений с плавающей точкой. В расчете на математический сопроцессор вводятся типы, приведенные в табл. 9.9.

Таблица 9.9

Тип

Диапазон значений

Количество значащих цифр

Размер в байтах

Single

1.5E-45..3.4e+38

7-8

4

Double

5.0E-324..1.7E+308

15-16

8

Extended

3.4E-4932..1.1E+4932

19-20

10

Comp

-9.2E+18..9.2E+18

19-20

8

Все эти типы — вещественные, за исключением Comp, который является «очень длинным» целым типом (хранит только целые

- 183 -

значения). Диапазон этого типа в таблице задан округленно, так как реальные числа (от -2 до 263-1) слишком длинны.

Обычный тип Real (6 байт, диапазон 2.9Е-39...1.7Е+38, 11-12 значащих цифр) будет работать с сопроцессором, но крайне неэффективно. Этот формат — чужой для сопроцессора, и время, «съедаемое» преобразованием его в сопроцессорный тип, перекрывает ускорение. А точности не добавляется. Поэтому лучше всего ввести свой тип, например Float, и понимать под ним либо Real, либо чисто сопроцессорный вещественный тип в зависимости от режима компиляции.

{$N... <-- какой-либо режим }

{$IFOPT N+}

TYPE

Float = Double; { или любой другой тип для 80X87 }

{$ELSE>

TYPE

Float = Real; { без 80X87 — только этот тип }

{SENDIF}

VAR { переменные типа Float }

r : Float;

d : Array [1..9] of Float;

Целые типы Турбо Паскаля работают с сопроцессором без каких-либо оговорок.

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

VAR

e1, e2 : Extended;

e3 : Double;

result : Single;

...

result := e1*e2/e3;

- 184 -

значение выражения справа будет вычислено как тип Extended. Но при присваивании его переменной result «малого» типа Single будет произведено усечение, и резко уменьшится число значащих цифр после десятичной точки. Подобные ситуации надо предвидеть и стараться избегать их. Особенно неприятны они в циклах суммирования:

VAR

е : Extended:

Sum : Single;

i : Word;

...

BEGIN

e:=1.23456e-12;

Sum:=0;

for i:=32767 to 65535 do Sum := Sum + i/e;

...

END.

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

eSum:=0;

for i:=32767 to 65535 do eSum := eSum + i/e;

Sum:=eSum;

Теперь потери будут значительно меньше.

По той же причине (из-за усечения точности) некорректной является операция сравнения двух разнотипных вещественных переменных или переменной с выражением (последнее, как уже отмечалось, может быть вычислено в типе Extended). Так, сравнение в примере:

VAR

e : Extended;

d : Double;

...

e := Cos( Pi/8 );

d := e;

{==>} if d=e then ...

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

- 185 -

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

if Abs(d-e) < 1.0Е-15 then ...

Здесь 1.0Е-15 — точность для типа переменной d (Double).

Продолжим перечень особенностей применения сопроцессора. Его наличие в ПЭВМ и использование сильно влияет на работу функции округления Round: она начинает округлять полуторные значения в сторону ближайшего четного целого числа (это называется «банковским способом»)! Например:

без сопроцессора с сопроцессором

Round(0.5) --> 1 Round(0.5) --> 0

Round(1.5) --> 2 Round(1.5) --> 2

Round(2.5) --> 3 Round(2.5) --> 2

Round(3.5) --> 4 Round(3.5) --> 4

С остальными значениями (без '.5') функция работает нормально.

Некоторые неприятности могут поджидать любителей рекурсивного подхода к написанию функции. Возможны, в принципе, ситуации, когда рекурсивные вызовы переполнят внутренний стек данных сопроцессора, рассчитанный на восемь уровней рекурсии, и возникнет сбой программы. Возможным решением будет разнесение сложнорекурсивных выражений типа Fn:=Fn(N-1)+Fn(N-2) по локальным переменным, например, f1:=Fn(N-1); и f2:=Fn(N-2). После этого выражение Fn:=f1+f2 будет безопасным для сопроцессора.

Завершая тему использования сопроцессора, напомним, что и расширенные вещественные типы, и тип Real при работе с сопроцессором 80X87 выводятся на печать операторами Write и WriteLn с 4 цифрами в показателе степени:

при $N- WriteLn(123.4) выдаст 1.2340000000Е+02,

но при $N+ WriteLn(123.4) выдаст 1.234000000000000Е+0002.

Этот факт надо учитывать при форматированном выводе и при преобразовании чисел в строку процедурой Str.

- 186 -

Глава 10. Код программы, данные, адреса

Системная библиотека Турбо Паскаля содержит набор средств для анализа расположения программ и данных в памяти ПЭВМ. Широко поддерживается работа с адресами данных и кодов. В этой главе дается обзор этих средств и способы их применения.

10.1. Система адресации MS-DOS

Адресуемое пространство памяти в операционной системе MS-DOS организовано сегментами: последовательными блоками памяти по 64K каждый. Если известен сегмент, то дальнейшее уточнение места объекта в памяти происходит по его смещению, т.е. номеру байта от начала сегмента. Это, может быть, не самый эффективный способ адресации памяти, но на нем основана операционная система MS-DOS и все программы для нее. Таким образом, любая ячейка адресуемого пространства MS-DOS определяется парой чисел СЕГМЕНТ:СМЕЩЕНИЕ. При этом сегмент может начинаться с любого физического адреса, что порождает множественность способов адресации ячейки памяти. Например, такие разные адреса, как $83FD:$000B, $7FFD:$400B и $759D:$E60B в действительности адресуют к одной и той же ячейке. Иногда может быть интересно получить сплошной адрес ячейки, отсчитанный от начала памяти 0000:0000. Такое число получить очень просто: оно равно СЕГМЕНТ *16 + СМЕЩЕНИЕ.

Существует понятие нормализации адреса. Под этим понимается приведение его к такому виду, что смещение находится в диапазоне от 0 до 15 ($000F). Если вычислен сплошной адрес ячейки памяти, то его можно легко пересчитать в нормализованный «обычный» формат:

СЕГМЕНТ = Сплошной_адрес div 16

и

СМЕЩЕНИЕ = Сплошной_адрес mod 16,

где div и mod — операции деления нацело и взятие остатка от деления соответственно.

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

- 187 -

10.2. Распределение памяти при выполнении программ

Рассмотрим распределение памяти для выполнимого кода программ на Турбо Паскале (рис. 10.1).

Рис. 10.1

При запуске программы (ЕХЕ-файла) MS-DOS организует в памяти нечто вроде анкеты длиной 256 байт на этот файл, называемой PSP (Program Segment Prefix). Структура PSP описывается в технических руководствах по MS-DOS. Сегмент, с которого начинается отсчет PSP, может быть получен через предопределенную в системной библиотеке (модуле System) переменную PrefixSeg типа Word.

После PSP начинается код ЕХЕ-файла. Он может занимать более одного сегмента. Когда выполняется какой-либо из блоков кода (основной блок, процедуры из модулей), он считается размещенным

- 188 -

в некотором сегменте кода. Реальное значение сегмента при этом содержится в регистре CS процессора.

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

Заметим, что реальный сегмент может быть и меньше чем 64K. В самом деле, он может начинаться где угодно. Если самый последний байт в нем имеет смещение, например 255 ($00FF), то следующий сегмент может отсчитываться от следующего же байта.

Следом за сегментом данных следует область стека. В ней располагаются локальные переменные и параметры-значения процедур и функций во время их работы по вызову. Сегмент стека содержится в регистре SS процессора. Турбо Паскаль отводит под стек один сегмент, и поэтому область стека не может превышать 64K.

Стек заполняется от своей верхней границы (она может быть назначена директивой компилятору $М) по направлению к началу, т.е. к старту сегмента. Специальный регистр SP процессора содержит смещение указателя стека в сегменте SS (указатель стека — это как бы отметка уровня заполнения стека).

Имеется предопределенная системная переменная StackLimit типа Word, которая логически примыкает к рассматриваемым вопросам. Она содержит минимальное допустимое значение указателя стека. Когда программа запускается, указатель стека имеет максимальное значение, равное отведенной под стек памяти. При работе стек заполняется «сверху вниз», и указатель как бы снижается. Как только он спустится настолько, что свободная часть стека станет меньше чем значение StackLimit, возникнет ошибка времени счета номер 202 Stack overflow (переполнение стека), и программа прервется.

Нормальное значение StackLimit — это 0, а в режиме компиляции {$N+, E+} — 224. Обычно нет необходимости менять это значение.

Выше стека программа отводит себе память под буфер для работы оверлеев — перекрывающихся частей программы. Если они не используются, то буфер не отводится (подробнее об этом см. гл. 18 «Модуль Overlay»).

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

- 189 -

10.3. Анализ расположения кода и областей данных программы

При программировании на низком уровне или использовании вставок машинных кодов в программу необходимо иметь средства анализа положения программы в ее данных в оперативной памяти. Системная библиотека Турбо Паскаля содержит набор средств для этого. Перечень специальных функций анализа памяти приведен в табл. 10.1.

Таблица 10.1

Функция : Тип -- Возвращаемое значение

CSeg : Word -- Содержимое регистра CS процессора

DSeg : Word -- Содержимое регистра DS процессора

SSeg : Word -- Содержимое регистра SS процессора

SPtr : Word -- Содержимое регистра SP процессора

При работе программы ее текущий исполнимый код находится в кодовом сегменте, что фиксируется в регистре CS, а статические переменные основного блока и типизированные константы располагаются в сегменте данных, который запоминается регистром DS. Локальные переменные и параметры процедур и функций при вычислениях располагаются в стеке, и сегмент стека содержится в регистре SS. Последний регистр – SP – содержит смещение указателя стека в сегменте SSeg.

10.4. Тип Pointer

В Турбо Паскале предопределен специальный адресный тип Pointer — указатель: можно объявлять переменные, значением которых будет адрес ячейки памяти:

VAR

Р : Pointer; { переменная-указатель }

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

- 190 -

вводится специальный набор функций. Кроме того, указатели полностью совместимы со ссылочным типом и могут использоваться (с оговорками) как ссылки. Указатели могут обмениваться значениями через оператор присваивания (:=), и сравниваться операторами = и <>. Но сравнение их — весьма ненадежная операция. Так, когда два указателя содержат один и тот же адрес в памяти, но записанный в них разными способами, они считаются различными. Таким образом, два указателя считаются одинаковыми, если в них записаны одинаковые значения сегмента и смещения. Во всех остальных случаях они считаются неравными. Понятия «больше» и «меньше» к значениям типа Pointer неприменимы.

Если мы хотим указать в программе на значение по указанному в переменной типа Pointer адресу, то мы должны использовать символ «^» после имени указателя, например: Р^. Это есть операция разыменования. Подробно этот вопрос рассмотрен при описании работы со ссылками, а особенности разыменования указателей обсуждаются вместе с работой функции Ptr.

10.5. Средства для работы с адресами

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

Таблица 10.2

Функция : Тип -- Возвращаемое значение

Addr(X) : Pointer -- Ссылка на начало объекта X в памяти

Seg(X) : Word -- Сегмент, в котором хранится объект X

Ofs(X) : Word -- Смещение в сегменте для объекта X

Prt(S, O : Word) : Pointer -- Ссылка на место в памяти, заданное значениями смещения O и сегмента S

SizeOf(X) : Word -- Размер объекта X в байтах

Операция @X : Pointer -- Возвращает ссылку на начало объекта X памяти (аналог функции Addr)

10.5.1. Определение адреса переменных

Функции Addr(X), Seg(X) и Ofs(X), а также оператор @ возвращают адрес объекта X или компоненты адреса. Под X можно понимать любой объект: переменные любых типов, объекты, процедуры и функции (но не константы).

Функция Addr(X) и оператор @ возвращают значение типа Pointer — адрес объекта X. Их действие одинаково:

VAR

X : String; p, q : Pointer;

...

р: = Addr( X );

q: = @X;

{Теперь p=q, и адреса равны; они указывают на один объект }

Значение типа Pointer не может быть выведено на экран. Но так как этот тип состоит из двух слов (Word), хранящих сегмент и смещение, можно вывести их в отдельности, используя функции Seg и Ofs (обе типа Word):

WriteLn( 'Сегмент ', Seg( р ), ' смещение ', Ofs( р ));

В то же время значения ссылок можно получить в режиме отладки. Они будут выводиться в окна наблюдения и модификации (Watch и Evaluate).

Может возникнуть вопрос — а зачем вообще нужна функция Addr, если есть Seg и Ofs, тем более что нельзя распечатать ее значение? Ответ: функция Addr и оператор @ нужны для привязывания ссылок, т.е. динамических переменных, к статическим данным, а также для работы с массивами данных в виде OBJ-файлов, связанных с выполнимым файлом на этапе компоновки. Пример компоновки внешних данных дан при описании работы с образом экрана на диске в разд. 20.4 «Работа с образом экрана на диске».

Заметим, что если P — ссылка, то Addr(P) или @P, а также Seg(P) и Ofs(P) вернут адрес или сегмент со смещением самой переменной-ссылки P в области статических данных, но Addr(P^) или @Р^ и Seg(P^) с Ofs(P^) возвратят содержимое ссылки P, т.е.

Р = Addr( Р^).

Рассмотрим действие оператора @ с различными типами переменных. При использовании с глобальными переменными или типизированными константами оператор вернет адрес этих переменных, как правило, в сегменте данных. При использовании его внутри процедур и функций с параметрами-переменными оператор @

- 192 -

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

10.5.2. Создание адреса функцией Ptr

Функция Ptr( Seg, Ofs : Word) выполняет противоположную функции Addr работу: организует ссылку на место в памяти, определяемое заданными сегментом и смещением. Необходимость в такой функции возникает всякий раз, когда требуется наложить динамическую структуру на системную область памяти (системные, т.е. зарезервированные, области памяти достаточно жестко фиксированы, и их адреса описаны в специальной литературе). Если, например, известно, что образ текстового экрана начинается с адреса $В000 : $0000 и занимает 4000 байт (цветной и черно-белый режимы, 80 столбцов на 25 строк), то можно «наложить» на него структуру, например массив, используя ссылку на такой массив и функцию Ptr (рис. 10.2):

| TYPE

| VideoArray = Array [0..3999] of Byte;

| VAR

| V : ^VideoArray; { ссылка на структуру }

| BEGIN

| V := Ptr( $B000, 0 );

| { Далее V^[i] обращается непосредственно к ячейкам видеопамяти в текстовом режиме }

| ...

| END.

Рис. 10.2

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

Так как значение типа Pointer, возвращаемое функцией Ptr, совместимо со всеми ссылочными типами, можно наложить любую структуру на какой угодно участок памяти. Кроме того, его разрешается разыменовывать, т.е. записывать конструкции вида

Ptr( $40, $40 )^

- 193 -

Но в чистом виде такая конструкция имеет мало смысла, ибо не определена структура, на первый байт которой указывает это разыменование. А определить эту структуру можно операцией приведения (преобразования) типа:

B := Byte( Ptr($40, $40)^); {B — значения байта $40:$40 }

W := Word( Ptr($40,$40)^ ); { W — значение слова $40:$40 }

X := VideoArray( Ptr($B800,0)^); { X — статический массив типа VideoArray содержит теперь в себе образ видеопамяти (текстовое изображение) }

и т.д.

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

10.5.3. Определение размеров типов и переменных

Функция SizeOf(X): Word возвращает объем в байтах, занимаемый X. Причем X может быть не только переменной, но также и идентификатором типа (рис. 10.3).

| TYPE

|  XType = Array[1..10, 1..10] of byte;

|CONST

|  L : Longint = 123456;

| VAR

|  X : String;

| BEGIN

|  WriteLn(SizeOf(Xtype): 10,  SizeOf(L): 10, SizeOf(X))

| END.

Рис. 10.3

Значение SizeOf(строка) всегда дает максимальное значение длины строки. Реальное значение дает функция Length.

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

Применительно к данным типа «объект» (OBJECT) эта функцию должна использоваться более осторожно, так как у объектов может не быть заранее предопределяемого размера. Обсуждение этого можно найти в гл. 13.

Глава 11. Ссылки, динамические переменные и структуры

Динамическими структурами данных считаются такие, размер которых в процессе работы программы заранее не известен или изменяется и(или) для которых место в памяти ПЭВМ отводится во время выполнения программы. Необходимость в динамических структурах данных обычно возникает в следующих случаях:

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

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

Кроме этих двух случаев, общих для различных версий Паскаля, при программировании на Турбо Паскале есть еще один. А именно: когда размер переменной (массива или записи) превышает 64 К.

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

11.1. Ссылочные переменные

Основным механизмом для организации динамических данных является выделение в специальной области памяти, называемой «кучей», непрерывного участка (блока) подходящего размера и сохранения адреса начала этого участка в специальной переменной. Такие переменные называют ссылочными переменными или просто ссылками (reference). Часто используется синоним этого термина — «указатель» (pointer), но в Турбо Паскале это название имеет особый смысл.

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

TYPE

ИмяСсылочногоТипа = ^ИмяБазовогоТипа;

где ИмяБазовогоТипа — любой идентификатор типа. В результате

- 195 -

этого определения создаваемые затем ссылочные переменные будут указывать на объекты базового типа, определяя тем самым динамические переменные базового типа. Например:

TYPE { БАЗОВЫЕ ТИПЫ }

DimType = Array [1..10000] of Real; { массив }

RecType = RECORD { запись }

...

END;

ObjType = OBJECT { объект }

...

| END;

{ ССЫЛОЧНЫЕ ТИПЫ }

IntPtr = ^Integer; { ссылка на целое значение }

DimPtr = ^DimType; { ссылка на массив данных }

RecPtr = ^RecType; { ссылка на запись }

ObjPtr = ^ObjТуре; { ссылка на объект }

XXXPtr = Pointer; { ссылка вообще — указатель }

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

Все ссылочные переменные имеют одинаковый размер, равный 4 байтам, и содержат адрес начала участка оперативной памяти, в котором размещена динамическая структура данных. Отношение между ссылочной переменной и объектом, на который она указывает, наглядно представлено на рис. 11.1. Здесь J — ссылочная переменная, указывающая на значение целого типа (VAR J : ^Integer). Сравните с простой переменной I типа Integer на том же рисунке.

Рис. 11.1

Чтобы ссылка ни на что не указывала, ей присваивается значение nil, например:

J := nil;

Это предопределенная константа типа Pointer, соответствующая адресу 0000:0000.

- 196 -

11.2. Операция разыменования

Основной операцией при работе со ссылочными переменными является операция разыменования. Суть ее состоит в переходе от ссылочной переменной к значению, на которое она указывает. Эта операция обозначается указанием символа «^» следом за ссылочной переменной. Результатом операции является значение объекта, на который указывала ссылочная переменная, или, что то же самое, динамическая переменная. Так, пусть мы имеем две ссылочные переменные I и J, указывающие на объекты целого типа, значения которых равны 2 (I^) и 4 (J^) соответственно. Для того чтобы скопировать содержимое переменной I^ в переменную J^, необходимо выполнить оператор

J^ := I^;

Следует отметить, что нужно писать именно I^ и J^, поскольку оператор вида

J := I;

приведет к копированию адреса значения, на которое указывает I, в ссылочную переменную J. В этом случае мы получим две ссылки на одно и то же значение. Значение, на которое раньше указывала переменная J, будет потеряно. На рис. 11.2 показан результат выполнения этих двух операторов (а — ситуация до (слева) и после выполнения оператора J^:=I^; б — ситуация до (слева) и после выполнения оператора J:=I). После выполнения оператора J:=I ссылка на значение 4 теряется (рис. 11.2, б, справа), и к нему больше нет доступа.

Рис. 11.2

- 197 -

Само значение теперь будет просто пассивно занимать память, т.е. превратится в «мусор».

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

DimPtr := RecPtr;

но после разыменования контроль типов становится строгим и

DimPtr^ := RecPtr^;

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

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

if DimPtr = XXXPtr then ... ;

if DimPtr <> XXXPtr then ... ;

Сравнения ссылок не всегда работают корректно. Если две ссылки указывают на один и тот же адрес в памяти, но этот адрес записан в них различными значениями (что вполне возможно), то они считаются различными. Процедуры New и GetMem всегда возвращают ссылки, приведенные к такому виду, что смещения адреса имеют значения от 0 до 15 ($F), и они будут сравниваться корректно. А специальные функции типа Addr, Ptr этого не делают, и сравнивать их результаты с чем-либо надо с большой осторожностью.

Разыменованные ссылки на структуры индексируются (массивы) или разделяются на поля (записи, объекты) обычным образом. Для определенных выше ссылок это выглядит следующим образом:

DimPtr^ [i] — доступ к элементу i динамического массива,

RecPtr^.Поле — доступ к полю динамической записи,

ObjPtr^.Метод — доступ к методу динамического объекта.

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

11.3. Организация памяти области кучи

Для размещения динамических переменных используется область памяти, называемая «кучей». Место для данных в куче

- 198 -

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

На рис. 11.3 представлено распределение памяти области кучи при работе программ, написанных на Турбо Паскале. Куча первоначально всегда свободна и заполняется от нижних адресов в области кучи. Эта область характеризуется двумя предопределенными в языке указателями (переменными типа Pointer): HeapOrg и HeapPtr. Переменная HeapOrg указывает на начало кучи. Как видно из рис. 11.3, куча начинается сразу за оверлейным буфером. Если же программа не имеет оверлейных блоков, то куча начинается сразу за областью стека. Значение HeapOrg постоянно и, как правило, не меняется по ходу выполнения программы.

Переменная HeapPtr указывает на нижнюю границу свободного пространства в куче. Каждый раз, когда в куче размещается наверху новая динамическая переменная, этот указатель перемещается на размер переменной. При этом он нормализуется (приводится к виду СЕГМЕНТ:СМЕЩЕНИЕ) таким образом, что смещение находится в диапазоне от 0 до $F (15). Максимальный размер переменной, которая может быть размещена в куче равен 65520 байт, так как каждая переменная должна находится в одном сегменте и «оставлять» в нем 15 байтов.

Верхняя граница памяти MS-DOS

Рис. 11.3

- 199 -

Переменные HeapOrg и HeapPtr не стоит использовать в программах, пока не требуется распределять память кучи лучше, чем системные процедуры Турбо Паскаля. Но для опытных программистов, собирающихся производить «уборку мусора» и оптимизацию кучи, они могут быть полезны.

11.4. Управление размерами области кучи и стека

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

{$М Стек, МинимумКучи, МаксимумКучи }

при компиляции программы. Эта директива должна быть в первых строках основной программы (в модулях она игнорируется). При указании размеров кучи в директиве {$М...} помните, что программа не будет выполняться, если свободной памяти, оставшейся после загрузки выполнимого файла, будет меньше, чем задано минимальным (нижним) значением МинимумКучи. Всегда должно выполняться условие

МинимумКучи <= МаксимумКучи.

Диапазон значений области стека — от 1024 до 65535 байт (1К...64К), а обоих параметров кучи — от 0 до 655360 байт (0...640К). Максимальное значение объема кучи может быть больше, чем объем реально свободной памяти. В таком случае кучей будет использоваться вся свободная память.

Если директива {$М...} не указана, то значения минимального (нижнего) и максимального (верхнего) размеров кучи устанавливаются равными 0 и 655360 соответственно. Это означает, что под кучу будет использоваться вся оставшаяся в ПЭВМ свободная память.

Можно установить эти параметры в среде программирования, используя меню Options/Compiler/Memory.

Реальная необходимость в явном задании размеров стека и памяти возникает лишь при запуске субпроцессов и организации резидентных программ.

11.5. Процедуры управления кучей

Управление кучей осуществляет монитор кучи, являющийся частью системной библиотеки Турбо Паскаля. Он реализует следу-

- 200 -

ющие процедуры и функции (табл. 11.1), размещающие и удаляющие динамические переменные из кучи и анализирующие ее состояние.

Таблица 11.1

Процедуры и функции

Назначение

New (VAR P : Pointer)

Отводит место для хранения динамической переменной P^ и присваивает ее адрес ссылке P

Dispose (VAR P : Pointer)

Уничтожает связь, созданную ранее New, между ссылкой P и значением, на которое она ссылалась

GetMem (VAR P : Pointer; Size : Word)

Отводит место в Size байт в куче, присваивая адрес его начала указателю (ссылке) P

FreeMem (VAR P : Pointer; Size : Word)

Освобождает Size байт в куче, начиная с адреса, записанного в указателе (ссылке) P

Mark (VAR P : Pointer)

Запоминает в указателе P текущее состояние кучи

Release (VAR P : Pointer)

Возвращает кучу в состояние, запомненное ранее в P вызовом процедуры Mark(P)

New (ТипСсылки) : Pointer

Альтернативная форма создания динамической переменной P^ типа заданного базового типа

MaxAvail : LongInt

Возвращает длину (в байтах) самого длинного свободного участка памяти в куче

MemAvail : LongInt

Возвращает сумму длин всех свободных участков памяти (в байтах)

Размещение динамических переменных.

11.5.1. Процедуры New и GetMem

Размещение динамических переменных Турбо Паскалем выполняется процедурами New( VAR P : Pointer ) и GetMem ( VAR P : Pointer; Size : Word ) или функцией New( ИмяТипаСсылки ) : Pointer и происходит следующим образом. Пусть P описана как ссылочная

- 201 -

переменная, имеющая тип IntPtr, определяющий ссылку на целое число (Integer). Тогда при вызове

New(P);

или

Р := New(IntPtr);

в куче выделяется блок памяти размером SizeOf (Integer) — это 2 байта, и адрес первого байта этого блока запишется в P. Процедура New работает только с типизированными ссылочными переменными, но значение функции New может быть присвоено переменной-указателю. После выполнения New можно уже ссылаться на динамическую переменную P^.

Процедура GetMem требует указания двух параметров. В качестве первого из них должна быть указана ссылочная переменная любого типа. Второй параметр может быть любым выражением, определяющим значение типа Word. Эта процедура производит выделение в куче неразрывного блока памяти с размером, определяемым вторым параметром процедуры (Size), и помещает адрес первого байта этого блока в ссылочную переменную (P).

Можно вызов New(P) заменить на

GetMem(P, SizeOf(ИмяБазовогоТипа_P)),

но по сути своей процедура GetMem предназначена для выделения памяти указателям:

VAR

Р : Pointer; { объявлен указатель }

BEGIN

GetMem(P, 4*1024 );

{ Теперь P указывает на блок памяти размером 4K, }

{ и P^ не имеет типа, но содержит 4096 байт. }

...

END.

Забота о подстановке размера отводимого блока памяти при работе с GetMem перекладывается на программиста так же, как и ответственность за возможную организацию «бардака» в куче при неумелом использовании процедуры GetMem.

11.5.2. Процедуры Dispose и FreeMem

Процедура Dispose (VAR P : Pointer ) освобождает память, занимаемую динамической переменной P^, на которую указывает ее

- 202 -

аргумент P. Эта процедура работает только с типизированными ссылочными переменными. Во избежание проблем вызовы Dispose должны быть парны вызовам New с тем же аргументом и ни в коем случае не применяться к неразмещенным ссылкам.

После выполнения процедуры Dispose значение ссылки P не определено, как и значение разыменования P^.

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

FreeMem( VAR Р : Pointer; Size : Word ).

Она производит освобождение участка памяти, начиная с адреса, передаваемого ей в первом параметре (ссылке или указателе P) и имеющего размер, определяемый вторым параметром (Size). При использовании процедуры FreeMem нельзя забывать, что размер освобождаемого блока должен точно соответствовать размеру, заданному при его размещении посредством GetMem или New. В противном случае либо возникнут потерянные байты, если размер блока при освобождении оказался меньше (а это мусор в памяти), либо в дальнейшем возможна потеря части данных, непосредственно примыкавших к этой области, если размер освобождаемого блока больше ранее отведенного. Последнее чревато особо неприятными последствиями.

Вызовы FreeMem, как и Dispose, в идеале должны быть парны вызовам GetMem. Хотя на практике можно использовать FreeMem вместо Dispose.

Значение ссылочной переменной P после вызова FreeMem считается неопределенным, и ссылаться на P^ в этом случае не стоит.

Если сразу за операторами Dispose или FreeMem следуют конец всей программы или оператор Halt и ему подобные, то можно, в принципе, исключить из программы эти последние процедуры освобождения. Это не совсем по правилам, но может доставить немного радости тем, кто вечно воюет с размером собственных программ. Все сказанное в этом абзаце не относится к резидентным программам.

11.5.3. Процедуры Mark и Release

Механизм действия этих процедур следующий. Пусть переменная P имеет предопределенный тип Pointer, а P1, P2, P3 и P4 объявлены как ссылочные переменные. Пусть текст программы содержит фрагмент

- 203 -

...

New(P1);

New(P2);

Mark(P); { вызов Mark }

New(P3);

New(P4);

...

Release(P); { вызов Release }

...

Перед вызовом процедуры Release куча будет иметь вид, как на рис. 11.4.

Рис. 11. 4

При вызове процедуры Mark в переменную P записалось значение HeapPtr, которое было сразу после размещения P2. Далее были размещены P3 и P4, и указатель HeapPtr передвинулся туда, где он изображен на рис. 11.4.

Если теперь осуществить вызов Release (P), то указатель заполнения кучи HeapPtr переустановится в «позицию», которая была запомнена ранее в указателе P. Куча примет вид, показанный на рис. 11.5.

Рис. 11.5

- 204 -

Действие Release (P) проявилось в том, что куча вернулась в предыдущее состояние, «забыв» обо всех динамических переменных, созданных после выполнения процедуры Mark(P). Теперь уже не надо освобождать ссылки P3 и P4. Их нет, как будто они и не размещались.

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

Очевидно, что пара процедур Mark/ Release — это очень мощное средство управления кучей. Они позволяют эффективно освобождать память с минимальными усилиями. Однако за это приходится платить гибкостью использования пространства кучи. При их применении освобождение памяти должно производится в порядке, обратном размещению динамических переменных. Так, например, нельзя удалить переменную P2^, не удалив при этом переменные P3^ и P4^. Для более гибкого использования кучи необходимо применять процедуры Dispose и FreeMem.

Вместе с тем не рекомендуется перемежать вызовы процедур Release с вызовами процедур Dispose и FreeMem. Две последние действуют избирательно и могут освобождать блоки памяти в используемой части кучи. Так, если после строки New(P4) в рассмотренном примере поставить вызов Dispose (P1), то перед выполнением Release (P) на месте динамической переменной P1^ будет пусто, и это пустое место могло бы быть потом использовано для размещения других данных. Координаты этого пустого (свободного) блока хранятся в специальном списке свободных блоков. Процедура Release (P) среди всего прочего стирает список свободных блоков, навсегда блокируя тем самым доступ к свободным блокам, находящимся ниже значения указателя P. Об этом надо помнить всегда, иначе можно легко и незаметно заблокировать всю кучу и потерять массу времени на нетривиальное решение вечного вопроса «почему программа не пошла?»

11.5.4. Функции MaxAvail и MemAvail

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

Функция MaxAvail возвращает длину в байтах самого длинного свободного блока. Она находится как максимальное значение из размера свободной части кучи и размеров освобожденных к данному

- 205 -

моменту блоков. Выдаваемое MaxAvail значение имеет смысл размера наибольшей сплошной структуры данных (как массив, запись, объект), которая могла бы уместиться в куче. Правда, такая сплошная структура данных сама ограничена размером в 65520 байт.

Полный объем свободного пространства (памяти) в куче можно опросить функцией MemAvail. Она вернет сумму длин всех свободных блоков в куче: и освобожденных, и еще ни разу не использованных.

Эти две функции полезны при анализе ресурсов памяти перед размещением динамических переменных, особенно процедурой GetMem. На рис. 11.6 показан пример их использования.

| PROGRAM TestHeap; {ПРОГРАММА, АНАЛИЗИРУЮЩАЯ МЕСТО В КУЧЕ}

| TYPE

| Dim = Array [1..5000] of LongInt; { базовый тип }

| VAR

| P : ^Dim; { ссылка на базовый тип — массив }

| Psize : LongInt; { переменная для анализа размера }

| CONST

| SL = SizeOf(LongInt); { размер элемента массива }

| BEGIN

| WriteLn( 'В куче свободно ', MemAvail, ' байт' );

| {Psize округляется до целого числа значений LongInt:}

| Psize := SL*(MaxAvail div SL);

| if SizeOf(Dim) > Psize

| then begin { мало места в куче }

| WriteLn('Массив P^ не может быть размещен целиком');

| GetMem( P. Psize ); { отводим Psize байт }

| WriteLn( ' Размещено ', Psize div SL, ' элементов' )

| end

| else begin { достаточно места }

| New( P ); { размещаем массив }

| Psize := SizeOf(Dim); { объем массива P^ }

| WriteLn( 'Динамический массив P размещен' )

| end;

| { ... работа с динамическим массивом ... }

| FreeMem(P, Psize);{универсальное освобождение массива}

| END.

Рис. 11.6

11.5.5. Более детальный анализ состояния кучи

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

- 206 -

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

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

Указатель на список свободных блоков хранится в предопределенной системной переменной FreePtr типа Pointer. Эта переменная фактически указывает на массив записей типа FreeList, т.е. соответствует типу FreeListP:

TYPE

FreeRec = RECORD { Указатели на }

OrgPtr, EndPtr : Pointer; { начало и конец }

END; { блока в куче }

FreeList = Array [0..8190] of FreeRec;

FreeListP = ^FreeList; { ссылка на массив записей }

Поля OrgPtr и EndPtr каждой записи определяют начало и конец каждого свободного блока (EndPtr, точнее говоря, указывает на первый байт после блока) и являются нормализованными указателями.

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

Число освобожденных пустых блоков (элементов в массиве FreeList) на текущий момент можно вычислить по формуле

FreeCount := (8192 - Ofs(FreePtr^) div 8) mod 8192;

Максимальное число свободных блоков, которые могут существовать одновременно, равно емкости массива FreeList (8191 блок). Число это достаточно велико, чтобы достичь его на практике. Если же это удастся, то возникнет фатальная ошибка и останов программы.

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

- 207 -

участка памяти между HeapPtr и списком свободных блоков (FreePtr). Для этого необходимо в FreeMin записать гарантированный размер этого участка в байтах. Чтобы при этом не происходило потерь памяти, значение размера должно быть вычислено как

ЧИСЛО_ЭЛЕМЕНТОВ_СПИСКА_В_ЗАЗОРЕ*8,

где 8 — размер записи FreeRec. Когда значение FreeMin не равно нулю, вызовы процедур New и GetMem будут неэффективными, если они пытаются сделать расстояние между HeapPtr и FreePtr меньше FreeMin. Кроме того, MaxAvail и MemAvail будут вычитать FreeMin из возвращаемых значений.

Иногда необходимо знать величину еще ни разу не использованного пространства кучи (между значениями указателей FreePtr сверху и HeapPtr снизу). Функция HeapAvail, анализирующая размер именно этого пространства (без учета освобожденных блоков в куче), приводится на рис. 11.7.

| { $М 1024, 4000, 4000} (*заданные параметры кучи для теста*)

| FUNCTION HeapAvail : LongInt;

| VAR

| LongSeg, LongFreePtr, LongHeapPtr : LongInt;

| BEGIN

| LongSeg := Seg(FreePtr^)+$1000*Byte(Ofs(FreePtr^)=0);

| LongFreePtr :=(LongSeg * 16 ) + Ofs(FreePtr^);

| LongSeg := Seg( HeapPtr^);

| LongHeapPtr := ( LongSeg*16 ) + Ofs( HeapPtr^);

| HeapAvail := LongFreePtr – LongHeapPtr

| END;

| procedure WriteAvail; { вспомогательная процедура }

| begin

| WriteLn( ' MemAvail=', MemAvail :6,

| ' MaxAvail=', MaxAvail :6,

| ' HeapAvail=', HeapAvail :6 )

| end; {WriteAvail}

| VAR { ПРИМЕР АНАЛИЗА ПАМЯТИ КУЧИ }

| P1, P2 : Pointer;

| BEGIN

| WriteLn( 'Начало работы:' ); WriteAvail;

| GetMem ( P1, 1000 ); { отводится 1000 байт в куче }

| GetMem ( Р2, 10 ); { отводится 10 байт в куче }

| WriteLn('Размещены в куче 2 переменные(1000 и 10 б)');

| WriteAvail;

| FreeMem( P1, 1000 ); { освобождается первый блок }

- 208 -

{Сейчас в куче появилась дыра, а в списке свободных блоков появились ее координаты, уменьшив кучу на 8 байт.}

| WrfteLn( 'Освобождена ссылка на 1000 байт:' );

| WriteAvail;

| FreeMem( P2, 10 ); { освобожден второй блок }

| { Теперь вся куча пуста, и нет нужды в списке блоков. }

| WriteLn( 'Освобождена ссылка на 10 байт:' );

| WriteAvail;

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 11.7 (окончание)

Заметьте, что все локальные параметры в функции HeapAvail имеют тип LongInt, чтобы хранить десятичные значения ненормализованных (абсолютных) адресов. Чтобы избежать потери порядка из-за превышения диапазона типа Word, значения функций Seg(...) перед умножением переписываются в переменную более «длинного» типа LongInt.

Следующий вопрос, связанный со списком свободных блоков, — это потенциальная проблема дробности. Она связана с тем, что дробность в мониторе кучи равна одному байту. Это означает, что при размещении одного байта переменная будет занимать один байт. При размещении и удалении в произвольном порядке большого числа переменных или блоков различной длины могут появляться свободные блоки небольшого размера, причем число таких блоков может быть большим. Так, например, при освобождении блока размером 20 байт и размещении вслед за этим блока размером 19 байт, появится свободный блок длиной 1 байт, который может находиться в списке свободных блоков довольно долго. Для решения этой проблемы справочное руководство по Турбо Паскалю советует воспользоваться следующим приемом. Каждый раз выделять и впоследствии освобождать блок с размером, кратным какому-либо целому числу байтов. Для этого необходимо переопределить процедуры GetMem и FreeMem. Например, если мы хотим выделять память блоками с размером, кратным 16 байт, то переопределения GetMem и FreeMem будут выглядеть следующим образом:

PROCEDURE GetMem( VAR P : Pointer; Size : Word );

BEGIN

System.GetMem(P, (Size+15) and $FFF0);

END; { GetMem }

- 209 -

PROCEDURE FreeMem( VAR P : Pointer; Size : Word );

BEGIN

System.FreeMem( P, (Size+15) and $FFF0);

END; { FreeMem }

В этом случае минимальный размер свободного блока будет не меньше 16 байт. Однако это будет справедливо до тех пор, пока не будут применены процедуры New и Dispose. Процедура New, например, может для переменной, имеющей размер, не кратный 16 байт, использовать такой свободный блок, что останется пустой излишек с размером менее 16 байт. И уж он-то будет находиться в памяти очень долго. Ситуация осложняется еще тем, что мы теперь уже не можем так просто управлять размером выделяемого блока. Возможным средством улучшить ситуацию является приведение размера динамической переменой к величине, кратной 16 байт. Так, например, если необходимо размещать в куче переменные типа:

TYPE

Dot = RECORD x,y : Real END;

размером 12 байт (6+6), то его размер необходимо увеличить еще на 4 байта. Для этого вместо приведенного выше описания необходимо дать следующее:

TYPE

Dot = RECORD

х, у : Real;

foo : Array [1..4] of Byte

END;

Теперь при размещении переменной типа Dot память будет выделяться и, что самое главное, освобождаться блоками по 16 байт. Заметим, что в принципе можно было бы отказаться от использования процедур New и Dispose и управлять памятью с помощью одних лишь процедур GetMem и FreeMem, хотя это вызвало бы определенные трудности при работе с объектами.

11.5.6. Обработка ошибок распределения памяти

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

FUNCTION ИмяФункции( Size : Word ) : Integer;

- 210 -

Обычно ее называют HeapFunc. Эта функция вызывается в случае, когда New или GetMem не может обработать запрос на распределение кучи. Параметр Size содержит размер блока, который не мог быть распределен, и функция обработки ошибки должна попытаться освободить блок размером не меньше Size. В качестве результата функция должна возвращать значения 0, 1 или 2. В случае 0 немедленно будет возникать фатальная ошибка и останов программы. В случае 1 вместо аварийного завершения процедуры New или GetMem будет возвращаться указатель, равный nil. Наконец, 2 означает как бы замалчивание ошибки, но вызывает повторение запроса на распределение, что, впрочем, может опять вызвать ошибку.

Необходимо, чтобы эта функция компилировалась в режиме {$F+}. Функция обработки ошибки (пусть в программе она названа UserHeapFunc) может быть подставлена в монитор кучи присваиванием ее адреса системной переменной HeapError:

HeapError := @UserHeapFunc;

Мало смысла в том, чтобы писать свои функции HeapFunc, возвращающие значение 0. Программа и так оборвется при нехватке памяти в куче. Зато очень удобно обрабатывать ошибки распределения памяти, если установить возвращаемое значение равным 1:

{$F+}

FUNCTION HeapFunc(Size : Word) : Integer;

BEGIN

HeapFunc := 1

END;

{$F-}

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

...

New(P);

if P = nil then обработка ситуации нехватки памяти;

{иначе нормальная работа с P^}

...

Если пойти еще дальше, то можно написать функцию HeapFunc такой структуры:

- 211 -

($F+}

FUNCTION HeapFunc( Size : Word ) : Integer;

BEGIN

{ ОСВОБОЖДЕНИЕ КАКИМ-ЛИБО СПОСОБОМ Size БАЙТ В КУЧЕ }

HeapFunc := 2 {и повтор неудачного распределения }

END;

{$F-}

Начальное значение переменной HeapError при старте программы равно nil. Его же надо восстанавливать, если отпала необходимость в обработке ошибок кучи.

11.6. Ссылки, работающие не с кучей

Традиционно понятие «ссылка» всегда увязывается с динамическими переменными, кучей и т.п. У Турбо Паскаля тоже есть традиции. Одна из них — расширение общепринятых стандартов. В частности, ничто, кроме традиционных учебников стандартного Паскаля, не обязывает связывать ссылки или указатели именно с кучей. Ссылки могут указывать на что угодно: даже на выполнимый код программы (крайний и бесполезный случай). Обычно в разных трюках ссылки связываются со статическими данными или с системными областями памяти ПЭВМ (областью данных БСВВ, видеопамятью и др.).

Кроме способа связывания, такие ссылки ничем не отличаются от рассмотренных ранее (рис. 11.8).

| PROGRAM NoHeap;

| { ПРИМЕР ССЫЛОК БЕЗ ИСПОЛЬЗОВАНИЯ КУЧИ }

| TYPE { базовые типы: }

| VideoArray=Array[1..4000] of RECORD {структура экрана }

| Symbol : Char;

| Attrib : Byte

| END;

| Vector=Array[1..100] of Real; { одномерный массив }

| Matrix=Array[1..10,1..10] of Real;{ матрица 10 на 10 }

| VAR

| VideoPtr : ^VideoArray; { ссылка на структуру экрана }

| Vec : Vector; { ссылка на одномерный массив }

| MatPtr : ^Matrix; { ссылка на массив — матрицу }

| P : Pointer; { просто указатель }

| i : Word; { счетчик для циклов }

Рис. 11.8

- 212 -

| BEGIN

| VideoPtr := Ptr( $B800, 0 );

{Переменная VideoPtr теперь содержит адрес начала видеопамяти в цветных и черно-белых режимах. Для режима mono надо подставить в присваивании Ptr{$B000,0). После этого можно непосредственно обращаться к видеопамяти. }

| for i:=1 to 4000 do begin

| { Заполнение видеопамяти}

| VideoPtr^[i].Symbol:= '+'; { символом '+' в ярко- }

| VideoPtr^[i].Attrib:=15+128 { белом цвете с мерцанием}

| end {for};

| ReadLn; { пауза до нажатия клавиши ввода }

| { Заполнение статического массива Vec: }

| for i:=1 to 100 do Vec[i] := i*3.14;

| MatPtr := Addr(Vec); {передача его адреса ссылке MatPtr}

{Теперь к 100 элементам одномерного массива Vec можно обращаться и как к элементам матрицы 10x10, используя разыменование ссылочной переменной MatrPtr^. Здесь мы распечатаем диагональные элементы матрицы: }

| for i:=1 to 10 do WriteLn(' ':i, MatPtr^[i,i]:-9:2 );

| ReadLn; { пауза до нажатия клавиши ввода }

| { и т.п. }

| END.

Рис. 11.8 (окончание)

Советуем внимательно рассмотреть пример на рис. 11.8. В нем нет ни процедур New/Dispose, ни GetMem/FreeMem! Динамические переменные здесь не создаются и не освобождаются. Взамен этого в ссылки «ручным способом» записываются адреса тех блоков памяти, с которыми мы хотели бы работать. А далее мы обращаемся с ними, как будто они есть структурированные динамические переменные.

Подобная техника открывает доступ к видеопамяти через любые структуры, позволяет проделывать такие вещи, как запись текстов с экрана на диск или их загрузку, подмену структур обращения к данным (как альтернатива приведению типов) и многое другое. Ссылки без кучи в последующих программах-иллюстрациях будут использоваться не раз, особенно при работе с видеопамятью.

11.7. Как организовать структуры, большие чем 64К?

Цифра 64K постоянно преследует разработчика больших программ. Сумма размеров всех глобальных переменных и типизированных констант не может превышать 64K. Размер типа тоже не может превышать 64K:

- 213 -

TYPE { матрица 200x200 }

Dim200x200 = Array [1..200, 1..200] of Real;

В таком описании размер типа равен 200x200x6 байт, что составит более 234К. Компилятор этого ни за что не пропустит, и переменная типа Dim200x200, понятно, не может быть объявлена. С другой стороны, эти 240K вполне могли бы разместиться в средних размеров куче. И это можно сделать!

Нужно лишь реорганизовать этот массив так, чтобы он распался на части, не превышающие по отдельности 64K каждая:

TYPE

Dim200 = Array [1..200] of Real;

Dim200Ptr = ^Dim200;

Dim200x200 = Array [1..200] of Dim200Ptr;

VAR

D : Dim200x200;

Здесь мы определяем тип Dim200 (тип строки матрицы) и тип ссылки на строку Dim200Ptr. После этого определяется тип матрицы 200x200 как статический массив из 200 ссылок на динамические массивы по 200 элементов. Последние вполне могут поместиться в куче. Тем более, что для каждого массива понадобится блок длиной 200x6 байт, а сами эти блоки могут размещаться в разных частях кучи. Размещение такой структуры немного усложнилось:

for i:=1 to 200 do New( D[i] );

как и освобождение:

for i:=1 to 200 do Dispose( D[i] );

Обращение к элементу массива D (разыменование) имеет вид D[i]^[j], где i — номер строки, a j — номер столбца.

Описанный прием достаточно эффективен для многомерных массивов и записей. Таким образом, можно заменять части структуры ссылками на них и забыть про предел в 64K. Но с одномерным массивом так поступить уже нельзя. Придется искать какие-либо обходные пути.

Существует несколько способов хранения данных и их структур, которые ограничены лишь свободным объемом памяти (ОЗУ). К ним относятся списочные структуры, деревья (графы). Отдельно можно выделить структуры типа «стек».

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

- 214 -

ки* nil, т.е. уже ни на что не ссылается. Списки легко создаются, добавляются с любого конца; их можно размыкать для вставки нового элемента, исключать элементы и т.д.

* Так напечатано. Видимо при печати пропущена часть текста.— Ю. Ш.

Мы не будем здесь рассматривать работу со списками. Большинство учебных и справочных изданий по языку Паскаль содержит основные принципы работы с ними.

Вместо этого мы предлагаем пример модуля, реализующего процедуры работы со стеком. Стек, или магазин, иногда называется списком LIFO (последним вошел — первым вышел). Это структура данных, при которой элемент, первым помещенный в стек, будет извлечен оттуда последним. И наоборот, доступнее всех последний положенный в стек элемент. Аналог стека — детская разборная пирамидка из дисков на штырьках. Надеть диск сверху — значит поместить в стек очередное значение. Снять диск (а снять можно только верхний диск) — значит вытолкнуть значение из стека. Доступ к содержимому стека всегда последователен, причем порядок выгрузки элементов из стека обратен порядку их загрузки в стек.

11.8. Практический пример построения стека

Организация стека основана на связном списке, и поэтому стек занимает в памяти только необходимый на данный момент объем. Наглядно структура стека представлена на рис. 11.9.

Рис. 11.9

- 215 -

Сумма размеров всех хранимых в стеке данных ограничена только размером свободной памяти в куче, хотя элемент данных по-прежнему не должен превышать 64K. Стек оптимален для случаев, когда требуется просчитать и запомнить большое число структур данных, а потом обработать их в обратном порядке (в других случаях он мало полезен). К недостатку стека и списков, вообще, надо отнести расход памяти под узлы (здесь — 2x4 байта на каждый узел). Но если элемент хранимых данных имеет размер, например, 16K, с восемью байтами можно примириться.

Ниже приведен текст модуля StackManager (рис. 11.10), реализующего операции со стеком и пример программы, использующей его (рис. 11.11). Все тексты написаны и любезно предоставлены Г.П. Шушпановым.

| UNIT StackManager; {БИБЛИОТЕКА СРЕДСТВ РАБОТЫ СО СТЕКОМ }

| INTERFACE

| CONST { коды ошибок, возникающих при работе со стеком }

| StackOk =0; { успешное завершение }

| StackOverflow =1; { переполнение стека }

| StackUnderflow =2; { стек был пуст }

| VAR

| StackError : Byte; { результат операции со стеком }

| TYPE

| NodePtr = ^Node; { ссылка на узел }

| Node = RECORD { Узел, состоящий из }

| Info : Pointer; { ссылки на значение и }

| Next : NodePtr; { ссылки на следующий }

| END; { узел. }

| Stack = RECORD { тип стека - запись }

| Head : NodePtr; { ссылка на голову списка }

| Size : Word; { размер элемента данных в }

| END; { стеке }

| PROCEDURE InitStack( VAR S : Stack; Size : Word );

| { формирует стек с элементами размера Size }

| PROCEDURE ReInitStack(VAR S : Stack; Size : Word);

| { переопределяет стек для элементов другого размера }

| PROCEDURE ClearStack( VAR S : Stack );

| { очищает стек }

| PROCEDURE Push( VAR S : Stack; VAR E );

| { помещает значение переменной E в стек S }

Рис. 11.10

- 216 -

| PROCEDURE Pop( VAR S : Stack; VAR E );

| { выталкивает значение из стека в переменную E }

| PROCEDURE Top( VAR S : Stack; VAR Е );

| { копирует значение на вершине стека в переменную E }

| FUNCTION Empty( VAR S : Stack ) : Boolean;

| { возвращает True, если стек пуст }

| IMPLEMENTATION

| VAR { переменная для хранения }

| SaveHeapError : Pointer; { адреса старой функции }

| { обработки ошибок кучи }

| {$F+}

| FUNCTION HeapFunc( Size : Word ) : Integer;

| BEGIN

| HeapFunc := 1;

| {вернуть nil, если нельзя разместить переменную в куче}

| END;

| {$F-}

| PROCEDURE InitStack( VAR S : Stack; Size : Word );

| BEGIN { сохранение стандартного }

| SaveHeapError := HeapError; { обработчика ошибок кучи }

| S.Head := nil; { установка вершины }

| S.Size := Size; { размер значения }

| StackError := StackOk; { все в порядке }

| END;

| PROCEDURE ReInitStack(VAR S : Stack; Size : Word );

| BEGIN

| if S.Head <> nil then

| ClearStack(S); { очистка стека }

| S.Size := Size; { установка нового размера значения }

| StackError := StackOk; { все в порядке }

| END;

| PROCEDURE СlearStack(VAR S : Stack);

| VAR Deleted : NodePtr; { удаляемый элемент }

| BEGIN

| StackError := StackOk;

| while S.Head <> nil do

| begin { Цикл по всем элементам:}

| Deleted := S.Head; { удаляемый узел }

| S.Head := Deleted^.Next; { продвижение вершины }

| FreeMem(Deleted^.Info,S.Size); { удаление значения }

| Dispose(Deleted); { удаление узла }

| end { while }

| END;

Рис. 11.10 (продолжение)

- 217 -

| PROCEDURE Push( VAR S : Stack; VAR E );

| LABEL Quit;

| VAR

| NewNode : NodePtr; { новый узел }

| BEGIN { Подстановка функции }

| HeapError := @HeapFunc; { обработки ошибок. }

| StackError := StackOverflow; { возможно переполнение }

| NewNode := New(NodePtr); { размещение узла }

| if NewNode = nil

| then goto Quit; { Негде! Выход. }

| NewNode^.Next := S.Head; { установление связи }

| S.Head := NewNode; { продвижение вершины }

| GetMem(NewNode^.Info,S.Size); { размещение значения }

| if NewNode^.Info = nil

| then goto Quit; { Негде! Выйти. }

| Move(E, NewNode^.Info^,S.Size); { перенос значения }

| StackError := StackOk; { Все в порядке. Выход }

| Quit:

| HeapError := SaveHeapError; { вернем старую функцию }

| END;

| PROCEDURE Pop( VAR S : Stack; VAR E );

| VAR Deleted : NodePtr; { выталкиваемый узел }

| BEGIN

| StackError := StackUnderflow; { возможна неудача }

| if S.Head = nil then Exit; { Стек пуст! Выход. }

| Deleted := S.Head; { удаляемый узел }

| S.Head := Deleted^.Next; { продвижение вершины }

| Move(Deleted^.Info^,E,S.Size); { перенос значения }

| FreeMem(Deleted^.Info,S.Size); { удаление значения }

| Dispose(Deleted); { удаление узла }

| StackError := StackOk; { все в порядке }

| END;

| PROCEDURE Top( VAR S : Stack; VAR E );

| BEGIN

| StackError := StackUnderflow; { возможна неудача }

| if S.Head = nil then Exit; { Стек пуст! Выход. }

| Move(S.Head^.Info^,E.S.Size); { перенос значения }

| StackError := StackOk; { все в порядке }

| END;

| FUNCTION Empty( VAR S : Stack ) : Boolean;

| BEGIN

| Empty := S.Head = nil { пусто, если список пуст }

| END;

| END. { unit StackManager }

Рис. 11.10 (окончание)

- 218 -

| PROGRAM UsesStack;{ПРОГРАММА, ХРАНЯЩАЯ ЗНАЧЕНИЯ В СТЕКЕ}

| USES StackManager; VAR

| St : Stack; { переменная структуры типа Stack (стек) }

| I : Integer;

| R : Real;

| В : Byte;

| BEGIN

| InitStack( St, SizeOf( Integer ) ); { стек целых }

| { Поместить в стек 100 целых значений: }

| for I:=1 to 100 do Push( St, I );

| WriteLn( ' ':20, 'Первые 100 чисел' );

| WriteLn( ' ': 20, '(целые значения)' );

| WriteLn;

| while not Empty(St) do begin { Пока стек не пуст: }

| for В := 1 to 10 do begin {порциями по 10 элементов}

| Pop( St, I ); { вытолкнуть очередное зна- }

| Write( I:5 ) { чение и напечатать его }

| end; { for В }

| WriteLn { закрытие строки 10 чисел }

| end; { while }

| ReadLn; { пауза до нажатия ввода }

| ReInitStack(St,SizeOf(Real)); {изменяется тип данных }

| { Поместить в стек 100 вещественных значений: }

| for I := 1 to 100 do begin

| R := I; { перевод в тип Real }

| Push( St, R ); {и поместить его в стек }

| end; { for I }

| WriteLn( ' ':20, 'Первые 100 чисел' );

| WriteLn( ' ': 17, '(вещественные значения)' );

| WriteLn;

| while not Empty(St) do begin { Пока стек не пуст: }

| for B:=1 to 10 do begin { порциями по 10 элементов: }

| Pop( St,R ); { вытолкнуть следующее зна- }

| Write( R : 5 : 1 ) { чение и напечатать его }

| end; { for В }

| WriteLn { закрытие строки 10 чисел }

| end; { while }

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 11.11

Обращаем внимание на рекурсивность в определении списка (вернее, его узла типа Node на рис. 11.10). В самом деле, тип ссылки на узел (NodePtr) определен, до того как задан сам тип узла Node.

- 219 -

Но в то же время поле Next узла имеет тот же тип NodePtr. Этот парадокс типов Паскаля разрешается самим компилятором. Можно определять ссылки на данные, содержащие элементы того же типа ссылки. Рекомендуется именно такой способ их задания, как в примере. Однако можно было бы перенести описание типа NodePtr за описание типа Node — ничего страшного не произошло бы.

- 220 -

Глава 12. Ввод-вывод данных и файловая система

Любой обмен данными подразумевает наличие источника информации, канала передачи и ее приемника. В случае обмена данными между программой и периферийными устройствами одним концом канала обмена данными всегда является оперативная память ПВЭМ. Другой конец этого канала в Турбо Паскале определен как файл.

Понятие файла достаточно широко. Это может быть обычный файл данных на диске или коммуникационный порт, устройство печати или что-либо другое. Файл может быть источником информации – тогда мы читаем из файла (ввод данных из файла) или приемником – в этом случае мы записываем в файл (вывод данных в файл).

Операция вывода данных означает пересылку данных из рабочей памяти (ОЗУ) в файл, а операция ввода – заполнение ячеек памяти данными, полученными из файла.

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

12.1. Понятие логического файла

Логический файл описывается как переменная одного из файловых типов, определенных в Турбо Паскале. После того как в программе в разделе описания переменных объявлена файловая переменная, она может быть использована как средство общения с любым физическим файлом, независимо от природы последнего. Само имя физического файла может появиться в программе только один раз, когда специальной процедурой устанавливается, что объявленный логический файл будет служить средством доступа именно к этому физическому файлу (данным на диске, портам, печати и т.п.) Если, например, мы хотим работать с текстовым файлом 'A:\TEXT.DOC', то в программе должны быть такие строки:

- 221 -

VAR

f : Text; { объявляем файловую переменную f (вводим

логический файл типа текст) }

BEGIN

Assign( f, 'A:\TEXT.DOC' ); { связываем физический файл 'a:\text.doc'

на диске А: с логическим файлом f }

...

END.

После этого все обращения к файлу на диске будут производиться через файловую переменную f.

Введение логического файла позволяет программисту не задумываться о технических проблемах организации обмена данными, а заняться программированием самого потока данных. Различные физические файлы имеют различные механизмы ввода и вывода информации. Все особенности физических файлов «спрятаны» в механизме логических файлов, которые сами определяют, как наладить обмен данными со связанными физическими файлами. Иными словами, логические файлы унифицируют работу с файлами, позволяя работать не непосредственно с устройствами ПЭВМ, а с их логическими обозначениями.

12.2. Физические файлы в MS-DOS

Что такое физические файлы? Ответ на этот вопрос лучше искать не в руководствах по Турбо Паскалю, а в описаниях MS-DOS. Все, что является файлом в MS-DOS, является физическим файлом в Турбо Паскале. Банальный пример — файл с данными на диске (гибком, жестком, виртуальном — все равно). Определяется физический файл строкой с его названием (именем). В Турбо Паскале имена могут быть строковыми константами или храниться в строковых переменных. Имя файла на диске может иметь адресную часть, оформленную в соответствии с правилами MS-DOS:

'C:\PAS\TESTFILE.PAS' ,

'A:TEST.TXT'

'..\PRIMER.BAS'

Другая разновидность физических файлов — это устройства MS-DOS. MS-DOS не делает особого различия между «традиционными» файлами и устройствами (портами коммуникаций). Устройства имеют свои фиксированные имена и во многом схожи с файлами: имя устройства, например, может встать на место имени файла на диске при копировании. Имена устройств

- 222 -

MS-DOS и необходимые замечания по ним сведены в табл. 12.1.

Таблица 12.1

Имя

Расшифровка устройства

Примечание

CON

Консоль (клавиатура и экран)

Ввод из CON — это чтение с клавиатуры, а вывод в CON — это запись на экран

LPT1 LPT2 LPT3

Параллельные порты (типа Centronix) номер 1…3 (если установлены)

Через эти имена файлов происходит вывод данных на принтеры или другие устройства с интерфейсом типа Centronix

PRN

Принтер. Синоним имени LPT1

Имя обращения к принтеру, включенному в порт LPT1

COM1 COM2

Последовательные порты (типа RS-232) номер 1..2 (если установлены)

Имена файлов-устройств для ввода-вывода данных через серийные порты коммуникации.

AUX

Синоним имени COM1

Файл-устройство COM1

NUL

Фиктивное устройство

Это бездонный файл, принимающий что угодно, но всегда пустой

Физические файлы-устройства организуются как текстовые файлы, и для нормальной работы их надо связывать с текстовыми логическими файлами. Хотя, если понадобится, можно устанавливать связь и с бестиповымн файлами (например, при работе с 'COM1' или 'COM2').

Как видно из табл. 12.1, у устройства есть свои особенности. Например, 'CON' — одно имя двух устройств. Если логический файл, которому назначено устройство 'CON', открывается для чтения, то в действительности он связывается с клавиатурой, но если для записи, то — с экраном! В то же время 'LPT1'...'LPT3', 'PRN', а с ним и 'NUL', могут быть открыты только для записи в них, а если все же они открыты для чтения, то сразу же возвращают признак конца файла. Никакого сбоя при этом не будет. Серийные порты — двусторонние. Позволяют считывать из себя и принимать данные. «Файл-пустышка» 'NUL' нужен для отладки программ, использующих другие порты.

Имена физических файлов-устройств должны быть записаны так же, как и в таблице: без точек и прочих знаков после них. Регистр букв роли не играет: 'CON', 'con' — консоль, 'PRN' — принтер, но

- 223 -

'CON.' — это файл на текущем диске, с именем CON и пустым расширением. Можно приписывать после имени устройства двоеточие, но лучше обходится без этого. Так, 'PRN' и 'PRN:' — это одно и то же.

Не определена такая структура данных, как файл в памяти ПЭВМ. Любой объявленный логический файл имеет смысл только после связи с внешним физическим файлом.

Турбо Паскаль позволяет программировать собственные механизмы для работы с периферией ПЭВМ или виртуальными устройствами — так называемые драйверы текстовых устройств. Но для этого надо вручную переписать почти всю библиотеку процедур работы с файлами. Заинтересованные читатели могут найти нужную им информацию в справочном руководстве по Турбо Паскалю [2].

12.3. Понятие буфера ввода-вывода

С файловой системой Турбо Паскаль связано понятие буфера ввода-вывода. Может показаться странным, но если выполнилась команда записи данных в файл на диске, то это вовсе не означает, что на диске действительно появились новые данные. Вывода данных (как впрочем, и ввод), осуществляется через буфер. Буфер – это область в памяти, отводимая при открытии файла. При записи в файл вся информация сначала направляется в буфер и там накапливается до тех пор, пока весь объем буфера не будет заполнен. Только после этого или после специальной команды сброса буфера происходит передача данных по предназначению: на диск, порт. Аналогично при чтении из файла считывает не столько, сколько запрашивается, с сколько уместится в буфер. И если, например, считывается 4 числа, а буфер вмещает 64, то следующие 60 чисел будут считаны уже из буфера.

Механизм буферизации позволяет более быстро и эффективно обмениваться информацией с различными устройствами. Для текстовых и бестиповых файлов можно устанавливать размер буфера по своему усмотрению.

Вывод текстовой информации на экран реализован так, что эффект буферизации исчезает автоматически, иначе компьютер постоянно «недоговаривал» бы свои ответы.

12.4. Файловые типы Турбо Паскаля

Турбо Паскаль поддерживает три файловых типа:

— текстовые файлы (типа Text);

- 224 -

— компонентные файлы (типа File Of ... );

— бестиповые файлы (типа File).

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

Текстовые файлы — это файлы, состоящие из кодов ASCII, включая расширенные и управляющие коды. Текстовые файлы организуются по строкам и обязательно содержат специальный код, называемый концом файла. Любую информацию (числовую, символьную или строчную) текстовый файл хранит в виде символов, ее изображающих. Например, текст программы на Паскале — это текстовый файл. Его можно вывести на экран командой MS-DOS TYPE или на печать командой PRINT и прочитать. Но выполняемый ЕХЕ-файл, полученный после компиляции, уже не будет текстовым. И, если удается увидеть или распечатать его содержимое, то прочитать, например, как эту страницу точно не удается. Пример текстового файла — бегущие строки на экране дисплея, когда он работает в текстовом режиме. При наборе букв и цифр на клавиатуре, создается текстовый файл.

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

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

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

Файловые переменные, описанные в программе, не могут участвовать в операторах присваивания.

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

- 225 -

12.5. Общие процедуры для работы с файлами

Турбо Паскаль вводит ряд стандартных процедур, применимых к файлам любых типов (табл. 12.2). Кроме этого, существует ряд их расширений и специальных процедур для работы с различными типами файлов. Такие процедуры будут рассматриваться в разделах, посвященных различным типам файлов. Описания процедур ввода и вывода данных Write, WriteLn, Read и ReadLn не включены в этот раздел, так как они достаточно сильно различаются при работе с разными типами файлов, а иногда (при работе с бестиповыми файлами) и вовсе теряют смысл.

В Турбо Паскале не определены процедуры ввода и вывода в файлы Get(f) и Put(f), и их функции выполняют другие процедуры ввода-вывода. Не определено также обращение к буферной переменной f^.

Таблица 12.2

Процедура или функция

Действие

Assign(VAR f; FileName : String)

Связывает файловую переменную f с именем физического файла, заданным в строке FileName

Reset(VAR f)

Открывает файл с логическим именем f для чтения

Rewrite(VAR f)

Открывает файл с логическим именем f для записи

Close(VAR f)

Закрывает канал ввода-вывода файла с логическим именем f

Rename(VAR f; NewName : String))

Переименовывает физический файл, ранее связанный с файловой переменной f, в имя NewName. Должна вызываться до открытия файла (применима лишь к закрытым файлам)

Erase(VAR f)

Стирает (если это возможно) физический файл, связанный с файловой переменной f с носителя информации. Стираемый файл должен быть закрытым

- 226 -

EOF(VAR f) : Boolean

Возвращает значение True, если достигнут конец файла f, т.е. из него ничего уже нельзя прочитать или файл пуст. Иначе возвращает False

Файловая переменная f может иметь любой файловый тип.

12.5.1. Связывание файлов

Процедура Assign (VAR f; FileName: String) устанавливает связь между логическим файлом, описываемым файловой переменной f любого файлового типа, и конкретным файлом MS-DOS, название которого содержится в строковом параметре FileName. Иными словами, логический файл f связывается с физическим файлом FileName. Строка FileName может содержать имя файла на диске (в том числе полное имя файла), имя стандартного устройства MS-DOS ('CON', PRN' и т.п.) или пустую строку '':

Assign( f, 'file.dat' ); {связь с файлом текущего каталога }

Assign( f, 'a:\x.pas' ); {связь с файлом x.pas на диске А: }

Assign(' f, 'LPT2' ); {связь со вторым принтером ПЭВМ }

Assign( f, ' ' ); {связь со стандартным файлом, как правило файлом 'CON' }

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

Процедура Assign не занимается анализом корректности имени файла и безоговорочно связывает заданное имя с логическим файлом f. Логический файл при этом считается закрытым, а размер буфера файла — неопределенным. Если файл f связан с некорректным именем, то это вызовет ошибку ввода-вывода лишь при попытке произвести любое действие над ним (будь то открытие файла, удаление его или что-либо другое).

Будучи однажды установленной, связь между файловой переменной f и физическим файлом сохраняется до следующего вызова Assign с той же переменной f. Это означает, что можно проделывать различные операции с файлом f, лишь единожды связав его с физическим файлом:

- 227 -

Assign( f, 'TEST.TMP' ); { установлена связь }

Rewrite( f ); { открытие файла для перезаписи }

Write( f, ...); { запись в файл f }

Close( f ); { закрытие файла (вызов необязателен) }

Reset( f ); { открытие файла для чтения }

Read( f, ...); { чтение из файла f }

Close( f ); { закрытие файла (вызов обязателен) }

Erase( f ); { удаление файла с диска }

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

12.5.2. Открытие файлов

Процедуры открытия файлов Reset(VAR f) и Rewrite(VAR f) открывают логический файл f для чтения данных (Reset) или записи (Rewrite). Если процедуры выполняются успешн6о (открытие файла происходит без ошибки), то файл становится открытым и готов к чтению или записи первого элемента в нем. Эти же процедуры фиксируют размер буфера файла (он устанавливается автоматически, если только не был переопределен вызовом SetTextBuf для файлов типа Text или расширенной записью Reset/Rewrite для бестиповых файлов).

После открытия файла (и только после него!) становится возможным чтение или запись данных. Процедуры открытия могут применяться многократно к одном и тому же файлу. Если файл был до этого открыт, то он автоматически предварительно закрывается. Повторный вызов Reset переустановит последовательность чтения вновь на самый первый элемент файла, при этом потеря данных исключена. Но повторное обращение к Rewrite сотрет текущее содержимое файла и подготовит файл к заполнению с первого элемента. Между повторными вызовами процедур открытия не обязательно вставлять оператор закрытия файла Close. Советуем также внимательно просмотреть разд. 12.11 «Обработка ошибок ввода-вывода».

12.5.3. Закрытие файлов

Процедура Close(VAR f) закрывает открытый до этого логический файл f. Попытка закрыть уже закрытый (или еще не открытый) файл вызовет сбой программы. Процедура не изменяет связь между файловой переменной f и физическим файлом, но назначает им текущее состояние «закрыт». Это особенно важно для файлов, открытых для записи. Закрытие файла гарантирует сохранность и полноту заполнения. Так, фатальная ошибка в программе

- 228 -

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

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

Вызовы процедуры Close необходимы при завершении работы с файлами. Также необходимо закрывать открытые файлы перед их удалением (Erase) или переименованием (Rename).

12.5.4. Переименование файлов

Процедура Rename( VAR f; NewName : String ) позволяет переименовать физический файл на диске, связанный с логическим файлом f. Процедура выполнима только с закрытым файлом, в противном случае возникнет сбой.

Предполагается, что файловая переменная f была предварительно связана вызовом процедуры Assign с неким физическим файлом, например FileName. Вызов Rename ( f, NewName ) сменит имя физического файла с FileName на NewName. В принципе, процедура Rename выполняет ту же работу, что и команда REN в MS-DOS. Правда, в отличие от последней Rename не может содержать в строковом параметре символы '*' и '?'.

Рассмотрим фрагмент программы (рис. 12.1).

| VAR

| f : File of Real;

| BEGIN

| Assign(f, 'A:\REAL.DAT'); { установлена связь }

| Rewrite( f ); { открытие файла для записи }

| Write( f, ... ); { запись в файл f }

| Close( f ); { обязательно закрытие файла}

| {Пусть теперь надо сменить имя файла 'REAL' на 'FLOAT'}

| Rename( f, 'A:\FLOAT.DAT' ); { Готово! }

Рис. 12.1

Переименование происходит при закрытом файле f. После него можно снова открывать файл, но f будет связана уже с новым именем. Старый файл не резервируется (его имя 'A:\REAL.DAT' замещено на 'A:\FLOAT.DAT').

Будет ошибкой так переименовывать имя, что изменится имя диска и путь к файлу. Например, заведомо ошибочен второй оператор:

- 229 -

Assign( f, 'A:\FILE.AAA');

Rename( f, 'C:\FILE.BBB');

поскольку, кроме имени файла, изменяется содержащий его диск. Ведь таким образом мы задаем перенос файла с А: на С:, а лишь затем его переименование. Перенос же, как и копирование, не определен в языке, и его надо конструировать средствами Турбо Паскаля или использовать внешний вызов командного процессора MS-DOS (см. процедуру Exec модуля DOS).

12.5.5. Удаление файлов

Процедура Erase(VAR f) уничтожает (стирает) физический файл на носителе (диске). Файловая переменная f должна быть предварительно связана с существующим физическим файлом. Сам файл к моменту вызова Erase должен быть закрыт.

Чтобы уничтожить файл с именем FileName, достаточно конструкции:

Assign(f, FileName); Erase(f);

где f — файловая переменная любого типа.

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

12.5.6. Анализ состояния файлов

Логическая функция EOF(VAR f ) : Boolean возвращает значение True, когда при чтении достигнут конец файла f. Это означает, что уже прочитан последний элемент в файле или файл f после открытия оказался пуст. Во всех остальных случаях функция возвращает значение False. Состояние EOF обновляется автоматически при каждом обращении к процедуре ввода данных. Файл f должен быть открыт.

Обращение к EOF без указания файла соответствует анализу конца стандартного файла Input (как правило, связанного с клавиатурой). Стандартный файл считается текстовым, и конец файла в нем обозначен символом #26 (в прочих, нетекстовых файлах, явного обозначения конца файла не существует).

Назначение функции EOF — указывать на возникновение конца файла. Наиболее часто EOF используется в цикле while, читающем файл до конца:

while not EOF(f) do { пока не достигнут конец файла f,}

Read( f, ... ); { читать данные из этого файла}

- 230 -

Эта конструкция гарантирует, что чтение прекратится только после считывания последнего элемента в файле с логическим именем f. Обратите внимание, что используется именно цикл while...do, а не repeat...until. Функция EOF постоянно следит за статусом чтения и позволяет опознать конец файла до того, как мы его непосредственно прочитаем.

12.6. Текстовые файлы

Определение «текстовые файлы — это те, которые выдают или принимают текстовую информацию» в целом правильно, но не слишком развернуто. Дадим другое определение: текстовые файлы — это файлы, в которых:

1) информация представляется в текстовом виде посредством символов в коде ASCII;

2) порции информации могут разделяться на строки. Признаком конца строки служит символ #13 (код 13 — CR). Он может быть объединен с символом перевода строки #10 (код 10 — LF);

3) конец файла обозначается явно символом ^Z (код 26);

4) при записи чисел, строк и логических значений они преобразуются в символьный (текстовый) вид;

5) при чтении чисел и строк они автоматически преобразуются из текстового представления в машинное.

Бытовые примеры текстовых файлов просты. Если файл можно вывести на экран в текстовом режиме и прочитать его, то это — текст. Клавиатура посылает в компьютер «сплошной» текст-файл. Компьютер посылает на принтер текст-файл, даже если принтер рисует в графическом режиме. Рассмотрим коротенький текст-файл:

| Текст-файл

| [13][10]

| Вы читаете текстовый файл, который [13][10]

| может храниться на диске или печататься [13][10]

| на принтере.[13][10]

| В нем можно хранить цифровые записи чисел:[13][10]

| 123 456 789 0[13][10]

| 234 567 890 1[13][10]

| 1.2 3.4 5.60 4[13][10]

| -100.254 [13][10]

| Конец файла[13][10]

| [26]

Цифры в квадратных скобках — управляющие коды с тем же номером, т.е. [13]=#13. в файле они занимают по одному символу и в текстовых режимах, как правило, на экран и принтер не выводятся (но управляют выводом).

Заметьте, что каждая строка заканчивается признаком конца строки, даже пустая (1-ая сверху). Самый последний символ в файле — признак его конца. Реально файл хранится как сплошная последовательность символов и разбивается на строки лишь при его выводе на экран или печать. Пустой текстовый файл содержит один символ #26.

Для работы с текстовым файлом необходимо определить файловую переменную (переменную логического файла):

VAR

f : Text;

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

В системной библиотеке Турбо Паскаля определены две текст-файловые переменные: Input и Output. Они связаны с устройством 'CON' (или фиктивным устройством CRT, если подключен модуль CRT) автоматически. И если в процедурах ввода опущено имя файла, то считается, что ввод идет из системного файла Input (это клавиатура) , а если имя файла опущено в операторе вывода, то в файл Output (вывод идет на экран).

Текстовые файлы в Турбо Паскале — это вовсе не аналоги файлов типа File of Char. Знак равенства между этими типами можно поставить лишь со значительными оговорками.

12.6.1. Текст-ориентированные процедуры и функции

Кроме общих для всех файлов процедур и функций, определены еще несколько, работающих только с текстовыми файлами (табл. 12.3).

Таблица 12.3

Процедуры и функции

Действие

SetTextBuf( VAR f : Text; VAR Buf [; BufSize : Word]

Устанавливает размер буфера файла f равным BufSize байт. Должна выполняться перед открытием файла f. Буфер размещается в переменной Buf.

Append( VAR f : Text)

Открывает текстовый файл f для дозаписи в конец файла

- 232 -

Flush( VAR f : Text)

Выводит текущее содержимое буфера f в физический файл, не дожидаясь заполнения буфера до конца. Имеет смысл только при записи в файл

EOLn( VAR f : Text) : Boolean

Функция возвращает True, если текущая позиция в файле — конец строки или конец файла, и False, если нет

SeekEOLn( VAR f : Text) : Boolean

Функция возвращает True, если достигнут конец строки или конец файла, или перед ними стоят лишь пробелы и (или) символы табуляции (#9)

SeekEOF( VAR f : Text) : Boolean

Функция возвращает True, если достигнут конец файла или перед ними стоят лишь пробелы, признаки концов строк и (или) символы табуляции

12.6.1.1. Процедура SetTextBuf(VAR I: Text; VAR Buf [;BufSize: Word]). Эта процедура служит для увеличения или уменьшения буфера ввода-вывода текстового файла f. Автоматическое значение размера буфера для текстовых файлов равно 128 байт. При интенсивном обращении к физическим файлам на диске мы рекомендуем увеличить это число до нескольких килобайт, что существенно ускорит процесс. При этом не так жестоко будут эксплуатироваться головки дисковода. Увеличение буфера должно произойти после связывания логического файла с физическим, но до первой операции ввода или вывода. Советуем взять за правило менять буфер до открытия файла. Это дает гарантию безопасности данных.

Задавая новый буфер, мы должны передать процедуре SetTextBuf не только логический файл f, но и переменную Buf, в которой этот буфер расположится. Это означает, что если под рукой нет пока незанятой переменной, то придется ввести еще одну, соответствующего размера. Тип переменной Buf не имеет значения. Важен ее размер. Буфер файла начнется с первого байта, отведенного Buf, и займет столько байт, сколько задано в необязательном параметре BufSize. Если в вызове процедуры число BufSize не указано, то

- 233 -

считается, что оно равно размеру переменной Buf. Задание BufSize больше, чем размер самой Buf, приведет к потере данных, «соседних» по памяти с Buf.

Рассмотрим вариант использования SetTextBuf (рис. 12.2).

| VAR

| ft : Text; { текстовый логический файл }

| Buf : Array [1..4*1024] of Byte; { его новый буфер }

| BEGIN

| Assign(ft,'TEXTFILE.DOC'); {файл связывается с диском }

| SetTextBuf( ft, Buf ); {меняется буфер (теперь он }

| {в переменной размером 4K) }

| Reset( ft ); {открытие файла }

| Read( ft,...) {операции ввода - все как обычно }

| Reset( ft ); { возврат в самое начало файла }

| { буфер no-прежнему в Buf, 4K }

| Прочие действия с файлом ft

| ...

| END.

Рис. 12.2

Будучи однажды установленным для файла ft, буфер не меняет своего места и (или) размера до следующего вызова SetTextBuf или Assign с той же файловой переменной ft.

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

| PROCEDURE GetFileAndOpenIt( VAR f : Text );

| VAR

| Buffer : Array [1..16*1024] of Byte; { буфер }

| FileName : String; { имя файла }

| BEGIN

| ReadLn( FileName ); { считывается имя файла }

| Assign( f, FileName );

| SetTextBuf( f, Buffer ); { назначение буфера }

| Rewrite( f ) { открытие файла f }

| END;

Рис. 12.3

- 234 -

| VAR

| ff : Text;

| BEGIN { основная часть примера }

| GetFileAndOpenIt( ff );

| Write{ ff, ... ); { попытка записи в файл ff }

| { Дальше неважно, что будет. Все равно результат уже }

| { будет неверный. }

| END.

Рис. 12.3 (окончание)

Дело в том, что локальная переменная Buffer (а именно в ней мы размещаем буфер открываемого файла) существует лишь во время выполнения процедуры. После окончания она исчезает, область буфера становится общедоступной и наверняка очень быстро заполнится совершенно «посторонними» значениями, а переданный в вызывающий блок файл f (ff) будет вести себя непредсказуемо. При всем этом не возникнет ни ошибки компиляции, ни ошибки во время счета.

Если размещать буфер в статической переменной, то он «съедает» часть области данных или стека. А они ограничены размером 64K, что вовсе, не так много. Выгоднее было бы размещать буфер в динамической памяти (куче). Для этого надо объявить указатель на место буфера в куче (рис. 12.4).

| VAR

| ft : Text; { файл типа текст }

| PBuf : Pointer; { ссылка на буфер }

| CONST

| BufSize=1024; { размер буфера }

| BEGIN

| Assign( ft, 'TEXTFILE.DOC' );

| GetMem( PBuf, BufSize); { в памяти отводится }

| { блок размером с буфер }

| SetTextBuf( ft, PBuf^,BufSize ); { Задается буфер в }

| { динамической памяти. }

| Reset( ft ); { открытие файла }

| { . . . } { работа с файлом ft }

| Close( ft };

| FreeMem(Pbuf, BufSize); { Буфер удаляется из }

| { памяти (кучи). }

| END.

Рис. 12.4

- 235 -

В этом случае нужно отводить и освобождать память под буфер, а в SetTextBuf обязательно указывать его размер, так как блок памяти с началом в PBuf^ «не знает» своего размера.

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

12.6.1.2.Процедура Append(VAR f : Text). Эта процедура служит для специального открытия файлов для записи. Она применима только к уже существующим физическим файлам и открывает их для дозаписи, т.е. файл не стирается, как при вызове Rewrite, а подготавливается к записи элемента в конец файла. Если Append применяется к несуществующему файлу, то возникнет ошибка времени счета. Новый файл может быть создан только процедурой Rewrite. Как автоматически выбрать соответствующую процедуру открытия файла — Append или Rewrite, описано в разд. 12.11.

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

12.6.1.3. Процедура Flush( VAR f: Text). Эта процедура применяется к файлам, открытым для записи (процедурами Rewrite или Append). Данные для записи накапливаются в буфере файла и только после полного его заполнения записываются в физический файл. Процедура Flush принудительно записывает данные из буфера в файл независимо от степени его заполнения. Когда буфер имеет большую емкость, его содержимое может не попасть в физический файл, если программа внезапно прервется в процессе счета. Этого можно избежать, если перед «аварийными» частями программы ставить вызовы Flush.

Процедура Flush не закрывает файл и не влияет на последовательность вывода. Flush может найти применение при работе со стандартными файлами MS-DOS: устройствами AUX, или COM1, COM2,...,PRN, или LPT1 LPT3. При работе с ними данным незачем «отстаиваться » в буфере, и процедура Flush, поставленная после Write, снимет эффект задержки буфера файла.

12.6.1.4. Функция EOLn( VAR f: Text) : Boolean. Эта функция анализирует текущее положение в текстовом файле f, открытом для чтения. Расшифровка этой функции говорит сама за себя:

- 236 -

«End-Of-Line» — конец строки. EOLn возвращает значение True, если следующей операцией будет прочитан признак конца строки (символ #13) или конца файла (символ #26) и False во всех прочих случаях. Функция как бы предчувствует результат предстоящего чтения и анализирует его. Необходимость в EOLn( f ) возникает всякий раз, когда заранее не известно, где встретится конец строки. Пусть у нас имеется файл со столбцами цифр (рис. 12.5).

DIGITS.DAT

12.3 13.2 14.4 5.7 126.0[13][10]

17.8 -7.6 100 456 987.6[13][10]

55.5 6.06 7.8 0.00 10.11[13][10]

[26]

Рис. 12.5

Как автоматически определить число столбцов в нем и наладить чтение? С помощью EOLn (рис. 12.6).

| VAR

| f :Text; { логический текстовый файл }

| NCol :Byte; { счетчик числа столбцов }

| R :Real; { число для чтения из файла }

| BEGIN

| Assign( f, 'DIGITS.DAT' ); { связывание файлов }

| Reset ( f ); { открытие f для чтения }

| Ncol := 0; { стартовое значение Ncol}

| while NOT EOLn(f) do

| begin { Цикл до конца строки: }

| Read( f, R ); { чтение вправо по строке}

| Inc( Ncol ) { увеличение счетчика столбцов }

| end; {while} { конец цикла счета столбцов }

| Reset( f ); { возврат на 1-ю позицию в файле }

| { ... и повторение чтения, уже зная число столбцов }

| END.

Рис. 12.6

Существует разновидность функции EOLn без параметров. В этом случае считается, что действие ее относится к стандартному файлу Input, т.е. вводу с клавиатуры. Здесь функция EOLn возвращает True не перед, а после прохождения признака конца строки: сразу после нажатия клавиши ввода. Более того, от EOLn без параметра не дождетесь значения False. Она «подвешивает» программу и возвра-

- 237 -

щает управление следующему оператору только после нажатия ввода. В руководстве языка приводится способ организовать паузу до нажатия ввода:

WriteLn(EOLn);

12.6.1.5. Функция SeekEOLn( VAR f: Text): Boolean.Эта функция является «ближайшей родственницей» функции EOLn (f). Файл f должен быть текстовым и открытым для чтения. Функция возвращает значение True, если до конца строки (символ #13) или конца файла (символ #26) могут быть считаны только пробелы и (или) символы табуляции (символ #9). Значение True также вернется, если текущее положение в файле непосредственно предшествует символам #13 или #26. Другими словами, SeekEOLn всегда вернет True, если EOLn на ее месте вернет True. Но в отличие от EOLn функция SeekEOLn как бы «видит» конец строки (или файла) через пробелы и знаки табуляции.

SeekEOLn ориентирована, главным образом, на работу с текстовыми файлами чисел. Последний пример из описания EOLn можно было бы переписать, заменив EOLn на SeekEOLn. От этого он заработал бы только лучше. Действительно, чтобы EOLn вернула True, нужно «упереться» в признак конца. А для этого надо убедиться, что «пустопорожние» пробелы после последнего числа в строке не являются числами: съедается время. SeekEoLn же игнорирует все пробелы и табуляции и «видит» конец издалека, ускоряя обработку.

12.6.1.6. Функция SeekEOF( VAR : Text) : Boolean. Эта функция замыкает ряд функций, начатый EOLn и SeekEOLn. Если отнять у SeekEOLn способность реагировать на признак конца строки, то получится функция SeekEOF, которая возвращает True, если только следующий за текущим положением символ — конец файла (#26), или если перед концом файла имеются только пробелы и (или) символы табуляции (#9), и (или) признаки конца строки (#13). Короче говоря, символы #9, #13, #32(пробел) для SeekEOF являются «прозрачными», и если сквозь них «виден» конец файла #26, то функция возвращает значение True. Во всех прочих случаях вернется значение False.

Функция позволяет найти смысловой конец файла, а не физический. Это полезно при работе с числами (реже с символами). Так, цикл чтения из файла f

while not EOF( f ) do Read( f, ... );

остановится только после полного истощения файла, даже если

- 238 -

последние 1024 строк его были пустыми. Если переписать цикл в виде

while not SeekEOF( f ) do Read( f, ... );

он станет работать более эффективно.

Как и SeekEOLn, функция SeekEOF применима только к открытым для чтения текстовым файлам.

12.6.2. Операции ввода-вывода в текстовые файлы

Ввод и вывод числовой и текстовой информации в Турбо Паскале осуществляется операторами:

ввод – Read( f, X ) или Read( f, X1,X2,...,Xn ) и

ReadLn( f, X ) или ReadLn( f, X1,X2,…,Xn );

вывод – Write( f, X ) или Write( f, X1,X2,…Xn ) и

WriteLn( f, X ) или WriteLn( f, X1, X2,…,Xn ).

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

Если операторы содержат один лишь список ввода-вывода, то считается, что ввод сопряжен со стандартным логическим файлом Input (под ним подразумевается клавиатура с «эхом» ввода на экране), а вывод — с логическим файлом Output (что соответствует выводу на экран дисплея).

Имена Input и Output являются предопределенными в системной библиотеке (модуле System). Напомним, что в стандартном Паскале любая программа, использующая ввод-вывод, должна начинаться со слов

PROGRAM имя( Input, Output);

что, по сути, открывает каналы ввода-вывода. В Турбо Паскале можно смело опускать описание PROGRAM и не надо описывать имена Input и Output.

Таким образом, оператор Read( x1, x2) полностью эквивалентен оператору Read( Input, x1, x2 ), а оператор Write( х3, х4) — оператору Write( Output, х3, х4 ).

12.6.2.1. Операторы Read/ReadLn. Рассмотрим сначала операторы ввода информации — Read и ReadLn. Их аргументами должен быть список переменных, значения которых будут считаны (введены). Тип переменных при вводе из текстового файла (в том числе и

- 239 -

с клавиатуры) может быть только целым, вещественным, символьным (Char), строковым или совместимым с ними. Сложные структурированные типы (такие, как массивы, множества, записи и др.) могут быть введены только по элементам (по полям для записей). Например:

| VAR

| i : Word

| l : Longint;

| r : Real;

| Rec RECORD { запись }

| x, у : Real

| ch : Char

| END;

| Dim : Array [0...99] of Byte; { массив }

| S : String;

| BEGIN

{ . . . ЧИТАЮТСЯ С КЛАВИАТУРЫ: . . . }

| Read( i, l); { два целых числа,}

| Read( l, r, s); { целое, вещественное число и строка,}

| Read( Rec.x, Rec.у, Rec.ch ); { запись по полям,}

| for i:=0 to 99 do

| Read( Dim[i] ); { ввод массива }

| END.

Всякие попытки вставить «сокращения» типа Read (Rec) или Read (Dim) вызовут понятное возмущение компилятора. Такое возможно лишь при вводе из типизированного файла (см. разд. 12.7).

При вводе из текстового файла, будь то файл на диске или клавиатура, необходимо помнить правила чтения значений переменных. Когда вводятся числовые значения, два числа считаются разделенными, если между ними есть хотя бы один пробел, или символ(ы) табуляции (#9), или символ(ы) конца строки (#13). Так, при выполнении оператора Read( i, r ) можно ввести значения с клавиатуры несколькими способами:

123 1.23 [Клавиша ввода]

или

123 [Клавиша ввода] 1.23 [Клавиша ввода]

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

- 240 -

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

VAR

ch1, ch2 : Char;

...

Read( ch1, ch2 );

В этом случае надо не спешить нажать клавишу ввода на клавиатуре:

аб[ВВОД] --> ch1 = 'а', ch2 = 'б'

а[ВВОД]б[ВВОД] --> ch1 = 'а', ch2 = #13

[ВВОД][ВВОД] --> ch1 = #13, ch2 = #13

И, наконец, ввод строк. Начало строки идет сразу за последним введенным до этого символом (с первой позиции, если соответствующая строчная переменная стоит первой в списке ввода). Считывается количество символов, равное объявленной длине строки. Но если во время считывания попался символ #13, то чтение строки прекращается. Сам символ #13 (конец строки) служит разделителем строк и в переменную никогда не считывается.

Рассмотрим пример комплексного списка ввода:

Read( realVar, intVar, Ch, String11, String88).

При вводе последовательность символов будет разбита на разнотипные части следующим образом ([#13] обозначает один символ с кодом 13):

Обратите внимание, что символьная переменная Ch здесь может заполучить себе только пробел (или #13 и #9), иначе, если следом сразу начнется строка, произойдет сбой при чтении целого значения! Строка StringSS будет заполнена не целиком, а на ту часть, которая успела считаться до символа #13 (нажатия клавиши ввода или конца строки в файле).

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

- 241 -

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

При вводе с клавиатуры («с экрана») особой разницы между Read и ReadLn нет. Процедура ReadLn (Read Line) считывает значения в текущей строке и переводит позицию на начало следующей строки, даже если в текущей строке остались непрочитанные данные. Так, при чтении в текстовом файле f строки:

12.3 13.4 14.5 15.6

оператором ReadLn( f, r1, r2) вещественные переменные r1 и r2 получат значения 12.3 и 13.4, после чего произойдет переход на другую строку, и следующие два числа (14.5 и 15.6) будут проигнорированы. Вызов ReadLn ( f ) вообще пропустит строку в файле f. Вызов ReadLn без указания файла сделает паузу до нажатия клавиши ввода.

Символ-признак конца текста #26 также является разделителем и ограничивает строку, но за ним чтение уже невозможно. Файл на нем кончается! Конец файла может быть считан в символьную переменную, в строчную он не войдет (как не входит символ #13), а чтение #26 вместо ожидаемых числовых значений эквивалентно прочтению 0.

12.6.2.2. Операторы Write/WriteLn. Операторы Write и WriteLn выводят значение X или список значений X1, Х2,..., Хn в текстовый файл f. Если файл не указан, то считается, что вывод направлен в файл Output (на дисплей). Значения, как и при вводе, могут иметь лишь целые, вещественные, символьные и строковые типы, а также производные от них. Всевозможные структуры (записи, массивы) должны выводится по их полям или элементам. Множества, указатели (Pointer), файловые переменные также не могут быть выведены без предварительного их преобразования в выводимые составляющие. Исключение составляет лишь тип Boolean:

CONST

tr : Boolean = True;

fa : Boolean = False;

...

Write( tr, ' ... ' , fa );

Оператор Write напечатает на экране: 'TRUE ... FALSE'. Предостерегаем от попыток прочитать эти значения из файла в том же виде. Из этого ничего не выйдет. Чтобы получить из файла логическое значение, закодируйте его байтом:

0 = False

1 = True

- 242 -

и считайте в байтовую переменную, а затем преобразуйте в логическое значение:

VAR

by : Byte; { байтовое значение }

boo : Boolean absolute by; { логическое значение }

...

Read( by ); { вводится значение-байт 0 или 1 }

if boo then ... ; {и считается логическим значением }

Вернемся, однако, к выводу данных. Процедура Write выводит данные в текущую строку и не закрывает ее, т.е. следующие данные запишутся в ту же строку. Формально во внешнем файле размер строки не ограничен. Исключение составляет вывод на дисплей. Если выводимый текст «уперся» в правую границу окна экрана, то он на этом месте разрывается и продолжается с начала следующей строки. Кроме того, вывод символа в нижний правый угол окна автоматически сдвинет изображение вверх на строку, т.е. все-таки совершит переход на следующую строку.

Процедура WriteLn (Write Line) выводит именно строку данных и закрывает ее: приписывает символ #13 в ее конец (точнее, символы #13 и #10, но последний как бы «сливается» с основным кодом). Это автоматически открывает следующую строку, а на экране возвращает курсор в крайнюю левую позицию и опускает его на строку вниз.

Оператор WriteLn или WriteLn( f ), где f — имя логического файла, данный без списка вывода, создает пустую строку, содержащую один только признак конца.

Список вывода Write и WriteLn может содержать константы, переменные, выражения, вызовы функций — лишь бы они имели соответствующие типы и были разделены запятыми:

Write( RealVar, ' номер ', intVar, #10#10'сумма=' );

WriteLn( RealVar+IntVar, '+', Cos(5*5) );

Все, что стоит в кавычках или является строковыми (символьными) константами и переменными, выведется в том виде, в каком подставлено, и лишнего места не займет. Но числовые значения будут выводится по-разному. Целые — как пробел или знак '-', а затем число, вещественные — как пробел или знак и затем экспоненциальная запись числа. Имеется возможность управлять форматом вывода данных.

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

- 243 -

Write( Ch : 2, St : 20 );

Это число показывает, сколько позиций отводится под значение. Так, значение Ch (символ) будет размещено в двух позициях, хотя реально займет лишь одну, а строка St — в 20 позициях. Если реальное значение «короче» формата, излишек будет заполнен пробелами. Но если наоборот (формат «мал»), то значение будет выводиться, игнорируя спецификацию. Ошибки при этом не возникает. Выравнивание значения в поле формата здесь происходит по правому краю. На этом можно сыграть следующим образом. Часто надо выводить значения с середины строки. При выводе на экран можно использовать специальную процедуру из модуля CRT для установки курсора, но при выводе в файл на диске это работать не будет. А как передвинуть значение? Решение очевидно:

Write( ' ', ChapterNameStr );

Но так же очевидно, что это неэффективно (в программе будет попусту «болтаться» столько пробелов!). Разумное решение таково:

Write( ' ' : 25, ChapterNameStr );

Один пробел, но в поле из 25 символов. Эффект будет тот же. Можно даже выкинуть пробел и поставить пустую строку .

Логические значения False и True выводятся как строковые константы и могут быть помещены в заданном поле.

Формат целочисленных значений задается почти так же, как и для строковых — размером поля за значением:

Write( intVar:5, 123:4, (6*8):10 );

Целое число, включая знак минус, если нужен, будет размещено в заданном числе позиций и выровнено по правому краю. Излишки заполнятся пробелами, а если формата не хватит, то он проигнорируется. Формат удобно использовать для вывода таблиц. Пусть надо красиво вывести 10 столбцов целых значений в 80 колонок экрана. Для этого можно задать формат

WriteLn( х1:7, х2:7, х3:7,...х10:7 );

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

Write( RealVar : 12 : 3, 123.456 : 8 : 1 );

- 244 -

Реальная длина числа равна сумме одной позиции под знак, числа знаков до десятичной точки, одной позиции под точку и значения второго параметра формата. Поэтому бессмысленны форматы типа ':4:3'. В примере переменная RealVar на экране будет иметь три знака после точки, и если полная ее длина не превысит двенадцать позиций, то она будет выровнена по правому краю. Оставшееся место будет пусто. При некорректном задании формата игнорируется только первый его параметр, а число знаков после точки устанавливается всегда корректно, но не превышает точности типа.

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

Можно выводить вещественные числа без дробной части. Для этого следует задать второй параметр равным 0:

Write( 123.456 : 6 : 0 ); { ' 123' }

При необходимости вывода вещественных значений в экспоненциальном формате надо задавать вновь только одно поле. Это поле указывает число позиций, в которых надо разместить число. Само число будет иметь вид -5.5678Е+00 или 0.0012Е-20. При задании подобного формата надо учесть место под знак числа, одну цифру до точки, саму точку, хотя бы одну цифру после точки, и четыре знака под степень — всего восемь позиций.

При формате, меньшем чем восемь позиций, он устанавливается автоматически равным восьми:

Write( 123.456 : 8, ' ', 123.456 : 6 ); { одно и то же }

Увеличивая формат, мы тем самым увеличиваем число значащих цифр после запятой. Максимальное их число определяется типом вещественного числа, и дальнейшее увеличение формата эффекта не даст.

Ряд проблем вызывает использование сопроцессора. В этом случае все вещественные типы при выводе в экспоненциальном формате показывают степень в виде Е+0000, т.е. минимальный формат становится равным ':10', и чтобы сохранить равное число знаков в самом числе при разных режимах работы с сопроцессором, надо менять форматы. Этот момент подробно рассмотрен при описании строковой процедуры Str (разд. 8.3.2.1).

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

- 245 -

VAR

F, n : ShortInt;

BEGIN

F:=8; n:=3;

WriteLn( 123.456 : F : n );

END.

До сих пор мы рассматриваем форматы, размещающие и форматирующие одновременно. Но когда длина значения заранее неизвестна, размещение-выравнивание по правому краю может дать некрасивые форматы:

Короткое число в формате 10 = 12

Длинное число в формате 10 = 12345678

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

Короткое число в формате -10 = 12

Длинное число в формате -10 = 12345678

Для задания такого режима надо ближнюю к значению спецификацию формата задавать отрицательной:

Write( 123.456 : 6 : 1, 22 : 4 ); { ' 123.5' и ' 22' }

Write( 123.456 :-6 : 1, 22 :-4 ); { '123.5' и '22' }

Несмотря на некоторое отсутствие гибкости в способе задания формата (нельзя задавать форматы-шаблоны — как в Фортране, Бейсике, а надо описывать каждое значение), механизм форматированного вывода текстовой информации Турбо Паскаля достаточно мощный. Помните только, что форматы имеют смысл лишь при работе с текстовыми файлами. Во всех остальных случаях они неприменимы.

12.7. Типизированные файлы и операции ввода-вывода

Типизированный, или компонентный, файл — это файл с объявленным типом его компонентов, т.е. файл с наборами данных одной и той же структуры. Как и в стандарте Паскаля, объявление такого файлового типа имеет структуру

File of ТипКомпонента,

- 246 -

где компонент может иметь любой ординарный или структурированный тип, предопределенный или построенный программистом. Запрещено лишь объявлять файлы файлов и файлы объектов, а также файлы структурированных компонентов (массивов, записей и др.), содержащих те же файлы или объекты. Так, допустимы следующие объявления:

TYPE

DimComp = Array [1..100,1..2] of Real;

RecComp = RECORD

X,Y : Byte;

A : DimComp

END;

DimFile = File of DimComp;

RecFile = File of RecComp;

IntFile = File of Integer;

Но компилятор не пропустит такие типы:

TYPE

FileFilel = File of File of Real; { неверно: файл файлов }

FileFile2 = File of DimFile; { неверно: файл файлов }

FRecComp = RECORD

X,Y : Byte;

F : File of Char

END;

FRecFile = File of FRecComp; { нельзя: файл в компоненте!}

ObjComp = OBJECT

...

END;

ObjFile = File of ObjComp; { неверно: файл объектов }

При написании программ необязательно определять специальные файловые типы. Это можно сделать «на ходу» при описании переменных:

VAR

FR : File of Real;

FD : File of DimComp;

Для работы с объявленным файлом необходимы обычные предварительные действия: связывание файловой переменной с физическим файлом и открытие файла для чтения или записи, например:

Assign( FR, 'RFILE.DAT' ); Reset( FR );

Assign( FD, 'DFILE.DAT' ); Rewrite( FD );

- 247 -

Для типизированных файлов обе процедуры Reset и Rewrite устанавливают режим «чтение/запись» в соответствии со значением предопределенной системной переменной FileMode (оно по умолчанию равно 2), т.е. независимо от выбора процедуры открытия, файл открывается и для чтения, и для записи. Это верно только для типизированных и бестиповых файлов, но ни в коем случае, не для текстовых. Этот порядок нарушится только в том случае, когда значение FileMode соответствует режиму «только запись» (1) или «только чтение» (0). Сменить режим можно простым присваиванием нужного значения переменной FileMode перед открытием файла. После этого вызов Reset будет открывать файл в заданном режиме, даже если он будет «только запись»! Процедура Rewrite также должна «слушаться» указаний FileMode, но только в том случае, когда файл уже существует. Для новых файлов Rewrite всегда включает режим «чтение/запись».

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

После открытия файла ввод и вывод данных осуществляется стандартными операторами

Read( f, х ) и Write( f, x )

или

Read( f, х1, х2, хЗ,...,xn) и Write(f, х1, х2, хЗ,..., xn).

Первым аргументом должно быть имя логического файла f, с которым связан конкретный физический файл. А далее должна стоять переменная (или их список) того же типа, что и объявленный тип компонента файла f, в которую запишется очередное значение из файла при чтении (Read) или, наоборот, которая запишется в файл (Write).

В отличие от файлов типа Text типизированные файлы имеют более строгую внутреннюю структуру. При записи в них записывается машинное представление очередного компонента, будь то число, массив, запись или строка. Внутри файла компоненты не отделяются ничем друг от друга (тем не менее найти любой компонент несложно: каждый из них занимает в файле одинаковый объем, равный размеру его типа). Поэтому не имеет смысла применять к типизированным файлам операторы ReadLn и WriteLn. В них просто не существует такого понятия, как строка и ее конец, и нет признака конца файла (конец определяется длиной файла). Даже если объявить файл как

- 248 -

VAR

f : File of String[80];

он не будет похож на текстовый файл из строк. В нем по-прежнему не будет символов конца строки, а будет (после записи) сплошная последовательность символов, кратная 81 (80 символов в строке и байт длины строки). Хуже того, если реальные значения строк короче 80 символов, то все равно в файле окажется по 81 символу на строку, и «излишки» будут забиты «мусором»,

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

Для специальных целей (например, написания программ перекодировки текстов) можно трактовать текстовые файлы как File of Char. Это, разумеется, не оживит работу процедур ReadLn/WriteLn и функции EOLn, работающей с текстами, но при соблюдении неприкосновенности и неизменности кодов конца строки и конца файла (символ #26), даст возможность побуквенного чтения, изменения и последующей записи в другой File of Char исходного текста. Каркас такой программы показан на рис. 12.7.

| PROGRAM Decode_Text;

| VAR

| fIn, fOut : File of Char; {файлы для чтения и записи}

| Ch : Char; {обрабатываемый символ }

| FUNCTION DecodeChar( С : Char ) : Char;

| { Функция должна возвращать символ,

| получающийся перекодировкой из C. }

| BEGIN { . . . } END;

| BEGIN

| Assign( fIn, 'C:\DOC\DOCUM.A' ); Reset( fIn );

| Assign( fOut, 'C:\DOC\DOCUM.B' ); Rewrite( fOut );

| Ch := ' '; { очистка Ch }

| while Ch <> #26 do

{цикл до конца ТЕКСТОВОГО файла:}

| begin

| Read ( fIn, Ch ); { читается символ }

| Write( fOut, DecodeChar(Ch) ) { запись замены }

| end; {while} { конец цикла }

| Close( fIn ); Close( fOut ) { закрытие файлов }

| END.

Рис. 12.7

- 249 -

(Чтобы не закладывать имена текстовых файлов в текст самой программы, следовало бы использовать функцию ParamStr или организовать более или менее «дружелюбный» диалог с пользователем, что советуем сделать.)

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

TYPE

dim100x20 = Array [1..100, 1..20] of Real;

VAR

XX, YY : dim100x20;

fIn, Fout : File of dim100x20;

BEGIN

... { открытие файлов fin и fOut... }

Read( fIn, XX ); { считывается сразу весь массив }

... { обрабатываются массивы }

Write( fOut, YY ); { записывается весь массив сразу }

... { среди прочего — закрытие файлов}

END.

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

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

12.8. Бестиповые файлы и операции ввода-вывода

Стандарт Турбо Паскаля вводит особый файловый тип, являющийся, по сути, обобщенным файловым типом. Мы будем называть его в дальнейшем бестиповым файлом, поскольку его обозначение состоит только из слова File без указания типа компонент.

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

- 250 -

Ввод-вывод в бестиповые файлы осуществляется специальными процедурами BlockRead и BlockWrite. Кроме того, расширяется синтаксис процедур Reset и Rewrite. В остальном принципы работы остаются такими же, как и с типизированными файлами. Перед использованием файловая переменная f (логический файл)

VAR

f : File;

должна быть связана с конкретным физическим файлом через вызов оператора Assign. Далее файл должен быть открыт для чтения или записи с помощью вызова процедуры Reset (f) или Rewrite (f) соответственно. После окончания работы файл должен быть закрыт процедурой Close (f).

Открывая бсстиповый файл для работы, мы неявно устанавливаем размер буфера передачи данных равным 128 байт. Однако можно явным способом указать иной размер буфера (чем он больше, тем быстрее происходит ввод-вывод), исходя из ресурсов памяти и удобства работы с данными. Для задания буфера надо после оператора Assign открывать файл расширенной записью процедур:

Reset( VAR f : File; BufSize : Word )

и

Rewrite( VAR f : File; BufSize : Word ).

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

Минимальный блок, который может быть записан или прочитан из файла, это 1 байт. Чтобы задать его, надо установить именно такую величину буфера при открытии файла. Максимальный размер блока не может превышать 64K.

Во время отладки программ в среде Турбо Паскаль можно проверить размер буфера, поместив в окно просмотра (Watch) или анализа (Evaluate) файловую переменную f, приведенную к типу FileRec (для этого может понадобиться подключение модуля DOS):

{ FileRec(f), R

или, конкретнее,

FileRec( f ).BufSize

Для чтения или записи данных в бестиповый файл стандартные процедуры Read и Write не годятся. Их заменяют здесь процедуры:

BlockRead(VAR f : File; VAR Destin; Count : Word [; VAR ReadIn : Word])

и

BlockWrite(VAR f : File; VAR Source; Count : Word [; VAR WriteOut : Word]).

Эти процедуры осуществляют чтение в переменную Destin и запись из переменной Source не компонентов файла или его строк, а блоков, состоящих из того количества байтов, которое определено для буфера файла f. Если Count больше 1, то за одно обращение будет считано Count емкостей буфера. Значение Count, меньшее единицы, не имеет смысла. Всегда должно выполняться условие:

Count*Размер_буфера < 64K.

Необязательный параметр ReadIn возвращает число блоков (буферов), считанное текущей операцией BlockRead. Аналогичный параметр WriteOut процедуры BlockWrite после каждой операции записи показывает число блоков (буферов), записанное в данный файл этой операцией.

Если операции записи или чтения прошли успешно, то значения ReadIn и WriteOut будут равны соответствующим значениям параметров Count. Но если произошел сбой при вводе-выводе, и заказанное число блоков не перенеслось, то параметры ReadIn и WriteOut будут содержать целое число удачно перенесенных блоков (неудача посередине блока практически равносильна отмене его чтения или записи).

Таким образом, эти параметры могут использоваться для контроля выполнения операций BlockRead и BlockWrite:

VAR

Fr,Fw : File; { файловые переменные }

ReadIn, WriteOut : Word; { переменные контроля }

Destin : ....... ; { приемник при чтении }

Source : ………; { источник при записи }

- 252 -

BEGIN

...

BlockRead( Fr, Destin, 3, ReadIn );

if ReadIn <> 3 then обработка ошибки чтения ;

BlockWrite( Fw, Source, 4, WriteOut );

if WriteOut <> 4 then обработка ошибки записи ;

...

END.

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

Процедуры BlockRead и BlockWrite не имеют списков ввода и вывода, поскольку не определен тип компонента файла. Взамен их в вызовах присутствуют бестиповые переменные. Адрес начала переменной в памяти соответствует адресу области памяти, начиная с которого заданное количество байт будет выведено в файл при записи или помещено в память из файла при чтении. Передавая переменную процедуре, мы всегда тем самым передаем адрес ее содержимого, точнее, первого байта ее значения. Если переменная X — массив

VAR

X : Array [1..10] of ... ;

то вызов BlockWrite или BlockRead с ней будет принимать за точку начала отсчета блока первый элемент массива. Можно более явно указать в вызове начало блока как X [1]. Но если подставить X[5], то отсчет блока будет вестись уже сразу с пятого элемента массива. Особенно осторожно надо будет обращаться со ссылками при подстановке их в BlockWrite и BlockRead. Ссылки должны быть разыменованы, с тем чтобы показывать на данные, а не на место в памяти, где хранится сама ссылка. Так, если определена ссылочная переменная P:

TYPE

Dim = Array [0..999] of Real; { массив }

VAR

P : ^Dim; { ссылка на массив }

f : File; { бестиповый файл }

то после создания динамического массива P^ вызовом процедуры New(Р) и его заполнения, он может быть записан в файл f следующим образом:

- 253 -

Assign( f, 'DIMFILE.DAT' ); { связывание f с диском }

Rewrite( f, SizeOf( Dim ) ); { открытие f для записи }

BlockWrite( f, Р^, 1 ); { запись массива в файл }

{ Ссылка P разыменована! }

Close( f ); { закрытие файла f }

Если ошибочно написать P вместо P^, то процедура сработает, но сохранит в файле кусок памяти, начиная с Addr(P), который вовсе не равен адресу динамического массива Addr(P^)!

Чтобы прочитать впоследствии записанный массив из файла, нужно «развернуть» направление вывода данных:

{ Место под массив P^ должно быть зарезервировано! }

New( Р );

Assign( f, 'DIMFILE.DAT' ); { связывание f с диском }

Reset( f, SizeOf( Dim ) ); { открытие f для чтения }

BlockRead( f, P^, 1 ); { чтение массива из файла}

{ Ссылка Р разыменована! }

Close( f ); { закрытие файла f }

Перед чтением блока в динамическую переменную (здесь: P^) она должна быть корректным образом создана (через вызов New либо GetMem или присвоением значения адреса), иначе последствия будут непредсказуемыми.

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

VAR

A, B, C : Array [1..2000] of Real;

то их элементы выстраиваются в одну сплошную цепочку. Иными словами:

Addr(B) = Addr(A) + SizeOf(A),

Addr(C) = Addr(B) + SizeOf(B).

(Это верно не только для массивов, но и для любых статических структур, кроме объектов: память в пределах блока описания переменных отводится последовательно по мере их следования.)

- 254 -

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

Assign( f, 'ABC.DAT' );

Rewrite( f, SizeOf(A) ); { открыть f и записать в }

BlockWrite( f, A, 3); { него три блока сразу }

Close( f );

или

Reset( f, SizeOf(A) ); { открыть f и считать из }

BlockRead( f, A, 3); { него три блока сразу } Close( f );

Другой, более специфичной областью применения бестиповых файлов является работа с системными областями памяти ПЭВМ, в том числе с видеопамятью. Одной из иллюстраций этого является, например, запись текстовых и графических изображений, рассматриваемая в разд. 20.4 и 22.3.

12.9. Последовательный и прямой доступ к файлам

Файл — это последовательная структура данных. И естественным способом доступа к компонентам файла является последовательный доступ. После открытия файла он «ждет» чтения или записи первого компонента. После каждого очередного обращения к файлу он готов выдать или принять очередной по счету компонент. В данном случае возможно только косвенно управлять последовательностью чтения или записи.

Пусть нужно прочитать из файла f пятый элемент и записать его в переменную V соответствующего типа. Это можно сделать, считав «впустую» четыре первых значения:

Reset( f ); { файл открыт для чтения первого компонента }

for i:=1 to 5 do Read ( f, v );

Reset(f); { переустановка снова на первый компонент }

В V останется лишь последнее, пятое, значение из файла. Это, конечно, не самое удачное решение проблемы прямого доступа, т.е. доступа сразу к тому компоненту, который нас интересует. Гораздо лучше будет использовать встроенные процедуры и функции Турбо Паскаля для прямого доступа к компонентам файла (табл. 12.4).

- 255 -

Функции и процедуры

Назначение

FileSize(VAR : f) : LongInt

Возвращает число записей компонентов или блоков в открытом файле f

FilePos(VAR f) : LongInt

Функция возвращает номер записи компонента или блока в открытом файле f, предшествующий тому, который будет считан или записан последующей операцией ввода-вывода

Seek(VAR f; W : LongInt)

Устанавливает текущим компонентом (блоком) в открытом файле f компонент с номером N, отсчитанным от нулевого. Назначенный компонент будет считан или записан последующей операцией ввода-вывода

Truncate(VAR f)

Отсекает часть открытого файла f, начиная с того компонента, который был бы считан последующей операцией ввода, и подтягивает на ее место конец файла

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

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

Прямой доступ означает возможность позиционировать внутри файла указатель на интересующую нас запись. В случае типизированных файлов запись в файле — это компонент файла, а в случае бестиповых — блок, равный по размеру буферу файла. Далее в этом разделе мы будем использовать термин «запись» именно в этом смысле (ранее мы избегали его из-за двусмысленности: запись компонента в файле сама может быть записью (record) в смысле типа данных).

Файл заполняется последовательно от начала. Его структура всегда линейна: запись следует за записью. В нем не может быть «дыр». Добавить запись можно лишь в конец, удлинив тем самым сплошную их цепочку в файле. Правда, можно заместить любую

- 256 -

существующую в файле запись, но это не изменит его структуры и длины.

Для индексации структуры файла достаточно просто пронумеровать его записи, что и делается в Турбо Паскале. Но эта нумерация достаточно своеобразна. Можно считать, что нумеруются не записи, а как бы границы между ними (рис. 12.8). Эти границы — чистая условность, и в реальном файле записи не разделяются, а идут подряд. Просто они позволяют наглядно изобразить принцип нумерации записей. Самая первая граница (в начале файла) имеет номер 0.

Рис. 12.8

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

12.9.1. Опрос размеров файлов и позиции в них

12.9.1.1.Функция FileSize( VAR f) : LongInt. Эта функция возвращает реальное число записей в открытом файле f. Применительно к рис. 12.8, эта функция вернула бы значение n. Для пустого файла возвращаемое значение равно 0.

12.9.1.2.Функция FilePos( VAR f ) : LongInt Эта функция возвращает нашу текущую позицию в файле f. Файл должен быть открытым. Позиция в файле — это номер условной границы (см. рис. 12.8). Если файл только что открылся, то текущей позицией будет граница с номером 0. Это значит, что можно прочитать (или записать) запись с реальным номером (0+1)=1. После, например, ее прочтения позиция переместится на границу 1, и следующей можно будет прочитать запись (1+1)=2 и т.д. После прочтения последней записи в файле с реальным номером n позиция совпадает с границей с таким же номером n. Дальше записей нет. Поэтому, если FilePos

- 257 -

возвратила значение, равное FileSize, то мы находимся в конце файла за последней записью:

if FilePos( f ) = FileSize( f ) then { Все! Конец файла }

Все сказанное можно теперь сформулировать следующим образом:

1. В самом начале файла функция FilePos возвращает значение 0.

2. В самом конце файла функция FilePos возвращает число, равное реальному количеству записей в файле (FileSize).

3. В остальных случаях функция FilePos возвращает значение, на единицу меньшее реального номера записи, которая готова к прочтению или созданию.

12.9.2. Позиционирование в файлах

Операция назначения текущей позиции в файле (позиционирование) производится процедурой Seek. Процедура Seek( VAR f; N : Longint ) непосредственно реализует прямой доступ в файл f. Файл должен быть открыт. Разберем механизм работы процедуры, используя рис. 12.8. В параметре N должен быть задан номер условной границы между записями. Чтобы работать с записью, имеющей реальный номер 3, мы должны задать позицию на границе перед ней, т.е. на границе с номером N=(3-1)=2. Чтобы прочитать или записать первую запись, должны задать N=0:

Seek( f, 0 );

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

Seek( f, FileSize( f ) ).

Доступ к последней записи в файле:

Seek( f, FileSize( f ) - 1 ).

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

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

- 258 -

| { ПРИМЕР ТОГО, КАК ПОМЕНЯТЬ МЕСТАМИ ЗАПИСИ В ФАЙЛЕ }

| TYPE

| Dim = Array [1..3] of Char; { тип компонента файла }

| VAR

| f : File of Dim; { компонентный файл }

| ff : File; { бестиповый файл }

| Dfirst, Dlast : Dim; { массивы типа Dim }

| FS : LongInt; { длина файла f }

| CONST

| St: String[11*3]= 'AAA—BBB—CCC—DDD—EEE—FFF';

| {Две процедуры для создания файла из 11 массивов типа }

| {Dim и его загрузки после модификации прямым доступом. }

| {Содержимое массивов представлено строкой длины 11*3=33 }

PROCEDURE Save.St;

| BEGIN

| Assign( ff, 'DIMFILE.DAT' ); Rewrite( ff, 3 );

| BlockWrite( ff, St[1], 11 ); Close( ff )

| END;

PROCEDURE Load.St;

| BEGIN

| Assign( ff, 'DIMFILE.DAT' ); Reset(ff, 3);

| BlockRead( ff, St[1], 11 ); Close( ff )

| END;

| BEGIN

| WriteLn( 'Стартовое содержимое файла: ', St );

| Save St;

| Assign( f, 'DIMFILE.DAT' ); { связывание f с диском }

| Reset( f ); { открытие файла f }

| FS := FileSize( f ); { запоминание длины файла }

| if FS < 2 then

| begin

| WriteLn('Маловато записей в файле для примера!');

| Halt { выход из программы }

| end; {if}

| Read( f, Dfirst ); { считывается первый массив в файле }

| Seek( f, FS-1 ); { переход к последней записи }

| Read( f, Dlast ); {считывается последний массив }

| Seek( f, FilePos(f)-1 ); { назад на одну запись }

| Write( f, Dfirst ); { первый массив замещает последний }

| Seek{ f, 0 ); { переход в самое начало файла }

| Write( f, Dlast ); { последний массив замещает первый }

| Close( f ); { закрытие модифицированного файла }

| Load St; WriteLn { 'Итоговое содержимое файла: ', St );

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 12.9

- 259 -

Напомним, что процедуры Write/Read и BlockWrite/BlockRead при каждом вызове перемещают границу на число прочитанных или записанных записей (компонентов или блоков).

Вызов Seek со значением N, большим чем FileSize, вызовет ошибку ввода-вывода.

12.9.3. Усечение файлов

Процедура Truncate(VAR f) связана с прямым доступом в файлы, но с натяжкой. Просто она увязана с процедурой позиционирования Seek.

Назначение процедуры Truncate - «отсекать хвосты» открытого файла f. Вернемся к рис. 12.8. Если текущая позиция соответствует, например, границе 2, то вызовом  Truncate(f) будут удалены все идущие за ней записи с реальными номерами 3, 4, ... , FileSize(f), а сама граница 2 станет концевой.

Комбинация

Seek(f,0);  {установить в начало файла}

Truncate(f); {отсечь все за границей 0}

сделает файл f совершенно пустым. Граница 0 станет первой и последней.

После отсечения нельзя восстановить прежнюю длину (если только не создать все заново). Можно трактовать  Truncate как частичное стирание (Erase). С текстовыми файлами процедура  Truncate не работает.

Несколько слов о работе EOF(f) — функция анализа конца файла f. Как только текущая позиция совпадает с концевой границей (см. рис. 12.5), функция EOF(f) начинает возвращать при опросе значение True. Все остальное время она возвращает значение False.

12.10. Процедуры для работы с каталогами

Поскольку Турбо Паскаль ориентирован на работу в среде MS-DOS, естественно, что он содержит средства, специфичные именно для этой ОС. В частности, в системной библиотеке имеются процедуры для работы с каталогами на дисках. Эти процедуры (табл. 12.5 ) практически повторяют набор средств самой MS-DOS.

- 260 -

Таблица 12.5

Процедура

Назначение

GetDir(drive : Byte; VAR S : String)

Возвращает в строке S текущее имя каталога на диске с индексом drive

ChDir(S : String)

Устанавливает текущим каталог с именем, содержащимся в S

MkDir(S : String)

Создает каталог с именем S на диске

RmDir(S : String)

Удаляет пустой каталог с именем S с диска

Для работы с каталогами Турбо Паскаль использует вызовы функций MS-DOS, а они очень чувствительны ко входным значениям имен каталогов и (или) дисков. Поэтому при невозможности выполнения процедуры возникает ошибка времени счета, и программа аварийно останавливается. Этого, однако, не случится, если вызов процедуры будет откомпилирован в режиме {$I-} — программа не будет обрываться. Подробнее об этом см. в разд. 12.11 «Обработка ошибок ввода-вывода» (команды управления каталогами определены как часть библиотеки ввода-вывода).

Процедура GetDir( drive : Byte; VAR S : String ) может определить имя текущего каталога заданного диска. Диск задается его индексом или номером:

0 — текущий диск

1 — диск А:

2 — диск В:

3 — диск С:

и т.д.

Если задать номер диска, отсутствующего в конфигурации ПЭВМ, то возникнет ошибка. После выполнения процедуры переменная S будет содержать полное имя каталога (с указанием буквы диска). Можно использовать GetDir для получения текущей буквы диска:

GetDir( 0, S );

WriteLn( 'Текущий диск-> ', S[1], S[2] );

Возвращаемое в S значение можно потом без изменений использовать в вызовах ChDir и MkDir. Но если надо приписать к нему имя файла, то не забудьте вставить между ними разделитель '\':

GetDir( 1, S );

FullFileName := S + '\' + FileName;

Однако это не лучшее решение задачи, ибо как быть в случае, если

- 261 -

S содержит корневой каталог 'А:\'? Решение может дать процедура FExpand модуля DOS.

Процедура ChDir( S : String ) используется для перехода в какой-либо существующий на диске каталог. Она делает текущим каталог, содержащийся в строке S (точнее, пытается сделать — все зависит от корректности содержимого S). Параметр S может содержать все те же значения, что может принять команда MS-DOS CD (CHDIR). Вот некоторые примеры вызовов:

ChDir('C:\PASCAL\EXE') — задан весь путь;

ChDir('\PASCAL\DOS') — дан путь от корневого каталога;

ChDir('WORK') — переход в подкаталог Work текущего каталога;

ChDir('..') — выход из подкаталога;

ChDir('..\TOOLS') — то же, но с переходом;

ChDir('\') — возврат в корневой каталог;

ChDir('A:') — переход в текущий каталог диска A:

Программа может сама создавать каталоги и подкаталоги, используя процедуру MkDir( S : String ). Параметр S должен содержать корректное имя нового подкаталога и при необходимости путь к нему (маршрут). Если возможно по правилам MS-DOS создать такой каталог, то он будет создан. Перехода в новый каталог при этом не происходит. Примеры обращений к процедуре:

MkDir( 'C:\PASCAL\NEW');

MkDir( 'HOBBY');

MkDir( '..\NEWDIR');

Каталоги можно удалять. Удалить можно любой каталог, если:

1) он совершенно пуст;

2) он не является текущим.

Удаление производится процедурой RmDir( S : String ), где S содержит имя удаляемого каталога. Удаление — процедура, симметричная созданию каталога. Примеры будут аналогичны примерам для процедуры MkDir.

Описанными выше процедурами вовсе не исчерпывается набор средств для работы со структурой дисков. Большое число специальных функций реализовано в модуле DOS и рассматривается в гл. 16.

12.11. Обработка ошибок ввода-вывода

Компилятор Турбо Паскаля позволяет генерировать выполнимый код в двух режимах: с проверкой корректности ввода-вывода и без нее. В среде программирования этот режим включается в меню

- 262 -

Options/Compiler/IO-checking. При включении в программу ключ режима компиляции обозначается как

{$I+} — режим проверки включен;

{$I-} — режим отключен.

По умолчанию, как правило, действует режим $I+. Этот ключ компиляции имеет локальную сферу влияния. Можно многократно включать и выключать режим, вставляя в текст программы конструкции {$I+} и {SI-}, тем самым создавая области с контролем ввода-вывода и без него.

При включенном режиме проверки любая ошибка ввода-вывода будет фатальной: программа прервется, выдав номер ошибки. Возможные номера ошибок ввода-вывода находятся в диапазоне от 2 до 200 ( от 2 до 99 — это коды ошибок DOS, от 100 до 149 — ошибки, диагностируемые самой программой, и от 150 до 200 — критические аппаратные ошибки). Расшифровка кодов ошибок с краткими комментариями приведена в табл. 12.6 в конце этого раздела.

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

12.11.1. Функция IOResult

Функция IOResult : Integer возвращает целое число, соответствующее коду последней ошибки ввода-вывода (см. табл. 12.6). Если же операция ввода-вывода прошла без сбоев, то функция вернет значение 0.

Опросить функцию IOResult можно только один раз после каждой операции ввода или вывода, ибо она обнуляет свое значение при каждом вызове. Обычно это обходится запоминанием значения функции в какой-либо переменной. При режиме компиляции операций ввода и (или) вывода {$I+} функция не имеет смысла.

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

12.11.2. Примеры обработки ошибок ввода-вывода

Рассмотрим несколько практических примеров (везде далее f — файловая переменная).

- 263 -

1. Обработка отсутствия файла с данными. Если файл отсутствует, то действие процедуры открытия Reset вызовет ошибку (рис. 12.10 ).

| Assign( f, 'NoFile.TXT' );

| {$I-} { выключение проверки ввода-вывода }

| Reset( f ); { попытка открыть файл f }

| {$I+} { восстановление проверки }

| if IOResult<>0 { Если файл не может быть открыт, }

| then { то дать сообщение: }

| WriteLn( 'Файл не найден или не читается' )

| else begin { Иначе (код равен 0) все хорошо }

| Read( f, ... ); { и можно нормально работать с }

| ... { файлом f... }

| Close(f)

| end; {else и if}

Рис. 12.10

В случае неудачи при открытии файла к нему не надо применять процедуру закрытия Close.

По тому же принципу можно построить функцию анализа существования файла (рис. 12.11).

| FUNCTION FileExists( FileName : String ) : Boolean;

| VAR

| f : File; { тип файла не важен }

| BEGIN

| Assign( f, FileName ); { связывание файла f }

| {$I-} Reset( f ); {$I+} { открытие без контроля }

| if IOResult=0 { Если файл существует, }

| then begin { то его надо закрыть }

| Close{ f );

| FileExists := True end {then}

| else { иначе просто дать знать}

| FileExists := False;

| END;

Рис. 12.11

2. Выбор режима дозаписи в текстовый файл или его создания. Механизм остается тот же (рис. 12.12). Здесь f — текст-файловая переменная.

- 264 -

| Assign(f,'XFile.TXT'); {связывание файла f }

| {$I-} Append( f ); {$I+} {попытка открыть его для дозаписи}

| if IOResult<>0 {Если файл не может быть открыт, }

| then Rewrite( f ); {то создать его. }

| ...

| Write( f, ...); { нормальная работа с файлом }

| ...

| Close( f );

Рис. 12.12

3. Переход в заданный каталог или его создание, если переход возможен (рис. 12.13, S — строковая переменная).

| S := 'C:\NEWDIR'; { задано имя каталога }

| {$I-} ChDir( S ); {$I+} { попытка перейти в него }

| if IOResult<>0 { Если не получается, }

| then begin

| MkDir( S ); {то сначала создать его, }

| ChDir( S ) { а уж потом перейти. }

| end; {if}

| { Подразумевается, что каталог S в принципе создаваем. }

Рис. 12.13

4. Построение «умных» ждущих процедур чтения данных с клавиатуры. Такие процедуры не будут реагировать на данные не своего формата (рис. 12.14).

| { Здесь используется ряд процедур из библиотеки }

| CRT; { модуля CRT. Они отмечены * в комментариях. }

{Процедура считывает с клавиатуры значение типа Integer, помещая его в переменную V. При этом игнорируется любой ввод, не соответствующий этому типу. X и Y — координаты текста запроса Comment. Проверка корректности значений X и Y не производится. }

PROCEDURE ReadInteger( X,Y : Byte; Comment : String;

| VAR V : Integer );

Рис. 12.14

- 265 -

| CONST

| zone =12; { ширина окна зоны ввода числа }

| VAR

| WN.WX : Word; {переменные для хранения размеров окна }

| BEGIN

| WN:=WindMin; WX:=WindMax; {Сохранение текущего окна }

| {$I-} { отключение режима проверки }

| GotoXY( X,Y ); {*перевод курсора в X,Y }

| Write( Comment ); { печать комментария ввода }

| Inc(X, Length(Comment)); { увеличение координаты X }

| Window( X,Y, X+zone,Y ); {*определение окна на экране }

| Repeat { Главный цикл ввода числа: }

| ClrScr; {* очистка окна ввода, }

| ReadLn( V ); { считывание значения при $I- }

| until (IOResult=0); { пока не введено целое }

| {$I+} { включение режима проверки }

| {*восстановление окна: }

| Window( Lo(WN)+1, Hi(WN)+1, Lo(WX)+1, Hi(WX)+1 )

| END; {proc}

| VAR i : Integer; { === ПРИМЕР ВЫЗОВА ПРОЦЕДУРЫ === }

| BEGIN

| ClrScr; {* очистка экрана }

| ReadInteger(10,10,'Введите целое число: ',i); { вызов }

| WriteLn; WriteLn( 'Введено i=', i ); { контроль }

| ReadLn { пауза до нажатия ввода}

| END.

Рис 12.14 (окончание)

В примере можно попутно устроить проверку диапазона значений V, переписав условие окончания цикла в виде

until (IOResult=0) and (V<Vmax) and (V>Vmin);

где Vmax и Vmin — границы воспринимаемых значений V. Аналогичным способом, меняя лишь типы переменной V, можно определить процедуры ReadByte, ReadWord, ReadReal и т.п. Справедливости ради надо отметить, что хотя описанная процедура ReadInteger спокойно относится к попыткам впихнуть в нее буквы, дроби и прочие неподходящие символы, она чувствительна к превышению диапазона значений типа Integer во входном числе и не обрабатывает его.

5. Работа с текстовыми файлами данных произвольного формата. Пусть существует файл из N столбцов цифр, содержащий в некоторых строках словесные комментарии вме-

- 266 -

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

| CONST N=3; { пусть в файле данные даны в трех столбцах }

| VAR

| f : Text; { текст-файловая переменная }

| i : Byte; { счетчик }

| D : Array [1..N] of Real; { значения одной строки }

| { данных в формате Real }

| BEGIN

| Assign(f,'EXAMPLE.DAT'); { связывание файла f }

| Reset( f ); { открытие файла для чтения }

| {$I-} { отключение режима проверки }

| while not SeekEOF(f) do { Цикл до конца файла: }

| begin

| Read( f, D[1] ); { попытка считать 1-е число }

| if IOResult=0 { Если это удалось,то затем }

| then begin { читаются остальные числа: }

| for i:=2 to N do Read( f, D[i] );

| { и как-либо обрабатываются: }

| WriteLn( D[1]:9:2, D[2]:9:2, D[3]:9:2 )

| end; {if 10...}

| ReadLn( f ) { переход на следующую строку }

| end; {while} { конец основного цикла }

| {$I+} { включение режима проверки }

| Close( f ); { закрытие файла f }

| ReadLn { пауза до нажатия ввода }

| END.

Рис. 12.15

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

Обращаем внимание на то, что во всех примерах подразумевается общий режим компиляции {$I+}, который в них всегда восстанавливается после завершения операции ввода-вывода. Советуем компилировать программы и модули в режиме {$I+}, используя его отключение только там, где действительно нужно обработать ошибку.

12.11.3. Сводка номеров ошибок ввода-вывода

Все ошибки, которые могут быть проанализированы функцией IOResult, подразделяются на три группы: ошибки, диагностируемые

- 267 -

MS-DOS (их номера не превышают 99), затем файловой системой Турбо Паскаля (номера от 100 до 159), и критические ошибки, диагностируемые аппаратно. Сводка всех номеров ошибок, относящихся к работе с файлами приводится в табл. 12.6.

Таблица 12.6

Описание ошибок

I. ОШИБКИ УРОВНЯ DOS

2

File not found (файл не найден)

ИСТОЧНИК: Reset, Append, Rename, Erase. Физический файл, связанный с файловой переменной, не найден или не существует.

3

Path not found (каталог/маршрут/ не найден)

ИСТОЧНИК: Reset, Rewrite, Append, Rename, Erase. Имя файла на диске, связанное с файловой переменной, является неправильным или указывает на несуществующий подкаталог.

ИСТОЧНИК: ChDir, MkDir, RmDir. Заданный маршрут является недействительным или содержит несуществующий подкаталог.

4

Too many open files (слишком много открытых файлов)

ИСТОЧНИК: Reset, Rewrite, Append, Rename, Erase. Программа имеет слишком много открытых файлов. Увеличьте число в параметре FILES= файла CONFIG.SYS и перезагрузите систему.

5

File access denied (отказано в доступе к файлу)

ИСТОЧНИК: Reset, Append, Rewrite. Открытие файла допускает запись (согласно значение переменной FileMode), но физический файл является каталогом или файлом, доступным только для чтения, а в случае Rewrite — эта ошибка возникает еще, когда в каталоге нет свободного места.

ИСТОЧНИК: Rename. Имя физического файла совпадает с именем каталога, или новое имя указывает уже существующий файл.

ИСТОЧНИК: Erase. Попытка стереть каталог или файл, доступный только для чтения.

ИСТОЧНИК: MkDir. Имя уже использовано в этом каталоге, или в каталоге нет места, или имя есть имя устройства DOS.

ИСТОЧНИК: RmDir. Заданное имя определяет непустой либо несуществующий каталог, или оно задает корневой каталог.

ИСТОЧНИК: Read/Write и BlockRead/BlockWrite. Попытка считывать (записывать) данные в еще не открытый файл.

- 268 -

6

Invalid file handle (недопустимый файловый канал) Эта ошибка появляется только при нарушении внутренней работы файловой системы, и ее возникновение является свидетельством того, что файловая переменная испорчена каким-либо образом.

12

Invalid file access code (неверный код доступа к файлам)

ИСТОЧНИК: Reset, Append. Значение переменной FileMode в момент открытия файла было несоответствующим команде открытия.

15

Invalid drive number (неверный номер дисковода)

ИСТОЧНИК: GetDir. Заданный номер диска при текущей конфигурации ПЭВМ не имеет смысла.

16

Cannot remove current directory (нельзя удалить текущий каталог).

ИСТОЧНИК: RmDir. Справедливое замечание на попытку срубить под собой сук

17

Cannot rename across drives (нельзя при переименовании указывать разные дисководы)

ИСТОЧНИК: Rename.

II. ОШИБКА УРОВНЯ ФАЙЛОВОЙ СИСТЕМЫ

100

Disk read error (ошибка чтения с диска)

ИСТОЧНИК: Read. Возникает в типизированном файле при попытке осуществить считывание после конца файла.

101

Disk write error (ошибка записи на диск)

ИСТОЧНИК: Close, Flush, Write/WriteLn, BlockWrite. Диск заполнен до отказа.

102

File not assigned (файл не связан)

ИСТОЧНИК: Reset, Rewrite, Append, Rename, Erase. С переменной логического файла (файловой переменной) не было связано имя физического файла через вызов процедуры Assign.

103

File not open (файл не открыт)

ИСТОЧНИК: Close, Flush, Read/Write, Seek, EOF, FilePos, FileSize, BlockRead/BlockWrite. Попытка операции ввода-вывода с еще не открытым файлом.

104

File not open for input (файл не открыт для ввода)

ИСТОЧНИК: Read, ReadLn, EOF, EOLn, SeekEOF, SeekEOLn. Попытка прочитать информацию из текстового файла, не открытого для чтения.

- 269 -

105

File not open for output (файл не открыт для вывода)

ИСТОЧНИК: Write, WriteLn. Попытка записать информацию в текстовый файл, не открытый для записи.

106

Invalid numeric format (неверный числовой формат)

ИСТОЧНИК: Read, ReadLn. Числовое значение, считанное из текстового файла, не соответствует числовому формату соответствующего типа данных.

III. КРИТИЧЕСКИЕ ОШИБКИ

150

Disk is write-protected (диск защищен от записи)

151

Unknown unit (неизвестный аппаратный модуль)

152

Drive not ready (дисковод не готов )

153

Unknown comnand (неопознанная команда)

154

CRC error in data (ошибка контроля данных в ОС)

155

Bad drive request structure length (при запросе к диску указана неверная длина структуры)

156

Disk seek error (ошибка при операции позиционирования головок на диске)

157

Unknown media type (неизвестный тип носителя)

158

Sector not found (сектор на диске не найден)

159

Printer out of paper (кончилась бумага на принтере)

160

Device write fault (ошибка при записи на устройство)

161

Device read fault (ошибка при чтении с устройства)

162

Hardware failure (сбой аппаратуры)

- 270 -

Глава 13. Объектно-ориентированное программирование

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

Объектно-ориентированное программирование базируется на трех основных понятиях: инкапсуляции, наследовании, полиморфизме.

Инкапсуляция — это комбинирование данных с процедурами и функциями, которые манипулируют этими данными. В результате получается новый тип данных — объект.

Наследование — это возможность использования уже определенных объектов для построения иерархии объектов, производных от них. Каждый из «наследников» наследует описания данных «прародителя» и доступ к методам их обработки.

Полиморфизм — это возможность определения единого по имени действия (процедуры или функции), применимого одновременно ко всем объектами иерархии наследования, причем каждый объект иерархии может «заказывать» особенность реализации этого действия над «самим собой».

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

13.1. Определения объектов

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

- 271 -

методами. Для обозначения типа «объект» в языке имеется служебное слово OBJECT. Тип объекта описывается способом, похожим на задание типа «запись»:

TYPE

ИмяОбъекта = OBJECT

ПоляДанных;

ЗаголовкиМетодов;

END;

Конкретную переменную, объявленную типом ИмяОбъекта, принято называть экземпляром этого типа.

Рассмотрим в качестве примера основные типы объектов для работы с символьной и текстовой информацией. При построении объектов всегда следует начинать с определения самого нижнего (элементарного) уровня данных и действий. Так, при работе с текстовой информацией на дисплее за нижний уровень представления данных можно принять позицию курсора (назовем ее ObjPos), определяемую двумя параметрами: номером строки (Line) и номером позиции в ней, т.е. столбцом (Col). Для задания позиции и символа объявляем процедуру Init, которая должна присваивать значения полям Line и Col, а для определения позиции вводим две функции: GetLine и GetCol (рис. 13.1). Метод Print не выполняет здесь никаких действий, но понадобится в дальнейших примерах.

TYPE

ObjPos = OBJECT

Line : Word; { номер строки }

Col : Word; { номер столбца }

PROCEDURE Init(init_line, init_col : Word);

FUNCTION GetLine : Word; { опрос Line }

FUNCTION GetCol : Word; { опрос Col }

PROCEDURE Print { зарезервировано }

END;

PROCEDURE ObjPos.Init( init_line, init_col : Word );

BEGIN

Line := init_line; { метод задания номера строки }

Col := init_col; { метод задания номера столбца }

END;

Рис. 13.1

- 272 -

FUNCTION ObjPos.GetLine : Word;

BEGIN

GetLine := Line { метод опроса номера строки }

END;

FUNCTION ObjPos.GetCol : Word;

BEGIN GetCol := Col { метод опроса номера столбца }

END;

PROCEDURE ObjPos.Print;

{ пустая процедура вывода }

BEGIN

Write( #7 ); { это вызовет звуковой сигнал }

END;

VAR ObjPosVar : ObjPos;

{ объявление экземпляра объекта }

(*Прочие описания типов, переменных, процедур, функций*)

BEGIN

{ Пример вызова метода назначения позиции: }

ObjPosVar.Init( 5, 15 );

...

END.

Рис. 13.1 (окончание)

В описании объекта фиксируется только название метода, в то время как его реализация в виде процедуры или функции может находиться в каком-либо из блоков описания процедур и функций. При реализации метода перед его именем обязательно указывается имя типа объекта, которому принадлежит метод. Разделителем имен служит точка «.». Обращаем внимание на то, что после объявления конкретного экземпляра объекта (на рис. 13.1 это переменная ObjPosVar) вызов метода предваряется уже не именем типа, а именем конкретного экземпляра.

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

Объектный подход подразумевает, что объявляемый в программе объект содержит исчерпывающие данные о соответствующем «физическом» объекте, поэтому методы, объявляемые в объекте, должны по возможности обращаться только к друг другу и к полям

- 273 -

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

ObjPosVar.Line := 5;

ObjPosVar.Col := 15;

Но в таком случае мы, во-первых, как бы «выносим» метод за границы объекта, а во-вторых, метод назначения позиции может быть гораздо более сложным (и мы это покажем позже), и в случае его изменения придется переделывать все присваивания вместо одного единственного метода. В ООП должно выполняться «джентльменское» соглашение: доступ к полям-данным объекта должны иметь только методы этого объекта. Нарушение этого правила может свести на нет все преимущества объектного подхода.

При объявлении объектов должны выполняться следующие требования:

— описание типа «объект» может производиться только в блоке определения типов TYPE основной программы или в разделах модулей; нельзя описывать локальные объекты в подпрограммах;

— при описании типа объекта все поля данных должны находиться перед описаниями методов;

– компоненты объекта не могут быть файлами, а файлы, в свою очередь, не могут содержать компоненты типа «объект».

Данные типа «объект» не могут быть записаны в файл на диске. Тем не менее в демонстрационном архиве OOP.ARC пакета Турбо Паскаль приведены две программы: OBJECTS.PAS и ODEMO.PAS, которые совместно с находящимися там же ассемблерными вставками реализуют механизм хранения объектов на диске.

13.2. Область действия полей объекта и параметр Self

Область действия (domain) полей данных объекта неявно распространяется на тела процедур и функций, реализующих методы этого объекта. В примере на рис. 13.1 метод Init (процедура) работает с полями Line и Col объекта типа ObjPos, обращение к которым не требует указания имени объекта. Можно сказать, что внутри методов объекта действует неявный оператор WITH. Следствием этого является то, что формальные параметры метода (если присутствуют) не могут совпадать по имени ни с одним из полей данных соответствующего объекта.

- 274 -

Мы не раз подчеркивали, что внешне объекты очень похожи на записи. Так же, как и записи, они могут явно записываться в теле оператора WITH :

VAR

ObjPosVar : ObjPos; { экземпляр объекта }

...

with ObjPosVar do { оператор присоединения }

BEGIN

Init( 1,1); { имя экземпляра опущено }

...

Init( GetLine+1, GetCol+1 );

...

end; { with }

Всякий раз, когда вызывается метод какого-либо объекта, в него, кроме фактических параметров, передается невидимый параметр Self («свой», «внутренний»). Он указывает, какому объекту принадлежит метод. Так, метод Init из примера на рис. 13.1 воспринимается компилятором так, как если бы он был описан следующим образом:

PROCEDURE ObjPos.Init( init_line, init_col : Word );

BEGIN

Self.Line := init_line; { метод задания номера строки }

Self.Col := init_col { метод задания номера столбца }

END;

Компилятор автоматически обрабатывает параметр Self, поэтому не стоит использовать его явно. Исключением является случай, когда идентификаторы начинают «конфликтовать» в пределах методов. На рис. 13.2 показано, как, используя в методе объекта параметр Self, разрешить конфликт между полями самого объекта и формального параметра (записи).

| TYPE

| PosRec = RECORD { запись }

| Line, Col : Word; { номера строки и столбца }

| END;

| ObjPos = OBJECT { объект }

| Line, Col : Word; { номера строки и столбца }

| PROCEDURE Init2( Pos : PosRec ); { метод }

| END;

Рис. 13.2

- 275 -

PROCEDURE ObjPos.Init2( Pos : PosRec );

| BEGIN

| with Pos do begin

{ присоединение для записи Pos }

| Self.Line:= Line; { Self развязывает одинаковые имена}

| Self.Col := Col

| end {with}

| END;

Рис. 13.2 (окончание)

13.3. Наследование

При помощи объекта типа ObjPos (см. рис. 13.1) определяется положение какого-либо символа в тексте на дисплее, но сам символ в нем не определен. Объявим объект с именем ObjSym, добавляющий символ и выполняющий определенные действия с ним (рис. 13.3).

| USES CRT; { в примере используется системный модуль CRT }

| TYPE

| ObjSym = OBJECT

| Line : Word; { номер строки с Sym }

| Col : Word; { номер столбца с Sym }

| Sym : Char; { поле-значение символа }

| PROCEDURE Init(init_line,init_col : Word;

| init_sym : Char);

| FUNCTION GetLine : Word; { опрос Line }

| FUNCTION GetCol : Word { опрос Col }

| PROCEDURE Print { вывод Sym }

| END;

| PROCEDURE ObjSym.Init; { инициализация полей объекта }

| BEGIN

| Line := init_line; { метод задания номера строки }

| Col := init_col; { метод задания номера столбца }

| Sym := init_sym { задание значения символа } END;

| FUNCTION ObjSym.GetLine : Word;

| BEGIN

| GetLine := Line { метод опроса номера строки }

| END;

Рис. 13.3

- 276 -

| FUNCTION ObjSym.GetCol : Word;

| BEGIN

| GetCol := Col

| { метод опроса номера столбца }

| END;

| PROCEDURE ObjSym.Print;

| BEGIN

| CRT.GotoXY(Col,Line);

| { процедура из библиотеки CRT }

| Write( Sym ) { вывод символа в позиции }

| END;

Рис. 13.3 (окончание)

Обратите внимание на то, что в задании нового объекта использовались поля данных и два метода GetLine и GetCol, идентичные полям и методам ранее описанного объекта ObjPos. Метод Init переписан заново, а поле Sym и, по сути, метод Print просто добавлены. Можно сказать, что более сложный объект, описывающий символ в тексте, унаследовал свойства и методы объекта-позиции. Методология ООП строится как раз на построении такого ряда объектов, в котором можно было бы проследить развитие и наследование свойств от простых структур к сложным.

Синтаксически наследование выражается следующим образом. В случае определения типа объекта, как производного от уже существующего, имя прародительского объекта заключается в круглые скобки после служебного слова OBJECT:

TYPE

ИмяОбъектаНаследника = OBJECT( ИмяОбъектаПрародителя )

НовыеПоляОбъектаНаследника;

НовыеМетодыОбъектаНаследника;

END;

Пример на рис. 13.3 по правилам ООП и Турбо Паскаля должен выглядеть, как показано на рис. 13.4 (на нем не показаны, но используются определения, введенные ранее на рис. 13.1).

Тип «наследник» иногда называется производным типом, а тип, от которого производится наследование («прародитель») — прародительским типом. Таким образом, отличие объекта от записи состоит не только в объединении полей и методов «под одной крышей», но и в способности объектов к наследованию. Поля и методы прародителя могут появляться в телах методов наследника, как если бы они были объявлены явно. На рис. 13.4 это иллюстрируется методом Init, который для инициализации полей

- 277 -

| USES CRT; { в примере используется системный модуль CRT }

| {*3десь должны быть определения, введенные на рис.13.1*}

| TYPE

| ObjSym = OBJECT( ObjPos ) { объявление наследования }

| Sym : Char; { поле-значение символа }

| PROCEDURE Init(init_line, init_col : Word;

| init_sym : Char );

| PROCEDURE Print { метод вывода символа }

| END;

| PROCEDURE ObjSym.Init;

| BEGIN

| ObjPos.Init( init_line, init_col ); {задание позиции }

| Sym := init_sym { задание значения символа }

| END;

| PROCEDURE ObjSym.Print;

| BEGIN

| CRT.GotoXY(Col, Line); {процедура из библиотеки CRT}

| Write( Sym ) { вывод символа в позиции }

| END;

Рис. 13.4

Line и Col, «по наследству» перешедших к объекту ObjSym, пользуется наследуемой процедурой ObjPos.Init.

Продолжая ряд наследования, можно ввести объект, описывающий символ совместно с его цветовым атрибутом. Для этого достаточно описать объект, производный от ObjSym и добавляющий поле данных для атрибута и методы его назначения или опроса. Такой объект будет третьим уровнем наследования, если считать от базового объекта ObjPos. Но можно объявить и объект того же уровня наследования по отношению к ObjPos, что и ObjSym. Определим, к примеру, объект «подстрока» (он пригодится в последующих примерах). Для задания подстроки надо указать координаты ее начала номер строки и столбца) и само содержимое подстроки, которое содержит в себе указание на ее длину. Можно создать объект типа ObjString, описывающий подстроку, как производный от объекта-позиции (рис. 13.5).

Процесс наследования является транзитивным: если тип объекта TypeB наследуется от типа объекта TypeA, а тип TypeC наследуется от TypeB, то тип объекта TypeC также считается наследником типа TypeA. Таким образом, можно получить иерархию объектов, связан-

- 278 -

| TYPE

| ObjString = OBJECT( ObjPos )

| SubSt : String; { поле-значение подстроки }

| PROCEDURE Init( init_line, init_col:Word;

| init_ss:String );

| PROCEDURE Print { вывод SubSt в позиции }

| END;

| PROCEDURE ObjString.Init; { инициализация полей объекта }

| BEGIN

| ObjPos.Init( init_tine, init_col ); {задание позиции }

| SubSt := init_ss { задание значения подстроки }

| END;

| PROCEDURE ObjString.Print;

| BEGIN

| CRT.GotoXY(Col, Line); { процедура из библиотеки CRT }

| Write( SubSt ) { печать подстроки в позиции }

| END;

Рис. 13.5

ных «родственными» отношениями. Как правило, основная часть работы по написанию объектно-ориентированных программ состоит в построении именно иерархий объектов.

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

Несколько слов о «хорошем тоне» ООП. В случае, если в производном типе описывается новая процедура инициализации, в ней обычно вначале вызывается процедура инициализации непосредственного прародителя. Так удобно поступать еще и потому, что это самый естественный способ проинициализировать наследуемые поля предназначенным для этого методом.

- 279 -

13.4. Присваивание объектов

Из «умения» объектов наследовать вытекают новые правила присваивания для переменных типа «объект» (экземпляров). Им можно присваивать не только значения этого же типа, но и любого производного от него. Аналогичное правило совместимости типов действует при передаче в процедуру или функцию параметров типа «объект». Например, если в программе объявлены переменные типа «объект»:

VAR

ObjPosVar : ObjPos; { переменная - позиция в тексте }

ObjSymVar : ObjSym; { переменная - символ в позиции }

то для копирования позиции, записанной в ObjSymVar, в переменную ObjPosVar достаточно выполнить присваивание

ObjPosVar := ObjSymVar;

Подобная операция заполнит поля данных в ObjPosVar значениями аналогичных полей, унаследованных ObjSymVar. Методы таким способом не присваиваются. Поскольку производный тип всегда получается не меньшим, чем прародительский, операция Присваивания возможна именно таким путем:

Прародитель <-- Наследник.

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

Переменные типа «объект» могут быть динамическими, т.е. объявляться как ссылки:

VAR

ObjPosVarPtr : ^ObjPos; { ссылка на позицию в тексте }

ObjSymVarPtr : ^ObjSym; { ссылка на символ в позиции }

После создания динамических объектов процедурой или функцией New ссылки (как разыменованные, так и сами по себе) могут присваиваться друг другу. Правила совместимости останутся теми же: корректными будут только присваивания ссылок на наследников ссылкам на прародителей:

- 280 -

ObjPosVarPtr := ObjSymVarPtr; { передача ссылки }

ObjPosVarPtr^ := ObjSymVarPtr^; { передача полей }

13.5. Полиморфизм

Подобно расширенным правилам присваивания, совместимость типов при передаче в процедуру или функцию параметров типа «объект» также понимается полнее. Формальному параметру типа «объект» может соответствовать фактический параметр не только этого же типа, но и типа, производного от него. Такое свойство совместимости объектов носит название полиморфизма. Практическим примером его использования могла бы стать процедура, выводящая либо строку, либо символ на экран. Несмотря на различие входных параметров (строка или символ), процедура будет одна — но она должна работать с объектами. В самом деле, ранее мы ввели объект-позицию ObjPos и производные от него типы ObjSym и ObjString. Если описать в процедуре формальный параметр как имеющий тип ObjPos, то по правилу совместимости в процедуру можно будет передавать фактические параметры других, производных от него типов, т.е. типов ObjSym и ObjString, и даже производных от них! Такая процедура приведена на рис. 13.6.

{ Считаются описанными типы ObjPos, ObjSym и ObjStr

(см. рис. 13.1, 13.4 и 13.5)

Процедура выводит полиморфный объект (строку или символ)}

| PROCEDURE PrintObj( VAR Obj : ObjPos );

| BEGIN

| Obj.Print

| END;

| VAR

| ObjSymVar : ObjSym; { экземпляр типа ObjSym }

| ObjStringVar : ObjString; { экземпляр типа ObjString }

| BEGIN { пример инициализации и вывода }

| ObjSymVar.Init( 10, 10, '*' );

| ObjStringVar.Init( 20, 20, '...ПОДСТРОКА...' );

| PrintObj( ObjStringVar );

| PrintObj( ObjSymVar );

| END.

Рис. 13.6

- 281 -

Обращаем внимание на легкость реализации процедуры. Она не зависит от процессов внутри объектов, а только вызывает нужный нам метод обработки полей данных (разнотипных). Поскольку мы предварительно сами позаботились о том, чтобы у всех наших объектов был одинаковый по написанию метод Print, его запись в процедуре встречается один раз. Но здесь необходимо сделать оговорку. Несмотря на внешнюю правильность примера, он будет работать не совсем корректно: всегда будет срабатывать метод Print для типа объекта ObjPos, независимо от типа фактического параметра. Это происходит потому, что во всех объявленных выше объектах используются статические методы.

13.5.1. Статические методы

Такое название методов связано с тем, что размещение соответствующих ссылок на них осуществляется еще на этапе компиляции.

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

1. При вызове метода компилятор устанавливает тип объекта, вызывающего метод.

2. Установив тип, компилятор ищет метод в пределах типа объекта. Найдя его, компилятор назначает вызов этого метода.

3. Если указанный метод не найден, то компилятор начинает рассматривать тип непосредственного прародителя и ищет метод, имя которого вызвано, в пределах этого прародительского типа. В случае, если метод с таким именем найден, вызов заменяется на вызов метода прародителя.

4. Если же искомый метод отсутствует в типе ближайшего прародителя, то компилятор переходит к типу следующего прародителя («дедушке») нашего типа, где и осуществляет дальнейший поиск. Процесс продолжается до тех пор, пока вызванный метод не будет найден, иначе компилятор, дойдя до самого последнего типа («родоначальника») и не найдя метод, имя которого вызывается, выдаст сообщение об ошибке компиляции номер 44 Field identifier expected («Ожидается идентификатор поля»). Это говорит о том, что метод с таким именем не определен.

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

- 282 -

Применительно к примеру на рис. 13.6 сработают правила 1 и 2, и будет выполнен метод, объявленный в типе формального параметра (т.е. ObjPos.Print). Для того чтобы процедура заработала правильно, необходимо объявить метод Print виртуальным.

13.5.2. Виртуальные методы

13.5.2.1. Виртуализация методов. Из правил совместимости фактических и формальных параметров типа «объект» следует, что в качестве фактического параметра может выступать объект любого производного типа от типа формального параметра. Таким образом, во время компиляции процедуры неизвестно, объект какого типа будет ей передан в качестве фактического параметра (такой параметр называется полиморфным объектом). В полной мере полиморфизм объектов и методов реализуется при помощи виртуальных методов.

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

PROCEDURE ИмяМетода( параметры ); VIRTUAL;

или

FUNCTION ИмяМетода( параметры ) : ТипЗначения; VIRTUAL;

При виртуализации методов должны выполняться следующие условия:

1. Если прародительский тип объекта описывает метод как виртуальный, то все его производные типы, которые реализуют метод с тем же именем, должны описать этот метод тоже как виртуальный. Другими словами, нельзя заменять виртуальный метод статическим. Если же это произойдет, компилятор сообщит об ошибке номер 149 VIRTUAL expected («Ожидается служебное слою VIRTUAL»).

2. Если переопределяется реализация виртуального метода, то заголовок заново определяемого виртуального метода в производном типе не может быть изменен. Иначе говоря, должны остаться неизменными порядок расположения, количество и типы формальных параметров в одноименных виртуальных методах. Если этот метод реализуется функцией, то не должен изменяться и тип результата. При изменении заголовка метода компилятор выдаст сообщение об ошибке номер 131 Header does not match previous definition («Заголовок не соответствует предыдущему определению»).

- 283 -

3. В описании объекта должен обязательно описываться специальный метод, инициализирующий объект (обычно ему дают название Init). В этом методе служебное слово PROCEDURE в объявлении и реализации должно быть заменено на слово CONSTRUCTOR. Это служебное слово обозначает особый вид процедуры — конструктор, который выполняет установочную работу для механизма виртуальных методов. Все типы объектов, которые имеют хотя бы один виртуальный метод, должны иметь конструктор. Конструктор всегда вызывается до первого вызова виртуального метода. Вызов виртуального метода без предварительного вызова конструктора может привести систему к тупиковому состоянию, а компилятор не проверяет порядок вызовов методов. Помните об этом!

13.5.2.2. Конструкторы и таблица виртуальных методов. Каждый экземпляр (переменная) типа «объект», содержащий виртуальные методы, должен инициализироваться отдельным вызовом конструктора. Если переменная А инициализирована вызовом конструктора, а переменная В того же типа не инициализирована, то присваивание В:=А не инициализирует переменную В и при вызове ее виртуальных методов программа может «зависнуть».

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

Важно помнить, что таблица виртуальных методов — одна для каждого типа, а не у каждой переменной типа «объект». Переменная лишь держит связь с таблицей своего типа, и эта связь устанавливается конструктором. В объекте может быть определено несколько конструкторов. Сами конструкторы могут быть только статическими, хотя внутри конструктора могут вызываться и виртуальные методы.

При передаче в процедуру или функцию полиморфного объекта, имеющего виртуальные методы, адреса этих методов передаются

- 284 -

через соответствующую объекту таблицу VMT. Это гарантирует, что сработают именно те методы, которые подразумевались при объявлении типа объекта. Кроме того, если объект Z наследует от объекта Y виртуальный метод, вызывающий другие методы, то последние вызовы будут относиться к методам объекта Z, а не Y. В случае статических методов все было бы наоборот (вызовы не «вернулись» бы в Z).

Мы начали этот раздел с примера полиморфной процедуры (см. рис. 13.6). Чтобы она заработала, надо сделать некоторые методы виртуальными и объявить конструкторы в объектах. Это проделано на рис. 13.7.

| USES CRT; { в примере используется системный модуль CRT }

| TYPE

| ObjPos = OBJECT

| Line : Word; { номер строки }

| Col : Word; { номер столбца }

| { ! } CONSTRUCTOR Init(init_line,init_col: Word);

| { ! } PROCEDURE Print; VIRTUAL { зарезервировано }

| END;

| CONSTRUCTOR ObjPos.Init( init_line, init_col : Word );

| BEGIN

| Line := init_line; { метод задания номера строки }

| Col := init_col; { метод задания номера столбца }

| END;

| PROCEDURE ObjPos.Print; { пустая процедура вывода }

| BEGIN

| Write( #7 ); { это вызовет звуковой сигнал }

| END;

| TYPE

| ObjSym = OBJECT( ObjPos ) { объявление наследования }

| Sym : Char; { поле-значение символа }

| { ! }CONSTRUCTOR Init(init_line,init_col : Word;

| init_sym : Char);

| {!} PROCEDURE Print; VIRTUAL {метод вывода Sym }

| END;

| CONSTRUCTOR ObjSym.Init;

| BEGIN

| ObjPos.Init( init_line, init_col ); { задание позиции }

| Sym := init_sym { задание значения символа }

| END;

Рис. 13.7

- 285 -

| PROCEDURE ObjSym.Print;

| BEGIN CRT.GotoXY( Col, Line );

| { процедура из модуля CRT }

| Write( Sym )

| { вывод символа в позиции }

| END;

| TYPE

| ObjString=OBJECT( ObjPos )

| SubSt : String; { поле-значение подстроки }

| { ! }

| CONSTRUCTOR Init(init_line,init_col: Word;

| init_ss : String);

| { ! }

| PROCEDURE Print; VIRTUAL

| {метод вывода SubSt }

| END; CONSTRUCTOR ObjString.Init;

| {инициализация полей объекта }

| BEGIN

| ObjPos.Init( init_line, init_col );

| {задание позиции }

| SubSt := init_ss { задание значения подстроки }

| END;

| PROCEDURE ObjString.Print;

| BEGIN CRT.GotoXY( Col, Line };

| {процедура из библиотеки CRT }

| Write( SubSt ) {печать подстроки в позиции }

| END;

| {Вывод полиморфного объекта (строки или символа) }

| PROCEDURE PrintObj( VAR Obj : ObjPos );

| BEGIN Obj.Print END;

| { =========== ТЕЛО ОСНОВНОЙ ПРОГРАММ ================ }

| VAR ObjSymVar : ObjSym;

| { экземпляр типа ObjSym }

| ObjStringVar : ObjString; { экземпляр типа ObjString }

| BEGIN { Инициализация и вывод: }

| ClrScr; { очистка экрана }

| ObjSymVar.Init( 10, 10, '*' );

| ObjStringVar.Init( 20, 20, '...ПОДСТРОКА...' );

| PrintObj( ObjStringVar ); { вывод строки }

| PrintObj( ObjSymVar ); { вывод символа }

| END.

Рис. 13.7 (окончание)

- 286 -

Весьма важным является наличие слова VAR перед формальным параметром в процедуре PrintObj. В этом случае мы передаем сам объект. Если бы в процедуре PrintObj формальный параметр был описан как параметр-значение (без слова VAR), то процедура работала бы с копией объекта, приведенной к типу формального параметра. В примере на рис. 13.7 это выразилось бы в том, что несмотря на виртуальность методов, вызывался бы метод ObjPos.Print из типа формального параметра.

13.5.3. Выбор вида метода

При объектно-ориентированном программировании на Турбо Паскале приходится все время решать дилемму: «Каким быть методу, статическим или виртуальным?» При решении этого вопроса пользуйтесь следующим критерием: делайте метод виртуальным, если есть хотя бы малейшая вероятность того, что понадобится переопределение этого метода. Это обеспечит расширяемость программ.

Другим критерием выбора может быть скорость выполнения программы. Если объект имеет хотя бы один виртуальный метод, то для него создается таблица виртуальных методов, и каждая переменная этого типа будет иметь связь с этой таблицей. Каждый вызов виртуального метода проходит через обращение к таблице VMT. С другой стороны, статические методы вызываются «напрямую», поэтому вызов статического метода происходит быстрее, чем виртуального. А если объект вообще не содержит виртуальных методов, то таблица виртуальных методов не будет создана и, как следствие этого, каждая переменная такого типа не будет поддерживать связь с таблицей VMT.

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

13.6. Динамические объекты

13.6.1. Создание динамических объектов

Объекты могут быть размещены в динамической области памяти («куче»). Для этого они должны объявляться как ссылки, подобно любым другим динамическим структурам данных:

VAR

ИмяСсылкиНаОбъект : ^ТипОбъекта;

- 287 -

Дальнейшее обращение к объектам и полям тоже будет обычным:

ИмяСсылкиНаОбъект — ссылка на объект,

ИмяСсылкиНаОбъект^ — объект в целом,

ИмяСсылкиНаОбъект^.ИмяПоля— поле данных объекта, ИмяСсылкиНаОбъект^.ИмяМетода — вызов метода объекта.

Динамические объекты могут создаваться стандартной процедурой New:

New( ИмяСсылкиНаОбъект );

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

ИмяСсылкиНаОбъект^. ИмяКонструктора( параметры );

В Турбо Паскале процедура New расширена. Она позволяет в одной операции выделить память под объект и вызвать конструктор:

New( ИмяСсылкиНаОбъект, ИмяКонструктора( параметры ) );

Порядок действия такого вызова следующий. Сначала как бы выполняется операция New( ИмяСсылкиНаОбъект ). Если она завершилась успешно, то вызывается конструктор объекта. Иногда удобно описывать поля данных объекта тоже как динамические. В этом случае выделение памяти кучи для них должно происходить в конструкторе. И, конечно, в конструкторе должна происходить необходимая инициализация полей данных (в том числе и вызовы конструкторов для унаследованных полей). Связь экземпляра с таблицей VMT устанавливается самим фактом вызова конструктора. Разместить объект в куче можно также функцией New, возвращающей ссылку на объект. В этом случае параметр, передаваемый New — это тип ссылки на объект, а не сама переменная-ссылка:

TYPE

ТипСсылкиНаОбъект = ^ТипОбъекта;

VAR

ИмяСсылкиНаОбъект : ТипСсылкиНаОбъект;

BEGIN

ИмяСсылкиНаОбъект := New( ТипСсылкиНаОбъект );

...

END.

Точно так же, как и в процедурной форме, в функциональном

- 288 -

варианте New можно использовать второй параметр — имя конструктора типа объекта.

13.6.2. Освобождение объектов. Деструкторы

Для освобождения кучи от динамических объектов применяется стандартная процедура

Dispose( ИмяСсылкиНаОбъект ).

Подобный вызов уничтожит объект в целом. Но если поля данных объекта были динамическими и под них выделялась дополнительная память при выполнении конструктора или иной процедуры инициализации, то их надо освободить до уничтожения самого объекта. Для этих целей (или других завершающих действий) вводится специальный вид метода — деструктор. Он объявляется среди прочих методов служебным словом DESTRUCTOR вместо PROCEDURE (пример реализации деструктора приведен в разд. 13.6.3). По сути, деструктор — это метод, противоположный конструктору. Обычно, если конструктор рекомендуется называть Init, то деструктору дается имя Done («завершено»). Для одного типа объекта могут быть определены несколько деструкторов. Деструкторы могут наследоваться. Они могут быть статическими или виртуальными, но лучше использовать виртуальные, так как это гарантирует, что будет выполнен именно тот деструктор, который соответствует данному типу объекта. Объект может иметь деструктор даже в том случае, когда все его методы — статические. Смысл и необходимость введения деструктора заключаются в том, что его можно использовать в расширенной процедуре Dispose так же, как используется конструктор в New.

Расширенный синтаксис процедуры Dispose позволяет в качестве второго параметра передавать имя деструктора данного типа объекта:

Dispose( ИмяСсылкиНаОбъект, ИмяДеструктора );

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

DESTRUCTOR ИмяТипаОбъекта.Done; VIRTUAL;

BEGIN END;

который нужен для нормальной работы процедуры Dispose.

- 289 -

13.6.3. Обработка ошибок при работе с динамическими объектами

Если при попытке разместить динамический экземпляр типа «объект» свободной памяти окажется недостаточно, то вызов расширенной процедуры New сгенерирует код ошибки выполнения 203. Но если переписать системную функцию HeapFunc (см. разд. 11.5.6) таким образом, чтобы она возвращала значение 1 вместо 0, то в размещаемую ссылочную переменную в случае ошибки вернется значение nil и программа не прервется. Если при запросе памяти для объекта процедурой

New( ИмяСсылкиНаОбъект, ИмяКонструктора )

функция HeapFunc выдаст значение 1, то конструктор не будет выполняться, а в ИмяСсылкиНаОбъект запишется nil.

Когда начинает выполняться тело конструктора, экземпляр объекта уже будет гарантированно и успешно распределен. Однако сам конструктор может выполнять действия по распределению динамических полей данных экземпляра, и при распределении таких полей может произойти сбой, если не хватит памяти. Будет разумно, если в подобной ситуации конструктор отменит все уже проделанные распределения и в завершение освободит экземпляр типа объекта так, чтобы в результате ссылка получила бы значение nil. Для этого введена стандартная процедура Fail, не имеющая параметров. Она может быть вызвана только из конструктора. Вызов этой процедуры освобождает динамический экземпляр, который был размещен в памяти до входа в конструктор, и возвращает в ссылке значение nil. Получение nil обозначает неудачу распределения памяти.

Нехватка памяти возможна и в случае статических объектов с динамическими полями. Так, при размещении конструктором динамических полей в куче может возникнуть нехватка памяти. Но, поскольку объект статический, нельзя передать сигнальное значение nil в ссылку — ее попросту нет. Вместо этого предлагается использовать имя конструктора как логическую функцию. Если внутри конструктора была вызвана процедура Fail, то в имени конструктора вернется значение False. В остальных случаях будет возвращаться значение True. Подобным способом анализа можно пользоваться и для проверки работы унаследованных конструкторов.

На рис. 13.8 приводится пример объектов (динамических и с динамическими полями) и их инициализация с обработкой возможных ошибок.

| TYPE

| VectorType = Array [ 1..1000 ] of Real; { вектор }

| MatrixType = Array [1..20,1..20 ] of Real; { матрица }

| VectorTypePtr = ^VectorType; { ссылка на вектор }

| MatrixTypePtr = ^MatrixType; { ссылка на матрицу }

| Vector = OBJECT {статический объект с динамическим полем }

| V : VectorTypePtr;

| CONSTRUCTOR Init( FillVect : Real );

| DESTRUCTOR Done; VIRTUAL;

| PROCEDURE Work; VIRTUAL;

| END;

| ComplexPtr = ^Complex; { Динамический объект с }

| Complex = OBJECT(Vector) { динамическими полями данных }

| M : MatrixTypePtr,

| CONSTRUCTOR Init(FillVect, FillMat : Real);

| DESTRUCTOR Done;

| VIRTUAL;

| PROCEDURE Work; VIRTUAL;

| END;

| { Реализация методов объектов }

| CONSTRUCTOR Vector.Init( FillVect : Real );

| VAR i : Word; { параметр цикла заполнения }

| BEGIN

| New( V ); { попытка разместить V в куче }

| if V=nil then begin

{ при неудаче сделать откат }

| Vector.Done; { завершение работы объекта }

| Fail { объявить сбой конструктора }

| end; {if}

| for i:=1 to 1000 do

|{ поле V создано и заполняется }

| V^[i] := FillVect;

| END;

| DESTRUCTOR Vector.Done;

| BEGIN

| if V<>nil then Dispose( V )

|{ освобождение поля V }

| END;

| PROCEDURE Vector.Work; { метод обработки поля V }

| BEGIN

| { Какие-либо действия над вектором V^ }

| END;

- 291 -

| CONSTRUCTOR Convex.Init( FillVect, FillMat : Real );

| VAR i,j : Word; { параметры циклов заполнения}

| BEGIN

| if not Vector.Init(FillVect) {инициализация прародителя }

| then Fail; {при неудаче сделать откат }

| New( M ); { попытка разместить M в куче }

| if M=nil then begin

{ при неудаче сделать откат }

| Complex.Done; { завершение работы объекта }

| Fail { объявить сбой конструктора }

| end; {if}

| for i:=1 to 20 do

| {поле М создано и заполняется }

| for j:=1 to 20 do

| M^[i,j] := FillMat;

| END;

| DESTRUCTOR Complex.Done;

| BEGIN

| if M<>nil then Dispose( M );

|{ освобождение поля M }

| Vector.Done { освобождение поля V }

| END;

| PROCEDURE Complex.Work; { метод обработки поля М }

| BEGIN

| { Какие-либо действия над матрицей M^ }

| END;

| {$F+} { новая функция анализа распределения памяти}

| FUNCTION HeapFunc(Size: Word) : Integer;

| BEGIN

| HeapFunc := 1

| END;

| {$F-}

| VAR

| Vec : Vector; { экземпляр статического объекта}

| ComPtr : ComplexPtr; { ссылка на динамический объект }

| BEGIN

| HeapError := @HeapFunc; { подстановка функции анализа }

| if not Vec.Init( 1.0 ) { инициализация поля Vec.V }

| then Halt( 1 ); { реакция на неудачу операции }

| New(ComPtr, Init(2,3)); { размещение объекта ComPtr^ }

| if ComPtr=nil { реакция на неудачу операции }

| then Halt( 2 );

| (* Применение методов Vec.Work и ComPtr^.Work *)

| Vec.Done; { освобождение поля Vec.V }

| Dispose(ComPtr, Done); { освобождение объекта ComPtr^ }

| END.

Рис. 13.8

- 292 -

Обращаем внимание на вызовы деструкторов в Vector.Init и Complex.Init перед вызовом процедуры Fail. Они нужны для отмены всех успешных размещений полей. Также важно то, что в Complex.Init вызов Vector.Init записан в выражении таким образом, что можно проверить успешность выполнения конструктора прародителя.

13.7. Функции TypeOf и SizeOf

Турбо Паскаль версии 5.5 вводит стандартную функцию

TypeOf( ИмяЭкзОбъекта_или_ИмяТипа ) : Pointer

которая возвращает указатель на таблицу виртуальных методов для конкретного экземпляра или самого типа объекта. Функция TypeOf имеет один параметр, который может быть либо идентификатором типа объекта, либо идентификатором экземпляра этого типа. Функция TypeOf применима только к объектам, имеющим таблицу VMT. Применение ее к другим типам объектов вызовет ошибку.

Функция TypeOf может быть использована для проверки фактического типа экземпляра, например:

if TypeOf( Self ) = TypeOf( ObjVar ) then ... ;

Стандартная функция Турбо Паскаля SizeOf при применении к экземпляру типа «объект», который имеет связь с таблицей VMT, возвращает размер, хранящийся в таблице VMT. Таким образом, для типов объектов, которые имеют таблицу виртуальных методов, функция SizeOf всегда возвращает фактический размер экземпляра, который может отличаться от декларированного в описании типа.

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

Программа может сама проверять корректность объектов, анализируя их размеры. Для этого программа должна компилироваться в режиме {$R+}, который распространен на виртуальные методы. При этом генерируется вызов подпрограммы проверки правильности VMT перед каждым вызовом виртуального метода. Если контрольные значения размеров в VMT указывают на сбой, происходит фатальная ошибка 210.

Включение механизма проверки вызовов виртуальных методов замедляет работу программы и несколько увеличивает ее размер. Поэтому имеет смысл включать режим {$R+} только во время отладки программы, а для рабочей версии устанавливать режим {$R-}.

- 293 -

13.8. Задание стартовых значений объектам

Можно объявлять статические объекты со стартовыми значениями полей. Для этого используется тот же синтаксис, что и для задания констант типа «запись». Для методов стартовых величин просто не существует, и они не задаются:

CONST

CObjPos : ObjPos = (Line: 1; Col: 1);

CObjString : ObgString = (Line: 1; Col:2; SubSt: 'ПЭВМ');

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

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

| TYPE

|  Obj = OBJECT

|               Поля данных;

|               CONSTRUCTOR Copy(X : Obj);

|               Другие конструкторы и(или) методы;

|            END;

| CONSTRUCTOR Obj.Copy(X : Obj);

| BEGIN

|    Self := X

| END;

| CONST

|    CObj : Obj = (значения полей данных);

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

13.9. Модули, экспортирующие объекты

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

- 294 -

деления типов объектов в разделе реализации: такие типы подчиняются тем же ограничениям, что и любые другие типы, определенные в разделе реализаций модуля. Тип объекта, определенный в интерфейсном разделе модуля, может иметь производные типы в разделе реализации модуля. В случае, когда модуль B использует модуль A, модуль В может определять производные типы от любого типа объекта, экспортируемого модулем A.

Из виртуализации объектов следует важное свойство объектно-ориентированных программ — это расширяемость или открытость. С чем оно связано? Модули, содержащие программные инструментальные средства (например, программы работы с меню, с окнами, с графикой и т.д.), могут поставляться конечным пользователям в виде подключаемых TPU-файлов с распечаткой типов объектов и методов, определенных в интерфейсном разделе модуля. Пользователи такого модуля могут, используя полиморфизм и наследование, добавлять к модулю новые свойства. Таким образом, программа наследует все, что было в исходном модуле, и создает на основе этого новые объекты.

- 295 -

Глава 14. Специальные средства языка

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

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

14.1. Работа с командной строкой. Функции ParamCount и ParamStr

Функции ParamCount и ParamStr необходимы для работы самостоятельных программ (ЕХЕ-файлов) с параметрами командной строки. Под последними понимается набор параметров, разделенных пробелами (реже знаками табуляции), который стоит после имени запускаемого файла в строке MS-DOS, например:

C:\> format a: /S

Сам по себе параметр может содержать все что угодно, кроме пробелов и табуляций. Правда, можно видеть, что некоторые утилиты требуют разделять параметры знаками типа «/» или «-». Они не являются разделителями по правилам MS-DOS, и программа сама должна разбираться, сколько параметров заложено в конструкциях типа /a/c/e/z/x или -a-g-c.

Если после имени файла в командной строке MS-DOS пусто, то ParamCount возвращает значение 0, в противном случае — число параметров в строке, разделенных пробелами или табуляцией. Это можно использовать для остановки программ, которым при запуске не были переданы параметры-аргументы (рис. 14.1).

- 296 -

| PROGRAM Uses_Parameters; { программа MyProg.pas }

| ...

| BEGIN { начало основного блока }

| if ParamCount=0 then

| begin { параметры отсутствуют }

| WriteLn;

| Write ( 'Запуск программы: '#10 );

| WriteLn( 'MyProg Параметр1 [ Параметр2 ]' );

| WriteLn; Halt

| end;

| { . . . выполнение программы . . . }

| END.

Рис. 14.1

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

В этом примере ParamCount вернула бы значение 4, a ParamStr имела бы такие значения типа String:

| N -- ParamStr(N)

| 0 -- 'C:\TURBO\PAS\MYPROG.EXE'

| 1 -- 'abc'

| 2 -- 'z'

| 3 -- '/c/d'

| 4 -- '123'

| 5 и более -- ' '

Отметим два момента: во-первых, имеет смысл (всегда!) вызов ParamStr (0), возвращающий полное имя запущенной программы; во-вторых, цифры в строке параметров будут трактоваться как строка, а не как число, и их надо будет преобразовывать процедурой Val.

- 297 -

При запуске из среды программирования ParamStr(0) вернет полное имя файла TURBO.EXE (с указанием пути к нему).

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

| { Пример программы, принимающей имя файла }

| VAR

| s : String;

| BEGIN { начало основного блока }

| if ParamCount>0 { есть ли параметры? }

| then s:=ParamStr(1) {да }

| else begin {нет }

| Write( 'Введите имя файла [DEFAULT.DAT] ' );

| ReadLn( s );

| if s=' ' then s:='DEFAULT.DAT'

| end;

| { ... ВЫПОЛНЕНИЕ ПРОГРАММЫ — обработка файла s ... }

| END.

Рис. 14.2

При отладке программ в среде Турбо Паскаль, где нет командной строки MS-DOS, можно передать программе параметры через команду Parameters в меню системных команд Options.

14.2. Доступ к памяти ПЭВМ. Массивы Mem, MemW, MemL

Для простого доступа к любой физической ячейке памяти Турбо Паскаль вводит три предопределенных массива: Mem, MemW, MemL. Они как бы наложены на всю память ПЭВМ. Можно условно считать, что эти массивы известны по системному определению:

VAR

Mem : Array of Byte absolute 0:0;

MemW : Array of Word absolute 0:0;

MemL : Array of Longlnt absolute 0:0;

- 298 -

Но отличие их от обычных массивов — в задании индексов. Они должны задаваться не номером, а адресом интересующей нас ячейки памяти в формате СЕГМЕНТ:СМЕЩЕНИЕ. Так,

Mem [$B000:$0000] — значение байта (Byte) по данному адресу;

MemW[$B000:$0000] — значение слова (Word) по данному адресу;

MemL[$B000:$0000] — значение двойного слова (LongInt).

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

Mem[ $50 : 0 ] := Mem [ $50: 0 ] xor 1;

{ вкл/выкл реакции на Shift+PrtScr }

Элементы массивов Mem могут подставляться как фактические параметры при вызовах процедур и функций. Наиболее часто массивы Mem, MemW и MemL используются для доступа к системным областям памяти, как в примере на рис. 14.3.

| PROGRAM Devices; { Анализ байта конфигурации }

| VAR

| CFG : Word; { сюда запишется значение ячейки памяти }

| BEGIN

| CFG := MemW[ $0000:$0410 ];

| WriteLn( #10, 'Текущая конфигурация:', #10 );

| WriteLn('Макс. число принтеров -->', CFG shr 14 );

| WriteLn('Число серийных портов -->', (CFG shr 9) and 7);

| WriteLn('Число НГМД --> ',

| ( CFG and 1 )*( 1 + ( CFG shr 6 ) and 3 ) );

| WriteLn('Наличие игрового порта-—>',(CFG and 4096)=1);

| WriteLn;

| ReadLn

| END.

Рис. 14.3

14.3. Доступ к портам ввода-вывода. Массивы Port и PortW

Массивы Port и PortW аналогичны массивам Mem, с той лишь разницей, что проиндексированы они не адресами, а номерами портов ввода-вывода. С помощью предопределенного массива Port можно обмениваться данными с 8-битовыми портами, а с помощью PortW — с 16-битовыми. Под поротом понимается нумерованный канал ввода-вывода, подсоединенный к процессору. Все взаимодействие с периферией ПЭВМ осуществляется через порты (в том числе работа дисплея, серийных портов, динамика, клавиатуры и т.п.). Если  ссылка на Port или PortW стоит справа в присваивании, например:

PostStatusVar := PortW[$61]; {чтение из порта}

то это означает чтение из порта с данным номером. Но если Port или PortW стоит слева, то это имеет смысл записи (посылки) в порт значения:

Num := $64;

Port[ Num ] := ByteVar {запись в порт}

Имена Port и PortW могут стоять только в операторах присваивания. Будет ошибкой обращение к Port или PortW без указания индекса. Не имеет смысла взятие адреса массивов Port или их отдельных элементов. Максимальное значение номера порта равно $3FFF.

14.4. Процедура заполнения FillChar

Эта процедура уже использовалась в предыдущих главах. Здесь мы обсудим ее подробно. Вызов процедуры содержит три параметра:

FillChar( VAR V; NBytes : Word; В : Byte )

или

FillChar( VAR V; NBytes : Word; С : Char )

Первый — переменная V любого типа, второй — число байтов переменной V, которые будут заполнены значением B или C. Процедура FillChar служит для заполнения участков памяти (ОЗУ) одним и тем же однобайтовым значением. Например, обнулить числовой массив A любой сложности можно одним вызовом:

FillChar( A, SizeOf( А ), 0 );

Если заполнение происходит числом, то третьим параметром должно быть значение, совместимое с типом Byte. Но если речь идет о заполнении символом, то последнее значение должно быть символьного типа. Самой процедуре FillChar этот момент безразличен, и можно для числового массива A записать

FillChar( A, SizeOf( А ), '0' );

- 300 -

но результатом здесь будет заполнение не нулем, а кодом Ord('0'), что равняется 48.

Следует также помнить, что заполняется заданным значением каждый байт блока с размером, заданным параметром NBytes. И если переменная A сконструирована не из однобайтных значений, а из более длинных (Word, Integer, Real и т.п.), то корректно работает лишь заполнение нулем. Например, заполнение переменной W типа Word вызовом

FillChar( W, SizeOf( Word ), 1 );

приведет к тому, что в W будет записано значение 257. Если надо заполнить не всю структуру, а часть ее, то следует указать идентификатор того элемента структуры, начиная с которого надо проводить заполнение. Так, можно заполнить средние элементы массива A:

VAR

А : Array [ 1..500 ] of LongInt;

BEGIN

FillChar( A[ 100 ], 200 * SizeOf( LongInt ), 0 );

...

END.

В этом примере 200 значений типа LongInt массива A, начиная с 100-го, будут заполнены нулем.

С особой осторожностью надо заполнять строки символами, так как нужно заботиться о нулевом байте строки. Подробно об этом говорилось в гл. 8 «Обработка символов и строк».

Кроме того, надо всегда следить за согласованностью реального размера переменной (первого параметра) и длины заполняемого блока (значением NBytes). Если длина блока превышает размер переменной, то будут заполнены байты ОЗУ, следующие за переменной, но к ней уже не относящиеся! Иными словами, если A — статическая переменная или разыменованная ссылка, то следует придерживаться правила

NBytes <= SizeOf( A ).

Сам Турбо Паскаль проверок на корректность параметров не производит.

То, что процедура FillChar заполняет все по байтам, не всегда удобно. В справочном руководстве по Турбо Паскалю приводится пример функции в машинных кодах, заполняющей области памяти так же, как FillChar, но значениями типа Word — по 2 байта сразу (рис. 14.4).

- 301 -

| PROCEDURE FillWord( VAR V; NWords, Fill : Word );

| BEGIN

| inline(

| $C4/$BE/ V / { LES DI, bp+V}

| $8B/$8E/ NWords/ { MOV CX, bp+NWords }

| $8B/$86/ Fill/ {MOV AX, bp+Fill}

| $FC/ { CLD }

| $F3/$AB ) { REP STOSW }

| END;

| VAR

| P : Pointer;

| BEGIN

| P := Ptr( $B800, 0 ); {Начало памяти экрана для цветных мониторов; для монохромных надо задавать P := Ptr( $8000, 0 ) }

| FillWord( Р^, 80*25, 176 + 14 * 256 );

| ReadLn

| END.

Рис. 14.4

На рис. 14.4 дан пример заполнения области экрана (размером 80x25 видимых символов) символом #176 цветом номер 14. Код и цвет скомбинированы в одно значение типа Word. При таком заполнении помните, что первым в машинном представлении слова (Word) идет младший байт, а следом за ним — старший (значение множителя при 256). Обратите внимание на разыменование указателя P, что означает передачу в FillWord адреса начала видеоизображения, а не самого значения P.

14.5. Процедура перемещения данных Move

Процедура Move в некотором роде — уникальная. Она практически не имеет аналогов в стандартах языков высокого уровня. По своей сути она скорее является командой машинного уровня. Процедура содержит три параметра:

Move( VAR Source, Dest; NBytes : Word )

и служит для перемещения в ОЗУ блоков данных размером NBytes. Начало блока задается переменной Source любого типа (первый байт блока соответствует первому байту значения Source). Переменная Dest, точнее задаваемый ею первый байт, указывает на место в

- 302 -

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

Очень эффективно работает процедура Move в различных трюках программистов, таких как копирование области видеопамяти (см. пример к процедуре Keep модуля DOS). Но не менее эффективно ее можно использовать и в более традиционных задачах. Например, копирование массива B в массив A:

А := В;

может быть выполнено процедурой

Move( В, A, SizeOf( В ) );

т.е. блок байтов — значений массива B соответствующего размера — будет скопирован в область памяти, занимаемую массивом A. В этом случае применение Move не дает особого эффекта. Но если, например, нам надо скопировать одну структуру в другую, причем сами структуры — разнотипные, то Move позволяет проделать это максимально просто и с наибольшим быстродействием (рис. 14.5). В этом случае не надо уже беспокоиться об индексах, а надо только указать размер копируемого блока.

| VAR R : RECORD { запись R : } X, Y :Integer; { поля-числа } Arr : Array [ 20..120 ] of Real; { поле-массив } S :String { поле-строка } END; A : Array [ 1..500 J of Real; { массив А } i : Word; BEGIN {Традиционное решение: for i:=20 to 120 do A[ i-19 ] := R.Arr[ i ]; } { Оптимальное решение : } Move( R.Arr, A, SizeOf( R.Arr ) ); END.

Рис. 14.5

Еще одна область приложения, где Move эффективнее прочих способов — это перемещение значений (сдвиг) внутри одного массива. Пусть, к примеру, объявлен массив

VAR

A : Array[ 1..10000 ] of Real;

- 303 -

(тип элементов может быть и любым другим), и надо скопировать тысячу элементов, начиная с первого на сто индексов выше (т.е. как бы сдвинуть значения с первого на сто первый индекс). Обычное, но необдуманное решение проблемы — цикл FOR:

for i:=1 to 1000 do A[ i+100] := A[ i ];

который лишь испортит данные массива A. Это произойдет из-за перекрытия исходного и конечного отрезков значений (рис. 14.6).

Рис. 14.6

Здесь элементы, начиная со 101-го, будут замещены раньше, чем скопированы! Корректный цикл FOR должен быть убывающим:

for i:=1000 downto 1 do A[ i+100 ] := А[ i ];

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

Move( А[ 1 ], А[ 101 ], 1000 * SizeOf( Real ) );

При этом проблема перекрытия снимается автоматически самой процедурой Move (она выбирает направление копирования исходя из заданных параметров). Параметры A[1] и A[101] в вызове имеют смысл не значений 1-го и 101-го элементов массива A, а адресов этих элементов в памяти.

Если же понадобится вернуть 1000 элементов «назад» в первую позицию массива, вызов будет таким:

Move( А[ 101 ], А[ 1 ], 1000 * SizeOf( Real ) );

и проблема перекрытия вновь будет решена автоматически.

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

- 304 -

данные, что весьма неприятно. Советуем использовать функцию SizeOf для вычисления длин блока. Выражения типа 1000*SizeOf (Real) состоят из констант и могут быть вычислены еще во время компиляции программы, так что длинные арифметические последовательности в вызове Move ничуть не замедляют работу программ.

14.6. Функции обработки машинных слов Lo, Hi и Swap

Среди прочих специальных средств низкого уровня Турбо Паскаль предоставляет несколько удобных функций для работы над отдельными байтами машинных слов. Некоторые системные переменные и функции Турбо Паскаля возвращают два однобайтовых значения, объединенных в тип Word. Для их «распаковки» как раз подходят описываемые здесь функции. Их три (табл. 14.1).

Таблица 14.1

Функция : Тип

Возвращаемое значение

Hi(X) : Тип-X

Старший байт аргумента X

Lo(X) : Тип-X

Младший байт аргумента X

Swap(X) : Тип-X

Число с переставленными старшим и младшим байтами

Аргумент X имеет тип Word или Integer ( 2-байтовый целый), и возвращаемое значение имеет тот же тип, что и X.

Любое число типа Word раскладывается на два слагаемых из значений своих байтов по правилу (для типа Integer эта формула не подходит)

X := Hi(X) * 256 + Lo(X);

Функция Swap возвращает число типа Word или Integer в зависимости от типа аргумента X, в котором старший и младший байты поменялись местами. Следует быть осторожным при использовании функции с аргументом типа LongInt. В версии 5.5 Турбо Паскаля компилятор «ничего не имеет против» таких вызовов, но возвращаемое значение при счете усекается до типа Word, меняя его иной раз до неузнаваемости.

14.7. Вставки машинного кода в программе

14.7.1. Оператор inline

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

- 305 -

эффективным по быстродействию, если сравнивать с грамотно написанной программой на ассемблере. Другой вопрос, за сколько дней и ночей будет написан и отлажен ассемблерный текст, а за сколько — программы на Турбо Паскале. Все это верно и для других языков. В последних версиях языка Си можно просто писать вставки на ассемблере посреди текста Си-программ. Довольно похожим способом решена проблема включения машинных команд в текст программ на Турбо Паскале. Правда, в текущих версиях языка для того надо употреблять не мнемонические команды языка ассемблера, а их аналоги в машинном коде. Оператор вставки машинного кода записывается с помощью зарезервированного слова inline и списка кодов, разделенных косой чертой:

inline ( Код1/ Код2/ Код3/ .../ КодN );

Встретив такой оператор, компилятор прекращает на время генерировать код и вставляет Код1, Код2 и другие из оператора inline без каких-либо особых преобразований, а затем снова начинает преобразовывать предложения Турбо Паскаля в выполнимый код. Это более гибкий способ, чем компоновка объектного файла директивой {$L ИмяФайла}, поскольку позволяет вставлять в программу «чисто ассемблерные» отдельные операторы, в то время как {$L...} позволяет лишь использовать внешние процедуры и функции. Программирование в чистых машинных кодах, как это требует формат inline, — занятие не для начинающих. Не имея большого опыта работы с ассемблерами для процессоров семейства 8086/286, лучше избегать применения оператора inline, тем более, что необходимость в нем возникает не так уж часто. В книге Дж.Дунтемана [5], посвященной подобным вопросам, приводится такой список задач, требующих прямого использования машинных кодов:

1. Процедуры обработки прерываний.

2. Резидентные программы.

3. Организация многозадачных режимов.

Дж. Дунтеман характеризует эти задачи как задачи «не для малодушных», особенно третью. Код в операторе inline — это либо константа, либо имя переменной. Константа должна быть целым положительным числом типа Byte или Word и может быть записана как в десятичном, так и в шестнадцатеричном формате. Пример: оператор

inline( $CD / 05 ); { Мнемоника -> INT 05H }

это то же самое, что вызов прерывания 05 (печать с экрана). Если значение константы попадает в диапазон 0...255, то она хранится

- 306 -

как однобайтовый код. Если же оно превосходит 255, то хранится как слово (два байта). В последнем случае код хранится по машинному правилу: младший байт (Lo( Word )) предшествует старшему (Hi( Word )). Можно явно заказывать формат хранения кода, используя перед константой знаки «<» и «>». Если константа записана с предшествующим знаком «<», то от нее будет взят только младший байт. Но если ей предшествует знак «>», то она будет записана в двух байтах, например:

inline( >1 ) даст два байта кода: $01 и $00.

Размер хранения кодов важен для организации переходов внутри оператора inline.

Если вместо константы стоит имя переменной, то оно трактуется как слово (два байта) — смещение в сегменте хранения этой переменной. Таким образом, переменная в inline задает адрес в сегменте DS (DSeg) или SS (SSeg) первого байта своего значения. Если же нужен не первый байт значения, а, например, третий, то можно указать это, дописав к переменной константу — смещение от ее первого байта, например:

inline(.../ XVar+2 /...);

Адрес первого байта XVar может быть записан как XVar+0. Смещение от начала переменной может быть и отрицательным, достаточно заменить знак «+» на «-».

Внутри кодов inline могут быть доступны значения глобальных переменных и типизированных констант (они хранятся в сегменте DS), а также, если inline стоит внутри тела процедуры или функции, становятся доступными локальные переменные этих процедур и их переменные параметры. Подробное изложение техники обращения к ним, соглашений о размещении и размерах локальных переменных, способах передачи значений в процедуры, функции и обратно заняло бы слишком много места (не считая таблицы машинных кодов для 8088/86/286). Подробно вопросы интерфейса с ассемблерными программами и работа с inline рассматривается в гл. 15 справочного руководства по Турбо Паскалю 5.0 [2] и в уже упоминавшейся книге [5] (с оговорками, ибо она написана для версии 3.0). Здесь же мы дадим один последний совет начинающим любителям машинных кодов: во избежание фатальных последствий запрещено модифицировать кодами оператора inline регистры процессора ВР, SP, SS и DS. Остальные — можно.

- 307 -

14.7.2. Процедуры с директивой inline

Вставки машинных кодов в программу могут производиться и другим способом: посредством описания процедур или функций директивой inline, содержащей машинные коды, как и оператор inline, рассмотренный в предыдущем разделе. Такие процедуры, собственно, уже не столько процедуры, сколько ассемблерные макросы. Механизм их работы существенно изменяется.

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

PROCEDURE PrintScreen; inline( $CD / 05 );

Вызов такой процедуры PrintScreen эквивалентен выполнению ассемблерной команды INT 05.

Inline-процедуры и функции не могут иметь тела. Все их содержимое описывается кодами в директиве inline. Но они могут иметь параметры, которые, впрочем, нельзя указывать по имени совместно с кодами (это не относится к глобальным идентификаторам).

Директивы inline предназначены только для очень коротких (менее 10 байтов) процедур и функций в машинных кодах. Из-за того, что процедуры и функции с директивой inline являются макроопределениями, к ним неприменимы операции взятия адреса (оператор @, функции Addr, Ofs и Seg).

14.8. Процедура завершения и обработка ошибок программ

Если действия написанной программы вступают в противоречие с вычислительными возможностями ПЭВМ или требуют невозможного от ее ресурсов, то они, как правило, прерываются с выдачей сообщения типа «Runtime Error NNN». В таком случае мы говорим о фатальной ошибке времени счета (или во время счета). Такие ошибки могут возникать при запросах на размещение динамических переменных при малом объеме свободной памяти, попытках записи на переполненный диск, чтении с пустых дисководов, делениях на нуль или при нарушениях области допустимых значений аргументов функций Sqrt, Ln и т.д. Список этот можно продолжить. Общим для всех этих причин является то, что неизвестно, где и как они могут

- 308 -

возникнуть. Как правило, ошибки, не связанные с вводом-выводом, возникают из-за недосмотров в логическом построении программ. Причем хорошо, если все закончится выдачей текста «Runtime Error...», ведь программа может «зависнуть» так, что разблокировать ПЭВМ можно будет только полным перезапуском...

Все ошибки времени счета можно разделить на условно и безусловно фатальные. Условно фатальные ошибки — это те, которые могут блокироваться соответствующими режимами компиляции. Например, ошибка при проверке диапазонов с кодом 201 (Range Check Error) может появиться лишь, если программа откомпилирована в режиме {$R+}, ошибка 202 — переполнение стека (Stack Overflow) — в режиме {$S+}. К условно фатальным можно отнести все ошибки, связанные с вводом-выводом (коды ошибок 2-199), подробно рассмотренные в гл. 12. Отключение соответствующих режимов контроля ошибок вовсе не повышает безошибочность программ. Оно всего лишь загоняет «болезнь» программы внутрь и дает лишний повод усомниться в корректности выдаваемых программой ответов. Безусловно фатальные ошибки — это такие, которые нельзя ничем заблокировать. Сюда относятся все ошибки вычислений с плавающей точкой и некоторые другие.

Мы уже обсуждали способы обработки ошибок ввода-вывода и ошибок при распределении памяти (см. разд. 12.11, 11.5.6). Ниже будет рассмотрен способ обработки фатальных ошибок.

Турбо Паскаль дает возможность перехватить стандартную цепочку завершения программы и подставить свою собственную процедуру, которая будет выполнять любые действия вместо выдачи малоинформативного «Runtime Error...». Восстановить нормальную работу программы при возникновении фатальной ошибки уже нельзя, и после выполнения предписанных действий программа все равно прервется, но перед этим она сможет «нормальным» языком объяснить причину останова, восстановить видеорежимы, цвета, размеры курсора и т.п.

Механизм подстановки процедуры несложен. Вот его алгоритм:

1. Пишется процедура завершения программы. Это вполне обычная процедура. Требования к ней таковы: она не должна иметь параметров и должна быть откомпилирована в режиме {$F+}. Кроме того, в ней необходимо предпринять ряд действий по обработке ошибок и восстановлению системных адресов.

2. Объявляется переменная, например, с именем OldExitProc, имеющая тип Pointer.

- 309 -

3. В самом начале программы запоминается значение предопределенной системной переменной ExitProc — адрес стандартной процедуры завершения. Оно записывается в объявленную ранее переменную (у нас — в OldExitProc). А в ExitProc записывается значение адреса новой процедуры выхода.

4. Тело новой процедуры завершения должно начинаться с восстановления старого значения ExitProc. Далее, необходимо как бы обнулить системный указатель на фатальную ошибку (даже если ее не будет в действительности, это не повредит), записав в системную переменную ErrorAddr значение nil. Если этого не сделать, то после выполнения анализа ошибки и других действий на экран может вылезти уже не нужное «Runtime Error...».

Подставленная таким образом процедура всегда будет выполняться при завершении программы: будь то естественное завершение, выход по команде Halt или останов из-за ошибки.

Хотя по определению процедура выхода не содержит параметров, ей доступно значение кода ошибки и кодов завершения, посылаемых оператором Halt(N). Они хранятся в системной переменной ExitCode типа Integer. Совместно со значением адреса ErrorAddr переменная ExitCode определяет причину остановки программы (N — значение ExitCode):

ExitCode=0

ExitCode<>0

ErrorAddr= nil

Естественное завершение

Выход по Halt(N)

ErrorAddr<> nil

Не может быть

Ошибка N

Если программа была прервана пользователем с помощью комбинации клавиш Ctrl+Break, то в ExitCode запишется значение 255. Рассмотрим пример подстановки процедуры завершения (рис. 14.7).

Программа на рис. 14.7 всегда будет чистить за собой экран и заканчивать свою работу выдачей одного из предписанных сообщений. Если выполнимый код программы создан в режимах $R- и $I-, то варианты 2..199 и 201 могут никогда не сработать. Можно было использовать условную компиляцию для изъятия их из текста при необходимости.

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

- 310 -

| USES CRT; { используется модуль CRT }

| VAR

| OldExitProc : Pointer; { здесь запомнится ExitProc }

| {$F+} { режим компиляции $F+ }

| PROCEDURE NewExit; { новая процедура выхода }

| BEGIN

| ExitProc := OldExitProc; { восстановление пути выхода }

| TextAttr := White; { задание белого цвета (CRT) }

| ClrScr; { очистка всего экрана (CRT) }

| if ErrorAddr <> nil { Выход из-за ошибки? }

| then { Да. Обрабатывается ее код. }

| case ExitCode of

| 2..199:WriteLn('Ошибка ввода-вывода.' );

| 200 :WriteLn('ДЕЛЕНИЕ НА 0.Проверьте входные данные');

| 201 :WriteLn('Переполнение диапазона.' );

| 203 :begin

| WriteLn('HE ХВАТАЕТ СВОбОДНОЙ ПАМЯТИ.' );

| WriteLn('Освободите память и повторите запуск');

| end;

| 205 :WriteLn('Переполнение в вещественном числе.');

| 206 :WriteLn('Потеря порядка в вещественном числе.' );

| else WriteLn ('Ошибка ', ExitCode, '. ',

| 'Смотрите описание TURBO PASCAL 5.5')

| end {case и then}

| else (Нет. Нормальное завершение }

| case ExitCode of

| 255 :WriteLn('Программа прервана.');

| else WriteLn('Код завершения программы : ', ExitCode )

| end; {case и else}

| ErrorAddr := nil; { обнуление адреса ошибки }

| END; {$F-} { можно вернуть режим $F- }

| { == ОСНОВНОЙ БЛОК ПРОГРАММЫ == }

| BEGIN

| OldExitProc:= ExitProc; {запоминается адрес ExitProc }

| ExitProc:= @NewExit; {назначается новая процедура }

| {...любые остальные действия программы... }

| END.

Рис. 14.7

переменной ExitProc адрес следующей процедуры, написанной по тем же правилам, и лишь в самой последней из них восстановить исходное значение ExitProc.

- 311 -

Иногда удобно оформлять процедуры завершения как модули. Программу на рис. 14.7 очень легко переделать в модуль. Надо лишь вписать слова unit Имя, interface и implementation. Тогда при его подключении к основной программе инициализирующая часть настроит процедуру завершения еще до начала выполнения основной программы. Подключать такой модуль надо будет одним из первых в списке раздела USES.

14.8.1. Оператор RunError

В Турбо Паскале введен особый оператор

RunError(N : Word)

Его предназначение — останавливать работу программ так, как будто произошла фатальная ошибка с номером N. Всюду, где можно поставить оператор Halt, можно поставить и оператор RunError. Отличие будет лишь в том, что в последнем случае программа завершится выдачей сообщения об ошибке. Оператор RunError очень удобен при отладке программ, особенно содержащих процедуры завершения и обработки ошибок. С его помощью можно испытать программу на рис. 14.7, не провоцирую реальных критических ситуаций. Вызов RunError без указания номера ошибки эквивалентен вызову RunError(0).

14.8.2. Сводка номеров фатальных ошибок

Фатальные ошибки (табл. 14.2) всегда приводят к немедленной установке программы.

Таблица 14.2

ОПИСАНИЕ ОШИБОК

200

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

ИСТОЧНИК: /, mod, div

201

Range check error (ошибка в границах/диапазонах)

ИСТОЧНИК: ошибка генерируется операторами, скомпилированными в состоянии {$R+} , при возникновении одной из следующих ситуаций: -индекс элемента массива вышел из описанного диапазона; -была осуществлена попытка присвоить переменной значение, находящееся вне диапазона значений типа переменной; -была попытка передать значение, находящееся вне допустимого диапазона, в качестве параметра процедуре или функции

- 312 -

202

Stack overflow error (переполнение стека)

ИСТОЧНИК: вызов процедуры или функции, откомпилированной в режиме $S+, в случае, если нет достаточной области для размещения их локальных переменных. Надо увеличить размер стека, используя директиву компилятора $М

203

Heap overflow error (переполнение кучи)

ИСТОЧНИК: процедуры New или GetMem в случае, если нет достаточно свободного места в динамической области памяти, чтобы выделить память для блока требуемого размера

204

Invalid pointer operation (неверная операция со ссылкой)

ИСТОЧНИК: процедуры Dispose или FreeMem в случае, если их аргумент имеет значение nil или указывает на адрес, лежащий за пределами динамически распределяемой области, или если список свободных блоков переполнен

205

Floating point overflow (переполнение при операции с плавающей точкой)

ИСТОЧНИК: операция с плавающей точкой

206

Floating point underflow (исчезновение порядка при операции с плавающей точкой)

ИСТОЧНИК: операция с плавающей точкой. Эта ошибка генерируется только в случае, если используется математический сопроцессор 8087 с управляющим словом, которое демаскирует ошибки, возникающие при исчезновении порядка. По умолчанию исчезновение порядка приводит к возвращению результата, равного нулю

207

Invalid floating point operation (недопустимая операция с плавающей запятой)

ИСТОЧНИК: функции Trunc или Round, если их аргумент не может быть преобразован в целое число, находящееся в диапазоне значений типа LongInt (от -2147483648 до 2147483647).

ИСТОЧНИК: функции Sqrt, если ее аргумент — отрицательный, и Ln, если аргумент — неположительный.

ИСТОЧНИК: переполнение стека 8087. Надо упростить математическое выражение в программе или разбить его на части

- 313 -

208

Overlay manager not installed (не установлена подсистема управления оверлеями)

ИСТОЧНИК: вероятнее всего — отсутствие обращения к процедуре OvrInit или неудачное обращение к этой процедуре. Нужно помнить, что если в каком-либо из оверлейных модулей содержится код инициализации, то нужно создать дополнительный неоверлейный модуль, вызывающий процедуру OvrInit, и использовать этот модуль перед любым из оверлейных модулей

209

Overlay file read error (ошибка чтения оверлейного файла)

ИСТОЧНИК: когда подсистема управления оверлеями пыталась считать оверлей из оверлейного файла, произошла ошибка чтения

210

Object not initialized (объект не был инициализирован)

ИСТОЧНИК: попытка вызова виртуального метода объекта, который не был ранее инициализирован вызовом конструктора. Эта ошибка генерируется, если программа создана в режиме компиляции $R+

- 314 -

Часть IV. Специальные библиотеки языка

Глава 15. Модуль CRT

Аббревиатура CRT будет расшифровываться по-русски как «электронно-лучевая трубка». И действительно, в модуле CRT реализованы специальные процедуры и функции для работы с текстовой информацией на дисплее, позволяющие: управлять текстовыми режимами, организовывать окна вывода на экран, настраивать цвета символов на экране, управлять курсором. Кроме того, в модуль включены функция опроса клавиатуры и процедуры управлений встроенным в ПЭВМ динамиком.

Несмотря на то, что модуль CRT реализует шестнадцать процедур и четыре функции, его размер составляет не более 3K. Его стандартное местонахождение — системная библиотека TURBO.TPL.

Для подключения модуля достаточно включить его в директиву USES в самом начале программы:

USES CRT;

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

Оператор Write --> функция MS-DOS (вывод строки) --> подпрограмма BIOS --> --> (базовая система ввода-вывода --> видеопамять монитора.

При подключении модуля CRT из этой цепочки исключаются медленная функция MS-DOS и, как правило, подпрограмма БСВВ вследствие чего значительно повышается скорость вывода информации на дисплей. Понятно, что чем «медленнее» работает компьютер, тем заметнее будет эффект от подключения модуля CRT. Пользователи ПЭВМ класса PC/XT могут воочию увидеть разницу, запустив по очереди две программы показанные на рис. 15.1.

- 315 -

| { Программа использует стандартный вывод }

| PROGRAM StandartOutput;

| VAR i : Byte; { счетчик цикла }

| BEGIN

| for i:=1 to 100 do Write('* Турбо Паскаль* ');

| WriteLn

| END.

| { Программа использует средства модуля CRT}

| PROGRAM CRT_Output;

| USES CRT; { подключение модуля CRT }

| VAR i : Byte; { счетчик цикла }

| BEGIN

| for i: = 1 to 100 do Write('* Турбо Паскаль* ');

| WriteLn

| END.

Рис. 15.1

Механизм подобного ускорения можно проиллюстрировать следующим образом. Существуют стандартные текстовые файлы: Input — для ввода и Output — для вывода информации. До тех пор пока программист или компилятор не предпримут каких-либо действий по их переназначению, они считаются связанными: Input — с клавиатурой, a Output — с дисплеем посредством функций MS-DOS. Все стандартные операторы ввода-вывода остаются связанными с этими файлами, т.е. оператор Write ('привет') эквивалентен оператору Write ( Output, 'привет' ), а оператор ReadLn( SomeString ) соответственно эквивалентен оператору ReadLn(Input, SomeString).

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

AssignCRT( Input ); { Связывается системный файл Input с }

{ фиктивным устройством CRT. }

Reset( Input ); { открытие Input для ввода через CRT }

AssignCRT( Output );{ Здесь связывается системный файл }

{ Output с фиктивным устройством CRT.}

Rewrite( Output ); { Файл Output открывается для вывода.}

Процедура AssignCRT из модуля CRT будет рассмотрена в разд. 15.4.8. Она аналогична по сути процедуре

Assign( логический файл, физический файл или устройство ),

но связывает логический файл с фиктивным устройством CRT.

- 316 -

Переназначение на CRT происходит автоматически, и нет нужды вставлять операторы в текст программы. Они выполняются при подключении модуля CRT.

Если же по каким-либо причинам пользователь хочет восстановить стандартную связь файлов Input и (или) Output, т.е. отказаться от «услуг» подключенного модуля CRT, то в его программе должны быть следующие операторы:

Assign( Input, ' '); { Файл Input связывается со стандарт-}

{ ным устройством ввода (чтения). }

Reset ( Input ); { Файл Input открывается для чтения. }

Assign ( Output, ' '); {Файл Output связывается со стандарт-}

{ ным устройством вывода (записи). }

Rewrite( Output ); { Файл Output открывается для записи.}

Пустая строка в операторе Assign означает стандартное предопределенное устройство, как правило устройство CON .

Кроме ускорения вывода информации на дисплей, подключение модуля CRT вносит ряд дополнений и расширений в работу стандартных процедур Write, WriteLn, Read и ReadLn.

15.1. Вывод специальных символов

При подключенном модуле CRT можно выводить на дисплей строки и символы, содержащие в себе управляющие коды (коды 0...31). При этом они не будут оказывать управляющие воздействия, а будут изображаться на дисплее, согласно таблице изображений символов по их ASCII-коду. Исключение составляют лишь четыре кода (табл. 15.1):

Таблица 15.1

Код

Управляющее воздействие

Название кода

($07)

Вызывает один короткий звук динамика

Bell

($08)

Сдвигает текущую позицию курсора влево на один символ, если есть куда сдвинуться в пределах строки; в противном случае не имеет эффекта

BackSpace (BS)

($0A)

Переводит текущее положение курсора на строку ниже, не меняя текущего столбца

Line Feed (LF)

($0D)

Переводит текущее положение курсора в начало строки

Carriage Return (CR)

- 317 -

Ниже приводится ряд программ (рис. 15.2 и 15.3), показывающих работу с управляющими символами.

| Программа вывода изображений управляющих кодов }

| USES CRT; { Используется модуль CRT }

| CONST

| SpecialChars : Set of Char = [ #7, #8, #10, #13 ];

| { символы из таблицы }

| Ch : Char = #0; { переменная-символ }

| VAR i : Byte; { параметр цикла }

| BEGIN

| ClrScr; { очистка экрана }

| while Ch < #32 do { цикл по #0...#31 }

| begin

| for i:=1 to 2 do begin

| Write ( ' Код', Ord( Ch ):3, ' -—> ');

| if ( Ch in SpecialChars )

| then Write ( ' Имеет действие' )

| else Write ( Ch:15 );

| Ch := Succ( Ch ); { следующий символ }

| end; {for}

| WriteLn { закрытие строки }

| end; { конец цикла while }

| Write ( 'Нажмите ввод для окончания ...' );

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 15.2

| {Программа использования 4-х управляющих кодов экрана }

| USES CRT; { используется модуль CRT }

| VAR i : Byte; { переменная для цикла }

| BEGIN

| ClrScr; { очистка всего экрана }

| WriteLn ( 'Нажимайте клавишу ввода для продолжения' );

| ReadLn;

| WriteLn ( ' Эффект от кода 7 - короткий звук'#7 );

| WriteLn; WriteLn; ReadLn;

| WriteLn ( ' Демонстрация кода возврата - #8 (BS)' );

| for i:=1 to 40 do Write('/'); { 40 правых косых скобок }

| for i:=1 to 40 do begin

| Delay ( 100); { задержка в 100 мс }

| Write ( #8, '\', #8 ); { Передвижение на символ }

| { влево, замена на '\' и снова один сдвиг влево }

Рис. 15.3

- 318 -

| end; {for}

| WriteLn; WriteLn; ReadLn;

| WriteLn ('Демонстрация кода разрыва строки - f10(LF)');

| WriteLn;

| Write('Эта '#10'строка '#10'разорвана '#10'кодами 10');

| Writeln( #10#10 ); ReadLn;

| WriteLn ('Работа с кодом возврата каретки - #13'#10);

| for i:=1 to 40 do Write('/'); { 40 правых косых скобок }

| Write ( #13 ); {перевод курсора в начало }

| for i:=1 to 40 do begin

| Delay ( 100 ); { задержка в 100 мс }

| Write ( '\'); { поочередная печать '\' }

| end; { конец цикла }

| WriteLn; ReadLn { пауза до нажатия клавиши ввода }

| END

Рис. 15.3 (окончание)

15.2. Модификация операторов Read, ReadLn

Операторы Read и ReadLn считывают поступающую информацию по строкам. Так, при вводе с клавиатуры, информация уходит на обработку только после ввода кода закрытия строки (а он вырабатывается клавишей Enter или Return).

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

После подключения модуля CRT набор клавиш редактирования расширяется комбинациями и клавишами, приведенными в табл. 15.2.

Таблица 15.2

Клавиша или комбинация

Действие

Esc

Стирает все символы в строке ввода

Ctrl+A

Дублирует клавишу Esc

Ctrl+S

Дублирует клавишу BackSpace

- 319 -

Ctrl+D

Вызывает очередной символ из введенной ранее, но стертой строки ввода

Ctrl+F

Вызывает всю стертую ранее строку ввода

Ctrl+Z

Вводит строку (заканчивает ввод) и вырабатывает признак конца файла, если значение системной переменной модуля CRT CheckEOF=True (см. разд. 15.3.2.2)

Комбинация клавиш Ctrl+Z может быть весьма полезна при создании файлов на диске непосредственным вводом с клавиатуры.

Далее речь пойдет о дополнительных возможностях модуля CRT и реализуемых в нем процедурах и функциях.

15.3. Системные переменные модуля CRT

При подключении модуля CRT инициализируется ряд его системных констант и переменных. Константы используются как параметры в процедурах модуля CRT. Системные же переменные играют роль переключателей режимов работы механизмов ввода-вывода, реализованных в CRT.

И константы, и переменные становятся глобальными и доступными программе, использующей модуль CRT, и их не надо описывать среди прочих идентификаторов. Так, например, в модуле CRT определена переменная DirectVideo типа Boolean, и ее стартовое значение равно True. Если надо сменить определяемый ею режим работы устройства CRT, то необходимо вставить в программу строку

USES CRT; { модуль CRT подключен }

... { раздел прочих описаний }

BEGIN

DirectVideo := False ; { <-— смена режима CRT }

... { собственно программа }

END.

Но если определить в программе такую же переменную, то доступ к оригиналу из CRT будет заблокирован. Теперь, чтобы все-таки сменить значение системной переменной, надо указывать ее принадлежность в виде определяющего поля:

- 320 -

USES CRT; { Модуль CRT подключен. }

VAR

DirectVideo : Boolean ; { Переопределение системной }

{ переменной. Тип может быть и любым другим }

BEGIN

DirectVideo := False ; { не влияет на работу CRT }

CRT.DirectVideo := False; { Режим работы CRT меняется. }

END.

В модуле CRT предопределены восемь идентификаторов (табл. 15.3)

Таблица 15.3

Переменные: тип

Действие и содержание

Стартовое значение

CheckSnow, DirectVideo : Boolean

Управление режимами вывода на дисплей

False True

CheckBreak : Boolean

Управление прерыванием работы программы

True

CheckEOF : Boolean

Разрешение или запрет интерпретации символа конца файла (#26)

False

LastMode : Word

Переменная для работы с процедурой TextMode

зависит от режима работы компьютера

TextAttr : Byte

Значение текущего цветового атрибута для вывода текста на экран

зависит от последнего режима цвета

WindMax : Word WindMin : Word

Параметры текущего окна на дисплее (см. разд. 15.4.1.1)

зависит от режима работы

Переменные общего плана рассматриваются ниже, а ряд специализированных переменных (LastMode, WindMax и WindMin) будет детально обсужден при описании процедур TextMode и Window.

15.3.1. Переменные управления выводом на дисплей

15.3.1.1. Переменная CheckSnow. На цветных дисплеях с видеоадаптером CGA могут наблюдаться белые штрихи при смене изображения или выводе информации. Это явление (Snow — в переводе

- 321 -

с английского «снег») вызвано рассогласованием между обновлением видеопамяти и сменой изображения. Оно может быть снято программным путем. Механизм снятия «снега» реализован в модуле CRT и управляется логической переменной CheckSnow. Если ее значение установлено равным True, то будет включен механизм согласования, и эффект «снега» не возникнет. При этом несколько замедлится вывод символов на экран. Для прочих дисплейных адаптеров (EGA, VGA, MDA/Hercules и др.) и для адаптеров CGA без эффекта «снега» имеет смысл поддерживать значение CheckSnow равным False. Это ускорит вывод текстовой информации на экран дисплея.

После вызова процедуры TextMode значение CheckSnow всегда автоматически устанавливается равным False.

Переменная CheckSnow зависит от состояния другой переменной модуля CRT — DirectVideo. Если последняя равна False, то значение CheckSnow не играет роли.

15.3.1.2. Переменная DirectVideo. Она устанавливает режим записи информации в видеопамять при выполнении операторов Write и WriteLn, выводящих информацию на дисплей через механизм CRT (этот механизм включается автоматически при подключении модуля CRT).

Стартовое значение логической переменной DirectVideo равно True. Это же значение устанавливается после каждого вызова процедуры TextMode. При таком значении вывод информации на дисплей производится максимально быстрым способом. После записи значения False в DirectVideo вывод на экран производится медленнее.

Трудно указать причины, когда может понадобиться смена значения DirectVideo с True на False, кроме, может быть, написания системных программ и драйверов устройств, но если необходимо это сделать, то надо помнить о переустановке значения переменной после вызова процедуры TextMode.

15.3.2. Переменные управления работой клавиатуры

15.3.2.1. Переменная CheckBreak. Эта переменная является логическим переключателем режима работы откомпилированной и скомпонованной программы. Если ее значение равно True (стартовое значение), то нажатие комбинации клавиш Ctrl+Break во время выполнения операций ввода-вывода будет прерывать работу программы. Нажатие Ctrl+Break не во время ввода-вывода информации не имеет эффекта.

Запись значения False в переменную CheckBreak вообще отключает механизм прерывания работы программы комбинацией Ctrl+Break.

- 322 -

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

USES CRT; { подключен модуль CRT }

BEGIN

CheckBreak:= False ; { отключение контроля }

... { непрерываемая часть }

CheckBreak:= True; { включение контроля }

... { здесь возможно прервать программу }

END.

Если на клавиатуре нет клавиши Break, то ее заменяет клавиша ScrollLock, и комбинация прерывания будет соответственно Ctrl+ScrollLock.

15.3.2.2. Переменная CheckEOF. Эта переменная разрешает (True) или запрещает (False) ввод с клавиатуры кода признака конца файла (ASCII-код номер 26 — «End-Of-File»). Этот код вырабатывается нажатием комбинации клавиш Ctrl+Z.

Стартовое значение CheckEOF равно False, т.е. нажатие Ctrl+Z введет в строку символ #26 и не будет иметь управляющего воздействия. Если же поменять значение CheckEOF на True, то можно организовать ввод текстов построчно, заканчивая текст признаком конца файла так же, как это делается в среде MS-DOS по команде

COPY CON FILE.TXT,

например, как в примере на рис. 15.4.

Здесь функция EOF не имеет параметров. Это означает, что она ожидает ввод кода конца файла с текущего устройства, т.е. с

| PROGRAM CopyTextToFile; { программа ввода текста в файл }

| USES CRT;

| VAR

| f : Text; { имя логического файла }

| s : String[126]; { Максимальное число символов в }

| {строке, считываемой через процедуры Read(), ReadLn() }

| BEGIN

| ClrScr; { очистка экрана }

| Assign (f,'file.txt'); { файл на диске - file.txt }

| Rewrite ( f ); { открытие файла для записи }

| WriteLn( 'Введите текст:' );

| CheckEOF := True; { разрешение интерпретации #26 }

Рис. 15.4

- 323 -

| While not EOF do { считывать строки с клавиатуры }

| Begin { пока не нажато Ctrl+ z }

| ReadLn( s );

| WriteLn{ f, s) { запись строки в файл на диске }

| end;

| Close( f ) {закрытие файла на диске }

| END.

Рис. 15.4 (окончание)

клавиатуры через механизм CRT. Если бы не было строки CheckEOF:=True, то цикл WHILE был бы «вечным».

15.3.3. Переменная TextAttr

Переменная TextAttr имеет тип Byte и может принимать значения от 0 до 255. В ней хранятся текущие цветовые атрибуты для фона, символов и атрибут мерцания символов. Каждый из восьми битов переменной TextAttr содержит определенную информацию (табл. 15.4).

Таблица 15.4

Номер бита

7

6 5 4

3 2 1 0

Что определяет

Мерцание

1 — да

0 — нет

Цвет фона

(8 значений)

0*16..7*16

Цвет символов

(16 значений,

от 0 до 15)

Компонент цвета (RGB)

Крас Зел Гол

Ярк Крас Зел Гол

Зная структуру этого байта, можно написать три функции опроса текущего цветового режима (рис. 15.5).

PROGRAM Test_Colors; { анализ текущих цветов }

USES CRT; { подключен модуль CRT }

{Бит номер 7(2^7 = 128) содержит 1(True) или 0 (False)?}

FUNCTION IsBlinking: Boolean; { проверка мерцания }

BEGIN

IsBlinking := ( TextAttr and 128 ) = 128;

END;

Рис. 15.5

- 324 -

{Число в битах 4,5,6 (2^4+2^5+2^6=112), деленное на 16 }

FUNCTION GetBackGround : Byte; { номер цвета фона }

BEGIN

GetBackGround := ( TextAttr and 112 ) div 16;

END;

{Число в битах 0, 1, 2 и 3 (1 + 2^1 + 2^2 + 2^3 = 15) }

FUNCTION GetForeGround : Byte; { код цвета символа }

BEGIN

GetForeGround := TextAttr and 15;

END;

BEGIN { Вызовы функций }

WriteLn( ' Мерцание : ', IsBlinking 5, ' Цвет фона : ', GetBackGround 2, ' символов : ', GetForeGround 2 );

ReadLn { пауза до нажатия клавиши ввода }

END.

Рис. 15.5 (окончание)

Переменную TextAttr можно использовать для управления цветовым режимом вывода символов на экран, с помощью формулы

TextAttr := ЦветСимволов(0..15)+16*ЦветФона(0..7) [+128]

Запись [+128] означает необязательный атрибут мерцания. Когда 128 добавлено, надпись будет мерцать. Если использовать такую форму установки цвета, то становятся почти «бесполезными» процедура TextColor и TextBackGround, которые, вообще говоря, всего лишь изменяют соответствующие биты системной переменной TextAttr.

При «ручном» задании цвета, как это было сделано выше, вместо цифр можно указывать цветовые константы, определяемые модулем CRT (они рассматриваются вместе с процедурами TextColor и TextBackGround), например:

TextAttr: = White + 16 * Red + Blink;

Такая формула задает мерцающий белый цвет на красном фоне.

Некоторые особенности возникают при использовании монохромных мониторов (режим Mono). Они способны отображать лишь три градации яркости: «черный», «белый» и «ярко-белый». Название градаций яркости взято в кавычки потому, что реально цвет может быть серым, зеленым или красным в зависимости от монитора. Текст может быть инверсным или подчеркнутым. Все эти атрибуты по-прежнему задаются в переменной TextAttr, но их кодировка уже иная:

- 325 -

Номер бита

7

6 5 4

3

2 1

0

Что определяет

Мерцание

1 — да

0 — нет

Цвет фона/ инверсия

Яркость

1 — да

0 — нет

Цвет символа

Подчеркивание

1 — да

0 – нет

Строго говоря, возможны лишь определенные значения атрибута:

0 (00000000) – черные символы на черном фоне;

1 (00000001) – подчеркнутые неяркие символы, черный фон;

7 (00000111) – неяркие символы на черном фоне;

9 (00001001) – подчеркнутые яркие символы, черный фон;

15 (00001111) – яркие символы на черном фоне;

112 (01110000) – инверсные цвета (черный на светлом);

127 (01111111) – инверсные цвета (яркие на светлом).

Добавление 128 к этим значениям заставит символы (но не фон!) мерцать.

Прочие комбинации битов дадут те же яркостные сочетания, хотя правила взаимодействия битов здесь далеко не прозрачные. Бит мерцания влияет только на мигание символов. Подчеркивание (бит 0) работает только, когда в битах 6, 5, 4, 2 и 1 стоят нули. В третьем бите может быть единица, добавляющая яркость подчеркнутым символам. Далее не легче: если в битах фона 6, 5, 4 есть хоть одна единица, а в битах 0, 1, 2 — нули, то будет инверсный цвет: черный по белому; если же в биты 0, 1, 2 попадет хоть одна единица, то цвета сольются: будет неяркий белый по белому. И, наконец, если в битах фона что-либо есть, бит 3 (яркость) равен единице и в битах цветов символов 0, 1, 2 есть хотя бы одна единица, то будет инверсное изображение — ярко-белое по белому.

15.4. Процедуры и функции модуля CRT

Реализованные в модуле процедуры и функции сведены в табл. 15.5.

Таблица 15.5

Процедуры и функции

Назначение

Работа с экраном в целом

Window(X1, Y1, X2, Y2 : Byte)

Задание текущего окна на экране

- 326 -

Процедуры и функции

Назначение

ClrScr

Очистка текущего окна на экране

TextMode(M: Word)

Установка текстового режима

Позиционирование курсора

GotoXY(X, Y:Byte)

Установка курсора в столбец X, строку Y

WhereX : Byte

Выдача номера текущего столбца

WhereY : Byte

Выдача номера текущей строки

Работа со строками

ClrEOL

Стирание всех символов в строке, начиная от текущего и до конца строки

InsLine

Вставка пустой строки на место текущей

DelLine

Удаление текущей строки

Настройка цвета

TextColor(C:Byte)

Выбор цвета символов на экране

TextBlackGround(C:Byte)

Выбор цвета фона под символами

HighVideo

Включение яркости цвета символов

LowVideo

Выключение яркости цвета символов

NormVideo

Восстановление цветового режима

Подача звуковых сигналов

Sound(Hz:Word)

Включение звука с частотой тона Hz в герцах

NoSound

Выключение звука

Использование встроенного таймера

Delay (ms:Word)

Задержка процесса (пауза) в ms миллисекунд

Опрос клавиатуры

KeyPressed: Boolean

Логическая функция для анализа нажатия клавиши

ReadKey : Char

Функция, возвращающая символ нажатой клавиши

Переназначение стандартных файлов

AssignCRT(VAR f : Text)

Связь текстового файла f с устройством CRT

- 327 -

Далее будут рассмотрены более подробно все функции и процедуры из табл. 15.5.

15.4.1. Работа с экраном в целом

15.4.1.1. Процедура Window( X1, Y1, X2, Y2 : Byte). Эта процедуpa устанавливает текущее текстовое окно на экране согласно схеме на рис. 15.6.

Рис. 15.6

Координаты диагонали окна X1, Yl, X2 и Y2 всегда отсчитываются от левого верхнего угла экрана в абсолютных координатах и должны удовлетворять следующим условиям:

1 <= Х1 < Х2 <= Xmax;

1 <= Y1 < Y2 <= Ymax.

При нарушении этих условий окно не создается.

Параметр Xmax может принимать два значения — 40 и 80 (при видеоадаптере MDA/Hercules — только 80), a Ymax — два или одно в зависимости от типа видеоадаптера: 25 (все типы) и 43 или 50 (адаптеры EGA или VGA соответственно).

После выполнения процедуры Window все операции, все действия с экраном относятся к той его части, которая определена координатами X1, Y1, X2, Y2. Отсчет строк и столбцов для позиционирования курсора теперь производится в координатах текущего окна, и позиция (1, 1) — это левый верхний угол окна. Часть экрана вне окна практически изымается из обращения и становится недоступной стандартным средствам языка.

Сразу после выполнения процедуры курсор устанавливается в позицию (1, 1) только что созданного окна. Очистка окна не производится.

При использовании процедуры Window следует помнить, что координаты очередного создаваемого окна всегда даются в «абсолют-

- 328 -

ных» экранных координатах, а не в относительных координатах последнего текстового окна.

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

| PROGRAM Windows; { демонстрация текст-окон }

| USES CRT; { используется модуль CRT }

| VAR

| i : Byte; { параметр циклов for }

| BEGIN

| TextAttr := White+16*Black; { цвет - белый на черном }

| ClrScr;

| for i:=1 to 112 do

| Write('* Полный Экран '); { вывод на основной экран }

| repeat

| TextAttr := White+16*Red; { цвет - белый на красном }

| Window ( 5, 5, 20, 15 ); { задание одного окна }

| for i:=1 to 120 do

| Write ( '* Окно 1 ' ); { вывод текста в это окно }

| ClrScr; { очистка первого окна }

| TextAttr:= White+16*Blue; { цвет - белый на синем }

| Window ( 40,10, 55,20 ); { задание другого окна }

| for i:=1 to 120 do

| Write ( '* Окно 2 ' ); { вывод текста в это окно }

| ClrScr; { очистка второго окна }

| until KeyPressed; { цикл до нажатия клавиши }

| END.

Рис. 15.7

Для программного опроса текущих координат окна на экране введены две специальные системные переменные модуля CRT — WindMax и WindMin.

15.4.1.2. Переменные WindMax и WindMin. Эти переменные имеют тип Word и хранят в себе закодированную информацию о размерах текущего окна на дисплее (см. процедуру Window). Поскольку максимальные значения координат текстовых окон в столбцах и строках не превышают 255, т.е. могут храниться в одном байте, каждая из переменных хранит одновременно координаты X и Y в младшем и старшем байтах соответственно. Извлечь значения X и

- 329 -

Y можно с помощью встроенных функций языка Турбо Паскаль Lo и Hi. Схема кодировки такова:

Х1 := Lo( WindMin ) + 1 ; Х2 := Lo( WindMax ) + 1;

Y1 := Hi( WindMin ) + 1 ; Y2 := Hi( WindMax ) + 1;

где X1, Yl, X2, Y2 — координаты диагонали окна (см. рис. 15.6).

Ко всем значениям добавлена единица. Это сделано для совмещения с экранными координатами, у которых начало расположено в верхнем левом углу дисплея и имеет координаты (1,1). В переменных же WindMax; и WindMin все значения отсчитываются от нуля (начало координат — точка (0,0)).

Переменные WindMin и WindMax являются единственным путем программного определения размеров текущего текстового окна. Надо только помнить схему кодировки значения и не забывать добавлять единицу.

15.4.1.3. Процедура ClrScr. Эта процедура очищает текущее текстовое окно, установленное процедурой Window или взятое по умолчанию (т.е. весь экран). При этом окно как бы «закрашивается» текущим цветом фона. Так, например, чтобы сделать поле экрана голубым, необходимо вставить в программу две строки:

TextBackGround(Blue);

ClrScr;

Процедура имеет дополнительный эффект — всегда устанавливает курсор в позицию с координатами (1,1) в текущем текстовом окне.

15.4.1.4. Процедура TextMode( М : Word ). Она переключает текстовые режимы вывода информации на дисплей. Специально для этой процедуры в модуле CRT определены восемь констант (табл. 15.6).

Таблица 15.6

Имя = числовое значение

Разрешение экрана

Цветовой режим

BW40 = 0

40x25

Черно-белый при цветном адаптере

CO40 = 1 или C40 = 1

40x25

Цветной

BW0 = 2

80x25

Черно-белый при цветном адаптере

CO80 = 3 или C80 = 3

80X25

Цветной

Mono =7

80x25

Монохромный на дисплеях MDA/Hercules

- 330 -

Font8x8 = 256

80/40 x 43 80/40 x 50

Цветной, адаптер EGA Цветной, адаптер VGA

Все остальные числовые значения до 65535, не являющиеся суммой одной из указанных констант (0, 1, 2, 3, 7), и Font8x8, включают в процедуре TextMode режим С80.

Эти константы задуманы как параметры процедуры, т.е. предлагается записывать операторы как TextMode (CO80 ), например для включения цветового режима, хотя вполне сработает и менее наглядный эквивалент TextMode (3).

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

Необходимо сделать несколько замечаний по явно выделяющейся в перечне константе Font8x8. В переводе она означает «шрифт 8x8» и включает режимы большей текстовой вместимости дисплеев с видеоадаптерами EGA и VGA, в которых вместо стандартных шрифтов из матриц 8x14 и 8x16 подключаются более «низкие» шрифты с матрицей 8x8, что дает увеличение числа строк до 43 (EGA) или 50 (VGA). Эта константа является дополнительной, т.е. она должна прибавляться к выбранному коду режима, например:

TextMode (CO80 + Font8x8 )

В этом случае включится цветовой режим CO80 одновременно со сменой разрешающей способности экрана с 80x25 на 80x43(50). Просто вызов TextMode(Font8x8) равносилен вызову TextMode (BW40+Font8x8).

В большинстве случаев режимы BWxx и СОхх не отличаются друг от друга, что всегда имеет место при использовании дисплеев с раздельным управлением цветовыми лучами (так называемые RGB-дисплеи).

Режим Mono, включенный при цветном видеоадаптере, может сбить палитру цветов для их «проявления» на монохромных дисплеях.

Кроме смены режима текстового изображения, команда TextMode обновляет значения системных переменных и производит переустановку цветовых атрибутов. Можно считать, что происходит выполнение следующих действий:

- 331 -

Window( 1, 1, Xmax,Ymax ); {окно делается равным всему экрану}

DirectVideo <-- True; {включается режим прямого вывода }

CheckSnow <-- False; {отключается снятие <снега< (CGA) }

NormVideo; {устанавливается стартовый атрибут}

ClrScr; {экран очищается }

LastMode <-- Параметр; {параметр в TextMode запоминается }

Легко заметить, что «букет» эффектов от команды TextMode не располагает к слишком частому ее использованию в программе. Нормальное место процедуры TextMode — в начале программы и (или) в самом ее конце для включения и выключения режимов работы программы. С процедурой TextMode тесно связана уже упоминавшаяся системная переменная модуля CRT LastMode.

15.4.1.5. Переменная LastMode. В этой переменной сохраняется текстовый режим работы, который установлен последним выполнением процедуры TextMode.

Ее значения (типа Word) соответствуют разрешенным значениям параметров TextMode. Самое первое значение LastMode соответствует режиму, из которого запускалась программа.

С помощью переменной LastMode можно реализовать «хороший тон» работы программы, когда после ее выполнения восстанавливается исходный текстовый режим (рис. 15.8).

| USES CRT; { программа использует модуль CRT }

| VAR

| StartMode : Word; { здесь сохранится значение режима }

| BEGIN

| StartMode := LastMode; { сохранение стартового режима }

| ... { работа в разных режимах }

| TextMode ( StartMode ) { восстановление режима }

| END.

Рис. 15.8

15.4.2. Позиционирование курсора

15.4.2.1. Процедура GotoXY( X, Y : Byte ). С помощью этой процедуры можно устанавливать курсор в столбец X и строку Y текущего окна. При этом последующая операция вывода текста на дисплей разместит первый символ выводимой строки в позиции (X, Y).

GotoXY использует систему координат текущего текстового окна, т.е. координаты (1, 1) соответствуют левому верхнему углу окна.

- 332 -

Если аргументы процедуры X и Y окажутся вне текущего окна, то ее вызов не будет иметь никакого эффекта. Нижние разрешенные значения для X и Y всегда равны 1, а верхние определяются размерами текущего окна. С помощью процедуры GotoXY можно выводить строки на экран вертикально. Пример этого приведен на рис. 15.9.

| USES CRT; { подключен CRT }

| PROCEDURE VertStr( X,Y : Byte; S : String );

| VAR

| Len : Byte absolute S; { длина строки S } i : Byte; { параметр цикла }

| BEGIN

| for i:=1 to Len do begin

| GotoXY( X, Y+Pred(i) ); { назначение позиции вывода }

| Write( S[i] ) { вывод очередного символа }

| end {for}

| END;

| BEGIN

| ClrScr; { очистка экрана }

| VertStr( 5,5, 'Вертикально!' ); { вывод строки } ReadLn { пауза }

| END.

Рис. 15.9

При выводе символов или другой информации по мере необходимости на экране происходит прокрутка, или сдвиг, изображения. Это всегда имеет место при выводе кодов конца строки (LF, код 10) в последней строке окна операторами WriteLn и ReadLn или когда выводимая строка не умещается в той же последней строке текстового окна. А, например, вывод типа

GotoXY( 5, 25 ); Write( 'строка' );

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

GotoXY( 80,25 ); Write( '*' );

и символ '*' окажется уже в 24-й строке, а не в 25-й.

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

- 333 -

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

| USES CRT;

| { Процедура закраски квадратной области экрана }

| { с диагональю (X0,Y0)-(X,Y) символом Ch }

| { ms - период задержки при закраске }

| PROCEDURE Spiral( Xo,Yo,X,Y: Byte; ms: Word; Ch: Char );

| VAR

| height, width, j : Byte;

| с : Integer;

| BEGIN

| с := 1; { начальное значение с }

| width := X - Х0 + 1; { начальная ширина поля }

| height := Y - Y0 + 1; { начальная высота поля }

| repeat { основной цикл }

| for j:=1 to width do begin { вправо/влево }

| GotoXY( X,Y ); Write( Ch ); { ставим символ }

| if (Y>Hi(WindMax)) and (X>Lo(WindMax))

| then begin { !!! Обработка }

| GotoXY( 1,1 ); InsLine { особого случая

| end;

| Delay( ms ); { задержка }

| X := X – с

| end; {for j}

| X := X + с; { восстановление Х после цикла }

| Dec( height); { поле закраски стало ниже }

| for j:=1 to height do begin { вверх/вниз }

| Y := Y - c;

| GotoXY( X,Y ); Write( Ch ); Delay( ms )

| end; {for j}

| Dec( width); { Поле закраски стало уже }

| X := X + с; {и стартовое X сдвинулось. }

| с := -1*с { смена направления }

| until (height<1) or (width<1); { условие окончания }

| GotoXY( 1, 1 ) { курсор в начало }

| END;

| VAR i : Byte; { --ПРИМЕР ИСПОЛЬЗОВАНИЯ--}

| BEGIN

| ClrScr;

| Spiral( 1,1,80,25, 2, #176 );

Рис. 15.10

- 334 -

| for i:=1 to 10 do begin

| TextAttr := i;

| Spiral( 2*i, i, 5*i, 2*i, 4, Chr( 47+i ) )

| end; {for}

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 15.10 (окончание)

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

15.4.2.2. Функции WhereX и WhereY. Эти функции нужны для программного опроса текущего местоположения курсора в текстовом окне. Они возвращают значения координат курсора в текущем окне. Можно считать, что пара функций WhereX и WhereY обратна процедуре GotoXY.

Правила нахождения столбца (WhereX) и строки (WhereY) курсора несложны. Их всего четыре:

1) сразу после команды GotoXY (X, Y) функции возвращают значения X и Y соответственно;

2) после оператора Write курсор стоит сразу за последним символом выводимой строки (если не выводятся специальные символы типа #8, #10 или #13);

3) после операторов Read, ReadLn, WriteLn курсор стоит в первом столбце строкой ниже;

4) после команд, относящихся ко всему окну (экрану), таких как ClrScr, TextMode, Window, курсор имеет координаты (1,1).

Функции WhereX и WhereY могут эффективно использоваться в программах, работающих с пользователем в режиме полноэкранного диалога (редактора текстов, таблиц и т.п.).

15.4.3. Работа со строками

15.4.3.1. Процедура ClrEOL. Эта процедура может применяться как для стирания «хвостов» строк, так и для раскраски чистого экрана в полоску максимально быстрым способом. Смысл процедуры содержится в ее названии — «очистка до конца строки». Она стирает все символы в строке, начиная с текущей позиции курсора и до правого края текущего окна. Вместо стираемых символов она ставит

- 335 -

пробелы, при этом цвет строки определяется цветовым атрибутом фона. Процедура не имеет других эффектов — даже курсор при выполнении процедуры не меняет своих координат. Программа на рис. 15.11 иллюстрирует как стирание строк, так и раскраску экрана.

| USES CRT; { Примеры применения процедуры ClrEOL }

| VAR i : Byte; {счетчик цикла }

| BEGIN

| TextAttr := White; ClrScr; {очистка экрана }

| for i:=1 to 100 do Write('*ClrEOL*'); {текст на экране }

| Delay( 1000 ); {пауза в 1 с }

| TextAttr := 16*Green; { зеленый цвет фона }

| for i:=1 to 10 do begin { Стирание концов строк: }

| GotoXY( i * 8, i ); { установка курсора, }

| ClrEOL { собственно очистка. }

| end;

| TextAttr := 16*Blue; { синий цвет фона }

| for i:=12 to 25 do { Штриховка в полоску : }

| if Odd( i ) { если i нечетное, то }

| then begin

| GotoXY( 1, i ); ClrEOL { закрасить всю строку. }

| end;

| ReadLn; { пауза до нажатия ввода }

| TextAttr := White; ClrScr { восстановление цвета } END.

Рис. 15.11

15.4.3.2. Процедуры InsLine и DelLine. Эти процедуры также работают со строками. Они позволяют «прокручивать» часть текстового окна или весь экран вверх и вниз. Процедуры выполняют несложные операции: InsLine вставляет пустую строку на место той, где находится в текущий момент курсор. Все нижние строки, начиная с нее, смещаются вниз на одну строку. Самая нижняя строка, понятно, уйдет за нижнее поле окна и исчезнет. Традиционно при вводе множественной информации «с экрана» строки начинают двигаться вверх, освобождая внизу окна место для очередного запроса. Аналогично, длинные тексты пробегают по экрану снизу вверх. При помощи процедуры Insline можно организовать такую выдачу информации на экран, при которой изображение смещается сверху вниз. Для этого достаточно перед выводом очередной строки поставить в программе два оператора

- 336 -

GotoXY( 1,1 ); InsLine;

как это сделано в примере на рис. 15.12.

| USES CRT; { Пример использования процедуры InsLine }

| VAR

| i : Byte; { счетчик цикла }

| BEGIN

| ClrScr; { очистка экрана }

| for i:=1 to 25 do { цикл вывода строк }

| begin

| {->} GotoXY( 1, 1); InsLine; { расчистка места }

| WriteLn(('Строка N ', i ); { вывод строки }

| Delay ( 200 ) { задержка в 200 мс }

| end; {for}

| ReadLn { пауза до нажатия }

| END.

Рис. 15.12

В отличие от InsLine процедура DelLine удаляет строку, в которой находится курсор, подтягивая на ее место все нижестоящие строки. При этом освобождается самая нижняя строка окна. Процедура DelLine реализует «традиционную» прокрутку всего окна или его части.

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

| USES CRT; { Пример применения процедур InsLine/DelLine }

| VAR

| i, n : Byte; { переменные для циклов }

| BEGIN

| ClrScr;

| GotoXY(1, 2*7); { начало абзаца текста }

| for i:=1 to 7 do { вывод семи строк в абзац }

| WriteLn( 'Ins/Del Line' );

| GotoXY( 1,1); { вывод курсора из абзаца }

| Repeat { Цикл : }

| for i:=1 to 7 do DelLine; { поднять абзац на 7 строк }

| for i:=1 to 7 do InsLine { и опустить на 7 строк }

| until KeyPressed; { пока не нажата какая-либо клавиша }

| END.

Рис. 15.13

- 337 -

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

15.4.4. Настройка цвета

15.4.4.1. Процедуры TextColor(C : Byte) и TextBackGround(C: Byte). Действие этих процедур сводится к записи в системную переменную TextAttr модуля CRT определенных значений. Процедура TextColor устанавливает цвет символов, a TextBackround — цвет фона. Специально для этих процедур определены константы, соответствующие различным цветам (табл. 15.7).

Таблица 15.7

Константа Число Цвет

Процедуры

Black = 0 Черный

TextColor, TextBackround

Blue = 1 Синий

TextColor, TextBackround

Green = 2 Зеленый

TextColor, TextBackround

Cyan = 3 Голубой

TextColor, TextBackround

Red = 4 Красный

TextColor, TextBackround

Magenta = 5 Фиолетовый

TextColor, TextBackround

Brown = 6 Коричневый

TextColor, TextBackround

LightGray = 7 Ярко-серый

TextColor, TextBackround

DarkGray = 8 Темно-серый

TextColor

LightBlue = 9 Ярко-синий

TextColor

LightGreen = 10 Ярко-зеленый

TextColor

LightCyan = 11 Ярко-голубой

TextColor

LightRed = 12 Ярко-красный

TextColor

LightMagenta = 13 Ярко-фиолетовый

TextColor

Yellow = 14 Желтый

TextColor

White = 15 Белый

TextColor

Blink = 128 Мерцание

TextColor (как слагаемое)

Удобство использования процедур в том, что не надо пересчитывать значения, как это делалось при непосредственном изменении TextAttr. Достаточно указать нужный цвет, подставив соответствующую константу, например:

TextColor( LightRed + Blink );

TextBackround( Green );

- 338 -

В результате будет установлен мигающий ярко-красный цвет символов на зеленом фоне.

Заметьте, что для фона разрешенными являются только восемь значений «неярких цветов».

15.4.4.2. Процедуры установки яркости HighVideo и LowVideo. Эти процедуры не имеют параметров, но тоже занимаются установкой значения системной переменной TextAttr. Более конкретно, они устанавливают бит яркости в значения «да» (1) или «нет» (0), превращая обычные цвета (Black...LightGray) в «яркие» (DarkGray...White). Хотя можно заметить некоторые несоответствия. Так, ярко-серый (LightGray) стал ярко-белым (White), коричневый (Brown) стал желтым (Yellow).

Процедуры HighVideo и LowVideo хорошо работают при оформлении диалога и каких-либо других задач, связанных с выводом текстов на экран (рис. 15.14),

| USES CRT; { Пример применения LowVideo и HighVideo}

| BEGIN

| TextColor( LightGray ); { неяркий белый цвет }

| TextBackGround( Black ); { черный цвет фона }

| ClrScr;

| Write ( 'Легко использовать ' );

| HighVideo; { включение яркости }

| Write ( 'яркость ' );

| LowVideo: { выбор низкой яркости }

| Write ( 'для выделения слов.' );

| ReadLn; { пауза до нажатия ввода}

| ClrScr

| END.

Рис. 15.14

15.4.4.3. Процедура NormVideo. Эта процедура, хотя и похожа по виду на процедуры HighVideo и LowVideo, имеет с ними мало общего. После ее выполнения восстанавливаются тот цветовой атрибут (цвет фона, символов и мерцание), который был на момент начала работы программы.

Мы уже писали о «хорошем тоне» написания программ — когда рекомендовали ставить процедуру TextMode для восстановления исходного текстового режима. Советуем добавить в конец программы вызов NormVideo. Это дает гарантию, что программа «не собьет» нормальные цвета после окончания.

- 339 -

15.4.5. Подача звуковых сигналов

Звуковые процедуры Sound ( Hz : Word ) и Nosound дают доступ к встроенному динамику ПЭВМ. Процедура Sound включает звук с заданной частотой тона в герцах. После включения звука программа выполняется дальше. Более того, если сама программа «забудет» выключить звук, то придется добавлять к ней в конец оператор NoSound под непрекращающийся аккомпанемент динамика. Набор звуковых команд всегда должна завершать процедура NoSound, выключающая динамик, хотя вызовов процедур Sound может быть сколько угодно. В таком случае звук не будет прекращаться, но будет менять свою частоту согласно заданным аргументам. Можно, например, в начало каждой процедуры поставить команду Sound с различными частотами. Тогда при работе программа будет издавать трели.

Очень часто процедуры Sound и NoSound используются вместе с процедурой задержки времени Delay(ms). Например, строка программы

Sound(300); Delay (1000); NoSound;

издает ровный звук на частоте 300 Гц продолжительностью 1 с. Но при этом во время звучания программа будет «стоять».

В качестве примера приведем несложную процедуру печати строк в звуковом сопровождении (рис. 15.15):

| USES CRT;

| {Процедура звуковой печати строк }

| PROCEDURE SoundType( X, Y: Byte; S; String; ms: Word );

| CONST

| Hz = 50; {частота тона }

| VAR i : Byte;{параметр цикла}

| BEGIN

| Dec(X);

| for i:=1 to Lengh(S) do begin

| Sound(Hz); Delay(ms); {первый сигнал }

| GotoXY(X+i, Y); Write(S[i]); {печать символа }

| Sound(2*Hz); Delay(ms); {второй сигнал }

| Nosound {снятие звука }

| end {for}

| END;

| BEGIN{--ПРИМЕР ВЫЗОВА--}

| ClrScr;

| SoundType(20, 10, '0123456789abcdeedcba9876543210', 40);

| Readln {пауза до нажатия клавиши ввода }

| END.

Рис. 15.15

- 340 -

Если разделять вызовы Sound с разными частотами небольшими задержками, то можно «синтезировать» довольно сложные звуки. Интересные примеры этого приводятся в учебной программе Turbo Pascal Tutor фирмы Borland International. Некоторые из них приведены на рис. 15.16.

| PROGRAM Sounds; { Демонстрация звуковых эффектов }

| USES CRT;

| { -- ПРОЦЕДУРЫ СИНТЕЗА ЗВУКОВ — }

| PROCEDURE Phone; { телефонный сигнал }

| VAR i : Word;

| BEGIN

| Repeat { Цикл: }

| for i:=1 to 100 do

| begin { собственно сигнал }

| Sound(1200); Delay(10); NoSound

| end;

| Delay(800) { задержка 0,8 с }

| until KeyPressed { выход - после нажатия клавиши }

| END;

| PROCEDURE Bell; { резкий звук }

| BEGIN

| Repeat { начало цикла показа }

| Sound(1800); Delay(2);

| Sound(2000); Delay(2);

| Sound(2200); Delay(2);

| Sound(2400); Delay(2)

| until KeyPressed; { выход - после нажатия клавиши }

| NoSound { отключение звучания }

| END;

| PROCEDURE Sirena; { имитация сигнала тревоги }

| VAR i : Word;

| BEGIN

| Repeat { основной цикл }

| for i := 400 to 800 do begin { восходящие тона }

| Sound( i ); Delay( 3 ) end;

| for i := 800 downto 400 do

| begin { нисходящие тона }

| Sound( i ); Delay( 3 )

| end;

| NoSound { отключение звучания }

| until KeyPressed { выход - после нажатия клавиши }

| END;

Рис. 15.16

- 341 -

| PROCEDURE Pause; { очистка буфера клавиатуры и пауза }

| VAR

| ch : Char;

| BEGIN

| While KeyPressed do ch:=ReadKey; { очистка буфера } Delay( 200 ) { задержка 0,2 с }

| END;

| BEGIN {=== основная часть ===}

| ClrScr;

| Write('Нажмите любую клавишу'#10#10#13);

| { Вызовы процедур - исполнителей: }

| Write('Звук телефона'#13);

| Phone;

| Pause;

| Write(' Звук зуммера '#13); Bell; Pause;

| Write(' Звук сирены '#13); Sirena;

| Pause;

| ClrScr

| END.

Рис. 15.16 (окончание)

Вообще говоря, встроенный в ПЭВМ «слабенький» одноголосый динамик можно «заставить» играть джаз и говорить на сносном русском языке. Но это делается с помощью специальных программ, а вручную вряд ли возможно. Зато ввести в программу нехитрые мотивы можно, зная ноты и их частотные эквиваленты в герцах.

Мы предоставляем заинтересованному читателю поупражняться в программировании и написать программу составления таблицы нот по рабочей формуле (в терминах Турбо Паскаля):

| VAR

Hz : Word;

OKT : Integer;

NOTA : Byte;

Hz:=Round( 440 * Exp( Ln(2) * (OKT - (10 - NOTA)/12 ) ) );

Здесь OKT — номер одной из восьми октав, покрывающих диапазон от 32 Гц до почти 8 кГц. Самая низкотональная октава в таком диапазоне имеет отрицательный номер (-3) и дальнейшая нумерация соответственно будет -2, -1, 0, 1, ..., +4. Параметр NOTA — это номер ноты в октаве: «До» --> 1, «До-диез» --> 2, «Ре» --> 3, .... «Си» --> 12.

- 342 -

15.4.6. Использование встроенного таймера

Процедура Delay(ms : Word) программирует паузу в ms миллисекунд. Обычное место процедуры Delay — рядом с оператором Sound или после операторов вывода рекламной или аварийной информации. Не стоит только использовать ее для очень точных отсчетов времени — реальная задержка может отличаться не несколько процентов от заказанной.

15.4.7. Опрос клавиатуры

15.4.7.1. Функция KeyPressed. Эта функция возвращает логическое значение True, если в буфере ввода с клавиатуры имеется хотя бы один символ, и False, если буфер пуст.

Когда программа стартует, буфер обычно пуст. Но любое нажатие клавиши (кроме клавиши регистров Ctrl, Shift, Alt и переключателей типа NumLock, CapsLock и т.п.) занесет ее код в буфер. Коды в буфере будут храниться до тех пор, пока они либо не будут считаны, либо буфер не будет очищен самой программой.

Очищают буфер полностью процедуры Read и ReadLn, а также операция Reset над файлом, связанным с консолью. Вообще говоря, процедуры Read и ReadLn получают ввод с клавиатуры через еще один специальный буфер. (Этим, кстати, и объясняется ограничение в 126 символов для одной вводимой строки — такова емкость буфера строки.)

Имеется еще одна функция, очищающая буфер клавиатуры — ReadKey. Но в отличие от Read и ReadLn, которые очищают весь буфер после своей работы, ReadKey как бы «вынимает» последовательно введенные в него символы по одному за каждое обращение.

Мы неспроста дали такое подробное описание механизма работы буфера ввода с клавиатуры. Ведь самое естественное место логической функции KeyPressed — в опросе состояния клавиатуры:

if KeyPressed then Действие ;

и очень заманчиво использовать ее как флаг факта нажатия клавиши. Но такая трактовка не всегда корректна. Функция KeyPressed является флагом не только сиюминутного нажатия, но и нажатий вообще во время работы программы. Так, если пользователь заденет несколько клавиш во время «молчаливого» счета своей задачи, то внешне ничего не произойдет. Но буфер запомнит все, что было «введено», и функция KeyPressed совершенно резонно не захочет работать так, как от нее ожидалось бы.

- 343 -

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

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

Функция возвращает всегда один символ, т.е. одно значение типа Char. Есть две важные особенности:

1) полученные функцией символы никогда не отражаются на дисплее, т.е. ввод символа происходит вслепую;

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

Используя эти особенности, можно построить несколько довольно полезных конструкций, что мы и сделаем в качестве иллюстрации (переменная Ch должна быть типа Char):

while KeyPressed do ch:=ReadKey; { очистка буфера ввода }

repeat until KeyPressed; { ожидание нажатия любой клавиши }

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

Тех, кто не нашел ответы на свои вопросы в этом разделе, мы просим обратиться к гл. 21 «Как осуществить полный доступ к клавиатуре», где рассмотрены примеры разделения функциональных и символьных кодов, опрос регистров и многое другое.

15.4.8. Переназначение стандартных файлов

Процедура AssignCRT(VAR f : Text) перенаправляет вывод на фиктивное устройство CRT. Устройство CRT активизируется при подключении модуля CRT директивой USES. Оно начинает выполнять функции ввода-вывода средствами библиотеки Турбо Паскаля взамен стандартных процедур MS-DOS. Подробно об этом писалось

- 344 -

в начале этой главы. При подключении модуля CRT стандартный ввод в вывод автоматически связывается с механизмами CRT. Но если вводятся файлы, отличные от стандартных, то для использования устройства CRT надо эти файлы связывать с ним. А это возможно только через процедуру AssignCRT.

Рассмотрим каркас программы (рис. 15.17), перенаправляющей файлы.

| USES CRT; { используется модуль CRT } VAR

| f : Text; { текстовый логический файл }

| BEGIN

| Assign( f, 'LPT2' ); { файл f связан с принтером }

| Rewrite( f ); { файл f открыт для вывода }

| WriteLn( f, ...); { вывод данных на печать }

| Close( f ); { файл f (LPT2) закрыт }

| AssignCRT( f ); { Файл f связан с устройством CRT }

| { и использует его механизмы быстрого вывода. }

| Rewrite( f ); { файл f открыт для вывода }

| WriteLn( f, ...}; { быстрый вывод на монитор }

| Close( f ); { файл все равно надо закрыть }

| END.

Рис. 15.17

Отметим, что никаким другим способом нельзя связать объявленный в программе файл с фиктивным устройством CRT. Наивные попытки использовать для этого процедуру Assign, типа

Assign( f, 'CRT' ); Rewrite( f );

организуют на диске файл с именем 'crt' (случай Rewrite ((f)) или вообще дадут ошибку (случай Reset (f), если файла 'crt' не существует).

При использовании вывода в устройство CRT уже нельзя будет организовать перенаправление потоков ввода-вывода при запуске откомпилированной программы в MS-DOS из командной строки. Но перенаправление станет возможным, если связать файлы в программе со стандартным устройством MS-DOS.

- 345 -

Глава 16. Модуль DOS

В системном модуле DOS, имеющем размер около 6K, реализовано большое число процедур и функций, ориентированных на работу со средой MS-DOS и использующих ее возможности. Все они отсутствуют в стандартном Паскале. Заметим, что системная библиотека Турбо Паскаля реализует много функций, специфичных для MS-DOS (например, ChDir, ParamStr и т.п.), которые, однако, оставлены в основной библиотеке, а не вынесены в модуль DOS. Но это все функции более высокого уровня, а те, которые предоставляет модуль DOS, являются инструментом доступа к «низкоуровневым» операциям MS-DOS.

Многие из реализуемых DOS процедур или функций — это просто оформленные в синтаксисе языка Паскаль вызовы функций MS-DOS. Таковы, например, почти все средства работы с файлами.

Модуль DOS при его подключении вводит большое количество констант и предопределенных типов. Их смысл до конца может быть понятен лишь опытному системному программисту. Мы же не стремимся превратить изложение Турбо Паскаля в книгу по MS-DOS и просто постараемся показать, как их можно использовать в прикладных программах.

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

— опрос и установка параметров (ключей) MS-DOS;

— работа с часами и календарем ПЭВМ;

— анализ ресурсов дисков;

— работа с каталогами и файлами;

— работа с прерываниями MS-DOS;

— организация субпроцессов и резидентных программ.

Отметим, что в отличие от модуля CRT подключение модуля DOS без использования его программ не дает видимого эффекта (хотя и привносит предопределенные типы, переменные и константы).

- 346 -

16.1. Опрос и установка параметров MS-DOS

Команды опроса и установки параметров реализованы процедурами и функциями, приведенными в табл. 16.1.

Процедуры и функции

Дейстувие

DOSVersion : Word

Возвращает закодированный номер текущей версии MS-DOS

GetCBreak(VAR B: Boolean)

SetCBreak(B: Boolean)

Считывает значение параметра BREAK

Устанавливает значение BREAK

GetVerify(VAR V : Boolean)

SetVerify(V : Boolean)

Считывает значение параметра VERIFY

Устанавливает значение VERIFY

EnvCount : Integer

EnvString( N : Integer): String

GetEnv(E : String) : String

Возвращает число системных переменных MS-DOS

Возвращает полную строку задания переменной MS-DOS номер N

Возвращает значение системной переменной Е

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

| USES DOS;

| FUNCTION XDOSVersion : String;

| VAR

|   V : Real;

|   S : String;

| BEGIN

|   V := Lo(DosVersion) + Hi(DosVersion) / 100;

|   Str(V:4:2, S);

|   XDOSVersion := S

| END;

- 347 -

16.1.1. Управление параметрами BREAK и VERIFY

16.1.1.1. Процедуры GetCBreak( VAR В : Boolean) и SetCBreak( В : Boolean ). Пара процедур GetCBreak/SetCBreak работает с системным параметром MS-DOS BREAK. Его значение обычно устанавливается в файлах CONFIG.SYS или AUTOEXEC.BAT. Если значение BREAK равно ON, то вызов процедуры GetCBreak( В ) запишет в логическую переменную B значение True; если BREAK равно OFF, то — False. Процедура SetCBreak(B) устанавливает значение BREAK равным ON, если B равно True, и OFF в противном случае.

Параметр MS-DOS BREAK контролирует возможность прерывания программ при их выполнении нажатием комбинации клавиш Ctrl+Break. Если BREAK равно ON, то возможно прерывание программы во время любых обращений ее к функциям MS-DOS, если же BREAK равно OFF, то прерывание сработает только в моменты операций ввода-вывода (при подключенном модуле CRT этот процесс, в свою очередь, контролируется переменной модуля CRT CheckBreak).

Отключение возможности прерывания делает программы более «закрытыми» и немного более быстрыми.

Эффект от установки значений BREAK может проявиться только при запуске ЕХЕ-файла вне среды Турбо. При работе в среде прерывания управляются самой средой.

16.1.1.2. Процедуры GetVerify(VAR В : Boolean) и SetVerify(B : Boolean ). Процедуры управления режимом записи на диск GetVerify и SetVerify работают так же, как пара GetCBreak/SetCBreak, с той лишь разницей, что они общаются с системным параметром MS-DOS VERIFY. Он определяет режим записи на диск: с проверкой идентичности записанных и исходных данных (значение VERIFY равно ON, а параметра в GetVerify /SetVerify — True) или без нее (значения равны OFF и False соответственно).

Режим записи с проверкой гарантирует правильность записи информации на диск, но существенно замедляет сам процесс записи.

16.1.2. Опрос системных переменных MS-DOS

Средства работы с системными переменными MS-DOS реализованы в модуле DOS функциями EnvCount, EnvStr и GetEnv. Системные переменные (не путать с параметрами!) MS-DOS — это их имена и значения, заданные пользователем командой SET (как правило, в файле AUTOEXEC.BAT) и командами PATH и PROMPT.

- 348 -

Задавая системную переменную, всегда надо писать ее имя и значение (может быть пустым), например:

| .ВАТ-ФАЙЛ

| PROMPT $p$g

| SET LIB=C:\BIN\LIB

| SET COMSPEC=E:\COMMAND.COM

Работая в MS-DOS, можно подать команду SET без параметров и увидеть текущие системные переменные и их значения. Причем, даже если не было подано ни одной команды «SET имя = значение» до этого, будут определены две системные переменные: PATH и COMSPEC. Они вводятся автоматически при загрузке системы. Параметр PROMPT должен быть задан явно. Остальные переменные «придумываются» самим пользователем.

Функция EnvCount типа Integer возвращает число определенных в MS-DOS переменных, а функция EnvStr возвращает строку в виде «имя = значение». С их помощью легко построить процедуру, аналогичную по действию команде SET без параметров в MS-DOS (рис. 16.2):

| USES DOS;

| PROCEDURE ShowSET; { показ системных переменных }

| VAR i,j : Integer;

| BEGIN

| i := EnvCount; { число переменных }

| for j:=1 to i do

| WriteLn( EnvStr( j ) ); {их вывод на экран }

| END;

| BEGIN

| ShowSET; { запуск процедуры }

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 16.2

Последняя функция GetEnv позволяет получить значение системной переменной по ее имени. Многие пакеты программ (Турбо Паскаль в том числе) при работе опрашивают системные переменные, в которых должны быть записаны рабочие каталоги, настроечные параметры и т.п. Если они отсутствуют, то принимаются какие-либо значения по умолчанию. На Турбо Паскале можно легко программировать подобные действия. Например, если нужно, чтобы

- 349 -

готовая программа работала только на ПЭВМ ее автора, достаточно вставить в текст строку

USES DOS; { подключен модуль DOS }

...

{определение переменных, типов, процедур }

BEGIN

{==> } if GetEnv( 'AVTOR' ) <> 'IVANOV' then Halt;

{ остальная программа }

END.

А в файл AUTOEXEC.BAT внести команду

AUTOEXEC.BAT

ECHO OFF

PATH ...

...

SET AVTOR=IVANOV <===

...

Программа будет работать только, если в системе определена переменная AVTOR со значением IVANOV.

Этот нехитрый способ, конечно, не годится для засекречивания коммерческих программ, но для «домашнего» пользования вполне достаточен.

Средства языка Турбо Паскаль не позволяют менять значения системных переменных или вводить их. Это связано с тем, что после завершения конфигурации среды MS-DOS ее последующая модификация весьма ограничена.

Напомним, что для увеличения области памяти под системные переменные надо вставить в файл CONFIG.SYS корневого каталога строку

SHELL = d:\путь\COMMAND.COM /р /e:NNNN

где NNNN — число байтов для области памяти системных переменных.

16.2. Работа с часами и календарем

Модуль DOS представляет как бы два набора процедур: один — для работы со встроенными часами и календарем, а второй — для ведения дат и времени создания файлов (табл. 16.2).

- 350 -

Процедура

Действие

GetDate(VAR Year, Month, Day, DW : Word)

SetDate(Year, Month, Day: Word)

Считывает год, месяц, число и день во встроенных часах ПЭВМ

Устанавливает  год, месяц, число во встроенных часах

GetTime(VAR Hour, Min, Sec, Sec100 : Word)

SetTime(Hour, Min, Sec, Sec100 : Word)

Считывает текущее время по встроенным часам ПЭВМ

Устанавливает новое время во встроенных часах ПЭВМ

PachTime(VAR DT : DataTime; VAR T : LongInt)

UnPachTime(T : LongInt; VAR DT : DataTime; )

Создает компактную запись даты и времени для назначения ее файлу

Распаковывает запись даты и времени, считанную в файле

GetFTime(VAR f; VAR T : LongInt)

SetFTime(VAR f; VAR T : LongInt)

Считывает компактную запись даты и времени для открытого файла f

Записывает компактную запись даты и времени для открытого файла f

16.2.1. Опрос и назначение даты

Для опроса или замены даты, имеющейся во встроенных часах ПЭВМ, используются процедуры GetDate и SetDate. Процедура GetDate возвращает в своих переменных значения года, месяца, числа и номера дня в неделе. Процедура SetDate, наоборот, устанавливает значения года, месяца и числа в часах. Заметим, что SetDate не нужен номер дня недели. Он вычисляется автоматически при вызове процедуры GetDate.

Существуют ограничения на вводимые значения даты. Так, год при установке должен быть в диапазоне 1980...2099, месяц — 1...12, число — 1...31. При нарушении диапазонов вызов процедуры SetDate игнорируется. Кроме употребления процедур GetDate/SetDate по непосредственному назначению, их можно использовать для определения дня недели любого числа в месяце до 2099 года. Как это сделать, рассмотрено в примере на рис. 16.3.

- 351 -

| { ДЕМОНСТРАЦИЯ ОПРЕДЕЛЕНИЯ ДНЯ НЕДЕЛИ ПО ДАТЕ }

| USES DOS;

| TYPE

| DayString = String[11];

| CONST

| Days : Array [1..7] of DayString = { дни недели }

| ( 'Понедельник', 'Вторник , 'Среда', 'Четверг',

| 'Пятница', 'Суббота', 'Воскресенье' );

| { Функция возвращает название дня недели по дате.}

| FUNCTION WhatDay( Year, Month, Day : Word ) : DayString;

| VAR

| Y, M, D, n : Word;

| BEGIN

| GetDate( Y, M, D, n ); { запоминание текущей даты }

| SetDate( Year,Month,Day ); { установка даты из запроса }

| GetDate( Year,Month,Day,n); {получение по ней номера n }

| WhatDay := Days[n]; { номер n дает название дня }

| SetDate(Y, M, D ) { восстановление даты в ПЭВМ }

| END;

| VAR { -- ПРИМЕР ВЫЗОВА -- }

| у, m, d : Word;

| BEGIN

| Write( 'Введите год ' ); ReadLn( у );

| Write( 'Введите месяц' ); ReadLn( m );

| Write( 'Введите число' ); ReadLn( d );

| WriteLn;

| WriteLn(d:2,'/', m:1,'/',y:4,'-->',WhatDay(y,m,d));

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 16.3

16.2.2. Опрос и назначение времени

Процедуры GetTime(VAR Hour, Min, Sec, Sec100 : Word ) и SetTime( Hour, Min, Sec, Sec100: Word) опрашивают и устанавливают значение текущего времени во встроенных часах ПЭВМ. Обе процедуры используют одинаковую последовательность параметров:

( часы, минуты, секунды, миллисекунды )

При установке времени процедурой SetTime их можно задавать непосредственно значениями. Разрешенные значения для установки времени таковы: часы — 0...23, минуты и секунды — 0...59, миллисекунды — 0...99. При нарушении диапазонов время не устанавливается.

- 352 -

Неаккуратное использование процедуры SetTime может сильно изменить представление компьютера о времени, зато процедура GetTime вполне безопасна. С ее помощью можно сделать счетчик времени работы программы. Схема включения процедур в программу приводится на рис. 16.4.

| USES DOS;

| VAR

| h, min, s, ms : Word; { отсечки времени по часам }

| Time : Real; { время работы в секундах }

| BEGIN

| GetTime( h, min, s, ms ); { начало работы программы }

| { время начала программы в секундах : }

| Time := ( h*60 + min )*60 + s + ms/100;

| { === программа работает - время идет === }

| Write(' Нажмите ENTER' ); ReadLn;

| GetTime( h, min, s, ms ); { конец работы программы }

| { время работы программы в секундах : }

| Time := ( h*60 + min )*60 + s + ms/100 - Time;

| ms:= Trunc( 100 * Frac( Time ) ); { миллисекунды }

| h := Trunc( Time ) div 3600; { часы }

| min := Trunc( Time-3600*h ) div 60; { минуты }

| s := Trunc( Time-3600*h ) mod 60: { секунды }

| WriteLn( 'Активное время работы , h:1,' ч ',

| min:1, ' мин ', s:1, ',' , ms:1, ' с' );

| ReadLn { пауза... }

| END.

Рис. 16.4

16.2.3. Работа с датой создания файлов

Работа с датой создания файлов — в общем-то, не первая необходимость. Но для написания антивирусных программ, для ведения картотек и баз данных или анализа файлов данных — это «рабочий» инструмент.

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

TYPE

DateTime = RECORD

Year, Month, Day, Hour, Min, Sec : Word;

END;

- 353 -

Поля этой записи представляют собой нормальные значения даты и времени, с ограничением лишь на диапазон возможных значений: Year имеет диапазон 1980...2099, Month — 1...12, Day — 1...31, Hour — 0...23, Min и Sec — 0...59.

В MS-DOS вся эта информация упакована в четыре байта, что соответствует типу LongInt Турбо Паскаля. Для преобразования даты и времени в формат MS-DOS служит процедура

PackTime( VAR DT : DateTime; VAR Т : LongInt )

Для обратного кодирования из LongInt в DateTime служит процедура

UnPackTime ( Т : LongInt; VAR DT : DateTime )

Но обе эти процедуры имеют смысл только в сопряжении с процедурами чтения и записи времени создания файла:

GetFTime( VAR f; VAR Т : LongInt )

и

SetFTime( VAR f; Т : LongInt )

Переменная f в них обозначает файл произвольного типа, вернее его логическое имя. Этот файл к моменту вызова процедур GetTime/SetTime должен быть связан с каким-либо физическим файлом на диске и открыт для записи или чтения. Переменная T в первом случае возвращает упакованные дату и время, во втором — содержит и устанавливает их. Сказанное можно проиллюстрировать программой чтения и установки даты создания файлов (рис. 16.5).

| { ПРИМЕР СМЕНЫ ДАТЫ СОЗДАНИЯ ФАЙЛА }

| USES DOS;

| { Процедура назначает файлу Fname дату и время NewDT. }

| PROCEDURE ChangeFtime(Fname: String; NewDT: DateTime);

| VAR

| f : File; { переменная для любого файла }

| ftime : LongInt; { переменная для Get/SetFTime }

| dt : DateTime; { переменная для Pack/UnpackTime }

| BEGIN

| Assign( f, Fname); { связь f с файлом }

| {$I-} Reset( f ); {$I+} { попытка открытия файла}

| if IOResult<>0 then

| Exit; { выход, если файла нет }

| GetFTime( f, ftime); { считывание времени }

| UnpackTime( ftime, dt ); { расшифровка времени }

Рис. 16.5

- 354 -

| with dt do

| WriteLn(Дата и время создания файла '+Fname+' : ',

| Day :1, '-', Month:1, '-', Year:1, ' ',

| Hour:1, ':', Min :1, ':', Sec :1 );

| PackTime( NewDT, ftime ); { упаковка новой даты }

| SetFTime( f, ftime ); { назначение ее файлу }

| Close( f ); { закрытие файла }

| with NewDT do

| WriteLn('Новые дата и время создания файла : ',

| Day :1, '-', Month:1, '-', Year:1, ' ',

| Hour:1, ':', Min :1, ':', Sec :1 );

| END; { ChangeFTime }

| { -- ПРИМЕР ВЫЗОВА ПРОЦЕДУРЫ -- }

| CONST

| NewDT : DateTime = ( Year:1991; Month:1; Day:1;

| Hour:5; Min:5; Sec:0 );

| BEGIN

| ChangeFTime( 'TEST.PAS', NewDT );

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 16.5 (окончание)

Процедура GetFTime работает с файлами, открытыми как для записи ( через Rewrite или Append ), так и для чтения (Reset). Однако процедуру SetFTime следует применять только к файлам, открытым для чтения. В противном случае процедура закрытия файла Close переустановит значение времени и даты на текущее системное. Чтобы избежать этого, можно вставить перед вызовом SetFTime оператор Reset, переоткрывающий этот же файл, но уже для чтения. Дальнейшая запись в него будет, правда, невозможна, но все это можно проделать непосредственно перед закрытием файла, и проблемы не будет.

При тестировании демонстрационной программы мы заметили необычный эффект (Турбо Паскаль 5.5, MS-DOS 3.30, PS/2-50): при назначении файлу времени 0 ч 0 мин 0 с MS-DOS переставала выдавать время создания файлов при подаче команды DIR. Возможно, этот эффект будет сохраняться в различных версиях DOS на различных ПЭВМ.

16.3. Анализ ресурсов дисков

Модуль DOS включает в себя две функции для анализа дисков:

DiskFree( D : Word ) : LongInt

- 355 -

и

DiskSize( D : Word ) : LongInt

Обе функции возвращают длинное целое число — размер свободного пространства на диске и общую вместимость диска в байтах соответственно.

Параметром является целая переменная или целое число, указывающее на конкретный диск. Если D = 0, то анализируется текущий диск, D = 1 соответствует диску A: , D = 2 — диску B: и т.д.

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

| { ПРОГРАММА АНАЛИЗА ЖЕСТКИХ И ВИРТУАЛЬНЫХ ДИСКОВ }

| USES DOS;

| VAR i : Byte; disk : LongInt; { объем дисков }

| ch : Char; { буква диска }

| BEGIN

| { Анализ ячейки системной памяти ПЭВМ: }

| i := ( Mem[0:$411] shr 6 ) + 1;

| WriteLn( #10'Дисководов для гибких дисков:', i );

| i:= 3; ch:= 'С'; disk:= DiskSize(i); { начало анализа }

| if disk>0 then WriteLn('Жесткие и виртуальные диски:');

| while disk > -1 do begin

| WriteLn( 'Диск '+ch+': -> ОБЪЕМ=', disk:8,

| ' Байт; СВОБОДНО ', DiskFree( i ),' Байт' );

| Inc( i ); ch := Succ( ch ); { следующий диск }

| disk := DiskSize( i ) end; {while}

| END.

Рис. 16.6

Первая строка тела процедуры проверяет количество накопителей на гибких дисках (для применения к ним процедур DiskSize и DiskFree надо быть уверенным, что в дисководы вставлены дискеты и шторки на них задвинуты). Далее цикл While анализирует жесткие и виртуальные диски. Цикл продолжается до первого отсутствующего диска. При этом мы считаем, что первый жесткий диск имеет обозначение C: .

- 356 -

Для того чтобы получить значения размеров в килобайтах, достаточно поделить получаемые цифры на 1024, например:

disk := DiskSize( i ) div 1024

Полученное число будет ближайшим меньшим целым числом K.

Проверка самого факта существования в ПЭВМ дисковода может производиться непосредственным вызовом функции MS-DOS. Пример этого будет рассмотрен в разд. 16.5.3 «Процедура MsDos».

16.4. Работа с каталогами и файлами

Традиционные средства языка Паскаль предоставляют минимальные возможности при работе с внешними файлами. Обычно, это открытие, закрытие, переименование и удаление файла (две последние функции отсутствуют в стандарте языка, но имеются в системной библиотеке Турбо Паскаля). А такие специальные действия, как поиск файлов и работа с их атрибутами, реализованы лишь на уровне функций операционной системы и доступны только с помощью средств ассемблера. Некоторые из таких средств включены в виде процедур и функций в модуль DOS Турбо Паскаля (табл. 16.3).

Таблица 16.3

Процедуры и функции

Назначение

Поиск файлов (анализ каталогов)

FindFirst(Path : String; Attr : Word; VAR SR : SearchRec)

Находит первое подходящее запросу Path имя с заданным атрибутом Attr

FindNext(VAR SR : SearchRec)

Вызывается после FindFirst для нахождения дальнейших подходящих имен

FSearch(Path : PathStr; DirList : String) : PathStr

Ищет файл с именем Path в списке каталогов DirList; возвращает полное имя файла

Анализ атрибутов файлов

GetFAttr(VAR f : File; VAR FA : Word)

Считывает атрибут FA файла на диске, связанного с f

SetFAttr(VAR f : File; FA : Word)

Устанавливает атрибут файлу на диске, связанному с f

- 357 -

Синтаксический анализ имени

Fsplit(Path : PathStr; VAR Dir : DirStr; VAR Name : NameStr; VAR Ext : ExtStr)

Разбивает полное имя файла Path на его составляющие (подстроки): путь Dir, имя Name и расширение Ext

Fexpand(Path : PathStr) : PathStr

Приписывает к имени файла Path текущий маршрут

16.4.1. Типы и константы модуля DOS для работы с файлами

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

CONST

ReadOnly = $01; { только для чтения }

Hidden = $02; { скрытый файл }

SysFile = $04; { системный (непереносимый) }

VolumeID = $08; { метка диска }

Directory = $10; { подкаталог }

Archive = $20; { архивный (для BACKUP) }

AnyFile = $3F; { сумма всех предыдущих }

При использовании их можно складывать. Так, имя файла имеет шестнадцать вариантов композиций атрибутов ReadOnly, Hidden, SysFile, Archive; имя подкаталога может быть скрытым и т.п. Не стоит только суммировать что-либо с константой AnyFile, ибо она уже есть сумма всех предыдущих.

Для процедур FindFirst и FindNext введен тип SearchRec:

TYPE

SearchRec = RECORD

Fill : Array[1..21] of Byte; {системное поле }

Attr : Byte; {поле атрибута }

Time : LongInt; {запись времени }

Size : Longlnt; {размер файла }

Name : String[12]; {имя файла }

END;

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

- 358 -

файлов (типизированных или бестиповых), кроме текстовых, имеется системный тип:

TYPE

FileRec = RECORD

Handle : Word;

Mode : Word;

RecSize : Word;

Private : Array [1..26] of Byte;

UserData : Array [1..16] of Byte;

Name : Array [0..79] of Char;

END;

Поле Handle содержит специальную информацию для файловых функций MS-DOS. Поле Mode типа Word хранит специальное число, характеризующее состояние файла. Для работы с этим полем определены четыре константы (и только их значения могут содержаться в этом поле):

CONST

fmClosed = $D7B0; { файл закрыт }

fmInput = $0781; { текстовый файл открыт для чтения }

fmOutput = $D782; { текстовый файл открыт для записи }

fmInOut - $D7B3; { нетекстовый файл открыт для доступа }

{Все прочие значения говорят, что файл ни с чем не связан. }

Сравнивая значения констант со значением поля Mode, можно определить текущий статус файла.

Следующее поле записи FileRec — RecSize — содержит длину записи файла (она определяется типом компонентов файла). Для бестиповых файлов она устанавливается процедурами Rewrite или Reset, а для текстовых — процедурой SetTextBuf.

Поле Private, состоящее из 26 байт, зарезервировано и не используется, зато поле UserData может содержать практически любую информацию размером до 16 байт. Оно играет роль комментария к файлу. Здесь уместно напомнить, что основное назначение типа FileRec — обслуживание внутренних процессов языка. Из полей можно извлекать информацию, но запись в них может привести к непредсказуемым, а то и фатальным последствиям. (Исключение составляет процесс написания собственных драйверов текстовых файлов, что требует весьма высокой квалификации и знания «внутренностей» MS-DOS.) Поле UserData — единственное безопасное в этом плане.

Последний компонент записи FileRec — поле Name, которое содержит полное имя физического файла на диске. Заметим, что тип

- 359 -

имени не соответствует типу строки, и вдобавок к этому имя заканчивается символом #0.

Все сказанное выше относилось к нетекстовым файлам. Для текстовых файлов используется запись с другой структурой:

TYPE

TextBuf = Array[0..127] of Char; { стандартный буфер }

TextRec = RECORD

Handle : Word;

Mode : Word; { состояние файла fmXXX }

BufSize : Word; { размер буфера }

Private : Word;

BufPos : Word;

BufEnd : Word;

BufPtr : ^TextBuf; { адрес буфера в памяти }

OpenFunc : Pointer; { адреса драйверов: }

InOutFunc: Pointer;

FlushFunc: Pointer;

CloseFunc: Pointer;

UserData : Array [1..16] of Byte;

Name : Array [0..79] of Char;

Buffer : TextBuf;

END;

Первые поля имеют тот же смысл, что и для нетекстовых файлов. Поле Mode может содержать те же значения констант. Дополнительные поля отведены для работы с текстовым буфером, а группа полей типа Pointer содержит адреса функций — драйверов текстовых файлов. Если в них не записаны адреса своих текстовых драйверов, то принимаются системные.

Кроме случаев создания собственных драйверов, следует избегать внесения изменений в поля записи (кроме поля UserData). Это требование остается и для текстовых файлов.

Если кого-либо заинтересовала возможность использования системной информации о файлах, то обязательно появится вопрос: а как к ней добраться? Ни одна функция или процедура языка не имеет аргумента типа FileRec или TextRec. Создание переменной таких типов будет пустой тратой памяти. Оказывается, что это и не нужно. Для работы с файлами необходимо объявлять их переменные, например:

VAR

tf : Text; { текстовый файл }

fr : File of Real; { файл вещественных чисел }

f : File; { бестиповый файл }

- 360 -

Предопределено, что структура типа File и File of... соответствует типу FileRec (размер 128 байт), а типа Text — типу TextRec (paзмер 256 байт). Используя операцию преобразования типов, легко опросить любое поле системного типа. Примеры этого:

if TextRec( tf ).Mode = fmOutput then ... ;

if FileRec( fr ).Mode <> fmlnOut then ... ;

ByteVAR := FileRec( f ).UserData[4];

и т.п. Пример извлечения имени файла из записи:

StringVAR := ' '; i := 0; { имя файла }

repeat

StringVAR := StringVAR + TextRec( tf ).Name[i];

Inc( i )

until StringVAR[i]=#0;

...

Работая таким образом с файловыми переменными, следует всегда помнить, что файловая переменная f перед анализом обязательно должна «пройти» через процедуры Assign (f, имя физического файла) и Reset или Rewrite. В противном случае поля типов будут содержать в буквальном смысле что угодно, кроме полезной информации.

Возможное применение описанных записей — анализ состояния конкретных файлов через поле Mode, добавление комментариев в поле UserData. Это достаточно полезно и относительно несложно. Но основное их назначение — подключение собственных файловых драйверов. Этот вопрос слишком сложен и в этой книге не рассматривается.

Зато все вышеизложенное можно с пользой применять при отладке программ в среде Турбо Паскаль. Если, например, непонятно, что творится с логическим текстовым файлом MyFile, то можно поместить его в окно отладчика Watch в преобразованном виде:

TextRec( MyFile ), R

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

Для третьей группы (процедуры FSplit и функции FExpand) вводятся специальные типы для ведения имен файлов и подкаталогов:

- 361 -

TYPE

ComStr = String [127]; { для командной строки }

PathStr = String [79]; { для полного имени файла }

DirStr = String [67]; { для маршрута на диске }

NameStr = String [8]; { только имя файла }

ExtStr = String [4]; { точка и расширение }

Для работы с процедурами поисков файлов и анализа имен необходимо вводить переменные именно таких типов. Размеры строк в типах соответствуют ограничениям MS-DOS на длину имен и маршрутов.

Для работы с файлами может также пригодиться системная переменная модуля DOS — DosError.

16.4.2. Переменная DosError

Предопределенная переменная DosError типа Integer содержит номер ошибки, возвращаемой MS-DOS, при неправильной операции. Эта переменная равна нулю до тех под, пока не произойдет сбой во время работы программы при обращении к функциям DOS. Возможные значения DosError:

0 — нет ошибки;

2 — не найден файл (невозможно связать логический файл с физическим устройством);

3 — путь (маршрут) не найден (неверная адресация файла на диске);

4 — слишком много открытых файлов (больше, чем указано в директиве FILES = ... файла CONFIG.SYS);

5 — доступ закрыт (операция заблокирована средствами DOS, или нарушаются правила работы с именами файлов или каталогов);

6 — неверное ведение файла (редкая ошибка, возникающая при нарушении информации в полях файловых переменных или в системных областях MS-DOS);

8 — не хватает памяти;

10 — несовместная операционная система;

11 — нераспознаваемая разметка (формат) диска;

12 — неверный код доступа к диску (ошибка в поле Mode файловой записи);

18 — искомые файлы исчерпаны (возникает при поиске файлов по шаблонам).

Обычно переменная  DosError используется в сопряжении с процедурами FindFirst и FindNext.

- 362 -

16.4.3. Процедуры поиска файлов на диске

16.4.3.1. Процедуры FindFirst(Path : String; Attrib : Word; VAR SR: SearchRec ) и FindNextt(VAR SR : SearchRec ). Эти процедуры предназначены для нахождения файлов на диске и всегда сопряжены между собой. Процедура FindFirst принимает в виде параметров строку с указанием маршрута поиска и имени файла (или шаблона для имен файлов) и числовое значение Attrib, указывающее атрибут искомых файлов. Атрибут может задаваться константами или их суммами. Он показывает, какие именно типы имен надо найти. Вызов процедуры FindFirst при заданных значениях параметров Path и Attrib должен производиться один раз. При этом в переменную SR предопределенного типа SearchRec запишутся параметры первого найденного файла (имя, атрибут, дата и время создания и его длина). Кроме этого, будет подготовлена специальная системная запись в памяти для ее дальнейшего использования процедурой FindNext. Эта процедура всегда должна вызываться после FindFirst (или не вызываться вовсе в противном случае). FindNext просто записывает в переданную ей переменную SR параметры следующего найденного файла, удовлетворяющего значениям Path и Attrib.

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

| USES DOS; { ПРИМЕР ПОИСКА МЕТКИ ДИСКА }

| { Функция возвращает метку диска. }

| FUNCTION GetVolume( Disk : String ) : String;

| VAR SR : SearchRec;

| BEGIN { Поиск. Имя диска дописывается до шаблона.}

| FindFirst( Disk+'\*.*', VolumeID, SR );

| case DosError of { анализ : }

| 0 : GetVolume = SR.Name; { нашлась }

| 18 : GetVolume = 'NO LABEL' { не нашлась }

| else GetVolume = 'ERROR'#7 { ошибка }

| end {case}

| END;

| BEGIN { ПРИМЕР ВЫЗОВА }

| WriteLn( 'Метка диска С: ', GetVolume( 'С:' ) );

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 16.7

- 363 -

файлов, или их список исчерпался при очередном запросе FindNext), DosError будет хранить ее код. При этом FindFirst может дать коды 2 и 18, a FindNext — только 18.

Ряд примеров (рис. 16.7,16.8,16.9) показывает, как можно использовать описанные процедуры.

| USES DOS; { ПРИМЕР ПРОВЕРКИ СУЩЕСТВОВАНИЯ ФАЙЛА }

| (Функция возвращает True, если файл FileName существует. }

| FUNCTION FileExists( FileName : String ) : Boolean;

| VAR SR : SearchRec;

| BEGIN

| { Поиск происходит только среди файлов. }

| FindFirst(FileName,AnyFile-VolumeID-Directory,SR);

| FileExists := ( DosError = 0 )

| END;

| BEGIN { — ПРИМЕР ВЫЗОВА — }

| if FileExists( 'C:\PASCAL\*.PAS' ) then

| begin

| WriteLn( 'Здесь есть Паскаль-программы !');

| if FileExists( 'C:\PASCAL\demo.pas ')

| then WriteLn('...И файл DEMO тоже здесь есть!')

| else WriteLn( 'Но среди них нет файла DEMO...');

| end {then}

| else WriteLn( В каталоге нечего искать ! );

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 16.8

| USES DOS; { ПРИМЕР ПОКАЗА СОДЕРЖИМОГО КАТАЛОГА }

| { ПРОЦЕДУРА ПОКАЗЫВАЕТ СПИСОК СОДЕРЖИМОГО ДИСКА ПО }

| { ШАБЛОНУ Where }

| PROCEDURE ShowDisk( Where : PathStr );

| TYPE { виды атрибутов }

| AttrType = ( RO, Hid, Sys, Vol, Dir, Arc );

| CONST { их обозначения }

| AttrText : Array[AttrType] of.Char = ('R', 'H', 'S', 'V', 'D', 'A');

| { их значения }

| AttrVal : Array [AttrType] of Byte = ( 1, 2, 4, 8, 16, 32 );

Рис. 16.9

- 364 -

| VAR

| i : AttrType; { переменная цикла по атрибутам }

| SR : SearchRec;

| DT : DateTime;

| BEGIN

| if Where=' ' { Если пустая строка, }

| then Where:='*.*'; { то дописать шаблон. }

| { Поиск происходит среди файлов и каталогов:}

| FindFirst(Where, AnyFile, SR); { найти первый файл }

| while DosError = 0 do begin { пока нет ошибки }

| with SR do begin { очередной объект }

| Write( Name:15, Size:10 );

| UnPackTime( Time, DT );

| with DT do Write(Day:5,'-',Month:2, '-',Year:4,

| Hour:5, ':', Min:2, ':', Sec:2,' ');

| for i:=RO to Arc do { Цикл по атрибутам }

| if ( Attr and AttrVal[i] ) = AttrVal[i]

| then Write(AttrText[i]) else Write( '.' );

| WriteLn

| end; {with SR}

| FindNext( SR ) { поиск следующего }

| end {while}

| END;

| { ПРИМЕР ВЫЗОВА }

| BEGIN

| ShowDisk( 'C:\*.*' );

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 16.9 (окончание)

Функция GetVolume возвращает метку диска, которая была установлена при форматировании или командой MS-DOS LABEL. Метка диска одна, поэтому используется только вызов FindFirst. С помощью FindFirst можно проверять наличие файла в определенном месте.

Последний пример показывает, как написать процедуру показа содержимого каталога (как это делается, например, в системах PC TOOLS или Norton Commander).

16.4.3.2. Функция FSearch( Path : PathStr, DirList: String ) : PathStr. Эта функция возвращает строку типа PathStr, в которой содержится имя и адрес файла на диске. Параметры функции несколько необычны. Первый параметр Path задает имя файла, который нужно отыскать, а второй параметр DirList является списком маршрутов, разделенных точкой с запятой и указывающих, где

- 365 -

именно искать файл. Возможные вызовы функции FSearch могут иметь такой вид:

USES DOS;

VAR S : PathStr;

BEGIN

{Поиск файла в списке каталогов: }

S:=FSearch('MYFILE.DOC', 'C:\;C:\TOOLS;C:\HELP;D:\' );

...

{Поиск файла в одном каталоге: }

S:= FSearch( 'YOURFILE.PAS', 'C:\PASCAL\PAS' );

...

{ Поиск файла в текущем каталоге: }

S:= FSearch( 'OURFILE.PAS' , ' ');

...

END.

Перед тем как начать поиск файла в каталогах списка DirList, функция всегда попытается отыскать его в текущем каталоге. Если файл будет найден, то в переменную S запишется имя файла из параметра Path, в противном случае функция вернет пустую строку. Легко заметить, что параметр DirList аналогичен по синтаксису команде РАТН=... MS-DOS. Поэтому, если программе надо искать файл (не обязательно .СОМ или .ЕХЕ) в общедоступных каталогах, то можно построить вызов

S: = FSearch( 'MyFile.txt', GetEnv( 'PATH' ) );

Функцию FSearch можно, в принципе, использовать для проверки наличия файла в указанном месте. Более того, именно так и надо поступать, если поиск ведется во многих местах. Но для нахождения файла в одном конкретном месте более эффективна процедура, построенная из FindFirst и FindNext.

16.4.4. Работа с атрибутами файлов

Работа с атрибутами файлов проводится при помощи двух процедур:

GetFAttr ( VAR f; VAR Attr : Word );

и

SetFAttr ( VAR f; Attr : Word ).

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

- 366 -

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

| USES DOS;

| VAR

| f : File Of Real;

| t : Text;

| FA : Word;

| BEGIN

| Assign( f, 'DIFFUR.DAT'); GetFAttr( f, FA );

| if ( FA and ReadOnly ) = ReadOnly

| then SetFAttr( f, FA-ReadOnly );

| Rewrite( f );

| ...

| Close( f );

| FA := Archive + ReadOnly + Hidden;

| Assign( t, 'TEXT.FIL' ); SetFAttr( t, FA );

| ...

| END.

Рис. 16.10

В примере на рис. 16.10 анализируется атрибут файла DIFFUR.DAT, и если он содержит в себе защиту от записи, то она снимается и можно открывать файл. Второй файл TEXT.FIL снабжается целым «букетом» атрибутов защиты.

Используя константы атрибутов, легко анализировать и изменять атрибуты файлов. Пусть FA — считанный только что атрибут файла. Тогда выражение типа

( FA and Hidden ) = Hidden

анализирует наличие атрибута Hidden. Если оно истинно, то атрибут имеется. Выражение типа

FA := FA or ReadOnly

подготовит FA для установки, включив режим «только для чтения»;

FA := FA and (AnyFile - ReadOnly)

сделает все наоборот: исключит ReadOnly из суммы атрибутов, а оператор

FA := FA xor SysFile

сменит атрибут системности на обратный.

- 367 -

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

Естественно, следует помнить и об эффектах иных атрибутов. Так, поставив какому-либо каталогу атрибут Hidden, не следует потом удивляться, куда он делся при подаче команды DIR, как не стоит удивляться тому, что файлы с нарушенным атрибутом архивности не копируются командой BACKUP.

16.4.5. Анализ имен файлов

16.4.5.1. Процедура FSplit( X : PathStr, VAR Dir : DirStr, VAR Name : NameStr, VAR Ext: ExtStr). Эта процедура служит для разбиения на части полного имени файла. Под полным именем мы понимаем конструкцию из маршрута на диске и собственно имени файла. Принимая на входе строку X, процедура разбивает ее на три подстроки соответствующих типов:

Dir — имя маршрута на диске;

Name — имя файла ( до восьми символов без точки );

Ext — точка и следующее за ней расширение.

Если при разборе строки X окажется невозможным выделить какой-либо ее компонент, то вернется значение '' (пустая строка). Примеры вызовов и их результаты можно увидеть в табл. 16.4.

Таблица 16.4

Значение X

Dir=

Name=

Ext=

'C:\DOS33\SYS.COM'

'C:\DOS33\'

'SYS'

'.COM'

'BILL.EXE'

''

'BILL'

'.EXE'

'GAMES\DIGGER'

'GAMES\'

'DIGGER'

''

'GAMES\DIGGER\'

'GAMES\DIGGER\'

''

''

'A:FILE.COM'

'A:'

'FILE'

'.COM'

В некоторых случаях возможна неоднозначная трактовка параметра X. Так, в примере с 'GAMES\DIGGER' подстрока 'DIGGER' может быть и именем файла, и именем подкаталога.

Процедура FSplit никогда не запрашивает диск, чтобы разобраться в подобных проблемах. Она просто считает последнее слово после символа '\' в строке именем файла. Если подразумевается, что DIGGER — имя подкаталога, то надо дописывать символ разделения каталогов.

- 368 -

16.4.5.2. Функция FExpand( X : PathStr ) : PathStr. Действие функции состоит в приведении строки X к полному имени файла, причем к какому именно, зависит от значения X.

Если X — просто имя файла или имя файла с указанием его подкаталога относительно текущего местонахождения, то функция допишет к X полный маршрут текущего положения. Но если X уже содержит полное имя, то оно просто перепишется заглавными буквами без добавления маршрута. Сказанное выше иллюстрируется табл. 16.5 (считается, что текущий каталог — C:\TEST):

Таблица 16.5

Пример вызова

Возвращаемое значение

... :=Fexpand( 'test.txt' )

'C:\TEST\TEST.TXT'

... :=Fexpand( '..\DEMO\d.pas' )

'C:\DEMO\D.PAS'

... :=Fexpand( '..\auto.bat ' )

'C:\AUTO.BAT'

... :=Fexpand( '\LEX\out.txt ' )

'C:\LEX\OUR.TXT'

... :=Fexpand( '\' )

'C:\'

... :=Fexpand( '\\' )

'C:\\

... :=Fexpand( 'SUBDIR\' )

'C:\TEST\SUBDIR\'

... :=Fexpand( 'A:\LEX\our.txt' )

Программа на рис. 16.11 показывает, как можно применить процедуру FSplit и функцию FExpand для написания заведомо «капризных» программ, которые работают только с файлами из текущего каталога.

| USES DOS; { ПРИМЕР ОБРАБОТКИ ИМЕН ФАЙЛОВ }

| VAR X, FullName : PathStr; Dir : DirStr ;

| Name : NameStr; Ext : ExtStr ;

| BEGIN

| Write( 'Введите полное имя обрабатываемого файла: ' );

| ReadLn( X );

| FSplit(X, Dir, Name, Ext); { состав введенного имени }

| X:=FExpand( X ); { перевод в верхний регистр }

| if ( Dir=' ' ) or {He введен путь или же ка- }

| (X<>FExpand(Name+Ext)) { талог при X - не текущий. }

| then begin { Файл не оттуда! Конец. }

| WriteLn( #10'Ошибка в имени'+

| или попытка обмануть программу!' );

| Halt end; { if }

| ... { работа с верным именем }

| END.

Рис. 16.11

- 369 -

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

16.5. Работа с прерываниями MS-DOS

Вызов системных функций MS-DOS реализован в виде прерываний. Каждое прерывание, будучи активизированным, может открывать доступ к множеству различных функций. Так, например, прерывание с номером 16H дает доступ к функциям опроса клавиатуры на уровне операционной системы, прерывание с номером 25H управляет чтением диска и т.д. Особую роль играет прерывание с номером 21H. Оно открывает доступ к нескольким десяткам функций, образующим собственно операционную систему.

Работая на ассемблере, программист при необходимости вызова той или иной функции MS-DOS должен предварительно загрузить в определенные регистры процессора номер функции и ее аргументы и вызвать прерывание по его номеру. Список прерываний, связанных с ними функций и их аргументов, занял бы целую книгу и здесь не приводится. Заинтересованных мы отсылаем к техническим описаниям MS-DOS конкретных версий и БСВВ (BIOS) конкретных ПЭВМ.

А как быть тем, кто знает Паскаль, но не знаком с машинным кодом? Ответ прост: пользоваться процедурами модуля DOS, поддерживающими обращение к функциям MS-DOS (или прерываниям), прямо из Паскаль-программ (но знать, что делает прерывание и как выполняется, конечно, необходимо). Список этих процедур приводится в табл. 16.6.

Таблица 16.6

Процедура

Действие

GetIntVec(N : Byte; VAR Adress : Pointer)

Возвращает в Adress адрес подпрограммы прерывания с заданным номером N

SetIntVec(N : Byte; Adress : Pointer)

Устанавливает в DOS новую подпрограмму прерывания с номером N, замещая старое значение адреса на Adress

- 370 -

Intr(N : Byte; VAR R : registers)

Активизирует программное прерывание N, передавая ему номер функции и параметры в переменной R

MsDos(VAR R : Registers)

Специализированный вызов прерывания с номером 21H

В таблице введен новый тип Registers. Он определен в модуле DOS и является записью с вариантами:

| TYPE

Registers = RECORD

case Integer of

0: (AX, BX, CX, DX, BP, SI, DI, DS, ES, Flags : Word);

1:(AL, AH, BL, BH, CL, CH, DL, DH : Byte);

| END;

Переменные такого типа служат для доступа к регистрам микропроцессора при вызовах Intr и MsDos. Вариант 0 позволяет обращаться к 16-разрядным регистрам (парам), а вариант 1 — к 8-разрядным ячейкам процессора. Специально об указании варианта заботиться не следует. Если написать, например,

USES DOS;

VAR

R1, R2 : Registers;

BEGIN

R1.AX := $01FF;

R2.AL := $CA;

…

END.

то компилятор сам разберется с типом поля записи по его имени.

16.5.1. Чтение и перестановка адресов подпрограмм прерываний

Действия с перестановкой адресов — работа несложная, но «опасная». Прежде чем пояснить этот тезис, дадим общее понятие о предмете. При загрузке операционной системы в ОЗУ модуль БСВВ располагает в самом начале памяти таблицу векторов прерываний. Под этим красивым названием хранится простой список адресов подпрограмм ОС или аппаратной части, выполняющих действия по тому или иному прерыванию. Выполнение прерывания означает

- 371 -

среди прочего чтение адреса из этой таблицы и передачу управления подпрограмме по этому адресу.

Очевидно, что если написать свою программу обработки какого-нибудь прерывания (что непросто без специальных знаний) и «подставить» ее адрес вместо «настоящего», то ряд функций ОС будет выполняться этой программой. Так работают все резидентные программы. Находясь постоянно в памяти, они перехватывают нужные им прерывания и анализируют их. Например, если резидентная программа активизируется нажатием каких-либо клавиш (таковы SideKick, драйверы клавиатуры и т.п.), то она настраивает на себя прерывания 9 и 16H, которые «включаются» при каждом нажатии клавиши на клавиатуре. Далее анализируется, что именно было нажато, и если это была запускающая комбинация, то начинает работать сама резидентная программа. Если же нет, то вызывается настоящая подпрограмма этого прерывания, как будто ничего не было. Чтение адреса подпрограммы отработки прерывания осуществляется процедурой

GetIntVec( N : Byte; VAR Adress : Pointer ).

Задав через параметр N номер интересующего нас прерывания, после вызова получим в переменной Adress адрес его подпрограммы, вызов процедуры вполне безопасен. Установка адреса новой подпрограммы делается процедурой

SetIntVec( N : Byte; Adress : Pointer ).

Здесь параметр N по-прежнему содержит номер прерывания, а параметр Adress должен содержать адрес специально оформленной процедуры, которую надо подставить в таблицу векторов.

Эксперименты с этой процедурой в высшей степени опасны: ошибка в задании адреса или неверное оформление процедуры способны, используя термины жаргона программистов, послать вектор прерывания «в космос». Реально же это означает полную непредсказуемость дальнейшего поведения ПЭВМ. Хорошо, если она просто «зависнет», а то — можно лишиться информации на диске и испортить ее.

Жесткие требования предъявляются к оформлению собственно процедур обработки прерываний. Описание заголовков таких процедур, должно выглядеть следующим образом:

PROCEDURE IntProc(Flags, CS, IP, АХ, ВХ, СХ, DX,

SI, DI, DS, ES, ВР: Word); INTERRUPT;

- 372 -

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

Например, заголовки

PROCEDURE IntProc2( SI, DI, OS, ES, BP : Word ); INTERRUPT;

PROCEDURE IntProc3( ES, BP : Word ); INTERRUPT;

верны, так как отброшены и оставлены две неразрывные части полного списка параметров, а заголовок

PROCEDURE IntProc4( Flags, ES, BP : Word ); INTERRUPT;

неверен, так как пропуск делает «дыру» в списке.

Названия параметров не должны меняться. Внутри процедуры прерывания с ними можно делать что угодно (опрашивать, изменять — одновременно с ними будет изменяться содержимое соответствующих им регистров). Процедура с указанием interrupt не может быть вызвана, как обычная процедура. Она начнет работать только после активации настроенного на нее прерывания, и она ничего не возвращает. Имена ее параметров можно использовать вне interrupt-процедуры.

Процедуры для прерываний низкого уровня (аппаратных — от клавиатуры, портов, таймера и т.п.), номера которых лежат в диапазоне от 0 до 31 (от 0 до 16H), не должны в общем случае содержать в себе вызовов процедур ввода-вывода Турбо Паскаля, команд динамического распределения памяти и вызовов функций ОС.

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

| USES DOS;

| VAR

| GlobalVARI, GlobalVAR2, ..., GlobalVARK : Word;

| {$F+} {<-Interrupt-процедуры должны быть с таким ключом }

| PROCEDURE MyInterrupt(Flags, CS, IP, AX, BX, CX, DX,

| SI, DI, DS, ES, BP : Word); INTERRUPT;

| VAR

| ... { описание локальных переменных }

Рис. 16.12

- 373 -

| BEGIN

| GlobalVAR1:=AX; { Можно снять входные параметры}

| GIobaIVAR2:=Port[...]; { прерывания и запомнить их. }

| ...

| END; { Myinterrupt }

| {$F-}

| VAR

| N : Byte;

| OldlntVectN : Pointer; { буферная переменная }

| BEGIN

| N := { номер заменяемого прерывания };

| { Сохранение исходного вектора в буферной переменной:}

| GetIntVec( N, OldlntVectN );

| { Запись в вектор N адреса подставляемой процедуры: }

| SetIntVec( N, SMylnterrupt );

| ...

| { Программа работает с подмененным прерыванием: }

| Write( GlobalVARI, GlobalVAR2 GlobalVARK );

| ...

| SetIntVec( N, OldlntVectN );

| { Всегда надо восстанавливать исходные векторы, если }

| { только программа не остается резидентной в памяти. }

| END.

Рис. 16.12 (окончание)

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

16.5.2. Вызов прерывания процедурой Intr

Процедура Intr(N : Byte; VAR R : Registers) выполняет прерывание номер N, передавая ему значение через регистры переменой R и в ней же возвращая сосояние регистров после обработки прерывания.

Пример использования процедуры Intr дан на рис 16.13.

16.5.3. Процедура MsDos

Процедура MsDos (VAR R: Registers) реализует частный случай вызова Intr( N, R ) для N = 33 (21Н). Эта процедура вызывает и выполняет одну из функций DOS прерывания с номером 21Н. Каждая функция имеет свой набор входных значений регистров в

- 374 -

| USES DOS;

| {Печать экрана на принтере, как при нажатии Shift+PrtScr}

| PROCEDURE PrintScreen;

| VAR R : Registers;

| BEGIN

| Intr( $05, R ) { вызов системного прерывания }

| END;

| BEGIN

| Write( 'Нажмите ENTER для запуска печати экрана ' );

| ReadLn;

| PrintScreen;

| END.

Рис. 16.13

записи R типа Registers. Обычно в R.AH должен содержаться номер функции, в R.AL и следующих — параметры для вызова. После выполнения процедуры MsDos регистр R.AL содержит, как правило, код завершения операции (0, если все в порядке) и возвращаемые величины в других регистрах. Пример использования MsDos — определение множества букв, обозначающих доступные в ПЭВМ диски (рис. 16.14). Для работы примера требуется MS-DOS версий 3.0 и старше.

| USES DOS; { АНАЛИЗ НАЛИЧИЯ ДИСКОВОДОВ В ПЭВМ }

| TYPE

| DrivesSetType = Set of 'A'..'Z'; { множество букв }

| { Процедура возвращает множество букв дисков в ПЭВМ }

| PROCEDURE TestDrives( VAR Drives : DrivesSetType );

| VAR

| R : Registers; { переменная-регистры }

| i : Byte; { параметр цикла }

| ch : Char; { буква очередного диска }

| BEGIN

| ch := Pred('A'); { символ перед 'A' }

| Drives := []; { стартовое значение набора }

| for i:=1 to 26 do begin { от диска A: до... }

| ch:=Succ( ch ); { буква рассматриваемого диска }

| R.AH := $44; { номер функции MS-DOS }

| R.AL := $08; { загрузка параметра в AL }

Рис. 16.14

- 375 -

| R.BL := i; { загрузка номера диска в BL }

| MsDos( R ); { вызов функции номер 44Н }

| if R.AX <= 1 { если АХ>1, то диска нет }

| then Drives := Drives + [ch]

| end {for}

| END;

| VAR { ПРИМЕР ВЫЗОВА }

| с : Char; { параметр цикла }

| HD : DrivesSetType; { множество дисков }

| BEGIN

| TestDrives( HD ); { анализ дисков }

| for c:='A' to 'Z' do

| if с in HD then WriteLn(c, ':' );

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 16.14 (окончание)

16.6. Организация субпроцессов и резидентных программ

Операционная система MS-DOS обладает мощной способностью организовывать субпроцессы. Это означает, что одна программа может запустить другую, а та, в свою очередь, еще одну и т.д. Запускающая программа (процесс), включив работу субпроцесса, сама как бы замирает (но остается в памяти ПЭВМ). Субпроцесс выполняется в оставшейся памяти как любая другая программа. После его завершения вновь «оживает» процесс более высокого уровня.

Это свойство MS-DOS позволяет создавать программы-интеграторы. В них содержатся, как правило, меню запускаемых программ с комментариями и сами запуски этих программ, т.е. команды организации субпроцессов. Популярная программа Norton Commander, например, является нормальной нерезидентной программой, активно использующей субпроцессы (будь то запускаемые из нее файлы или подкачка программ типа dbview.exe).

Нормальные программы после завершения работы освобождают память ПЭВМ. Субпроцессы после их завершения передают управление вызвавшим их программам, а те, в конце концов, передают управление ОС.

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

- 376 -

ограничиться только скрытыми «махинациями» с прерываниями ОС. Основная их особенность в том, что после завершения своей работы они остаются в памяти ПЭВМ, и оживают лишь при выполнении каких-либо условий. Как правило, резидентные программы настраивают на себя определенные векторы прерываний (сигнал с клавиатуры, обращение к диску, запуск программы и т.п.), анализируют, что произошло, и при необходимости выполняют заложенные в них действия. Примеров резидентных программ можно привести множество. Здесь и система SideKick, и драйверы кириллицы ALFA, BETA, антивирусные программы и сами вирусы, а также многое другое. Объединяет их одно: они все находятся в ОЗУ и «оживают» лишь при специальных условиях (нажатии определенной клавиши, например, ALFA, BETA; обращении к диску — антивирусные программы-защитники, наступлении заданного времени — программы расписаний и т.п.). В пассивном состоянии резидентные программы только занимают место и не мешают нормальным программам работать (в том числе вызывать субпроцессы и т.д.).

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

Рис. 16.15

Эта свободная память используется для локальных переменных процедур и функций и для динамических переменных (созданных

- 377 -

процедурами New и GetMem). В ней не могут быть организованы субпроцессы. А другой свободной памяти нет. Выход один — указать явно отводимый размер памяти (рис. 16.16).

Рис. 16.16

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

В Турбо Паскале для управления памятью служит ключ компилятора $М. Он должен стоять до первой строки текста на Паскале в основной программе (в модулях он не имеет смысла):

{$М Стек, МинимумКучи, МаксимумКучи }

Этот ключ детально обсуждался в разд. 11.4. На месте первого параметра должно стоять число в интервале от 1024 до 65520 (1K...64K) — это память для стека. Второй параметр — Минимум-Кучи — это число, показывающее минимальный размер требуемой свободной памяти (обычно это 0, максимальное значение — 655360 (640K). Если на момент запуска программы свободной памяти в ПЭВМ будет меньше чем МинимумКучи, то она не сможет работать и остановится с сообщением о невозможности выполнения. Последним идет максимальный размер кучи. Его диапазон тот же: от 0 до 655360 (0K...640K), но не меньше чем МинимумКучи.

- 378 -

Задавая размеры кучи, не следует заботиться об уже находящихся в памяти программах и вычислять, сколько места они занимают. Если для кучи выделено параметром МаксимумКучи места больше, чем реально осталось в памяти, то его значение будет автоматически сокращено. Основной задачей для разработчика программы является определение разумных ресурсов стека и кучи. Размер стека можно оценить, просуммировав размеры локальных переменных в процедурах и функциях самой «глубокой» по уровням вложенности цепочки их вызовов и найдя максимальное для программы значение этой суммы. Проще найти требуемые размеры кучи. Для этого надо просуммировать размеры динамических переменных (объектов), созданных при выполнении процедур New и GetMem. Заметим, что ограничившись этой суммой, надо далее идеально использовать память кучи, т.е. не оставлять в ней пустот между динамическими объектами, стирая некоторые из них. В противном случае, если куча будет «дырчатой» (разрывной), в нее могут не уместиться объекты, более крупные, чем максимальный свободный блок в ней, даже если сумма этих зазоров будет достаточно велика.

Тем не менее полученные числа для размеров стека и кучи вполне можно взять за начальные приближения. Если же они окажутся малы, то возникнут ошибки времени выполнения: 202 — переполнение стека и 203 — переполнение кучи (при отладке программ рекомендуем включать в них директиву проверки переполнения стека {$S+}).

Пусть, к примеру, вычисленные предварительно размеры стека и кучи будут равны 968 байт и 2000 байт соответственно. Тогда директива $М может иметь вид

{$М 1024, 0, 2048 -

Значения округлены в большую сторону до целого числа килобайтов. Вместо 0 можно, в принципе, поставить любое число, не превышающее максимальное значение кучи (здесь до 2048).

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

{$М 4096, 0, 0 -

Установив директиву использования памяти, можно далее применять специальные процедуры (табл. 16.7) для организации субпроцессов и резидентных программ.

- 379 -

Процедуры

Назначение

SwapVectors

Восстанавливает системные либо временные векторы прерываний для запускаемых субпроцессов

Exec(ExeFile, ComLine : String)

Запускает выполнимый файл ExeFile (субпроцесс) со строкой параметров ComLine

Функция DosExitCode : Word

Возвращает код завершения субпроцесса

Keep(ExitCode : Word)

Завершение программы без стирания ее из памяти ПЭВМ (организация резидентного кода)

16.6.1. Программирование субпроцессов

16.6.1.1. Процедура SwapVectors. При запуске среды Турбо Паскаль или созданного в ней выполнимого файла первым делом происходит смена ряда системных векторов прерываний на векторы отладчика среды и системной библиотеки. Однако адреса системных векторов не теряются, а запоминаются в переменных типа Pointer с именами SaveIntNN, где NN — номер прерывания (эти переменные являются предопределенными и привносятся вместе с системной библиотекой).

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

Процедура SwapVectors восстанавливает векторы прерываний, которые сохранены в переменных SaveIntNN, записывая одновременно в эти же переменные предыдущие векторы. Поэтому второй вызов SwapVectors вновь восстановит «отключенные» процедуры прерываний и сохранит в переменных последние активные адреса. Вообще говоря, можно даже взять за правило, чтобы в текстах программ соблюдалось требование четности вызовов процедуры SwapVectors.

Обычно эта процедура используется как «обрамляющая» для вызова Exec и в тех случаях, когда надо вернуться на время к исходным векторам, т.е. к тем, что были до запуска программы. О

- 380 -

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

16.6.1.2. Процедура Ехес( ExeFile, ComLine : String ). Эта процедура служит для запуска субпроцесса. Программа, в которой используются вызовы процедуры Exec, должна иметь в своем начале директиву распределения памяти {$М...}. Кроме того, рекомендуется до вызова Exec и сразу после него вставлять процедуру SwapVectors.

В процедуру передается два строковых аргумента: ExeFile — имя файла или полное имя файла (в обоих случаях обязательно указывать расширение имени) — это просто имя того файла, который нужно «запустить» из программы; ComLine — строка из аргументов, которые передаются запускаемому файлу.

Рассмотрим пример. Пусть в командной строке MS-DOS дается команда

С:\> format a: /s

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

Ехес( 'format.com', 'a: /s' );

или даже

Ехес( 'c:\dos\format.com', 'a: /s' );

если файл format.com лежит не в текущем каталоге, а в C:\DOS.

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

Второй пример: в строке MS-DOS слияние файлов задается командой

С:\> copy a.txt + b.txt c.txt

Но COPY — встроенная команда командного процессора и не является запускаемым файлом. Чтобы реализовать ее как субпроцесс, необходимо запускать командный процессор COMMAND.COM и передавать ему текст команды в виде параметров:

Ехес( 'connmand.com', '/с copy a.txt+b.txt c.txt' );

Важно не забывать включить в командную строку первым по счету ключ /c для командного процессора. Если забыть это сделать, то получится «выход в DOS», и вернуться из субпроцесса можно будет только через подачу команды EXIT с клавиатуры. Ключ /р тоже не годится для субпроцесса, поскольку заставляет выполниться файл AUTOEXEC.BAT, что вряд ли к месту при запуске субпроцесса. А

- 381 -

ключ /c выполнит команды из строки и автоматически завершит субпроцесс.

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

Ехес( GetEnv( 'COMSPEC' ), '' );

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

Ехес( GetEnv( 'COMSPEC' ), '/с format a: /s' );

Обращаем внимание, что здесь расширение '.СОМ' у команды format уже не обязательно. Подобный запуск имеет свои особенности. Первая — это незначительный перерасход памяти, и им можно пренебречь. Вторая особенность важнее: если запускается субпроцесс, то можно при помощи функции DosExitCode проанализировать, чем и как он закончился. Написав, например, в программе

Exec( 'subproc.exe', Parameters );

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

Exec( GetEnv( 'COMSPEC' ), '/с subproc '+Parameters );

скорее всего даст нормальное завершение субпроцесса, даже если subproc.exe сломает дисковод, сожжет монитор и завершится фатальной ошибкой. Просто в этом случае будет рассматриваться работа самого процессора COMMAND.COM, а не того субпроцесса, который он запускает и выполняет. А процессор редко дает сбои. Следует помнить об этом внутреннем различии, хотя внешний эффект будет неразличим (если, конечно, речь идет не о сжигании мониторов!).

О функции DosExitCode речь еще пойдет ниже. Кроме нее, можно анализировать ход выполнения субпроцесса через системную переменную модуля DOS DosError. После выполнения вызова Exec переменная DosError может содержать значения:

0 — все в порядке, нормальное выполнение;

2 — не найден файл-субпроцесс;

8 — не хватает памяти для запуска;

10 — несоответствие среды DOS;

11 — ошибка в формате команд.

- 382 -

Появление значения DosError, равного 8, говорит о том, что надо повысить значение максимального размера кучи в директиве компилятора {$М ... }.

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

16.6.1.3. Функция DosExitCode : Word. Эта функция анализирует завершение субпроцесса. В возвращаемом значении типа Word скомбинированы два значения. Старший байт содержит одно из значений, приведенных в табл. 16.8.

Таблица 16.8

Hi

Значение кода

0

Нормальное завершение и возврат управления

1

Субпроцесс был прерван нажатием Ctrl+Break (по прерыванию 23Н)

2

Субпроцесс был прерван из-за ошибки какого-либо устройства

3

Субпроцесс завершился процедурой Keep и остался резидентным

Младший байт содержит код завершения программы-субпроцесса, переданный через процедуру завершения: Halt(n) или Keep(n), где n — код окончания. Если таких команд в программе не было, то код завершения будет равен 0.

На рис. 16.17 приведен пример, объединяющий процедуры и функции организации субпроцессов.

| { $М 1512, 0, 0 ресурсы для запускающей программы }

| USES DOS, CRT;

| {Функция запускает файл ExeFile с параметрами Parameters и возвращает логическое значение True, если запуск был удачен. Коды завершения субпроцесса возвращаются в переменных ErrorLevel и ExitHiByte.}

Рис. 16.17

- 383 -

| FUNCTION Execute( ExeFile, Parameters : String;

| VAR ErrorLevel, ExitHiByte : Byte ) : Boolean;

| VAR

| Wrd : Word; { промежуточная переменная }

| BEGIN

| SwapVectors; { установка векторов DOS }

| Exec(ExeFile, Parameters); { сам запуск субпроцесса }

| SwapVectors; { возврат векторов TURBO }

| Wrd := DosExitCode; { запомним код завершения }

| ErrorLevel := Lo( Wrd ); { код выхода из процесса }

| ExitHiByte := Hi( Wrd ); { код способа выхода }

| Execute := False; { пусть сначала будет так }

| case DosError of { анализ вызова Exec }

| 0 : begin { все в порядке }

| Execute := True; { Меняем значение функции }

| Exit { и выходим из нее }

| end;

| 2 : WriteLn(#10'He найден файл ', ExeFile );

| 8 : WriteLn(#10'He хватает памяти для субпроцесса )

| else WriteLn(#10'Ошибка DOS номер ', DosError )

| end {case}

| END;

| VAR { ===== ПРИМЕР ВЫЗОВОВ ==== }

| Er, Ex : Byte;

| Ch : Char;

| BEGIN

| ClrScr; { очистка экрана }

| CheckBreak := True; '

| Repeat { вечный цикл }

| WriteLn( 'Нажмите :' );

| WriteLn{ ' ':15, '[D] - для выхода в DOS' );

| WriteLn( '':15, '[S] - для запуска субпроцесса' );

| WriteLn( '':15, '[Q] - для завершения работы' );

| repeat

| Ch := UpCase( ReadKey ) { Выборочный опрос }

| until ( Ch in [ 'D','S','Q'] ); { клавиатуры. }

| case Ch of { Действия : }

| 'D' : begin { 1.Выход в MS-DOS. }

| HighVideo;

| Write( #10'Для возврата введите EXIT...' );

| LowVideo;

| if Execute(GetEnv('COMSPEC'),' ',Er,Ex) then;

| end;

Рис. 16.17

- 384 -

| 'S' : begin { 2. Запуск файла. }

| if not Execute('outer.exe',' ', Er, Ex ) then

| Halt; { запуск неудачен }

| if Ex = 1 then { Вы нажали ^Break:}

| WriteLn(#10'Процесс прерван с консоли.' );

| end;

| 'Q' : Exit { 3. Выход из программы. }

| end; {case}

| until False { условие вечного цикла }

| END.

Рис. 16.17 (окончание)

16.6.2. Процедура Keep и резидентные программы

Процедура Кеер( ExitCode : Word ), пожалуй, наименее описанная в руководстве по Турбо Паскалю. Ее назначение — завершать выполнение программы, выдавая в DOS код, заданный параметром ExitCode и оставлять ее в памяти ПЭВМ, т.е. делать программу резидентно находящейся в памяти. Ставится эта процедура в тексте программы последней по очередности выполнения. Внешне она аналогична процедуре Halt(n), но в отличие от последней резервирует память. Программы, разрабатываемые как резидентные, должны обязательно иметь в первых строках директиву распределения памяти {$М ... } , в которой указываются необходимые для резервирования объемы памяти под стек и кучу (динамические объекты и данные).

Организация резидентных программ — дело достаточно сложное и требующее хороших системных знаний. Ведь мало оставить программу в памяти ПЭВМ — надо еще «заставить» ее реагировать на прерывания, возвращать управление и т.п. Это подразумевает наличие в тексте вставок машинных кодов и процедур с директивой interrupt, что вовсе не упрощает написание программ. Тяжело дается и отладка «резидентов» — после каждой неудачи, как правило, приходится перезапускать ПЭВМ.

Тем не менее ниже мы приводим пример резидентной программы. Она использует ряд функций модуля CRT и специальные приемы определения начала видеопамяти (см. разд. 20.1) и копирования экрана процедурой Move (рис. 16.18).

- 385 -

| { $М 1024, 0, 0} { директивы распределения памяти }

| PROGRAM HideScr;

{ Резидентная программа скрытия экрана от любопытных глаз во время отсутствия программиста. Работает во всех режимах текста и использует пароль (если задан) для возврата }

| USES CRT, DOS;

| VAR

| OldAttr : Byte; { последний цвет символов }

| WX, WY : Byte; { последнее место курсора }

| ScrAddr : Word; { сегмент начала экрана }

| Buffer : Array [1..8000] of Byte; {буфер для экрана }

| PS : String[20]; { нужна для ввода пароля }

| b : Boolean; { значение параметра BREAK }

| CONST

| Password : String[20] = ' '; { задаваемый пароль входа }

| {$F+}

| PROCEDURE MyInt05H; INTERRUPT; { процедура прерывания }

| VAR с : Char;

| BEGIN

| GetCBreak(b); { запоминание статуса BREAK }

| SetCBreak( False ); { отключение проверки ^Break }

| OldAttr := TextAttr; { запоминание последнего цвета }

| WX := WhereX; { запоминание позиции курсора }

| WY := WhereY;

| TextAttr := 7; { неяркий цвет }

| if (Mem[0:$410] and $30) = $30 { начало экрана: }

| then ScrAddr := $B000 { моно – режим }

| else ScrAddr := $B800; { цветной режим }

| Move(Mem[ScrAddr:0],buffer,8000); { экран -> в буфер }

| FillChar(Mem[ScrAddr:0], 8000, 0); { затемнение экрана }

| repeat {цикл опроса пароля }

| ClrScr; { гашение экрана }

| repeat until KeyPressed; { ждать до нажатия }

| while KeyPressed do с := ReadKey;{ сброс нажатия }

| Write( #10'Пароль возврата? ' ); { Ввод пароля, но }

| TextAttr := 0; ReadLn(PS); TextAttr := 7; { вслепую! }

| until PS=Password; { Пароль введен ? }

| Move(buffer, Mem[ScrAddr:0],8000); { буфер-> на экран }

| GotoXY( WX, WY ); { курсор на место }

| TextAttr := OldAttr; { снова старый цвет }

| SetCBreak(b); { восстановление статуса BREAK }

| END;

| {$F-}

Рис. 16.18

- 386 -

| { Запускающая часть программы }

| BEGIN

| CheckBreak := False;

| Write(#10#13'Программа закрытия экрана'#10#13

| Запуск');

| Write(#10' HIDESCR [пароль возврата]'#10#10#13);

| WriteLn( 'Для включения нажмите PrintScreen'#10#13 );

| Password := ParamStr(1); {пароль из командной строки }

| SetIntVec($00,SaveInt00); {Необходимые операции подго- }

| SetIntVec($1B,SaveInt1B); {товки резидентной работы }

| SetIntVec($05,@MyInt05H); {подстановка прерывания 05 }

| Кеер(0); { <-- То, ради чего построен пример! }

| END.

Рис. 16.18 (окончание)

- 387 -

Глава 17. Модуль Printer

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

17.1. Содержимое модуля Printer

Этот модуль содержит всего одну переменную и две строки исполняемого текста. Он устанавливает соответствие между переменной Lst и системным устройством LPT1 (первым параллельным портом). Полный текст модуля приведен на рис. 17.1.

| UNIT Printer;

| INTERFACE

| VAR

| Lst : Text;

| IMPLEMENTATION

| BEGIN

| Assign (Lsr, ‘LPT1’);

| ReWrite (Lst)

| END.

Рис. 17.1

После подключения модуля Print операторы Write(Lst,…) и WriteLn(Lst,…) будут выводить данные непосредственно на принтер.

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

Если принтер подключен через какое-нибудь другое устройство, например через второй порт LPT2 или через последовательный порт COM1, то можно создать свой собственный модуль Printer2 по аналогии с рис. 17.1, заменив LPT1 на другое имя и оттранслировав его.

17.2. Низкоуровневые средства работы с принтером

Вывод данных или специальных командных кодов на принтер через связанный с ним файл Lst или ему подобный — не единственный способ управлять печатью. Существует и другой путь посылки символа или их последовательности в принтер — через прерывание БСВВ 17H. Кроме того, используя это прерывание, можно опрашивать состояние устройства печати.

Прерывание 17H обеспечивает доступ к трем функциям обслуживания принтера:

— печати символа на принтере (функция номер 0);

— инициализации порта принтера (функция номер 1);

— чтению состояния принтера (функция номер 2).

При вызове прерывания регистр процессора AH должен содержать номер функции, а регистр DX — номер параллельного порта (0 соответствует LPT1, 1 — LPT2, 2 — LPT3). При вызове функции 0 надо дополнительно загрузить в регистр AL ASCII-код посылаемого в принтер символа. Прерывание после выполнения всегда возвращает в регистре AH байт состояния принтера. Некоторое исключение составляет функция 0. Если она закончилась неудачей, то после небольшой задержки в регистре AH вернется значение 01H.

Наиболее полезна для программ, работающих с принтерами, функция номер 2, опрашивающая байт состояния принтера. Этот байт имеет следующую структуру (рис. 17.2).

Бит 7 — принтер занят (0) или ждет символ (READY) (1)

Бит 6 — если 1, то принтер подключен

Бит 5 — если 1, то кончилась бумага (PAPER OUT)

Бит 4 — если 1, то принтер в состоянии принять сигнал

Бит 3 — если 1, то ошибка ввода-вывода

Бит 2 — не используется (зарезервирован)

Бит 1 — не используется (зарезервирован)

Бит 0 — если 1, то задержка (timeout

Рис. 17.2

- 389 -

В специальной литературе оговаривается, что результаты опроса состояния принтера через прерывание 17H могут меняться на различных ПЭВМ и с различными принтерами. Это не значит, что прерывание нельзя использовать. Практически всегда должно выполняться условие возможности получения очередного символа на бумаге. Оно заключается в том, что перед выводом символа на печать биты 4 и 7 байта состояния принтера должны содержать единицы, т.е. в регистре AH после опроса должно быть значение 10H+80H=90H. Более «тонкие» проверки следует протестировать на конкретных ПЭВМ. На рис. 17.3 приводится пример функции опроса состояния принтера и связанной с ней процедуры печати файла из программы. В большинстве случаев эти подпрограммы должны работать корректно.

| DOS, CRT, Printer;

| { Функция возвращает код состояния принтера LPT1 (PRN).

| При работе требуется подключение модуля DOS. }

| FUNCTION TestPrinter : ShortInt;

| VAR

| R : Registers; { служебная переменная }

| BEGIN

| TestPrinter := 100; { исходное значение }

| R.AH:=$02; { функция номер 2 }

| R.DX:=$00; { принтер в LPT1 }

| Intr( $17, R ); { прерывание 17H }

| if (R.AH and $10) = $00 { проверка наличия }

| then begin

| TestPrinter := -1; { принтер не подключен }

| Exit { выход из функции }

| end;

| if (R.AH and $80) = $00 { проверка готовности: }

| then TestPrinter := 0 { подключен, но OFF LINE }

| else TestPrinter := +1; { подключен, и ON LINE }

| END;

{ Процедура печатает файл FileName на принтере, подключенном к LPT1, анализируя состояние принтера. Можно прервать процедуру, нажав клавишу Esc. X и Y - координаты сообщения на экране. Для работы нужны модули Printer и CRT. }

Рис. 17.3

- 390 -

| PROCEDURE PrintFile( X, Y : Byte; FileName : String );

| LABEL

| mStop; { метка выхода no Esc }

| VAR

| f : Text; s : String; { служебные переменные }

| Т : ShortInt; { результат опроса принтера }

| BEGIN

| REPEAT { цикл опроса состояния LPT1 }

| Т := TestPrinter; { см. предыдущую страницу }

| if KeyPressed { опрос клавиш }

| then if ReadKey=#27 then

| Exit; { Esc – выход }

| GotoXY( X,Y );

| case Т of { анализ LPT1: }

| -1 : Write( ' ПРИНТЕР НЕ ПОДКЛЮЧЕН...' );

| 0 : Write( ' НАЖМИТЕ <ON LINE> !... ');

| +1 : Write( ' РЕЗУЛЬТАТЫ ВЫВОДЯТСЯ... ' );

| else Write( ' ПРОБЛЕМЫ С ПРИНТЕРОМ... ' );

| end;

| Write( ' (ОТКАЗ - Esc)' );

| UNTIL ( T=1 ); { при Т=1 уже можно печатать }

| Assign( f, FileName ); { связывание файла FileName }

| Reset( f ); { открытие его для чтения }

| while not EOF(f) do begin { печать файла по строкам }

| ReadLn( f, s ); { чтение строки }

| if KeyPressed then { опрос клавиш }

| if ReadKey=#27 then

| Goto mStop; { Esc – выход }

| WriteLn( 1st, s ) { печать строки }

| end; {while} { конец цикла печати файла }

| mStop : Close( f ) { закрытие файла FileName }

| END;

| BEGIN

| PrintFile(10,10, 'ris17-3.pas'); { печать текст-файла }

| END.

Рис.17.3 (Окончание)

17.3. Работа с двумя принтерами одновременно

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

- 391 -

портов, записанные в системных ячейках памяти $0000:$0408 (порт LРТ1, он же PRN) и $0000:$040А (порт LPT2). Резидентная версия программы перестановки адресов приведена на рис. 17.4. После нажатия клавиши PrintScreen (PrtScr) адреса меняются местами, о чем свидетельствует звуковая сигнализация. Количество сигналов соответствует номеру порта, а порядок следования — их текущему перенаправлению.

| { $M 1024,0,0, F-,R-,S-,I-,N-}

USES

| CRT, DOS;

| VAR

| LPT1, LPT2 : Word; { значения адресов }

| CONST

| OrderIsChanged : Boolean = False; { состояние обмена }

| PROCEDURE Beep; { процедура выдачи одиночного сигнала }

| BEGIN

| Sound( 200 ); Delay( 100 ); NoSound; Delay( 20 )

| END;

| {$F+} { подставляемая процедура обработки прерывания}

| PROCEDURE NewInt05; INTERRUPT;

| BEGIN

| OrderIsChanged:=not OrderIsChanged; {порядок изменяется }

| if OrderIsChanged

| then begin {обратный порядок }

| MemW[ 0:$0408 ] := LPT2; { адреса меняются }

| MemW[ 0:$040A ] := LPT1;

| Beep; Beep; Delay( 200 ); Beep {2+1 сигнала звуком }

| end

| else begin { исходный порядок }

| MemW[ 0:$0408 ] := LPT1; { адреса меняются }

| MemW[ 0:$040A ] := LPT2;

| Beep; Delay( 200 ); Beep; Beep {1+2 сигнала звуком }

| end;

| END;

| {$f-}

| BEGIN { запускающая часть примера }

| HighVideo;

| WriteLn( #10#13'LPT1 <--> LPT2'#10 );

| WriteLn('НАЖИМАЙТЕ PrintScreen',

| ' ДЛЯ ПЕРЕНАПРАВЛЕНИЯ'#10);

Рис. 17.4

- 392 -

| LowVideo;

| LPT1:=MemW[ $0000:$0408]; {исходный адрес порта 'LPT1' }

| LPT2:=MemW[$0000:$040А]; {исходный адрес порта 'LPT2' }

| SetIntVec($00, SaveInt00); {нужно для резидентности }

| SetIntVec($1B, SaveInt1B); {нужно для резидентности }

| SetIntVec($05, @NewInt05); {подстановка прерывания 05 }

| Кеер(0) {программа будет резидентной }

| END.

Рис. 17.4 (окончание)

Программу на рис. 17.4 легко переделать при необходимости в обычную нерезидентную процедуру перестановки адресов и использовать ее в других приложениях.

- 393 -

Глава 18. Модуль Overlay

После компиляции программы может случиться, что ее притязания на размер требуемой оперативной памяти ПЭВМ окажутся чрезмерными: программа получится слишком большой. В этом случае система при запуске программы выдает сообщение Not enough memory («не хватает памяти») или нечто подобное. Есть несколько выходов из этой ситуации. Один из них заключается в использовании автономного компилятора (TPC.EXE). В этом случае размер доступной программе памяти увеличится на объем, занимаемый интегрированной средой при работе (около 230 К). Если же это не помогает, то, вероятнее всего, ситуацию может спасти использование модуля Overlay и соответствующей оверлейной технологии составления программ.

18.1. Оверлейное построение программ

Модуль Overlay (далее просто оверлей) — мощное средство для разбиения программы на отдельные части. Таких частей может быть сколько угодно, а суммарный объем их может значительно превышать объем доступной в ПЭВМ памяти. Программа, организованная как оверлейная, состоит из одного файла с расширением .EXE и файла с тем же именем, но с расширением .OVR. При этом EXE-файл содержит постоянную часть программы, а OVR-файл хранит коды, которые подгружаются в память по мере необходимости. При оверлейном построении программ в памяти находятся только те из оверлейных процедур и функций, которые необходимы в данный момент и впоследствии могут быть перекрыты другими процедурами и функциями. Но дополнительных объемов памяти для этого уже не потребуется — оверлейные части программы используют одну и ту же область памяти (называемую оверлейным буфером), но по очереди. Все внутренние действия по подгрузке или выгрузке оверлеев из памяти производятся автоматически администратором оверлеев (см. разд. 18.3). программисту достаточно лишь проделать минимальные действия по объявлению оверлейных фрагментов программ и по инициализации работы их администратора.

- 394 -

18.2. Правила оформления оверлейных программ

Турбо Паскаль позволяет создавать оверлеи только на уровне модулей. Это значит, что минимальным программным блоком перекрывающихся процедур и функций, который может быть оверлейным, является модуль (UNIT). Оверлей оформляется как модуль за исключением некоторых особенностей. Поэтому, если большая программа построена на модулях, а не на подключаемых директивой компилятора {$I ИмяФайла} файлах, очень просто любой из них преобразовать в оверлей.

Оверлеи, как и обычные модули, имеют раздел объявлений (INTERFACE) и раздел реализации (IMPLEMENTATION), а также могут иметь инициализирующую часть. Однако здесь необходимо соблюдать следующие условия:

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

2. Все процедуры и функции, прямо или косвенно вызывающие оверлейные подпрограммы, должны быть откомпилированы в режиме {$F+} (модель вызова FAR).

Эти условия реализуются обычно следующим образом. В начале оверлейного модуля устанавливаются директивы {$F+,O+}, а основная программа содержит в первых строках ключ режима компиляции {$F+}.

Кроме этого, в основной программе необходимо подключить модуль Overlay и указать, какие модули из перечисленных в директиве USES будут оверлейными. На рис. 18.1 показано такое объявление оверлеев на примере программы, использующей оверлейный набор отдельно реализованных математических процедур.

| PROGRAM MultiCalc:

| {$F+ все вызовы процедур и функций имеют модель FAR }

| USES

| CRT, DOS, Overlay, MultCalc, DivCalc, AddCalc, SubCalc;

| {$O MultCalc} { модуль MultCalc - оверлей }

| {$O DivCalc} { модуль DivCalc - оверлей }

| {$O AddCalc} { модуль AddCalc - оверлей }

| {$O SubCalc} { модуль SubCalc - оверлей }

| ...

| {============ текст основной программы =============}

Рис. 18.1

- 395 -

Директива {$O ИмяМодуля} обязательна для указания оверлейных модулей. Обратите внимание на расположение этой директивы в тексте программы. Добавим также, что в списке директивы USES модуль Overlay должен стоять до первого модуля, который будет оверлейным. В остальном текст оверлейной программы практически не отличается от обычной (не считая операторов управления администратором оверлеев).

Программы с оверлеями уже не могут компилироваться в память и всегда должны создаваться на диске. В результате компиляции программы (пусть она имеет имя MULTICAL.PAS) будет получен выполнимый файл MULTICAL.EXE и сопутствующий ему файл MULTICAL.OVR, хранящий коды процедур из всех модулей, объявленных оверлейными.

Определенные ограничения накладываются на раздел инициализации оверлейного модуля (если, конечно, таковой имеется) . В нем запрещено включать администратор оверлеев. Кроме того, в разделе инициализации нельзя производить какие-либо действия до включения администратора. Может показаться, что возникает замкнутый круг: раздел инициализации выполняется перед действиями основной программы, но после включения администратора, а последний можно включить лишь в основной программе! Решение просто. Надо ввести в построение программы дополнительный неоверлейный модуль, в разделе инициализации которого и будет включаться администратор оверлеев, и подключить его в директиве USES перед оверлейными модулями.

Все системные библиотечные модули являются неоверлейными. Также не могут быть оверлейными модули, которые содержат обработку прерываний. Таким модулем, например, является CRT, так как он содержит обработку прерываний по нажатию клавиш Ctrl+Break.

18.3 Инициализация работы оверлеев

18.3.1 Включение администратора оверлеев

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

OvrInit(OvrFileName : String)

- 396 -

объявленной в модуле Overlay. Эта процедура проводит инициализацию и открывает оверлейный OVR-файл. Через параметр OvrFileName должно быть передано имя оверлейной части программы ( оно такое же, как и у основной части, но с расширением .OVR вместо .EXE). Если не производить действий по оптимизации работы администратора и не обрабатывать его возможные ошибки, то однократного вызова OvrInit достаточно для дальнейшей работы с оверлеями. Однако инициализация может закончиться ошибкой, и для ее анализа можно использовать специальную переменную модуля Overlay.

18.3.2. Анализ результата инициализации

Предопределенная в модуле Overlay переменная OvrResult типа Integer сохраняет код завершения процедур и функций модуля Overlay, в том числе и OvrInit. Определено семь возможных значений, которые может принимать OvrResult. Для каждого из них предопределена константа (табл. 18.1).

Таблица 18.1

Константа

Ее смысл

OvrOk = 0

Нормальное завершение

OvrError = -1

Ошибка управления Overlay

OvrNotFound = -2

Файл .OVR не найден

OvrNoMemory = -3

Не хватает памяти для буфера

OvrIOError = -4

Сбой при чтении оверлейного файла

OvrNoEMSDriver = -5

Драйвер EMS не установлен

OvrNoEMSMemory = -6

Емкости EMS-памяти не достаточно

Ошибка OvrError обычно возникает при попытке инициализации неоверлейного файла. Другая ошибка, OvrNotFound, может возникнуть при неправильном размещении оверлейного файла на диске. Если в имени файла OvrFileName при инициализации не указан полный путь, то файл ищется сначала в текущем каталоге, затем в том же каталоге, где находится ЕХЕ-файл и во всех каталогах, которые указаны в системной переменной MS-DOS PATH. Если ни в одном из них файл не найден, то генерируется ошибка. Сама программа при этом продолжит свою работу до первой попытки вызвать процедуру или функцию, находящуюся в оверлейном файле, после чего остановится с выдачей кода фатальной ошибки выполнения 208 Overlay manager not installed («администратор оверлеев не установлен»). Чтобы избежать подобных неприятностей,

- 397 -

рекомендуем файлы .ЕХЕ и .OVR хранить в одном каталоге (что, собственно, и делает компилятор).

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

Ошибка OvrIOError свидетельствует о возникшем сбое при чтении оверлейного кода из файла. Как правило, к ее появлению приводят внешние причины (повреждение файла, сбой внутри MS-DOS и т.п.).

Два последних кода ошибки (OvrNoEMSDriver и OvrNoEMSMemory) не могут быть выданы процедурой OvrInit. Они могут появиться при работе добавочной процедуры инициализации OvrInitEMS.

18.3.3. Размещение оверлейного файла в EMS-памяти

Процедура OvrInitEMS не имеет параметров. Она просто определяет, есть ли в ПЭВМ расширяемая память (EMS-память). Если есть, то далее процедура проверяет, установлена ли программа-драйвер этой памяти, работающая по стандарту LIM (EMS 4.0 и выше). Если и это условие выполняется, то оверлейный файл целиком загрузится в EMS и все операции по работе с оверлейными процедурами и функциями будут происходить в памяти. При этом программа начинает работать более быстро, так как операции чтения из памяти в память производятся гораздо быстрее, чем с диска в память (особенно при работе с дискетами). Вызов OvrInitEMS не является обязательным, и ни в коей мере не отменяет необходимости обычной предварительной инициализации администратора оверлеев. Неудача при попытке разместить OVR-файл в EMS-памяти не будет иметь никаких фатальных последствий, и программа будет работать так, как будто вызова OvrInitEMS не было. Переменная OvrResult при этом получит значения OvrNoEMSDriver или OvrNoEMSMemory. Последняя может возникнуть из-за того, что в EMS-памяти уже размещены кэш (cache) жесткого диска, виртуальный диск или что-нибудь иное.

При запуске процедуры OvrInitEMS в переменную OvrResult могут передаваться и другие ошибки: OvrError — если не было предварительного вызова OvrInit, и OvrIOError — если произошел сбой при переносе оверлейного файла с диска в EMS-память.

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

- 398 -

| VAR

| ovr_name : PathStr; { полное имя оверлея на диске }

| d : DirStr; { Типы объявлены в модуле DOS.}

| n : NameStr;

| е : ExtStr;

| BEGIN

| FSplit(ParamStr(0), d, n, e); { анализ имени ЕХЕ-файла }

| ovr_name := d + n + '.OVR'; { построение имени .OVR }

REPEAT

| OvrInit( ovr_name ); { запуск администратора }

| if OvrResult = OvrNotFound { OVR-файл не найден }

| then begin

| WriteLn('Оверлейный файл не найден:',ovr_name);

| Write ('Введите правильное имя файла: ');

| ReadLn ( ovr_name )

| end; {if}

| UNTIL OvrResult <> OvrNotFound;

| if OvrResult <> OvrOk { анализ прочих ошибок }

| then begin

| WriteLn('Ошибка администратора оверлеев ',

| OvrResult);

| RunError { останов программы }

| end; {if}

| OvrInitEMS; { попытка загрузки в EMS }

| if OvrResult <> OvrOk then { анализ этой попытки }

| then begin

| case OvrResult of

| OvrNoEMSDriver:Write('Драйвер EMS не установлен');

| OvrNoEMSMemory:Write('Мало свободной EMS-памяти');

| OvrIOError :Write('Ошибка чтения файла' );

| end; {case}

| Write( ' - EMS память не используется.' ) { итог }

| end; {if}

| { Администратор инициализирован. Можно работать дальше }

| ...

| END.

Рис. 18.2

18.4. Управление оверлейным буфером

Для «ручного» управления размерами оверлейного буфера, который обычно назначается автоматически, и его очистки в модуле Overlay введены специальная функция

OvrGetBuf : LongInt

- 399 -

и процедуры

OvrSetBuf(Size : LongInt)

и

OvrClearBuf.

18.4.1. Опрос размера буфера

Функция OvrGetBuf возвращает размер текущего буфера в байтах. Ее значения в некоторых случаях могут превышать 64К, поэтому она описана как LongInt. В специальных случаях можно пользоваться предопределенной переменной модуля System OvrHeapSize типа Word, хранящей начальное значение оверлейного буфера.

18.4.2. Установка размера буфера

Процедура OvrSetBuf (Size : LongInt) регулирует размер буфера. Она должна вызываться после инициализации администратора оверлеев процедурами OvrInit и OvrInitEMS. В параметре Size задается требуемая величина буфера в байтах. Она должна быть больше или равна начальному размеру буфера и не превышать размер всей доступной памяти, который можно вычислить как (MaxAvail + стартовое значение OvrGetBuf).

Вообще говоря, при инициализации администратора оверлеев под оверлеи автоматически выделяется ровно столько памяти, сколько необходимо для загрузки наибольшего оверлейного модуля. Если значение Size больше текущего размера буфера, то дополнительный объем выделяется из кучи. Если же меньше, то ненужная часть буфера присоединяется к куче. У процедуры OvrSetBuf есть одна особенность: она проверяет состояние области кучи. Если она пуста, то процедура работает без ошибок. Если же в этой области уже были размещены динамические переменные (процедурами New или GetMem), то в OvrResult будет возвращена ошибка OvrError. Эта же ошибка будет возвращена, если значение Size слишком мало или если не была проведена инициализации администратора оверлеев.

Возможная ошибка, OvrNoMemory, говорит о том, что не хватает памяти для увеличения размера буфера. Это может быть из-за наличия в программе директивы распределения памяти типа {$М 16384, 0, 655360}. В этом случае необходимо указать минимальный размер кучи, не меньший чем максимальное приращение к оверлейному буферу, например {$М 16384, 65536, 655360}.

- 400 -

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

OvrSetBuf( OvrGetBuf + 2048 ).

Особо следует остановиться на совместной работе модулей Graph и Overlay. При включении графических режимов в области кучи отводится место под графический драйвер и шрифты. Этим блокируется возможность изменения оверлейного буфера. Поэтому будет безопаснее инициализировать и регистрировать графические драйверы и шрифты только после запуска администратора оверлеев и назначения размера буфера.

18.4.3. Принудительная очистка буфера

Процедура OvrClearBuf служит для принудительной очистки оверлейного буфера. Ее действие эквивалентно выгрузке всех находящихся в текущий момент в буфере оверлейных подпрограмм. Сам администратор оверлеев эту процедуру никогда не вызывает. Но иногда ее вызов имеет смысл. Например, если отрабатывается фрагмент программы, не использующий оверлейных подпрограмм, можно освободить вызовом OvrClearBuf буфер и использовать его для хранения динамических данных (назначая им адреса «вручную», без вызовов GetMem или New). Адрес начала области буфера определяется как Ptr(OvrHeapOrg, 0), ее конец как Ptr(OvrHeapEnd, 0), где  OvrHeapOrg и OvrHeapEnd — предопределенные переменные модуля System, объявленные типам Word.

18.5. Оптимизация работы оверлеев

В Турбо Паскале версии 5.5 реализован специальный алгоритм оптимизации подгрузки наиболее часто используемых оверлейных процедур и функций. В оверлейном буфере в общем случае может разместиться несколько не самых крупных оверлейных модулей. Если их объявлено несколько, то, как правило, так и происходит. Администратор следит за заполнением буфера, передвигая в нем при необходимости подгрузки нового модуля уже загруженные модули. Передвижение происходит от начала к концу буфера. Если же таким способом места в начале буфера не освободить, то наиболее «долго» сидящий в буфере (он же ближний к концу буфера) оверлей выгружается (если он, конечно, не активен в данный момент), высвобождая часть буфера. Можно активизировать механизм оптимизации, нахо-

- 401 -

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

18.5.1. Установка размера области испытаний

Функция OvrGetRetry : LongInt возвращает текущий размер области испытаний. До вызова процедуры  OvrGetRetry будет всегда возвращать нуль.

Процедура  OvrSetRetry(Size : LongInt) устанавливает размер области испытаний в оверлейном буфере. Теперь при попадании оверлея в последние Size байт буфера он автоматически ставится на «испытание» стартовый размер области испытаний равен нулю, что, по сути, блокирует работу механизма испытаний. Определить размер области испытаний можно только методом проб и ошибок. В техническом описании Турбо Паскаля рекомендуется отводить под эту область немногим более трети буфера. Включение механизма оптимизации ускоряет работу администратора оверлеев, но немного замедляет обращения к хранящимся в оверлеях подпрограммам. Вызов процедуры  OvrSetRetry должен стоять после вызовов OvrInit и OvrInitEMS:

OvrInit(ovr_name); {инициализация администратора}

OvrInitEMS;  {попытка использовать EMS}

{Назначение области испытаний (и включение оптимизации):}

OvrSetRetry(OvrGetBuf div 3);

18.5.2. Подсчет вызовов оверлеев

Предопределенные переменные OvrTrapCount и OvrLoadCount типа Word, привносимые модулем Overlay, хранят статистику обращений к OVR-файлу. Их стартовые значения — нули. Переменная  OvrTrapCount хранит количество обращений к файлу в том случае, если нужный оверлейный модуль находится на диске или в буфере на «испытании».  Другая переменная, OvrLoadCount ведет подсчет количества загрузок оверлея. Сопоставление этих двух значений может помочь выбрать оптимальный размер «области испытаний» (отношение OvrLoadCount к  OvrTrapCount должно быть минимальным).

18.6. Предопределенные переменные для работы с оверлеями

Мы рассматривали переменную модуля Overlay OvrResult с набором констант-значений (см. разд. 18.3.2) и переменные OvrTrapCount и OvrLoadCount (разд. 18.5.2). Кроме них, определены еще тип и две переменные:

TYPE

OvrReadFunc = Function( OvrSeg : Word ) : Integer;

VAR

OvrReadBuf : OvrReadFunc;

OvrFileMode : Byte;

Переменная OvrReadBuf предназначена для перехвата операции загрузки оверлея и позволяет устанавливать собственную функцию чтения и проверки оверлейных файлов. Это может понадобиться, например, в случае необходимости проверки наличия сменного диска. Когда администратору оверлеев нужно прочитать очередной сегмент, он вызывает функцию, адрес которой хранится в переменной OvrReadFunc. Если эта функция возвращает нуль, то считается, что операция чтения прошла успешно. Если не нуль,то системой генерируется код фатальной ошибки номер 209 Overlay file read error («Ошибка чтения файла оверлея»). Параметр OvrSeg указывает, какой сегмент должен быть загружен. Однако, в силу того что имя сегмента неявно передается в эту функцию процедурой OvrInit, его можно считать предопределенным.

Для установки собственной процедуры проверки загрузки оверлея необходимо проделать следующее:

1) описать в основной программе собственную функцию обработки чтения оверлея из OVR-файла с заголовком, соответствующим типу OvrReadFunc, и убедиться, что она будет компилироваться в режиме {$F+}. Внутри этой функции после всех предварительных проверок должен стоять вызов основной (сохраненной) функции чтения оверлея. После этого можно производить обработку ошибок;

2) запомнить (сохранить) в программе стартовое значение переменной OvrReadBuf;

3) присвоить переменной OvrReadBuf адрес собственной функции обработки чтения файла.

- 403 -

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

Сама подстановка функции чтения оверлея должна находиться сразу за вызовом процедуры OvrInit.

Переменная OvrFileMode определяет код доступа при открытии оверлейного файла. По умолчанию код доступа соответствует режиму «только чтение». Для того чтобы изменить код доступа, необходимо перед инициализацией оверлеев присвоить новое значение этой переменной, о котором можно справиться в технических руководствах по MS-DOS. Реальная необходимость в этом может возникнуть, пожалуй, только при работе в локальных сетях ПЭВМ.

Для работы с оверлеями предназначены и некоторые специальные переменные модуля System, объявленные как переменные со стартовым значением:

CONST

OvrCodeList : Word =0; { список сегментов кодов }

OvrHeapSize : Word =0; { стартовый размер буфера }

OvrDebugPtr : Pointer=nil; { зарезервировано для отладчика }

OvrHeapOrg : Word =0; { сегмент начала буфера }

OvrHeapPtr : Word =0; { указатель заполнения буфера }

OvrHeapEnd : Word =0; { сегмент конца буфера }

OvrLoadList : Word =0; { используется администратором }

OvrDosHandle : Word =0; { используется администратором }

OvrEMSHandle : Word =0; { используется администратором }

Они предназначены в основном для обслуживания системных запросов администратора оверлеев, и не стоит экспериментировать с их значениями. Реально можно использовать лишь переменные, описывающие буфер (см. разд. 18.4.3).

18.7. Включение оверлеев в EXE-файлы

Версия 5.5 Турбо Паскаля позволяет хранить оверлейную часть в одном файле с исполняемым кодом, а не в отдельном OVR-файле. Для этого следует дописать оверлеи в конец EXE-файла командо MS-DOS COPY с ключом /B:

COPY/B TEST.EXE+TEST.OVR

- 404 -

При этом надо быть уверенным, что EXE-файл откомпилирован без отладочной информации (в интегрированной среде в меню Debug/Standalone debugging стоит off). Чтобы инициализировать оверлей, достаточно в процедуре OvrInit указать имя основного EXE-файла. Обычно это делают через функцию ParamStr:

OvrInit(ParamStr(0))

Глава 19. Модуль Graph

Модуль Graph представляет собой библиотеку подпрограмм, обеспечивающую полное управление графическими режимами различных адаптеров дисплеев: CGA, EGA, VGA, MCGA, Hercules, PC3270, AT&T6300 и IBM8514. Библиотека содержит более пятидесяти графических процедур и функций, как базовых (рисование точек, линий, окружностей и т.п.), так и расширяющих возможности базовых (многоугольники, заполнение фигур, вывод текста и др.).

Чтобы запустить программу, использующую процедуры модуля Graph, необходимо, чтобы в рабочем каталоге находились соответствующие графические драйверы (файлы с расширением .BGI), а если программа использует еще и штриховые шрифты, то необходимо, чтобы там же находились файлы шрифтов (с расширением .CHR). Кроме того, системе программирования (компилятору) должен быть доступен модуль GRAPH.TPU (он входит в состав файла TURBO.TPL, а изначально находится в архиве BGI.ARC).

19.1. Файлы BGI и содержимое модуля Graph

Файл BGI — это графический интерфейс (Borland Graphic Interface) фирмы Borland. Он обеспечивает взаимодействие программ с графическими устройствами. Перед работой программы в графических режимах дисплея процедура InitGraph определяет тип адаптера, представленнгого в ПЭВМ, и загружает в память соответствующий BGI-драйвер, в котором определены возможные режимы работы.

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

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

Итак, в рабочем каталоге могут находиться следующие файлы:

CGA.BGI — драйвер для IBM CGA, MCGA;

EGAVGA.BGI — драйвер для IBM EGA, VGA;

- 406 -

HERC.BGI — драйвер для Hercules;

ATT.BGI — драйвер для АТ&Т6300 (400 строк);

PC3270.BGI — драйвер для IBM 3270PC;

IBM8514.BGI — драйвер для IBM 8514.

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

Необходимо особо сказать об адаптере и драйвере IBM8514. Это адаптер высокого разрешения, позволяющий обрабатывать изображение размером 1024x768 точек и с палитрой в 256 цветов. Этот адаптер автоматически не определяется (точнее, он определяется, как адаптер VGA), поэтому при вызове процедуры инициализации он должен задаваться явно.

Все процедуры и функции модуля Graph можно разбить на функциональные группы:

1. Управление графическими режимами и их анализ (DetectGraph, InitGraph, CloseGraph, GraphDefaults, ClearDevice, InstallUserDriver, RegisterBGIDriver, RestoreCRTMode, SetGraphMode, SetWriteMode, GetGraphMode, GetModeRange, GetMaxMode, GetModeName, GelDriverName, GraphResult, GraphErrorMsg).

2. Рисование графических примитивов и фигур:

а) управление «текущим указателем» (MoveTo, MoveRel, GetMaxX, GetMaxY, GetX, GetY);

б) собственно рисование (Line, LineTo, LineRel, Arc, GetArcCoords, Circle, Sector, Ellipse, Rectangle, DrawPoly);

в) стиль линий и коэффициент сжатия изображении (SetLineStyle, GetLineSettings, SetAspectRatio, GetAspectRatio).

3. Управление цветами и шаблонами заполнения (SetColor, GetColor, SetBkColor, GetBkColor, GetMaxColor, GetPalette, GetPaletteSize, GetDefaultPalette, SetPalette, SetAllPalette, SetRGBPaletle, SetFillStyle, SetFillPattern, GetFillPattern, GetFillSettings, SetGraphBufSize, FillPoly, FillEllipse, FloodFill, PicSlice, Bar, Bar3D).

4. Битовые операции (PutPixel, GetPixel, ImageSize, GetImage, PutImage).

5. Управление страницами (SetActivePage, SetVisualPage).

6. Графические окна ( вьюпорты ) (SetViewPort, GetViewSettings, ClearViewPort).

- 407 -

7. Управление выводом текста (RegisterBGIFont, InstallUserFont, OutText, OutTextXY, SetTextStyle, SetTextJustify, SetUserCharSize, GetTextSettings, TextHeight, TextWidth).

19.2. Управление графическми режимами

19.2.1. Инициализация и закрытие графического режима

19.2.1.1. Процедура инициализации InitGraph. Простейшая программа, использующая графику, обязательно должна содержать блок вызовов процедур инициализации графического режима и обращение к процедуре его закрытия. Такой блок инициализирует графический режим, проверяет правильность переключения и, если все операции прошли успешно, допускает дальнейшую работу программы. Процедура инициализации объявлена следующим образом:

InitGraph( VAR GraphDriver : Integer; { тип адаптера }

| VAR GraphMode : Integer; { режим графики }

DriverPath : String ); { путь к драйверу }

В модуле Graph определены константы для задания вида графического адаптера параметром GraphDriver перед вызовом InitGraph (последняя константа введена для вызова процедуры GetModeRange уже после инициализации):

CONST

Detect =0; { автоопределение }

CGA =1; { адаптер CGA }

MCGA =2; { адаптер MCGA }

EGA =3; { адаптер EGA 256K }

EGA64 =4; { адаптер EGA 64K }

EGAMono =5; { EGA с моно-дисплеем }

IBM8514 = 6; { адаптер 8514 }

HercMono = 7; { адаптер Hercules }

ATT400 =8; {для ПЭВМ AT&T }

VGA = 9; { адаптер VGA }

PC3270 =10; { адаптер 3270 }

CurrentDriver =-128; { для GetModeRange }

Если параметру GraphDriver присвоить значение константы Detect, то система включится в режим автоопределения. Если возможно переключение системы в графический режим, то инициализируется соответствующий BGI-драйвер и включается режим с максимальным разрешением. В параметрах GraphDriver и

- 408 -

GraphMode при этом будут возвращены автоматически выбранные значения или код ошибки.

Такая установка параметров процедуры рекомендуется в тех случаях, когда программа должна работать на разных ПЭВМ с различными видеоадаптерами. Однако этот метод предполагает наличие в памяти ПЭВМ или на диске одновременно всех драйверов. Если программа большая, то наличие всех драйверов в памяти может вызвать затруднения.

Если же параметр GraphDriver содержит номер конкретного адаптера, то и второй параметр, GraphMode, должен иметь значение (номер) режима, допустимого при этом адаптере.

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

Параметр DriverPath указывает путь в каталог, содержащий файлы с необходимыми драйверами. Если в него передается значение '' (пустая строка), то драйверы должны находиться в текущем каталоге. Это же значение должно передаваться DriverPath, если необходимые BGI-файлы преобразованы при помощи утилиты BINOBJ в файлы типа .OBJ, а затем скомпанованы с программой в EXE-файл.

Пример инициализации графического режима приведен на рис. 19.1 (в разд. 19.2.2).

19.2.1.2. Процедура CloseGraph. Для окончательного завершения работы в графическом режиме необходимо всегда производить вызов процедуры CloseGraph. Эта процедура не имеет параметров. Она очищает экран, переводит адаптер в текстовый режим и, если возможно, выгружает из памяти все BGI-драйверы и штриховые шрифты. Последующий возврат в графические режимы возможен только через повторную инициализацию

19.2.2. Обработка ошибок инициализации

Процедура InitGraph возвращает также и результат своей работы в параметре GraphDriver. В случае ошибки он может принимать значения, приведенные в табл. 19.1.

таблица 19.1.

Значение

Объяснение

-2

Нет графического адаптера

-3

Не найден файл драйвера

-4

Ошибка в драйвере (в его коде)

- 409 -

-5

Не хватает памяти для загрузки драйвера

-10

Невозможный режим для выбранного драйвера.

-15

Нет такого драйвера

Если же ошибок при инициализации не обнаружено, то в параметре GraphDriver возвращается номер адаптера из приведенного в разд. 19.2.1.1 списка констант.

В модуле Graph реализован еще один способ проверки результата проведения графической операции. Он осуществляется с помощью функции

GraphResult : Integer

которая возвращает код результата последнего вызова одной из процедур или функций, указанных в табл. 19.2.

Таблица 19.2

Bar

Bar3D

ClearViewPort

CloseGraph

DetectGraph

DrawPoly

FillPoly

FloodFill

GetGraphMode

ImageSize

InitGraph

InstallUserDriver

InstallUserFont

PieSlice

RegisterBGIdriver

RegisterBGIfont

SetAllPalette

SetFillPattern

SetFillStyle

SetGraphBufSize

SetGraphMode

SetLineStyle

SetPalette

SetTextJustify

SetTextStyle

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

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

- 410 -

GraphErrorMsg(ErrorCode : Integer) : String;

Константы кодов ошибок, определенные в модуле Graph, и соответствующие им сообщения приведены в табл.19.3.

Таблица 19.3

Константа

Код

Сообщение об ошибке

Перевод и пояснения

grOk

No error

Ошибки нет

grNoInitGraph

-1

(BGI) Graphics not installed (use InitGraph)

Графика не инициализирована

grNotDetected

-2

Graphics hardware not detected

Графический адаптер не найден

grFileNotFound

-3

Device driver file not detected

BGI-файла нет в указанном каталоге

grInvalidDriver

-4

Invalid device driver file

BGI-файл содержит ошибочный код

grNoLoadMem

-5

Not enough memory to load driver

Нет места в ОЗУ для загрузки драйвера

grNoScanMem

-6

Out of memory in scan fill

При работе процедуры FillPoly не хватает рабочей памяти

grNoFloodMem

-7

Out of memory in flood fill

При работе процедуры FloodFill не хватает рабочей памяти

grFontNotFound

-8

Font file not found

CHR-файла нет в указанном каталоге

grNoFontMem

-9

Not enough memory to load font

Нет места в ОЗУ для загрузки шрифта

grInvalidMode

-10

Invalid Graphics mode for selected driver

Невозможный режим для выбранного драйвера

- 411 -

grError

-11

Graphics error

Ошибка графики

grIOError

-12

Graphics I/O error

Ошибка ввода-вывода графики

grInvalidFont

-13

Invalid font file

В файле шрифта неправильный код

grInvalidFontNum

-14

Invalid font number

Несуществующий номер шрифта

grInvalidDeviceNum

-15

Invalid device number

Несуществующий номер адаптера

Простейший блок инициализации графического режима в программе может выглядеть, как показано на рис. 19.1.

| USES Graph; {подключен модуль Graph}

| PROCEDURE GrInit; {инициализация режима графики}

| VAR

| GraphDriver : Integer; {для графического адаптера}

| GraphMode : Integer; {для графического режима}

| ErrorCode : Integer; {для кода ошибки}

| BEGIN

| GraphDriver := Detect; {режим автоопределения}

| InitGraph(GraphDriver, GraphMode, ' '); {инициализация}

| ErrorCode := GraphResult, {результат инициализации}

| if ErrorCode <> grOk then {если неуспешно, то…}

| begin

| WriteLn('Ошибка графики:)', GraphErrorMsg(ErrorCode));

| WriteLn('Программа остановлена');

| Halt(1)

| end {if}

| END;

| {{==ПРИМЕР ИНИЦИАЛИЗАЦИИ}==}

| BEGIN

| GrInit; {вызов инициализации}

| Line(0, 0, GetMaxX,GetMaxY); {работа с графикой….}

| Readln; {пауза до нажатия ввода}

| CloseGraph {закрытие режима графики}

| END.

Рис. 19.1

- 412 -

В дальнейшем процедуру GrInit лучше записать в отдельный файл (например, INITGRAF.PAS) и использовать директиву включения этого файла при компиляции (что и сделано во всех остальных примерах). Такой блок всегда включает стандартный графический режим максимального разрешения. Однако это не всегда необходимо. На адаптере CGA, например, уменьшение разрешения дает возможность использовать большее количество цветов, а на адаптерах EGA и VGA увеличивает количество видеостраниц. Ниже мы рассмотрим процедуры, позволяющие определять тип установленного графического адаптера и режимы, которые могут быть установлены для него.

19.2.3. Классификация и анализ графических режимов

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

Таблица 19.4

Драйвер

Имя константы режима и ее значение

Разрешение экрана (в точках)

Палитра

Число видеостраниц

CGA

CGAC0 = 0 CGAC1 = 1 CGAC2 = 2 CGAC3 = 3 CGAHi = 4

320x200 320x200 320x200 320x200 640x200

4 цвета 4 цвета 4 цвета 4 цвета 2 цвета

MCGA

MCGAC0 = 0 MCGAC1 = 1 MCGAC2 = 2 MCGAC3 = 3 MCGAMed=4 MCGAHi = 5

320x200 320x200 320x200 320x200 640x200 640x480

4 цвета 4 цвета 4 цвета 4 цвета 2 цвета 2 цвета

EGA

EGALo = 0 EGAHi = 1

640x200 640x350

16 цветов 16 цветов

2

- 413 -

EGA64

EGA64Lo = 0 EGA64Hi = 1

640x200 640x350

16 цветов 4 цвета

EGAMono

EGAMonoHi = 3

640x350

2 цвета

1 (2)

Herc

HercMonoHi = 0

720x348

2 цвета

ATT400

ATT400C0 = 0 ATT400C1 = 1 ATT400C2 = 2 ATT400C3 = 3 ATT400C4 = 4 ATT400Hi = 5

320x200 320x200 320x200 320x200 640x200 640x200

4 цвета 4 цвета 4 цвета 4 цвета 2 цвета 2 цвета

VGA

VGALo = 0 VGAMed = 1 VGAHi = 2

640x200 640x350 640x480

16 цветов 16 цветов 16 цветов

PC3270

PC3270Hi = 0

720x350

2 цвета

IBM8514

IBM8514Lo = 1 IBM8514 = 1

640x480 1024x768

256 цветов 256 цветов

Как видно из таблицы, наиболее качественная «картинка» получается при использовании адаптера IBM8514. Однако он редко встречается у нас в стране, и поэтому в дальнейшем мы не будем о нем упоминать.

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

19.2.3.1. Процедура DetectGraph. Для тестирования графического адаптера в модуле Graph объявлена процедура:

DetectGraph( VAR GraphDriver, GraphMode : Integer )

- 414 -

Эта процедура может быть вызвана до инициализации графики. Через формальный параметр GraphDriver возвращается значение из первого столбца таблицы 19.4, а через параметр GraphMode — обычно последнее значение из соответствующего раздела второго столбца. Эти значения и рекомендуется подставлять в качестве фактических параметров в процедуру InitGraph. Если на ПЭВМ не установлена графическая плата, то функция GraphResult будет возвращать значение grNotDetected. После определения GraphDriver автоматически становится доступным диапазон графических режимов, реализуемых адаптером ПЭВМ. Дело в том, что по мере развития индустрии ПЭВМ возникали новые уровни возможностей графики (рис. 19.2).

Рис. 19.2

Адаптер Hercules несколько отличается от остальных, но тем не менее «перекрывается» старшим уровнем — адаптером VGA. Таким образом, имея адаптер VGA, можно имитировать практически все режимы, возможные на платах EGA, CCA, Hercules и т.д., имея плату

- 415 -

EGA, можно то же, кроме режимов VGA. В результате получается так называемая совместимость «снизу вверх». Поясним это на примере (рис. 19.3).

| USES Graph; { используется Graph }

| VAR

| gDriver : Integer; { для графического адаптера }

| gMode : Integer; { для графического режима }

| ErrorCode : Integer; { для кода ошибки }

| BEGIN

| DetectGraph(gDriver, gMode); { Опрос наличия и }

| ErrorCode := GraphResult; { типа адаптера. }

| if ErrorCode <> grOk then

| begin { если ошибка, то... }

| WriteLn(GraphErrorMsg( ErrorCode ));

| Halt( 1 )

| end; {if}

| if gDriver in [EGA, EGA64, VGA] { Если адаптер }

| then begin { старше CGA, то }

| gDriver := CGA; { возможен режим }

| gMode := CGACO { работы CGA. }

| end; {if}

| InitGraph(gDriver,gMode, ); { режим CGA }

| Line( 0, 0, 319, 199 ); { работа как на CGA }

| CloseGraph { закрытие графики } END.

Рис. 19.3

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

19.2.3.2. Диапазоны графических режимов. Номер текущего графического режима для установленного драйвера определяется функцией

GetGraphMode : Integer,

а функция

GetMaxMode : Word

возвращает номер максимального режима для графического адаптера; таким образом, каждый драйвер поддерживает диапазон режимов 0..GetMaxMode. Обычно этот же результат можно получить из процедуры

- 416 -

GetModeRange( GraphDriver : Integer;

VAR LoMode, HiMode : Integer ),

через параметры LoMode и HiMode возвращающей соответственно нижнюю и верхнюю границу режимов для драйвера GraphDriver. Но по ряду технических соображений предпочтительнее пользоваться функцией GetMaxMode, полагая минимальный номер режима равным нулю.

19.2.3.3. Функции GetModeName и GetDriverName. Есть еще одна функция, которая может быть полезна для организации диалогового управления графическими режимами:

GetModeName( GraphMode : Word ) : String

Она возвращает строку, в которой содержится последовательно через пробелы разрешение, имя константы и иногда название палитры из табл. 19.4, например, '640x200 CGA'. Представленный пример (рис. 19.4) поможет определить, в каких графических режимах может работать используемая ПЭВМ.

| USES Graph; { подключен модуль Graph }

| {$I initgraf.pas} { процедура инициализации }

| VAR

| mode : Integer;

| BEGIN

| GrInit; { инициализация }

| for mode := 0 to GetMaxMode do

| { показ всех режимов }

| OutTextXY( 10, 10+mode*10, GetModeName( mode ) );

| ReadLn; { пауза до нажатия... }

| CloseGraph { закрытие графики }

| END.

Рис. 19.4

Функция

GetDriverName : String

позволяет получить имя используемого драйвера. Ее применение обосновано только в том случае, если в процедуре InitGraph переменная GraphDriver определена, как Detect (рис. 19.5).

19.2.4. Очистка экрана и переключение режимов

19.2.4.1. Очистка графического экрана. Две следующие процедуры выполняют почти одинаковые действия, только первая из них

- 417 -

| USES Graph; { подключен модуль Graph }

| {$I initgraf.pas} { процедура инициализации }

| BEGIN

| GrInit; { инициализация графики }

| OutTextXY( 40, 40, { выводится имя драйвера: }

| 'У меня используется драйвер типа ' + GetDriverName );

| ReadLn; { пауза до нажатия ввода }

| CloseGraph { закрытие режима графики }

| END.

Рис. 19.5

является как бы подмножеством второй:

ClearDevice

очищает графический экран и устанавливает указатель позиции в положение (0, 0), а процедура

GraphDefaults

кроме очистки экрана, устанавливает ряд параметров графической системы:

1) графическое окно становится равным размеру экрана;

2) восстанавливается системная цветовая палитра;

3) переназначаются цвета основных линий и фона экрана;

4) толщина и стиль линий принимаются как по умолчанию;

5) цвет и шаблон заливки геометрических фигур и замкнутых ломаных принимается как по умолчанию;

6) переустанавливается активный шрифт и его стиль. Процедура GraphDefaults неявно вызывается при инициализации графики и выполняет, no-сути, все стартовые установки графических параметров.

19.2.4.2. Переключение режимов. Оно осуществляется процедурой

SetGraphMode(GraphMode : Integer),

которая переключает систему в указанный параметром GraphMode графический режим и очищает экран монитора. При этом все дополнительные характеристики устанавливаются по умолчанию. Чтобы предостеречь от ошибок, вызванных кажущейся простотой переключения, укажем, что такие переключения возможны только в рамках текущего драйвера — иначе необходимо реинициализировать систему (рис. 19.6).

- 418 -

| USES Graph; { подключен модуль Graph }

| {$I initgraf.pas} { процедура инициализации }

| VAR

| mode, modeLo, modeHi : Integer; { номера режимов }

| BEGIN

| GrInit; { инициализация }

| GetModeRange(CurrentDriver,modeLo,modeHi); { диапазон }

| for mode:=modeLo to modeHi do begin { цикл по режимам }

| SetGraphMode( mode ); { включение режима }

| Line( 0, 0, 639, 479); { рисование линии }

| ReadLn { ожидание ввода }

| end; {for}

| CloseGraph { закрытие графики }

| END.

Рис. 19.6

19.2.4.3. Процедура RestoreCRTMode. При написании некоторых пакетов, использующих и графические, и текстовые режимы работы ПЭВМ, может оказаться полезной процедура RestoreCRTMode, которая возвращает систему в текстовый режим, работавший до инициализации графики. Казалось бы, уже есть процедура с подобным действием — CloseGraph. Однако после нее возврат в графический режим должен проводиться через процедуру InitGraph, что довольно сложно (см. рис. 19.1). Если же воспользоваться процедурой RestoreCRTMode, то возвращение в графику будет достаточно простым (рис. 19.7).

| USES Graph; { подключен модуль Graph }

| {$I initgraf.pas} { процедура инициализации }

| CONST { константы-сообщения: }

| graph_str = 'Это графический режим';

| text_str = 'А это текстовый режим';

| graph_back = 'А это снова графический режим';

| BEGIN

| GrInit; { инициализация графики }

| Line(0,0,GetMaxX,GetMaxY ); { диагональ экрана }

| OutTextXY(0,100,graph_str); { вывод первого сообщения }

| ReadLn; { пауза до нажатия ввода }

| RestoreCRTMode; { восстановление текстового режима }

| Write( text_str ); { вывод второго сообщения }

| ReadLn; { пауза до нажатия ввода }

Рис. 19.7

- 419 -

| SetGraphMode(GetGraphMode); { восстановление графи- }

| { ческого режима }

| Line(0,0,GetMaxX,GetMaxY); { диагональ экрана }

| OutTextXY(0,100,graph_back); {вывод третьего сообщения }

| ReadLn; { пауза до нажатия ввода }

| CloseGraph { закрытие графики }

| END.

Рис. 19.7 (окончание)

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

19.2.5. Управление режимом вывода отрезков на экран

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

SetWriteMode( WriteMode : Integer ).

Для задания параметра WriteMode в модуле Graph описаны пять констант, каждой из которых соответствует поразрядная операция (табл. 19.5).

Таблица 19.5

Имя константы

Значение

Логическая операция

Ее действие

CopyPut

MOV

Замещение

XORPut

XOR

Исключающее 'Или'

ORPut

OR

'Или'

ANDPut

AND

'И'

NOTPut

NOT

'НЕ'

- 420 -

Поскольку рисование на экране, по сути, является действием с битами, при прорисовке точек производятся логические операции между битами памяти монитора и битами изображения. Для описываемой процедуры разрешены только первые две операции: первая — замещение (очистка перед прорисовкой) и вторая (очень интересная) — XOR. Дело в том, что две последовательно проведенные логические операции XOR приведут биты памяти монитора в исходное состояние. Фактически это означает, что если есть какое-нибудь изображение на экране, то использовав его в качестве фона и нарисовав на нем картинку, можно восстановить его, прорисовав картинку еще раз (рис. 19.8). При инициализации и после смены режимов устанавливается режим CopyPut.

| Graph, CRT; { подключены Graph и CRT }

| {$I initgraf.pas} { процедура инициализации }

| VAR

| dx, dy, x, у : Integer; { рабочие переменные }

| maxx, maxy : Integer; { разрешение монитора }

| BEGIN

| GrInit; { инициализация графики }

| maxx := GetMaxX; { функции из раздела 19.3 }

| maxy := GetMaxY;

| dx := maxx DIV 4; { вычисление стороны }

| dy := maxy DIV 4; { прямоугольника }

| Bar3D( dx, dy, maxx-dx, maxy-dy, 30,True ); { разд.19.5.3 }

| SetWriteMode( XORput ); { установка режима XOR }

| repeat { пока не нажата клавиша.. }

| x := Random( maxx - dx ); { случайная точка экрана }

| у := Random( maxy - dy );

| { рисование прямоугольника }

| Rectangle( x,y, x+dx, y+dy);

| Delay( 200 ); { пауза в 200 мс }

| { стирание прямоугольника }

| Rectangle( x,y, x+dx, y+dy );

| until KeyPressed; { условие конца цикла }

| ReadLn; { пауза до нажатия ввода }

| CloseGraph { закрытие графики }

| END.

Рис. 19.8

Режим, заданный процедурой SetWriteMode, распространяется только на рисование отрезками, т.е. на процедуры Line, LineTo, LineRel, а также Rectangle и DrawPoly.

- 421 -

19.3. Системы координат и "текущий указатель"

19.3.1. Координаты устройства и мировые координаты

В растровой компьютерной графике экран представляет собой прямоугольный массив адресуемых точек и любое изображение на нем образуется как композиция светящихся или погашенных пикселов (так называется минимальный элемент изображения). Эти точки адресуются двумя целыми — горизонтальным номером точки nx и вертикальным номером ny:

0 <= nx <= nx_max,

0 <= ny <= ny_max,

где nx_max и ny_max — количество адресуемых точек по горизонтали и по вертикали минус единица. В табл. 19.4 в колонке «Разрешение экрана» показано количество точек для различных режимов и типов адаптеров дисплеев.

В модуле Graph предусмотрена возможность программного опроса максимальных адресуемых координат экрана. Она реализована парой функций

GetMaxX : Integer;

GetMaxY : Integer.

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

Точка с адресом (0,0) обычно расположена в левом верхнем углу экрана дисплея. Координаты (nx, ny) называют также координатами устройства. Они могут принимать только целые значения.

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

Вторая система координат — так называемая мировая. Она представляет собой декартову систему (X, Y), определенную программистом, и является независимой от типа устройства отображения:

xmin < x < xmax

ymin < у < ymax

Параметры, которыми задаются диапазоны изменения x и y (xmin, xmax, ymin, ymax), определяют прямоугольную область в

- 422 -

абстрактном математическом двумерном пространстве. В примере на рис. 19.9 приведены необходимые объявления и процедура установки мировых координат.

| TYPE { глобальный тип }

| World_Rec = RECORD { запись: }

| xmin.ymin, { предельные значения }

| xmax.ymax, { мировых координат }

| width,height: Real { диапазон мира }

| END;

| VAR

| my_world :World_Rec; { глобальная переменная-мир }

| nx_max,ny_max: Integer; { макс. разрешение экрана }

| PROCEDURE SetWindowWorld(minX,minY,maxX,maxY : Real);

| BEGIN

| with my_world do begin { работа с записью my_world }

| xmin = minX; { Назначение мировых координат в }

| ymin = minY; { соответствии с заданными }

| xmax = maxX; { фактическими параметрами... }

| ymax = maxY;

| width := maxX - minX; { Определение диапазона их }

| height:= maxY – minY { возможного изменения }

| end {with}

| END;

Рис. 19.9

Для перевода текущих координат точки из мировой системы в систему устройства можно воспользоваться процедурой с рис. 19.10.

| PROCEDURE WorldToDevice(x, y : Real; VAR nx, ny : Integer);

| BEGIN

| with my_world do {работа с записью my_world }

| begin

| nx := Round((x-xmin)/width)*nx_max;

| ny := Round((y-ymin)/height)*ny_max

| end

| END;

Рис. 19.10

- 423 -

Заметим, что переменные nx_max, ny_max должны быть инициализированы сразу после включения соответствующего графического режима. Это можно сделать, используя функции GetMaxX и GetMaxY. Так как в модуле Graph все процедуры и функции работают с координатами устройства, то в дальнейшем все действия будут осуществляться только в определенной режимом системе координат.

19.3.2. Управление «текущим указателем»

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

MoveTo( х, у : Integer )

перемещает его в точку экрана с координатами (x, y). Другая процедура —

MoveRel( dx, dy : Integer )

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

Для определения текущего положения графического курсора используются функции

GetX : Integer;

GetY : Integer,

возвращающие положение указателя соответственно по оси X и по оси Y. Позиционирование текущего указателя и опрос его местонахождения работают корректно, даже если работа происходит за пределами координат устройства.

Не все графические процедуры перемещают текущий указатель. Кроме названных выше, изменяют его положение лишь процедуры LineTo, LineRel, OutText. Все процедуры инициализации и очистки экрана (InitGraph, GraphDefaults, ClearDevice, SetGraphMode, SetViewPort и ClearViewPort) устанавливают его в положение (0,0).

- 424 -

19.4. Рисование графических примитивов и фигур

19.4.1. Линии и их стили

Процедура вывода линии (отрезка) на экран (в текущем цвете и стиле) определена в следующем виде:

Line( Х1, Y1, Х2, Y2 : Integer )

Здесь задаются координаты начала (X1,Y1) и конца (X2,Y2) отрезка. Возможны еще два метода рисования отрезков:

1. Из текущей точки в точку с заданными координатами (X,Y) процедурой

LineTo( х, у : Integer );

2. Относительно текущей позиции. Положение текущего указателя принимается за начало «временных» координат (0,0) и указывается местоположение конца отрезка в них. Такое построение делает процедура

LineRel( dx, dy : Integer )

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

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

TYPE

LineSettingsType = RECORD

LineStyle : Word; { стиль (тип) }

Pattern : Word; { шаблон типа }

Thickness : Word; { толщина }

END;

CONST

{ Для значений поля LineStyle: }

SolidLn = 0 { сплошная линия }

DottedLn = 1 { точечная линия }

CenterLn = 2 { штрихпунктирная линия }

DashedLn = 3 { пунктирная линия }

UserBitLn = 4 { тип линии задан явно шаблоном }

{ Для значений поля Thickness: }

NormWidth = 1 { толщина линии в один пиксел }

ThickWidth = 3 { толщина линии в три пиксела }

- 425 -

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

GetlineSettings( VAR LineType : LineSettingsType )

а чтобы установить новый стиль линий, необходимо использовать процедуру

SetLineStyle( LineStyle, Pattern, Thickness : Word ),

подставив в нее соответствующие значения. Если параметр LineStyle не равен UserBitLn, то значение параметра Pattern не играет роли и обычно задается нулем.

Рассмотрим подробно вариант, когда LineStyle равно UserBitLn. В этом случае при определении типа линии руководствуются следующими соображениями:

1. Линия представляет собой совокупность отрезков, каждый из которых имеет длину 16 пикселов. Если длина линии не делится на 16 нацело, то последний отрезок обрезается.

2. Можно задать шаблон-комбинацию шестнадцати светящихся или погашенных пикселов. Его представляют как множество единиц и нулей: 1 — светится, 0 — нет. Например, мелкий равномерный пунктир задается как

1100110011001100 — всего 16 разрядов.

Поскольку Турбо Паскаль не позволяет работать с числами, представленными в двоичной системе счисления, необходимо перевести полученное число в десятичную (52428) или в шестнадцатеричную ($СССС) систему счисления и подставить его фактическим параметром на место Pattern при вызове SetLineStyle (рис. 19.11).

| USES Graph; { подключен модуль Graph }

| {$I initgraf.pas} { процедура инициализации } VAR

| х : Integer;

| BEGIN

| GrInit; { инициализация графики }

| х := GetMaxX; { разрешение экрана по X }

| SetLineStyle( DottedLn, 0, NormWidth );

| Line( 0, 10, х, 10 ); { тонкая сплошная линия }

| SetLineStyle( CenterLn, 0, NormWidth );

| Line( 0, 20, х, 20 ); { штрихпунктирная линия }

Рис. 19.11

- 426 -

| SetLineStyle( UserBitLn, $CCCC, NormWidth );

| Line( 0, 30, x, 30 ); { линия 1100110011001100 }

| SetLineStyle( UserBitLn, $B38F, NormWidth );

| Line( 0, 40, x, 40 ); { линия 1011001110001111 }

| SetLineStyle( UserBitLn, $4C70, NormWidth );

| Line( 0, 50, x, 50 ); { линия 0100110001110000 }

| ReadLn; { пауза до нажатия ввода }

| SetLineStyle( DottedLn, 0, ThickWidth );

| Line( 0, 10, x, 10 ); { толстая сплошная линия }

| SetLineStyle( CenterLn, 0, ThickWidth );

| Line( 0, 20, x, 20 ); { штрих-пунктирная линия }

| SetLineStyle( UserBitLn, $CCCC, ThickWidth );

| Line( 0, 30, x, 30 ); { линия 1100110011001100 }

| SetLineStyle( UserBitLn, $B38F, ThickWidth );

| Line( 0, 40, x, 40 ); { линия 1011001110001111 }

| SetLineStyle( UserBitLn, $4C70, ThickWidth );

| Line( 0, 50, x, 50 ); { линия 0100110001110000 }

| ReadLn; { пауза до нажатия ввода }

| CloseGraph { закрытие графики }

| END.

Рис. 19.11 (окончание)

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

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

19.4.2. Коэффициент сжатия изображения

Если попытаться нарисовать квадрат отрезками, например

MoveTo( 100, 100 );

LineRel( 20, 0 ); LineRel( 0, 20 );

LineRel(-20, 0 ); LineRel( 0, -20 );

то на экране скорее всего возникнет сжатый прямоугольник. Похожая картина будет наблюдаться, если «вручную» нарисовать окружность с помощью отрезков прямых или точек: получится эллипс. Это связано с тем, что отношение высоты экрана к ширине не равно отношению его разрешающей способности по вертикали к разрешающей способности по горизонтали. Для учета этого неравенства в графическом стандарте BGI вводится специальный показатель, на-

- 427 -

зываемый коэффициентом сжатия изображения (aspect ratio). Его значения могут иметь широкий диапазон. Например, для ПЭВМ типа IBM PC/XT/AT стандартные мониторы имеют отношение высоты экрана к его ширине, равное 0,75. При этом разрешающая способность адаптеров колеблется от 640x200 для CGA до 1024x768 для IBM8514, и отношение GetMaxY к GetMaxX может меняться от 0,3125 (640x200) до 0,75 (640x480, 1024x768). Таким образом, на единицу длины оси экрана приходится разное количество пикселов по горизонтали и вертикали, а поскольку все операции производятся с пикселами, то в результате вместо окружности может получиться эллипс, горизонтальная полуось которого равна радиусу, а вертикальная — радиусу, деленному на коэффициент сжатия изображения. Это очень неудобно при работе программы на разных ПЭВМ, так как если в ней есть прорисовка окружностей, то на различных ПЭВМ они будут выглядеть как различные вариации эллипса. В модуле Graph есть две процедуры, помогающие устранить это неудобство. Первая из них

GetAspectRatio( VAR А, В : Word )

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

SetAspectRatio( А, В : Word )

позволяет изменять текущий коэффициент сжатия на равный (A/B) и может помочь при написании программ, одинаково работающих на различных IBM-совместимых ПЭВМ.

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

19.4.3. Окружности, эллипсы и дуги

Для изображения окружностей используется процедура

Circle( x, у : Integer; Radius : Word )

Здесь (X,Y) — координаты центра окружности, Radius — ее радиус. Результатом ее работы будет окружность, если коэффициент сжатия

- 428 -

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

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

Положительное направление оси X (слева направо) принято за 0°, отрицательное направление оси Y — за 90°, т.е. углы отмеряются от положительного направления оси X против часовой стрелки. Все значения этих параметров даются в градусах.

Ниже перечислены процедуры рассматриваемого класса:

1. Рисование дуги радиуса Radius из центра с координатами (X,Y) от угла StartAngle до EndAngle:

Arc( X,Y: Integer; StartAngle, EndAngle, Radius: Word )

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

2. Рисование эллиптической дуги с аналогичными параметрами:

Ellipse( X, Y: Integer; StartAngle, EndAngle, XRadius, YRadius: Word )

где XRadius и YRadius — размеры горизонтальной и вертикальной полуосей соответственно. Как видно из описания процедуры, оси

- 429 -

эллипса могут быть только параллельны осям X и Y. Для изображения полного эллипса надо задавать углы 0° и 360°. Значение коэффициента сжатия изображение не влияет на его вид.

Некоторые другие процедуры, изображающие секторы (Sector, PieSlice), а также FillEllipse, выполняют попутно их заливку, поэтому они рассмотрены в разд. 19.5.3 «Заливка областей изображения».

Угловые параметры очень неудобны для нашей системы координат — мы можем определить координаты начала и конца дуг окружности или эллипса не иначе, как только используя известные тригонометрические выражения. Но в подобных вычислениях нет необходимости, поскольку эти координаты все равно известны внутри процедур Arc, Ellips, Sector и PieSlice.

Извлечь концевые координаты дуг позволяет процедура

GetArcCoords( VAR ArcCoords : ArcCoordsType )

Тип ArcCoordsType объявлен в модуле Graph следующим образом:

TYPE

ArcCoordsType = RECORD

X, Y : Integer; { центр }

XStart, Ystart : Integer; { начало }

XEnd, Yend : Integer; { конец }

END;

Рассматриваемая процедура возвращает «итоги» последнего вызова процедуры рисования дуги или сектора. Это может пригодиться в случае, если дуги являются частью какого-либо построения на экране дисплея (рис. 19.13).

USES Graph; { подключен модуль Graph }

{$I initgraf.pas} { процедура инициализации }

VAR

maxx, maxy, radius : Integer;

x_right, x_left, y_right, y_left : Integer;

ArcCo1, ArcCo2 : ArcCoordsType;

BEGIN

GrInit; { инициализация графики }

maxx := GetMaxX; { разрешение по оси X }

maxy := GetMaxY; { разрешение по оси Y }

radius := Round(maxy*0.30); { значение радиуса дуг }

x_right := Round(maxx*0.75); { центр правой дуги }

y_right := Round(maxy*0.25);

Рис. 19.13

- 430 -

x_left := Round(maxx*0.25); { центр левой дуги }

y_left := Round(maxy*0.75);

Arc(x_right, y_right, 315, 135, radius);

GetArcCoords(ArcCol ); { где концы правой дуги? }

Arc( x_left, y_left, 135, 315, radius );

GetArcCoords( ArcCo2 ); { где концы левой дуги? }

{ Дуги сопрягаются прямыми: }

Line(ArcCo1.XStart, ArcCo1.YStart, ArcCo2.XEnd, ArcCo2.YEnd);

Line(ArcCo2.XStart, ArcCo2.YStart, ArcCo1.XEnd, ArcCol.YEnd);

ReadLn;

CloseGraph { закрытие графики }

END.

Рис. 19.13 (окончание)

19.4.4. Построение прямоугольников и ломаных

Для построения прямоугольника достаточно вызвать процедуру

Rectangle( Х1, Y1, Х2, Y2 : Integer ),

которая изобразит на экране прямоугольник с диагональю (X1, Y1) — (X2, Y2). Для рисования квадрата надо выбрать высоту прямоугольника так, чтобы она равнялась произведению ширины на коэффициент сжатия изображения (см. разд. 19.4.2).

Чтобы построить фигуры с большим количеством вершин (в том числе и незамкнутые), можно воспользоваться процедурой

DrawPoly( NumPoints : Word; VAR PolyPoints )

Она позволяет рисовать на экране дисплея любую ломаную, заданную набором координат некоторого множества точек. Это может быть как сложная геометрическая фигура, так и табличная математическая функция. Параметр NumPoints — это количество точек ломаной (заметим, что если необходимо нарисовать замкнутый многоугольник с N вершинами, то значение NumPoints должно быть на единицу больше числа N, а координата (N+1)-й точки должна быть такой же, как координата первой). Под бестиповым параметром PolyPoints понимается какая-либо переменная, состоящая из наборов двухкомпонентных записей. Поля каждой записи должны содержать координаты X и Y очередной точки. В модуле Graph введен такой тип:

TYPE

PointType = RECORD

X, Y : Integer { координаты точки }

END;

- 431 -

Обычно набор точек организуется как массив из записей типа PointType (и именно к такой структуре приводится значений параметра Poly Point при работе процедуры DrawPoly). Пример построения графика функции с помощью процедуры DrawPoly приведен на рис. 19.14.

USES Graph; { подключен модуль Graph }

{$I initgraf.pas} { процедура инициализации }

CONST

Pi = 3.14151828;** { константа Pi (замещает функцию) }

Pi2 = 2*Pi; { различные производные от Pi... }

Pi001 = 0.01*Pi;

VAR

angle : Real;

sine_func : Array[1..201] of PointType; {массив точек }

maxy, i : Integer;

BEGIN

GrInit; { инициализация графики }

maxy := GetMaxY div 2; { середина экрана по оси Y }

angle := 0.0; { задание стартовых значений }

i := 0; { счетчик точек в sine_func }

repeat { цикл заполнения sine_func }

Inc(i); sine_func[i].x := Round( 100*angle ) + 10;

sine_func[i].y := Round( 100*Sin(angle) ) + maxy ;

angle := angle + Pi001;

until

angle > Pi2;

DrawPoly(i,sine_func); { рисование графика синуса }

ReadLn; { пауза до нажатия ввода }

CloseGraph { закрытие графики }

END.

Рис. 19.14

** Так напечатано. Вообще-то с точностью до 8-го знака после запятой число p=3,14159265.— Ю.Ш.

С помощью DrawPoly можно вывести график части функции. Для этого достаточно указать при передаваемом массиве номер n первого рассматриваемого элемента (т.е. точки), а в первом параметре — количество рассматриваемых точек, начиная с n-й, например

DrawPoly( 20, sine_func[100] );

Такой вызов выведет ломаную по точкам с номерами 100, 101, ..., 119.

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

- 432 -

19.5. Управление цветами и шаблонами заливки (заполнения)

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

19.5.1. Немного о цветах

Говоря о цветах, профессионалы пользуются специфической терминологией (рис. 19.15). Хроматические цвета — это все, кроме белого, черного и серых. Нейтральные цвета (белый, черный и серые) называются ахроматическими.

Рис. 19.15

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

- 433 -

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

Рис. 19.16

Под светлотой цвета обычно понимается его яркость.

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

Цветовое колесо, показанное на рис. 19.16, получается из стандартного цветового круга. Цветовой круг создан четырьмя базовыми цветовыми тонами, воспринимаемыми человеческим глазом: красным, желтым, зеленым и синим. Восприятие совокупности цветных точек как единого целого (хорошо известное свойство зрения) используется в кинескопах дисплеев ПЭВМ, Базовые цвета в триадах точек люминофора — красный (red), синий (blue), зеленый (green) — могут смешиваться в определенных пропорциях (это имеет место в RGB-дисплеях). При этом можно получить практически все существующие в природе цветовые тона.

Правильный подбор цветовой комбинации на экране называют гармонией.

Аналоговая гармония — это комбинация цветовых тонов, которые являются соседними в цветовом круге (рис. 19.17). В зависимости от

- 434 -

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

Рис. 19.17

Дополняющая гармония разделяется на так называемую прямую и разделенно-дополняющую. Прямая гармония — это совокупность цветов, которые прямо противостоят друг другу в цветовом круге (рис. 19.18). Например, красно-зеленая гамма — это прямая гармония. Она обычно создает впечатление сильного удара, импульса.

Рис. 19.18

Составная гармония формируется комбинацией цветов, которые расположены в вершинах треугольника, вписанного в цветовой круг. Составная гармония называется также троичной гармонией. Красно-желто-синяя комбинация — это типичный пример троичной гармонии.

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

Цвет/Белый/Черный = Цветовая смесь

Наглядно она представлена на рис. 19.19.

- 435 -

Рис. 19.19

Человеческий глаз может точно распознавать девять оттенков серого между чисто-белым и чисто-черным (рис. 19.20).

Рис. 19.20

19.5.2. Задание типа заливки

В модуле Graph предусмотрены процедуры, с помощью которых можно заполнить (залить) определенным «узором» любую замкнутую область изображения. Вид «узора» задается так называемым шаблоном заливки. В Турбо Паскале предопределен ряд стандартных шаблонов, но кроме того, имеется возможность конструировать собственные.

19.5.2.1. Построение шаблона заливки. Рассмотрим, как можно получить на экране полутоновые изображений любого цвета из стандартного набора цветов, т.е. как расширить за счет введения полутоновых заполнений цветовые возможности адаптера. Составим шаблоны для заливки полутоновых изображений (рис. 19.21).

На этом рисунке изображены типовые матрицы 8x8, используя которые можно создать полутоновые изображения любыми двумя

- 436 -

Рис. 19.21

цветами. Тип переменной для задания матрицы заполнения объявлен в модуле Graph как массив:

| TYPE

FillPatternType : Array [1..8] of Byte

Таким образом, каждую матрицу можно представить, как показано на рис. 19.22.

Рис. 19.22

- 437 -

Если рассмотреть первую строку в шаблоне 25%-го заполнения, то получится 01000100 в двоичной системе счисления (68 в десятеричной или $44 в шестнадцатиричной). Следующая строка — 00010001 в двоичной (17 в десятеричной или $11 в шестнадцатеричной) и т.д. В результате мы можем получить константу

CONST

Fill_25 : FillPatternType =

( $44, $17, $44, $17, $44, $17, $44, $17 )

Подобные константы можно задать для любого из шаблонов с рис. 19.21. Если программы должны работать на ПЭВМ с монохромным дисплеем (MDA, Hercules), то наличие разных по яркости шаблонов заполнения может скомпенсировать отсутствие цветных возможностей у монитора.

19.5.2.2. Назначение шаблона заполнения (заливки). Оно производится процедурой

SetFillStyte( Pattern : Word; Color : Word )

где параметр Pattern определяет вид шаблона заливки, a Color — его цвет. Все разрешенные значения параметра Pattern предопределены в модуле Graph в виде констант:

CONST

EmptyFill = 0 { сплошная заливка цветом фона }

SolidFill = 1 { сплошная заливка текущим цветом }

LineFill = 2 { заливка типа === }

LtSlashFill = 3 { заливка типа /// }

SlashFill = 4 { заливка жирными линиями типа /// }

BkSlashFill = 5 { заливка жирными линиями типа \\\ }

LtBkSlashFill = 6 { заливка типа \\\ }

HatchFill = 7 { заливка редкой штриховкой }

XHatchFill = 8 { заливка частой штриховкой }

InterleaveFill =9 { заливка прерывистой линией }

WideDotFill = 10 { заливка редкими точками }

CloseDotFill = 11 { заливка частыми точками }

UserFill = 12 { заливка, определенная программистом }

Наиболее интересна здесь константа UserFill. Она используется для определения типа заливки, который предварительно был задан в программе. Для задания своего нового шаблона необходимо воспользоваться процедурой

SetFillPattern(PattMatrix : FillPatternType; Color : Word)

передав ей в параметре PattMatrix матрицу шаблона заливки и указав цвет параметром Color. Эта процедура по действию, вообще говоря,

- 438 -

аналогична SetFillStyle, но устанавливает только «самодельные» шаблоны. Процедура SetFillStyle удобнее, особенно в приложениях деловой графики (гистограммы, круговые диаграммы и т.п.). Задавая хотя бы раз новый шаблон, мы автоматически связываем его со значением UserFill и далее можем манипулировать всеми тринадцатью шаблонами. Если же задать UserFill, не определив перед этим новый шаблон, то функция GraphResult возвратит значение -11 (grError) и все установки вида шаблона и цвета останутся прежними. По умолчанию устанавливается шаблон SolidFill и цвет с номером, максимальным для текущего графического режима.

Несколько слов о назначении цвета при заливке. В обеих процедурах назначения шаблона переменная Color определяет цвет, которым исполняется шаблон. Цвет фона при этом остается неизменным. Это создает некоторые трудности при создании цветовой смеси. Например, цвет фона обычно задается черным (Black), а требуется создать 50%-ю смесь коричневого и синего цветов. Казалось бы, просто: рисуем фигуру, заливаем ее сплошным коричневым и потом заливаем ее 50%-м шаблоном синего. Однако после этих операций получится фигура, залитая чисто синим 50%-и яркости. Дело в том, что процедуры заливки в Турбо Паскале реализованы, на наш взгляд, не очень корректно (чего нельзя сказать о реализации этих процедур в системе Quick Pascal фирмы Microsoft): там, где в двоичном коде шаблона стоят единицы, процедуры ставят точки цвета Color, а там, где нули, — вместо того чтобы ничего не рисовать, они ставят точки цвета текущего фона. Выход из этой ситуации может быть найден с помощью средств, описанных в разд. 19.5. «Управление палитрой».

19.5.2.3. Анализ шаблона заполнения. Рассмотрим процедуры получения информации о текущих установках шаблонов заливки. Так, процедура

GetFillSettings(VAR FillType : FillSettingsType )

возвращает в переменной FillType предопределенного типа

TYPE

FillSettingsType = RECORD

Pattern : Word; { шаблон }

Color : Word; { цвет }

END;

номер шаблона из списка, представленного при описании процедуры SetFillStyle (поле Pattern), и цвет, которым наносится этот шаблон (поле Color). Если значение поля Pattern оказалось равным UserFill,

- 439 -

то для получения подробной информации следует вызвать процедуру

GetFillPattern( VAR PattMatrix : FillPatternType )

возвращающую в переменной типа FillPatternType матрицу последнего определенного пользователем шаблона.

19.5.3. Заливка областей изображения

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

Bar( X1, Y1, X2, Y2 : Integer )

рисует прямоугольник, внутренняя область которого залита по текущему шаблону. Она обычно используется в деловой графике для построения столбчатых диаграмм. Параметры (X1,Y1) и (X2,Y2) — координаты верхнего левого и правого нижнего углов прямоугольника. Еще более наглядное представление информации при рисовании диаграмм позволяет получить процедура

Bar3D( X1,Y1, X2,Y2 : Integer; D3 : Word; Top : Boolean )

Она рисует параллелепипед, лицевая сторона которого заливается по текущему шаблону, а глубина задается в пикселах параметром D3. Параметр Top задает режим отображения верхней плоскости: True — отображать, False — не отображать. Этот параметр необходим для того, например, чтобы можно было рисовать столбцы, стоящие друг на друге. В модуле Graph определены две константы для нее:

CONST

TopOn = True; { верхняя плоскость нужна }

TopOff = False; { верхняя плоскость не нужна }

Следующие «заполняющие» процедуры работают с секторами окружностей и эллипсов. Рисование сектора эллипса, который будет залит цветом по текущему шаблону, осуществляется процедурой

Sector( X, Y : Integer;

StartAngle, EndAngle, XRadius, YRadius : Word )

Параметры процедуры имеют тот же смысл, что и в процедурах Arc, Ellipse (см. разд. 19.4.3). Для задания кругового сектора надо задавать YRadius с учетом коэффициента сжатия:

- 440 -

VAR

R, А, В : Word; { R - радиус кругового сектора }

BEGIN

...

GetAspectRatio( А, В );

Sector( 100, 100, 0, 90, R, R*LongInt( A ) div В );

...

END.

Этого же эффекта можно достичь, используя процедуру

PieSlice( X, Y : Integer;

StartAngle, EndAngle, Radius : Word )

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

К рассмотренным процедурам примыкает еще одна:

FillEllipse( X, Y : Integer; XRadius, YRadius : Word )

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

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

FillPoly( NumPoints : Word; VAR PolyPoints )

Ее параметры имеют такое же назначение, как и в процедуре DrawPoly (см. разд. 19.4.4). Единственное отличие в том, что координаты первой и последней вершины многоугольника могут не совпадать. Однако все равно они будут соединены линией, и внутренность фигуры будет залита (рис. 19.23).

| USES Graph; { подключен модуль Graph }

| {$I initgraf.pas} { процедура инициализации} CONST

| our_figure : Array [1..4] of PointType =

| ((x : 319; y : 40), { Задание координат концов}

| ( x : 398; y : 146), { отрезков, являющихся сто- }

| ( x : 240; y : 146), { ронами нашей геометричес- }

| ( x : 400; y : 40 )); { кой фигуры }

Рис. 19.23

- 441 -

| BEGIN GrInit; { инициализация графики }

| SetFillStyle(InterleaveFill, Red); { задание шаблона }

| FillPoly( SizeOf(our_figure) div SizeOf( PointType ), our_figure );

| { рисование заданной фигуры }

| ReadLn; { пауза до нажатия ввода }

| CloseGraph { закрытие графики }

| END.

Рис. 19.23 (окончание)

Обратите внимание на то, как в этом примере вычисляется количество точек многоугольника. Функция SizeOf (our_figure) возвращает размер константы our_figure в байтах, a SizeOf (PointType) — размер памяти, занимаемый одним элементом типа PointType. И, наконец, можно сказать, универсальная процедура

FloodFill( X, Y : Integer; Border : Word )

Она заливает всю область вокруг точки (X,Y), ограниченную линиями цвета Border. Например, если точка (X,Y) находится внутри области, ограниченной окружностью, то вся область будет залита по шаблону и цветом, установленными процедурами SetFillPattern или SetFillStyle. Если же точка будет находиться вне этой области, то залитым будет весь экран за исключением этой области. Обратите внимание на то, что если область не замкнута сплошной линией или границами экрана, то по шаблону заполнится весь экран. Следует помнить, что использование очень редкого заполнения шаблона на маленьких областях чревато некорректной работой процедуры (рисунок шаблона может не проявиться). Вообще говоря, авторы языка Турбо Паскаль, исходя из требований переносимости программ в последующие его версии, рекомендуют не пользоваться описанной процедурой и заменять ее, где это возможно, процедурой FillPoly, работающей более корректно.

19.5.4. Опрос и установка цветов пера и фона

Различные адаптеры поддерживают разное количество цветов, выводимых одновременно на экран в графическом режиме. Но для всех BGI-драйверов оно ограничено диапазоном 0..15. Нумерация и названия цветов совпадают с теми, которые были приведены для текстовых цветов в гл. 15 «Модуль CRT», а имена констант, обозна-

- 442 -

чающих цвета (за исключением Blink), продублированы в модуле Graph.

Максимальный номер цвета, воспринимаемый данным адаптером в текущем графическом режиме, может быть получен при помощи функции

GetMaxColor : Word

Например, для CGA в режиме 320x200 (4 цвета на экране) эта функция возвращает число 3, а для CGA в режиме 640x200 (только два цвета) — 1. Эту информацию можно использовать для переопределения цветов:

TYPE

ColorSetType = Array [0..15] of Byte; { тип набор }

VAR

CS : ColorSetType; { набор цветов }

i, GMC : Word;

BEGIN

...

GMC := Succ( GetMaxColor );

for i:=0 to 15 do CS[ i ] := i mod GMC;

...

end.

После такого заполнения матрицы-набора цветов можно обращаться к любому цвету из диапазона 0..15, например CS [White] (это то же, что и CS[15]), даже в режиме Hercules — значение элементов массива никогда не превзойдет GetMaxColor.

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

SetColor( Color : Word )

Цвет фона — всегда един в поле экрана. Он может быть изменен процедурой

SetBkColor( Color : Word )

После использования этой процедуры цвет экрана сразу же меняется на заданный. Параметр Color не должен превышать текущее значение GetMaxColor. Цветом фона может быть любой из разрешенных цветов, в том числе и яркий. По умолчанию и при реинициализации графики цвет фона равен 0 (Black), а цвет пера равен значению функции GetMaxColor.

- 443 -

Всегда можно опросить текущие установки цвета. Функция

GetColor : Word

возвращает значение текущего цвета пера, а функция

GetBkColor : Word

возвращает текущий цвет фона.

19.5.5. Управление палитрой

19.5.5.1. Палитра и ее анализ. Максимальный набор цветов, поддерживаемых одновременно BGI-драйвером, называется палитрой и может состоять из 16 цветов, пронумерованных от 0 до 15 (так будет, например, для графических адаптеров EGA, VGA). Эти шестнадцать цветов используются по умолчанию в режимах 640x480 для VGA, 640x350, 640x200 и 320x200 для EGA как в текстовом, так и в графическом режимах.

Стандартная палитра режима 320x200 адаптера GGA (палитра С0) состоит из всего лишь четырех цветов:

0 — черный;

1 — синий;

2 — малиновый;

3 — белый.

А для того же адаптера CGA в режиме CGAHi (640x200) и для Hercules палитра состоит только из двух цветов: черного (0) и белого (1).

Числа от 0 до 15, которые используются для обозначения цветов, определяют цветовые атрибуты или, как их еще называют, «программные» цвета. Каждому программному цвету присваивается «аппаратный» цвет из так называемой полной палитры. Например, для адаптера EGA, выводящего одновременно до 16 цветов, программные цвета выбираются из полной палитры в 64 цвета, имеющейся в этом адаптере. А в адаптере VGA аппаратная палитра содержит 256 цветов. Для адаптеров класса CGA полная палитра составляет 16 аппаратных цветов, но одновременно на экране могут появиться тишь максимум четыре цвета одной из четырех программных палитр (C0...C3). У адаптеров Hercules и РС3270 полная и программная палитры состоят из двух цветов.

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

Рассмотрим процедуры, с помощью которых можно получить системную информацию о ней. В модуле Graph определен тип для описания палитры:

- 444 -

CONST

MaxColors*15; { максимальный программный номер цвета }

TYPE

PaletteType=RECORD

Size : Byte; { размер программной палитры}

Colors: Array [0..MaxColors] of ShortInt;

END;

Поле Size содержит количество цветов в палитре, а поле Colors содержит действующие цвета в первых Size элементах массива. Процедуры GetPalette и GetDefaultPalette возвращают в фактических параметрах значение типа PaletteType:

GetDefaultPalette( VAR Palette : PaletteType );

GetPalette( VAR Palette : PaletteType )

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

GetPaletteSize : Word

возвращает результат типа Word, который показывает, какое количество цветов входит в текущую программную палитру. В принципе, эта функция возвращает значение, равное GetMaxColor+1.

19.5.5.2. Установка палитры. Для установки палитры в модуле Graph представлены три процедуры разной сложности. Процедура

SetPalette( ColorNum : Word; Color : ShortInt )

управляет только одним цветом в палитре. ColorNum — это номер программного цвета, Color — номер аппаратного цвета, который будет под ним пониматься. Например, вызов SetPalette( 0, Red ) делает красный цвет первым цветом палитры. Параметр Color может превышать максимальный программный номер цвета, но только на адаптерах EGA (0..63) и VGA. При некорректном вызове процедуры функция GraphResult вернет значение grError. Процедура

SetAllPalette( VAR Palette )

позволяет самостоятельно производить «перетасовку» всей палитры сразу и назначать соответствие между программными и аппаратными цветами. Параметр Palette является бестиповым, переменной длины. Первый его байт должен содержать количество цветов N в устанавливаемой палитре, следующие N байтов должны содержать цвета

- 445 -

из аппаратной палитры, которые будут использоваться в дальнейшем. Каждый из этих байтов может принимать значения от -1 до максимального аппаратного, причем диапазон чисел от 0 и выше представляет устанавливаемые цвета, а число -1 задается в том случае, если соответствующий цвет остается без изменений. Параметр Palette удобно представлять типом PaletteType, так как он имеет именно такую структуру. Пример смены палитры приведен на рис. 19.24.

(* ТОЛЬКО ДЛЯ АДАПТЕРОВ EGA ИЛИ VGA*)

USES Graph, CRT; { подключены Graph и CRT }

{$I initgraf.pas} { процедура инициализации }

VAR

palette : PaletteType; { переменная для палитры }

i, j, MaxC : Integer; { счетчики; максимальный цвет }

BEGIN

GrInit; { инициализация графики }

palette.size:=GetPaletteSlze; { размер текущей палитры }

MaxC := Pred(palette.size); { макс, программный цвет }

for i:=0 to MaxC do

{ Рисование вложенных разно- }

begin { цветных прямоугольников }

SetFillStyle( SolidFill, i );

Bar(i*10, i*10, GetMaxX-i*10, GetMaxY-i*10)

end;

for i:=0 to 63-MaxC do

{ цикл по аппаратным цветам }

begin

{ Сдвиг программных цветов относительно аппаратных: }

for j:=0 to MaxC do

palette.colors[j] := j + i ;

SetAllPalette(palette); { назначение новой палитры }

Delay( 100 ) { пауза в 100 мс }

end;

ReadLn; { пауза до нажатия ввода }

GetDefaultPalette(palette); { берется исходная палитра }

SetAllPalette(palette); {и восстанавливается }

CloseGraph { закрытие графики }

END.

Рис. 19.24

Заменяя палитры, можно «оживлять» изображения на экране при условии, что все его «кадры» находятся в поле экрана и не пересекают друг друга. Допустим, есть 15 кадров. Тогда назначается палитра со всеми цветами, равными фоновому. Далее рисуются все 15 кадров, причем первый кадр выводится первым цветом програм-

- 446 -

мной палитры, второй — вторым и т.д. После вывода 15-го кадра цветом номер 15 все кадры на экране будут «невидимы». Теперь достаточно с нужной задержкой устанавливать один из цветов палитры видимым, и мгновенно будет «проявляться» очередной кадр.

Для удобства работы со стандартными цветами адаптера EGA в модуле Graph введены 16 констант со значениями аппаратных цветов, соответствующими стартовой программной палитре:

CONST

EGABlack = 0; EGABlue = 1; EGAGreen = 2;

EGACyan = 3; EGARed = 4; EGAMagenta = 5;

EGABrown = 20; EGALightgray = 7; EGADarkgray = 56;

EGALightblue = 57; EGALightgreen = 58; EGALightcyan = 59;

EGALightred = 60; EGALightmagenta = 61; EGAYellow = 62;

EGAWhite= 63;

Более сложная процедура

SetRGBPalette( ColorNum,

RedValue, GreenValue, BlueValue : Integer )

позволяет манипулировать цветовыми сочетаниями развитых графических адаптеров VGA и IBM8514. Параметр программного цвета ColorNum должен быть в диапазоне 0..15 для VGA и 0..255 для IBM8514. Последние три параметра показывают смешение красного, зеленого и синего цветов. Хотя они объявлены как Integer, BGI-драйвером воспринимается в них только младший байт, в котором, в свою очередь, значащими являются только шесть битов, с 0-го по 5-й (т.е. значения в диапазоне 0..63). Это сделано для совместимости со стандартом EGA.

На практике применение этой процедуры проблематично из-за сложности представления «аппаратных» цветов. Кроме того, не на всех модификациях адаптера VGA процедура работает одинаково. Для переносимости программ мы не рекомендуем пользоваться этой процедурой.

19.5.5.3. Низкоуровневое управление палитрой EGA/VGA. В графическом режиме нет проблем поменять палитру (если, конечно, в ПЭВМ стоит плата EGA, VGA или IBM8514). Но это невозможно сделать в текстовом режиме, поскольку рассмотренные выше процедуры работают только после инициализации графики. Можно напрямую изменять программную палитру, даже в текстовом режиме, используя функцию 10H прерывания 10H. Надо только правильно закодировать аппаратный цвет. Структура байта, представляющего собой один аппаратный цвет (составляемый смешением компонентов), показана на рис. 19.25.

- 447 -

-- Бит → Компонент цвета

0 -- B → синий, интенсивность 2/3

1 -- G → зелёный, интенсивность 2/3

2 -- R → красный, интенсивность 2/3

3 -- b → синий, интенсивность 1/3

4 -- g → зелёный, интенсивность 1/3

5 -- r → красный, интенсивность 1/3

6 -- не используется

7 -- не используется

Рис. 19.25

Как видно, для каждого чистого цвета R, G и В имеется возможность получить три градации яркости: 1/3 интенсивности, 2/3 интенсивности и 1/3+2/3=1 интенсивности. Кроме того, возможны различные комбинации битов в регистрах. Возможное количество цветов равно двум в степени шесть (это 64 — от 0 до 63).

Как заменить программный цвет номер ColorNum на аппаратный RGBrgb, построенный по схеме рис. 19.25, показано на рис. 19.26. Для вызова прерывания требуется подключение модуля DOS.

| USES DOS; { необходим модуль DOS }

| PROCEDURE SetPalColor( ColorNum, RGBrgb : ShortInt );

| VAR

| Regs : Registers; { нужна для вызова DOS.Intr() }

| BEGIN

| with Regs do begin

| { действия с полями Regs }

| AX := $1000; { AL=$00, AH=$10 }

| BL := ColorNum; { номер изменяемого цвета }

| BH := RGBrgb { присваиваемое ему значение }

| end; {with}

| Intr( $10, Regs ) { прерывание 10H - сервис EGA }

| END;

Рис. 19.26

- 448 -

19.6. Битовые графические операции

19.6.1. Битовые операции

19.6.1.1. Опрос пикселов. Турбо Паскаль позволяет организовать прямой доступ к каждому пикселу экрана. Делается это функцией

GetPixel( X, Y : Integer )

которая возвращает значение типа Word — номер цвета пиксела с координатами (X,Y). Поскольку обычно номер цвета лежит в диапазоне 0..15 или меньше, значащим является только младший байт.

Приведем пример процедуры копирования изображения с графического экрана на одноцветный принтер (рис. 19.27). Это адаптированная версия процедуры из пакета Turbo Graphix Toolbox 4.0. Ее алгоритм довольно прост: поскольку на принтере можно воспроизвести только два цвета — черный и белый, то каждый пиксел экрана проверяется на совпадение с фоном. Если цвет есть (т.е. его значение не равно фоновому), то на принтер выводится точка, если цвета нет, то точка не выводится. В процедуру CopyToPRN передаются координаты прямоугольной области экрана X1... Y2 и два цвета, принимаемые за фоновые. Один из них — действительно фон, а второй может понадобиться, если в изображении есть область иного цвета, служащая фоном для надписей или чего-либо другого.

| CRT, Printer, Graph; { используются эти модули }

| PROCEDURE CopyToPRN(X1,Y1,X2,Y2:Integer;Bk1,Bk2 : Word;

| Inverse : Boolean; Mode : Byte );

| { Mode : 1 = двойная плотность (д/п) 120 точек/дюйм } { 2 = д/п, высокая скорость 120 точек/дюйм } { 3 = четверная плотность 240 точек/дюйм } { 0, 4, 5 = 80 точек/дюйм }

| { 6 = 90 точек/дюйм }

| { Для EPSON-принтеров не из ряда FX задавать Mode=1 }

| { Inverse : если True, то фон печати будет черным }

| VAR

| ScanLine : Integer; {текущая выводимая строка печати }

| n1, n2 : Byte; {специальные значения для принтера }

Рис. 19.27

- 449 -

| { Составление байта для вывода графики на печать }

| FUNCTION ConstructByte( X,Y : Integer) : Byte;

| CONST

| Bits : Array[0..7] of Byte = ( 128,64,32,16,8,4,2,1 );

| { десятичные веса 7-го,6-го,..,0-го бита в байте }

| VAR

| P : Word; { цвет точки (пиксела) }

| CByte, Bit : Byte; { байт и номер бита в нем }

| YY : Integer; { координата текущей точки }

| BEGIN

| CByte := 0; { начальное значение байта }

| for Bit := 0 to 7 do begin { цикл: 8 точек вдоль оси Y }

| YY := Y+Bit; { координата точки по оси Y }

| Р := GetPixel(X, YY); { цвет в этой точке }

| if (YY<=Y2) and (P<>bk1) and (P<>bk2) { Если цвет видимый, }

| then Inc( CByte, Bits[Bit] ); {то запомнить точку }

| end; {for}

| ConstructByte := Cbyte { 8 битов (точек) построены }

| END;

| PROCEDURE Doline; { вывод одной строки на печать }

| VAR

| XPixel : Integer; { текущая координата точки по X }

| PrintByte : Byte; { байт, кодирующий 8 пикселов }

| BEGIN

| if Mode=1 { включение графической печати: }

| then Write( Lst, #27'L' )

| else Write( Lst, #27'*', Chr(Mode) );

| Write(Lst,Chr(n1),Chr(n2)); { посылка длины строки }

| for XPixel:=X1 to X2 do begin { цикл по строке растра }

| PrintByte := ConstructByte( XPixel, ScanLine );

| if Inverse then PrintByte:=not PrintByte; {инверсия }

| Write(Lst,Chr(PrintByte)); { печать кодового байта }

| end; {for}

| Write( Lst, #10 ) { посылка кода перевода строки }

| END;

| LABEL

| Quit; { метка выхода при нажатии Esc }

| BEGIN

| Mode := Mode mod 7; { настройка режима печати Mode: }

| if Mode in [0,5] then Mode := 4;

| Write(Lst,#27'3' #24); { межстрочный интервал 24/256 }

| n1 := Lo(Succ(X2-X1)); { Определение количества точек }

| n2 := Hi(Succ(X2-X1)); { на одной строке печати }

Рис. 19.27 (продолжение)

- 450 -

| ScaneLine := Y1; {стартовая строка растра }

| while ScanLine(Y2 do

| begin {цикл по растру экрана }

| if KeyPressed and (ReadKey=#27) {Нажата клавиша Esc? }

| then Goto Quit; {если да, то выход… }

| DoLine; {печать порции: 8 линий растра }

| Inc(ScanLine, 8) {следующая порция линий растра }

| end; {while}

| Quit: {метка выхода при нажатии Esc }

| Write(Lst, #27#2) {восстановление режима печати }

| END;

| {$I initgraf} {блок инициализации графики }

| BEGIN {ПРИМЕР ВЫЗОВА ПРОЦЕДУРЫ}

| GrInit; {инициализация графики }

| SetFillStyle(HatchFill, Blue); {установка типа заливки }

| FillEllipse(300, 100, 100, 50); {заливка области-эллипса }

| CopyToPRN(0, 0, GetMaxX, GetMaxY, Black, False, 1);

| CloseGraph {закрытие режима графики }

| END.

Рис. 19.27 (окончание)

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

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

PutPixel(x, y : Integer; Color : Word)

зажигает на экране с координатами (X, Y) пиксел цвета Color. На применении этой процедуры построен пример на рис. 19.28.

| Graph, CRT {понадобится модуль CRT }

| {$I initgraf.pas} {процедура инициализации }

| CONST

| minx = 290; miny = 70; {левый верхний угол области }

| maxx = 350; maxy = 130; {правый нижний угол области }

| Nx = Succ(maxx-minx); {ширина области в пикселах }

| Ny = Succ(maxy-miny); {высота области в пикселах }

| Npixels = Nx+Ny; {число пикселов в области }

- 451 -

| VAR

| countpixels, color : Word; {счетчик точек и их цвет }

| x, y : Integer; {координаты текущей точки }

| BEGIN

| GrInit; {инициализация графики }

| color := GetMaxColor; {цвет выводимых точек }

| countpixels := 0; {обнуление счетчика точек }

| {Повторение до тех пор, пока значение счетчика не равно }

| repeat {количеству точек в фигуре: }

| x := minx+Random(Nx); {Случайные координаты }

| y := miny+Random(Ny); {точки в прямоугольнике. }

| if GetPixel(X, Y)=Black then {Если в точке (X, Y) }

| begin {ничего нет, то }

| PutPixel(x, y, color); {подсветить ее и }

| Inc(countpixels) {увеличить счетчик. }

| end;

| until countpixels=Npixels;

| repeat until KeyPressed; {пауза до нажатия клавиши }

| {Повторение до тех пор, пока значение счетчика не станет }

| repeat {равным нулю: }

| x := minx+Random(Nx); {Случайные координаты }

| y := miny+Random(Ny); {точки в прямоугольнике. }

| if GetPixel(x, y) = color then

| begin {Если точка (X, Y) светится, }

| PutPixel(x, y, Black); {то «потушить» ее и }

| Dec(countpixels) {уменьшить счетчик. }

| end;

| until countpixels=0;

| CloseGraph {закрытие режима графики }

| END.

Рис. 19.28 (окончание)

19.6.2. Работа с фрагментами изображений

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

ImageSize(X1, Y1, X2, Y2 : Integer) : Word;

Возвращает размер памяти в байтах, необходимый для сохранения прямоугольной области экрана. Прямоугольник определяется координатами левого верхнего (X1, Y1) и правого нижнего (X2, Y2) углов. Эта функция обычно используется совместно с процедурой GetMem.

- 452 -

Записать изображение в буфер можно, используя процедуру

GetImage ( Х1, Y1, Х2, Y2 : Integer; VAR BitMap)

в которой параметры X1, Y1, X2, Y2 имеют то же значение, что и в ImageSize, а вместо бестипового параметра BitMap должна подставляться переменная-буфер, занимающая область памяти размера, необходимого для полного сохранения изображения (т.е. равного значению ImageSize). Отметим, что максимальный размер сохраняемого изображения не должен превышать 64K.

Процедура

PutImage( X1, Y1 : Integer; VAR BitMap; Mode : Word )

восстанавливает изображение из буфера BitMap в прямоугольник, левый верхний угол которого определен координатами (X, Y). Обратите внимание на то, что в отличие от процедуры GetImage здесь нужна всего одна точка. Объясняется это тем, что в структуре BitMap первые два слова (четыре байта) содержат ширину и высоту в пикселах запомненного изображения. Наиболее интересным в этой процедуре является возможность определять режим вывода изображения: можно суммировать изображение на экране и изображение в буфере, можно уничтожать изображение, находящееся в определяемой области, можно инвертировать изображение, содержащееся в буфере. Эти операции задаются параметром Mode, для которого в модуле Graph определены константы, уже названные при описании процедуры SetWriteMode. Напишем их еще раз:

CONST

CopyPut =0; { операция MOV (замещение) }

XORPut =1; { операция XOR }

ORPut = 2; { операция OR }

ANDPut = 3; { операция AND }

NOTPut = 4; { операция NOT }

В фигурных скобках написаны операторы ассемблера, которыми реализуется соответствующий алгоритм.

Например, если в режиме ORPut на малиновый цвет изображения (номер 5, двоичная запись 0101) вывести бирюзовый (номер 3, 0011) из буфера, то результирующая картинка будет светло-серого цвета (номер 7, 0111). Из этих пяти режимов самым интересным является XOR, поскольку проведенные последовательно две операции XOR с одинаковым вторым аргументом оставляют первый из них без изменений. Это свойство операции XOR и используется в тех случаях, когда необходимо изобразить некий подвижный объект на сложном

- 453 -

фоне: два раза выведя один и тот же фрагмент в одно и то же место в режиме XOR, мы оставим фон неизменным. Фактически, мы таким образом экономим память ПЭВМ — не нужен буфер для запоминания участка фона, находившегося под новой картинкой (рис. 19.29).

| Graph, CRT; { используются Graph и CRT }

| {$I initgraf.pas} { процедура инициализации }

| CONST

| r = 10; { радиус подвижного шарика }

| VAR

| X1, Y1, X2, Y2, sx, sy : Integer; { Переменные для ожи- }

| maxx, maxy, sxmove, symove: Integer; { вления фрагмента }

| Size : Word; { размер фрагмента }

| P : Pointer; { указатель на буфер }

| BEGIN

| GrInit; { инициализация графики }

| maxx := GetMaxX; { максимальное поле экрана }

| maxy := GetMaxY;

| X1 := maxx div 2 - r; { Координаты области экрана, }

| Y1 = maxy div 2 - r; {в которой будет нарисован }

| X2 = Х1 + 2*r; { шарик и которая и будет со- }

| Y2 = Y1 + 2*r; { храненным фрагментом }

| sx = Х1; sxmove := 3; { Начальная точка движения и }

| sy := Y1; symove := -1; { шаг перемещения шарика }

| SetFillStyle( SolidFill, Red ); { выбор типа заливки }

| PieSlice( X1+r,Y1+r, 0,360, r ); { рисование шарика }

| Size := ImageSize(X1,Y1,X2,Y2); { фрагмент в байтах }

| GetMem(P, Size ); { размещение буфера }

| Getlmage( Х1, Y1, Х2, Y2, P^); { фрагмент -> в буфер }

| SetFillStyle(CloseDotFill, Blue); { тип заливки фона }

| Bar( 50, 50, maxx-50, maxy-50 ); { фоновая картинка }

| repeat { Начинается движение шарика: }

| PutImage( sx, sy, P^, XORPut ); { вывод шарика }

| Delay( 12 ); { пауза для АТ/12МГц }

| Putlmage( sx, sy, P^, XORPut ); { стирание шарика }

| {ограничения на движение шарика в пределах поля фона: }

| if (sx<50) or (sx>maxx-50-2*r) then

| sxmove := -sxmove;

| if (sy<50) or (sy>maxy-50-2*r) then

| symove := -symove;

| Inc( sx, sxmove ); {Следующая точка появления }

| Inc( sy, symove ); { шарика на экране }

| until KeyPressed; { ... пока не нажата клавиша }

| FreeMem( Р, Size ); { освобождение памяти буфера }

| CloseGraph { закрытие режима графики }

| END.

Рис. 19.29

- 454 -

В приведенном примере продемонстрирован алгоритм мультипликации, применяющий «битовые» методы (используется пересылка битовых массивов процедурами GetImage и PutImage). Скорость движения картинки сильно зависит от разрешения экрана и количества цветов: наибольшая — в режиме CGA 640x200 2 цвета (1 бит на пиксел), наименьшая — в режиме VGA 320x200 256 цветов (8 бит на пиксел). Возникают также некоторые сложности с синхронизацией перемещений и частоты вертикальной развертки монитора.

Обращаем внимание на стандартную связку:

Size:= ImageSize( Х1, Y1, Х2, Y2 ); { фрагмент в байтах }

GetMem( P, Size ); { размещение буфера }

GetImage( Х1, Y1, Х2, Y2, P^ ); { фрагмент -> в буфер }

...

Putlmage( х, у, P^, xxxPut ); { вывод фрагмента(ов) }

FreeMem( P, Size); { освобождение буфера }

организующую хранение динамического фрагмента через переменную P типа Pointer. В вызовах PutImage/GetImage указатель P должен быть разыменован. Динамический буфер для фрагментов всегда предпочтительнее, поскольку сам размер фрагмента зависит от многих условий, и их трудно удовлетворить, используя для буфера статическую структуру.

19.7. Управление видеостраницами

Память видеоадаптеров разделена на так называемые страницы, или видеостраницы. По умолчанию в графическом режиме действия производятся с нулевой страницей, поэтому практически во всех предыдущих примерах было видно, как рисуются на экране фигуры. Однако, если направить вывод изображений на ненулевую страницу (при условии, что такая доступна в текущем режиме видеоадаптера — см. табл. 19.4), то на экране ничего не отобразится, поскольку по умолчанию видимой является нулевая страница. Если же после этого дать команду считать видимой «скрытую» страницу, то она появится на экране буквально мгновенно (конкретно: за один прямой проход луча в кинескопе). Проделать все это позволяют две процедуры:

SetVisualPage(Page : Word)

которая устанавливает «видимой» на экране видеостраницу номер Page, и процедура

SetActivePage( Page : Word )

- 455 -

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

На рис. 19.30 показан типичный пример использования этих процедур.

| (* Пример только для адаптеров EGA и VGA !!! *)

| USES Graph, CRT; { используется Graph и CRT }

| {$I initgraf.pas} { процедура инициализации }

| PROCEDURE Forms(kadr:Byte);

| { рисование кадров 0..3 }

| CONST

| Radius : Array [0..3] of Integer = (20, 40, 60, 80);

| VAR r, rr : Integer; { радиусы эллипсов в кадрах }

| BEGIN

| r := Radius[kadr]; { максимальный радиус }

| rr := 0; { радиус вложенного эллипса }

| repeat

| Ellipse(GetMaxX div 2,GetMaxY div 2, 0, 360, r, rr);

| Inc(rr, 5) until rr>=r;

| END;

| PROCEDURE AnimEGAVGA; { процедура смены кадров }

| CONST ms = 60; { задержка между кадрами, мс }

| VAR i : Byte; { параметр циклов смены }

| BEGIN

| Repeat { цикл до нажатия клавиши... }

| for i:=0 to 3 do

| begin

| { Смена видеостраниц: прямо }

| SetVisualPage(i); Delay( ms )

| end;

| for i:=3 downto 0 do

| begin { ... и обратно }

| SetVisualPage(i); Delay(ms)

| end;

| until KeyPressed;

| { условие окончания показа }

| END;

| VAR (* ОСНОВНАЯ ЧАСТЬ ПРИМЕРА *)

| i : Byte; { параметр (номер кадра) }

| BEGIN

| GrInit; { инициализация графики }

| SetGraphMode( EGALo ); { режим EGA, 640x200, 4 стр. }

Рис. 19.30

- 456 -

| for i:=3 downto 0 do

| begin { Цикл заполнения страниц: }

| SetVisualPage(Succ(i) mod 4);

| { Видим пустоту }

| SetActivePage(i);

| {и готовим кадр }

| Forms(i) { рисунок кадра }

| end; {for}

| AnimEGAVGA;

| { начало оживления кадров }

| CloseGraph { закрытие режима графики }

| END.

Рис. 19.30 (окончание)

Здесь показано использование процедур SetActivePage и SetVisualPage для алгоритма «кадровой» мультипликации. Особенность ее заключается в том, что все кадры (здесь их четыре) сначала записываются на соответствующие страницы, а затем производится последовательное переключение отображения страниц на дисплей процедурой SetVisualPage.

19.8. Графические окна

В системе BGI-графики вводится термин «viewport». Точного аналога этого слова в русском языке нет, если не считать заимствования «вьюпорт». Специальный словарь дает следующее разъяснение: «вьюпорт — это область просмотра, окно экрана, в компьютерной графике — часть пространства отображения, в которой изображается и просматривается часть моделируемого объекта». Мы будем использовать термин «графическое окно». При образовании графического окна получается как бы «экран в экране» заданного размера. В модуле Graph для описания графического окна объявлен следующий тип и две константы:

| TYPE

| ViewPortType = RECORD

| X1, Y1, X2,Y2 : Integer; { границы окна }

| Clip : Boolean; { режим отсечения }

| END;

| CONST

| ClipOn = True; { отсечение по границе окна включено }

| ClipOff = False; { отсечение по границе окна выключено }

Здесь первые элементы записи — это координаты прямоугольной области (графического окна), как их принято задавать, a Clip — это параметр, указывающий графической системе, что делать с изобра-

- 457 -

жением, попавшим за пределы этой области. Clip может принимать два значения. Значение ClipOn указывает на то, что все элементы изображения (например, линия line(X3, Y3, X4, Y4) на рис. 19.31) обрезаются по границам графического окна, a ClipOff указывает на то, что все рисуется без изменений, как бы «не глядя» на границы окна.

Рис. 19.31

Объявление графического окна производится процедурой

SetViewPort( Х1, Y1, Х2, Y2 : Integer; ClipMode : Boolean )

где входные параметры соответствуют полям записи типа ViewPortType. После выполнения этой процедуры все текущие установки станут относиться к окну. Текущий указатель (графический курсор) установится в его левый верхний угол, и туда же переносится начало системы координат устройства. Другими словами, мы получим локальную систему координат устройства. Если параметры процедуры заданы неправильно, то функция GraphResult возвратит ошибку grError (-11).

Назначение графического окна можно использовать для перемещения начала системы координат. Так, если задать окно вызовом

SetViewPort( GetMaxX div 2, GetMaxY div 2, GetMaxX, GetMaxY, ClipOff );

то получим систему координат с началом в центре экрана. При этом станет «видимой» адресация отрицательных координат. Графическое окно не меняет масштаба системы координат, а лишь выбирает систему отсчета адресуемых пикселов.

Для опроса текущих параметров графического окна служит процедура

GetViewSettings( VAR ViewSettings : ViewPortType )

- 458 -

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

Для очистки рабочего пространства графического окна в модуле Graph существует специальная процедура

ClearViewPort

Она работает следующим образом:

1) устанавливает цвет заполнения равным текущему цвету фонда;

2) вызывает процедуру Bar с теми же значениями координат; что и у процедуры SetViewPort, вызванной перед этим;

3) перемещает текущий указатель в точку (0, 0).

Несмотря на то, что понятие графического окна является общим для всех процедур и функций, одна процедура все же работает не по правилам: процедура PutImage в силу особенностей программной реализации работает одинаково как для значения параметра Clip, равного ClipOn, так и для ClipOff. Помните об этом, и обязательно проверяйте в программе условия помещения всего изображения в графическом окне.

19.9. Вывод текста

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

19.9.1. Выбор шрифта и стиля

В комплектах поставки пакета Турбо Паскаль, начиная с версии 4.0, есть файлы с расширением .CHR. Это набор штриховых шрифтов, которые могут быть использованы для вывода информации. Поскольку они построены не матричным способом (как сделаны стандартные шрифты для текстового режима), а векторным, становятся возможными манипуляции размерами шрифтов без потери качества их изображения.

- 459 -

Всего с пакетом Турбо Паскаль поставляется четыре шрифта (хотя можно, используя отдельный специальный пакет, самостоятельно расширить их набор). Кроме того, доступен системный матричный шрифт 8x8 для графических режимов (всегда доступны символы с ASCII-кодами от 0 до 127 и символы с кодами от 128 до 255 при условии, что их матрицы загружены в память ПЭВМ). Для обозначения этих пяти шрифтов введены константы:

CONST

DefaultFont = 0; { матричный шрифт 8x8 (по умолчанию ) }

TriplexFont = 1; { полужирный шрифт }

SmallFont = 2; { светлый шрифт (тонкое начертание) }

SansSerifFont = 3; { книжная гарнитура (рубленый шрифт) }

GothicFont = 4; { готический шрифт }

DefaultFont — это уже упоминавшийся матричный шрифт 8x8. Если не принимать никаких действий по смене шрифта, то будет принят именно он.

Активизация любого из названных шрифтов осуществляется процедурой

SetTextStyle( Font, Direction : Word; CharSize : Word )

Здесь параметр Font — номер шрифта (например, одна из описанных выше констант), Direction — расположение текста (по умолчанию принимается горизонтальное). Возможны лишь две ориентации текста, обозначенные константами:

CONST

HorizDir = 0; { горизонтальная, слева направо }

VertDir = 1; { вертикальная, снизу вверх }

При значении Direction, равном VertDir, все символы будут повернуты против часовой стрелки на 90° и выводятся снизу вверх. Однако на самом деле есть еще один вариант регулирования направления шрифтов. Если задать Direction=2, то буквы будут повернуты так же, как и при Direction=VertDir, но вывод строки будет производиться горизонтально, слева направо.

Размер каждого символа устанавливается параметром CharSize, диапазон изменения которого составляет от 1 до 10. Стандартное значение CharSize для матричного шрифта 8x8 равно единице, а для штриховых шрифтов — четырем. Однако это можно не запоминать: достаточно передать в CharSize значение 0, и шрифт будет выводиться в стандартном размере. Чтобы продемонстрировать, как влияет этот параметр на размер изображения, можно задать CharSize=2 для

- 460 -

шрифта DefaultFont, и на экран будет выведен символ в матрице 16x16. Штриховые же шрифты задаются по-другому: в некоторой единичной системе координат описывается последовательное прохождение контура, образующего символ. Поскольку координаты каждой следующей точки контура заданы относительно предыдущей, то и модификация шрифта (увеличение, расширение и т.п.) производится простым умножением этих координат на соответствующее число.

При каждом вызове процедурой SetTexStyle какого-либо шрифта он читается с диска и загружается в память. Это обстоятельство вносит некоторые сложности. Во-первых, если программа использует штриховые шрифты, необходимо, чтобы файлы соответствующих шрифтов находились в известном каталоге совместно с BGI-файлами. В противном случае, не найдя их, система будет использовать DefaultFont, т.е. матричный шрифт 8x8. Во-вторых, при быстром переключении между несколькими штриховыми шрифтами будет происходить задержка программы на время, необходимое для считывания соответствующего шрифта с диска. Это случается потому, что в рабочей памяти может храниться только один штриховый шрифт. Чтобы определить результат чтения файла шрифта с диска и загрузки его в память, можно проверить значение функции GraphResult. Перечень значений, возвращаемых ею в этом случае, приведен в табл. 19.6.

Таблица 19.6

GraphResult

Смысл значения

0

Успешное выполнение операции

-8

Файл CHR не найден

-9

Не хватает памяти для загрузки выбранного шрифта

-11

Ошибка графики

-12

Ошибка ввода-вывода

-13

Неправильное содержимое файла шрифта

-14

Неправильный номер шрифта

19.9.2. Предварительная загрузка и регистрация шрифтов

19.9.2.1. Загрузка шрифтов из пакета Турбо Паскаль. Для хранения в памяти более одного шрифта одновременно необходимо предварительно разместить их в памяти и вызвать функцию

- 461 -

RegisterBGIFont( FontPtr : Pointer ) : Integer

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

1. В динамической памяти (куче) отводится область размером с файл шрифта.

2. Файл шрифта считывается с диска и помещается в эту область.

3. Указатель на шрифт в памяти регистрируется при помощи функции RegisterBGIDriver.

Пример процедуры загрузки шрифта в память приведен на рис. 19.32. В процедуру надо передать полное имя одного из CHR-файлов и сохранить возвращаемые ею указатель на место шрифта в памяти FPtr и размер Size (это может понадобиться при удалении шрифтов из кучи процедурой FreeMem(FPtr.Size)).

| PROCEDURE LoadFont(BGIFileName: String; VAR FPtr: Pointer;

| VAR Size: Word );

| VAR

| FontFile : File;

| BEGIN

| Assign(FontFile,BGIFileName); { связь файла с диском }

| Reset( FontFile, 1 ); { чтение с начала, побайтно }

| Size:=FileSize(FontFile); { размер файла со шрифтом }

| GetMem( FPtr, Size ); { выделение участка памяти }

| BlockRead(FontFile,FPtr:,Size); { загрузка туда шрифта }

| Close( FontFile ); { закрытие файла }

| if RegisterBGIFont(FPtr) < grOK then

| begin { Если возникла ошибка, то }

| WriteLn( 'Ошибка загрузки шрифта: ', { выдать }

| GraphErrorMsg(GraphResult) ); {сообщение }

| ReadLn { пауза до нажатия ввода... }

| end {if}

| END;

Рис. 19.32

Регистрация может проводится до инициализации графики. Так, в примере на рис. 19.32 считается, что текущий режим — текстовый, и используется оператор WriteLn для выдачи аварийного сообщения. Функция RegisterBGIFont может возвращать значения ошибки (табл. 19.7).

- 462 -

Код

Обозначение ошибки

Пояснения

-11

grError

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

-13

grInvalidFont

Заголовок файла шрифта — неправильный или испорченный.

-14

grInvalidFontNum

Номер шрифта в заголовке файла шрифта — неправильный.

19.9.2.2. Регистрация новых штриховых шрифтов. Модуль Graph может поддерживать таблицу из десяти шрифтов. Однако в системе их представлено только четыре (не считая DefaultFont, который не требует загрузки), Возникает вопрос, как указать системе, что мы хотим использовать новые шрифты, не имеющие идентификаторов в системе (созданные самостоятельно или приобретенные дополнительно). Модуль Graph предоставляет и такую возможность — главное, чтобы файл шрифтов был в формате фирмы Borland. Пользуясь функцией

InstallUserFont( FontFileName : String ) : Integer;

можно установить соответствие между именем шрифтового файла (FontFileName) и его регистрационным номером в системе (возвращаемым функцией InstallUserFont). После этого можно выбрать этот шрифт процедурой SetTextStyle, указав первым параметром номер нового шрифта. Если таблица шрифтов уже вся заполнена, то функция возвращает значение 0 (DefaultFont). В общем случае, ошибка установки нового шрифта диагностируется функцией GraphResult. После установки можно обращаться с новым шрифтом как со стандартным, и в том числе загружать в память.

19.9.2.3. Загрузка матричных шрифтов 8x8. Часть матричного шрифта 8x8 (коды от 0 по 127) реализована в ПЭВМ аппаратно и всегда доступна. Другая часть (коды от 128 до 255) должна быть предварительно резидентно загружена в память ПЭВМ. Обычно это делается программами-русификаторами или утилитой MS-DOS GRAFTABL. Но можно это проделать самим, предварительно создав файл типа File of Byte из 128 матриц по восемь байтов, представля-

- 463 -

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

| USES DOS, Graph; { необходим модуль DOS }

| VAR

| OldFont8x8 : Pointer; { адрес исходного шрифта 8x8 }

| PROCEDURE LoadFont8x8(FileName: String; VAR FPtr:Pointer);

| VAR

| FontFile : File;

| BEGIN

| Assign(FontFile,FileName); { связывание файла с диском }

| Reset( FontFile, 1024 ); { чтение с начала и целиком }

| GetMem( FPtr, 1024 ); { выделение участка памяти }

| BlockRead(FontFile,FPtr^,1); { загрузка в него шрифта }

| Close( FontFile ); { закрытие файла }

| GetIntVec($1F,OldFont8x8); { запоминание старого шрифта }

| SetIntVec( $1F, FPtr ) { установка нового шрифта }

| END;

Рис. 19.33

Важно предусмотреть, чтобы перед окончанием работы программа восстанавливала адрес исходного шрифта при помощи вызова процедуры модуля DOS SetIntVec( $1F, OldFont8x8).

Описанные способы подключения к системе шрифтов имеют один общий недостаток: для того чтобы программа, использующая их, нормально работала, необходимо наличие соответствующих шрифтов в текущем или известном программе каталоге файлов. Начичие дополнительных файлов в системе снижает ее надежность, поэтому в языке Турбо Паскаль предусмотрена возможность встраивания шрифтов прямо в ЕХЕ-файл. Этот вопрос рассматривается в разделе 19.10.

19.9.3. Непосредственный вывод строк

Итак, мы выбрали шрифт. Теперь перейдем к выводу текста. Для этого есть две процедуры. Первая —

OutText( TextString : String )

выводит на графический экран строку TextString, ориентированную относительно позиции текущего указателя, а вторая

OutTextXY( x, y : Integer; TextString : String )

- 464 -

выводит строку, ориентированную относительно координат (X, Y). Шрифт предварительно может быть установлен вызовом SetTextStyle (по умолчанию принимается DefaultFont). Рассмотрим ориентировку строки относительно стартовой точки. Существует несколько вариантов ориентировки. Они задаются процедурой

SetTextJustify( Horizontal, Vertical : Word )

параметры которой могут принимать одно из трех объявленных в модуле Graph значений:

CONST

{ — Для горизонтального ориентирования (Horizontal) — }

LeftText = 0; { координата X задает левый край строки }

CenterText = 1; { координата X задает середину строки }

RightText = 2; { координата X задает правый край строки }

{ — Для вертикального ориентирования (Vertical): — }

BottomText = 0; { координата Y задает нижний край строки }

CenterText = 1; { координата Y задает середину строки }

TopText = 2; { координата Y задает верхний край }

Эта процедура позволяет ориентировать выводимую строку относительно стартовой координаты по схеме, показанной на рис. 19.34, где знак ■ символизирует координаты (X,Y). По умолчанию параметры ориентировки соответствуют LeftText, TopText.

Рис. 19.34

Отметим, что текстовые процедуры GotoXY, Write/WriteLn и установка цвета текста в графическом режиме работают только, если переменная CRT.DirectVideo равна False (или модуль CRT не подключен). Ввод текста через Read/ReadLn действует всегда. При этом текст стирает фоновое изображение (см. также гл. 22).

19.9.4. Размер букв и его масштабирование

19.9.4.1. Размер букв и строк. Всегда важно знать вертикальный и горизонтальный размер выводимой строки в пикселах. Это позволяет располагать строки пропорционально разрешающей способности графического режима, вычислять «текстовую» емкость окна и т.п. Функции

- 465 -

TextHeight( TextString : String ) : Word;

и

TextWidth( TextString : String ) : Word;

возвращают высоту и ширину строк TextString в пикселах, при условии, что они будут выведены текущим шрифтом и размером (т.е. заданными последним вызовом SetTextStyle или по умолчанию). Для штриховых шрифтов размеры букв различаются (их начертание неравномерное), и длина и высота строки в пикселах зависит не только от количества букв в ней, но и от их начертания. Пример анализа расположения строк показан на рис. 19.35, выводящем рекламную информацию.

| USES Graph; { подключен модуль Graph }

| {$I initgraf.pas) { процедура инициализации }

| CONST

| my_str = 'Turbo Pascal '; { выводимая строка текста }

| VAR

| maxx, maxy : Integer; { текущее разрешение экрана }

| tx, ty, i, j : Word; { временные переменные }

| BEGIN

| GrInit;

| maxx:=GetMaxX; maxy:=GetMaxY; { разрешение }

| SetTextJustify(CenterText, CenterText); { ориентация }

| SetTextStyle(SmallFont, HorizDir, 6); { стиль шрифта }

| tx := TextWidth(my_str); { ширина строки }

| ty := TextHeight(my_str); { высота строки }

| for j:=1 to (maxy div ty) do { цикл no оси Y }

| for i:=1 to (maxx div tx) do { цикл по оси X }

| OutTextXY( i*tx, j*ty, my_str ); { тело циклов }

| SetTextStyle(DefaultFont,HorizDir,6); { смена шрифта }

| tx := TextWidth ( 'W' ) div 6; { 1/6 ширины }

| ty := TextHeight( 'E' ) div 6; { 1/6 высоты } SetColor( LightRed );

| OutTextXY( maxx div 2 + tx, maxy div 2 + ty, my_str );

| SetColor( LightBlue );

| OutTextXY( maxx div 2, maxy div 2, my_str );

| ReadLn; { пауза до нажатия ввода }

| CloseGraph { закрытие режима графики }

| END.

Рис. 19.35

У процедуры OutTextXY есть одна особенность: выводимая текстовая строка всегда обрезается по границе графического окна. Более

- 466 -

того, если активным является матричный шрифт (DefaultFont), то «вылезающая» строка вообще не появляется на экране. Решать подобные проблемы можно, точно рассчитывая место выводимых в графике строк.

19.9.4.2. Масштабирование штриховых шрифтов. Размер букв (высота и ширина) штриховых шрифтов (и только их) может задаваться процедурой

SetUserCharSize( multX, divX, multY, divY : Word )

Она позволяет оперативно менять размер шрифта, установленный процедурой SetTextStyle. Отношение (multX/divX) задает масштабирование ширины начертания шрифта, а отношение (multY/divY) выражает масштаб изменения высоты шрифта. Например, задание параметров multX=3 и divX=1, говорит о том, что буквы выводимого шрифта будут в три раза шире нормы.

19.9.5. Опрос стиля и ориентации шрифтов

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

GetTextSettings(VAR Settings : TextSettingsType)

В параметре Settings она возвращает исчерпывающую информацию обо всем, что относится к выводу строк. Тип этого параметра предопределен в модуле Graph:

TYPE

 TextSettingsType = RECORD

Font : Word; {номер шрифта}

Direction : Word; {направление}

CharSize : Word; {размер шрифта}

Horiz : Word; {ориентация по X}

Yert : Word; {ориентация по Y}

END;

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

19.10. Включение шрифтов и драйверов в ЕХЕ-файл

Стандартный режим работы графики, при котором помимо основного ЕХЕ-файла необходимо присутствие еще одного или не-

- 467 -

скольких вспомогательных BGI- и CHR-файлов, не очень удобен. Устранение этого неудобства возможно включением содержимого этих файлов непосредственно в ЕХЕ-файл, получаемый из программы на Паскале, Для этого надо выбрать, какие драйверы и шрифты необходимы при автономной работе нашей программы (если она рассчитана на работу с одним адаптером, то достаточно одного соответствующего BGI-драйвера и шрифтов; если программа должна переноситься, то придется вставить в нее как минимум три драйвера: для CGA, EGA/VGA и Hercules).

Далее, нужно запустить утилиту BINOBJ.EXE для получения из ВGI- и (или) CHR-файла (файлов) OBJ-файла (файлов), что лучше сделать ВАТ-файлами:

drivers.bat

BINOBJ %1.BGI %1.OBJ %1DriverProc

fonts.bat

BINOBJ %1.CHR %1.OBJ %1FontProc

В этом случае можно обработать драйверы и шрифты следующим образом:

C:\TP\BGI>driver.bat CGA

C:\TP\BGI>driver.bat EGAVGA

C:\TP\BGI>driver.bat HERC

...

C:\TP\BGI>fonts.bat TRIP

C:\TP\BGI>fonts.bat SANS

...

Если желательно включить в файл и свою часть шрифта 8x8 (пусть он хранится в файле 8x8.FON), то надо выполнить команду

C:\TP\BGI>binobj 8x8.fon 8x8 Font8x8Proc

После этого можно подготовить полученные OBJ-файлы для компоновки в ЕХЕ-файл. Удобнее всего это сделать, организовав модуль, например BGI.TPU. Исходный текст его (с учетом наших предыдущих действий) приведен на рис. 19.36.

- 468 -

| UNIT BGI; { модуль с BGI-компонентами }

| INTERFACE { объявления псевдопроцедур }

| PROCEDURE CGADriverProc; { BGI-драйвер для CGA }

| PROCEDURE EGAVGADriverProc; { BGI-драйвер для EGA/VGA }

| PROCEDURE HERCDriverProc; { BGI-драйвер для Hercules }

| { ... }

| PROCEDURE TRIPFontProc; { CHR-шрифт TriplexFont }

| PROCEDURE SANSFontProc; { CHR-шрифт SansSerifFont }

| { ... }

| PROCEDURE Font8x8Proc; { матричный шрифт 8x8 }

| IMPLEMENTATION { подстыковка содержимого: }

| USES Graph, DOS;

| {$L cga.obj} PROCEDURE CGADriverProc; EXTERNAL;

| {$L egavga.obj} PROCEDURE EGAVGADriverProc; EXTERNAL;

| {$L herc.obj} PROCEDURE HERCDriverProc; EXTERNAL;

| { ... }

| {$L trip.obj} PROCEDURE TRIPFontProc; EXTERNAL;

| {$L sans.obj} PROCEDURE SANSFontProc; EXTERNAL;

| { ... }

| VAR

| OldFont8x8 : Pointer; { адрес старого шрифта 8x8 }

| {$L 8x8.obj} PROCEDURE Font8x8Proc; EXTERNAL;

| BEGIN

| if RegisterBGIDriver(@CGADriverProc)<0

| then Halt(101);

| if RegisterBGIDriver(@EGAVGADriverProc)<0

| then Halt(102);

| if RegisterBGIDriver(@HERCDriverProc)<0

| then Halt(103);

| { ... }

| if RegisterBGIFont(@TRIPDriverProc)<0 then Halt(201);

| if RegisterBGIFont(®SANSDriverProc)<0 then Halt(202);

| { ... }

| GetIntVec($1F,OldFont8x8); { старый адрес шрифта 8x8 }

| SetIntVec($1F,@Font8x8Proc) { новый адрес шрифта 8x8 }

| END.

Рис. 19.36

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

- 469 -

USES

Graph, BGI, ... ;

использовать процедуру InitGraph с третьим параметром — пустой строкой, не заботясь о наличии конкретного драйвера или шрифта на диске совместно с ЕХЕ-файлом.

19.11. Подключение новых драйверов

Из средств модуля Graph мы не рассмотрели до сих пор функцию

InstallUserDriver( DriverFileName : String;

AutoDetectPtr : Pointer ) : Integer

которая позволяет работать с самыми разными графическими контроллерами, для которых написаны специальные драйверы в стандарте BGI, а также добавлять новые драйверы. Однако для этого надо сначала написать этот драйвер. Такая задача достаточно сложна, требует специальных знаний в области аппаратного обеспечения ПЭВМ и стандартов BGI, и поэтому описание ее решения выходит за рамки нашей книги. Если же имеется какой-либо дополнительный BGI-драйвер (например, отладочный), то его можно использовать, подключив функцией InstallUserDriver. Первый параметр — это имя файла, содержащего драйвер, второй — адрес функции без параметров, опрашивающей аппаратную часть и возвращающей значение типа Integer. Отрицательное значение функции должно означать ошибку, неотрицательное — номер режима работы по умолчанию. Сама функция должна компилироваться в режиме {$F+}, Функция InstallUserDriver вернет либо отрицательный код ошибки, либо номер установленного драйвера, который затем нужно передать на первом месте процедуре инициализации InitGraph. Пример таких действий имеется в контекстной подсказке системы программирования.

19.12. Один полезный совет

В заключение хотим дать один небольшой, но важный совет. Следование ему даст возможность создавать действительно переносимые графические программы. Суть совета в следующем: никогда не опирайтесь в программах на постоянные значение координат графических изображений. Вместо этого всегда старайтесь все координаты задавать как отношение к максимальному разрешению в текущем режиме. Например, работая на VGA(640 x 480), ВЫ поместили какую-либо надпись в центр экрана:

- 470 -

OutTextXY(320, 240, 'Плохо!..');

Если эта программа может работать с адаптером CGA (640 x 200), то надпись просто «уйдет» за кадр. Переносимость же, как известно, подразумевает нечто иное.

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

OutTextXY(GetMaxX div 2, GetMaxY div 2, 'Хорошо!!!..');

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

Часть V. Практические приемы работы с ПЭВМ

Глава 20. Профессиональная работа с текстовыми изображениями

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

Обо все этом и пойдет речь ниже. Правда, должны сразу же оговориться, что такие операции приходится выполнять «грязными» руками: использовать специфические особенности ОС и архитектуры ПЭВМ. Плата за это – практическая непереносимость программ на другие ЭВМ и в другие ОС. Но так как парк IBM-совместимых ПЭВМ постоянно растет, то особой беды в непереносимости нет.

20.1. Программный опрос режимов текстового дисплея

Начнем с рассмотрения видеопамяти. Известно, что она располагается в адресах памяти ПЭВМ от $А000:$0000 до $BFFF:$0000. Непосредственно интересующая нас память текстового изображения находится «где-то» в этом диапазоне.

Определение начала видеопамяти текстового изображения — весьма важная и нужная задача. Монохромные режимы используют ячейки памяти, начиная с $В000:0000, а цветные — с $В800:0000. Хорошая программа должна сама определять, с каким режимом она

- 472 -

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

файл GET_PTR.INC

| { Функция возвращает адрес видеопамяти в режиме текста }

| FUNCTION GetScreenPtr : Pointer;

| BEGIN

| if ( Mem[0:$0410] and $30 ) = $30

| then GetScreenPtr := Ptr($B000,0) { режим MONO }

| else GetScreenPtr := Ptr($B800,0) { цветной режим }

| END;

Рис. 20.1

Рассмотренная функция работает практически со всеми стандартными видеоадаптерами в режимах с разрешениями 80 или 40 столбцов на 25, 43 или 50 строк.

Реальный размер используемой видеопамяти зависит от режима работы. Минимальное значение его (при режиме 40 столбцов на 25 строк) равно 40x15x2 = 2000 байт. Максимальный из стандартных режимов размер для адаптера VGA в режиме 80x50 равен 8000 байт.

Определение текущего режима есть, по сути, задача опроса фиксированных адресов памяти, где хранятся сведения по конфигурации. Тип адаптера определяет минимальное число столбцов (80 или 40) и максимальное число строк (25, 43 или 50) на текстовом экране. Варианты возможных режимов сведены в табл. 20.1.

Таблица 20.1

25

43

50

40

Все, кроме MDA

EGA, VGA

VGA

80

Все

EGA, VGA

VGA

При работе с адаптером VGA и программами русификации ПЭВМ режим 80x50 может быть включен только, если загружены

- 473 -

шрифты форматов 8x16 и 8x8. Если же в ПЭВМ загружен шрифт 8x14, то будет включаться режим 80 столбцов на 43 строки.

Некоторые адаптеры (VGA, UltraEGA, SuperEGA и т.п.) могут использовать и другие режимы, но они не являются стандартными и не рассматриваются в этой книге.

Можно легко получить номер текущего текстового режима. Он всегда содержится в переменной модуля CRT LastMode, имеющей тип Word. Младший байт LastMode содержит номер режима (см. табл. 15.6), а нулевой бит старшего байта содержит признак режима в 43 или 50 строк (десятичное число 256 — константа Font8x8). Используя эту переменную, легко построить две функции опроса видеорежимов (рис. 20.2).

файл GET_PAR.INC

| { Функция возвращает номер текущего режима }

| FUNCTION CurrentMode: Byte;

| BEGIN

| CurrentMode := Lo( LastMode )

| END;

| { Функция возвращает True, если включен режим Font8x8 }

| FUNCTION Font8x8YES : Boolean;

| BEGIN

| Font8x8YES := ( LastMode and Font8x8 ) = Font8x8

| END;

| {Функция возвращает длину видеопамяти в режиме текста }

| FUNCTION GetScreenSize : Word;

| VAR

| R : Byte absolute $0000:$0484;

| С : Byte absolute $0000:$044A;

| BEGIN

| if Hi( LastMode ) = 1

| then GetScreenSize := Succ( R )*С*2

| else GetScreenSize := 25*С*2;

| END;

| { Функция возвращает число столбцов - 40 или 80 }

| FUNCTION GetColNum : Byte;

| BEGIN GetColNum := Mem[0:$44A] END;

| { Функция возвращает число строк - 25,43 или 50 }

| FUNCTION GetRowNum : Byte;

| BEGIN

| GetRowNum := GetScreenSize div GetColNum div 2

| END;

Рис. 20.2

- 474 -

Сложнее получить информацию о текущем количестве столбцов и строк на экране и размер видеопамяти, поскольку эти числа зависят не только от режимов, но и от типа адаптера. На рис. 20.2 предлагается библиотека процедур и функций опроса видеорежимов. В большинстве примеров применяются опросы специальных адресов системной памяти IBM-совместимых ПЭВМ. Пример обращения к этим функциям приведен на рис. 20.3.

| USES CRT; { ДЕМОНСТРАЦИЯ АНАЛИЗА ВИДЕОРЕЖИМА (ТЕКСТ) }

| {$I get_ptr.inc} { функция GetScreenPtr (см. рис. 20.1) }

| {$I get_par.inc) { функции анализа режима с рис. 20.2 }

| VAR

| P : Pointer;

| BEGIN

| P := GetScreenPtr; { P^ - Начало видеопамяти }

| if Seg(P^)=$B000 then TextMode(Mono)

| else TextMode( C040);

| WriteLn('Старт видеопамяти: ', Seg(P^), ':', Ofs(P^) );

| WriteLn('Длина видеопамяти: ', GetScreenSize,' Байт' );

| WriteLn('Емкость экрана : ', GetColNum, 'x', GetRowNum);

| WriteLn; Write( 'Нажмите Enter...');

| ReadLn { пауза до нажатия ввода }

| END.

Рис. 20.3

20.2. Организация доступа к видеопамяти

Структура видеопамяти проста. Видимые строки экрана хранятся последовательно, выстраиваясь в цепочку от стартового адреса видеопамяти. Единственная сложность в том, что один символ на экране занимает два байта в памяти: первый байт содержит его ASCII-код, а второй — его цветовой атрибут (значение TextAttr для этого символа). Поэтому все четные адреса видеопамяти, начиная с нуля, содержат символы, а нечетные — их цвета.

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

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

- 475 -

| TYPE

| VideoWord = RECORD { Пара байтов: }

| Symbol : Char; { символ, }

| Attrib : Byte { его цвет. }

| END;

| TYPE

| VideoText = Array [1..50*80] of VideoWord;

| { Максимальный размер экрана - 80x50 }

| { MDA —> 80x25; }

| { CGA --> 80x25 и 40x25; }

| { EGA --> 40x25, 80x25, 40x43 и 80x43; }

| { VGA —> 40x25, 80x25, 40x50 и 80x50. }

| VideoTextPtr = ^VideoText;

| { ссылка на образ экрана в памяти ПЭВМ }

Рис. 20.4

Размер массива VideoText определяется максимальной емкостью экрана 80x50 для адаптера VGA. Все менее емкие режимы вполне уместятся в этой структуре. Непосредственное обращение к видеопамяти производится через динамическую переменную типа «ссылка на структуру VideoText». В процедурах на рис. 20.5 такая переменная обозначена именем VT. Инициализация динамической переменной производится без вызовов процедур New или GetMem. Вместо того ей просто присваивается адрес начала видеопамяти и тем самым устанавливается, что ссылки на элементы структуры VT^ будут соответствовать ячейкам видеопамяти.

Если известно текущее число столбцов M, то преобразование двумерных координат X и Y в номер i элемента массива V^[i] поизводится по формуле

i := М*(Y-1) + X

Используя это соотношение, можно считать или записать пару символ-атрибут» в любое место видеопамяти, задавая координаты символа обычным способом через X и Y.

На рис. 20.5 приводятся две процедуры. Одна из них, FillArea, записывает прямо в видеопамять постоянную пару значений типа VideoWord, тем самым максимально быстро заполняя заданную прямоугольную область на экране. Вторая процедура, ChangeAttr, меняет цвет любой прямоугольной области экрана, задаваемой координатами X1, Y1, X2, Y2. Ее действие таково: сначала в данной координате считывается код находящегося там символа, а после этого

- 476 -

пара «символ-атрибут» с предварительно измененным атрибутом цвета записывается на то же место в структуре видеопамяти.

Процедуры работают во всех текстовых режимах, но не содержат в себе контроля корректности координат области (см. рис. 20.5). Параметр VT в процедурах — это ссылка на начало экранной памяти, на которую наложена структура VideoText. Цвет символов задается параметром Attr так же, как переменная TextAttr.

| USES CRT;

| TYPE

| VideoWord = RECORD { Пара байтов: }

| Symbol : Char; { символ, }

| Attrib : Byte { его цвет. }

| END;

| VideoText = Array [1..50*80] of VideoWord;

| { Максимальный размер экрана - 80x50 символов. }

| VideoTextPtr = ^VideoText;

| { ссылка на образ экрана в памяти ПЭВМ }

| { Процедура закраски области экрана символом Ch }

| PROCEDURE FillArea(VT : VideoTextPtr;X1,Y1,X2,Y2 : Byte;

| Ch : Char; Attr : Byte);

| VAR

| i, j, k : Word; { счетчики циклов и пр. }

| BuffWord : VideoWord; { символ и его атрибут }

| M : Byte absolute 0:$44А; { текущее число столбцов }

| BEGIN

| with BuffWord do begin

| { определение символа }

| Symbol := Ch;

| Attrib := Attr

| end;

| for j:=Y1 to Y2 do begin { Запись в видеопамять }

| k := M*(j-1); { символов Ch в цвете Attr }

| for i:=X1 to X2 do

| VT^[k+i] := BuffWord;

| end; {for j}

| END;

| { Процедура смены цвета прямоугольной области экрана }

| PROCEDURE ChangeAttr( VT : VideoTextPtr; X1,Y1,X2,Y2,

| Attr : Byte );

| VAR

| VW : VideoWord; { один символ и его цвет }

Рис. 20.5

- 477 -

| i, j, k, n : Word; M : Byte absolute 0:$44A; { число столбцов }

| BEGIN

| VW.Attrib := Attr;

| { запись нового цвета }

| for j:=Y1 to Y2 do

| begin { цикл обновления цвета }

| k :=M*(j-1);

| for i:=X1 to X2 do

| begin n :=k+i; { индекс доступа }

| VW.Symbol := VT^[n].Symbol;

| { запоминание символа }

| VT[n] := VW { вывод его в новом цвете}

| end {for i}

| end {for j}

| END;

| {$I get_ptr.inc}

| { функция GetScreenPtr (см. рис. 20.1) }

| VAR V : Pointer; { основной блок примера }

| BEGIN V := GetScreenPtr; { адрес видеопамяти }

| if Seg( V^ )=$8000

| then TextMode( Mono )

| else TextMode( C080);

| Write( 'Нажимайте клавишу ввода ...' );

| ReadLn;

| FillArea( V, 2, 2, 80, 25, #177, White );

| { Весь экран (режим С080) закрашивается сим- }

| { волом 177 белого цвета. }

| ReadLn; FillArea( V, 5, 5, 40, 20, #176, Blue+16*lightGray );

| { Область закрашивается символом 176, цвет - }

| { синий по белому. }

| ReadLn;

| ChangeAttr( V, 5, 5, 40, 20, Yellow+16*Red );

| { Область меняет цвет на желтый по красному. }

| ReadLn;

| ChangeAttr( V, 25, 15, 75, 24, Green+16*Cyan );

| { Область меняет цвет на зеленый по голубому.}

| ReadLn;

| { пауза до нажатия ввода }

| ClrScr { очистка экрана }

| END.

Рис. 20.5 (окончание)

В качестве входного параметра процедуры используют параметр VT, совместимый по типу со значениями типа Pointer. Такой подход предоставляет еще большие возможности. Так, можно передавать адрес различных видеостраниц (если адаптер ПЭВМ их

- 478 -

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

Подобные действия с видеопамятью используются при организации накладывающихся окон. Перед созданием окна весь экран или его часть сохраняется (запоминается вся структура или подынтервалы из нее), а после уничтожения окна восстанавливается вновь. Стандартная процедура Window всегда уничтожает изображение «под окном».

20.3. Запомнинание окон экрана и их восстановление

20.3.1. Общие принципы работы с окном

Введенные выше типы структур для обращения к видеопамяти можно с успехом использовать для работы с произвольными областями экрана — окнами. Единственное, что потребуется — это, чтобы окно имело прямоугольную форму. В таком случае надо обрабатывать (считывать, запоминать, заполнять) не всю последовательность ячеек видеопамяти, а набор фрагментов, каждый из которых представляет собой одну строку окна. Число таких фрагментов равно числу строк в окне. Длина каждого фрагмента равна ширине окна. Начало первого фрагмента в структуре видеопамяти (Start) для окна, заданного координатами X1, Y1, X2, Y2, можно вычислить по формуле:

Start * M*( Y1 - 1 ) +X1,

где M — число столбцов для текущего текстового режима. Начало каждого последующего фрагмента получается добавлением числа M к началу предыдущего. Ширина окна (Width), она же длина одного фрагмента, определяется очевидным образом:

Width = ( Х2 - Х1 ) + 1

а число фрагментов (Height) находится как

Height = ( Y2 - Y1 ) + 1.

Для того чтобы запомнить (сохранить) все окно, потребуется область памяти размером

Size = Width * Height * 2,

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

20.3.2. Модуль Win

В архиве DEMOS.ARC пакета Турбо Паскаль имеются исходные тексты модуля Win, базирующегося на модуле CRT и реализующего простейшие действия с текстовыми окнами. Большинство его процедур написано на ассемблере, что обеспечивает высокую скорость выполнения. В модуле вводятся три новых типа и две константы для рисования рамок вокруг окна (рис. 20.6):

| TYPE

| TitleStr=string[63]; { заголовок окна }

| FrameChars=Array[1..8] of Char; { символы рамки }

| WinState = RECORD { параметры окна: }

| WindMin,WindMax : Word; { координаты окна }

| WhareX, WhereY : Byte; { положение курсора}

| TextAttr : Byte; { цветовой атрибут } END;

| CONST

| SingilFrame : FrameChars='┌┐ ││└└'; { одинарная paмкa }

| DoubleFrame : FrameChars='╔╗║║╚╝'; { двойная рамка }

Рис. 20.6

20.3.2.1. Задание окна. Поскольку модуль Win базируется на модуле CRT, задание окна по-прежнему производится процедурой Window (или, точнее, CRT.Window). По умолчанию считается, что окно соответствует всему экрану. По-прежнему активным может быть только одно окно — текущее.

20.3.2.2. Вывод строк в окна. В модуле Win реализована пара процедур для вывода символов и строк в окно. Процедура

WriteStr( X,Y : Byte; S : String; Attr : Byte )

выводит строку S, а процедура

WriteChar( X,Y, Count : Byte; Ch : Char; Attr : Byte )

выводит Count символов, заданных параметром Ch. В обоих процедурах параметры X и Y обозначают начало выводимой информации в оконных координатах, a Attr задает значение для TextAttr при выводе. Отличие этих процедур от Write и WriteLn в том, что при выходе за границы окна не происходит прокрутки изображения или переноса строк. Лишние символы просто «обрезаются» по рамке окна.

- 480 -

20.3.2.3. Оформление окон. В модуле Win имеется процедура для заполнения текущего окна символом Ch при цветовом атрибуте Attr:

FillWin(Ch :Char; Attr : Byte);

Ее можно вызывать вместо процедуры очистки окна ClrScr.

После задания окна процедурой Window его можно взять в рамку с помощью процедуры

FrameWin(Title : TitleStr; VAR Frame : FrameChars;

TAttr, FAttr : Byte),

где Title — строка-заголовок окна, Frame — набор символов, составляющих рамку (сюда можно подставлять константы SingleFrame и DoubleFrame), а TAttr и FAttr — цветовые атрибуты заголовка и рамки соответственно. Рамка выводится по периметру окна, не выходя за его пределы. Поэтому после обрамления размеры самого окна уменьшаются на единицу со всех сторон. Очистка окна при выводе рамки не осуществляется.

Отмена рамки для текущего окна производится процедурой UnFrameWin. Она просто восстанавливает размеры окна, которые были до взятия его в рамку (увеличивает их на единицу со всех сторон). Рамка при этом не стирается и может быть удалена только командой очистки всего окна (ClrScr или FillWin). Применение процедуры UnFrameWin к окну, не имеющему рамки, равносильно увеличению его размеров.

20.3.2.4. Сохранение параметров окна. При открытии (задании) нового окна на экране можно сохранять все параметры предыдущего окна. Это делается процедурой модуля Win

SaveWin(VAR W : WinState),

присваивающая текущим параметрам окна значения, сохраненные в переменной W типа WinState параметрами текущего окна. При восстановлении изображения окна на экране (об этом ниже) можно также «вспомнить», где стоял курсор и каким цветом выводился текст. Для этого предусмотрена процедура

RestoreWin(Var W : WinState),

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

20.3.2.5. Сохранение содержимого окна. При построении накладывающихся окон необходимо запоминать содержимое «нижних» окон и восстанавливать его после снятия с экрана «верхних». Эти действия реализованы одной функцией и двумя процедурами модуля Win:

- 481 -

WinSize : Word;

ReadWin( VAR Buf );

WriteWin( VAR Buf ).

Функция WinSize возвращает количество байтов, необходимое для запоминания содержимого текущего окна. Процедура ReadWin записывает в бестиповую переменную Buf изображение из текущего окна. Другая процедура, WriteWin, выводит в текущее окно изображение, сохраненное ранее в переменной Buf. Размер переменной Buf, передаваемой в процедуры, должен быть не менее, чем значение WinSize.

Важно, что само изображение не содержит указаний на размеры «своего» окна и его расположение. Поэтому для вывода сохраненного окна на экран надо сначала восстановить его параметры процедурой RestoreWin и лишь затем вызывать процедуру WriteWin.

На рис. 20.7 приводятся процедуры для задания на экране системы накладывающихся окон. Вся информация об окне содержится в переменных типа WindowType. Для введения окна в обращение надо однократно вызвать процедуру OpenWin. Далее окно можно «заморозить» процедурой FreezeWin (что сделает активным предыдущее окно) и вновь сделать активным с помощью процедуры ActivateWin. Изъятие окна из обращения производится процедурой CloseWin.

| { ПРОЦЕДУРЫ ДЛЯ РАБОТЫ С ОКНАМИ НА ЭКРАНЕ }

| CRT, Win; { подключены модули CRT и Win }

| TYPE

| WindowType = RECORD { тип для ведения системы окон: }

| Size : Word; { объем памяти для окна в байтах }

| Frame : 0..2; { шифр типа рамки (0, если нет) }

| BufSave : Pointer; { адрес изображения под окном }

| BufWin : Pointer; { адрес изображения в окне }

| StateSave : WinState; { состояние до открытия окна }

| StateWin : WinState; { состояние при закрытии окна }

| END;

| {Процедура открывает окно и делает его текущим. }

| PROCEDURE OpenWin(X1,Y1,X2,Y2: Byte;T: TitleStr;

| TAttr, FAttr, FrameSort: Byte; VAR W : WindowType );

| BEGIN

| with W do begin

| SaveWin( StateSave ); { сохранение исходного состояния }

Рис. 20.7

- 482 -

| Window(X1,Y1, X2,Y2);

| { объявление нового текущего окна }

| Frame := FrameSort;

| { запоминание типа рамки }

| Size := WinSize;

| { запоминание объема окна }

| GetMem(BufSave,Size);

| { память для картинки фона }

| ReadWin( BufSave^);

| { сохранение картинки фона }

| case FrameSort of { взятие текущего окна в рамку }

| 1 : FrameWin(T,SingleFrame,TAttr,FAttr); { простая }

| 2 : FrameWin(T,DoubleFrame,TAttr,FAttr ); { двойная }

| end; {case}

| ClrScr; { очистка нового текущего окна }

| SaveWin( StateWin );

| { сохранение этого состояния окна }

| if Frame<>0 then UnFrameWin;

| {если есть рамка, то снять }

| GetMem(BufWin,Size);

| { память для картинки окна }

| ReadWin( BufWin^ );

| { сохранение картинки окна }

| RestoreWin(StateWin) { восстановление рамки окна }

| end (with}

| END;

| { Процедура делает окно W активным (текущим). }

| PROCEDURE ActivateWin( VAR W : WindowType );

| BEGIN

| with W do

| begin

| RestoreWin( StateWin );

| { восстановление параметров }

| if Frame <> 0 then UnFrameWin;

| {если есть рамка,то снять }

| WriteWin( BufWin^ );

| { восстановление картинки окна }

| RestoreWin(StateWin)

| { восстановление снятой рамки }

| end

| END;

| { Процедура делает окно W неактивным и стирает его, }

| { если параметр Erase равен True. }

| PROCEDURE FreezeWin(VAR W: WindowType; Erase: Boolean);

| BEGIN

| with W do

| begin

| SaveWin( StateWin );

| { сохранение состояния окна }

| if Frame<>0 then UnFrameWin;

| {если есть рамка, то снять }

| ReadWin( BufWin^);

| { сохранение картинки окна }

| GotoXY(1,1);

| if Erase then

| { Если надо стереть окно, то }

| WriteWin(BufSave^);

| { восстановить картинку фона }

| RestoreWin(StateSave)

| { в предыдущее состояние }

| end {with}

| END;

Рис. 20.7 (продолжение)

- 483 -

| { Процедура закрывает (уничтожает) окно W. }

| PROCEDURE CloseWin( VAR W : WindowType );

| BEGIN

| with W do begin

| RestoreWin(StateWin); { окно W становится текущим }

| if Frame <> 0 then UnFrameWin; {если есть рамка, то снять }

| GotoXY( 1,1 );

| WriteWin(BufSave^); {восстановление картинки фона }

| RestoreWin(StateSave); {восстановление состояния фона }

| FreeMem(BufSave,Size); {удаление картинки фона }

| FreeMem(BufWin,Size) {удаление картинки окна }

| end {with}

| END;

| { -- ПРИМЕР ВЫЗОВОВ ПРОЦЕДУР —- }

| VAR

| WW : Array [1..4] of WindowType; { массив окон }

| i,k : Byte; { счетчики циклов }

| BEGIN

| FillWin{ #176, Cyan ); { закраска экрана }

| GotoXY( 1,1 );

| Write( 'Нажимайте клавишу ввода..,' );

| for k:=1 to 4 do begin

| OpenWin(10*k,2*k, 20*k, 4*k,'окно', { Открытие окон и }

| Black+k, Blue+k, k mod 3, WW[k]); { вывод в них: }

| TextAttr := 16*k + ( White-k );

| for i:=32 to 127 do begin

| Write( Chr(i) ); Delay(20)

| end;

| FreezeWin( WW[k], False ); { отмена активности }

| Delay( 200 ) { просто пауза 0.2с }

| end;

| ReadLn;

| for k:=4 downto 1 do begin

| ActivateWin( WW[k] ); { включение окна }

| for i:=128 to 255 do begin

| Write( Chr(i) ); Delay(20)

| end;

| FreezeWin( WW[k], False ); { отмена активности }

| Delay( 200 ) { просто пауза 0.2с }

| end;

| ReadLn; { стирание окон: }

| for k:=4 downto 1 do

| begin CloseWin(WW[k]); Delay(200) end;

| ReadLn

| END.

Рис. 20.7 (окончание)

- 484 -

Используя приведенные процедуры как базовые, можно построить более высокоуровневые процедуры работы с окнами. Мы же здесь хотели лишний раз показать, что грозно звучащие операции типа «сохранение окон» на деле вовсе не так сложны.

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

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

20.4. Работа с образом экрана на диске

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

| USES CRT; { ДЕМОНСТРАЦИЯ ЗАПИСИ /ЧТЕНИЯ ЭКРАНА С ДИСКА }

| {$I get_ptr.inc} {функция GetScreenPtr (см. рис. 20.1) }

| {I get_par.inc) (функция GetScreenSize (см. рис. 20.2) }

| { Процедура сохранения текущего текст-экрана на диске }

| PROCEDURE SaveCurrentScreenOnDisk(FileName : String );

| VAR

| f : File; { бестиповый файл }

| Res : Word; { контрольное число }

| BEGIN

| Assign(f, FileName ); { файл открывается }

| Rewrite(f, GetScreenSize ); { буфер равен экрану }

| { Запись всего экрана как блока по адресу видеопамяти: }

| BlockWrite(f, GetScreenPtr^, 1, Res );

| if Res<> 1 { контроль записи }

| then Writeln(^G 'Сбой при записи'^G);

| Close(f) { закрытие файла }

| END.

Рис. 20.8

- 485 -

| { Процедура считывания текст-экрана с диска на экран. }

| { !!! Процедура не проверяет совпадение режимов }

| { записанного в файле экрана и текущего !!! }

| PROCEDURE LoadScreenFromDisk( FileName : String );

| VAR

| f : File; { бестиповый файл }

| FSize.Res : Word; { размер и контроль }

| BEGIN

| Assign( f, FileName ); { открытие файла }

| Reset( f, 40);

| {Размер буфера чтения 40 - это наименьший общий делитель для размеров видеопамяти в различных текстовых режимах. }

| FSize := FileSize( f ); { число буферов в файле }

| { Чтение всего экрана в ОЗУ по адресу видеопамяти: }

| BlockRead( f, GetScreenPtr^, Fsize, Res);

| if Res<>Fsize { контроль чтения файла }

| then WriteLn( ^G 'Сбой при чтении' ^G };

| Close( f ) { закрытие файла f }

| END;

| VAR { — ОСНОВНАЯ ЧАСТЬ (ПРИМЕР) — }

| j : Byte; с : Char;

| BEGIN

| ClrScr; GotoXY( 1, 5 );

| for c:='A' to 'Я' do { Заполнение экрана: }

| for j:=1 to 40 do begin

| TextAttr := j ; Write( с )

| end; {for for}

| TextAttr := White + 18 * Black;

| SaveCurrentScreenOnDisk('SCREEN.SCN'); {запись на диск }

| Delay(2000); { пауза 2 с }

| ClrScr; { очистка экрана }

| Delay(1000); { пауза 1 с }

| LoadScreenFromDisk( 'SCREEN.SCN' ); { чтение с диска }

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 20.8 (окончание)

Рассмотренный пример вполне работоспособен, но имеет один достаток: «готовый» экран находится вне рабочего файла. При создании ЕХЕ-файла это может стать неудобным. Существует возможность включать текстовые изображения непосредственно в ЕХЕ-файл. Для этого надо использовать утилиту BINOBJ.EXE из пакета Турбо Паскаль для преобразования файла с изображением в OBJ-файл:

- 486 -

C:\TP> BINOBJ SCREEN.SCN SCREEN.OBJ EXTSCREEN

Первый параметр — исходный файл, второй — имя OBJ-файла, а третий — имя, по которому будет происходить обращение к экрану в программе.

После этого программа должна быть изменена, как на рис. 20.9.

| { ДЕМОНСТРАЦИЯ ВСТАВКИ ГОТОВОГО ЭКРАНА В ПРОГРАММУ }

| USES CRT;

| {$1 get_ptr.inc} { функция GetScreenPtr (см. рис. 20.1)}

| {$1 get_par.inc} { функция GetScreenSize (см. рис. 20.2)}

| {$L screen.obj} { включение OBJ -файла }

| PROCEDURE ExtScreen; EXTERNAL; { в оболочку процедуры }

| { -- ОСНОВНАЯ ЧАСТЬ — }

| BEGIN

| Move( @ExtScreen^, GetScreenPtr^, GetScreenSize );

| { Содержимое процедуры-экрана копируется в видеопамять.}

| { Размер экрана равен текущему. Проверка размера файла-}

| { экрана на соответствие текущему не производится. }

| ReadLn { пауза до нажатия ввода }

| END.

Рис. 20.9

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

20.5. Крупные надписи на экране

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

Различные видеоадаптеры содержат и поддерживают шрифты различного качества (разрешения). Самые простые состоят из матрицы 8x8 точек изображения, более качественные имеют большие матрицы — 14x8, 16x8 и др. Тем не менее практически во всех IBM-совместимых ПЭВМ присутствует шрифт 8x8.

Каждый символ шрифта 8x8 закодирован в виде восьми последовательных байтов. Первый байт соответствует двоичной кодировке

- 487 -

первой строки матрицы, восьмой — последней. Пример кодировки символа «+» приведен на рис. 20.10.

Рис. 20.10

Эту матрицу несложно воспроизвести на экране, если вместо нулей ставить пробелы, а вместо единиц — символы заполнения (решетки, звездочки и т.п.). Достаточно только знать, где лежат 8-байтовые матрицы шрифта. Ответ на этот вопрос прост лишь для той половины таблицы матриц символов, которая хранит символы от 0-го до 127-го. Для нее адрес матриц 8x8 всегда одинаков и равен $F000:$F0A6. Это число стабильно и реализуется аппаратно. Хуже дело со второй половиной таблицы — с матрицами символов от 128-го до 255-го. Именно там расположены знаки псевдографики и русский алфавит. На начало этой таблицы показывает системный вектор с номером $1F, и с помощью процедуры GetIntVec, рассмотренной в описании модуля DOS, можно получить адрес первого из 128 наборов по 8 байт второй части таблицы. Но этого мало. Надо убедиться, что таблица кодов со 128-го по 255-й загружена в память. Обычно их загрузку в память машины делает утилита MS-DOS GRAFTABL.COM, но она загружает «фабричные» символы. При программной русификации ПЭВМ такую таблицу должен загрузить драйвер русского алфавита. Но ему тоже надо указать, чтобы среди прочих грузился и шрифт 8x8. Например, адаптер EGA поддерживает два набора шрифтов (8x8 и 8x14), хотя в основном показывает на экране лишь второй! Если вторая половина шрифта не загружена, то вектор $1F будет указывать на адрес $F000:$0000. Если же она на месте, то вектор будет указывать на любой другой адрес, отличный от $F000:$0000.

- 488 -

Изображение увеличенных матриц символов на экране может быть получено множеством способов. Один из них предложен на рис. 20.11. Мы советуем внимательно изучить его, ибо ряд примененных приемов является достаточно универсальным. Так, массив можно наложить на область памяти через директиву absolute, причем использовать переменное значение адреса.

| PROGRAM Big_Chars; { ДЕМОНСТРАЦИЯ БОЛЬШИХ БУКВ }

| USES

| CRT, DOS; { подключены модули CRT и DOS }

{ Процедура рисует символ с кодом CharToPrint в квадрате размером 8x8 позиций. На экране этот квадрат имеет координаты нижнего левого угла, равные (Col, Row-1).

Символ заполняется образом CharToFill. Переменная AddrOfTable_2 должна иметь значение адреса второй половины таблицы символов (со 128-го по 255-й). }

| PROCEDURE WriteChar( Col, Row, CharToPrint : Byte;

| CharToFill : Char; VAR AddrOfTable_2 );

| TYPE

| CharDim = Array[1..8] of Byte; {структура символа }

| TableDim = Array[0..127] of CharDim; {половина таблицы }

| VAR

| X, Y :Byte;

| Table_1:TableDim absolute $F000:$FA6E; {1-я половина }

| Table_2:TableDim absolute AddrOfTable_2; {2-я половина }

| Pattern : CharDim; {один символ }

| BEGIN

| case CharToPrint of

| 000..127 : Pattern := Table 1[ CharToPrint ];

| 128..255 : Pattern := Table_2[ CharToPrint-128 ]

| end; {case}

| Inc(Col,7 ); { настройка положения }

| Dec( Row,8 );

| for X:=1 to 8 do

{ анализ матрицы символа }

| for Y:=7 downto 0 do begin { и его вывод на экран }

| GotoXY( Col-Y, Row+X );

| if (Odd(Pattern[X] SHR Y)) then

| Write( CharToFill )

| end { for.. for..}

| END;

Рис. 20.11

- 489 -

{ Процедура рисует большими буквами строку S (длиной не более 9 символов) с позиции ( X,Y ). Буквы закрашиваются символом C, а сдвинутая тень букв - символом Т.}

| PROCEDURE WriteLargeString(X,Y:Byte;C,T:Char;S:String);

| VAR

| i : Byte;

| Del: ShortInt;

| P : Pointer; { адрес второй половины таблицы символов }

| BEGIN

| Inc( Y ); { надо опустить Y из-за наличия тени }

| GetIntVec($1F, P ); { Р = адрес 2-й таблицы }

| if Y < 9 then

| Y := 9; { два ограничения no Y }

| if Y > Hi(WindMax) then

| Y:=Hi(WindMax)-H;

| i := Lo(WindMax)-Lo(WindMin)+1; { ширина текущего окна }

| repeat { Цикл отрывает сим- }

| Del := i-(8*length( S )+X-1); { волы с конца S, пока }

| if Del<0 { разность длин окна и }

| then Delete(S, Length(S), 1);

| { надписи Del не станет }

| until Del>=0; { неотрицательной. }

| for i:=1 to

| Length( S ) do { печать S no буквам }

| begin

| WriteChar(X+(i*8-7), Y, Ord(S[i]), T, P^); { тень }

| WriteChar(X+(i*8-8), Y-1, Ord(S[i]), C, P^) { буква }

| end

| END;

| BEGIN { -— ОСНОВНАЯ ЧАСТЬ -— }

| TextBackGround(Red); ClrScr; { очистка экрана }

| TextColor(Yellow); { выбор цветов для букв }

| TextBackGround(Blue);

| WriteLargeString(1,20,#176,' ','Turbo-Сила'); { вызов }

| Readln { пауза до нажатия ввода }

| END.

Рис. 20.11 (окончание)

Завершая этот раздел, заметим, что подобным способом можно выводить крупные символы и более детальных матриц. Но тут появляются две проблемы: одна — определение места шрифта в памяти ПЭВМ (в общем случае это не просто) и вторая — размещение столь крупных символов (размером 8 строк на 14 столбцов) на экране.

20.6. Управление формой курсора

Мигающий курсор постоянно присутствует на экране дисплея, если он отображает текстовую информацию (во время счета или

- 490 -

ввода-вывода данных на экран). Иногда он совершенно не нужен, например при работе систем меню на экране или при выводе заставки программы и т.п.

Можно управлять формой курсора до полного его отключения с помощью функции номер 1 аппаратного прерывания 10H. Нужно лишь загрузить в определенные регистры начальную и конечную линии курсора и вызвать прерывание.

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

Рис. 20.12

Если верх матрицы имеет четкий номер 0, то ее низ «плавает» в зависимости от текущего шрифта. Так, для адаптера CGA рабочий диапазон будет 0..7, для MDA/Hercules — 0..13. Адаптер EGA использует оба этих интервала в зависимости от режима работы (шрифт 8x8 или 8x14). Для адаптеров класса VGA этот диапазон может вырасти до размеров соответствующих шрифтов (но в режимах эмуляции CGA и MDA на этих адаптерах диапазоны будут по-прежнему 0..7 и 0..13).

Формально прерывание принимает значения номеров линий от 0 до 31. Попытайтесь, когда будет свободное время, изменить форму курсора в таком диапазоне. Нам кажется, что уловить логику в реакции курсора на эти значения, да еще на разных адаптерах, достаточно сложно.

- 491 -

Значение стартовой линии, равное 32, отключает курсор (делает его невидимым). Отключить мигание курсора нельзя, так как оно реализовано аппаратно. Пример процедур, меняющих форму курсора, приведен на рис. 20.13.

| { ПРИМЕР ПРОЦЕДУР ИЗМЕНЕНИЯ ФОРМЫ КУРСОРА }

| CRT, DOS; { используются модули CRT и DOS }

| { Процедура устанавливает форму курсора, }

| PROCEDURE SetCursorSize(c_Start, c_End : Byte );

| VAR

| Regs : Registers; { доступ к регистрам }

| BEGIN

| with Regs do begin

| AH = $01; { функция формы курсора }

| CH = c_Start; { стартовая линия курсора }

| CL = c_End; { конечная линия курсора }

| end; {with}

| Intr($10, Regs) { вызов прерывания 10H БСВВ }

| END;

| { Процедура устанавливает нормальную форму курсора. }

| PROCEDURE SetNormalCursor;

| VAR SE : Word; { компактная запись линий }

| BEGIN

| if ( LastMode >= Font8x8 )

| then

| SE:=$0507

| else

| if (LastMode = Mono ) then SE:=$0B0C

| else SE:=$0607;

| SetCursorSize( Hi(SE ), Lo(SE))

| END;

| { Процедура устанавливает крупный блок-курсор. }

| PROCEDURE SetBlockCursor;

| VAR с_End : Byte;

| BEGIN

| if ( LastMode >= Font8x8 ) or ( LastMode <> Mono )

| then c_End := 7

| else c_End := 13;

| SetCursorSize( 0, с_End )

| END;

Рис. 20.13

- 492 -

| { Процедура отменяет курсор (делает его невидимым). }

| PROCEDURE SetNoCursor;

| BEGIN

| SetCursorSize( 32, 0 )

| END;

| { -— ПРИМЕР ВЫЗОВОВ -— }

| BEGIN

| ClrScr; WriteLn( 'Нажимайте клавишу ввода для',

| ' продолжения' );

| Write( 'Крупный курсор ' ); SetBlockCursor; Readln;

| Write( 'Невидимый курсор ); SetNoCursor; Readln;

| Write( 'Нормальный курсор' ); SetNormalCursor; Readln

| END.

Рис. 20.13 (окончание)

- 493 -

Глава 21. Как осуществить полный доступ к клавиатуре

Описания языков программирования, как правило, не разъясняют механизм работы аппаратной части, а описания аппаратной части не отличаются популярностью изложения. В этом разделе мы попытаемся объединить изложение особенностей работы с клавиатурой ПЭВМ и методов их использования в программах на Турбо Паскале.

21.1. Как организовать опрос алфавитно-цифровой клавиатуры

Это, действительно, просто, если опрашиваются числовые или алфавитные клавиши без нажатий регистров Alt или Ctrl (регистр Shift при этом может быть нажат). Опишем для начала две вспомогательные процедуры, которые понадобятся в последующих примерах. Первая процедура «очищает» буфер клавиатуры (рис. 21.1).

файл CLRKEY.INC

| PROCEDURE ClrKeyBuf;

| VAR

| ch : Char;

| BEGIN

| while KeyPressed do ch:=ReadKey

| END;

Рис. 21.1

Вторая процедура, ожидающая нажатие клавиши, представлена на рис. 21.2.

После этого можно определить фрагмент, который принимает символ нажатой клавиши (рис. 21.3).

- 494 -

файл WAIT.INC

| PROCEDURE Wait;

| BEGIN

| repeat until KeyPressed

| END;

Рис. 21.2

| USES CRT;

| {$I clrkey.inc} { описание процедуры ClrKeyBuf }

| {$I wait.inc) { описание процедуры Wait }

| VAR

| с : Char;

| BEGIN

| ClrScr;

| WriteLn( 'Нажмите любую символьную клавишу' );

| ClrKeyBuf; { очистка буфера клавиатуры }

| с := ReadKey; { программа ждет нажатия клавиши }

| WriteLn( 'Была нажата клавиша с символом ', c );

| WriteLn;

| WritelLn('Программа держит паузу до первого',

| ' нажатия любой клавиши...' );

| Wait; { ожидание нажатия клавиши }

| ClrKeyBuf { мусор из буфера надо убрать }

| END.

Рис. 21.3

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

| CRT

| {$I clrkey.inc} { описание процедуры ClrKeyBuf }

| VAR

| с : Char;

| BEGIN

| ...

| Writeln('Выберите и нажмите клавишу [А], [Б] или [В]');

Рис. 21.4

- 495 -

| ClrKeyBuf;

| { очистка буфера }

| repeat

| c :=ReadKey

| until ( с in ['А'..'В','а'..'в'] );

| { Цикл разомкнется только, если будет нажат один }

| { из трех символов в любом регистре. }

| ClrKeyBuf; { очистка буфера }

| { Далее обрабатывается полученный символ: }

| case с of

| 'A','a' : begin реакция на символ 'a' end;

| 'Б','б' : begin реакция на символ 'б' end;

| 'В','в' : begin реакция на символ 'в' end

| end; {case}

| ClrKeyBuf;

| ...

| End.

Рис. 21.4 (окончание)

В этом примере для проверки принадлежности клавиши используется операция in — проверка наличия символа C в множестве [C1..Cn]. Это стандартный прием, и он весьма эффективен, так как синтаксис множества позволяет легко описывать диапазоны значений. Хотим предостеречь от возможных ошибок: при альтернативной кодировке кириллицы диапазон 'п'..'р' содержит в себе почти всю псевдографику (чего нет при «болгарской» кодировке). Это не очень страшно, так как псевдографика не привязана к клавишам, но лучше не давать повод для возможных «капризов» программ. Обращаем также внимание читателя на то, что и во множестве, и в операторе CASE проверка происходит и по верхнему, и по нижнему регистру написания символа, так как неизвестно, какой из них был включен в момент нажатия. Так всегда следует делать при опросе в режиме кириллицы. При опросе латинских символов достаточно вставить один дополнительный оператор и ограничиться анализом одних лишь заглавных букв, например:

repeat

с := ReadKey;

{ Перевод в верхний режим: только для латинского алфавита}

с := UpCase( с )

until ( с in ['Q'..'V'] );

Можно, конечно, написать свою собственную функцию перевода в верхний регистр, работающую и с кириллицей, но эта функция

- 496 -

будет «от рождения» зависеть от типа кодировки кириллицы. А определить программно тип кодировки практически невозможно.

21.2. Опрос клавиши в регистре Ctrl

Опрос клавиши в регистре Ctrl мало чем отличается от обычного опроса. Правда, при нажатой клавише Ctrl эффект от нажатия алфавитной клавиши определяется ее латинским названием, даже если включен регистр кириллицы. Вопрос же в том, что вернет функция ReadKey в этом случае. Профессионалы могут получить ответ на этот вопрос из табл. 21.1 и не читать этот раздел. Нажатие в регистре Ctrl клавиши на алфавитной клавиатуре выдает в ReadKey ASCII-код в диапазоне 1..26. Значение этого кода равно порядковому номеру буквы в английском алфавите (Ctrl+A даст 1, а Ctrl+Z — 26). Поэтому, получив после выполнения строки

C := ReadKey

в переменную C управляющий символ, ее надо сравнивать уже не с алфавитом, а с самими управляющими символами. Пусть, например, надо опросить только комбинации Ctrl+F, Ctrl+P и Ctrl+S. Это можно сделать двумя способами:

1) repeat 2) repeat

c:= ReadKe c := ReadKey

until(c in [#6, #16, #19]); until(c in [^F, ^P, ^S]);

case c of (Ctrl+F, P и $) case c of (Ctrl+F, P и S)

... ...

end; {case} end; {case}

Первый способ использует специальный синтаксис Турбо Паскаля.

Второй способ основан на том, что можно коды, связанные с алфавитом, изображать как “K, где” — знак «стрелка вверх, а К — клавиша с соответствующим порядковым номером символа.

Таблица 21.1

Клавиша

Нормальное нажатие

+SHIFT

+CTRL

+ALT

A

65

97

1

0 30

B

66

98

2

0 48

C

67

99

3

0 46

D

68

100

4

0 32

E

69

101

5

0 18

- 497 -

F

70

102

6

0 33

G

71

103

7

0 34

H

72

104

8

0 35

I

73

105

9

0 23

J

74

106

10

0 36

K

75

107

11

0 37

L

76

108

12

0 38

M

77

109

13

0 50

N

78

110

14

0 49

O

79

111

15

0 24

P

80

112

16

0 25

Q

81

113

17

0 16

R

82

114

18

0 19

S

83

115

19

0 31

T

84

116

20

0 20

U

85

117

21

0 22

V

86

118

22

0 47

W

87

119

23

0 17

X

88

120

24

0 45

Y

89

121

25

0 21

Z

90

122

26

0 44

[{

91

123

27

\|

92

124

28

]}

93

125

29

῾~

96

126

1!

49

33

0 120

2@

50

64

0 3

0 121

3#

51

35

0 122

4$

52

36

0 123

5%

53

37

0 124

6^

54

94

30

0 125

7&

55

38

0 126

8*

56

42

0 127

9(

57

40

0 128

0)

48

41

0 129

-_

45

95

31

0 130

=+

61

43

0 131

,<

44

60

.>

46

62

/?

47

63

;:

59

58

'”

39

34

Влево

0 75

52

0 115

4

Вправо

0 77

54

0 116

6

- 498 -

Вверх

0 72

56

8

Вниз

0 80

50

2

Home

0 71

55

0 119

7

End

0 79

49

0 117

1

PgUp

0 73

57

0 132

9

PgDn

0 81

51

0 118

3

Ins

0 82

48

Del

0 83

46

Esc

27

27

27

BackSpace

8

8

127

Tab

9

0 15

Серая /

47

47

Серая *

42

42

Серая -

45

45

Серая +

43

43

Enter

13

13

10

Пробел

32

32

32

32

F1

0 59

0 84

0 94

0 104

F2

0 60

0 85

0 95

0 105

F3

0 61

0 86

0 96

0 106

F4

0 62

0 87

0 97

0 107

F5

0 63

0 88

0 98

0 108

F6

0 64

0 89

0 99

0 109

F7

0 65

0 90

0 100

0 110

F8

0 66

0 91

0 101

0 111

F9

0 67

0 92

0 102

0 112

F10

0 68

0 93

0 103

0 113

F11

0 133

0 135

0 137

0 139

F12

0 134

0 136

0 138

0 140

Некоторые служебные и цифровые клавиши могут иметь иные коды на разных ПЭВМ.

Есть еще один способ — перечислить в множестве конструкции Chr(6), Chr(16), Chr(19) и т.п., но это будет слишком громоздко (хотя только через функцию Chr можно реализовать переменные значения символов в множествах).

Полный набор управляющих символов состоит из 32 наименований с кодами от 0 до 31 включительно. Не попавшие в диапазон 1..26 коды, однако, тоже могут быть получены аналогичным образом. Некоторые из цифровых клавиш, расположенных сразу над алфавитными, и знаков пунктуации в сочетании с регистром Ctrl дают недостающие коды (см. табл. 21.1). Хотя, признаться, авторы плохо представляют себе, где и как можно использовать такие «неуклюжие»

- 499 -

запросы, как Ctrl и клавиша «-» (код 31) или Ctrl+6 (код 30). Исключение составляет код 0. Он является чисто внутренним, и никакой комбинацией клавиш нельзя получить его в чистом виде.

Тот, кто просмотрит весь столбец «Ctrl» табл. 21.1, возможно, согласится с расстановкой кодов после буквы «Z» по принципу «максимального беспорядка». И, вероятно, понятное недоумение вызовут коды из двух цифр. Они описаны в следующем разделе.

21.3. Опрос расширенных кодов и функциональных клавиш

Обычные клавиши, даже если они нажаты одновременно с регистрами Ctrl или Shift, выдают символ с ASCII-кодом в диапазоне 1..127 (на русифицированных ПЭВМ диапазон расширяется почти до 255).

Но на клавиатуре ПЭВМ класса IBM PC имеется еще один, альтернативный, регистр (Alt) и десять функциональных клавиш (F1...F10). Алфавитно-цифровые клавиши, нажатые одновременно с клавишей Alt, и функциональные клавиши в любом регистре посылают в буфер ввода с клавиатуры сразу два символа: первый — символ с кодом 0 (нулевой символ), и второй — с цифровым кодом, характеризующим нажатую клавишу. Именно он и называется расширенным кодом.

Понятно, что подобный механизм значительно увеличивает информационную отдачу клавиатуры. Но его необходимо учитывать при программировании опроса клавиатуры, так как расширенные коды могут совпадать с нормальной кодировкой символов (так, F1 даст расширенный код 59, что будет трактоваться, как символ «;»). Рассмотренные в предыдущих разделах примеры могут давать сбои при нажатиях функциональных клавиш или обычных клавиш в регистре Alt.

Усовершенствованная программа опроса клавиатуры (универсальный вариант) показана на рис. 21.5.

| PROGRAM TestKeyBoard; { Пример опроса клавиш F1 - F10 }

| USES CRT;

| VAR

| ch : Char;

| ExtendedKey : Boolean; { флаг расширенного кода }

Рис. 21.5

- 500 -

| { $I clrkey.inc} { описание процедуры ClrKeyBuf }

| {$I wait.inc} { описание процедуры Wait }

| BEGIN

| ClrScr;

| {...} { программа без диалога }

| ClrKeyBuf; { очистка буфера }

| WriteLn( Нажмите функциональную клавишу. );

| Repeat { цикл опроса клавиш }

| ch := ReadKey; { опрос буфера клавиатуры }

| if ch=#0 { Первый байт - нулевой? }

| then { Да, код - расширенный. }

| begin { Считывается следующий }

| ch := ReadKey; { за ним расширенный код. }

| ExtendedKey := True { флаг расширенного кода }

| end

| else { Нет, код – не расширенный. }

| ExtendedKey := False; { флаг не устанавливается }

| until ( ( ch in [#59..#68] ) and ExtendedKey );

| { повторять, пока не получим расширенные коды F1..F10 }

| { ОБРАБОТКА НАЖАТОЙ ФУНКЦИОНАЛЬНОЙ КЛАВИШИ }

| WriteLn('Была нажата клавиша F',(Ord(ch) - 58):1);

| Wait; ClrScr

| END.

Рис. 21.5 (окончание)

Теперь проверяется, какой код считан первым. Если нулевой, то надо считать второй символ из буфера. Он и будет расширенным ходом. А чтобы по-прежнему реагировать только на избранные клавиши, вводится логическая переменная, которая показывает, является ли полученный от клавиши код расширенным или нет. Рассмотренный пример реагирует только на клавиши F1...F10 в «чистом» виде. Если убрать из программы оператор цикла repeat...until, то фрагмент будет возвращать значащий код любой клавиши и устанавливать значение логической переменной ExtendedKey=True в случае нажатия функциональной клавиши или Alt-комбинации.

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

- 501 -

IF KeyPressed {Была ли нажата Клавиша?}

THEN BEGIN {Да, буфер – не пустой.}

ch := ReadKey; { опрос буфера клавиатуры }

if ch=#0 { Первый байт - нулевой?}

then {Да, код – расширенный.}

BEGIN { Считывается следующий }

ch := readkey; { за ним расширенный код. }

Extended := True { флаг расширенного кода }

end

else { Нет, код – не расширенный.}

Extended := False; { Флаг не устанавливавтся }

END {then}

ELSE { не было нажатия клавиш }

ch := #0; { особое значение }

Теперь программа не будет «зависать» в ожидании и сможет работать дальше, даже если ничего не было нажато. В таком случае в ch записываем символ #0 как признак пустого прохода.

Иногда можно применять особенность редактора текстов системы Турбо Паскаль — возможность непосредственного включения в тексты управляющих кодов клавиатуры. Можно получить в тексте программы «образ» любой управляющей или функциональной клавиши, нажав комбинацию клавиш Ctrl+P и следом саму эту клавишу. На экране появится символ с измененным цветом (символ может быть сдвоенным). Его можно трактовать как символ, соответствующий нажатой специальной клавише:

case ReadKey of

'@H' : реакция на нажатие стрелки курсора вверх;

'@P' : реакция на нажатие стрелки курсора вниз;

'@' : реакция на нажатие клавиши F1;

'[' : реакция на нажатие клавиши Esc;

'A' : реакция на нажатие обычной клавиши A

end; {case}

21.4. Опрос служебных клавиш

Под служебными клавишами понимаются все клавиши редактирования, TAB, Enter(Return) и Esc. Их объединяет полное отсутствие системы в возвращаемых кодах. Достаточно взглянуть на табл. 21.1, чтобы увидеть это. Однако никакие принципиальные изменения в процедуры опроса вносить не придется — вполне сгодится алгоритм из предыдущего раздела. Надо только внимательно писать процедуры анализа возвращаемых символов и не забывать

- 502 -

анализировать флаг расширенных кодов. Советуем также посмотреть разд. 21.6 о скэн-кодах клавиш.

21.5. Анализ клавиш регистров и их состояния

К клавишам регистров относятся клавиши Alt, Shift, Ctrl, а также переключатели Ins, CapsLock, NumLock, ScrollLock и т.п. Все они отличаются тем, что, будучи нажаты, сами по себе они не возвращают никаких символов. Это значит, что нельзя определить, нажата ли клавиша регистра или отпущена (если другие клавиши при этом не нажимаются) при помощи стандартных процедур ввода-вывода.

Регистровые клавиши при нажатии устанавливают определенные биты фиксированных байтов системной памяти MS-DOS. В полностью совместимых с IBM PC ПЭВМ таких байтов два. Они имеют адреса $0000:$0417 и $0000:$0418 (адреса даны в шестнадцатеричном формате).

В байте $417 каждый бит имеет свое значение: 1 — если режим включен или комбинация клавиш нажата, и 0 в противном случае. На рис. 21.6 и 21.7 приведены расшифровки битов состояния клавиатуры. Справа от таблиц указаны десятичные значения весов соответствующих битов. Значение байта $417 или $418 равно сумме весов ненулевых битов.

Вес -- Бит -- Байт 0:$417

1 -- 0 -- Нажата правая клавиша Shift

2 -- 1 -- Нажата левая клавиша Shift

4 -- 2 -- Нажата клавиша Ctrl

8 -- 3 -- Нажата клавиша Alt

16 -- 4 -- Отмена прокрутки (ScrollLock)

32 -- 5 -- Регистр цифр (NumLock)

64 -- 6 -- Регистр букв (CapsLock)

128 -- 7 -- Режим вставки/замещения (Ins)

Рис. 21.6

Байт $418 содержит указатели на состояние самих клавиш режимов. Если соответствующий бит содержит 1, то клавиша в момент опроса нажата.

Биты 0...2 имеют смысл только на 101-клавишной клавиатуре. В противном случае они считаются зарезервированными и не используются.

- 503 -

Вес -- Бит -- Байт 0:$418

1 -- 0 -- 1 если нажаты Ctrl + Shift

2 -- 1 -- 1 если нажаты Alt + Shift

4 -- 2 -- Зависит от типа ПЭВМ и клавиатуры

8 -- 3 -- Зависит от типа ПЭВМ и клавиатуры

16 -- 4 -- 1 если нажата ScrollLock

32 -- 5 -- 1 если нажата NumLock

64 -- 6 -- 1 если нажата CapsLock

128 -- 7 -- 1 если нажата Ins

Рис. 21.7

Если же клавиатура имеет специальный контроллер на 101 клавишу, то содержимое бита $418 будет немного другим. Лучше не использовать различающиеся биты, чтобы не терять переносимость программ.

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

| USES CRT; { ФУНКЦИЯ ПРЕДСТАВЛЕНИЯ ЧИСЛА В ДВОИЧНОМ ВИДЕ}

| FUNCTION Binary(X : Longint; NumOfBits : Byte) : String;

| VAR

| bit, i : Byte; { вспомогательные переменные }

| s : String[32];

| BEGIN

| s:=''; { обязательная чистка строки }

| for i:=0 to 31 do begin { цикл перевода }

| bit := ( X shl i ) shr ( 31 ); { выделение бита }

| s := s + Chr( Ord( '0' ) + bit ) { запись в строку }

| end; (for) { конец цикла }

| { Оставляем в строке лишь NumOfBits битов справа: }

| Delete( s, 1, 32-NumOfBits );

| Binary := s { возвращаемая строка }

| END;

| VAR

| M:Byte absolute $000:$417; { можно изменить на $418 }

| BEGIN

| ClrScr;

| CheckBreak := True; { разрешить прерывание }

| Repeat

| WriteLn( M:10, ' ', Binary( M, 8 ) );

| until False { условие вечного цикла }

| END.

Рис. 21.8

- 504 -

После запуска программы нажимайте на клавиши Shift, Ctrl, Alt, CapsLock, NumLock, Ins и смотрите за состоянием битов. Закончить работу программы можно лишь нажав Ctrl+Break.

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

| TYPE { типы клавиш режимов }

| КеуТуре = ( Ins, Caps, Num, Scroll );

| {функция возвращает True, если включен режим xxxLock.}

| FUNCTION GetLockKey( Lock : КеуТуре ) : Boolean;

| VAR Bit : Byte;

| BEGIN

| case Lock of

| Ins : Bit = $60; {128}

| Caps : Bit*$40; { 64}

| Num : Bit = $20; { 32}

| Scroll : Bit = $10 { 16}

| end; {case}

| if ( Mem[0:$417] and Bit ) = Bit { бит включен? }

| then GetLockKey := True { да }

| else GetLockKey := False { нет }

| END;

| PROCEDURE SetLockKey( Lock : КеуТуре; В : Boolean );

| VAR

| M : Byte absolute 0:$417; { байт состояния }

| Bit : Byte;

| BEGIN

| case Lock of

| Ins Bit := $60; {128}

| Caps Bit := $40; { 64}

| Num Bit := $20; { 32}

| Scroll Bit := $10 { 16}

| end; {case}

| case В of

| True : M := M or Bit; { включить xxxLock }

| False : M := M and (255-Bit); { выключить xxxLock }

| end {case}

| END;

Рис. 21.9

- 505 -

| BEGIN { ПРИМЕР ВЫЗОВОВ }

| SetLockKey( Caps, True );

| { включить CapsLock }

| Write( 'Введите любой текст ' );

| ReadLn;

| SetLockKey(Caps, not GetLockKey(Caps));

| { наоборот } Write( 'Режим стал обратным ');

| ReadLn;

| END.

Рис. 21.9 (окончание)

Пример на рис. 21.9 переключает режимы, но не влияет на свечение индикаторов, которое управляется на разных классах ПЭВМ через различные порты.

С помощью подобных функций программа может так управлять вводом, что не будет нужды нажимать клавиши регистров. Сам факт нажатия клавиш регистров Shift, Ctrl и Alt может быть программно проанализирован путем опроса ячеек памяти 0:$417 и 0:$418. Если, например, надо проверить, нажата ли левая клавиша Shift (бит 1 в байте 0:$417 равен 1), то логическая функция должна иметь следующий вид:

if (Mem[0:$417] and 2) = 2 then ... {да, левый Shift нажат}

else ... { нет };

Если надо проверить нажатие правой и левой клавиш Shift одновременно, то условие немного изменится:

if (Mem[0:$417] and (2+1))=(2+1) then {да, обе Shift нажаты}

else { нет };

Подобные опросы можно применять при написании процедур запроса паролей, если паролем доступа к работе с программой делать комбинации типа Alt+Shift и т.п. Но подобная система опроса работает только при длительном нажатии клавиш регистров. Ведь в момент нажатия программа может не анализировать состояние регистров, и тогда информация проскочит «мимо». Четко отловить факт нажатия клавиш регистров можно лишь с помощью анализа скэн-кодов клавиш, перехватывая прерывания от клавиатуры (см. пример на рис. 21.11).

21.6. Скэн-коды клавиатуры и работа с ними

Чтение скэн-кодов клавиш — это самый низкий уровень программного опроса клавиатуры. Каждая нажатая клавиша выдает свой

- 506 -

уникальный скэн-код, который зависит только от ее местоположения на клавиатуре и никак не зависит от того, что под ней понимается. Так, арифметические знаки на алфавитной и цифровой клавиатурах имеют различные скэн-коды. Скэн-коды полностью совместимой с IBM PC ПЭВМ приведены в табл. 21. 2.

Таблица 21. 2

Клавиша

Скэн-код

(16)

Скэн-код

(10)

Клавиша

Скэн-код

(16)

Скэн-код

(10)

Esc

$01

1

Z

$2C

44

!1

$02

2

X

$2D

45

@2

$03

3

C

$2E

46

#3

$04

4

V

$2F

47

$4

$05

5

B

$30

48

%5

$06

6

N

$31

49

^6

$07

7

M

$32

50

&7

$08

8

<,

$33

51

*8

$09

9

>.

$34

52

(9

$0A

10

?/

$35

53

)0

$0B

11

Shift(правый)

$36

54

_-

$0C

12

PrintScreen

$37

55

+=

$0D

13

Alt

$38

56

BackSpace

$0E

14

Пробел

$39

57

TAB

$0F

15

CapsLock

$3A

58

Q

$10

16

F1

$3B

59

W

$11

17

F2

$3C

60

E

$12

18

F3

$3D

61

R

$13

19

F4

$3E

62

T

$14

20

F5

$3F

63

Y

$15

21

F6

$40

64

U

$16

22

F7

$41

65

I

$17

23

F8

$42

66

O

$18

24

F9

$43

67

P

$19

25

F10

$44

68

{[

$1A

26

NumLock

$45

69

}]

$1B

27

ScrollLock

$46

70

Enter

$1C

28

7 Home

$47

71

Ctrl

$1D

29

8 Вверх

$48

72

- 507 -

A

$1E

30

9 PgUp

$49

73

S

$1F

31

Серый -

$4A

74

D

$20

32

4 Влево

$4B

75

F

$21

33

$4C

76

G

$22

34

6 Вправо

$4D

77

H

$23

35

Серый +

$4E

78

J

$24

36

1 End

$4F

79

K

$25

37

2 Вниз

$50

80

L

$26

38

3 PgDn

$51

81

:;

$27

39

0 Ins

$52

82

“ '

$28

40

. Del

$53

83

~`

$29

41

F11

$D9

217

Shift (левый)

$2A

42

F12

$DA

218

|\

$2B

43

Проверить правильность этой таблицы на любой другой ПЭВМ (с MS-DOS и Турбо Паскалем, конечно) можно при помощи программы опроса скэн-кода нажатой клавиши (рис. 21. 10).

| USES CRT, DOS;

| VAR

| Ch, ExtCh : Char; {символы с клавиатуры }

| Scan, LastScan : Byte; {скэн-коды клавиш }

| OldInt09H : Pointer; {адрес старого вектора }

| {$F+}

| PROCEDURE IntProc; INTERRUPT; {перехват прерывания }

| BEGIN

| Scan:=Port[$60]; {чтение скэн-кода }

| Inline($FF/$1E/>OldInt09H); {возврат прерывания }

| END;

| {$F-}

| BEGIN

| GetIntVec($09, OldInt09H); {взятие адреса прерывания }

| SetIntVec($09, @IntProc); {подстановка перехватчика }

Рис. 21.10

- 508 -

| Scan := 128;

| { стартовое значение Scan }

| WriteLn('Нажимайте что угодно.', 'Esc - выход из программы.');

| repeat { Основной цикл опроса: }

| Ch := #0;

| ExtCh := #0;

| { сброс значений до опроса }

| repeat

| until Scan<128; { ожидание любого нажатия }

| Write( ' Скэн-код=', Scan:3 );

| if KeyPressed { Клавиша - не регистровая? }

| then Ch:=ReadKey; { да, ее код запоминается }

| if KeyPressed and (Ch=#0) {Клавиша - функциональная? }

| then ExtCh := ReadKey; { да, запоминается расш. код }

| { вывод итогов опроса: }

| Write ( 'Символ', Ch + ExtCh );

| GotoXY( 30, WhereY ); { нейтрализация кода 13 }

| WriteLn(('” Код=', Ord( Ch ):3, ' Расш. код=', Ord( ExtCh ) );

| LastScan := Scan; { нужен последний скэн-код }

| Scan := 128; { снова стартовое значение }

| until LastScan=1; { условие конца — нажата Esc }

| SetIntVec($09, OldInt09H);

| { восстановление прерывания }

| ReadLn { пауза до нажатия ввода }

| END.

Рис. 21.10 (окончание)

Программа перехватывает низкоуровневое прерывание номер 9 и запоминает содержимое порта, через который передаются коды нажатых клавиш, в глобальной переменной Scan. После этого анализируется, внесло ли нажатие что-либо в буфер ввода. Если да, то выводится информация о нажатой клавише. Используя перехват прерывания, кaк это сделано в примере, можно проводить и более сложный анализ (рис. 21.11). После каждого нажатия любой клавиши перехватчик записывает в Scan скэн-код. Но здесь есть особенность: при нажатии клавиши вырабатывается истинный скэн-код, а при отпускании — увеличенный на 128. Поэтому в примере ожидание нажатия возложено на цикл

repeat until Scan < 128;

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

На рис. 21.11 рассматривается каркас Паскаль-программы, позволяющей «отлавливать» одновременное нажатие нескольких регистровых клавиш вместе с алфавитной клавишей или без нее.

Аналогичным методом можно определять факты нажатия практически всех распознаваемых ПЭВМ комбинаций клавиш. Надо

- 509 -

| { КАРКАС ПРОГРАММЫ, РЕАГИРУЮЩЕЙ НА СПЕЦИАЛЬНЫЕ КОМБИНАЦИИ}

| { НАЖАТИЙ НА КЛАВИАТУРЕ }

| USES CRT, DOS;

| {Необходим модуль DOS. CRT нужен для примера. }

| VAR { глобальные переменные программы : }

| OldInt09H : Pointer; { адрес прерывания 09 }

| CtrlRShiftD : Boolean; { флаг нажатия комбинации }

| CONST { Константы специальной комбинации клавиш: }

| HotKey = $20; { скэн-код клавиши [D]; }

| KlavReg = 1+4; { значение в байте $0:$0417 при нажатии }

| { левого регистра Shift вместе с Ctrl : }

| { 1 - нажата правая клавиша Shift (бит 0); }

| { 4 - Нажато Ctrl+Shift (бит номер 2). }

| {$F+}

| PROCEDURE IntProc; INTERRUPT; {перехват прерывания 09Н }

| VAR

| M: Byte absolute $000:$417; { байт состояния регистров }

| C,L,H : Byte; { значение скэн-кода и др. }

| BEGIN

| С := Port[$60]; { чтение скэн-кода }

{Устанавливаем флаг нажатия, анализируя скэн-код и состояние байта нажатия клавиш регистров: }

| CtrlRShiftD:=(C=HotKey) and ((M and KlavReg)=KlavReg);

| if CtrlRShiftD

| then begin { Специальная обработка }

| L:=Port[$61]; H:=L; { портов, если нажата }

| L:=L or $80; { требуемая комбинация }

| Port[$61] :=L;

| Port[$61]:=H;

| Port[$20] :=$20

| end

| else { Иначе пусть выполняется }

| inline($FF/$1E/>OldInt09H); { настоящее прерывание }

| END;

| {$F-}

| VAR

| 1 : Word; {=== ОСНОВНАЯ ЧАСТЬ ПРИМЕРА ==== }

| LABEL Stop;

| BEGIN

| CtrlRShiftD:=False; {обязательное стартовое значение! }

| ClrScr:

| Write('Нажатие Ctrl+Пр.Shift+D приостановит цикл. ');

| GetIntVec($09, OldInt09H); { сохраняем старый вектор }

| SetIntVec($09, @IntProc ); { подставляем новый вектор }

| {...}

Рис. 21.11

- 510 -

| for i:=1 to 30000 do

| begin { рабочий цикл }

| GotoXY( 5,5 );

| Write( 1:6, ' из 30000.');

| { Программа должна периодически проверять, было ли }

| { одновременное нажатие Ctrl+Правая Shift + D ? }

| if CtrlRShiftD

| then { Да. Обработка нажатия горячего ключа }

| begin

| Write('Комбинация нажата...Закончить(Y/N)? ');

| if UpCase( ReadKey )='Y'

| then

| Goto Stop;

| ClrScr;

| { ... }

| end

| else

| { Нет. Дальнейшие действия программы }

| begin

| {...}

| end; {if}

| end; {for i}

| { конец рабочего цикла }

| { ... }

| Stop: { метка выхода из цикла }

| SetIntVec{ $09, OldInt09H );

| { вернем исходный вектор }

| ClrScr

| END.

Рис. 21.11 (окончание)

только устанавливать соответствующие значения скэн-кодов «горячих» клавиш в HotKey и числа для побитового сравнения с байтами $417/$418 в KlavReg.

Недостатком примера является задержка между нажатием комбинации клавиш и началом анализа. Избежать ее можно, если вставить вызовы процедур реакции на «горячие» комбинации прямо в Interrupt-процедуру. Однако не советуем спешить это сделать. При такой организации программы необходимо принимать специальные меры по предохранению содержимого регистров процессора, блокированию прочих прерываний, их согласованию и т.п., о чем можно всегда прочитать в любой толстой книге по системному программированию на языке ассемблера. В большинстве же программ может пригодиться и предложенный способ.

21.7. Эффект обратной записи в буфер ввода

Весь ввод данных с клавиатуры осуществляется на самом нижнем уровне через небольшой буфер ввода емкостью в шестнадцать симво-

- 511 -

лов. Если нажимается клавиша, то ее атрибуты уходят в этот буфер и могут быть оттуда считаны стандартными процедурами Read и ReadKey. Наличие хотя бы одного символа в буфере показывает логическая функция KeyPressed. При считывании из буфера символа его место освобождается. Если программа не опрашивает буфер клавиатуры, то, нажимая клавиши, можно его переполнить. Компьютер при этом издает характерное жалобное попискивание, и все «излишки» в буквальном смысле пропадают.

Ниже рассматривается пример, который вместо того, чтобы считывать информацию из буфера, записывает ее туда. При этом получается достаточно интересный эффект. Можно программно «изобразить» последовательность нажатий до 16 клавиш, в действительности к ним даже не прикасаясь. Такой прием, в частности, может хорошо работать при написании демонстрационных версий программ — достаточно лишь перед операторами ввода с клавиатуры заполнить буфер нужными ответами. Более того, можно организовывать запуск субпроцессов и отвечать на ряд вопросов запускаемых программ, в том числе и управлять меню или функциональными клавишами.

Сама структура буфера достаточно сложна. И способ хранения символов в ней тоже не очевиден (для обычных кодов хранится ASCII-код символа и скэн-код клавиши, для расширенных запоминается код 0 и собственно расширенный код). В силу этого вид процедуры UnReadKey на рис. 21.12 может показаться запутанным. Тем не менее процедура нормально работает.

| { $М 4096, 0, 0}

| { Программа не использует кучи и мало использует стек. }

| { Такая директива нужна для запуска субпроцесса OUTER. }

| USES CRT, DOS;

| { Процедура возвращает в буфер клавиатуры слово (Word). }

| { Значение KeyW должно содержать ASCII-код клавиши. }

| PROCEDURE UnReadKey( KeyW : Word );

| CONST

| KbdStart = $1E; { специальные значения }

| KbdEnd = $3C;

| VAR

| KbdHead Word absolute $40:$1A; { голова буфера }

| KbdTail Word absolute $40:$1C; { хвост буфера }

| OldTail Word;

Рис. 21.12

- 512 -

| BEGIN

| OldTail := KbdTail;

| if KbdTail = KbdEnd

| then KbdTail := KbdStart

| else Inc( KbdTail, 2 );

| if KbdTail = KbdHead

| then KbdTail := OldTail

| else MemW[$40:OldTail] := KeyW;

| END;

{Эта процедура посылает в буфер ввода значение расширенного кода, имитируя нажатия Alt-комбинаций, функциональных клавиш и клавиш управления курсором. В ExtCode должен содержаться второй (расширенный) код клавиши. }

| PROCEDURE UnReadExtCode( ExtCode : Word );

| BEGIN

| UnReadKey( Swap( ExtCode ) )

| END;

| { Процедура помещает в буфер строку в 16 символов }

| PROCEDURE UnReadString( S : String );

| VAR i : Byte;

| BEGIN

| Delete( S, 17, 255 ); { первые 16 символов }

| for i:=1 to Length(S) do

{ заполнение буфера }

| UnReadKey( Ord( S[i] ) );

| END;

| VAR St : String; { ПРИМЕР ПРИМЕНЕНИЯ ПРОЦЕДУР }

| BEGIN

| { — Пример 1 : автоматизация чтения с клавиатуры — }

| ClrScr;

| TextAttr := Black + 16*LightGray; { текст запроса: }

| Write( ' Допишите число или исправьте : ' );

| TextAttr := LightGray;

| UnReadString(22-2-19'); {подсовываем ответ в буфер }

| Readln(St); { чтение строки }

| Write(#10'Результирующая строка -> '); { что прочитали }

| HighVideo; WriteLn( St ); LowVideo; ReadLn;

| {--Пример 2: готовые ответы на вопросы внешнего файла-- }

| St := 'Hello, Outer !' + #13;

| {St - передаваемая строка. #13 на конце - символ ввода }

| WriteLn( 'В буфер передается строка : ',St );

| UnReadString(St);

| WriteLn( #10 Запускается внешний файл OUTER.' );

| {запуск внешнего файла}

| SwapVectors; Exec('OUTER.EXE','');

| SwapVectors;

| ReadLn { пауза до нажатия ввода }

| END.

Рис. 21.12 (окончание)

- 513 -

Здесь в качестве примера приводится запуск программы OUTER, ожидающей ввод строки с клавиатуры. При отладке этого примера демонстрационная программа OUTER.PAS имела содержание, приведенное на рис. 21.13.

| VAR { -- ПРОГРАММА OUTER.PAS -- }

| S : String;

| BEGIN

| Write( #10' ЗАПРОС <-- ' ); ReadLn( S );

| WriteLn( #10#10'Ha запрос была введена строка : ', S )

| END.

Рис. 21.13

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

UnReadExtCode( 80 ); { три нажатия стрелки }

UnReadExtCode( 80 ); { курсора вниз - код 80 }

UnReadExtCode( 80 );

UnReadKey( #13 ); { клавиша ввода -код 13 }

SwapVectors;

Ехес( '...', '...' ); { запуск программы с меню )

SwapVectors;

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

- 514 -

Глава 22. Работа с оперативной памятью видеоадаптеров

Рассмотрим организацию оперативных запоминающих устройств видеоадаптеров (ОЗУВ) CGA, EGA и их подобных. Дело в том, что ОЗУВ работает по-разному в зависимости от того, в каком режиме находится адаптер. Например, CGA использует способ хранения информации, при котором на один пиксел экрана приходится несколько последовательных битов в ОЗУВ, а EGA и VGA использует способ так называемого многоплоскостного хранения информации.

22.1. Многобитовое и многоплоскостное ОЗУВ

Простейший способ хранения информации — последовательный. Для графического режима 320x200, 4 цвета, в ОЗУВ на каждый пиксел расходуется 2 бита, которые позволяют получить четыре значения: 00, 01, 10, 11. Таким образом, в одном байте ОЗУВ может храниться четыре пиксела. А для графического режима 640x200, 2 цвета, только один бит необходим для представления каждого пиксела (так как надо всего два значения: 0 и 1 — выключен и включен). При многоплоскостном ОЗУВ адаптеры VGA и EGA хранят изображение как четыре отдельные картинки. Каждая картинка называется битовой плоскостью. Каждая битовая плоскость хранит изображение в одном из трех основных цветов, используемых EGA и VGA — красном, зеленом, синем и в так называемой плоскости яркости. Адаптеры VGA и EGA одновременно читают соответствующие биты со всех четырех плоскостей и определяют, каким из 16 доступных цветов должен быть показан указанный пиксел на экране дисплея. Так как каждая битовая плоскость может принимать значение 0 или 1, то все четыре битовые плоскости дадут нам диапазон от 0000 до 1111 в двоичной системе счисления (т.е. от 0 до 15, итого 16 вариантов). Для наглядности можно представить, что эти четыре плоскости представляют своеобразный «бутерброд» (рис. 22.1).

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

- 515 -

Рис. 22.1

максимальной до минимальной. Однако в режиме эмуляции EGA адаптер VGA полностью ему аналогичен.

22.2. Карта дисплейной памяти

На всех IBM-совместимых ПЭВМ область ОЗУ размером 256K, расположенная сразу за верхней границей оперативной памяти (640K), отведена под память видеоадаптеров дисплея (рис. 22.2).

Рис. 22.2

Отметим, что на ПЭВМ серии PS/2 пользователю доступен весь мегабайт ОЗУ, а оставшиеся 360K, отведенные под ОЗУВ, размещены сразу за ним и не отображаются на дисплейную память.

На рис. 22.3 показано, как используется 256-килобайтный блок ОЗУВ. Если на ПЭВМ стоит адаптер CGA, то задействовано только 16K ОЗУВ, начинающиеся с адреса $В8000 или $В800:$0 (736K). Если же на ПЭВМ установлен адаптер EGA и VGA, то тогда используются все 256K.

- 516 -

Рис. 22.3

На рис. 22.4 показано, как используются 16K ОЗУ В в адаптере CGA. Первые 8K ОЗУВ заняты четными строками изображения на экране. Вторые 8К заняты нечетными строками изображения. Такое построение ОЗУВ дает мерцание экрана и обусловливает медленную скорость работы адаптера и монитора. Так как каждый блок использует ровно 8000 байт, то остаются две области по 192 байт.

Рис. 22.4

Адаптеры VGA и EGA в своих стандартных режимах не используют метод хранения «четный-нечетный» — в них работает последовательно-параллельный способ хранения информации (слева-направо, сверху-вниз и по плоскостям). Однако в режимах эмуляции CGA эти адаптеры используют область памяти, начинающуюся с адреса $В800:0.

При разрешении экрана 640x200, 16 цветов, EGA и VGA работают в так называемом многостраничном режиме. В ОЗУВ располагаются четыре видеостраницы (рис. 22.5).

Рис. 22.5

- 517 -

Каждая из этих страниц представляет собой область, соответствующую экрану дисплея. Так как каждая страница на одной битовой плоскости занимает 640x200/8=16000 байт, а ОЗУВ предоставляет 16384 байт, то 384 байт на каждой битовой плоскости остается свободными.

Как видно из рисунка, первые 64K ОЗУВ содержат только битовую плоскость 0 каждой страницы. Каждый следующий блок содержит соответственно битовые плоскости 1, 2 и 3 для всех четырех страниц. Запомните, только первые 64K ОЗУВ могут быть непосредственно доступны для программ, использующих прямой доступ к памяти. При этом обращение происходит одновременно ко всем четырем битовым плоскостям. Поэтому любое изображение, выполненное таким способом, будет ярко-белым. Для раздельного доступа к битовым плоскостям используются специальные функции контроллера графического дисплея.

Если для разрешения 640x350, 16 цветов, произвести аналогичные расчеты, то получится, что каждая страница в этом режиме занимает 28000 байт ОЗУВ, поэтому здесь можно разместить только две страницы в одной битовой плоскости (рис. 22.6). Таким образом, одна полная страница занимает в ОЗУВ 28000x4=112000 байт.

Рис. 22.6

При работе с разрешением 640x480, 16 цветов, только одна страница ОЗУВ доступна для работы, так как на каждой битовой плоскости требуется 38400 байт, что больше половины сегмента

Рис. 22.7

- 518 -

Режим 320x200, 16 цветов, — это режим низкого разрешения, поэтому в нем доступны восемь страниц (по 8000 байт каждая) (рис. 22.8). Полный объем, занимаемый изображением на экране, составляет 32000 байт. Заметьте, что в табл. 19.4 при описании процедуры SetGraphMode модуля Graph этот режим не указан, однако включение его возможно.

Рис. 22.8

Режим 320x200, 256 цветов, доступен только для адаптеров, выходной сигнал которых представляется в аналоговом виде: VGA, MCGA, IBM8514. Из-за использования этими адаптерами незначительно измененного многоплоскостного способа хранения информации, одна страница занимает всего 16000 байт на каждой битовой плоскости. Таким образом, имеется возможность хранить четыре страницы видеоинформации (см. рис. 22.5).

22.3. Вывод текста на графический экран

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

Рассмотрим некоторые особенности прерывания 10H БСВВ. В нем есть несколько функций вывода текста с управлением цветом выводимых символов:

функция 09H — вывод в текущую позицию текстового курсора символа с заданным цветовым атрибутом;

функция 0EH — вывод символа в режиме телетайпа;

функция 13H — вывод текстовой строки.

Функция 09H не очень интересна, так как при выводе каждого символа необходимо самим передвигать текстовый курсор в следующую позицию. В этом смысле развитием ее является функция 0EH —

- 519 -

вывод каждого символа сопровождается его перемещением на следующую позицию (это и есть телетайп). Пример работы с этой функцией при выводе строки символов показан на рис. 22.9.

| USES Graph, CRT, DOS;

| {$I initgraf.pas} {Процедура инициализации (см. гл. 19) }

| PROCEDURE TeleWrite( str : String; attr : Byte );

| {Процедура вывода символа sym заданного цвета attr на }

| {графический экран системным шрифтом текстового режима }

| PROCEDURE WriteSym( sym : Byte; { ASCII-код символа }

| attr : Byte ); { цвет символа (0..15 }

| VAR

| regs : Registers; { требуется для прерываний }

| BEGIN

| with regs do begin { действия с полями reg }

| AH := $0E; { функции вывода символа }

| AL := sym; { ASCII код символа }

| BL := attr+$80; { его цвет (+$80 для XOR) }

| end;

| Intr( $10, regs ) { вызов прерывания 10H }

| END; {WriteSym}

| VAR

| i : Byte;

| BEGIN {TeleWrite}

| for i := 1 to Length(str) do

| WriteSym( Ord( str[i] ), attr );

| END; {TeleWrite}

| BEGIN { Пример вызова }

| GrInit; { инициализация графики }

| Bar3D(315,50, 330, 200, 30, TopOn); { графическая фигура }

| GotoXY( 34,12 ); { установка позиции }

| TeleWrite( 'Это желтый цвет', Yellow );

| ReadLn; { пауза до нажатия ввода }

| CloseGraph { закрытие графики }

| END.

Рис. 22.9

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

Функция 13H работает на графических адаптерах класса EGA и VGA и позволяет выводить не только строку заданного цвета (при

- 520 -

значении 0 или 1 регистра AL процессора — см. рис. 22.10), но и строку, в которой атрибуты заданы для каждого символа отдельно. При этом строка должна иметь структуру «символ-атрибут-символ-атрибут-...». Такой режим задается, если в регистр AL записать значение 2 или 3 (регистр BL при этом не используется). При значениях AL, равных 0 или 2, перевод курсора при выводе не осуществляется в отличие от значений 1 и 3. В графических режимах лучше использовать режимы 0 и 2.

| { Процедура вывода строки заданного цвета на графический }

| {экран системным шрифтом для текстового режима }

| {================(только EGA и VGA)==================== }

| PROCEDURE WriteStr( str : String; { выводимая строка }

| X, Y : Byte; { координаты начала }

| Page : Byte; { номер видеостраницы }

| attr : Byte ); { цвет символа (0..15) }

| VAR R : Registers; { требуется для прерываний }

| BEGIN

| with R do { действия с полями записи }

| begin

| AH := $13; { функция вывода строки }

| AL := 0; { цвет символов задан в BL }

| BH := page; { вывод на страницу page }

| BL := attr+$80, { цвет (+$80 для XOR) }

| DH:=Y; { DH и DL - позиция тексто- }

| DL := X; { вого курсора }

| CX := Length( str); { длина выводимой строки }

| BP := Ofs( str )+1; { Адрес выводимой строки в }

| ES := Seg( str ) { виде базы и сегмента, }

| end; { начиная со Str[1]. }

| Intr( $10, R ); { вызов прерывания 10Н }

| END;

Рис. 22.10

22.4. Работа с графическими образами на диске

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

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

- 521 -

попробуем записать изображение с экрана на диск. Казалось бы просто — достаточно немного изменить процедуру CopyToPrint. Однако при таком подходе место на диске будет расходоваться неэкономно: в каждом байте старшие четыре (как минимум) бита не используются. Исключение составляют все режимы с количеством цветов 256 и более (VGA, MCGA, IBM8514). Чтобы не заботиться об этом, можно воспользоваться функцией ImageSize (см. разд. 19.6.1) — она возвращает размер картинки в байтах, уже учтя все нюансы ее расположения в ОЗУВ. Воспользовавшись затем процедурой GetImage, можно сохранить изображение на диске (рис. 22.11).

| USES Graph;

| {$I initgraf.pas} {процедура инициализации (см. гл. 19) }

| { Процедура записи на диск картинки с экрана. }

| { Максимальный размер 640x200 при 16 цветах. }

| PROCEDURE SaveScreen( X1, Y1 { координаты картинки }

| X2, Y2 : Word;

| FileName : String ); { имя файла картинки }

| VAR

| PicFile : File; { бестиповый файл }

| size :Word; { размер файла }

| dataptr : Pointer; { указатель на буфер }

| BEGIN

| Size := ImageSize(X1,Y1, X2, Y2); { размер картинки }

| GetMem( dataptr, size ); { выделение памяти }

| GetImage(X1,Y1,X2,Y2,dataptr^); { картинку – в буфер }

| Assign( PicFile, FileName ); { Открытие файла для }

| Rewrite( PicFile, size ); { записи картинки. }

| BlockWrite(PicFile,dataptr^,1); { запись картинки }

| Close( PicFile ); { закрытие файла }

| FreeMem( dataptr, size ) { освобождение кучи }

| END;

| BEGIN { Пример вызова процедуры }

| GrInit;

| SetFillStyle(1,15); Bar( 0, 0, GetMaxX, GetMaxY );

| SetFillStyle(2, 2); Bar(40, 40, GetMaxX-40, GetMaxY-40 );

| SetFillStyle(3, 3); Bar(120, 120, GetMaxX-120, GetMaxY-120);

| SetFillStyle(4, 4);Bar(240, 180, GetMaxX-240, GetMaxY-180);

| ReadLn;

| SaveScreen(70,70, GetMaxX-70, GetMaxY-70, 'graph.scr');

| CloseGraph

| END.

Рис. 22.11

- 522 -

А с помощью процедуры PutImage можно восстановить это изображение (рис. 22.12).

| USES Graph;

| {$I initgraf.pas} {процедура инициализации (см. гл. 19) }

| {Процедура вывода на экран картинки, записанной на диск. }

| {Максимальный размер - экран в режиме 640x200, 16 цветов. }

| PROCEDURE LoadScreen(X,Y:Word; { координаты левого верх- }

| { него угла картинки }

| FileName : String; { имя файла картинки }

| Put : Word ); { режим вывода на экран }

| VAR

| PicFile :File; { бестиповый файл }

| size : Word; { размер файла в байтах }

| dataptr : Pointer; { указатель на начало }

| BEGIN

| Assign( PicFile, FileName ); { Открытие файла для }

| Reset( PicFile, 1 ); { чтения по одному байту. }

| size := FileSize( PicFile ); { размер файла в байтах }

| Reset( PicFile, size ); { смена буфера файла }

| GetMem( dataptr, size ); { выделение памяти }

| BlockRead(PicFile,dataptr^,1); { чтение картинки }

| PutImage(X,Y,dataptr^,put); { вывод картинки на экран }

| Close( PicFile ); { закрытие файла }

| FreeMem( dataptr, size ) { освобождение памяти }

| END;

| BEGIN { Пример вызовов процедуры }

| GrInit;

| LoadScreen( 0, 0, 'graph.scr', XORPut);

| LoadScreen(20, 20, 'graph.scr', XORPut);

| LoadScreen(40, 40, 'graph.scr', XORPut);

| LoadScreen(60, 60, 'graph.scr', XORPut } ;

| LoadScreen(80, 80, 'graph.scr', XORPut);

| ReadLn;

| CloseGraph

| END.

Рис. 22.12

При таком способе сохранения изображений существует ограничение на их размер. Это связано с тем, что функция ImageSize возвращает результат типа Word. Таким образом, картинка не должна занимать в памяти больше 65520 байт. Для адаптера EGA,

- 523 -

например, полностью весь экран можно записать на диск максимум в режиме 640x200, 16 цветов — это займет 64004 байта. Кроме того, если размеры картинки таковы, что она полностью не сможет поместиться на экран, то выводиться на него при чтении с диска она не будет.

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

Другой способ сохранения и чтения картинок основан на знании устройства и работы графических адаптеров: каждая цветовая плоскость сохраняется в отдельном файле. При таком способе работы ограничений на размер картинки практически нет (рис. 22.13).

| USES Graph;

| {$I initgraf.pas} {процедура инициализации (см. гл. 19) }

| TYPE

| g_plan=Array [1..38400] of Byte; { массив-плоскость }

| {Процедура сохранения изображения всего экрана на диске.

| Для каждой битовой плоскости создается отдельный файл.

| Параметр file_name - имя файла без расширения. }

| PROCEDURE SaveBitPlanes( file name : String );

| VAR

| scr_buf:Pointer ; { указатель на буфер данных }

| scr_arr:g_plan absolute $A000:$0; { память адаптера }

| plen,mx,my:LongInt; { размер плоскости }

| { Вложенная процедура записи плоскости на диск }

| PROCEDURE WriteBlk( name : String );

| VAR

| image_file : File;

| BEGIN

| Assign( image_file, name );

| Rewrite( image_fite, plen );

| BlockWrite( image_file, scr_buf^, 1 );

| Close( image file )

| END;

| BEGIN

| mx := GetMaxX+1; my := GetMaxY+1; { размеры плоскости }

Рис. 22.13

- 524 -

| plen := mx*my div 8;

| { получение длины буфера }

| GetMem( scr_buf, plen );

| { память для буфера }

| Port[$3CE]:=4; Port[$3CF]:=0;

| { чтение плоскости Blue }

| Move(scr_arr,scr_buf^,plen); { копирование ее в буфер }

| WriteBlk(file_name+'.blu');

| { запись буфера на диск }

| Port[$3CE]:=4; Port[$3CF]:=1; { чтение плоскости Green }

| Move(scr_arr,scr_buf^,plen); { копирование ее в буфер }

| WriteBlk(file_name+'.grn'}; { запись буфера на диск }

| Port[$3CE]:=4; Port[$3CF]:=2; { чтение плоскости Red }

| Move(scr_arr,scr_buf^,plen); { копирование ее в буфер }

| WriteBlk(file name+'. red');

| { запись буфера на диск }

| Port[$3CE]:=4; Port[$3CF]:=3; { плоскость яркости }

| Move(scr_arr,scr_buf^,plen); { копирование ее в буфер }

| WriteBlk(file_name+'.int'); { запись буфера на диск }

| FreeMem( scr_buf, plen ); { освобождение памяти }

| Port[$3CE]:=4; Port[$3CF]:=0; { восстановление портов }

| END;

{Процедура чтения файлов изображения и вывода их на экран. Параметр file_name - hmz файла без расширения. }

| PROCEDURE LoadBitPlanes( file_name : String );

| VAR scr_buf:Pointer ; { указатель на буфер данных }

| scr_arr:g_plan absolute $A000:$0; { память адаптера }

| plen,mx,my:LongInt; { размер плоскости }

| { Вложенная процедура чтения плоскости с диска }

| PROCEDURE ReadBlk( name : String );

| VAR image file : File;

| BEGIN Assign( image.file, name );

| Reset( image_file, plen );

| BlockRead( image_file, scr_buf^, 1 );

| Close( image_file )

| END;

| BEGIN

| mx:=GetMaxX+1;

| my:=GetMaxY+1; {размеры плоскости }

| plen := mx*my div 8; {получение длины буфера }

| GetMem( scr_buf, plen ); {память для буфера }

| ReadBlk( file_name+'.blu' ); {чтение с диска в буфер }

| Port[$3C4]:=2; Port[$3C5]:=1; {Буфер копируется }

| Move(scr_buf^,scr_arr,plen); {в плоскость Blue. }

| ReadBlk(file_name+'.grn' ); {чтение с диска в буфер }

Рис. 22.13 (продолжение)

- 525 -

| Port[$3C4]:=2;

| Port[$3C5]:=2;

| { Буфер копируется }

| Move(scr_buf^,scr_arr,plen);

| { в плоскость Green. }

| ReadBlk( file_name+'.red' );

| { чтение с диска в буфер }

| Port[$3C4]:=2;

| Port[$3C5]:=4;

| { Буфер копируется }

| Move(scr_buf^,scr_arr,plen );

| { в плоскость Red. }

| ReadBlk( file_name+'.int' );

| { чтение с диска в буфер }

| Port[$3C4]:=2; Port[$3C5]:=8; { Буфер копируется }

| Move(scr_buf^,scr_arr,plen ); { в плоскость яркости. }

| FreeMem( scr_buf, plen ); { освобождение памяти }

| Port[$3C4]:=2;Port[$3C5]:=15; { восстановление портов }

| END;

| BEGIN

| { Пример вызовов процедур }

| GrInit;

| SetFillStyle(1,15);

| Bar( 0, 0, GetMaxX, GetMaxY );

| SetFillStyle(2, 2);

| Bar(40, 40,GetMaxX-40, GetMaxY-40 );

| SetFillStyle(3,3);

| Bar(120,120, GetMaxX-120, GetMaxY-120);

| SetFillStyle(4,4);

| Bar(240,180, GetMaxX-240, GetMaxY-180);

| ReadLn;

| SaveBitPlanes( 'plane' );

| ClearDevice;

| ReadLn;

| LoadBitPlanes( 'plane' );

| ReadLn;

| CloseGraph

| END.

Рис. 22.13 (окончание)

Эти процедуры работают для всех режимов, кроме CGA (так как в нем другой способ хранения данных). Поэтому для него приведем отдельные процедуры (рис. 22.14).

| USES Graph;

| TYPE

| g_plan=Array [1..16384] of Byte; { массив двух блоков }

| {Процедура сохранения изображения всего экрана на диске }

| { для адаптеров, работающих в режиме CGA. }

| PROCEDURE SaveCGAScr(file_name:String); {полное имя файла }

| VAR

| image_file : File;

| scr_buf : Pointer; { ссылка на буфер }

| scr_addr:g_plan absolute $B800:0; { память адаптера }

| plen, mx, my : LongInt; { размер плоскости }

Рис. 22.14

- 526 -

| BEGIN

| mx := GetMaxX+1;

| my := GetMaxY+1;

| { размеры плоскости }

| if GetGraphMode = CGAHi { размер буфера: }

| then

| plen := mx*my div 8 + 384 { один бит на точку }

| else { или }

| plen := mx*my div 4 + 384; { два бита на точку }

| GetMem( scr_buf, plen ); { выделение памяти }

| Assign( image_file, file_name ); { связь файлов }

| Rewrite( image_file, plen ); { открытие файла }

| Move( scr_addr, scr_buf^, plen ); { экран – в буфер }

| BlockWrite(image_file,scr_buf^,1); { запись его в файл }

| Close( image_file ); { закрытие файла }

| FreeMem( scr_buf, plen ) { удаление буфера }

| END;

| { Процедура чтения изображения с диска и вывода его на }

| { экран для адаптеров, работающих в режиме CGA }

| PROCEDURE LoadCGAScr(file_name:String );

| {полное имя файла }

| VAR

| image_file : File;

| scr_buf : Pointer; { ссылка на буфер }

| scr_addr:g_plan absolute $8800:0; { память адаптера }

| plen,mx,my: LongInt; { размер плоскости }

| BEGIN

| mx := GetMaxX+1;

| my := GetMaxY+1; { размеры плоскости }

| if GetGraphMode = CGAHi { размер буфера: }

| then

| plen := mx*my div 8 + 384 { один бит на точку }

| else { или }

| plen := mx*my div 4 + 384; { два бита на точку }

| GetMem( scr_buf, plen ); { отводится память }

| Assign( image_file, file_name ); { связь файлов }

| Reset( image_file, plen ); { открытие файла }

| BlockRead(image_file,scr_buf^,1); { чтение картинки }

| Close( image.file ); { закрытие файла }

| Move(scr_buf^,scr_addr, plen); { буфер – на экран }

| FreeMem( scr buf, plen ) { удаление буфера }

| END;

Рис. 22.14 (окончание)

Подобный способ хранения изображений используется в некоторых графических пакетах программ (PBrush, DrHALO). Однако формат записи, используемый в них, другой. Поэтому они не совместимы ни между собой, ни с другими графическими пакетами.

- 527 -

ПРИЛОЖЕНИЕ 1 Сообщения и коды ошибок, генерируемые компилятором

При обнаружении ошибки компилятор Турбо Паскаля интегрированной среды программирования автоматически загружает исходный файл программы и помещает курсор около ошибки. Компилятор ТРС.ЕХЕ выводит на экран сообщение об ошибке, номер и исходную строку, используя для указания места ошибки символ «^». Учтите, что некоторые ошибки в исходном тексте до определенного времени не обнаруживаются. Если около курсора нет очевидной ошибки, ищите ее слева от курсора или в предыдущем тексте. После выдачи кода ошибки в интегрированной среде нажатие клавиши F1 выдаст комментарий к этому коду.

Ниже даны комментированные коды и сообщения компилятора.

1 Out of memory (выход за границы памяти)

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

— если в меню Compile/Destination (Компиляция/Направление) установлено значение Memory (память), измените его на Disk (диск);

— если для параметра Link Buffer в меню Option/Linker (Опция/Редактор связей) в интегрированной среде установлено значение Memory, измените его на Disk; другой путь состоит в размещении директивы {$L-} в начале программы; при работе с транслятором ТРС используйте опцию /L;

— удалите из памяти резидентные программы, в использовании которых нет крайней необходимости;

— если работа осуществляется в среде, попробуйте заменить ее компилятором ТРС.ЕХЕ: он занимает меньше памяти.

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

2 Identifier expected (ожидается идентификатор)

В этом месте должен находиться идентификатор. Возможно имеет место попытка использовать зарезервированное слово.

3 Unknown identifier (неизвестный идентификатор)

Этот идентификатор не был описан.

4 Duplicate identifier (повторное описание идентификатора)

5 Syntax error (синтаксическая ошибка)

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

- 528 -

6 Error in real constant (ошибка в действительной константе)

Нарушен синтаксис константы вещественного типа.

7 Error in integer constant (ошибка в целой константе)

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

8 String constant exceeds line (строковая константа превышает размеры строки)

Вероятно, в конце строковой константы не стоит кавычка константы, или она перенесена на следующую строку.

9 Too many nested files (слишком много вложенных файлов)

Компилятор допускает не более восьми вложенных исходных файлов. Вероятно, нарушено это правило.

10 Unexpected end of file (неожиданный конец файла).

Это сообщение об ошибке могло быть получено по одной из следующих причин:

— исходный файл закончился перед последним END основного блока программы; вероятно, количество операторов BEGIN и END не одинаково;

— включаемый файл заканчивается в середине раздела операторов; каждый раздел операторов должен целиком помещаться в одном файле;

— не закончен комментарий.

11 Line too long (строка слишком длинна)

Максимальная длина строки не может превышать 126 символов.

12 Type identifier expected (ожидается идентификатор типа)

В ожидаемом месте не указан идентификатор типа.

13 Too many open files (слишком много открытых файлов)

Файл CONFIG.SYS не включает параметр FILES=xx, или этот параметр указывает слишком мало файлов. Увеличьте число файлов до какого-либо подходящего значения, например 20.

14 Invalid file name (неверное имя файла)

Имя файла неверно или указывает несуществующий путь (маршрут).

15 File not found (файл не найден)

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

16 Disk full (диск заполнен)

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

17 Invalid compiler directive (неправильная директива или ключ компилятора)

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

18 Too many files (слишком много файлов)

- 529 -

В компиляции программы или программного модуля участвует слишком много файлов. Попытайтесь не использовать так много файлов, например, объединяя включаемые файлы.

19 Undefined type in pointer definition (неопределенный тип в определении ссылки)

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

20 Variable identifier expected (нужен идентификатор переменной)

В этом месте ожидается идентификатор (имя) переменной.

21 Error in type (ошибка в определении типа)

Определение типа не может начинаться с этого символа.

22 Structure too large (слишком большая структура)

Максимально допустимый размер объявляемой структуры данных — 65520 байт.

23 Set base type out of range (базовый тип множества нарушает разрешенные границы)

Базовый тип множества должен представлять собой отрезок типа с границами в пределах от 0 до 255 или перечислимый тип с не более чем 256 значениями.

24 File components may not be files or objects (компоненты файла не могут быть файлами или объектами)

Тип компонента файла не может быть типом объекта, типом файла, или любым другим структурным типом с компонентом типа файла либо типа объекта.

25 Invalid string length (неверная длина строки)

Максимальная длина строки должна находиться в диапазоне от 0 до 255.

26 Type mismatch (несоответствие типов)

Возможные причины ошибки:

— несовместимы типы переменной и выражения в операторе присваивания;

— несовместимы типы фактического и формального параметров в обращении к процедуре или функции;

— тип выражения не совместимым с типом индекса при индексировании массива;

— несовместимы типы операндов в выражении.

27 Invalid subrange base type (неправильный базовый тип для диапазона)

28 Lower bound greater then upper bound (нижняя граница больше верхней)

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

29 Ordinal type expected (нужен перечислимый тип)

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

30 Integer constant expected (ожидается целая константа)

- 530 -

31 Constant expected (ожидается константа)

32 Integer or real constant expected (ожидается целая или действительная константа)

33 Type identifier expected (ожидается имя типа)

Данный идентификатор не обозначает тип.

34 Invalid function result type (неправильный тип результата функции)

Правильными типами результата функции являются все простые, строковые и ссылочные типы.

35 Label identifier expected (нужен идентификатор метки)

Метка не обозначена с помощью идентификатора, как это требуется.

36 BEGIN expected (ожидается BEGIN)

37 END expected (ожидается END)

38 Integer expression expected (ожидается выражение целого типа)

Предыдущее выражение должно иметь целый тип.

39 Ordinal expression expected (ожидается выражение перечислимого типа)

Предшествующее выражение должно иметь перечислимый тип.

40 Boolean expression expected (ожидается логическое выражение)

Предшествующее выражение должно иметь логический тип Boolean.

41 Operand types do not match operator (типы операндов не соответствуют оператору)

Данный оператор не может быть применен к операндам данного типа. Такая ошибка возникнет, например, при попытке символ 'А' разделить на 2.

42 Error in expression (ошибка в выражении)

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

43 Illegal assignment (неверное присваивание)

Возможные причины ошибки:

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

44 Field identifier expected (ожидается имя поля записи)

Данный идентификатор не соответствует полю предшествующей переменной типа « запись» или « объект» .

45 Object file too large (объектный файл слишком большой)

Турбо Паскаль не может компоновать OBJ-файлы, большие чем 64K.

46 Undefined external (неопределенная внешняя процедура)

Внешняя процедура или функция не имеет соответствующего определения PUBLIC в объектном файле. Убедитесь, что указаны все объектные файлы в директивах ($L Файл.OBJ) и проверьте написание идентификаторов процедуры или функции в соответствующих файлах Файл. ASM.

- 531 -

47 Invalid object file record (неправильная запись объектного файла)

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

48 Code segment too large (сегмент кода слишком большой)

Максимальный размер кода программы или модуля — 65520 байт. При компиляции программы или модуля разбейте его на два (или более) модуля.

49 Data segment too large (сегмент данных слишком велик)

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

50 DO expected (ожидается слово DO)

51 Invalid PUBLIC definition (неверное определение PUBLIC)

Возможные причины ошибки:

— данный идентификатор получил тип PUBLIC с помощью директивы PUBLIC в языке ассемблера, но не соответствует описанию external в программе или программном модуле;

— две или более директивы PUBLIC на языке ассемблера определяют один и тот же идентификатор;

— OBJ-файлы определяют символы PUBLIC, не находящиеся в сегменте CODE.

52 Invalid EXTRN definition (неверное определение EXTRN)

Возможные причины ошибки:

— идентификатор осуществил ссылку в языке ассемблера с помощью директивы EXTRN, но это не было описано в программе или программном модуле на Паскале и не было описано в интерфейсной секции используемых программных модулей;

— идентификатор обозначает абсолютную переменную;

— идентификатор обозначает процедуру или функцию типа inline.

53 Too many EXTRN definition (слишком много определений типа EXTRN)

Турбо Паскаль не может обрабатывать OBJ-файлы при более чем 256 определениях EXTRN.

54 OF expected (ожидается слово OF)

55 INTERFACE expected (ожидается интерфейсная секция)

56 Invalid relocatable reference (недействительная перемещаемая ссылка)

Возможные причины ошибки:

— OBJ-файл содержит данные и перемещаемые ссылки в сегментах, отличных от CODE, например, при попытке описать инициализированные переменные в сегменте DATA;

— OBJ-файл содержит ссылки с размерами в байтах на перемещаемые символы. Такая ошибка происходит в случае

- 532 -

использования операторов HIGH и DOWN с перемещаемыми символами или ссылки в директивах DB на перемещаемые символы;

— операнд ссылается на перемещаемый символ, который не был определен в сегментах CODE или DATA;

— операнд ссылается на процедуру EXTRN или функцию EXTRN со сдвигом, например CALL SortProc+8.

57 THEN expected (ожидается слово THEN)

58 ТО or DOWNTO expected (ожидается слово ТО или DOWNTO)

59 Undefined forward (неопределенное опережающее описание)

Возможные причины ошибки:

— были описаны процедура или функция в интерфейсной секции и программного модуля или типе объекта, но их определение (реализация) отсутствует;

—процедуры или функции были описаны с помощью опережающего описания, но их определение не найдено.

60 Too many procedures (слишком много процедур)

Турбо Паскаль допускает не более 512 процедур или функций в одном модуле. При компиляции программы поместите некоторые процедуры или функции в программные модули. При компиляции модуля разбейте его на два или несколько модулей.

61 Invalid typecast (неверное приведение типа)

Возможные причины ошибки:

— размеры переменной и тип результата отличаются друг от друга при приведении типа переменной;

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

62 Division by zero (деление на нуль)

Предшествующая операция пытается выполнить деление на нуль.

63 Invalid file type (неверный файловый тип)

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

64 Cannot Read or Write variables of this type (нет возможности считать или записать переменные данного типа) Возможные причины ошибки:

— процедуры Read и ReadLn могут считывать переменные символьного, целого, вещественного и строкового типов;

— процедуры Write и WriteLn могут выводить переменные символьного, целого, вещественного, булевского и строкового типов.

65 Pointer variable expected (ожидается переменная-указатель)

Предыдущая переменная должна иметь ссылочный тип или тип Pointer.

66 String variable expected (нужна строковая переменная)

Предшествующая переменная должна иметь строковый тип.

- 533 -

67 String expression expected (нужно выражение строкового типа)

Предшествующее выражение должно иметь строковый тип.

68 Unit not found (программный модуль не найден)

Один или несколько программных модулей, используемых данным программным модулем, не указаны в директиве USES.

69 Unit name mismatch (несоответствие имен программных модулей)

Имя программного модуля, найденное в файле .TPU, не соответствует имени, указанному в директиве uses.

70 Unit version mismatch (несоответствие версий программных модулей)

Один или несколько программных модулей, используемых данной программой, были изменены после их компиляции. Воспользуйтесь опцией Compile/Make (Компиляция/Перекомпиляция) или Compile/Build (Компиляция/Построение) в интегрированной среде программирования и опциями /М или /В в компиляторе tpc, что позволит автоматически скомпилировать программные модули, нуждающиеся в перекомпиляции.

71 Duplicate unit name (повторное имя программного модуля)

Этот программный модуль уже указан в директиве USES.

72 Unit file format error (ошибка формата файла программного модуля)

TPU-файл является недействительным. Убедитесь, что это действительно TPU-файл соответствующей версии языка.

73 Implementation expected (ожидается секция реализации)

В модуле не найден раздел реализации.

74 Constant and case types do not match (типы констант и тип выражения оператора case не соответствуют друг другу)

Тип константы оператора case не совместим с выражением в операторе варианта.

75 Record variable expected (нужна переменная типа «запись»)

Предшествующая переменная должна иметь тип «запись» .

76 Constant out of range (константа нарушает границы)

Возможные причины ошибки:

— значение индексного выражения находится вне диапазона индекса для данного массива;

— попытка присвоить константу вне диапазона переменной;

— попытка передать константу вне диапазона в качестве параметра процедуре или функции.

77 File variable expected (ожидается файловая переменная)

Предшествующая переменная должна иметь файловый тип.

78 Pointer expression expected (ожидается выражение адресного типа)

Предшествующее выражение должно иметь ссылочный тип или тип Pointer.

79 Integer or real expression expected (ожидается выражение целого или вещественного типа)

- 534 -

Предшествующее выражение должно иметь целый или вещественный тип.

80 Label not within current block (метка не находится внутри текущего блока)

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

81 Label already defined (метка уже определена)

Данная метка уже помечает точку перехода.

82 Undefined label in preceding statement part (неопределенная метка в обрабатываемом разделе операторов)

83 Invalid @ argument (неправильный аргумент оператора @)

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

84 Unit expected (ожидается слово UNIT)

85 « ;» expected (нужно указать « ;»)

86 « :» expected (нужно указать « :» )

87 « ,» expected (нужно указать « ,» )

88 « (» expected (нужно указать « (» )

89 « )» expected (нужно указать « )» )

90 « =» expected (нужно указать « =» )

91 « :=» expected (нужно указать « :=» )

92 « [» or « (.» expected (нужно указать « [» или « (.» )

93 « ]» or « .)» expected (нужно указать « ]» или « .)» )

94 « .» expected (нужно указать « .» )

95 « ..» expected (нужно указать « ..» )

96 Too many variables (слишком много переменных)

Возможные причины ошибки:

— общий размер глобальных переменных, описанных в программе или программном модуле, не может превышать 64K;

— размер локальных переменных, описанных в программе или функции, не может превышать 64K.

97 Invalid FOR control variable (недопустимый тип управляющей переменной цикла FOR)

Управляющая переменная оператора FOR должна быть переменной перечислимого типа.

98 Integer variable expected (ожидается переменная целого типа)

Предшествующая переменная должна иметь целый тип.

99 File and procedure types are not allowed here (здесь не допускаются файловые и процедурные типы)

Типизированная константа не может иметь файловый или процедурный тип.

100 String length mismatch (несоответствие длины строки)

Длина строковой константы не соответствует количеству элементов символьного массива.

101 Invalid ordering of fields (неверный порядок полей)

- 535 -

Поля в константе типа « запись» должны записываться в порядке их описания в конструкции RECORD...END.

102 String constant expected (ожидается константа строкового типа)

103 Integer or real variable expected (ожидается переменная вещественного или целого типа)

Предшествующая переменная должна иметь целый или вещественный тип.

104 Ordinal variable expected (ожидается переменная перечислимого типа)

Предшествующая переменная должна иметь перечислимый тип.

105 INLINE error (ошибка в операторе INLINE)

Оператор не употребляется совместно с перемещаемыми ссылками на переменные. Такие ссылки всегда имеют размер в слово.

106 Character expression expected (предшествующее выражение должно иметь символьный тип)

107 Too many relocation items (слишком много перемещаемых элементов)

Размер раздела таблицы перемещения файла .ЕХЕ превышает 64K, что является верхним пределом в Турбо Паскале. Если обнаружена эта ошибка, то значит, программа просто слишком велика для обработки редактором связей Турбо Паскаля. Возможно также, что она слишком велика для выполнения. В таком случае нужно выделить в программе основной раздел, который выполнял бы два или несколько подразделов, выделенных в самостоятельные программы, используя процедуру Exec из модуля DOS.

108 Not enough memory to run program (недостаточно памяти для выполнения программы)

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

109 Cannot find EXE file (не находится ЕХЕ-файл)

По какой-то причине ЕХЕ-файл, сгенерированный только что компилятором, исчез.

110 Cannot run a unit (модуль выполнять нельзя)

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

111 Compilation aborted (компиляция прервана)

Компиляция была прервана с помощью нажатия клавиш Ctrl+Break.

112 CASE constant out of range (константа CASE нарушает допустимые границы)

Для операторов case целочисленные переключатели не должны выходить из диапазонов типов Word или Integer.

113 Error in statement (ошибка в операторе)

Данный символ не может быть первым символом в операторе.

- 536 -

114 Cannot call an interrupt procedure (нельзя вызвать напрямую процедуру прерывания)

115 Must have an 8087 to compile this (для компиляции необходимо наличие сопроцессора 80X87)

Компилятор требует для компиляции программ и программных модулей в режиме {$N+} наличия сопроцессора 80X87.

116 Must be in 8087 mode to compile this (для компиляции необходим режим использования 80X87)

Данная конструкция может быть скомпилирована только в режиме {$N+}. В режиме {$N-} операции с вещественными типами одиночной и двойной точности, расширенными и совместимыми с ними, не допускаются.

117 Target address not found (адрес назначения не найден)

Команда Compile/Find error (Компиляция/Поиск ошибки) в интегрированной среде программирования или опция /F в командной строке компилятора tpc не позволяют обнаружить оператор, соответствующий указанному адресу.

118 Include files are not allowed here (в такой ситуации включаемые файлы не допускаются)

Каждый блок операторов должен целиком размещаться в одном файле.

119 ТР file format error (Ошибка формата файла .ТР)

Файл конфигурации .ТР является недействительным. Убедитесь, что этот файл будет в действительности файлом конфигурации для данной системы.

120 NIL expected (ожидается NIL)

121 Invalid qualifier (неверный квалификатор)

Возможные причины ошибки:

— попытка индексировать переменную, которая не является массивом;

— попытка указать поля в переменной, которая не является записью;

— попытка разыменовать переменную, которая не является указателем.

122 Invalid variable reference (неверная ссылка на переменную)

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

123 Too many symbols (слишком много символов)

Программа (или модуль) описывает более 64K символов. При компиляции программы попробуйте отключить директиву {$D+). Иначе можно поместить некоторые описания в отдельный модуль.

124 Statement part too large (слишком большой раздел операторов)

Турбо Паскаль ограничивает размер кода блока операторов до величины примерно 24K. Если обнаружена эта ошибка, то поместите части разделов оператора в одну или несколько процедур. В любом

- 537 -

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

125 Module has no debug information (в модуле нет отладочной информации)

При возникновении ошибки времени выполнения в программе или модуле, не имеющих отладочной информации, отладчик не сможет указать на место сшибки в тексте программы. Перекомпилируйте модуль с опцией {$D+} и воспользуйтесь меню (Compile/Find Error) (Компиляция/Поиск ошибки), чтобы найти эту ошибку в интегрированной среде, или опцией /F в компиляторе tpc.

126 Files must be var parameters (параметры-файлы должны быть описаны как VAR)

Попытка описать формальный параметр файлового типа как параметр-значение. Поставьте слово VAR перед параметрами.

127 Too many conditional symbols (слишком много условных символов)

Отсутствует место для определения условных символов. Попытайтесь удалить некоторые символы или сократить некоторые из ключевых слов компиляции.

128 Misplaced conditional directive (пропущена условная директива)

Компилятор обнаружил директиву {$ELSE} или {$ENDIF} без соответствующих директив {$IFDEF}, {$IFNDEF} или {$IFOPT}.

129 ENDIF directive missing (пропущена директива ENDIF)

Исходный файл закончился внутри конструкции условной компиляции. В исходном файле должно быть равное количество директив {$IFxxx} и {$ENDIF}.

130 Error in initial conditional defines (ошибка в начальных условных определениях)

Исходные условные символы, указанные в меню O/C/Conditional Defines (Условные определения) или в директиве /D компилятора tpc являются недействительными.

131 Header does not match previous definition (заголовок не соответствует предыдущему определению)

Возможные причины ошибки:

— заголовок процедуры или функции, указанный в интерфейсной секции, не соответствует самому заголовку процедуры или функции;

— заголовок процедуры или функции, указанный в опережающем описании (описании forward), не соответствует самому заголовку процедуры или функции.

132 Critical disk error (критическая ошибка диска)

Во время компиляции произошла критическая ошибка диска (например, дисковод находится в состоянии « не готов» ).

133 Cannot evaluate this expression (невозможно вычислить данное выражение)

- 538 -

В выражении-константе или в отладочном выражении используются неподдерживаемые средства, например в описании константы используется функция Sin, или в отладочном выражении вызывается определенная пользователем функция.

134 Expression Incorrectly terminated (некорректное завершение выражения)

Ожидается конец выражения или оператор, но не обнаруживается ни то, ни другое.

135 Invalid format specifier (неверный спецификатор формата)

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

136 Invalid indirect reference (недопустимая косвенная ссылка)

Осуществляется недопустимая косвенная ссылка. Например, используются совмещенная переменная, базовая переменная которой в текущем модуле неизвестна, или в подпрограмме типа Inline делается ссылка на переменную, неопределенную в текущем модуле.

137 Structured variable are not allowed here (некорректное использование структурной переменной)

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

138 Cannot evaluate without System unit (нельзя вычислить без блока System)

Для того чтобы отладчик смог вычислить выражение, в файле TURBO.TPL должен содержаться модуль System.

139 Cannot access this symbol (доступ к данному символу отсутствует)

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

140 Invalid floating-point operation (недопустимая операция с плавающей запятой)

При операции с двумя действительными значениями было получено переполнение или деление на ноль.

141 Cannot compile overlay to memory (нельзя выполнить компиляцию оверлеев в память)

Программа, использующая оверлеи, должна компилироваться на диск.

142 Procedural or function variable expected (должна использоваться переменная-процедура или функция)

В этом контексте оператор получения адреса @ может использоваться только с переменной-процедурой или функцией.

143 Invalid procedure or function reference (недопустимая ссылка на процедуру или функцию)

Если конкретную реализацию процедуры или функции нужно

- 539 -

присвоить переменной-процедуре (функции), то она должна компилироваться в режиме {$F+} и не может описываться с помощью ключевых слов inline или interrupt.

144 Cannot overlay this unit (этот модуль не может быть оверлейным)

Попытка использовать в качестве оверлейного модуль, который не был скомпилирован в режиме {$О+}.

146 File access denied (доступ к файлу заблокирован DOS)

147 Object type expected (ожидается тип « объект» )

Идентификатор не обозначает тип « объект», или тип пропущен.

148 Local object types are not allowed (не допустимы локальные описания типов объектов)

Типы объектов могут быть определены только в глобальном блоке программы или модуля. Определения типа объекта внутри процедур и функций не допустимы.

149 VIRTUAL expected (необходимо слово VIRTUAL)

Отсутствует ключевое слово virtual в описании объекта.

150 Method identifier expected (ожидается идентификатор метода)

Идентификатор не обозначает метод объекта.

151 Virtual constructors are not allowed (виртуальные конструкторы не допустимы)

Правило конструктора объекта должно быть статическим.

152 Constructor identifier expected (ожидается идентификатор конструктора)

Идентификатор не обозначает конструктор объекта.

153 Destructor identifier expected (ожидается идентификатор деструктора)

Идентификатор не обозначает деструктор объекта.

154 Fail only allowed within constructors (вызов Fail допустим только из конструктора)

Стандартная процедура Fail может быть вызвана только из конструктора объекта.

- 540 -

ПРИЛОЖЕНИЕ 2 Ключи и директивы компилятора

Директивы компилятора Турбо Паскаля управляют режимами компиляции программ в выполнимый код (в памяти или на диске). Они представляют собой комментарии со специальным синтаксисом. Турбо Паскаль допускает директивы компилятора везде, где допускаются комментарии.

Директива компилятора начинается со знака «$», стоящего первым после открывающего граничного знака комментария. Непосредственно после знака «$» следует имя (одна или несколько букв), которое определяет конкретные директивы. Имеются три типа директив:

1. Ключи выбора режимов. Включают конкретные режимы компиляции или выключают их с помощью указания знаков «+» или «-» сразу после имени ключа.

2. Директивы с параметрами. Задают параметры, оказывающие влияние на компиляцию, например имена включаемых файлов и размеры памяти.

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

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

Директивы компилятора можно разместить непосредственно в исходном коде программы. Можно также изменить применяемые по умолчанию директивы с помощью компилятора, использующего командную строку (ТРС.ЕХЕ) или с помощью компилятора, работающего в диалоговой среде (TURBO.EXE). Все директивы компилятора можно задавать с помощью меню выбора режимов компиляции (Options/Compiler Menu). Все вносимые в меню изменения будут иметь силу при последующих компиляциях. При использовании компилятора ТРС.ЕХЕ директивы компилятора можно либо задавать в командной строке (например, ТРС /$R+ ИмяПрограммы), либо поместить их в файл конфигурации TPC.CFG. Директивы компилятора, которые содержатся в исходном тексте программы, всегда отменяют принятые по умолчанию значения директив.

Эквивалент меню: Option/Compiler/Align Data

Ключ $А позволяет переключаться между выравниванием переменных и

- 541 -

типизированных констант по границе слова и по границе байта. Для процессора 8088 выравнивание на границу слова игнорируется, однако для всех процессоров 80X86 такое выравнивание означает более быстрое выполнение, поскольку адресация ко всем элементам, имеющим размер в слово, или четным адресам происходит за один цикл обращения к памяти вместо двух.

В состоянии {$А+} все переменные и типизированные константы, превышающие по размеру один байт, выравниваются по границе машинного слова (адреса с четными значениями). В случае необходимости между переменными для достижения выравнивания по границе слова включаются дополнительные неиспользуемые байты. Ключ {$А+} не влияет ни на переменные размером в байт, ни на поля структур или элементы массивов. Поле записи будет выравниваться по границе слова только в том случае, если общий размер всех следующих перед ним полей будет иметь четное значение. Аналогично, для любого элемента массива выравнивание по границе слова будет иметь место только, когда размер элементов имеет четное значение.

В состоянии {$А-} никаких действий по выравниванию не предпринимается. Переменные и типизированные константы независимо от их размера помещаются в этом случае просто по следующему доступному адресу.

Независимо от режима $А каждое описание VAR и CONST всегда начинается на границе слова. Подобным образом компилятор всегда старается поддерживать указатель стека (SPtr) выравненным по границе слова, для чего в случае необходимости выделяется дополнительный неиспользуемым байт.

Эквивалент меню: Options/Compiler/Local Symbols

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

Когда для данного модуля задана генерация информации о локальных символах, встроенный отладчик Турбо Паскаля позволяет проверять и модифицировать локальные переменные модуля. Кроме того, с помощью меню Debug/Calls Stack можно проверять обращения к процедурам и функциям модуля.

При включенных режимах Options/Link/Map-File и Debug/Stand-Alone Debugging отладчик позволяет получить информацию о локальных символах данного модуля, если он компилировался в режиме {SL+}.

Для модулей информация о локальных символах записывается в TPU-файле наряду с объектным кодом модуля. Эта информация увеличивает размер файлов (требуется дополнительное пространство), но на размер и скорость работы выполняемой программы это влияния не оказывает.

Ключ, задающий включение информации о локальных символах, обычно используется вместе с ключом отладочной информации, который позволяет включить или выключить генерацию таблицы номеров строк для отладки. Заметим, что в том случае, если режим генерации отладочной информации выключен ({$D-}), директива $L будет игнорироваться.

Эквивалент меню: Options/Compiler/Stack-Checking

В зависимости от режима приводится в действие или отменяется генерирование кода проверки переполнения стека. При указании {$S+} компилятор генерирует в начале каждой процедуры или функции код, который проверяет, достаточное ли место в стеке выделено для локальных переменных. Если в стеке места недостаточно, то обращение к процедуре или функции, скомпилированное с указанием {$S+}, приводит к завершению работы программы, которая при этом выводит сообщение об ошибке времени выполнения. При указании {$S-} подобное обращение наиболее вероятно приведет к фатальной ошибке системы («зависанию»).

Режим проверки параметров строкового типа

Синтаксис: {$V+} или {$V-}

Режим по умолчанию: {$V+}

Тип: Локальный

Эквивалент меню: Options/Compiler/Var-String Checking

Ключ $V управляет проверкой типа при передаче строк в качестве параметров-переменных. В состоянии {$V+} выполняется строгая проверка типа, при которой требуется, чтобы формальный и фактический параметр имели идентичные строковые типы. В состоянии {$ V-} в качестве фактического параметра допускается использовать любую переменную строкового типа, даже если ее описанная длина не совпадает с длиной соответствующего формального параметра.

Директивы с параметрами

Эквивалент меню: Options/Directories/Object Directories

Данная директива предписывает компилятору скомпоновать указанный файл с компилируемой программой или модулем. Директива $L используется для компоновки кода, написанного на языке ассемблера для подпрограмм, описанных как внешние (external). Указанный файл должен быть перемещаемым объектным файлом в формате INTEL (OBJ-формате). Расширением по умолчанию для параметра «ИмяФайла» является «.OBJ». Если в параметре «ИмяФайла» каталог не указан, то в дополнение к поиску файла в текущем каталоге Турбо Паскаль просматривает каталоги, указанные в меню.

Размеры выделяемой памяти

Синтаксис: {$М Стек, МинимумКучи, МаксимумКучи }

Значения по умолчанию: {$М 16384, 0, 655360}

Тип: Глобальный.

Эквивалент меню: Options/Compiler/Memory Sizes

Данная директива указывает параметры распределения памяти программы. Параметр «Стек» должен быть целым числом в диапазоне от 1024 до 65520, указывающим размер сегмента стека. «МинимумКучи» должно быть числом в диапазоне от 0 до 655360, а «МаксимумКучи» должно быть числом в диапазоне от «МинимумКучи» до 655360. Последние два параметра указывают соответственно минимальные и максимальные размеры динамически распределяемой области памяти.

Директива $М не оказывает влияния при использовании ее в модуле (UNIT).

ПРИЛОЖЕНИЕ 3 Использование компилятора ТРС

Пакет Турбо Паскаль содержит вариант компилятора, работающего в режиме командной строки (автономного) — ТРС.ЕХЕ.

Использование ТРС.ЕХЕ несложно: в командной строке MS-DOS надо ввести

C:\TURBO> ТРС [параметры] ИмяФайла [параметры]

Параметры могут задаваться в любом порядке и могут стоять до и (или) после имени файла. Параметры разделяются косой чертой «/». Вместо косой черты можно использовать символ «-», но при этом параметры, начинающиеся с него, должны отделяться друг от друга пробелами.

Если имя файла не имеет расширения, то ТРС будет предполагать расширение .PAS. Чтобы транслируемый файл не имел вообще расширения, после имени файла необходимо поставить точку. Если в исходном файле содержится программа, то ТРС создаст выполняемый файл ИмяФайла.ЕХЕ, а если он является текстом модуля, то будет создан файл модуля ИмяФайла.TPU.

Параметры, управляющие режимами компиляции, записываются как /$Х+ или /$Х- (возможно и написание -$Х+ или -$Х-), где X — однобуквенное имя ключа режима компиляции. Ключи и их значения по умолчанию приведены в приложении 2.

Другой вид параметров — это аналоги настройки интегрированной среды программирования. Они задаются как /X (или -X), где X — специальные буквы, соответствующие различным строкам меню среды. Иногда после буквы необходимо задать значение (каталог, символ и др.). Ниже приведены такие параметры:

Параметр

Позиция меню среды

Значение

/Dсимвол

Options/Compile/Conditional Defines

Символ; символ;...

/L

Options/Linker/Link Buffer

Disk

иначе

принимается /Link Buffer

Memory

/GS

Options/Linker/Map File

On, Segments

/GP

Options/Linker/Map File

On, Public

/GD

Options/Linker/Map File

On, Detailed

иначе

принимается /Map File

Off

/V

Debug/Stand-alone Debugging

On

иначе

принимается ... Debugging

Off

/M

Compile/Make

/B

Compile/Build

/Fсг:см

Compile/Find Error

/Q

Подавление выдачи сообщений по ходу трансляции

Настройка каталогов:--------------------------------------

/Ткаталог

Options/Directories/Turbo Directory

- 548 -

/Екаталог

Options/Directories/EXE & TPU Directory

/Iкаталог(и)

Options/Directories/Include Directory

/Uкаталог(и)

Options/Directories/Unit Directory

/Oкаталог(и)

Options/Directories/Object Directory

Прокомментируем некоторые ключи компилятора. Параметр /D позволяет определять условные символы, как это делает директива компилятора {$DEFINE символ}. За параметром /D должен следовать один (или более) символ условия, разделенные точкой с запятой «;». Например, командная строка

ТРС pasprog /Dnocheck; nodebug

определяет для программы PASPROG.PAS два условных слова: nocheck и nodebug. Это эквивалентно внесению в начало исходного текста программы директив: {$DEFINE nocheck} и {$DEFINE nodebug}.

Параметр /F — поиск ошибки (Find Error) — нужен для поиска строки в тексте программы, вызвавшей фатальную ошибку в указанном сообщением «Run Time Error NNN at СЕГМ:СМЕЩ» адресе. Компиляция той же программы с ключом /FСЕГМ:СМЕЩ выведет на экран строку, в которой прервалась программа. Чтобы компилятор ТРС мог найти эту ошибку, программа и модули дожны компилироваться в режиме /$D+ (т.е. с генерацией отладочной информации).

ПРИЛОЖЕНИЕ 4 Список утилит пакета Турбо Паскаль

Программа администрирования библиотек TPUMOVER

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

Экран утилиты TPUMOVER состоит из двух расположенных рядом друг с другом окон. В верхней части окна указывается имя файла, а за ним указывается список модулей, находящихся в файле. Каждая строка в окне содержит информацию об одном модуле, а именно: имя модуля, размер кода, размер данных, размер таблицы символов и имена других модулей, используемых данным модулем. Все размеры указаны в байтах, а имена модулей сокращены до шести символов. Если список используемых модулей слишком велик и не помещается в окне, то внизу указываются три точки. Нажав клавишу F4, можно просмотреть список и увидеть имена других модулей, зависящих от указанного. Наконец, две строки в окне содержат информацию о текущем размере (в байтах) указанного файла и о количестве свободного пространства на диске, на котором расположен этот файл. В любой момент времени только одно из окон находится в «активном» состоянии. Это состояние обозначается двойной рамкой окна. Кроме того, только окно в активном состоянии содержит поле с подсветкой, перемещающееся по списку модулей, находящихся в файле. Это поле может передвигаться вверх и вниз с помощью клавиш управления движением курсора. Все команды имеют силу только для окна, находящегося в активном состоянии. Переключение активного состояния между окнами выполняется с помощью клавиши F6.

Для использования TPUMOVER нужно ввести следующую команду:

C:\TURBO>TPUMOVER ИмяФайла1 ИмяФайла2

где «ИмяФайла1» и «ИмяФайла2» — это файлы с расширением .TPL или TPU. Расширение .TPU предполагается по умолчанию, поэтому явным образом расширение указывается только для файлов TPL. TPUMOVER загружается и выводит на экран два окна: левое окно для «ИмяФайла1» и правое окно для «ИмяФайла2». Отметим, что и «ИмяФайла1», и «ИмяФайла2» являются

- 550 -

необязательными параметрами. Если указан только параметр «ИмяФайла1», то правое окно имеет по умолчанию имя NONAME.TPU. Если не указан никакой файл, то TPUMOVER попытается загрузить TURBO.TPL в левое окно, а правое окно останется пустым. Если TPUMOVER не сможет найти этот файл, то он распечатает на экране каталог всех файлов текущего диска, имеющих расширение .TPL.

Команды утилиты TPUMOVER

Основные команды указываются в нижней части экрана. Ниже приводится краткое описание каждой их этих команд:

F1 — выводит на экран диалоговую документацию.

F2 — записывает текущий файл (файл, связанный с окном в активном

состоянии) на диск.

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

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

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

+ — «плюс» помечает модуль (для копирования или удаления). Одновременно можно пометить несколько модулей. Кроме того, можно отменить пометку модуля, нажав клавишу «+» повторно.

Ins — копирует все помеченные модули из активного окна в окно, находящееся в неактивном состоянии.

Del — удаляет все помеченные модули из активного окна.

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

Опции программы GREP

Необязательные параметры (опции) командной строки — это один или несколько знаков, перед которыми стоит символ «-». За каждым отдельным знаком переключателя может следовать символ «+», выполняющий функцию включения параметра, или другой символ «-», выполняющий функцию отмены параметра. По умолчанию предполагается наличие символа «+» (например, -r значит то же самое, что и -r+). Приведем список необязательных параметров, используемых при работе с утилитой GREP:

-C — (только счетчик). Печатается только имя файла и число содержащих заданную строку поиска для каждого файла, который содержит по крайней мере одну совпадающую строку. Сами строки не печатаются.

-D — (каталоги). Все файлы, в которых происходит поиск, ищутся в указанном каталоге и всех его подкаталогах. Если набор файлов указывается без пути, то подразумевается текущий каталог.

-I — (игнорировать различие в строчных и прописных букв). Утилита GREP будет игнорировать различие в строчных и прописных буквах, т. е. символы a-z будут интерпретироваться так же, как символы A-Z.

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

-N — (номера). Перед каждой выводимой совпадающей строкой печатается ее номер.

-О — (выходной формат операционной системы UNIX). Выходной формат совпадающих строк изменяется для более полной поддержки конвейеризации команд по типу операционной системы UNIX. Перед всеми строками вывода указывается имя файла, содержащего совпадающую строку.

-R — (поиск текста/конструкций). Текст, заданный параметром строка_поиска, трактуется либо как обыкновенное строковое выражение (-R-), либо как конструкция-шаблон (-R+).

-U — (обновить параметры). Утилита GREP будет записывать заданные параметры в файл GREP.COM как новые принятые по умолчанию значения (другими словами, выполняется настройка конфигурации утилиты GREP).

- 552 -

-V — (несовпадения). Выводятся только несовпадающие строки. Только строки, содержащие строку поиска, рассматриваются как совпадающие строки.

-W — (поиск слова). Найденный и совпадающий с обычным выражением текст будет рассматриваться как совпадающий, только если непосредственно предшествующий и следующий символы не являются частью слова. Принятый по умолчанию набор символов слов включает в себя символы A-Z, 9-0 и символ подчеркивания «_». Альтернативная форма этого параметра позволяет задавать набор разрешенных для слов символов. Она имеет вид -W [множество_символов], где «множество_символов» представляет собой обычно допустимое выражение в синтаксисе множества. Если для определения множества используются алфавитные символы, то множество автоматически будет определено так, что в него войдут как строчные, так и прописные символы, независимо от того, какие символы были в определении (даже если при поиске они различаются).

-Z — (расширенный вывод). Выводится имя каждого искомого файла. Перед каждой совпадающей строкой ставится ее номер. Задается количество сравниваемых строк в каждом файле, даже если оно равно нулю.

Некоторые из этих параметров находятся в прямом противоречии друг с другом. В таких случаях применяется следующий порядок: первый параметр — это параметр, имеющий преимущество. Каждое вхождение опции подавляет ее предыдущее определение. С помощью параметра -U можно для каждого параметра установить значение по умолчанию из файла GREP.COM. Например, для включения параметра -Z можно задать следующую команду:

GREP -U -Z

Утилита преобразования двоичных файлов BINOBJ

Утилита BINOBJ.EXE добавлена для того чтобы можно было преобразовывать любой файл в файл типа .OBJ, который может компоноваться с любой программой Турбо Паскаля как «процедура». Это может быть полезным, если есть двоичный файл данных, который должен находиться в сегменте кода, или он слишком велик, чтобы разместиться в массиве типизированных констант. Например, можно использовать утилиту BINOBJ и модуль GRAPH для компоновки графического драйвера или файлов шрифтов непосредственно с EXE-файлом. Подробно эта операция рассматривалась в гл. 19 «,Модуль GRAPH»

Утилита BINOBJ имеет три параметра:

BINOBJ Файл[.BIN] Файл[.OBJ] общедоступное_имя

Где «Файл» - это преобразуемый файл, а «общедоступное_имя» - это имя процедуры, по которому она должна вызываться в Турбо Паскале.

ПРИЛОЖЕНИЕ 5 Команды встроенного редактора

Основные команды перемещения курсора

Влево на один символ Ctrl+ S или Стрелка влево

Вправо на один символ Ctrl+D или Стрелка вправо

Влево на слово Ctrl+ или Ctrl+A Стрелка влево

Вправо на слово Ctrl+ или Ctrl+F Стрелка вправо

Вверх на одну строку Ctrl+E или Стрелка вверх

Вниз на одну строку Ctrl+X или Стрелка вниз

Экран на одну строку вверх Ctrl+ W

Экран на одну строку вниз Ctrl+Z

Вверх на одну страницу Ctrl+R или PgUp

Вниз на одну страницу Ctrl+C или PgDn

Расширенный набор команд перемещения курсора

В начало строки Ctrl+ Q S или Home

В конец строки Ctrl+ Q D или End

В начало окна Ctrl+ Q E или Ctrl+ Home

В низ окна Ctrl+ Q X или Ctrl+ End

В начало файла Ctrl+ Q R или Ctrl+ PgUp

В конец файла Ctrl+ Q C или Ctrl+ PgDn

В начало блока Ctrl+ Q B

В конец блока Ctrl+ Q K

В предыдущее положение курсора Ctrl+ Q P

Команды вставки и удаления

Включение (выключение) вставки Ctrl+V или Ins

Вставить строку Ctrl+N

Удалить строку Ctrl+Y

Удалить до конца строки Ctrl+Q Y

Удалить символ слева от курсора Ctrl+H или BackSpace

Удалить символ над курсором Ctrl+G или Del

Удалить слова справа от курсора Ctrl+T

Команды работы с блоками

Пометить начало блока Ctrl+K B

Пометить конец блока Ctrl+K K

Пометить одиночное слово Ctrl+K T

Сделать невидимым (видимым) блок Ctrl+K H

Скопировать блок Ctrl+K C

Переместить блок Ctrl+K V

Удалить блок Ctrl+K Y

Напечатать блок Ctrl+K P

- 554 -

Считать блок с диска Ctrl+K R

Записать блок на диск Ctrl+K W

Сдвинуть весь блок вправо Ctrl+K I

Сдвинуть весь блок влево Ctrl+K U

Поиск и замена

Найти Ctrl+Q F

Найти и заменить Ctrl+Q A

Повторить последний поиск Ctrl+L

Найти парную скобку Ctrl+Q [ или Ctrl+Q ]

(пары могут состоять из символов:

{и}, [и], (и ), , ', *, и, (.и.), (*и*) )

Прочие команды

Табуляция Ctrl+I или Tab

Включение (выключение) режима

автоматического отступа (Indent) Ctrl+O I или Ctrl+Q I

Включение (выключение) режима замены пробелов знаками

табуляции (Fill) Ctrl+O F

Включение (выключение) режима удаления пробелов клавишей

Backspace (Unindent) Ctrl+O U

Управление режимом

табуляции (Tab) Ctrl+O T или Ctrl+Q T

Установить маркер позиции n Ctrl+K n

Перейти на позицию маркера n Ctrl+Q n

Показать последнюю ошибку Ctrl+Q W

Восстановить строку Ctrl+Q L

Ввод в текст управляющего символа Ctrl+P

Прервать выполнение команды Ctrl+U

Вызвать основное меню F10

Записать файл на диск Ctrl+K S или F2

Прочитать файл с диска F3

Выйти из редактора, не сохраняя файл Ctrl+K D или Ctrl+K Q

- 555 -

ПРИЛОЖЕНИЕ 6 Автоматическая оптимизация программ

Компилятор Турбо Паскаля автоматически производит оптимизацию выполняемого кода по нескольким критериям:

1. Вычисление выражений, состоящих из констант числовых и символьных типов (в том числе значений функций Abs, Sqr, Succ, Pred, Odd, Lo, Hi, Swap и Ptr от констант) или из конкатенации строк, происходит на этапе компиляции. То есть присваивания A:=10+Sqr(5) и S:='a'+'b' эквивалентны по эффективности кода присваиваниям А:=35 и S:='ab'. Это верно и для выражений в вызовах процедур и функций, а также для вычисления индексов массивов.

2. Одинаковые строковые константы хранятся в ЕХЕ-файле в единственном экземпляре. Например, два или более оператора Write ('Stop—') в одной и той же части программы будут использовать одну и ту же копию строковой константы 'Stop—'.

3. По умолчанию логические выражения вычисляются по короткой схеме (в режиме SB-). Это дает минимальный и быстрый код (см. разд. 9.3).

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

5. По умолчанию режим проверки корректности диапазонов значений отключен (режим $R-), что уменьшает код и увеличивает быстродействие.

6. Где только возможно, компилятор заменяет целочисленное умножение на степени числа 2 операцией сдвига влево (shl).

7. По умолчанию производится оптимизация размещения данных в памяти, что задается режимом компиляции $А+.

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

if False then Оператор;

будет проигнорирована.

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

Оптимизация при компоновке включается только при компиляции программы на диск.

- 556 -

ПРИЛОЖЕНИЕ 7 Список демонстрационных процедур и функций

Глава 6. Управляющие структуры языка

Program (рис. 6.16)

Демонстрация суммирования элементов массивов любого типа

Fast, IntPower (разд. 6.9.6.4)

Примеры рекурсивного вычисления факториала и целой степени числа

Unit Colors (рис. 6.19)

Модуль, выводящий цветовые константы

Глава 8. Обработка символов и строк

ExplodeString (рис. 8.4)

Процедура вывода строки с эффектом раздвижения и звуковым сигналом.

CenterStr (рис. 8.5)

Функция создания строки заданной длины со вставленной в середину подстрокой

ZStr (рис. 8.6)

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

PosN (рис. 8.7)

Функция, возвращающая номер символа, с которого начинается N-е вхождение подстроки в строку

Глава 9. Математические возможности Турбо Паскаля

Binary (рис. 9.1)

Функция перевода целого числа в двоичное представление

Code2to1/Decode1to2 (рис.9.2)

Процедуры кодирования /декодирования двух малых числе в один байт

ATAN2 (рис. 9.3)

Функция возвращающая значение угла наклона оси X в радианах. Возвращаемое значение находится в диапазоне 0…2*Pi и учитывает знаки координат

AcrCos, ArcSin (рис 9.4)

Функции, возвращающие главные значения арккосинуса и арксинуса

Log10 (рис. 9.5)

Функция, возвращающая значение десятичного логарифма

Pwr (рис. 9.6)

Функция, возвращающая значение A в степени X (A > 0)

Gauss (рис. 9.7)

Функция, возвращающая случайное вещественное значение, распределенное по нормальному закону

Глава 11. Ссылки, динамические переменные и структуры

HeapAvall (рис. 11.7)

Функция, возвращающая размер свободной области кучи, которая расположена выше значения HeapPtr

Unit StackManager (рис. 11.10)

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

Глава 12. Ввод, вывод данных и файловая система

FileExists (рис. 12.11)

Функция проверки существования файла с данным именем

 ReadInteger (рис. 12.14)

Процедура ввода с клавиатуры значения типа Integer с игнорированием любого ввода, не соответствующего этому типу.

Глава 13. Объектно-ориентированное программирование

Program (рис. 13.8)

Каркас программы, реализующей полиморфные операции с динамически распределяемыми объектами с полной обработкой ошибок.

Глава 14. Специальные средства языка

Devices (рис. 14.3)

Программа – демонстрация анализа конфигурации ПЭВМ

FillWord (рис. 14.4)

Процедура заполнения блоков памяти значением типа Word (по аналогии с FillChar)

NewExit (рис. 14.7)

Демонстрация процедуры обработки фатальных ошибок и выхода из программы

Глава 15. Модуль CRT

IsBlinking, GetBackGround, GetForGround (рис. 15.5)

Функции проверки факта мерцания символов на экране, текущего цвета фона и символов

VertStr(рис. 15.9)

Процедура вертикального вывода строки

Spiral (рис.15.10)

Процедура закраски по спирали области экрана

Program (рис. 15.11)

Демонстрация работы процедуры ClrEOL

Program (рис. 15.12, 15.13)

Демонстрация работы процедуры InsLine/DelLine

Program (рис. 15.14)

Демонстрация работы процедуры HighVideo, LowVideo

SoundType (рис. 15.15)

Процедура звуковой печати строк

Phone, Bell, Sirena (рис. 15.16)

Процедуры имитации звуков телефонного звонка, зуммера и сирены

Глава 16. Модуль DOS

XDOSVersoin  (рис. 16.1)

Функция выдачи строки с номером версии MS-DOS

ShowSET (рис. 16.2)

Процедура вывода значений системных переменных MS-DOS

WhatDay (рис. 16.3)

Функция, возвращающая название дня недели по дате

Program (рис. 16.4)

Пример программы, анализирующей время своей работы

ChangeFTime (рис. 16.5)

Процедура смены даты и времени создания файла

Program (рис. 16.6)

Пример программы, анализирующей жесткие диски ПЭВМ

GetVoluve (рис. 16.7)

Функция, возвращающая метку заданного диска

FileExists(рис. 16.8)

Функция проверки существования файла

ShowDisk (рис. 16.9)

Процедура вывода каталога по заданному шаблону

PrintScreen (рис. 16.13)

Печать экрана на принтере, как при нажатии комбинации клавиш Shift+PrtScr

TestDrives (рис. 16.14)

Процедура определения множества имен дисков в ПЭВМ

Execute (рис. 16.17)

Функция запускает файл с параметрами и возвращает логическое значение True, если запуск был удачен.

HideScr (рис. 16.18)

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

Глава 17. Модуль Printer

TestPrinter (рис. 17.3)

Функция возвращает код состояния принтера LPT1 (PRN)

PrintFile (рис. 17.3)

Процедура печати файла на принтере, подключенном к LPT1, с анализом состояния принтера.

Program (рис. 17.4)

Резидентная программа перенаправления потоков печати

Глава 18. Модуль Overlay

Program (рис. 18.2)

Пример блока обработки ошибок при работе с оверлеями

Глава 19. Модуль Graph

CopyToPRN (рис. 19.27)

Процедура получения твердой копии изображения, полученного на экране в графическом режиме, на принтерах типа EPSON FX

Program (рис. 19.29)

Программа-каркас, моделирования движения бильярдного шара, использующая свойство режима XOR вывода изображения

Program (рис. 19.30)

Программа-каркас, использующая по кадровый алгоритм движения изображения (только для адаптеров EGA и VGA)

LoadFont (рис. 19.32)

Процедура связывания файла внешнего шрифта с паскаль-программой

LoadFont8x8 (рис.33)

Процедура замены системного шрифта DefaultFont на внешний, сконструированный в матрицах 8 x 8

UNIT BGI (рис. 19.36)

Модуль, составленный для включения всех BGI-драйверов и CHR-шрифтов (в том числе и собственных) в EXE-файл

Глава 20. Профессиональная работа с текстовыми изображениями

GetScreenPtr (рис. 20.1)

Функция, выдающая адрес видеопамяти в режиме текста

CurrentMode (рис. 20.2)

Функция, выдающая номер текущего текстового режима

Font8x8Yes (рис. 20.2)

Функция, выдающая True, если включен режим Font8x8

GetScreenSize (рис. 20.2)

Функция, выдающая длину видеопамяти в текущем режиме

GetColNum, GetRowNum(рис. 20.2)

Функции, выдающие текущее число столбцов и строк

FillArea (рис. 20.5)

Процедура заполнения прямоугольной области экрана символом в заданном цветовом атрибуте

ChangeAttr(рис. 20.5)

Процедура предназначения цветового атрибута прямоугольной области экрана

Program (рис. 20.7)

Пример, ведения системы окон с помощью средств модуля Win

SaveCurrentScreenOnDisk, LoadScreenFromDisk (рис. 20.8)

Процедура сохранения текущего тест-экрана на диске и его чтения

WriteChar (рис. 20.11)

Процедура вывода символа в виде изображения размером 8 х 8 позиций

WriteLargeString (рис. 20.11)

Процедура изображения строки большими буквами

SetCursorSize (рис. 20.13)

Процедура установки формы текстового курсора

SetNormalCursor, SetBlockCursor, SetNoCursor (рис. 2013)

Процедуры установки нормальной, блочной и невидимой формы

Глава 21. Как осуществить полный доступ к клавиатуре

ClrKeyBuf (рис. 21.1)

Процедура очистки буфера клавиатуры

Wait (рис. 21.2)

Процедура ожидания нажатия на клавиатуре

GetLockKey, SetLockKey (рис. 21.9)

Функция, анализирующая состояние режима xxLock и процедура управления им

UnReadKey (рис. 21.12)

Процедура, возвращающая в буфер клавиатуры значение, содержащее ASCII-код алфавитной клавиши

UnReadExtCode (рис. 21.12)

Процедура, возвращающая в буфер клавиатуры значение, содержащее расширенный код функциональной клавиши или алфавитной в режиме Alt

UnReadString (рис. 21.12)

Процедура помещения в буфер строки (до 16 символов)

Глава 22. Работа с оперативной памятью видеоадаптеров

WriteSym (рис. 22.9)

Процедура вывода символа заданного цвета на графический экран шрифтом текстового режима

WriteStr (рис. 22.10)

Процедура вывода строки на графический экран шрифтом текстового режима (только EGA и VGA)

SaveScreen (рис. 22.11)

Процедура записи на диск картинки с экрана, не превышающего размер 640x200 при 16 цветах

LoadScreen (рис. 22.12)

Процедура вывода на экран картинки, записанной на диск. Максимальный размер — весь экран в режиме 640x200 при 16 цветах

SaveBitPlanes, LoadBitPlanes (рис. 22.13)

Процедуры сохранения изображения всего экрана на диске и считывания его

SaveCGAScr, LoadCGAScr (рис. 22.14)

Процедуры сохранения изображения всего экрана на диске и его чтения для CGA-адаптеров

- 561 -

Индекс

В индексе представлены зарезервированные слова (записаны прописными буквами) и предопределенные идентификаторы языка Турбо Паскаль. После идентификатора стоит имя вводящего его модуля и буква, обозначающая его сущность: t — тип (type), с — константа (const), v — переменная (var), p — процедура (procedure), f — функция (function).

$

$DEFINE 57–58

$ELSE 57–59, 181, 183

$ENDIF 57–59

$IFDEF 57–59, 181

$IFNDEF 57–58

$IFOPT 57, 59, 183

$UNDEF 57, 59

A

AbsSystem.f 77, 175

ABSOLUTE 79–82, 292

Addr System.f 190–192, 197, 307

AND 77, 162, 166, 171–172

AndPut Graph.c 419, 452

AnyFile DOS.c 357

Append System.p 231, 235, 267–268

Arc Graph.p 406, 428–429, 439

ArcCoordsType Graph.t 429

Archive DOS.c 357

ArcTan System.f 175, 177

ARRAY 61, 69, 132–133

Assign System.p 221, 225–226, 268

AssignCRT CRT.p 315, 326, 343–344

ATT400 Graph.c 407, 413

ATT400Cx Graph.c 413

ATT400Hi Graph.c 413

ATT400Med Graph.c 413

В

Bar Graph.p 406, 439, 458

Bar3D Graph.p 406, 439

BEGIN 53, 93–94

BkSlashFill Graph.c 437

Black CRT.c 337, 438

Black Graph.c 441–442

Blink CRT.c 337, 442

BlockRead System.p 250–252, 267–268

BlockWrite System.p 250–252, 267–268

Blue CRT.c 337

Blue Graph.c 441–442

Boolean System.t 61, 64–66, 171, 241–242

BottomText Graph.c 464

Brown CRT.c 337

Brown Graph.c 441–442

BW40 CRT.c 329–330

BW80 CRT.c 329

Byte System.t 61–62, 65, 142, 164

С

C80 CRT.c 329

CASE 96–98, 138

CenterLn Graph.c 424

CenterText Graph.c 464

CGA Graph.c 407, 412

CGACx Graph.c 412

CGAHi Graph.c 412, 443

Char System.t 61, 64–65, 148–152

ChDir System.p 260–261, 267

CheckBreak CRT.v 320–322

CheckEOF CRT.v 319–320, 322–323

CheckSnow CRT.v 320–321, 331

Chr System.f 77, 152

Circle Graph. p 406, 427

ClearDevice Graph.p 406, 417, 423 ClearViewPort Graph.p 406, 423, 458

- 562 -

ClipOff Graph.c 456–458

ClipOnGraph.c 456–458

Close System.p 225–228, 263, 268

CloseDotFill Graph.c 437

CloseGraph Graph.p 405–406, 408

ClrEOL CRT.p 326, 334

ClrScr CRT.p 326, 329, 480

CO80 CRT.c 329–330

CompSystem.t 182

ComStr DOS.t 361

Concat System.f 153–154

CONST 53, 60, 75–76, 84

CONSTRUCTOR 283, 293

Copy System.f 153–154

CopyPut Graph.c 419-420, 452

Cos System.f 175

Cpu86 59

Cpu87 59

CRT модуль 7, 130–131, 314

CSeg System.f 189

CurrentDriver Graph.c 407

Cyan CRT.c 337

Cyan Graph.c 441–442

D

DarkGray CRT.c 337

DarkGray Graph.c 441-442

DashedLn Graph.c 424

DateTime DOS.t 350, 352–353

Dec System.p 176, 180

DefaultFont Graph.c 459–460, 462–464, 466

Delay CRT.p 326, 339, 342

Delete System.p 153, 155–156

DelLine CRT.p 326, 335–336

DESTRUCTOR 288

Detect Graph.c 407, 416

DetectGraph Graph.p 406, 413

Directory DOS.с 357

DOS модуль 7, 130–131, 345

DosError DOS.v 361–363, 381–382

DosExitCode DOS.f 379, 381–382

DosVersion DOS.f 346

DottedLn Graph.c 424

Double System.t 182–184

DOWNTO 101

Drawpoly Graph.p 406, 420, 430–431

DSegSystem.f 189, 306

E

EGA Graph.c 407, 412

EGA64 Graph.c 407, 413

EG A64Hi Graph.c 413

EGA64Lo Graph.c 413

EGABlack-EGAWhite Graph.c 446

EGAHi Graph.c 412

EGALo Graph.c 412

EGAMono Graph.c 407, 413

EGAMonoHi Graph.c 413

Ellipse Graph.p 406, 428, 439–440

ELSE 94–97

Empty Fill Graph.c 437

END 53, 71–72, 93–94

EnvCount DOS.f 346–348

EnvStr DOS.f 347–348

EOF System.f 226, 229–230, 259, 268, 322

EOLn System.f 232, 235–237, 268

Erase System.p 225, 228–229, 267–268

ErrorAddr System.v 309

Exec DOS.p 379–381

Exit System.p 105, 124

ExitCode System.v 309

ExitProc System.v 309, 311

Exp System.f 175

Extended System.t 182–184

EXTERNAL 112–113

ExtStrDOS.t 357, 361

F

Fail System.p 289, 292

False System.c 64–66, 68, 174

FExpand DOS.f 357, 360, 368

FILE 61, 224, 245, 249–250, 360

FileMode System.v 247, 267–268

FilePos System.f 255–257, 268

- 563 -

FileRec DOS.t 250, 358–360

FileSize System.f 255-257, 259, 268

FillChar System.p 151, 295, 299–301

FillEllipse Graph.p 406, 429, 440

FillPatternType Graph.c 436-437, 439

FillPoly Graph.p 406, 410, 440–441

FillSettingsType Graph.t 438

FindFirstDOS.p 356–357, 361–363, 365

FindNext DOS.p 356–357, 361–363, 365

FloodFill Graph.p 406, 410, 441

Flush System.p 232, 235, 268

fmClosed DOS.c 358

fmInOut DOS.c 358

fmInput DOS.c 358

fmOutput DOS.c 358

Font8x8 CRT.c 330, 473

FOR 100–103, 105, 108

FORWARD 112, 126–127, 272

Free System.f 175,179

FreeMem System.p 200–202, 204, 208–209, 312

FreeMin System.v 206–207

FreePtr System.v 206–207

FSearch DOS.f 356, 364–365

FSplit DOS.p 357, 360, 367

FUNCTION 107, 114

G

GetArcCoords Graph.p 406, 429

GetAspectRatio Graph.p 406, 427, 440

GetBkColor Graph.f 406, 443

GetCBreak DOS.p 346–347

GetColor Graph.f 406, 443

GetDate DOS.p 350

GetDefaultPalette Graph.p 406, 444

GetDir System.p 259–260, 268

GetDriverName Graph.f 406, 416

GetEnv DOS.f 346–348

GetFAttr DOS.p 356, 365–366

GetFillPattern Graph.p 406, 439

GetFillSettings Graph.p 406, 438

GetFTime DOS.p 350, 353–354

GetGraphMode Graph.f 406, 415, 419

GetImage Graph.p 406, 452, 454, 521

GetIntVec DOS.p 369, 371

GetLineSettings Graph.p 406, 425

GetMaxColor Graph.f 406, 442, 444

GetMaxMode Graph.f 406, 415–416

GetMaxX Graph.f 406, 421, 423

GetMaxY Graph.f 406, 421, 423

GetMem System.p 200–202,

207–210, 312

GetModeName Graph.f 406, 416

GetModeRange Graph.p 406, 407, 416

GetPalette Graph. p 406, 444

GetPaletteSize Graph.f 406, 444

GetPixel Graph. f 406, 448

GetTextSettings Graph.p 466

GetTime DOS. p 350–352

GetVerify DOS. p 346–347

GetViewSettings Graph.p 406, 457

GetX Graph.f 406, 423

GetY Graph.f 406, 423

GothicFont Graph.c 459

GOTO 102–105, 111

GotoXY CRT.p 326, 331–334, 464

Graph модуль 7, 130–131, 405

Graphs модуль 7–8, 130–131

GraphDefaults Graph.p 406, 417, 423

GraphErrorMsg Graph.f 406, 409–410

GraphResuIt Graph.f 406, 409, 414

Green CRT.c 337

Green Graph.c 441–442

grError Graph.c 411, 438, 444, 457, 462

grFileNotFound Graph.c 410

grFontNotFound Graph.c 410

grInvalidDeviceNum Graph.c 411

grInvalidDriver Graph.c 410

grInvalidFont Graph.c 411, 462

grInvalidFontNum Graph.c 462

grInvalidMode Graph.c 411

grIOError Graph.c 411

grNoInitCraph Graph.c 410

grNoFloodMem Graph.c 410

grNoFontMem Graph.c 410

grNoLoadMem Graph.c 410

grNoScanMem Graph.c 410

grNotDetected Graph.c 410, 414

grOk Graph.c 410

H

Halt System.p 106, 202, 309, 311

HatchFill Graph.c 437

- 564 -

НеарError System.v 209–211

HeapOrg System.v 198–199, 204

HeapPtr System.v 198–199, 203,

206–207

HercMono Graph.c 407

HercMonoHi Craph.c 413

HiSystem.f 77, 304, 306

Hidden DOS.c 357, 367

HighVideo CRT.p 326, 338

HorizDir Graph.c 459

I

IBM8514 Graph.c 407, 413

IBM8514Lo Graph.c 413

IF 94–98

ImageSize Graph.f 406, 451–452, 522

IMPLEMENTATION 125, 127, 129

IN 77, 152, 163

IncSystem.p 176, 180

InitGraph Graph.p 405–408, 410, 414–418, 423

INLINE 115, 126, 305–307

INLINE директива 307

InOutRes System.v 262

Input System.v 229, 231, 236, 238, 315–316

Insert System.p 154–156

InsLine CRT.p 326, 335–336

InstallUserDriver Graph.f 406, 469

InstallUserFont Graph.f 407, 462

IntSystem.f 175, 179, 306

Integer System.t 61–63, 165

INTERFACE 125–126, 129

InterleaveFill Graph.c 437

INTERRUPT 115, 126, 371–372

IntrDOS.p 370, 373

IOResult System.f 262, 265, 267

К

KeepDOS.p 379, 384

KeyPressed CRT.f 326, 342–343

L

LABEL 52–53, 104

LastMode CRT.v 320, 330–331, 473

LeftText Graph.c 464

Length System.f 77, 153–154, 193

LightBlue CRT.c 337

LightBlue Graph.c 441–442

LightCyan CRT.c 337

LightCyan Graph.c 441–442

LightGray CRT.c 337

LightGray Graph.c 441–442

LightGreen CRT.c 337

LightGreen Graph.c 441–442

LightMagenta CRT.c 337

LightMagenta Graph.c 441–442

LightRed CRT.c 337

LightRed Graph.c 441–442

Line Graph.p 406, 420, 424, 457

LineFill Graph.c 437

LineRel Graph.p 406, 420, 423–424, 426

LineSettingsType Graph.t 424–425

LineTo Graph.p 406, 420, 423–424

Ln System.f 175, 313

Lo System.f 77, 304, 306

LongInt System.t 61–63, 165, 175–176

LowVideo CRT.p 326, 338

Lst Printer .v 387–388

LtBkSlashFill Graph.c 437

LtSlashFill Graph.c 437

M

Magenta CRT.c 337

Magenta Graph.c 441–442

Mark System.p 200, 202–204

MaxAvall System.f 200, 204–205, 207

MaxColors Graph.c 444

MCGA Graph.c 407, 412

MCGACx Graph.c 412

MCGAHi Graph.c 412

MCGAMed Graph.c 412

MemAvail System.f 200, 204–205, 207

Mem System.v 297–298

MemL System.v 297–298

MemW System. v 297–298;

MkDir System.p 260–261, 267

MOD 77, 162, 164

Mono CRT.c 324, 330

Move System.p 295, 301–304

MoveRel Graph.p 406, 423

- 565 -

MoveTo Graph.p 406, 423, 426

MsDos DOS.p 370, 373–374

MsDos 59

N

NameStrDOS.t 357, 361

New System.pf 200–204, 209–210, 287–289, 312

NIL 195, 289

NormVideo CRT.p 326, 331, 338

NormWidth Graph.c 424

NoSound CRT.p 326, 339

NOT 77, 162, 166, 171

NotPut Graph.c 419, 452

О

OBJECT 61, 72, 271, 276

Odd System.f 77, 176

OF 61, 97, 142

Ofs System.f 190–192, 206, 307

OR 77, 163, 166, 168, 172

Ord System.f 67, 77, 152, 154

OrPut Graph.c 419, 452

Output System.v 231, 238, 241, 315–316

OutText Graph.p 158, 407, 423, 463

OutTextXY Graph.p 158, 407, 463,

465, 470

Overlay модуль 7, 130–131, 393

OvrClearBuf Overlay.p 399–400

OvrCodeList System.v 403

OvrDebugPtr System.v 403

OvrDosHandle System.v 403

OvrEMSHandle System.v 403

OvrError Overlay.с 396–397, 399

OvrFileMode Overlay .v 402–403

OvrGetBuf Overlay.f 398, 400–401

OvrGetRetry Overlay.f 401

OvrHeapEnd System.v 400, 403

OvrHeapOrg System.v 400, 403

OvrHeapPtr System.v 403

OvrHeapSize System.v 399, 403

OvrInit Overlay.p 395–397, 399, 401–404, 313

OvrInitEMS Overlay.p 397, 399, 401

OvrIOError Overlay.c 396–397

OvrLoadCount Overlay .v 401–402

OvrLoadList System.v 403

OvrNoEMSDriver Overlay.c 396–397

OvrNoEMSMemory Overlay.c396-397

OvrNoMemory Overlay.c 396–397, 399

OvrNotFound Overlay.c 396

OvrOk Overlay .с 396

OvrReadBuf Overlay .v 402

OvrReadFunc Overlay.t 402

OvrResult Overlay.f 396–397, 399, 402

OvrSetBuf Overlay.p 399–400

OvrSetRetry Overlay.p 401

OvrTrapCount Overlay.v 401–402

P

PACKED 135

PackTime DOS.p 350, 353

PaletteType Graph.t 444–445

ParamCount System.f 295–296

ParamStr System.f 295–297

PathStr DOS.t 356–357, 361

PC3270 Graph.c 407, 413, 443

PC3270Hi Graph.c 413

Pi System.f 175, 177

PieSlice Graph.p 406, 429, 440

Pointer System.t 61, 65, 189–190,

194–195

PointType Graph.t 436, 441

Port System.v 298–299

PortW System.v 299

Pos System.f 154, 157–158

Pred System.f 67–68, 77, 152

PrefixSeg System.v 187

Printer модуль 7, 130–131, 387

PROCEDURE 106, 114, 283

PROGRAM 51, 141

Ptr System.f 77, 190, 192–193, 197

PutImage Graph.p 406, 452, 454, 458, 522

PutPixel Graph.p 406, 450

R

Random System.f 176, 179–180

Randomize System.p 176, 179

RandSeed System.v 180

Read System.p 247, 267–269

Read System.p (текст) 238–242, 316, 318, 342

- 566 -

ReadKey CRT.f 326, 342–343, 496

ReadLn System.p 238, 241, 268–269,

315-316, 3V8, 342

ReadOnly DOS.c 357, 367

RealSystem.t 61, 63, 183

RECORD 61, 71, 135–136

Rectangle Graph.p 406, 420, 430

Red CRT.c 337

RegisterBGIdriver Graph.f 406, 461

RegisterBGIfont Graph.f 407, 461

Registers DOS.t 370, 374

Release System.p 200, 202, 203, 204

Rename System.p 225, 228–229, 267–268

REPEAT 99–100

Reset System.p 225, 227, 247, 250,

267–268

RestoreCrtMode Graph.p 405–406, 418–419

Rewrite System.p 225, 227, 247, 250, 267–268

RightText Graph.c 464

RmDir System.p 260–261, 267–268

Round System.f 77, 176, 179, 185

RunError System.p 311

S

SansSerifFont Graph.c 459

SaveIntNN System.v 379

SearchRec DOS.t 356–357, 362

Sector Graph.p 406, 429, 439–440

Seek System.p 255, 257, 259, 268

SeekEOF System.f 232, 237–238, 268

SeekEOLn System.f 232, 237, 268

Seg System.f 190–192, 307

Self System.v 273–274, 292–293

SET 61, 70, 142

SetActivePage Graph.p 406, 454, 456

SetAllPalette Graph.p 406, 444

SetAspectRatio Graph.p 406, 427

SetBkColor Graph.p 406, 442

SetCBreakDOS.p 346, 347

SetColor Graph.p 406, 442

SetDateDOS.p 350

SetFAttrDOS.p 356, 365–366

SetFillPattern Graph.p 406, 437

SetFillStyle Graph.p 406, 437–438

SetFTimeDOS.p 350, 353–354

SetGraphBufSize Graph.p 406

SetGraphMode Graph.p 405-406, 417, 423, 521

SetIntVecDOS.p 369, 371

SetLineStyle Graph.p 406, 425

SetPalette Graph.p 406, 444

SetRGBPalette Graph.p 406, 446

SetTextBuf System.p 227, 231–235

SetTextJustify Graph.p 407, 464

SetTextStyle Graph.p 407, 459, 462, 464–466

SetTimeDOS.p 350–352

SetUserCharSize Graph.p 407, 466

SetVerifyDOS.p 346, 347

SetViewPort Graph.p 406, 423, 457–458

SetVisualPage Graph.p 406, 454, 456

SetWriteMode Graph.p 406, 419-420, 452

SHL 162, 169–170

Shortint System.t 61–62, 165

SHR 162, 169

Sin System.f 175

Single System.t 182–184

SizeOf System.f 77, 190, 193, 292, 299

SlashFill Graph.c 437

SmallFont Graph.c 459

SolidFill Graph.c 437–438

SolidLn Graph.c 424

Sound CRT.p 326, 339–340, 342

SPtr System.f 189

Sqr System.f 175

Sqrt System.f 175, 313

SSeg System.f 189, 306

StackLimit System.v 188

Str System.p 154, 157–159, 185

STRING 61, 64, 148, 149

Succ System.f 67–68, 77, 103, 152

Swap System.f 77, 304

SwapVectorsDOS.p 379

SysFile DOS.c 357

System модуль 7, 130–131

Т

Test8087 System.v 181

TextSystem.t 61, 223, 231, 360

- 567 -

TextAttr CRT.v 320, 323–324, 337–338, 474

TextBackground CRT.p 324, 326, 329, 337

TextBuf DOS.t 359

TextColor CRT.p 324, 326, 337

TextHeight Graph.f 407, 465

TextMode CRT.p 326, 329–331

TextRec DOS.t 359–360

TextSettingsType Graph.t 466

TextWidth Graph.f 407, 465

THEN 94–95

ThickWidth Graph.c 424

TO 101

TopOff Graph.c 439

TopOn Graph.c 439

TopText Graph.c 464

TriplexFont Graph.c 459

True System.c 64–66, 68, 174

Trunc System.f 77, 175, 179, 313

Truncate System.p 255, 259

Turbo3 модуль 7–8, 130–131

TYPE 53, 60, 273

TypeOf System.f 292

U

UNIT 124–125

UnpackTime DOS.p 350, 353

UNTIL 99–100

UpCase System.f 152

UserBitLn Graph.c 424–425

UserFill Graph.c 437–438

USES 52-53, 124–130, 394–395

V

Val System.p 154, 160

VAR 53–54, 78, 84, 109

Ver55 59

VertDir Graph.c 459

VGA Graph.c 407, 413

VGAHi Graph.c 413

VGALo Graph.c 413

VGAMed Graph.c 413

ViewPortType Graph.t 456, 457

VIRTUAL 282

VolumeID DOS.c 357

W

WhereX CRT.f 326, 334

WhereY CRT.f 326, 334

WHILE 98–100, 103

White CRT.c 337

White Graph.c 441–442

WideDotFill Graph.c 437

Win модуль 8, 479

WindMax CRT.v 320, 328–329

WindMin CRT.v 320, 328–329

Window CRT.p 325, 327–329, 479–480

WITH 140–141, 273–274

Word System.t 61-63, 65, 164

Write System.p 267, 269, 314–316

Write System.p (текст) 238, 241–243, 314–316, 332

WriteLn System.p 238, 241–242, 268–269, 316, 332

X

XHatchFill Graph.c 437

XOR 77, 163, 166, 168, 172

XORPut Graph.c 419, 452

Y

Yellow CRT.c 337

Yellow Graph.c 441–442

- 568 -

ЛИТЕРАТУРА

1. Turbo Pascal Version 5.0 User's Guide. — Borland International, 1988.

2. Turbo Pascal Version 5.0 Reference Guide. — Borland International, 1988.

3. Turbo Pascal Version 5.5 Object-Oriented Programming Guide. — Borland International, 1989.

4. Microsoft MS-DOS 3.3 Programmer's Reference. — Microsoft Corporation, 1987.

5. *Duntemann J. Turbo Pascal Solutions. — Scott, Foresman and Company, 1988.

6. *Dutton F. Turbo Pascal Toolbox. — SYBEX, 1988.

7. Hergert D. Mastering Turbo Pascal 5. — SYBEX, 1988.

8. Rankin, John R. Computer graphics software constructions. —

Prentice Hall, 1989.

КНИГИ, ОПИСЫВАЮЩИЕ СТАНДАРТНЫЙ ПАСКАЛЬ

Абрамов В.Г., Трифонов Н.П., Трифонова Г.Н. Введение в язык Паскаль. — М.: Наука, 1988.

Грогоно П. Программирование на языке Паскаль / Пер. с англ. — М.: Мир, 1982.

Йенсен К., Вирт Н. Паскаль. Руководство для пользователя / Пер. с англ. — М.: Финансы и статистика, 1989.

* В книгах рассматривается Турбо Паскаль версий 3.0 и 4.0

- 569 -

Оглавление

От автора ................... 3

Введение ................... 5

Часть I. РАБОТА В СРЕДЕ ПРОГРАММИРОВАНИЯ

ТУРБО ПАСКАЛЬ

1. Интегрированная среда....... 9

1.1. Окно просмотра результатов Output .............. 11

1.2. Окно просмотра переменных Watch .............. 12

1. 3. Структура меню ........... 12

1.3.1. Пункт File (работа с файлами) ................. 14

1.3.2. Пункт Edit (работа с редактором) .............. 18

1.3.3. Пункт Run (запуск на выполнение) ............. 20

1.3.4. Пункт Compile (компиляция) .................. 22

1.3.5. Пункт Options (установка параметров системы) ... 26

1.3.6. Пункт Debug (установки отладчика) ............ 35

1.3.7. Пункт Break/Watch (точки останова/обзор) ....... 40

1.4. Интерактивная справка...... 42

2. Настройка системы............. 45

2.1. Система настройки среды программирования ... 45

2.2. Принятые в системе расширения имен файлов...... 47

Часть II. ЯЗЫК ТУРБО ПАСКАЛЬ

3. Построение программ......... 49

3.1. Алфавит языка и зарезервированные слова......... 49

3.2.Общая структура программ ...................... 51

3.3.Комментарии и ключи компиляции ............... 54

3.4.Условная компиляция программ.................. 57

4. Введение в систему типов языка................... 60

4.1. Простые типы языка ........ 62

4.1.1. Целочисленные типы ...... 62

4.1.2. Вещественные числа....... 63

4.1.3. Логический тип........... 64

4.1.4. Символьный тип.......... 64

4.1.5. Строковый тип ........... 64

4.1.6.Адресный тип............. 65

4.1.7. Перечислимые типы ...... 65

4.1.8. Ограниченные типы (диапазоны) .............. 68

4.2 Сложные типы языка ......... 69

5. Константы и переменные....... 75

5.1. Простые константы........... 75

5.2. Переменные ................ 77

5.2.1. Совмещение адресов директивой absolute ....... 79

5.2.2. Переменные со стартовым значением или типизированные константы...82

5.3. Операция присваивания и совместимость типов и значений............... 85

5.4. Изменение (приведение) типов и значений.......... 89

6. Управляющие структуры языка..................... 93

6.1. Простой и составной операторы................... 93

6.2. Условный оператор (IF...THEN...ELSE) ........... 94

6.3. Оператор варианта (CASE) ................. 96

6.4. Оператор цикла с предусловием (WHILE) ..... 98

6.5. Оператор цикла с постусловием (REPEAT...UNTIL)... 99

6.6. Оператор цикла с параметром (FOR...DO) ......... 100

6.7. Оператор безусловного перехода Goto ............ 103

6.8. Операторы Exit и Halt......... 105

6.9. Процедуры и функции ....... 106

6.9.1. Параметры. Глобальные и локальные описания..................... 107

6.9.2. Опережающее описание процедур и функций.... 112

6.9.3. Объявление внешних процедур................ 113

6.9.4. Процедуры и функции как параметры.......... 113

6.9.5. Переменные-процедуры и функции............ 116

6.9.6. Специальные приемы программирования....... 117

6.10. Модули. Структура модулей.................... 124

6.11. Особенности работы с модулями ................ 127

6.12. Система библиотечных модулей языка........... 130

Часть III. СРЕДСТВА ЯЗЫКА ТУРБО ПАСКАЛЬ

7. Массивы, записи и множества в деталях............. 132

7.1. Массивы (Array) и работа с ними ............... 132

7.2. Тип «запись» (Record) и оператор присоединения With ............... 136

7.3. Тип «множество» (Set). Операции с множествами..................... 142

8. Обработка символов и строк ...................... 148

8.1. Символьный и строковый типы (Char и String) .... 148

8.2. Операции над символами ...................... 151

8.3. Операции над строками........................ 152

8.3.1. Редактирование строк....................... 154

8.3.2. Преобразование строк....................... 158

9. Математические возможности Турбо Паскаля.......... 161

9.1. Базовые операции.......... 161

9.2. Битовая арифметика........ 164

9.3. Логические вычисления и операции отношения ... 171

9.4. Математические процедуры и функции .......... 175

9.4.1. Обсуждение математических функций языка ... 177

9.4.2. Генераторы случайных чисел ................ 179

9.4.3. Оптимизация сложения и вычитания........... 180

9.5. Использование математического сопроцессора 80X87.................. 180

10. Код программы, данные, адреса .................... 186

10.1. Система адресации MS-DOS................... 186

10.2. Распределение памяти при выполнении программ .................... 187

10.3. Анализ расположения кода и областей данных программы...............189

10.4. Тип Pointer ................ 189

10.5. Средства для работы с адресами ............. 190

10.5.1. Определение адреса переменных............. 191

10.5.2. Создание адреса функцией Ptr ............. 192

10.5.3. Определение размеров типов и переменных .. 193

11. Ссылки, динамические переменные и структуры... 194

11.1. Ссылочные переменные ....................... 194

11.2. Операция разыменования ..................... 196

11.3. Организация памяти области кучи............. 197

11.4. Управление размерами области кучи и стека... 199

11.5. Процедуры управления кучей ................. 199

11.5.1. Размещение динамических переменных. Процедуры New и GetMem..... 200

11.5.2. Освобождение динамических переменных. Процедуры Dispose и FreeMem.... 201

11.5.3. Управление состоянием кучи. Процедуры Mark и Release......... 202

11.5.4. Анализ состояния кучи. Функции MaxAvail и MemAvail.......... 204

11.5.5.Более детальный анализ состояния кучи ...... 205

11.5.6. Обработка ошибок распределения памяти..... 209

11.6. Ссылки, работающие не с кучей................ 211

11.7. Как организовать структуры, большие чем 64K? ..................... 212

11.8. Практический пример построения стека.......... 214

12. Ввод-вывод данных и файловая система. 220

12.1. Понятие логического файла .................... 220

12.2. Физические файлы в MS-DOS .................. 221

12.3. Понятие буфера ввода-вывода .................. 223

12.4. Файловые типы Турбо Паскаля................. 223

12.5. Общие процедуры для работы с файлами ........ 225

12.5.1. Связывание файлов........................ 226

12.5.2. Открытие файлов....... 227

12.5.3. Закрытие файлов........ 227

12.5.4. Переименование файлов..................... 228

12.5.5. Удаление файлов........ 229

12.5.6. Анализ состояния файлов.................... 229

12.6. Текстовые файлы .......... 230

12.6.1. Текст-ориентированные процедуры и функции ................... 231

12.6.2. Операция ввода-вывода в текстовые файлы.... 238

12.7. Типизированные файлы и операции ввода-вывода..................... 245

12.8. Бестиповые файлы и операции ввода-вывода...... 249

12.9. Последовательный и прямой доступ к файлам..... 254

12.9.1. Опрос размеров файлов и позиции в них ....... 256

12.9.2. Позиционирование в файлах................. 257

12.9.3. Усечение файлов........ 259

12.10. Процедуры для работы с каталогами............ 259

12.11. Обработка ошибок ввода-вывода............... 261

12.11.1. Функция IOResult ...... 262

12.11.2. Примеры обработки ошибок ввода-вывода.... 262

12.11.3. Сводка номеров ошибок ввода-вывода....... 266

13. Объектно-ориентированное программирование....... 270

13.1. Определения объектов........................ 270

13.2. Область действия полей объекта и параметр Self .................... 273

13.3. Наследование ............. 275

13.4. Присваивание объектов........................ 279

13.5. Полиморфизм............ 280

13.5.1. Статические методы ....................... 281

13.5.2. Виртуальные методы....................... 282

13.5.3. Выбор вида метода...... 286

13.6. Динамические объекты........................ 286

13.6.1. Создание динамических объектов............. 286

13.6.2. Освобождение объектов. Деструкторы......... 288

13.6.3. Обработка ошибок при работе с динамическими объектами.......... 289

13.7. Функции TypeOf и SizeOf ....................... 292

13.8. Задание стартовых значений объектам............ 293

13.9. Модули, экспортирующие объекты.............. 293

14. Специальные средства языка....................... 295

14.1. Работа с командной строкой. Функции ParamCount и ParamStr.......... 295

14.2. Доступ к памяти ПЭВМ. Массивы Mem, MemW, MemL............... 297

14.3. Доступ к портам ввода-вывода. Массивы Port и PortW................ 298

14.4. Процедура заполнения FillChar ................ 299

14.5. Процедура перемещения данных Move.......... 301

14.6. Функции обработки машинных слов Lo.Hi и Swap................... 304

14.7. Вставки машинного кода в программе.......... 304

14.7.1. Оператор inline ........ 304

14.7.2. Процедуры с директивой inline.............. 307

14.8. Процедура завершения и обработка ошибок программ ................ 307

14.8.1. Оператор RunError...... 311

14.8.2. Сводка номеров фатальных ошибок.............. 311

Часть IV. СПЕЦИАЛЬНЫЕ БИБЛИОТЕКИ ЯЗЫКА

15. Модуль CRT ................. 314

15.1. Вывод специальных символов.................. 316

15.2. Модификация операторов Read, ReadLn.......... 318

15.3. Системные переменные модуля CRT............. 319

15.3.1. Переменные управления выводом на дисплей..................... 320

15.3.2. Переменные управления работой клавиатуры..................... 321

15.3.3. Переменная TextAttr....................... 323

15.4. Процедуры и функции модуля CRT............. 325

15.4.1. Работа с экраном в целом................... 327

15.4.2. Позиционирование курсора................. 331

15.4.3. Работа со строками........................ 334

15.4.4. Настройка цвета........ 337

15.4.5. Подача звуковых сигналов.................. 339

15.4.6. Использование встроенного таймера.......... 342

15.4.7. Опрос клавиатуры ...... 342

15.4.8. Переназначение стандартных файлов......... 343

16. Модуль DOS ................. 345

16.1. Опрос и установка параметров MS-DOS......... 346

16.1.1. Управление параметрами BREAK и VERIFY... 347

16.1.2. Опрос системных переменных MS-DOS....... 347

16.2. Работа с часами и календарем .................. 349

16.2.1. Опрос и назначение даты.................... 350

16.2.2. Опрос и назначение времени................. 351

16.2.3. Работа с датой создания файлов.............. 352

16.3. Анализ ресурсов дисков....................... 354

16.4. Работа с каталогами и файлами................. 356

16.4.1. Типы и константы модуля DOS для работы с файлами . 357

16.4.2. Переменная DosError....................... 361

16.4.3. Процедуры поиска файлов на диске........... 362

16.4. 4. Работа с атрибутами файлов................. 365

16.4.5. Анализ имен файлов........................ 367

16.5. Работа с прерываниями MS-DOS................ 369

16.5.1. Чтение и перестановка адресов подпрограмм прерываний ........ 370

16.5.2. Процедура Keep прерывания процедурой Intr... 373

16.5.3. Процедура MsDos ....... 373

16.6. Организация субпроцессов и резидентных программ................... 375

16.6.1. Программирование субпроцессов............. 379

16.6.2 Процедура Keep и резидентные программы..... 384

17. Модуль Printer................. 387

17.1. Содержание модуля Printer...................... 387

17.2. Низкоуровневые средства работы с принтером.... 388

17.3. Работа с двумя принтерами одновременно........ 390

18. Модуль Overlay................ 393

18.1. Оверлейное построение программ................ 393

18.2. Правила оформления оверлейных программ....... 394

18.3. Инициализация работы оверлеев................. 395

18.3.1. Включение администратора оверлеев......... 395

18.3.2. Анализ результата инициализации............ 396

18.3.3. Размещение оверлейного файла в EMS-памяти .................... 397

18.4. Управление оверлейным буфером............... 398

18.4.1. Опрос размера буфера ..................... 399

18.4.2. Установка размера буфера................... 399

18.4.3. Принудительная очистка буфера.............. 400

18.5. Оптимизация работы оверлеев .................. 400

18.5.1. Установка размера области испытаний........ 401

18.5.2. Подсчет вызовов оверлеев................... 401

18.6. Предопределенные переменные для работы с оверлеями............... 402

18.7. Включение оверлеев в ЕХЕ-файлы.............. 403

19. Модуль Graph................. 405

19.1. Файлы BGI и содержимое модуля Graph......... 405

19.2. Управление графическими режимами............ 407

19.2.1. Инициализация и закрытие графического режима................. 407

19.2.2. Обработка ошибок инициализации........... 408

19.2.3. Классификация и анализ графических режимов................... 412

19.2.4. Очистка экрана и переключение режимов..... 416

19.2.5. Управление режимом вывода отрезков на экран................... 419

19.3. Системы координат и «текущий указатель» ...... 421

19.3.1. Координаты устройства и мировые координаты................... 421

19.3.2. Управление «текущим указателем» .......... 423

19.4. Рисование графических примитивов и фигур...... 424

19.4.1. Линии и их стили ....... 424

19.4.2. Коэффициент сжатия изображения............ 426

19.4.3. Окружности, эллипсы и дуги................. 427

19.4.4. Построение прямоугольников и ломаных...... 430

19.5. Управление цветами и шаблонами заливки (заполнения............. 432

19.5.1. Немного о цветах ........ 432

19.5.2. Задание типа заливки........................ 435

19.5.3. Заливка областей изображения............... 439

19.5.4. Опрос и установка цветов пера и фона......... 441

19.5.5. Управление палитрой....................... 443

19.6. Битовые графические операции................. 448

19.6.1. Битовые операции ...... 448

19.6.2. Работа с фрагментами изображений........... 451

19.7. Управление видеостраницами................... 454

19.8. Графические окна.......... 456

19.9. Вывод текста.............. 458

19.9.1. Выбор шрифта и стиля...................... 458

19.9.2. Предварительная загрузка и регистрация шрифтов................. 460

19.9.3. Непосредственный вывод строк.............. 463

19.9.4. Размер букв и его масштабирование........... 464

19.9.5. Опрос стиля и ориентации шрифтов........... 466

19.10. Включение шрифтов и драйверов в ЕХЕ-файл.... 466

19.11. Подключение новых драйверов................. 469

19.12. Один полезный совет...... 469

Часть V. ПРАКТИЧЕСКИЕ ПРИЕМЫ РАБОТЫ С ПЭВМ

20. Профессиональная работа с текстовыми изображениями................... 471

20.1. Программный опрос режимов текстового дисплея..................... 471

20.2. Организация доступа к видеопамяти............. 474

20.3. Запоминание окон экрана и их восстановление.... 478

20.3.1. Общие принципы работы с окном ............ 478

20.3.2. Модуль Win............ 479

20.4. Работа с образом экрана на диске................ 484

20.5. Крупные надписи на экране .................... 486

20 6. Управление формой курсора.................... 489

21. Как осуществить полный доступ к клавиатуре......... 493

21.1. Как организовать опрос алфавитно-цифровой клавиатуры............ 493

21.2. Опрос клавиши в регистре Ctrl.................. 496

21.3. Опрос расширенных кодов и функциональных клавиш................ 499

21.4. Опрос служебных клавиш ..................... 501

21.5. Анализ клавиш регистров и их состояния......... 502

21.6. Скэн-коды клавиатуры и работа с ними.......... 505

21.7. Эффект обратной записи в буфер ввода........... 510

22. Работа с оперативной памятью видеоадаптеров........ 514

22.1. Многобитовое и многоплоскостное ОЗУВ......... 514

22.2. Карта дисплейной памяти....................... 515

22.3. Вывод текста на графический экран.............. 518

22.4. Работа с графическими образами на диске 520

Приложение 1. Сообщения и коды ошибок, генерируемые

компилятором.................... 527

Приложение 2. Ключи и директивы компилятора ......... 540

Приложение 3. Использование компилятора TPC.......... 547

Приложение 4. Список утилит пакета Турбо Паскаль ...... 549

Приложение 5. Команды встроенного редактора.......... 553

Приложение 6. Автоматическая оптимизация программ.... 555

Приложение 7. Список демонстрационных процедур и функций................ 556

Индекс........................... 561

Литература....................... 568

Справочное издание

Поляков Дмитрий Борисович

Круглов Игорь Юрьевич

Программирование в среде Турбо Паскаль (версия 5.5)

Редактор Г.Н. Борисова

Художественный редактор И.Ю. Круглов

Технический редактор Л.А. Леманская

Художник обложки И.Ю. Круглов

ИБ № 56

Подписано в печать 15.01.92. Бум. тип. № 2. Формат 84 х 1081/32 Гарнитура литературная. Усл. печ. л. 45,51. Уч.-изд. л. 45,54 Печать высокая. Тираж 50000 экз. Заказ № 3886.

Издателъство МАИ, 125871, Москва, Волоколамское шоссе, 4

Отпечатано с готового оригинал-макета в ордена Октябрьской

Революции и ордена Трудового Красного Знамени МПО «Первая

Образцовая типография» Министерства печати и информации

Российской Федерации. 113054, Москва, Валовая, 28.

- 577 -

Оглавление

Д. Б. Поляков, И.Ю. Круглов Программирование в среде Турбо Паскаль

  От авторов

  Введение

  Часть I. РАБОТА В СРЕДЕ ПРОГРАММИРОВАНИЯ ТУРБО ПАСКАЛЬ

    Глава 1. Интегрированная среда

      1.1. Окно просмотра результатов Output

      1.2. Окно просмотра переменных Watch

      1.3. Структура меню

        1.3.1. Пункт File (работа с файлами)

        1.3.2. Пункт Edit (работа с редактором)

        1.3.3. Пункт Run (запуск на выполнение)

        1.3.4. Пункт Compile (компиляция)

        1.3.5. Пункт Options (установка параметров системы)

        1.3.6. Пункт Debug (установки отладчика)

        1.3.7. Пункт Break/Watch (точки останова/обзор)

      1.4. Интерактивная справка

    Глава 2. Настройка системы

      2.1. Система настройки среды программирования

      2.2. Принятые в системе расширения имен файлов

  Часть II. Язык Турбо Паскаль

    Глава 3. Построение программ

      3.1. Алфавит языка и зарезервированные слова

      3.2. Общая структура программ

      3.3. Комментарии и ключи компиляции

      3.4. Условная компиляция программ

    Глава 4. Введение в систему типов языка

      4.1. Простые типы языка

        4.1.1. Целочисленные типы

        4.1.2. Вещественные числа

        4.1.3. Логический тип

        4.1.4. Символьный тип

        4.1.5. Строковый тип

        4.1.6. Адресный тип

        4.1.7. Перечислимые типы

        4.1.8. Ограниченные типы (диапазоны)

      4.2. Сложные типы языка

    Глава 5. Константы и переменные

      5.1. Простые константы

      5.2. Переменные

        5.2.1. Совмещение адресов директивой absolute

        5.2.2. Переменные со стартовым значением или типизированные константы

      5.3. Операция присваивания и совместимость типов и значений

      5.4. Изменение (приведение) типов и значений

    Глава 6. Управляющие структуры языка

      6.1. Простой и составной операторы

      6.2. Условный оператор (IF...THEN...ELSE)

      6.3. Оператор варианта (CASE)

      6.4. Оператор цикла с предусловием (WHILE)

      6.5. Оператор цикла с постусловием (REPEAT...UNTIL)

      6.6. Оператор цикла с параметром (FOR...DO)

      6.7. Оператор безусловного перехода Goto

      6.8. Операторы Exit и Halt

      6.9. Процедуры и функции

        6.9.1. Параметры. Глобальные и локальные описания

        6.9.2. Опережающее описание процедур и функций

        6.9.3. Объявление внешних процедур

        6.9.4. Процедуры и функции как параметры

        6.9.5. Переменные-процедуры и функции

        6.9.6. Специальные приемы программирования

      6.10. Модули. Структура модулей

      6.11. Особенности работы с модулями

      6.12. Система библиотечных модулей языка

  Часть III. Средства языка Турбо Паскаль

    Глава 7. Массивы, записи и множества в деталях

      7.1. Массивы (Array) и работа с ними

      7.2. Тип «запись» (Record) и оператор присоединения With

      7.3. Тип «множество» (Set). Операции с множествами

    Глава 8. Обработка символов и строк

      8.1. Символьный и строковый типы (Char и String)

      8.2. Операции над символами

      8.3. Операции над строками

        8.3.1. Редактирование строк

        8.3.2. Преобразование строк

    Глава 9. Математические возможности Турбо Паскаля

      9.1. Базовые операции

      9.2. Битовая арифметика

      9.3. Логические вычисления и операции отношения

      9.4. Математические процедуры и функции

        9.4.1. Обсуждение математических функций языка

        9.4.2. Генераторы случайных чисел

        9.4.3. Оптимизация сложения и вычитания

      9.5. Использование математического сопроцессора 80X87

    Глава 10. Код программы, данные, адреса

      10.1. Система адресации MS-DOS

      10.2. Распределение памяти при выполнении программ

      10.3. Анализ расположения кода и областей данных программы

      10.4. Тип Pointer

      10.5. Средства для работы с адресами

        10.5.1. Определение адреса переменных

        10.5.2. Создание адреса функцией Ptr

        10.5.3. Определение размеров типов и переменных

    Глава 11. Ссылки, динамические переменные и структуры

      11.1. Ссылочные переменные

      11.2. Операция разыменования

      11.3. Организация памяти области кучи

      11.4. Управление размерами области кучи и стека

      11.5. Процедуры управления кучей

        11.5.1. Процедуры New и GetMem

        11.5.2. Процедуры Dispose и FreeMem

        11.5.3. Процедуры Mark и Release

        11.5.4. Функции MaxAvail и MemAvail

        11.5.5. Более детальный анализ состояния кучи

        11.5.6. Обработка ошибок распределения памяти

      11.6. Ссылки, работающие не с кучей

      11.7. Как организовать структуры, большие чем 64К?

      11.8. Практический пример построения стека

    Глава 12. Ввод-вывод данных и файловая система

      12.1. Понятие логического файла

      12.2. Физические файлы в MS-DOS

      12.3. Понятие буфера ввода-вывода

      12.4. Файловые типы Турбо Паскаля

      12.5. Общие процедуры для работы с файлами

        12.5.1. Связывание файлов

        12.5.2. Открытие файлов

        12.5.3. Закрытие файлов

        12.5.4. Переименование файлов

        12.5.5. Удаление файлов

        12.5.6. Анализ состояния файлов

      12.6. Текстовые файлы

        12.6.1. Текст-ориентированные процедуры и функции

        12.6.2. Операции ввода-вывода в текстовые файлы

      12.7. Типизированные файлы и операции ввода-вывода

      12.8. Бестиповые файлы и операции ввода-вывода

      12.9. Последовательный и прямой доступ к файлам

        12.9.1. Опрос размеров файлов и позиции в них

        12.9.2. Позиционирование в файлах

        12.9.3. Усечение файлов

      12.10. Процедуры для работы с каталогами

      12.11. Обработка ошибок ввода-вывода

        12.11.1. Функция IOResult

        12.11.2. Примеры обработки ошибок ввода-вывода

        12.11.3. Сводка номеров ошибок ввода-вывода

    Глава 13. Объектно-ориентированное программирование

      13.1. Определения объектов

      13.2. Область действия полей объекта и параметр Self

      13.3. Наследование

      13.4. Присваивание объектов

      13.5. Полиморфизм

        13.5.1. Статические методы

        13.5.2. Виртуальные методы

        13.5.3. Выбор вида метода

      13.6. Динамические объекты

        13.6.1. Создание динамических объектов

        13.6.2. Освобождение объектов. Деструкторы

        13.6.3. Обработка ошибок при работе с динамическими объектами

      13.7. Функции TypeOf и SizeOf

      13.8. Задание стартовых значений объектам

      13.9. Модули, экспортирующие объекты

    Глава 14. Специальные средства языка

      14.1. Работа с командной строкой. Функции ParamCount и ParamStr

      14.2. Доступ к памяти ПЭВМ. Массивы Mem, MemW, MemL

      14.3. Доступ к портам ввода-вывода. Массивы Port и PortW

      14.4. Процедура заполнения FillChar

      14.5. Процедура перемещения данных Move

      14.6. Функции обработки машинных слов Lo, Hi и Swap

      14.7. Вставки машинного кода в программе

        14.7.1. Оператор inline

        14.7.2. Процедуры с директивой inline

      14.8. Процедура завершения и обработка ошибок программ

        14.8.1. Оператор RunError

        14.8.2. Сводка номеров фатальных ошибок

  Часть IV. Специальные библиотеки языка

    Глава 15. Модуль CRT

      15.1. Вывод специальных символов

      15.2. Модификация операторов Read, ReadLn

      15.3. Системные переменные модуля CRT

        15.3.1. Переменные управления выводом на дисплей

        15.3.2. Переменные управления работой клавиатуры

        15.3.3. Переменная TextAttr

      15.4. Процедуры и функции модуля CRT

        15.4.1. Работа с экраном в целом

        15.4.2. Позиционирование курсора

        15.4.3. Работа со строками

        15.4.4. Настройка цвета

        15.4.5. Подача звуковых сигналов

        15.4.6. Использование встроенного таймера

        15.4.7. Опрос клавиатуры

        15.4.8. Переназначение стандартных файлов

    Глава 16. Модуль DOS

      16.1. Опрос и установка параметров MS-DOS

        16.1.1. Управление параметрами BREAK и VERIFY

        16.1.2. Опрос системных переменных MS-DOS

      16.2. Работа с часами и календарем

        16.2.1. Опрос и назначение даты

        16.2.2. Опрос и назначение времени

        16.2.3. Работа с датой создания файлов

      16.3. Анализ ресурсов дисков

      16.4. Работа с каталогами и файлами

        16.4.1. Типы и константы модуля DOS для работы с файлами

        16.4.2. Переменная DosError

        16.4.3. Процедуры поиска файлов на диске

        16.4.4. Работа с атрибутами файлов

        16.4.5. Анализ имен файлов

      16.5. Работа с прерываниями MS-DOS

        16.5.1. Чтение и перестановка адресов подпрограмм прерываний

        16.5.2. Вызов прерывания процедурой Intr

        16.5.3. Процедура MsDos

      16.6. Организация субпроцессов и резидентных программ

        16.6.1. Программирование субпроцессов

        16.6.2. Процедура Keep и резидентные программы

    Глава 17. Модуль Printer

      17.1. Содержимое модуля Printer

      17.2. Низкоуровневые средства работы с принтером

      17.3. Работа с двумя принтерами одновременно

    Глава 18. Модуль Overlay

      18.1. Оверлейное построение программ

      18.2. Правила оформления оверлейных программ

      18.3 Инициализация работы оверлеев

        18.3.1 Включение администратора оверлеев

        18.3.2. Анализ результата инициализации

        18.3.3. Размещение оверлейного файла в EMS-памяти

      18.4. Управление оверлейным буфером

        18.4.1. Опрос размера буфера

        18.4.2. Установка размера буфера

        18.4.3. Принудительная очистка буфера

      18.5. Оптимизация работы оверлеев

        18.5.1. Установка размера области испытаний

        18.5.2. Подсчет вызовов оверлеев

      18.6. Предопределенные переменные для работы с оверлеями

      18.7. Включение оверлеев в EXE-файлы

    Глава 19. Модуль Graph

      19.1. Файлы BGI и содержимое модуля Graph

      19.2. Управление графическми режимами

        19.2.1. Инициализация и закрытие графического режима

        19.2.2. Обработка ошибок инициализации

        19.2.3. Классификация и анализ графических режимов

        19.2.4. Очистка экрана и переключение режимов

        19.2.5. Управление режимом вывода отрезков на экран

      19.3. Системы координат и "текущий указатель"

        19.3.1. Координаты устройства и мировые координаты

        19.3.2. Управление «текущим указателем»

      19.4. Рисование графических примитивов и фигур

        19.4.1. Линии и их стили

        19.4.2. Коэффициент сжатия изображения

        19.4.3. Окружности, эллипсы и дуги

        19.4.4. Построение прямоугольников и ломаных

      19.5. Управление цветами и шаблонами заливки (заполнения)

        19.5.1. Немного о цветах

        19.5.2. Задание типа заливки

        19.5.3. Заливка областей изображения

        19.5.4. Опрос и установка цветов пера и фона

        19.5.5. Управление палитрой

      19.6. Битовые графические операции

        19.6.1. Битовые операции

        19.6.2. Работа с фрагментами изображений

      19.7. Управление видеостраницами

      19.8. Графические окна

      19.9. Вывод текста

        19.9.1. Выбор шрифта и стиля

        19.9.2. Предварительная загрузка и регистрация шрифтов

        19.9.3. Непосредственный вывод строк

        19.9.4. Размер букв и его масштабирование

      19.9.5. Опрос стиля и ориентации шрифтов

      19.10. Включение шрифтов и драйверов в ЕХЕ-файл

      19.11. Подключение новых драйверов

      19.12. Один полезный совет

  Часть V. Практические приемы работы с ПЭВМ

    Глава 20. Профессиональная работа с текстовыми изображениями

      20.1. Программный опрос режимов текстового дисплея

      20.2. Организация доступа к видеопамяти

      20.3. Запомнинание окон экрана и их восстановление

        20.3.1. Общие принципы работы с окном

        20.3.2. Модуль Win

      20.4. Работа с образом экрана на диске

      20.5. Крупные надписи на экране

      20.6. Управление формой курсора

    Глава 21. Как осуществить полный доступ к клавиатуре

      21.1. Как организовать опрос алфавитно-цифровой клавиатуры

      21.2. Опрос клавиши в регистре Ctrl

      21.3. Опрос расширенных кодов и функциональных клавиш

      21.4. Опрос служебных клавиш

      21.5. Анализ клавиш регистров и их состояния

      21.6. Скэн-коды клавиатуры и работа с ними

      21.7. Эффект обратной записи в буфер ввода

    Глава 22. Работа с оперативной памятью видеоадаптеров

      22.1. Многобитовое и многоплоскостное ОЗУВ

      22.2. Карта дисплейной памяти

      22.3. Вывод текста на графический экран

      22.4. Работа с графическими образами на диске

    ПРИЛОЖЕНИЕ 1 Сообщения и коды ошибок, генерируемые компилятором

    ПРИЛОЖЕНИЕ 2 Ключи и директивы компилятора

    ПРИЛОЖЕНИЕ 3 Использование компилятора ТРС

    ПРИЛОЖЕНИЕ 4 Список утилит пакета Турбо Паскаль

    ПРИЛОЖЕНИЕ 5 Команды встроенного редактора

    ПРИЛОЖЕНИЕ 6 Автоматическая оптимизация программ

    ПРИЛОЖЕНИЕ 7 Список демонстрационных процедур и функций

    Индекс

    ЛИТЕРАТУРА

    Оглавление Fueled by Johannes Gensfleisch zur Laden zum Gutenberg