Использование объектов
Идею инкапсуляции полей и алгоритмов можно применить не только к графическим объектам, но и ко всей программе в целом. Ничто не мешает нам создать объект-программу и «научить» его трем основным действиям: инициации (Init), выполнению основной работы (Run) и завершению (Done). На этапе инициации экран переводится в графический режим работы и создаются и отображаются графические объекты (100 экземпляров TPoint и по одному экземпляру TLine, TCircle, TRecf). На этапе Run осуществляется сканирование клавиатуры и перемещение графических объектов. Наконец, на этапе Done экран переводится в текстовый режим и завершается работа всей программы.
Назовем объект-программу именем TGraphApp и разместим его в модуле GraphApp (пока не обращайте внимание на точки, скрывающие содержательную часть модуля -позднее будет представлен его полный текст):
Unit GraphApp;
Interface
type
TGraphApp = object
Procedure Init;
Procedure Run;
Destructor Done;
end;
Implementation Procedure TGraphApp.Init;
...
end;
...
end.
В этом случае основная программа будет предельно простой:
Program Graph_0bjects;
Uses GraphApp;
var
App: TGraphApp;
begin
App.Init;
App.Run;
App.Done
end.
В ней мы создаем единственный экземпляр Арр объекта-программы TGrahpApp и обращаемся к трем его методам.
Создание экземпляра объекта ничуть не отличается от создания экземпляра переменной любого другого типа. Просто в разделе описания переменных мы указываем имя переменной и ее тип:
var
Арр: TGraphApp;
Получив это указание, компилятор зарезервирует нужный объем памяти для размещения всех полей объекта TGraphApp. Чтобы обратиться к тому или иному объектному методу или полю, используется составное имя, причем первым указывается не имя объектного типа, а имя соответствующей переменной:
App.Init;
Арр.Run;
Арр.Done;
Переменные объектного типа могут быть статическими или динамическими, т.е. располагаться в сегменте данных (статические) или в куче (динамические). В последнем случае мы могли бы использовать такую программу:
Program Graph_0bjects;
Uses GraphApp;
type
PGraphApp = TGraphApp;
var
App: PGraphApp;
begin
App := New(PGraphApp,Init)
Арр.Run;
Арр.Done
end;
Для инициации динамической переменной Арр используется вызов функции New. В этом случае первым параметром указывается имя типа инициируемой переменной, а вторым осуществляется вызов метода-конструктора, который, я напомню, нужен для настройки таблицы виртуальных методов. Такой прием (распределение объектов в динамической памяти с одновременной инициацией их ТВМ) характерен для техники ООП. -
Ниже приводится возможный вариант модуля GraphApp для нашей учебной программы:
Unit GraphApp;
Interface
Uses GraphObj;
const
NPoints = 100; {Количество точек}
type
{Объект-программа}
TGraphApp = object
Points: array [1..NPoints] of TPoint; {Массив точек}
Line: TLine; {Линия}
Rect: TRect; {Прямоугольник}
Circ: TCircle; {Окружность}
ActiveObj : Integer; {Активный объект}
Procedure Init; Procedure Run;
Procedure Done; Procedure ShowAll;
Procedure MoveActiveObj (dX,dY: Integer);
end;
Implementation Uses Graph, CRT;
Procedure TGraphApp.Init;
{Инициирует графический режим работы экрана . Создает и отображает NPoints экземпляров объекта TPoint, а также экземпляры
объектов TLine, TCircle и TRect}
var
D,R,Err,k: Integer;
begin
{Инициируем графику}
D := Detect; {Режим автоматического определения
типа графического адаптера}
InitGraph(D,R, '\tp\bgi') ; {Инициируем графический режим. Текстовая строка должна задавать путь к каталогу с графическими драйверами}
Err := GraphResult; {Проверяем успех инициации графики}
if Err<>0 then
begin
GraphErrorMsg (Err) ;
Halt
end;
{Создаем точки}
for k : = 1 to NPoints do
Points [k] .Init (Random(GetMaxX),Random(GetMaxY),Random(15)+1);
{Создаем другие объекты}
Line. Init (GetMaxX div 3, GetMaxY div 3,2*GetMaxX div 3,
2*GetMaxY div 3,LightRed);
Circ. Init (GetMaxX div 2, GetMaxY div 2, GetMaxY div 5, White);
Rect.Init(2*GetMaxX div 5,2*GetMaxY div 5 , 3*GetMaxX div 5,
3*GetMaxY div 5, Yellow);
ShowAll; {Показываем все графические объекты}
ActiveObj := 1 {Первым перемещаем прямоугольник}
end ; { TGraphApp .Init}
{-----------}
Procedure TGraphApp .Run ;
{Выбирает объект с помощью Tab и перемещает его по экрану}
var
Stop: Boolean; {Признак нажатия Esc}
const
D = 5; {Шаг смещения фигур}
begin
Stop := False;
{Цикл опроса клавиатуры}
repeat
case ReadKey of {Читаем код нажатой клавиши}
#27: Stop := True; {Нажата Esc}
#9:begin {Нажата Tab}
inc(ActiveObj);
if ActiveObj>3 then
ActiveObj := 3
end;
#0: case ReadKey of
#71:MoveActiveObj(-D,-D); {Влево и вверх}
#72:MoveActiveObj( 0,-D); {Вверх}
#73:MoveActiveObj( D,-D); {Вправо и вверх}
#75:MoveActiveObj(-D, 0); {Влево}
#77:MoveActiveObj( D, 0); {Вправо}
#79:MoveActiveObj(-D, D); {Влево и вниз}
#80:MoveActiveObj( 0, D); {Вниз}
#81:MoveActiveObj( D, D); {Вправо и вниз}
end
end;
ShowAll;
Until Stop
end; {TGraphApp. Run}
{-----------}
Destructor TGraphApp . Done ;
{Закрывает графический режим}
begin
CloseGraph
end; {TGraphApp. Done}
Procedure TGraphApp . ShowAll ;
{Показывает все графические объекты}
var
k: Integer;
begin
for k := 1 to NPoints do Points [k] . Show;
Line. Show;
Rect . Show;
Circ.Show
end;
{-----------}
Procedure TGraphApp.MoveActiveObj;
{Перемещает активный графический объект}
begin
case ActiveObj of
1: Rect.MoveTo(dX,dY);
2: Circ.MoveTo(dX,dY);
3: Line.MoveTo(dX,dY)
end
end;
end.
В реализации объекта TGraphApp используется деструктор Done. Следует иметь в виду, что в отличие от конструктора, осуществляющего настройку ТВМ, деструктор не связан с какими-то специфичными действиями: для компилятора слова destructor и procedure - синонимы. Введение в ООП деструкторов носит, в основном, стилистическую направленность - просто процедуру, разрушающую экземпляр объекта, принято называть деструктором. В реальной практике ООП с деструкторами обычно связывают процедуры, которые не только прекращают работу с объектом, но и освобождают выделенную для него динамическую память. И хотя в нашем примере деструктор Done не освобождает кучу, я решил использовать общепринятую стилистику и заодно обсудить с Вами последнее еще не рассмотренное зарезервированное слово технологии ООП.
В заключении следует сказать, что формалистика ООП в рамках реализации этой технологии в Турбо Паскале предельно проста и лаконична. Согласитесь, что введение лишь шести зарезервированных слов, из которых действительно необходимыми являются три (object, constructor и virtual), весьма небольшая плата за мощный инструмент создания современного программного обеспечения.
Объекты
Основные принципы ООП
Постановка учебной задачи
Создание объектов
Использование объектов
В основе того или иного языка программирования лежит некоторая руководящая идея, оказывающая существенное влияние на стиль соответствующих программ.
Исторически первой была идея процедурного структурирования программ, в соответствии с которой программист должен был решить, какие именно процедуры он будет использовать в своей программе, а затем выбрать наилучшие алгоритмы для реализации этих процедур. Появление этой идеи было следствием недостаточной изученности алгоритмической стороны вычислительных процессов, столь характерной для ранних программных разработок (сороковые - пятидесятые годы). Типичным примером процедурно-ориентированного языка является Фортран - первый и все еще один из наиболее популярных языков программирования. Последовательное использование идеи процедурного структурирования программ привело к созданию обширных библиотек программирования, содержащих множество сравнительно небольших процедур, из которых, как из кирпичиков, можно строить «здание» программы.
По мере прогресса в области вычислительной математики акцент в программировании стал смещаться с процедур в сторону организации данных. Оказалось, что эффективная разработка сложных программ нуждается в действенных способах контроля правильности использования данных. Контроль должен осуществляться как на стадии компиляции, так и при прогоне программ, в противном случае, как показала практика, резко возрастают трудности создания крупных программных проектов. Отчетливое осознание этой проблемы привело к созданию Алгола-60, а позже - Паскаля, Модулы-2, Си и множества других языков программирования, имеющих более или менее развитые структуры типов данных. Логическим следствием развития этого направления стал модульный подход к разработке программ, характеризующийся стремлением «спрятать» данные и процедуры внутри модуля.
Начиная с языка Симула-67, в программировании наметился новый подход, который получил название объектно-ориентированного программирования (ООП). Его руководящая идея заключается в стремлении связать данные с обрабатывающими эти данные процедурами в единое целое - объект. Характерной чертой объектов является инкапсуляция (объединение) данных и алгоритмов их обработки, в результате чего и данные, и процедуры во многом теряют самостоятельное значение. Фактически объектно-ориентированное программирование можно рассматривать как модульное программирование нового уровня, когда вместо во многом случайного, механического объединения процедур и данных акцент делается на их смысловую связь.
Какими мощными средствами располагает объектно- ориентированное программирование наглядно демонстрирует библиотека Turbo Vision, входящая в комплект поставки Турбо Паскаля и описываемая во второй части этой книги. В этой главе мы рассмотрим основные идеи ООП и способы их использования.
Следует заметить, что преимущества ООП в полной мере проявляются лишь при разработке достаточно сложных программ. Более того, инкапсуляция придает объектам совершенно особое свойство «самостоятельности», максимальной независимости от остальных частей программы. Правильно сконструированный объект располагает всеми необходимыми данными и процедурами их обработки, чтобы успешно реализовать требуемые от него действия. Попытки использовать ООП для программирования несложных алгоритмов, связанных, например, с расчетными вычислениями по готовым формулам, чаще всего выглядят искусственными нагромождениями ненужных языковых конструкций. Такие программы обычно не нуждаются в структуризации, расчленении алгоритма на ряд относительно независимых частей, их проще и естественнее разрабатывать традиционными способами Паскаля. При разработке сложных диалоговых программ программист вынужден структурировать программу, так как только в этом случае он может рассчитывать на успех: «критической массой» неструктурированных программ является объем в 1000-1200 строк исходного текста - отладка неструктурированных программ большего объема обычно сталкивается с чрезмерными трудностями. Структурирование программы ведет, фактически, к разработке собственной библиотеки программирования - вот в этот момент к Вам на помощь и приходят новые средства ООП.
Основные принципы ООП
Объектно-ориентированное программирование основано на «трех китах» - трех важнейших принципах, придающих объектам новые свойства. Этими принципами являются инкапсуляция, наследование и полиморфизм.
Инкапсуляция
Инкапсуляция есть объединение в единое целое данных и алгоритмов обработки этих данных. В рамках ООП данные называются полями объекта, а алгоритмы - объектными методами.
Инкапсуляция позволяет в максимальной степени изолировать объект от внешнего окружения. Она существенно повышает надежность разрабатываемых программ, т.к. локализованные в объекте алгоритмы обмениваются с программой сравнительно небольшими объемами данных, причем количество и тип этих данных обычно тщательно контролируются. В результате замена или модификация алгоритмов и данных, инкапсулированных в объект, как правило, не влечет за собой плохо прослеживаемых последствий для программы в целом (в целях повышения защищенности программ в ООП почти не используются глобальные переменные).
Другим немаловажным следствием инкапсуляции является легкость обмена объектами, переноса их из одной программы в другую. Можно сказать, что ООП «провоцирует» разработку библиотек объектов, таких как Turbo Vision.
Наследование
Наследование есть свойство объектов порождать своих потомков. Объект-потомок автоматически наследует от родителя все поля и методы, может дополнять объекты новыми полями и заменять (перекрывать) методы родителя или дополнять их.
Принцип наследования решает проблему модификации свойств объекта и придает ООП в целом исключительную гибкость. При работе с объектами программист обычно подбирает объект, наиболее близкий по своим свойствам для решения конкретной задачи, и создает одного или нескольких потомков от него, которые «умеют» делать то, что не реализовано в родителе.
Последовательное проведение в жизнь принципа «наследуй и изменяй» хорошо согласуется с поэтапным подходом к разработке крупных программных проектов и во многом стимулирует такой подход.
Полиморфизм
Полиморфизм - это свойство родственных объектов (т.е. объектов, имеющих одного общего родителя) решать схожие по смыслу проблемы разными способами. В рамках ООП поведенческие свойства объекта определяются набором входящих в него методов. Изменяя алгоритм того или иного метода в потомках объекта, программист может придавать этим потомкам отсутствующие у родителя специфические свойства. Для изменения метода необходимо перекрыть его в потомке, т.е. объявить в потомке одноименный метод и реализовать в нем нужные действия. В результате в объекте-родителе и объекте-потомке будут действовать два одноименных метода, имеющие разную алгоритмическую основу и, следовательно, придающие объектам разные свойства. Это и называется полиморфизмом объектов.
В Турбо Паскале полиморфизм достигается не только описанным выше механизмом наследования и перекрытия методов родителя, но и их виртуализацией (см. ниже), позволяющей родительским методам обращаться к методам потомков.
Постановка учебной задачи
Знакомство с техникой ООП в этом разделе иллюстрируется примерами, объединенными рамками следующей учебной задачи.
Требуется разработать программу, которая создает на экране ряд графических изображений (точки, окружность, линия, квадрат) и может перемещать эти изображения по экрану. Вид создаваемого программой экрана показан на рис. 10.1.
Рис. 10.1. Экран, создаваемый учебной программой
Для перемещения изображений в программе будут использоваться клавиши управления курсором, клавиши Ноте, End, PgUp, PgDn (для перемещения по диагональным направлениям) и клавиша Tab для выбора перемещаемого объекта. Выход из программы - клавиша Esc.
Техническая реализация программы потребует использования средств двух стандартных библиотек - CRT и GRAPH, которые еще не рассматривались в этой книге. Чтобы не отвлекать Ваше внимание от основных проблем ООП, при описании реализации учебной задачи особенности использования средств этих библиотек лишь очень кратко комментируются в текстах программы. Если Вы не привыкли «принимать на веру» предлагаемые программные решения и хотите разобраться с деталями вызова незнакомых Вам процедур и функций, рекомендую просмотреть материал гл.13 и гл.14, где описаны эти библиотеки (они не используют средств ООП и, следовательно, могут изучаться до чтения настоящей главы).
Создание объектов
В Турбо Паскале для создания объектов используются три зарезервированных слова: object, constructor, destructor к три стандартные директивы: private, public и virtual.
Зарезервированное слово object используется для описания объекта. Описание объекта должно помещаться в разделе описания типов:
type
MyObject = object
(Поля объекта}
{Методы объекта}
end ;
Если объект порождается от какого-либо родителя, имя родителя указывается в круглых скобках сразу за словом object:
type
MyDescendantObject = object(MyObject)
.
.
end;
Любой объект может иметь сколько угодно потомков, но только одного родителя, что позволяет создавать иерархические деревья наследования объектов.
Для нашей учебной задачи создадим объект-родитель TGraphObject, в рамках которого будут инкапсулированы поля и методы, общие для всех остальных объектов:
type
TGraphObj = object
Private {Поля объекта будут скрыты от пользователя}
X,Y: Integer; {Координаты реперной точки}
Color: Word; {Цвет фигуры}
Public {Методы объекта будут доступны пользователю}
Constructor Init(aX,aY: Integer; aColor: Word);
{Создает экземпляр объекта}
Procedure Draw(aColor: Word); Virtual;
{Вычерчивает объект заданным цветом aColor}
Procedure Show;
{Показывает объект - вычерчивает его цветом Color}
Procedure Hide;
{Прячет объект - вычерчивает его цветом фона}
Procedure MoveTo(dX,dY: Integer);
{Перемещает объект в точку с координатами X+dX и Y+dY}
end; {Конец описания объекта TGraphObj}
В дальнейшем предполагается создать объекты-потомки от TGraphObj, реализующие все специфические свойства точки, линии, окружности и прямоугольника. Каждый из этих графических объектов будет характеризоваться положением на экране (поля X и Y) и цветом (поле Color). С помощью метода Draw он будет способен отображать себя на экране, а с помощью свойств «показать себя» (метод Show) и «спрятать себя» (метод Hide) сможет перемещаться по экрану (метод MoveTo). Учитывая общность свойств графических объектов, мы объявляем абстрактный объект TGraphObj, который не связан с конкретной графической фигурой. Он объединяет в себе все общие поля и методы реальных фигур и будет служить родителем для других объектов.
Директива Private в описании объекта открывает секцию описания скрытых полей и методов. Перечисленные в этой секции элементы объекта «не видны» программисту, если этот объект он получил в рамках библиотечного ТР(/-модуля. Скрываются обычно те поля и методы, к которым программист (в его же интересах!) не должен иметь непосредственного доступа. В нашем примере он не может произвольно менять координаты реперной точки (X.Y), т.к. это не приведет к перемещению объекта. Для изменения полей X и Y предусмотрены входящие в состав объекта методы Init и MoveTo. Скрытые поля и методы доступны в рамках той программной единицы (программы или модуля), где описан соответствующий объект. В дальнейшем предполагается, что программа будет использовать модуль GraphObj с описанием объектов. Скрытые поля будут доступны в модуле GraphObj, но недоступны в использующей его основной программе. Разумеется, в рамках реальной задачи создание скрытых элементов объекта вовсе необязательно. Я ввел их в объект TGraphObj лишь для иллюстрации возможностей ООП.
Директива public отменяет действие директивы private, поэтому все следующие за public элементы объекта доступны в любой программной единице. Директивы private и public могут произвольным образом чередоваться в пределах одного объекта.
Вариант объявления объекта TGraphObj без использования механизма private...public:
type
TGraphObj = object
X,Y: Integer;
Color: Word;
Constructor Init(aX,aY: Integer; aColor: Word);
Procedure Draw(aColor: Word); Virtual;
Procedure Show;
Procedure Hide;
Procedure MoveTo(dX,dY: Integer);
end;
Описания полей ничем не отличаются от описания обычных переменных. Полями могут быть любые структуры данных, в том числе и другие объекты. Используемые в
нашем примере поля X и Y содержат координату реперной (характерной) точки графического объекта, а поле Color - его цвет. Реперная точка характеризует текущее положение графической фигуры на экране и, в принципе, может быть любой ее точкой.
В нашем примере она совпадает с координатами точки в описываемом ниже объекте
TPoint, с центром окружности в объекте TCircle, первым концом прямой в объекте TLine и с левым верхним углом прямоугольника в объекте TRect.
Для описания методов в ООП используются традиционные для Паскаля процедуры и функции, а также особый вид процедур - конструкторы и деструкторы. Конструкторы предназначены для создания конкретного экземпляра объекта, ведь объект - это тип данных, т.е. «шаблон», по которому можно создать сколько угодно рабочих экземпляров данных объектного типа (типа TGraphOhj, например). Зарезервированное слово constructor, используемое в заголовке конструктора вместо procedure, предписывает компилятору создать особый код пролога, с помощью которого настраивается так называемая таблица виртуальных методов (см. ниже). Если в объекте нет виртуальных методов, в нем может не быть ни одного конструктора, наоборот, если хотя бы один метод описан как виртуальный (с последующим словом Virtual, см. метод Draw), в состав объекта должен входить хотя бы один конструктор и обращение к конструктору должно предшествовать обращению к любому виртуальному методу.
Типичное действие, реализуемое конструктором, состоит в наполнении объектных полей конкретными значениями. Следует заметить, что разные экземпляры одного и того же объекта отличаются друг от друга только содержимым объектных полей, в то время как каждый из них использует одни и те же объектные методы. В нашем примере конструктор Init объекта TGraphObj получает все необходимые для полного определения экземпляра данные через параметры обращения аХ, аY и aColor.
Процедура Draw предназначена для вычерчивания графического объекта. Эта процедура будет реализовываться в потомках объекта TGraphObj по-разному. Например, для визуализации точки следует вызвать процедуру PutPixel, для вычерчивания линии - процедуру Line и т.д. В объекте TGraphObj процедура Draw определена как виртуальная («воображаемая»). Абстрактный объект TGraphObj не предназначен для вывода на экран, однако наличие процедуры Draw в этом объекте говорит о том, что любой потомок TGraphObj должен иметь собственный метод Draw, с помощью которого он может показать себя на экране.
При трансляции объекта, содержащего виртуальные методы, создается так называемая таблица виртуальных методов (ТВМ), количество элементов которой равно количеству виртуальных методов объекта. В этой таблице будут храниться адреса точек входа в каждый виртуальный метод. В нашем примере ТВМ объекта TGraphObj хранит единственный элемент - адрес метода Draw. Первоначально элементы ТВМ не содержат конкретных адресов. Если бы мы создали экземпляр объекта TGraphObj с помощью вызова его конструктора Init, код пролога конструктора поместил бы в ТВМ нужный адрес родительского метода Draw. Далее мы создадим несколько потомков объекта TGraphObj. Каждый из них будет иметь собственный конструктор, с помощью которого ТВМ каждого потомка настраивается так, чтобы ее единственный элемент содержал адрес нужного метода Draw. Такая процедура называется поздним связыванием объекта. Позднее связывание позволяет методам родителя обращаться к виртуальным методам своих потомков и использовать их для реализации специфичных для потомков действий.
Наличие в объекте TGraphObj виртуального метода Draw позволяет легко реализовать три других метода объекта: чтобы показать объект на экране в методе Show, вызывается Draw с цветом aColor, равным значению поля Color, а чтобы спрятать графический объект, в методе Hide вызывается Draw со значением цвета GetBkColor, т.е. с текущим цветом фона.
Рассмотрим реализацию перемещения объекта. Если потомок TGraphObj (например, TLine) хочет переместить себя на экране, он обращается к родительскому методу MoveTo. В этом методе сначала с помощью Hide объект стирается с экрана, а затем с помощью Show показывается в другом месте. Для реализации своих действий и Hide, и Show обращаются к виртуальному методу Draw. Поскольку вызов MoveTo происходит в рамках объекта TLine, используется ТВМ этого объекта и вызывается его метод Draw, вычерчивающий прямую. Если бы перемешалась окружность, ТВМ содержала бы адрес метода Draw объекта TCircle и визуализация-стирание объекта осуществлялась бы с помощью этого метода.
Чтобы описать все свойства объекта, необходимо раскрыть содержимое объектных методов, т.е. описать соответствующие процедуры и функции. Описание методов производится обычным для Паскаля способом в любом месте раздела описаний, но после описания объекта. Например:
type
TGraphObj = object
...
end;
Constructor TGraphObj.Init;
begin
X := aX;
Y := aY; Color := aColor
end;
Procedure TGraphObj-Draw;
begin
{Эта процедура в родительском объекте ничего не делает, поэтому экземпляры TGraphObj не способны отображать себя на экране. Чтобы потомки объекта TGraphObj были способны отображать себя, они должны перекрывать этот метод}
end;
Procedure TGraphObj.Show;
begin
Draw(Color)
end;
Procedure TGraphObj.Hide;
begin
Draw(GetBkColor)
end;
Procedure TGraphObj.MoveTo;
begin
Hide;
X := X+dX;
Y := Y+dY;
Show
end;
Отмечу два обстоятельства. Во-первых, при описании методов имя метода дополняется спереди именем объекта, т.е. используется составное имя метода. Это необходимо по той простой причине, что в иерархии родственных объектов любой из методов может быть перекрыт в потомках. Составные имена четко указывают принадлежность конкретной процедуры. Во-вторых, в любом объектном методе можно использовать инкапсулированные поля объекта почти так, как если бы они были определены в качестве глобальных переменных. Например, в конструкторе TGraph.Init переменные в левых частях операторов присваивания представляют собой объектные поля и не должны заново описываться в процедуре. Более того, описание
Constructor TGraphObj.Init;
var
X,Y: Integer; {Ошибка!}
Color: Word; {Ошибка!}
begin
end;
вызовет сообщение о двойном определении переменных X, Y и Color (в этом и состоит отличие в использовании полей от глобальных переменных: глобальные переменные можно переопределять в процедурах, в то время как объектные поля переопределять нельзя).
Обратите внимание: абстрактный объект TGraphObj не предназначен для вывода на экран, поэтому его метод Draw ничего не делает. Однако методы Hide, Show и MoveTo «знают» формат вызова этого метода и реализуют необходимые действия, обращаясь к реальным методам Draw своих будущих потомков через соответствующие ТВМ. Это и есть полиморфизм объектов.
Создадим простейшего потомка от TGraphObj - объект TPoint, с помощью которого будет визуализироваться и перемещаться точка. Все основные действия, необходимые для этого, уже есть в объекте TGraphObj, поэтому в объекте TPoint перекрывается единственный метод - Draw.
type
TPoint = object(TGraphObj)
Procedure Draw(aColor); Virtual;
end;
Procedure TPoint.Draw;
begin
PutPixel(X,Y,Color) {Показываем цветом Color пиксель
с координатами X и Y}
end;
В новом объекте TPoint можно использовать любые методы объекта-родителя TGraphObj. Например, вызвать метод MoveTo, чтобы переместить изображение точки на новое место. В этом случае родительский метод TGraphObj.MoveTo будет обращаться к методу TPoint.Draw, чтобы спрятать и затем показать изображение точки. Такой вызов станет доступен после обращения к конструктору Init объекта TPoint, который нужным образом настроит ТВМ объекта. Если вызвать TPoint.Draw до вызова Init, его ТВМ не будет содержать правильного адреса и программа «зависнет».
Чтобы создать объект-линию, необходимо ввести два новых поля для хранения координат второго конца. Дополнительные поля требуется наполнить конкретными значениями, поэтому нужно перекрыть конструктор родительского объекта:
type
TLine = object(TGraphObj)
dX,dY: Integer; {Приращения координат второго конца}
Constructor Init(X1,Y1,X2,Y2: Integer; aColor: Word);
Procedure Draw(aColor: Word); Virtual;
end; ,
Constructor TLine.Init;
{Вызывает унаследованный конструктор TGraphObj для инициации полей X, Y и Color. Затем инициирует поля dX и dY}
begin
{Вызываем унаследованный конструктор}
Inherited Init(XI,Yl,aColor);
{Инициируем поля dX и dY}
dX := Х2-Х1;
dY := Y2-Y1
end;
Procedure Draw;
begin
SetColor(Color);{Устанавливаем цвет Color}
Line(X,Y,X+dX,Y+dY){Вычерчиваем линию}
end;
В конструкторе TLine.Init для инициации полей X, Y и Color, унаследованных от родительского объекта, вызывается унаследованный конструктор TGraph.Init, для чего используется зарезервированное слово inherited (англ.- унаследованный):
Inherited Init(XI,Yl,aColor) ;
С таким же успехом мы могли бы использовать и составное имя метода:
TGraphObj.Init(Xl,Yl,aColor);
Для инициации полей dX и dY вычисляется расстояние в пикселах по горизонтали и вертикали от первого конца прямой до ее второго конца. Это позволяет в методе TLine.Draw вычислить координаты второго конца по координатам первого и смещениям dX и dY. В результате простое изменение координат реперной точки X, Y в родительском методе TGraph.MoveTo перемещает всю фигуру по экрану.
Теперь нетрудно реализовать объект TCircle для создания и перемещения окружности:
type
TCircle = object(TGraphObj)
R: Integer; {Радиус}
Constructor Init(aX,aY,aR: Integer;
Procedure Draw(aColor: Virtual);
end ;
Constructor TCircle.Init;
begin
Inherited Init(aX,aY,aColor);
R := aR
end ;
aColor: Word)
Procedure TCircle.Draw;
begin
SetColor(aColor); {Устанавливаем цвет Color}
Circle(X,Y,R) {Вычерчиваем окружность}
end;
В объекте TRect, с помощью которого создается и перемещается прямоугольник, учтем то обстоятельство, что для задания прямоугольника требуется указать четыре целочисленных параметра, т.е. столько же, сколько для задания линии. Поэтому объект TRect удобнее породить не от TGraphObj, а от TLine, чтобы использовать его конструктор Init:
type
TRect = object(TLine)
Procedure Draw(aColor: Word);
end;
Procedure TRect.Draw;
begin
SetColor(aColor);
Rectangle(X,Y,X+dX,Y+dY) {Вычерчиваем прямоугольник}
end;
Чтобы описания графических объектов не мешали созданию основной программы, оформим эти описания в отдельном модуле GraphObj:
Unit GraphObj; Interface
{Интерфейсная часть модуля содержит только объявления объектов}
type
TGraphObj = object
...
end;
TPoint = object(TGraphObj)
...
end;
TLine = object(TGraphObj)
...
end;
TCircle = object(TGraphObj)
end;
TRect = object(TLine)
...
end;
Implementation
{Исполняемая часть содержит описания всех объектных методов}
Uses Graph;
Constructor TGraphObj.Init;
...
end.
В интерфейсной части модуля приводятся лишь объявления объектов, подобно тому как описываются другие типы данных, объявляемые в модуле доступными для внешних программных единиц. Расшифровка объектных методов помещается в исполняемую часть implementation, как если бы это были описания обычных интерфейсных процедур и функций. При описании методов можно опускать повторное описание в заголовке параметров вызова. Если они все же повторяются, они должны в точности соответствовать ранее объявленным параметрам в описании объекта. Например, заголовок конструктора TGraphObj.Init может быть таким:
Constructor TGraphObj.Init;
или таким:
Constructor TGraphObj.Init(aX,aY: Integer; aColor: Word);
Длинные строки
Среда Турбо Паскаль 7.0 обладает весьма интересным новшеством: в ней введена поддержка длинных строк, т.е. строк, длина которых может превышать 255 байт. Как известно, тип String в Турбо Паскале имеет максимальную длину 255 байт. Это связано с тем, что истинная длина строки в этом типе указывается первым байтом, мощность которого не позволяет определять строки большей длины. В то же время в языке С используется другой подход к заданию текстовых строк: первый байт строки является ее первым символом, второй байт - вторым символом и т.д. пока не встретится байт с символом #0. Таким образом, длина строки не указывается явно, как в типе String, а определяется по замыкающему символу #0. Ясно, что такие строки могут иметь произвольную длину, ограничиваемую лишь объемом оперативной памяти или принятой схемой ее адресации: в MS-DOS такой границей является длина сегмента, поэтому максимально возможная длина С-строки для ПК составляет 65535 символов. Такие строки в дальнейшем будем называть ASCIIZ-строками.
Для реализации операций над ASCIIZ-строками в язык введен новый тип PChar, определяемый как указатель на символ:
type
PChar =Char;
Однако такой обычный для Паскаля тип-указатель в рамках Турбо Паскаля 7.0 трактуется необычным способом: считается, что он указывает на цепочку символов, заканчивающуюся терминальным нулем, т.е. на ASCIIZ-строку. Более того, с этим типом совместим любой одномерный символьный массив с нулевой левой границей, а переменные типа PChar можно индексировать, как если бы они были массивами символов. Следующая программа напечатает все заглавные буквы английского алфавита:
{$Х+} {Включаем расширенный синтаксис}
var
Chars : array [0..26] of Char; {Массив символов}
PChars: PChar; {Указатель на символ}
k : Integer;
begin
for k := 0 to 25 do
Chars[k] := Chr(k+ord('A'); {Наполняем массив}
PChars := Chars; {Указателю присваиваем массив!}
PChars[26] := #0; {Индексируем указатель!}
WriteLn(PChars) {Печатаем указатель!}
end.
Три последние оператора программы недопустимы в стандартном Паскале и в ранних версиях Турбо Паскаля, но возможны в версии 7.0, если включен расширенный синтаксис (директивой {$Х+} или опцией Options/Compiler/Extended syntax). Обратите внимание: процедура WriteLn этой версии умеет работать с ASCIIZ-строками.
Для поддержки ASCIIZ-строк разработан модуль Strings, в котором реализованы необходимы процедуры и функции.
Функция StrCat.
Объединяет строки. Заголовок:
Function StrCat(Dest, Source: PChar): PChar;
Копирует строку Source в конец строки Dest и возвращает указатель на начало Dest.
Функция StrComp.
Сравнивает строки. Заголовок:
Function StrComp(Strl, Str2: PChar): Integer;
Побайтно сравнивает строку Strl со строкой Strl и возвращает следующий результат:
=0 Strl=Str2;
>0 Strl>Str2;
<0 Strl<Str2.
Функция StrCopy.
Копирует строку. Заголовок:
Function StrCopy(Dest, Source: PChar): PChar;
Копирует строку Source в строку Dest и возвращает указатель на Dest. StrCopy не проверяет реальный размер памяти, связанный с Dest (он должен быть не меньше StrLen(Source)+1).
Процедура StrDispose.
Удаляет строку из кучи. Заголовок:
Procedure StrDispose(Str: PChar);
Строка Str должна быть предварительно помещена в кучу функцией StrNew. Если Str=NIL, процедура ничего не делает.
Функция StrECopy.
Объединяет строки. Заголовок:
Function StrECopy(Dest, Source: PChar): PChar;
Эта функция работает в точности как StrCat, но возвращает указатель на конец сцепленных строк, т.е. на терминальный ноль.
Функция StrEnd.
Возвращает конец строки. Заголовок:
Function StrEnd(Str: PChar): PChar;
Функция возвращает указатель на терминальный ноль ASCIIZ-строки Str.
Функция StrlComp.
Сравнивает строки. Заголовок:
Function StrlComp(Strl, Str2: PChar): PChar; .
Функция сравнивает строки, игнорируя возможную разницу в высоте букв. Возвращает такой же результат, как и StrComp. Замечу, что функция правильно работает лишь с латиницей. Для кириллицы ее нужно модифицировать (см. ниже).
Функция StrLCat.
Объединяет строки. Заголовок:
Function StrLCat(Dest, Source: PChar; MaxLen: Word): PChar;
Копирует символы строки Source в конец строки Dest до тех пор, пока не будут скопированы все символы или когда длина сцепленной строки Dest не достигнет MaxLen. Возвращает указатель на сцепленную строку.
В отличие от StrCopy эта функция блокирует возможное переполнение области памяти, связанной с Dest. Обычно в качестве MaxLen используется выражение SizeOf (Dest) -1. Например:
{$Х+}
Uses Strings;
var
S: array [0..9] of Char;
begin
StrCopy(S, 'Turbo');
StrLCat(S, ' ', SizeOf(S)-1);
StrLCat(S, 'Pascal', SizeOf(S)-1);
WriteLn(S) {Напечатает "Turbo Pas"}
end;
Функция StrLComp.
Сравнивает строки. Заголовок:
Function StrLComp(Dest, Source: PChar; MaxLen: Word): PChar;
В отличие от StrComp сравнивает не более MaxLen символов строк. Возвращаемый результат такой же, как и у StrComp.
Функция StrLCopy.
Заголовок:
Function StrLCopy(Dest, Source: PChar; MaxLen: Word): PChar;
Копирует символы из строки Source в строку Dest до тех пор, пока не будет скопирована вся строка или пока не будет скопировано MaxLen символов. В отличие от StrCopy блокирует возможное переполнение области памяти, связанной с Dest. В качестве MaxLen обычно используется выражение SizeOf (Dest) -1. Например:
{$Х+}
Uses Strings;
var
S: array [0..9] of Char;
begin
StrLCopy(S, 'Turbo Pascal', SizeOf(S)-1);
WriteLn(S) {Напечатает "Turbo Pas"}
end;
Функция StrLen.
Возвращает длину строки. Заголовок:
Function StrCattStr: PChar): Word;
Функция StrLIComp.
Сравнивает строки с учетом регистра. Заголовок:
Function StrLIComp(Str1, Str2: PChar; MaxLen: Word): PChar;
Сравнивает не более MaxLen символов строк, проверяя точное соответствие высоты букв. Возвращаемый результат см. StrComp. Функция правильно работает только с латиницей.
Функция StrLower.
Преобразует в строчные буквы. Заголовок:
Function StrLower(Str: PChar): PChar;
Преобразует заглавные буквы строки Str к строчным и возвращает указатель на результат. Функция правильно работает только с латиницей.
Функция StrMove.
Копирует строку. Заголовок:
Function StrMove(Dest, Source: PChar; Count: Word): PChar;
Копирует точно Count символов строки Source в строку Dest и возвращает указатель на результат. Функция игнорирует действительные размеры строк и может выйти за их пределы.
Функция StrNew.
Помещает строку в кучу. Заголовок:
Function StrNew(Str: PChar): PChar;
Функция Str Pas.
Преобразует ASCHZ-строку в строку String. Заголовок:
Function StrPas(Str: PChar,) : String;
Функция StrPCopy.
Преобразует строку String в ASCIIZ-строку. Заголовок:
Function StrPCopy(Str: PChar; S: String): PChar;
Возвращает указатель на Str.
Функция StrPos.
Ищет подстроку. Заголовок:
Function StrPos(Strl, Str2: PChar): PChar;
Ишет подстроку Str2 в строке Strl и возвращает указатель на первое вхождение Str2 или NIL, есди подстрока не найдена.
Функция StrRScan.
Ищет последний символ. Заголовок:
Function StrRScan(Str: PChar; Ch: Char): PChar;
Ищет символ Ch в строке Str и возвращает указатель на последний обнаруженный символ Ch или NIL, если символ не найден.
Функция StrScan.
Ищет первый символ. Заголовок:
Function StrScan(Str: PChar; Ch: Char): PChar;
Ищет символ Ch в строке Str и возвращает указатель на первый обнаруженный символ Ch или NIL, если символ не найден.
Функция StrUpper.
Заголовок:
Function StrLower(Str: PChar): PChar;
Преобразует строчные буквы строки Str к заглавным и возвращает указатель на результат. Функция правильно работает только с латиницей.
Четыре функции модуля Strings (StrLower, StrUpper, StrlComp и StrLIComp) используют преобразование высоты букв и работают корректно только для букв латинского алфавита (латиницы). Для русских букв эти функции можно изменить следующим образом:
{Этот модуль содержит модификацию функций стандартного модуля Strings для работы с кириллицей (альтернативный вариант кодировки}
{$Х+}
Unit StringsR;
INTERFACE
Function LoCase(Ch: Char): Char;
Function UpCase(Ch: Char): Char;
Function StrLower(Str: PChar): PChar;
Function StrUpper(Str: PChar): PChar;
Function StrlComp(Strl, Str2: PChar): Integer;
Function StrLIComp(Strl, Str2: PChar; MaxLen: Word): Integer;
IMPLEMENTATION
Uses Strings;
Function LoCase(Ch: Char): Char;
{ Преобразует латинскую или русскую букву Ch к строчной}
begin
case Ch of
'A' . .'Z':LoCase:= Chr(ord('a')+ord(Ch)-ord('A'));
'A' . .'П':LoCase:= Chr(ord('a')+ord(Ch)-ord('A'));
'P' . .'Я':LoCase:= Chr(ord('p')+ord(Ch)-ord('P'));
else
LoCase:= Ch
end
end;
{-------------------}
Function UpCase(Ch: Char): Char;
{Преобразует латинскую или русскую букву Ch к заглавной}
begin
case Ch of
'a'..'z': UpCase := Chr(ord('A')+ord(Ch)-ord('a'));
'a'..'n': UpCase := Chr(ord('A')+ord(Ch)-ord('a'));
'p'..'я': UpCase := Chr(ord('P')+ord(Ch)-ord('p'));
else
UpCase:= Ch
end
end;
{-------------}
Function StrLower(Str: PChar): PChar;
{Преобразует латинские и русские буквы строки Str к строчным}
var
k: Word;
begin
for k := 0 to StrLen(Str)-1 do
Str[k]:= LoCase(Str[k]);
StrLower:= Str
end;
{-----------}
Function StrUpper(Str: PChar): PChar;
{Преобразует латинские и русские буквы строки Str к заглавным}
var
k: Word;
begin
for k :=0 to StrLen(Str)-1 do
Str[k]:= UpCase(Str[k]);
StrUpper:= Str
end;
{------------}
Function StrlComp (Str1, Str2 : PChar): Integer;
{Сравнивает две строки, игнорируя возможную разницу в высоте латинских или русских букв}
var
k: Word;
Max: Word;
begin
{Определяем максимальное количество сравниваемых символов
как минимум длин строк}
Мах := StrLen(Str1) ;
if StrLen (Str2).<Max then
Max := StrLen(Str2) ;
{Проверяем символы до первого несовпадения.Буквы преобразуем к заглавным}
for k := 0 to Max-1 do
if UpCase(Strl[k])<>UpCase(Str2[k]) then
begin
{Строки не равны}
StrIComp := ord(UpCase(StrlCk]))-ord(UpCase(Str2[k]));
Exit
end;
{Разницы нет - результат зависит от совпадения длин}
StrIComp := StrLen(Str1)-StrLen(Str2)
end;
{--------------}
Function StrLIComp(Str1, Str2: PChar; MaxLen: Word): Integer;
{ Сравнивает не более MaxLen символов строк, проверяя точное соответствие высоты букв}
var
k. Max: Word;
begin
{Определяем максимальное количество сравниваемых символов
как минимум длин строк и MaxLen}
Мах := MaxLen;
if StrLen(Strl)<Max then Max := StrLen(Strl);
if StrLen(Str2)<Max then Max := StrLen(Str2);
{Проверяем символы до первого несовпадения.Буквы преобразуем к заглавным}
for k := 0 to Max do
if UpCase(Str1 [k])<>UpCase(Str2[k]) then
begin
StrLIComp := ord(UpCase(Str1[k]))-ord(UpCase(Str2[k]));
Exit
end;
{Разницы нет. Если проверено MaxLen символов, строки считаются равными, в противном случае результат зависит от совпадения длин строк}
if Max=MaxLen then
StrLIComp := 0
else
StrLIComp := StrLen(Str1)-StrLen(Str2)
end;
end.
Если Вы будете использовать этот модуль, ссылайтесь на него в предложении Uses после ссылки на стандартный модуль Strings:
Uses Strings, StringsR, ...
Другие возхможности Турбо Паскаля
Внешние процедуры(функции)
Использование встроенных машинных кодов
Обращение к функциям операционной системы
Поддержка процедур обработки прерываний
Запуск внешних программ
Оверлей
Прямое обращение к памяти и портам ввода-вывода
Длинные строки
Использование встроенных машин кодов
В Турбо Паскале имеется возможность непосредственного включения в программу небольших фрагментов, написанных в машинных кодах. Для этого используется стандартная директива INLINE, за которой в круглых скобках следует один или несколько элементов машинного кода, разделяемых косыми чертами. Элемент кода, в свою очередь, строится из одного или более элементов данных, разделенных знаками «+» или «-»
В качестве элемента данных может использоваться целая константа, идентификатор (переменной, константы или функции) или ссылка на счетчик адреса («*»). Каждый элемент данных вызывает генерацию 1 или 2 байт кода программы. Значение этого кода получается сложением или вычитанием элементов данных в соответствии с разделяющим их знаком. Значением идентификатора переменной, константы, функции служит адрес соответствующего объекта, значением ссылки на счетчик адреса является тот адрес, по которому будет размещаться следующий байт кода.
Элемент кода будет генерировать 1 байт кода, если этот элемент состоит только из целых констант и значение результата не превышает мощности одного байта, т.е. находится в диапазоне от 0 до 255. Если значение превышает 255 или элемент кода содержит ссылку на счетчик адреса, генерируются 2 байта. Знаки «<» и «>» могут использоваться -для отмены автоматического выбора размера генерируемого кода. Если элемент кода начинается со знака «<», в код заносится только 1 байт (с младшей значимостью), даже если само значение занимает 2 байта. Наоборот, если элемент начинается со знака «>», в код заносятся 2 байта (старший байт может оказаться нулевым).
Значением идентификатора является смещение соответствующего объекта. Если переменная - глобальная, смещение задается относительно сегмента данных, хранящееся в регистре DS, если это локальная переменная, - относительно сегмента стека регистр SP). Базовым сегментом типизированной константы является сегмент кода регистр CS).
В следующем примере приводятся две короткие процедуры, с помощью которых можно ввести или вывести данные через любой порт ПК.
Function InPort(Port: Word): Word;
var
pp: Word;
cc:Char;
egin
pp:=port;
inline (
$8b/$96/pp/ { mov DX,pp[bp] }
$EC/ { IN AX,DX }
$88/$86/cc); {mov cc[bp],AX}
InPort:=ord(cc);
end;
Procedure OutPort(Port,Bt: Word);
var
pp: Word;
cc:Char;
begin
pp:=port;
cc:=chr(Bt);
inline (
$8a/$86/cc/ { mov AX,cc[bp] }
$8b/$96/pp/ { mov DX,pp[bp] }
$EE) { OUT DX,AX }
end;
Операторы INLINE могут произвольным образом смешиваться с другими операторами Турбо Паскаля, однако при выходе из процедуры (функции) содержимое регистров ВР, SP, DS и SS должно быть таким же, как и при входе в нее.
С помощью директивы INLINE можно также задавать последовательность машинных кодов, которую необходимо несколько раз вставить в программу. Для этого используется описание INLINE-процедуры, например:
Procedure DisableInterrupts;
inline ($FA); {CLI}
INLINE-процедура имеет обычный для Турбо Паскаля заголовок, в то время как тело процедуры пишется целиком с помощью оператора INLINE. Всякий раз, когда в программе будет встречаться оператор вызова INLINE-процедуры, компилятор Турбо Паскаля будет вставлять на это место не код вызова процедуры, а нужные машинные коды. Например, вместо вызова процедуры в операторе
DisableInterrupt;
компилятор вставит команду запрета прерываний CLI. Таким образом, INLINE-процедуры служат своеобразным средством расширения возможностей стандартного компилятора Турбо Паскаля и подобны макросам ассемблера. Использование INLINE-процедур увеличивает скорость исполнения программы, так как не осуществляется генерация (и исполнение) команд передачи управления в процедуру. По этой причине в INLINE-процедурах не следует использовать команды выхода из подпрограммы. INLINЕ-процедура может иметь параметры, однако на них нельзя ссылаться в INLINE-директивах (на другие символы Турбо Паскаля ссьшаться можно). В следующем примере перемножаются два числа типа INTEGER, результат имеет тип LONGINT:
FUNCTION LongMul(X,YInteger) : Longint;
inline (
$5 А/ {POP AX; получить в АХ число Х }
$58/ { POP DX; получить в DX число Y }
$F7/$EA); { IMUL DX; DX:AX ;= X * Y }
Отметим, что в силу упоминавшегося сходства с макросами ассемблера, имена INLINE-подпрограмм не могут использоваться в качестве аргументов в операторах @ или служить параметрами функций ADDR, OFS и SEG.
Обращения к функциям операционной системы
Турбо Паскаль предоставляет программисту практически неограниченные возможности использования любых функций стандартной операционной системы MS-DOS. При внимательном анализе материала этой книги Вы, очевидно, заметите, что значительную его часть составляет описание многочисленных библиотечных процедур и функций. Собственно язык Паскаль весьма прост и лаконичен, что, по мнению многих специалистов, и послужило одной из причин его широкого распространения. Библиотечные же процедуры и функции, в своей значительной части, являются, по существу, своеобразным интерфейсом между языковыми средствами Турбо Паскаля и функциями операционной системы. Разумеется, можно только приветствовать усилия разработчиков Турбо Паскаля по созданию мощных библиотек TURBO.TPL и GRAPH.TPU, однако ясно, что таким способом невозможно запрограммировать все допустимые обращения к средствам ДОС. Вот почему в Турбо Паскаль включены две процедуры, с
помощью которых программист может сам сформировать вызов той или иной функции дисковой операционной системы (ДОС).
Следует учесть, что единственным механизмом обращения к функциям ДОС является инициация программного прерывания. Прерывание - это особое состояние вычислительного процесса. В момент прерывания нарушается нормальный порядок выполнения команд программы и управление передается специальной процедуре, которая входит в состав ДОС и называется процедурой обработки прерывания. Каждое прерывание характеризуется в рамках ДОС порядковым номером и связано со своей процедурой обработки. В архитектуре центрального процессора ПК предусмотрены прерывания двух типов - аппаратные и программные. Аппаратные прерывания создаются схемами контроля и управления ПК и сигнализируют операционной системе о переходе какого-либо устройства в новое состояние или о возникновении неисправности. Программные прерывания инициируются при выполнении одной из двух специальных команд микропроцессора (INT или INTO) и служат для обращения к средствам ДОС.
Описываемые ниже процедуры входят в состав библиотечного модуля DOS.TPU и становятся доступными после объявления USES DOS. При возникновении программного прерывания в большинстве случаев необходимо передать процедуре обработки прерывания некоторые параметры, в которых конкретизируется запрос нужной функции. Эти параметры, а также выходная информация (результат обработки прерывания) передаются от программы к процедуре и обратно через регистры центрального процессора. В составе модуля DOS.TPU для этих целей определен специальный тип:
type
Registers = record case integer of
0 : (AX, BX, CX, BP, SI, DI, DS, ES, Flags : word);
1 : (AL, AH, BL, BH, CL, CH, DL, DH : byte)
end ;
Этот тип имитирует регистры центрального процессора и дает возможность обращаться к ним как к 16-битным или 8-битным регистрам.
Процедура INTR. С помощью этой процедуры инициируется программное прерывание с требуемым номером. Обращение:
INTR (<N>,<регистры>)
Здесь <N> - выражение типа BYTE; номер прерывания;
<регистры> - переменная типа REGISTERS; в этой переменной процедуре обработки прерывания передается содержимое регистров и в ней же возвращается выходная информация.
Например, прерывание с номером 18 ($12) возвращает в регистре АХ объем оперативной памяти ПК. Короткая программа, представленная в примере 11.1, выведет на экран сообщение об этом объеме.
Пример 11.1.
Uses DOS;
var
r : registers;
begin
Intr ($12, r);
writeln ('Объем памяти = ',r.AX, ' Кбайт')
end.
Процедура MSDOS. Инициирует прерывание с номером 33 ($21). Формат обращения:
MSDOS (<регистры>)
Программное прерывание с номером 33 ($21) стоит особняком, так как оно дает доступ к большому количеству функций ДОС (этим прерыванием вызывается 85 функций). Рассматриваемая процедура полностью эквивалентна вызову процедуры INTR с номером прерывания 33. Например, следующая программа (пример 11.2) выведет на экран версию операционной системы:
Пример 11.2
Uses DOS;
var
r : registers;
begin
r.АН := $30;
MsDos(r);
WriteLn('Версия операционной системы: ',
r.AL, '.' r.АН)
end.
Оверлей
Как отмечалось в гл.9, максимальный размер модуля не может превышать 64 Кбайта, однако количество модулей не ограничено, что дает возможность разрабатывать весьма крупные программы, занимающие, например, всю доступную оперативную память ПК (приблизительно 580 Кбайт). Тем не менее, в некоторых случаях и этот объем может оказаться недостаточным. Турбо Паскаль предоставляет в распоряжение программиста простой и достаточно эффективный механизм оверлея, с помощью которого можно создавать программы практически неограниченной длины (следует оговориться, что речь идет только о длине кода программы; два важных размера -длина сегмента данных и размер программного стека - в Турбо Паскале не могут превышать 64 Кбайта независимо от структуры программы).
Оверлей - это такой способ использования оперативной памяти, при котором в один и тот же участок памяти, называемый оверлейным буфером, попеременно по мере надобности загружаются различные оверлейные (перекрывающиеся) модули. При этом все оверлейные модули в готовом к работе виде хранятся на диске, а в оперативной памяти в каждый момент находится лишь один активный модуль и, возможно, небольшое число неактивных.
Пусть, например, программа (рис. 11.1) состоит из главной части MAIN и двух модулей А к В, a LM, LA и LB - соответственно длина главной части и обоих модулей, причем LA > LB. Тогда неоверлейная программа займет в памяти LM + LA + LB байт, в то время как- оверлейная программа - лишь LM + LA байт.
При исполнении оверлейной программы в память первоначально загружается главная часть и один из модулей, например, модуль А. Если в процессе исполнения программы встретится обращение к модулю В, программа приостановит свою работу, с диска в оверлейный буфер будет загружен модуль В (модуль А при этом частично уничтожается), после чего программа продолжит свою работу. Если в дальнейшем
встретится обращение к А, точно таким же образом будет загружен модуль А, причем загрузка нужных модулей в оверлейный буфер осуществляется автоматически и программисту не нужно об этом заботиться.
Puc.11.1. Пример структуры программы: а) неоверлейная; 6) оверлейная
Описанный механизм выявляет главное преимущество оверлейной структуры: объем оперативной памяти, занимаемой оверлейной программой, определяется длиной ее главной части и наибольшего из перекрывающихся модулей, в то время как при неоверлейной структуре в этот объем входит суммарная длина всех модулей. Чем больше в программе оверлейных модулей и чем меньше длина наибольшего из них, тем больший выигрыш в памяти дает оверлейная структура. Однако совершенно очевиден и главный недостаток таких структур: на каждую-загрузку оверлейного модуля с диска в оверлейный буфер требуется дополнительное время, поэтому оверлейная программа будет исполняться с меньшей скоростью.
Работа оверлейных программ обеспечивается с помощью процедур и функций библиотечного модуля OVERLAY, входящего в библиотечный файл TURBO.TPL.
При создании оверлейных программ нужно руководствоваться следующей последовательностью действий.
Выделить главную часть программы и разбить оставшуюся часть на несколько модулей. Отметим, что никаких дополнительных ограничений на модули, по сравнению с описанными в гл.9, не накладывается за одним исключением: в оверлейных модулях нельзя использовать процедуры обработки прерываний. Желательно продумать состав модулей таким образом, чтобы по возможности минимизировать количество их перезагрузок в оверлейный буфер в процессе исполнения программы.
В главной части программы указать с помощью директив компилятора вида {$О <имя>} те модули, которые будут оверлейными, например:
Program Main;
Uses CRT, DOS,Graph, Overlay, UnitA, UnitB;
{$0 DOS}
{$0 UnitA}
{$O UnitB}
Следует подчеркнуть, что из всех стандартных библиотечных модулей только один модуль DOS может быть оверлейным, остальные модули (CRT, Graph, Printer и т.д.) не могут объявляться оверлейными.
Предусмотреть перед первым по логике работы программы обращением к оверлейному модулю вызов процедуры инициализации оверлея OVRINIT. Здесь же, если это необходимо, следует установить размер оверлейного буфера и указать возможность использования расширенной памяти (см. ниже).
В начале главной программы и каждого оверлейного модуля необходимо поместить директивы компилятора {$О+} и {$F+} или установить опции OPTIONS /COMPILE/FORCE FAR CALLS и OPTIONS/ COMPILE/ OVERLAYS ALLOWED (см. прил.1) в активное состояние, после чего откомпилировать программу на диск. Программа готова к работе.
Таким образом, все процедуры и функции в оверлейной программе должны использовать дальнюю модель вызова - это обязательное условие. Отметим, что попытка компиляции оверлейного модуля, в начале которого отсутствует директива {$О+} предполагается, что опция среды OPTIONS/COMPILE/OVERLAY ALLOWED неактивна), будет обнаружена компилятором, в то время как! неправильная (ближняя) модель вызова оверлейных подпрограмм компилятором не контролируется и может привести к непредсказуемым результатам при исполнении программы.
Далее, инициация оверлея (осуществляется вызовом процедуры OVRINIT, см. ниже) должна происходить до вызова любого из оверлейных модулей. Это требование кажется тривиальным, однако множество проблем в оверлейных программах обычно :вязано именно с ним. Дело в том, что обращение к оверлейному модулю может происходить еще до начала работы основной программы: напомню, что любой модуль (в том числе и оверлейный) может иметь инициирующую часть, которая исполняется перед началом работы основной программы. В связи с этим рекомендую придерживаться следующего простого правила: никогда не используйте оператор BEGIN в конце модуля, если Вам нет нужды в инициирующих действиях; пустая инициирующая часть содержит пустой оператор, которому будет передано управление на этапе инициации. Таким образом, пустая инициирующая часть оверлейного модуля очень часто может вызывать сообщение об ошибке периода исполнения с кодом 208 (не установлена система управления оверлеем). Как же быть, если в оверлейном модуле все-таки нужна инициирующая часть? В этом случае можно рекомендовать следующий прием. Создайте лишний модуль, в котором будут пустыми все части, кроме инициирующей. В этой части разместите команды инициации оверлея. Новый модуль не должен быть оверлейным и его имя должно стоять в предложении USES основной программы перед именем любого оверлейного модуля. После компиляции такой программы инициация оверлея будет осуществляться перед выполнением любой другой инициирующей части и проблема будет решена.
Процедура OVRINIT.
Инициализирует оверлейный файл. Обращение:
OVRINIT (<имя>)
Здесь <имя> - выражение типа STRING; имя файла с оверлейной частью программы.
При компиляции оверлейной программы создается специальный файл с именем, совпадающим с именем главной программы, и расширением .OVR. В этот файл компилятор помещает все оверлейные модули, из него же эти модули загружаются в оверлейный буфер в процессе исполнения программы. Файл с оверлейной частью программы должен размещаться в том же каталоге, что и файл с главной частью (с расширением .ЕХЕ). Отметим, что имя оверлейного файла необходимо дополнять расширением .OVR.
Обычно размер оверлейного буфера определяется автоматически таким образом, чтобы в нем мог разместиться самый крупный из всех оверлейных модулей. Программист может увеличить размер буфера. Тогда при загрузке в буфер очередного модуля программа проверит, достаточно ли в буфере свободного места и, если достаточно, загрузит новый модуль сразу за старым, который, таким образом, не будет уничтожен. Такой механизм способствует минимизации потерь времени на перезагрузку модулей. Если установлен очень большой размер буфера, то в нем, возможно, смогут разместиться все оверлейные модули, однако в этом случае оверлейная структура становится просто ненужной.
Процедура OVRSETBUF.
Устанавливает размер оверлейного буфера. Формат обращения:
OVRSETBUF (<длина>)
Здесь <длина> - выражение типа LONGINT задает новую длину буфера в байтах не больше той, которую устанавливает сама система автоматически. Расширение буфера идет за счет соответствующего уменьшения доступной динамической памяти, поэтому к моменту вызова этой процедуры куча должна быть пустой.
Функция OVRGETBUF.
Возвращает значение типа LONGINT, содержащее текущий размер оверлейного буфера. Обращение:
OVRGETBUF
Процедура OVRINITEMS.
Обеспечивает использование расширенной памяти. Если Ваш ПК относится к классу компьютеров типа IBM PC/AT и в нем имеется так называемая EMS-памятъ (Expanded Memory Specification - расширенная1 память, удовлетворяющая стандарту фирм Lotus/Intel/Microsoff). Вы можете использовать эту память для размещения в ней оверлейного файла .OVR. Поскольку время доступа к расширенной памяти значительно меньше времени чтения с диска, такое размещение увеличивает скорость исполнения оверлейной программы. Обращение:
OVRINITEMS
При обращении к этой процедуре программа прежде всего проверит, достаточен ли объем имеющейся в Вашем ПК EMS-памяти для размещения оверлейного файла. Если это так, то оверлейный файл считывается в EMS-память, сам файл закрывается, и программа будет получать оверлейные модули из этой памяти. Если же ЕMS-память отсутствует или ее объем недостаточен, обращение к процедуре игнорируется, и программа будет считывать оверлейные модули с диска.
Все управление оверлеем осуществляется стандартной подпрограммой, которая называется администратором оверлея. Эта подпрограмма получает управление всякий
раз, когда программа обращается к ресурсам оверлейного модуля, не размещенного в данный момент в буфере. Администратор оверлея сначала перемещает предыдущий оверлейный модуль из буфера в так называемую контрольную зону, а уже затем грузит с диска в буфер новый модуль. Если в момент, когда оверлей находится в контрольной зоне, программа вновь обратится к нему, он вернется на свое старое место и таким образом затраты времени на обмен данными с диском будут уменьшены. Программист может задать размер контрольной зоны с помощью обращения к процедуре OVRSETRETRY и получить этот размер с помощью функции OVRGETRETRY. Обычно размер контрольной зоны составляет от одной трети до половины размера оверлейного буфера. Вы можете подобрать этот размер экспериментально в ходе пробного прогона программы. Для этого используются две переменные модуля OVERLAY:
var
OvrTrapCount: Word;{Счетчик обращений ,к администратору}
OvrLoadCount: Word;{Счетчик загрузок в оверлейный буфер}
Всякое обращение программы к оверлейному модулю, которого нет в оверлейном буфере (в том числе и к модулю, находящемуся в контрольной зоне), приводит к наращиванию содержимого переменной OVRTRAPCOUNT на единицу. Всякая загрузка оверлейного модуля из файла в буфер увеличивает на единицу счетчик OVRLOADCOUNT.
В интерфейсной части модуля ОVERLAY объявлены еще три переменные, которые могут оказаться полезными для некоторых применений.
type
vrReadFunc = Function (OvrSeg: Word): Integer;
var
vrReadBuf : OvrReadFunc;{ Функция чтения из оверлейного файла}
vrResult :Integer;{Признак ошибки оверлея}
vrFileMode:Byte;{Способ доступа к оверлейному файлу}
Переменная OVRRESULT содержит код, указывающий на успех или неуспех каждой очередной операции администратора оверлея. Значения этой переменной могут быть такими:.
0 - операция прошла успешно;
-1 - общая ошибка;
-2 - не найден оверлейный файл;
-3 - не хватает памяти для оверлейного буфера;
-4 - ошибка чтения-записи оверлейного файла;
-5 - не работает драйвер EMS-памяти;
-6 - не хватает EMS-памяти.
Переменная OVRFILEMODE обычно содержит 0, что трактуется как возможность доступа к оверлейному файлу только для чтения информации. Перед вызовом процедуры OVRINIT программа может установить другое значение этой переменной и таким образом изменить доступ к файлу, что бывает необходимым, если ПК подключен к сети ЭВМ.
В переменной OVRREADBUF содержится имя функции, к которой обращается администратор оверлея при каждом чтении из оверлейного файла. Программа может
перехватить обращение к этой функции и проанализировать результат операции. Для этого необходимо в основной программе сохранить имя стандартной функции чтения в глобальной переменной типа OVRREADFUNC и поместить в переменную OVRREADBUF имя новой функции. В эту новую функцию администратор будет передавать управление всякий раз, когда появится необходимость чтения из оверлейного файла. Программа может проверить состояние дисков перед исполнением операции (например, наличие нужного сменного диска), выполнить саму операцию (путем вызова функции, сохраненной в глобальной переменной), проверить результат обращения и предпринять необходимые действия. Отметим, что нормальное завершение операции чтения указывается нулевым значением функции чтения, ненулевое значение означает ту или иную ошибку; код ошибки стандартен для ДОС (см. прил.3) и/или для драйвера EMS-памяти.
При желании Вы можете пристыковать оверлейный файл в конец EXE-файла основной программы. При этом следует учесть, что интегрированная среда пристыковывает в конец EXE-файла отладочные таблицы, поэтому программу и все ее модули следует компилировать в режиме отключенных опций OPTIONS /COMPILER/DEBUG INFORMATION и OPTIONS/COMPILER/LOCAL SYMBOLS (см.прилЛ.2.8). Для объединения EXE-файла с оверлейным файлом необходимо дать такую команду ДОС:
СОРY /В NAME.EXE+NAME.OVR
Здесь NAME.EXE - имя EXE-файла, NAME.OVR - имя оверлейного файла. Чтобы оверлеи читались из ЕXE-файла, нужно просто указать имя этого файла при обращении к OVRINIT:
Ovrlnit(ParamStr(0));
(в программу всегда передается параметр ParamStr(0), в котором ДОС сообщает полное имя запущенной программы - с указанием диска и каталога, откуда была загружена программа).
Поддержка процедур обработки прерываний
При написании процедур обработки прерываний существенными являются два обстоятельства. Во-первых, процедура обработки прерывания не должна искажать работу прерванной программы. Для этого необходимо сначала сохранить регистры центрального процессора, а перед выходом из процедуры - восстановить их. Во-вторых, процедура должна строиться по принципу реентерабельности (повторной входимости): ее работа может быть прервана в любой момент другими прерываниями и ДОС может обратиться к соответствующей функции до завершения обработки предыдущего прерывания.
Турбо Паскаль предоставляет программисту возможность написания процедур обработки прерывания на языке высокого уровня, хотя обычно такие процедуры пишутся на языке ассемблера.
Процедура обработки прерывания, написанная на Турбо Паскале, должна начинаться стандартной директивой INTERRUPT (прерывание), например:
Procedure IntProc (Flags, CS, IP, AX, BX, CX, DX,
SI, DF, DS, ES, BP : word); inerrupt;
begin
...
end ;
Формальные параметры в заголовке процедуры должны перечисляться в указанном порядке - через эти параметры все регистры прерванной программы становятся доступны процедуре обработки прерывания. Количество перечисляемых в заголовке процедуры параметров-регистров может быть любым, но не больше 12. Если в списке опущен какой-либо параметр, должны быть опущены также и все предшествующие ему параметры. Например, описание
Procedure IntProc(SI, DP, ES: word); interrupt;
будет неверным (опущены параметры DS и ВР); правильное описание:
Procedure IntProc(SI, DP, DS, ES, BP: word); interrupt;
Заметим, что компилятор не контролирует порядок перечисления параметров в заголовке процедуры обработки прерывания.
Директива INTERRUPT вызывает генерацию специальных машинных кодов, обеспечивающих заталкивание регистров в стек при входе в процедуру и извлечение их из стека перед выходом из нее.
При входе в процедуру:
При выходе из процедуры:
mov sp, bp
pop bp
pop es
pop ds
pop di
pop si
pop dx
pop cx
pop bx
pop ax
irep
В самой процедуре обработки прерывания не рекомендуется обращаться к другим функциям ДОС, так как некоторые из них, в том числе все функции ввода-вывода, нереентерабельны.
Для связи с любыми процедурами прерываний, а следовательно, и с процедурами, написанными программистом, используются векторы прерываний - четырехбайтные абсолютные адреса точек входа в эти процедуры. Векторы прерываний располагаются
в младших адресах оперативной памяти, начиная с нулевого адреса: прерывание номер 0 - по адресу 0, номер 1 - по адресу 1*4 = 4, номер N - по адресу N * 4. С помощью следующих двух процедур программист может прочитать содержимое любого вектора или установить его новое значение.
Процедура GETINTVEC.
Возвращает вектор прерывания с указанным номером. Обращение:
GETINTVEC (<,<вектор>)
Здесь <D> - выражение типа BYTE; номер прерывания;
<вектор> - переменная типа POINTER; адрес точки входа в процедуру обработки прерывания.
Представленная в примере 11.3 программа выводит на экран содержимое всех ненулевых векторов прерываний.
Пример 11.3
Uses DOS;
var
i : byte; p : pointer;
begin
for i := 0 to 255 do
begin
GetlntVec (i, p) ;
if (Seg (р) <> 0) or (Ofs (рл) <> 0) then
WriteLn (' N=', i:3, ' Seg=', Seg (р):5,
' Ofs =' , Ofs (р) :5)
end
end.
Процедура SETINTVEC.
Устанавливает ндвое значение вектора прерывания. Формат обращения:
SETINTVEC (<,<адрес>)
Здесь <D> - выражение типа BYTE; номер прерывания;
<адрес> - выражение типа POINTER; адрес точки входа в процедуру обработки прерывания.
При нормальном завершении программы она выгружается из памяти, что делает невозможным разработку резидентных в памяти процедур обработки прерываний. Вы можете прекратить работу программы и оставить ее резидентной в памяти, если воспользуетесь процедурой KEEP.
Процедура KEEP.
Завершает работу программы и оставляет ее резидентной в памяти. Обращение:
KEEP (<код>)
Здесь <код> - выражение типа WORD - код завершения программы. Код завершения представляет собой фактически единственный механизм передачи сообщений от запущенной программы к программе, которая ее запустила. Он может быть проанализирован в вызывающей программе с помощью функции DOSEXITCODE.
Функция DOSEXITCODE.
Возвращает значение типа WORD - код завершения подчиненной программы. Обращение:
DOSEXITCODE
Прямое обращение к памяти и портам ввода - вывода
В Турбо Паскале имеется пять предварительно объявленных массивов: MEM, MEMW, MEML, PORT и PORTW. Первые три обеспечивают доступ к любому участку оперативной памяти по абсолютному адресу, два других - доступ к портам ввода-вывода.
Компонентами массива MEM являются данные типа BYTE, массива MEMW - типа WORD, массива MEML - типа LONGINT. Обращение к элементам этих массивов, т.е. их индексация, имеет специальный вид: каждый индекс представляет собой абсолютный адрес и состоит из двух выражений типа WORD; первое дает сегментную часть адреса, второе - смещение; выражения разделяются двоеточием. Например:
Меm[$0000:$1000] := 0;
DataMem := MemWfSeg(p):0fs(p)];
MemLong :.= MemL [64 : i*SizeOf (real) ] ;
Как следует из технического описания операционной системы MS-DOS, в памяти по адресу $F000:$FFFE располагается байт-указатель типа компьютера. Следующая программа (пример 11.5) прочтет этот байт и выведет на экран тип Вашего ПК.
Пример 11.5
begin
Write (' Тип компьютера: ') ;
case Mem [$FOOO:$FFFE] of
$FF : WriteLn ('PC');
$FE : WriteLn('XT');
$FD : WriteLn('PCjr');
$FC : WriteLn('AT');
$F9 : WriteLn('совместимый с PC')
end
end.
Компонентами массива PORT являются байты (тип BYTE), а массива PORTW - слова (тип WORD). Индексами этих массивов должно быть выражение типа BYTE, указывающее номер нужного порта. Присвоение значения элементу массива PORT или PORTW приведет к записи в порт, упоминание элемента в выражении - к чтению из порта. Компоненты массивов PORT и PORTW нельзя передавать в качестве параметров процедурам или функциям. Эти идентификаторы не употребляются без индексных выражений.
Внешние процедуры (функции)
С помощью внешних процедур (функций) можно осуществить вызов из программы процедур или функций, написанных на языке ассемблера. Ассемблер обеспечивает компиляцию программ, написанных на машинно-ориентированном языке программирования низкого уровня. В Турбо Паскале есть собственный встроенный ассемблер см. гл.12). В этом разделе речь идет о программах, написанных и откомпилированных с помощью внешнего ассемблера, такого как, например, ассемблер фирмы MicroSoft или Turbo Assembler фирмы Borland.
Машинно-ориентированный язык ассемблера предоставляет квалифицированному программисту богатейшие возможности использования всех особенностей архитектуры ПК. Ассемблерные программы выполняются значительно быстрее и занимают меньший объем памяти, чем программы, написанные на Турбо Паскале, однако низкий уровень языка ассемблера существенно снижает производительность труда программиста и резко усложняет отладку программ. Как правило, на языке ассемблера пишутся сравнительно небольшие фрагменты программ, в которых используются недоступные из Турбо Паскаля особенности архитектуры ПК.
Внешняя процедура (функция) в программе, написанной на Турбо Паскале, объявляется своим заголовком, за которым следует стандартная директива EXTERNAL, например:
Function LoCase (ch : char):char; external;
Procedure Swapping (var a,b; N:word); external;
Как видно из этих примеров, тело внешней процедуры (функции) отсутствует - его заменяет директива EXTERNAL. Для подключения ассемблерной программы необходимо предварительно ее откомпилировать и получить объектный файл с расширением OBJ, содержащий перемещаемый код ассемблерной программы. Непосредственно перед описанием внешней процедуры (функции) в тело основной программы вставляется директива компилятора {$L<имя файла>}, где <имя фата> - имя OBJ-файла. Диск и каталог, в котором следует искать этот файл, если он не обнаружен в текущем каталоге, указываются опцией OPTIONS/DIRECTORIES/OBJECT DIRECTORIES (см.прил.1).
Перед передачей управления внешней процедуре (функции) программа помещает параметры обращения в программный стек в том порядке, как они перечислены в заголовке процедуры (функции). Ассемблерная процедура должна сохранить регистры ВР, SP, SS и DS центрального процессора в самом начале своей работы и восстановить содержимое этих регистров перед возвратом управления в программу. Остальные регистры можно не сохранять и соответственно не восстанавливать.
Параметры могут передаваться по ссылке или по значению. Если параметр передается по ссылке, в стек помещается указатель, содержащий абсолютный адрес параметра, если по значению - в стек помещается сам параметр, точнее - его значение. Все параметры-переменные, т.е. параметры, объявленные в заголовке с предшествующим словом VAR, всегда передаются по ссылке. Параметры-значения могут передаваться по ссылке или по значению в зависимости от длины внутреннего представления соответствующего параметра. В общем случае используется следующее правило: если длина внутреннего представления параметра-значения составляет 1, 2 или 4 байта, он передается своим значением, т.е. его значение помещается в стек. Точно так же через стек передаются и все вещественные данные длиной в 4, 6, 8 и 10 байт (в версии 4.0 эти данные передаются через стек сопроцессора 8087/80287, начиная с версии 5.0 -через стек центрального процессора 8086/80486). Во всех остальных случаях, если длина внутреннего представления больше 4 байт, соответствующий параметр передается по ссылке.
Ассемблерные функции в зависимости от длины внутреннего представления результата должны возвращать его через регистры центрального процессора или сопроцессора по следующим правилам:
длиной в 1 байт - в регистре AL;
длиной в 2 байта - в регистре АХ;
длиной в 4 байта - в регистрах DX:AX (старшее слово в DX);
тип REAL (6 байт) - в регистрах DX:BX:AX;
типы SINGLE, DOUBLE, EXTENDED и СОМР - через стек сопроцессора 8087/80486;
указатели - в регистрах DX:AX (сегмент в DX);
строки возвращаются по ссылке: адрес начала строки помещается в DX:AX (сегмент в DX).
Все ассемблерные процедуры должны размещаться в сегменте с именем CODE или CSEG, или с именем, оканчивающимся на _ТЕХТ; инициализированные локальные Переменные помещаются в сегмент с именем CONST или с именем, оканчивающимся на _DATA. Все другие локальные переменные необходимо размещать в сегменте с именем DATA или DSEG, или с именем, оканчивающимся на _BSS. Любые другие объявления сегментов игнорируются. Все имена, объявленные в интерфейсной части модулей программы, написанной на Турбо Паскале, становятся доступны ассемблерной процедуре (функции) после их объявления директивой EXTRN. Точно так же все имена ассемблерных процедур и функций, которые должны быть доступны программе на Турбо Паскале, следует объявлять директивой PUBLIC.
Запуск внешних программ
Из программы, написанной на Турбо Паскале, можно запустить любую другую готовую к работе программу. Для этого используется процедура ЕХЕС из библиотечного модуля DOS. Формат обращения к процедуре:
ЕХЕС (<имя>,<параметры>)
Здесь <имя> - выражение типа STRING; имя файла с вызываемой программой; <параметры> - выражение типа STRING; параметры вызова.
Имени запускаемой программы может предшествовать путь к файлу. Параметры передаются запускаемой программе в виде текстовой строки и могут быть проанализированы ею с помощью двух следующих функций.
Функция PARAMCOUNT.
Возвращает общее количество параметров вызова программы (значение типа WORD). Обращение:
PARAMCOUNT
Параметры вызова обычно следуют в командной строке ДОС сразу за именем вызываемой программы и отделяются от этого имени и друг от друга пробелами, например:
C:\TP\TURBO MYPROG.PAS
C:\SIAM A:\SYSTEM1.SIA
Здесь MYPROG.PAS и A:\SYSTEM1.SIA - параметры, передаваемые программам TURBO и SIAM.
При вызове программы непосредственно из среды Турбо Паскаля ей можно передать параметры с помощью опции OPTIONS/PARAMETERS (см. прил.1).
Функция PARAMSTR.
Возвращает значение типа STRING, соответствующее нужному параметру вызова. Формат обращения:
PARAMSTR (<D>)
Здесь <D> - выражение типа WORD; порядковый номер параметра.
Заметим, что программе всегда передается параметр, соответствующий N = 0. В этом параметре ДОС сообщает полное имя запущенной программы с указанием диска и каталога, откуда она была загружена.
Использование процедуры ЕХЕС имеет ряд особенностей. Прежде всего необходимо отметить, что сама вызывающая программа остается резидентной в памяти, поэтому она не должна занимать всю оперативную память. Объем выделяемой программе памяти регулируется опцией OPTIONS/MEMORY SIZES (см. прил.1). По умолчанию параметры LOW HEAP LIMIT и HIGH HEAP LIMIT этой опции таковы (соответственно 0 и 655360 байт), что вызывающая программа, написанная на Турбо Паскале, занимает весь доступный объем памяти, и вызываемая программа не будет загружена. Полезно включить в текст вызывающей программы директиву компилятора, в которой изменяются принятые по умолчанию размеры памяти. Например, так:
{$М 2048, 0, 0}
Такая директива ограничивает используемую программой область стека величиной 2 Кбайта и исключает возможность использования в ней динамической памяти. Разумеется, Вы можете установить и другие значения параметров в этой директиве.
Специфические особенности исполнения программ Турбо Паскаля требуют изменения стандартных значений некоторых векторов прерываний. К ним относятся векторы со следующими шестнадцатеричными номерами:
$00, $02, $18, $23, $24, $34, $35, $36, $37,
$38, $39, $ЗА, $ЗВ, $ЗС, $3D, $3E, $3F, $75.
Начальные значения этих векторов сохраняются в восемнадцати переменных с именами SA VEINTXX из библиотечного модуля SYSTEM, где XX - шестнадцатеричный номер прерывания. Поэтому непосредственно перед запуском внешней программы и сразу после возврата из нее рекомендуется вызывать библиотечную процедуру без параметров SWAPVECTORS, которая обменивает содержимое векторов прерывания и перечисленных переменных.
Программа из примера 11.4 читает с клавиатуры любую команду ДОС, затем вызывает командный процессор COMMAND. COM операционной системы и передает ему эту команду.
Обратите внимание: для указания файла COMMAND.COM и пути к нему используется обращение к библиотечной функции GETENV, с помощью которой можно получить параметры настройки операционной системы. В частности, параметр COMSPEC определяет спецификацию файла, содержащего командный процессор.
Пример 11.4
{$М 1024, 0, 0}
Uses DOS;
var
st : string [79];
begin
write ('Введите команду ДОС: ');
readln (st); if st <> '' then
begin
st := '/C '+st;
SwapVectors;
Exec (GetEnv ('COMSPEC'), st) ;
SwapVectors
end
end.
Функция ENVCOUNT.
Возвращает значение типа INTEGER, в котором содержится общее количество установленных в ДОС параметров. Обращение:
ENVCOUNT
Функция ENVSTR.
Возвращает значение типа STRING, содержащее имя и значение нужного параметра настройки операционной системы. Формат обращения:
ENVSTR (<D>)
Здесь <D> - выражение типа INTEGER; номер параметра.
Эта функция возвращает строку типа NAME-VALUE, где NAME - имя, a VALUE -значение соответствующего параметра настройки.
Функция GETENV.
Возвращает значение типа STRING, в котором содержится параметр настройки ДОС. Формат обращения:
GETENV (<имя>)
Здесь <имя> - выражение типа STRING; имя параметра.
Эта функция имеет параметр обращения NAME, а возвращает значение VALUE (см. функцию ENVSTR).
Адресация
В архитектуре МП 8086/8088 адрес любого байта задается двумя 16-битовыми словами - сегментом и смещением. При формировании 20-разрядного полного адреса, необходимого для адресации в пределах 1 Мбайт, сегмент сдвигается влево на 4 разряда (умножается на 16) и складывается со смещением. Поскольку емкость 16-разрядного смещения составляет 65536 значений, в пределах одного сегмента можно адресовать до 64 Кбайт.
Архитектура МП позволяет использовать семь различных способов адресации.
Регистровая
Извлекает операнд из регистра или помещает его в регистр. Примеры:
mov ах,bх {Извлекаем из ВХ и помещаем в АХ}
add cx,ax {Содержимое АХ прибавляем к СХ}
push ex {Заталкиваем в стек содержимое СХ}
Непосредственная
Операнд (8- или 16-разрядная константа) содержится непосредственно в теле команды. Примеры:
mov ax,100 {Загружаем в АХ значение 100}
add ax,5 {К содержимому АХ прибавляем 5}
mov cx,$FFFF {Помещаем в СХ значение 65535}
Прямая
Смещение операнда задается в теле программы и складывается с регистром DS; например:
var
X: Word; В: Byte;
.......
mov ах,Х {Пересылаем значение переменной X регистр АХ}
add ah,В {К содержимому регистра АН прибавляем значение переменной В}
mov X,ax {Пересылаем содержимое регистра АХ, в область памяти переменной X}
Косвенная регистровая
Исполнительный адрес операнда (точнее, его смещение) содержится в одном из регистров ВХ, ВР, SI или DI. Для указания косвенной адресации этот регистр должен заключаться в квадратные скобки, например:
mov ax,[bx] {Содержимое 16-разрядного слова, хранящегося в памяти по адресу DS:BX,пересылаем в регистр АХ};
Каждый из регистров BX...DI по умолчанию работает со своим сегментным регистром:
DS:BX, SS:BP, DS:SI, ES:DI
Допускается явное указание сегментного регистра, если он отличается от умалчиваемого, например:
mov ax,es:[bx]
Адресация по базе
Базовый регистр ВХ (или ВР) содержит базу (адрес начала некоторого фрагмента памяти), относительно которой ассемблер вычисляет смещение, например:
mov ах,[Ьх]+10 {Загружаем в АХ 10- й по счету байт от начала базы памяти по адресу DS-.BX};
Индексная адресация
Один из индексных регистров SI или DI указывает положение элемента относительно начала некоторой области памяти. Пусть, например, АОВ - имя массива значений типа Byte. Тогда можно использовать такие фрагменты:
mov si,15 {Помещаем в SI константу 15}
mov ah,АОВ[si] {Пересылаем в АН 16-й по порядку байт от начала массива}
mov si,0
mov AOB[si],ah {Пересылаем полученное в самый первый элемент массива}
Адресация по базе с индексированием
Вариант индексной адресации для случая, когда индексируемая область памяти задается своей базой. Например:
mov ax,[bx][si]
Этот тип адресации удобен при обработке двумерных массивов. Если, например, АОВ есть массив из 10x10 байт вида
var
АОВ: array [0..9,0..9] of Byte;
то для доступа к элементу АОВ [2,3] можно использовать такой фрагмент
mov bx,20 {База строки 2}
mov si,2 {Номер 3-го элемента}
mov ax,AOB[bx] [si] {Доступ к элементу}
Ассемблерные прграммы
Ассемблерные подпрограммы - это процедуры и функции, объявленные с директивой Assembler. В таких подпрограммах исполняемая часть не содержит begin... end и состоит из единственного ассемблерного оператора asm... end. Например:
Function LongMul(X,Y:Integer):LongInt; Assembler;
asm
mov ax, X
imul Y {DX/AX содержат "длинный" результат}
end;
При компиляции ассемблерных подпрограмм выполняется ряд оптимизаций кода, в том числе:
параметры-значения строкового типа, а также длиной в 1, 2 и 4 байта не копируются во временную память, т.е. внутри подпрограммы они считаются параметрами-переменными ;
компилятор не создает переменную @Result для результата функции, и ссылка на эту переменную в ассемблерной функции недопустима; исключением являются функции, возвращающие значения строкового типа, для них разрешается использовать ссылку на @Result;
генерируются следующие команды на входе в подпрограмму и на ее выходе:
push bp {Сохраняется ВР}
mov bp,sp {ВР содержит текущую границу стека}
sub sp,Locals {Резервируется часть стека для размещения локальных переменных}
.......
mov sp,bp {Восстанавливается граница стека}
pop bp {Восстанавливается ВР}
ret Params {Из стека удаляются параметры
подпрограммы и осуществляется выход из нее}
Здесь Locals - общая длина в байтах всех объявленных в подпрограмме локальных переменных, a Params - длина (в байтах) всех формальных параметров. Если Locals и Params равны нулю, входной код не создается, а выходной содержит единственную инструкцию RET.
Все локальные переменные Турбо Паскаль размещает в стеке. Это относится как к обычным, так и к ассемблерным подпрограммам. Для ссылки на локальные переменные используется адресация по базе, задаваемой парой DS: ВР, поэтому при входе в процедуру всегда создается так называемый локальный стек: в регистр ВР помещается текущая граница стека, а сама эта граница смещается вверх на суммарную длину всех локальных переменных, чтобы работа со стеком внутри подпрограммы не разрушила локальные переменные. Например:
Procedure ...;
Assembler;
var
X: Word;
Y: Byte;
asm
mov X, ax {Компилируется в mov [BP-2], ax}
mov ah,Y {Компилируется в mov ah,[BP-3]}
end;
Ассемблерные функции должны следующим образом возвращать результат своей работы:
длиной 1 байт (Byte, Char и т.п.) - в регистре AL;
длиной 2 байта (Integer, Word) - в регистре АХ;
длиной 4 байта (Pointer, LongInt) - в регистрах DX (старшее слово) и АХ (младшее слово);
типа Real - в регистрах DX, BX, АХ (старшее слово - в DX, младшее в АХ);
вещественных типов Single, Double, Extended, Comp - в регистре ST (0) сопроцессора;
строкового типа - во временной области памяти, на которую ссылается @Result.
Директивы ассемблера
Встроенный ассемблер не поддерживает никакие директивы, обычно используемые в других ассемблерах, за исключением DB, DW, DD. Структура директив такова:
Dx <константа> [,<константа>,...,<константа>]
Здесь Dx - DB, DW или DD; <константа> - ассемблерная константа или константное выражение.
DB определяет цепочку байт, DW- слов, DD - двойных слов. Например:
db 'Турбо Паскаль',13,10
dw 0,$ FFFF, NearProc
dd 'ABCD1,999999999, FarProc
В качестве константных выражений разрешается использовать любые ассемблерные константы со значением, не выходящим из диапазона байта (DB), слова (DW) или двойного слова (DD). В любой директиве можно определять строковую константу, которая приводит к побайтовому заполнению памяти ASCII-кодами символов. Поскольку слово (двойное слово) размещается в памяти, начиная со своего младшего байта, старший (старшие) байт в директивах DW и DD при размещении строкой константы может остаться неопределенным и заполняется нулем. Например, два следующих объявления эквивалентны:
dw '5'
dw $35 {$35 - ASCII-код символа '5'}
В директивах DW и DD разрешается также указывать имена, которые в этом случае интерпретируются как адреса соответствующих объектов, причем для DW это - ближний адрес (смещение), а для DD - дальний. Например:
dw X {Размещает смещение переменной X}
dd Proc {Размещает FAR-адрес процедуры Рrос}
Данные, определяемые директивами Dx, всегда размещаются в текущем кодовом сегменте. Разместить таким образом данные в сегменте данных (т.е. определить константу или типизированную константу) невозможно - для этого используются стандартные средства Турбо Паскаля. Более того, директивы не могут снабжаться именами, а поэтому использовать размещаемые с их помощью данные не так-то просто. В следующем примере на экран выводится текстовое сообщение. Для этого используется функция 9 вызова ДОС, в соответствии с которой в регистрах DS:DX должен содержаться адрес текстовой строки, а сама строка должна заканчиваться символом «$»:
asm
jmp ©NextCode {Обходим фрагмент данных}
@:
db 'Текстовая строка,13,10,'$'
@NextCode:
push ds {Сохраняем DS}
push cs
pop ds {DS = CS}
mov dx,OFFSET @ {DS:DX - адрес строки}
mov ah,9 {AH - код функции вывода}
int 21h {Выводим строку}
pop ds {Восстанавливаем DS}
end;
Обратите внимание на использование регистра DS. В соответствии с требованиями функции 9, он должен содержать сегмент выводимой строки. В нашем случае строка располагается в кодовом сегменте, поэтому мы вынуждены сначала сохранить значение DS в стеке, а затем восстановить его. Если бы мы этого не сделали, по завершении ассемблерного оператора регистр DS указывал бы на сегмент кода и была бы потеряна связь программы Турбо Паскаля с глобальными переменными и константами.
просто ассемблер) дает возможность программировать
Встроенный ассемблер (далее - просто ассемблер) дает возможность программировать на уровне отдельных машинных инструкций. Это - главное отличие ассемблера от Паскаля и в этом отличии сосредоточены все его достоинства и недостатки. Достоинство заключается в том, что, программируя на ассемблере, программист обычно выбирает последовательность машинных инструкций так, чтобы реализовать нужные вычисления с максимальной скоростью при минимальных затратах памяти, в то время как даже такой весьма совершенный компилятор, как компилятор Турбо Паскаля, неизбежно вносит в машинный код некоторую избыточность, уменьшающую скорость счета и увеличивающую затраты памяти. С другой стороны, программирование на уровне машинных инструкций - чрезвычайно хлопотное занятие и не может сравниться по скорости разработки программ с программированием на Паскале - в этом заключается главный недостаток ассемблера.
Чтобы использовать средства ассемблера, необходимо ясно представлять себе детали архитектуры микропроцессоров Intel 80x86. К этому семейству относятся микропроцессоры:
8086 - 16-разрядный микропроцессор, используемый в ПК IBM PC/XT;
8088 - аналог 8086, отличается от него только взаимодействием с памятью: 8086 может обмениваться с памятью как байтами, так и 16-разрядными словами, в то время как 8088 - только байтами;
80286 - улучшенный вариант 8086, используемый в ПК IBM AT; может работать в двух режимах: в реальном режиме, полностью эмулирующем работу МП 8086, и в защищенном режиме, в котором способен адресовать память до 16 Мбайт (в реальном - до 1 Мбайт);
80386 - 32-разрядный вариант 80286; способен адресовать до 4 Гбайт;
80486 - комбинация 80386/80387, т.е. имеет внутреннюю подсистему реализации операций с плавающей точкой;
80586 (Pentium) - имеет ряд усовершенствований, обеспечивающих ему увеличение производительности в 2...3 раза по сравнению с 80486, в том числе возможность обрабатывать 64-разрядные числа.
Микропроцессоры этого семейства наращивают свои возможности в перечисленном порядке, но строго совместимы от младших моделей к старшим: все, что может 8086/8088, реализует и Pentium, но не наоборот. Ниже обсуждается архитектура (внутреннее устройство, способы адресации и система команд) МП 8086/8088.
Оператор ASM
Зарезервированное слово ASM открывает доступ к средствам встроенного ассемблера. Этот оператор может располагаться только внутри исполняемой части программы (подпрограммы). Область действия оператора ASM ограничивается ближайшим по тексту зарезервированным словом END. Таким образом, структура любого ассемблерного оператора такова:
asm
<Одна или несколько команд встроенного ассемблера>
end;
С точки зрения Турбо Паскаля пара asm... end считается операторными скобками, ограничивающими единственный оператор Паскаля, например:
if X>10 then
asm
.......
end
else
.......;
for k :=1 to 5 do
asm
.......
end;
Тело ассемблерного оператора asm... end может быть пустым или содержать несколько ассемблерных команд. Каждая ассемблерная команда должна располагаться на отдельной строке или отделяться от следующей за ней команды символом «;». Ниже приводятся два разных способа написания одной и той же последовательности ассемблерных команд:
asm
mov ah,0; int $16; mov ChCode, al; mov ScCode, ah
end;
asm
mov ah , 0
int $16
mov ChCode, al
mov ScCode, ah
end;
В конце строки, содержащей единственную ассемблерную команду, или между двумя командами, располагающимися на одной строке, разрешается вставлять комментарий, который должен оформляться по обычным правилам Турбо Паскаля, т.е. ограничиваться символами «{», «}» или «(*», «*)». Таким образом, комментарии разрешены между ассемблерными командами, но не внутри них. Например, такой оператор будет правильным:
asm
{Инициируем регистры}
lea si,X; push ds;
pop es; {ES := DS}
lea di,Y; mov ex,100
cld {Перенос - вперед}
rep {Выполняем Y := X}
movsw
{Здесь нет ошибки - комментарий можно вставлять между префиксом и командой}
end;
а такой - неправильным:
asm
{Готовим регистры}
lea si,X; push ds;
pop {ES:=DS} es;
{Ошибка! Комментарий разорвал мнемонику команды и ее операнд}
lea di,Y; mov ex,100 {и направление} eld
{Комментарий является разделителем команд, поэтому перед ним можно не ставить ";"}.
rep movsw
end;
В пределах ассемблерного оператора допускаются любые команды, но Турбо Паскаль требует выполнения следующего соглашения:
В начале ассемблерного оператора регистр DS содержит сегмент кода, SS - сегмент стека, ВР - текущий стек, SP указывает на вершину стека. Все эти регистры должны иметь точно такие же значения к моменту завершения работы ассемблерного оператора.
Программист не должен делать каких-либо предположений о содержимом остальных регистров, и эти регистры могут иметь произвольное значение после завершения работы ассемблерного оператора. Исключением является случай ассемблерной функции, которая должна использовать некоторые регистры для возврата своего значения (см. п. 12.2.3).
Регистры
В МП 8086/8088 имеется 14 регистров. В функциональном отношении они делятся на группы:
регистры общего назначения (АХ, ВХ, СХ, DX); предназначены для хранения операндов и выполнения основных команд; любой из них может использоваться как совокупность двух независящих друг от друга 8-разрядных регистров: старшего байта регистра (АН, ВН, СН, DH) и младшего байта (AL, BL, CL, DL); например, АХ состоит из АН и AL;
сегментные регистры (CS, DS, SS, ES); используются для указания сегмента при адресации памяти;
регистры-указатели (SP, BP, IP); используются для указания смещения при адресации памяти;
индексные регистры (SI, DI); применяются для индексной адресации;
регистр флагов; используется для хранения признаков состояния процессора.
Внутри одной и той же функциональной группы регистры используются различным образом. Ниже описывается специфика использования регистров.
Регистр АХ.
Является основным сумматором. Используется во всех арифметических операциях (сложить, умножить и т.п.). Только с помощью АХ и его полурегистров AHIAL возможен обмен данными с портами ввода/вывода.
Регистр ВХ.
Используется как сумматор в арифметических операциях, а также как базовый регистр при индексной адресации.
Регистр СХ.
В основном используется как счетчик при выполнении операций повторения и сдвига. Может также участвовать в арифметических операциях.
Регистр DX.
Используется как регистр данных в операциях ввода/вывода, а также как сумматор при обработке длинных целых чисел (32-разрядных).
Регистр CS.
Содержит номер сегмента памяти (сегмента кода), в котором располагается текущая машинная инструкция. Для получения полного адреса следующей команды его содержимое сдвигается влево на 4 разряда и складывается с регистром-указателем IP. Содержимое CS автоматически изменяется в командах дальнего (межсегментного) перехода и вызова процедур.
Регистр IP.
Определяет смещение относительно начала сегмента кода CS очередной исполняемой машинной инструкции. Содержимое IP автоматически изменяется в ходе исполнения инструкции, обеспечивая правильный порядок выборки команд из памяти.
Регистр DS.
Содержит номер сегмента памяти (сегмента данных), в котором располагаются данные (константы и переменные). Все глобальные переменные и типизированные константы программы Турбо Паскаля всегда располагаются в единственном сегменте, адресуемом этим регистром.
Регистр SS.
Содержит номер сегмента стека. Стек - это участок автоадресуемой памяти, предназначенный для временного хранения операндов. С помощью стека ТурбоПаскаль организует обмен данными между программой и процедурами, кроме того, в нем он размещает все локальные переменные (т.е. переменные, объявленные внутри процедуры). Память стека используется по правилу «последним пришел - первым ушел»: самый последний помещенный в стек операнд будет первым извлекаться из него.
Регистр SP.
Указывает на вершину стека, т.е. совместно с регистром 55 адресует ячейку памяти, куда будет помещаться операнд или откуда он будет извлекаться. Содержимое этого регистра автоматически уменьшается после размещения в стеке очередного операнда и увеличивается после извлечения операнда из стека.
Регистр ВР.
Так называемый указатель базы. Облегчает создание и использование локального стека (т.е. стека для использования внутри процедуры).
Регистр ES.
Дополнительный сегментный регистр ES используется для межсегментного обмена данными и в некоторых строковых операциях.
Регистр SI.
Определяет адрес источника информации при индексной адресации данных (например, при обработке массивов). Обычно используется в паре с регистром DS.
Регистр DI.
В паре с регистром £5 определяет приемник информации при межсегментном обмене данными.
Регистр флагов.
Отдельные разряды (биты) этого регистра имеют следующее назначение.
Флаг переноса CF.
Содержит 1, если произошел перенос единицы при сложении или заем единицы при вычитании. Используется также в циклических операциях и операциях сравнения.
Флаг четности PF.
Содержит 1, если в результате операции получено число с четным количеством значащих разрядов, т.е. дополняет результат до нечета - используется в операциях обмена для контроля данных.
Флаг внешнего переноса AF.
Контролирует перенос из 3- го бита данных. Полезен при операциях над упакованными десятичными числами.
Флаг нуля ZF.
Равен 1, если в результате операции получен ноль, и равен 0 в противном случае.
Флаг знака SF.
Равен 1, если в результате операции получено отрицательное число (с единицей в старшем разряде).
Флаг трассировки TF.
Равен 1, если программа исполняется по шагам, с передачей управления после каждой выполненной команды по прерыванию с вектором 1.
Флаг прерываний IF.
Содержит 1, если микропроцессору разрешена обработка прерываний.
Флаг направления DF.
Управляет направлением передачи данных: если он содержит 0, то после каждой индексной операции содержимое индексных регистров увеличивается на 1, в противном случае - уменьшается на 1.
Флаг переполнения OF.
Устанавливается в единицу, если в результате операции получено число, выходящее за разрядную сетку микропроцессора.
Синтаксис ассемблерных команд
Здесь и далее ассемблерными командами называются команды на языке встроенного ассемблера, вставляемые в тело ассемблерного оператора asm... end. Структура ассемблерной команды такова:
[Метка] [Префикс] [Код [Операнд [,Операнд]]]
В квадратных скобках указываются необязательные элементы структуры.
Метки
Любой команде ассемблерного оператора может предшествовать одна или несколько меток. В ассемблере используется два типа меток: глобальные и локальные. Глобальные метки - это обычные метки Турбо Паскаля. Они объявляются в разделе описаний после зарезервированного слова Label. С помощью глобальной метки можно передать управление в тело ассемблерного оператора оператором GOTO. Например:
Label
AltEnt;
begin
Goto AltEnd; {Передаем управление внутрь ассемблерного опера тора}
.......
asm
.......
AltEnd: {Сюда можно передать управление извне}
.......
end;
Локальные метки объявляются непосредственно в теле ассемблерного оператора. Эти метки обязаны начинаться символом «@». Поскольку этот символ нельзя использовать в именах Турбо Паскаля, он позволяет отличить локальную метку от глобальной. Локальная метка не известна нигде вне ассемблерного оператора, поэтому на нее нельзя передать управление оператором GOTO. По этой же причине в разных ассемблерных операторах можно использовать одноименные локальные метки.
Префиксы
Встроенный ассемблер поддерживает следующие префиксы команд:
LOCK Захват шины
REP/REPE/REPNE
Повтор строковой команды
REPZ/REPNZ Синоним REPE/REPNE
SEGCS Перекрытие CS
SEGDS Перекрытие DS
SEGSS Перекрытие SS
SEGES Перекрытие ES
Префиксы LOCK/REP/REPE/REPNE описаны в п. 12.1.3. Префиксы SEGxx определяют сегментный регистр, который должен использоваться вместо умалчиваемого, и распространяются только на следующие за ними ассемблерные команды.
Если префикс указан без кода инструкции, он распространяет свое действие на следующую ассемблерную команду.
Код инструкции очень редко имеет более одного префикса и никогда - более трех: допускается следующая последовательность
LOCK SEGxx REPxx
Замечу, что если при обработке строковой команды произошло аппаратное прерывание, МП 8086/8088 «забывает» префиксы LOCK и SEGxx, которые, возможно, определены в той же команде, так что использовать сложные префиксные конструкции не рекомендуется.
Коды инструкций
Встроенный ассемблер поддерживает мнемонику всех команд, перечисленных в п.12.1.3. Кроме того, в ассемблерных командах может использоваться мнемоника инструкций процессора 8087, а также команды процессоров 80286/80287. Замечу, что инструкции 8087 допустимы только при активном состоянии {SN+}, 80286 - при {$G+}, a 80287 - в случае {$G+,N+}.
Операнды
Операндами встроенного ассемблера могут быть выражения, состоящие из комбинации регистров, констант, имен и символов операций.
Регистры
Во встроенном ассемблере используется мнемоника регистров, указанная в п. 12.1.1, а также имя ST для ссылки на регистры арифметического сопроцессора.
Константы
Ассемблер поддерживает строковые и числовые константы.
Строковые константы заключаются в апострофы или кавычки. Если константа объявлена с помощью кавычек, внутри нее символ апостроф рассматривается наравне с другими символами, т.е. не считается ограничителем константы, точно так же внутри константы, обрамленной апострофами, не считается ограничителем символ кавычки. Если внутри константы необходимо указать ограничивающий ее символ, он удваивается. Примеры:
'Строковая константа'
"Это - тоже строковая константа"
'Символ '' не считается ограничителем'
'внутри строки, обрамленной кавычками "..."'
Числовые константы могут быть только целыми и их значение не может превосходить емкости двойного слова, т.е. должно быть внутри диапазона
- 2 147 483 648...+ 4 294 967 295.
По умолчанию при записи числовых констант используется десятичная нотация, но ассемблер поддерживает также двоичные, восьмеричные и шестнадцатеричные константы. Двоичная константа составляется как комбинация единиц и нулей, заканчивающаяся символом В (от Binary - двоичный); при записи восьмеричной константы используются символы 0...7, а в ее конце ставится символ О (Octal - восьмеричный); шестнадцатеричная константа записывается по правилам Турбо Паскаля (начинается с символа #) либо по правилам Турбо Ассемблера: начинается с цифры, в конце ставится символ H (от Hexadecimal - шестнадцатеричный).
Имена
Локальные метки - это единственные имена, которые разрешается определять внутри ассемблерного оператора. Имена остальных объектов программы - констант, переменных, подпрограмм - должны определяться только с помощью средств Турбо Паскаля.
Область определения имен подчиняется тем же правилам, что и в Турбо Паскале -имена должны быть «видны» в том месте, где они используются, и они локализуются в пределах блока, в котором описаны.
Во встроенном ассемблере могут использоваться три предопределенных имени:
@@Code - текущий сегмент кода
@Data - начальный сегмент данных
@Result - ссылка внутри функции на ее результат
Имена @Code и @Data могут использоваться только в сочетании с директивой SEG для ссылки на нужный сегмент. Например:
asm
mov ax, SEG ©Data
mov ds,ax
end;
Имя @Result используется для присвоения результата функции. Например:
Function Min(X,Y: Integer): Integer;
{Эта функция сравнивает два целых числа и возвращает наименьшее из них)
begin
asm
mov ax,X {Помещаем Х в АХ}
cmp ax,Y {X<Y ?}
jl @ {Да - на выход}
mov ax,Y {Нет - помещаем Y в АХ}
@: mov ©Result,ax {АХ содержит результат}
end
end;
Для доступа к полям записей разрешается использование составных имен. Например:
type
Point = record X,Y: Integer
end;
Rect = record
A,B: Point
end;
var
P: Point;
R: Rect;
begin
asm
mov ax,P.X
add ax,P.Y
mov R.A.X,ax
end
end.
Идентификаторы типов можно применять к операндам для уточнения данных, о которых идет речь. Каждая из следующих команд реализует одно и то же действие: загружает в регистр АХ слово по адресу ES: [DI+4 ]:
mov ax,(Rect PTR es:[di]).В.Х
mov ax,Rect(es:[di]).В.Х
mov ax,esrRect[di].B.X
mov ax,Rect[es:di].B.X
mov ax,es:[di].Rect.B.X
Следующие имена не могут использоваться в операндах встроенного ассемблера:
стандартные процедуры и функции (например, WriteLn, Chr);
предопределенные массивы Mem, MemW, MemL, Port, PortW;
константы с плавающей точкой, строковые и множественного типа;
макросы (процедуры и функции, полностью реализуемые одним InLine-оператором);
символ
@Result вне функции.
Выражения
Встроенный ассемблер использует выражения трех классов: регистровые, ссылки на память и непосредственные.
Регистровое выражение - это выражение, состоящее из имени регистра. Все следующие команды содержат только регистровые выражения:
push ds
pop es
mov ah,bl
add ex,ax
Непосредственные выражения - это нетипизированные константы и имена типов. Примеры непосредственных выражений:
const
dec =10;
.....
asm
mov ax, dec
mov bx,0
add cx,2*dec+l
sub dh,- 5
end;
Все остальные выражения относятся к ссылкам на память. Например:
const
dec: Word = 10;
Step =12;
var
Х,Y: Byte;
asm
mov ax, dec
mov ex, [Step]
add ah,X mov Y,bl
mov ax,[bx]
end;
Важным отличием ассемблерных выражений от выражений Турбо Паскаля является то обстоятельство, что они должны быть статическими, т.е. разрешены (вычислены) на этапе создания программы. Если выражение может быть полностью вычислено к моменту его трансляции, т.е. если оно состоит только из регистровых или непосредственных значений, такое выражение называется абсолютным, компилятор вычисляет его и использует для создания команды.
В ходе компиляции программы вырабатывается так называемый объектный код, который затем преобразуется компоновщиком в готовую к работе программу. При создании объектного кода компилятор не может вычислить значения выражений типа «ссылка на память», так как не знает окончательного положения в памяти меток, переменных, подпрограмм. В результате он создает так называемое перемещаемое выражение, которое затем компоновщиком преобразуется в нужную ссылку на память.
Встроенный ассемблер разрешает любую операцию над абсолютным значением (см. ниже), но ограничивает перемещаемые выражения до сложения или вычитания, одним из операндов которого должна быть константа.
Другое важное отличие ассемблерных выражений от выражений Турбо Паскаля заключается в способе интерпретации переменных. В выражениях Паскаля любая ссылка на переменную интерпретируется как текущее содержимое этой переменной. В ассемблерных выражениях это справедливо только тогда, когда все выражение в целом состоит из имени переменной. Во всех остальных случаях ссылка на переменную интерпретируется как адрес переменной. Например, выражение
х+10
в Паскале означает: «к содержимому переменной X прибавить 10». В ассемблерной команде это означает: .«к адресу (смещению) переменной X прибавить 10». Однако команда
mov ах,X
означает: «поместить в регистр АХ первые два байта переменной X». Если бы нам понадобилось загрузить в АХ адрес переменной X, мы должны были бы написать
mov ax,OFFSET X
Замечу, что попытка «перехитрить» ассемблер командами типа
mov ax,X+0 mov ax,X+1-1
и т.п. не дает желаемого результата: ассемблер просто загружает в АХ содержимое переменной X.
Как и в Паскале, ассемблерные выражения имеют тип, но в отличие от Паскаля этот тип определяет только размер объекта в памяти и не ограничивает применяемые к нему операции.
Встроенный ассемблер имеет следующие предопределенные типы:
Имена предопределенных типов можно использовать для приведения типов выражений. Например, если определены переменные
var
Flag: Boolean;
X : Word;
то такие ассемблерные выражения недопустимы:
mov Flag,bx
mov ah,X
Для корректного задания последней команды можно использовать следующие варианты:
mov ah,BYTE PTR X
mov ah,Byte(X)
mov ah,X.Byte
Во всех случаях в АН будет загружен первый (младший) байт переменной X. Встроенный ассемблер поддерживает операции, перечисленные в следующей таблице (в порядке убывания приоритета).
Операции встроенного ассемблера
Операция &
Осуществляет перекрытие идентификатора: следующий за знаком & идентификатор считается определенным в программе, даже если он совпадает с зарезервированным словом. Например:
var
Ch: Byte;
.......
mov ch,0 {Посылаем 0 в регистр СН}
mov &Ch,0 {Посылаем 0 в переменную Ch}
Операция 0
Круглые скобки используются обычным для Паскаля образом - для изменения порядка исчисления выражения (подвыражение, ограниченное скобками, вычисляется в первую очередь). Если перед скобками стоит имя типа, все выражение приобретает указанный тип. Например:
mov ах,((1+2)*3+4)*5 {АХ = 65}
mov bх,1+2*3+4*5 {ВХ = 27}
Операция[]
Определяет ссылку на память. Выражение внутри скобок вычисляется в первую очередь. Обычно оно связывается с регистрами BX, BP ,SI, DI и может использовать операции + и - для указания индексации. Например:
mov ah,100 mov ah,[100]
{АН = 100} {Загружаем в АН содержимое байта по адресу DS-.100}
Операция . (точка)
Селектор элемента структуры. Результат - сумма выражений до и после точки с типом второго выражения. Например:
var
R: record
X: Word; У: Byte
end;
.......
mov ax, R. X
mov R.Y,al
Операции HIGH и LOW
HIGH возвращает старший, a LOW - младший байт выражения типа слова, следующего за символами операции. Выражение должно иметь абсолютное непосредственное значение. Например:
mov al,High $1000 {AL = $10}
Операция : (двоеточие)
Указывает ассемблеру, что выражение после операции должно относиться к сегменту, указанному до операции. Результат - ссылка на память со значением второго выражения. Например:
mov ax, [10] {AX = слово по адресу DS:10}
mov ax,BS:[10] {АХ = слово по адресу BS:10}
Операция OFFSET
Возвращает смещение выражения, следующего за операцией. Результат имеет непосредственное значение. Например:
mov ах,Х {АХ = слово по адресу переменной X}
mov ax,offset X {АХ = смещение адреса X}
Операция SEG
Возвращает сегмент выражения, следующего за операцией. Результат имеет непосредственное значение.
Операция PTR
Осуществляет приведение типа. Результат - ссылка на память со значением выражения после операции и типом выражения до операции. Например:
Function Swap(X: Integer): Integer;
{Меняет местами байты в слове X}
begin
asm
mov ax,X
mov BYTE PTR @Result,ah
mov BYTE PTR @Result+l,al
end;
end;
Операции * и /
* - умножение, / - целочисленное деление. Оба выражения должны иметь непосредственные абсолютные значения, такое же значение имеет и результат операции. Например:
mov ax,2*2 {АХ = 4}
mov ах,17/3. {АХ = 5}
Операция MOD
Возвращает остаток от целочисленного деления. Оба выражения должны иметь непосредственные абсолютные значения, такое же значение имеет и результат операции. Например:
mov ах,17 mod 3 {АХ =2}
Операции SHL и SHR
Осуществляют логический сдвиг влево (SHL) или вправо (SHR) выражения, стоящего до операции, на количество разрядов, определяемое выражением после операции. Оба выражения должны иметь непосредственные абсолютные значения, такое же значение имеет и результат операции. Например:
mov ah,1 shl 7 {Ah = $80 = 128}
Бинарная операция +
Осуществляет сложение двух выражений. Выражения могут быть непосредственными значениями или ссылками на память, но только одно из них может быть перемещаемым. Если одно из выражений - ссылка на память, результат также определяет ссылку на память, а если одно из выражений - перемещаемое, результат будет перемещаемым.
Бинарная операция
Вычитание двух выражений. Первое выражение может быть любого класса, а второе должно быть абсолютным непосредственным значением. Результат относится к тому же классу, что и первое выражение.
Побитовые операции NOT, AND, OR, XOR
Имеют такой же смысл, что и одноименные операции Турбо Паскаля над целыми числами. Оба выражения должны иметь непосредственные абсолютные значения, такое же значение имеет и результат операции.
Система команд
В приводимых ниже таблицах указывается мнемоника всех допустимых инструкций для МП 8086/8088. Для удобства пользования все команды разбиты на 6 функциональных групп - пересылки данных, арифметические, битовые, строковые, передачи управления, прерываний. Внутри каждой группы команды объединяются в подгруппы по общим дополнительным признакам.
Детальный анализ всех команд МП 8086/8088 занял бы слишком много места, поэтому в идущих за таблицами пояснениях рассматриваются лишь наиболее популярные команды. Исчерпывающее описание всех команд Вы найдете в [1], [20].
Команды пересылки данных
Одна из наиболее часто используемых команд - МОV позволяет в защищенном режиме переслать байт или слово из регистра в регистр, из памяти в регистр или из регистра в память. Тип пересылаемых данных (байт или слово) определяется регистром, участвующим в пересылке. Ниже приводятся примеры использования команды:
mov ах,Table {Пересылка слова из памяти в АХ}
mov Table,ah {Пересылка байта из АН в память}
mov ds,ax {Пересылка в сегмент данных}
mov es:[bx],ax {Пересылка слова в память: базовая
адресация с заменой сегмента}
mov ch,-17 {Переслать константу в регистр}
mov Table,$FF {Переслать константу в память}
С помощью MOV нельзя пересылать:
из памяти в память, например, вместо
mov Mem1,Mem2
следует использовать
mov ax,Mem2
mov Mem1,ax
константу или переменную в DS, например, нельзя
mov DS,Data_Seg
нужно:
mov ax,Data_Seg
mov ds,ax
один сегментный регистр в другой, например, нельзя
mov es, ds
но можно
mov ax,ds
mov es,ax
в регистр CS; значение этого регистра (сегмента кода) автоматически меняется при выполнении дальних команд CALL и JMP; кроме того, он загружается из стека при выполнении команды RETF (выход из дальней процедуры).
Для временного сохранения регистров и данных, а также для обмена значениями между регистрами широко используются стековые команды PUSH и POP. Каждая из них работает со словом, т.е. в стек нельзя поместить или извлечь из него одиночный байт. При выполнении PUSH вначале уменьшается на 2 содержимое указателя SP, а затем операнд помещается по адресу SS: SP. При извлечении из стека сначала читается память по адресу SS: SP, а затем SP увеличивается на 2. Таким образом, при заполнении указатель вершины стека SP смещается к младшим адресам, а при освобождении -к старшим. При работе со стеком следует помнить о специфике использования стековой памяти («последним пришел - первым ушел»), а также о том, что эта память интенсивно используется при вызове процедур, т.е. состояние стека к моменту выхода из процедуры должно быть строго согласовано с дальнейшей работой программы. Первое условие определяет порядок извлечения данных из стека - он должен быть обратным порядку, в котором эти данные помещались в стек. Второе условие фактически означает, что после выхода из процедуры указатель SP должен содержать то же смещение, что и к моменту входа в нее. Иными словами, процедура не должна «забыть» в стеке лишнее слово или взять из него больше нужного.
Команда загрузки адреса LEA загружает в регистр адрес (смещение) нужного участка памяти. Этого же можно достичь с помощью зарезервированного слова OFFSET, стоящего перед именем переменной. Например:
var
X: Word;
..........
asm
mov ax, OFFSET X {Загружаем смещение X в АХ}
lea ax,X {To же действие}
end ;
Разница состоит в том, что в случае команды LEA разрешается использовать индексную адресацию, что особенно удобно при пересылке массивов данных.
Две другие команды адресной загрузки - LDS и LES загружают первое 16-разрядное слово из источника в регистр-приемник, а затем следующее слово - в регистр DS или ES, т.е. они рассчитаны на загрузку полного адреса операнда (сегмента и смещения).
Арифметические команды
При использовании арифметических команд следует помнить о том, что МП может обрабатывать знаковые числа, числа без знака, а также двоично-десятичные числа. В беззнаковых числах для представления значения используются все биты. т.е. они эквивалентны типам Byte и Word, в то время как знаковые числа в старшем разряде хранят знак числа и эквивалентны типам Shortlnt и Integer. Двоично-десятичные числа используют по 4 бита для каждого десятичного разряда и могут быть упакованными или неупакованными. В первом случае один байт хранит 2 десятичные цифры (старшая - в старшем полубайте), во втором - только одну (старший полубайт не используется). Основные арифметические команды МП (ADD, SUB, MUL, DIV) не учитывают двоично-десятичную форму представления чисел, поэтому в архитектуру МП включены команды коррекции результата.
Битовые команды
Битовые команды используются при исчислении логических выражений, а также в тех случаях, когда необходимо изменить отдельные разряды операнда. Логические команды AND, OR, XOR и NOT эквивалентны соответствующим операциям Турбо Паскаля в случае, когда операндами являются целочисленные выражения. Команда TEST выполняет целочисленную операцию поразрядного суммирования AND, но не изменяет значения операндов, а лишь устанавливает флаги в соответствии со значением результата сравнения: обнуляет CF и OF, изменяет PF, ZF, SF и не меняетAF (флаг ZF установится в 1 в том случае, когда оба операнда содержат по единице хотя бы в одном соответствующем разряде). Команды сдвига SHL/SHR эквивалентны одноименным операциям Турбо Паскаля и отличаются от команд циклического сдвига ROLIROR тем, что вытесненные в ходе их выполнения значащие разряды теряются, в то время как при циклическом сдвиге эти разряды появляются «с другой стороны». Например, если выполнить фрагмент
mov al,1 {Загружаем в AL единицу}
shr al,1 {Сдвигаем вправо ,на 1 разряд}
регистр AL будет содержать 0 ( вытесненная вправо единица будет помещена в CF), в то время как после замены команды SHR на ROR в нем будет значение $80=128 (вытесненная единица будет помещена в старший бит регистра).
Заметим, что счетчиком в командах сдвига может быть цифра 1 или количество сдвигов, указываемое в регистре CL.
Команды передачи управления
Команды безусловных переходов CALL, RET, JMP могут использовать дальнюю или ближнюю модель памяти, в то время как команды условных переходов - только малую (в пределах -128...+127 байтов). При дальней модели памяти (устанавливается опцией Options/Compiler/Force far calls среды Турбо Паскаля или директивой компилятора {F+}) осуществляется как внутрисегментная, так и межсегментная передача управления, при ближней - только внутрисегментная.
Инструкция CALL работает следующим образом. Вначале адрес следующей за CALL инструкции (адрес возврата) помещается в стек, затем в регистр IP (или в пару CS:IP) помещается адрес точки входа в процедуру, таким образом сразу за командой CALL будет исполняться уже первая команда процедуры. Оба адреса (точки входа и возврата) будут 16-битовыми смещениями для внутрисегментного вызова или 32-битовыми полными адресами - для межсегментного. Все процедуры (функции) Паскаля, оттранслированные в режиме {F+} или содержащие зарезервированное слово FAR в заголовке, должны вызываться как дальние. Для этого за инструкцией CALL следует указать модель памяти:
Procedure MyProc; Far;
.......
asm
call FAR MyProc {Вызов дальней процедуры}
.......
end;
Таким же способом должны вызываться все библиотечные подпрограммы (т.е. объявленные в интерфейсных частях модулей). При дальнем вызове в стек сначала заталкивается содержимое сегмента кода CS, а уже затем - смещение возврата.
При выходе из дальней процедуры команда RET извлекает из стека оба 16-разрядных слова и помещает первое в IP, а второе в CS, а при выходе из ближней извлекает из стека только смещение и помещает его в IP.
Команды условных переходов способны передавать управление на метку, расположенную в пределах ближайших плюс-минус 128 байт от самой команды. Если нужно передать управление на метку, расположенную дальше в том же сегменте, или на метку в другом сегменте, сразу за командой условной передачи располагают безусловную команду JMP или CAL, например:
стр ах,0 {Проверяем АХ}
jne@NotZero {AX=0 ?}
jmp IsZero {Да - переходим на дальнюю метку}
....... {Нет - продолжаем работу}
.......
В таблице термин «выше/ниже» используется применительно к сравнению беззнаковых операндов, а «больше/меньше» - знаковых.
Поскольку условные переходы реализуют ветвление программы на основе проверки флагов, обычно непосредственно перед ними располагаются команды, изменяющие эти флаги, чаще всего - команда сравнения СМР. Ниже показаны комбинации СМР - условный_переход для различных соотношений приемника и источника (первого и второго операнда) команды СМР:
Например:
сmр ах,5 {АХ>5 ?}
ja @AboveS {Да, больше - переходим}
стр bх,- 3 {ВХ<=-3 ?}
jle @LessM3 {Да, меньше или равен}
Команды LOOP/LOOPE/LOOPNE служат для организации циклов. Все они используют содержимое регистра СХ как счетчик числа повторений. Команда LOOP уменьшает СХ на единицу и передает управление на метку начала цикла, если содержимое этого регистра отлично от нуля. Команды LOOPE/LOOPNE также уменьшают счетчик СХ, но передают управление в начало цикла при совместном условии установки (или сброса) флага ZF и неравенства нулю счетчика СХ.
Вот как, например, можно отыскать нулевой байт в массиве АОВ:
var
АОВ: array [1..1000] of Byte;
.......
asm
mov ex, It)00 {Инициируем счетчик СХ}
lea bx,AOB {Помещаем адрес АОВ в ВХ}
dec bx {Готовим цикл}
{Здесь начало цикла проверки}
@@Test: inc bx {Адрес очередного байта}
cmp BYTE PTR [bx],0 {Проверяем байт}
loopne ©Test {Замыкаем цикл}
jnz ©NotZero {Если не найден нулевой байт}
....... {Нашли нулевой байт}
end;
Строковые команды
Строковые команды рассчитаны на обработку строк. Замечу, что термин «строка» здесь отнюдь не эквивалентен аналогичному термину Турбо Паскаля и означает произвольную цепочку байт или слов длиной до 64 Кбайт. Эти команды оперируют пятью примитивами, каждый из которых обрабатывает лишь один байт или одно слово за раз. Перед примитивом обычно указывается префикс повторения REP/REPE/REPNE, заставляющий выполняться примитив до тех пор, пока не обнулится счетчик повторений СХ или не будет нарушено соответствующее условие.
При использовании строковых команд важно помнить два обстоятельства. Во-первых, эти команды всегда берут адрес строки-источника из пары DS:SI, а строки-приемника - из пары ES:DI. Таким образом, перед исполнением строковой команды необходимо инициировать сегментные регистры нужным образом. Во-вторых, строковые команды используют индексную адресацию с автоматическим изменением смещения в SI/DI после однократного исполнения примитива. Содержимое этих регистров изменяется на 1 при обработке байтов и на 2 при обработке слов, причем наращивается, если флаг направления DF сброшен, и уменьшается, если он равен 1.
Вот как можно осуществить пересылку массива А в массив В:
var
А,В: array [1..250] of Integer;
.......
asm
lea si, A {Смещение А - в SI (источник)'}
push ds pop es {Инициируем ES := DS}
lea di,B {Смещение В - в DI (приемник)}
mov ex,250 {Счетчик- переноса}
сld {Направление переноса - наращивать}
rep movsw {Переносим 500 байт}
end;
В программе на Турбо Паскале регистр DS всегда содержит сегмент данных, поэтому инициировать его необязательно. Что касается регистра дополнительного сегмента ES, такого правила нет, и хотя в большинстве случаев он также ссылается на сегмент данных, рекомендуется проводить его инициацию перед использованием строковой команды (см. выше команды push ds, popes).
Команды прерываний
Выполнение прерываний во многом напоминает косвенный вызов дальней процедуры. По команде INT (INTO) в стек помещается регистр флагов, сегмент CS и указатель IP, а новые значения этих регистров берутся из 4-байтного вектора прерывания, соответствующего номеру прерывания в команде INT, или из вектора 4 -для команды INTO. Таким образом, единственным отличием от команды CALL является то, что в стек предварительно заносится регистр флагов. Следует, правда, оговориться: перед передачей управления программе обработки прерывания микропроцессор сбрасывает флаги трассировки TF и прерываний IF; сброс TF необходим для обеспечения нормальной работы отладчиков, использующих прерывание по вектору 1 или 4, сброс IF блокирует вмешательство других процессов в ход обработки прерывания.
Команда INTO представляет собой условное прерывание и выполняется, если в этот момент взведен флаг переполнения OF. Команда IRET реализует правильный выход из программы обработки прерывания: она считывает из стека 3 двухбайтные слова и помещает их в регистры IP, CS и регистр флагов.
Команды управления
Команды внешней синхронизации работают следующим образом.
HAL Т переводит МП в состояние останова, из которого его можно вывести только при перезагрузке системы или при наступлении немаскируемого прерывания.
WAIT заставляет МП выполнять холостой режим работы и каждые 5 тактов проверять уровень сигнала на входной шине: пока на этой шине нет сигнала активности, процессор выполняет WAIT, но как только шина активизируется, он продолжит исполнение программы. Эта инструкция обычно используется для ожидания сигнала обслуживания (прерывания) высокоприоритетного устройства типа контроллера прямого доступа к памяти.
Команда ESC используется для передачи указанного в ней операнда на шину данных. Тем самым обеспечивается возможность передачи команд другим процессорам. Эта команда чаще всего используется для управления работой арифметического сопроцессора. В этом случае код представляет собой код команды сопроцессора, а источник - используемый в этой команде операнд.
Команда LOCK фактически представляет собой однобайтовый префикс, который можно использовать совместно с любой другой командой микропроцессора. По этой команде МП активизирует одноименный сигнал на своей шине, что исключает возможность использования этой шины любым другим внешним устройством (процессором).
Спецификация встроенного ассемблера
Приведенное выше общее описание архитектуры МП 8086/8088 является базовым для любого ассемблера, в том числе и для встроенного ассемблера Турбо Паскаля. Однако ассемблеры содержат массу дополнительных возможностей, облегчающих разработку готовых к работе программ. Эти возможности отражаются в директивах и макрокомандах ассемблера. Встроенный ассемблер не предназначен для написания
законченных программ, поэтому в нем отсутствуют макрокоманды и директивы. Главной особенностью встроенного ассемблера является практически полное отсутствие в нем средств описания переменных и данных, т.к. эти объекты описываются средствами Турбо Паскаля.
Встроенный ассемблер
Общее описание МП 8086/8088
Регистры
Адресация
Система команд
Специфика встроенного ассемблера
Оператор ASM
Синтаксис ассемблерных команд
Директивы ассемблера
Ассемблерные подпрограммы
Ассемблером называется машинно-зависимый компилятор, преобразующий специальным образом составленные текстовые строки в машинные инструкции. Как и любой другой компилятор, ассемблер упрощает разработку программ за счет того, что предоставляет пользователю доступ к кодам машинных инструкций и операндам с помощью символьных имен.
В этой главе рассматриваются приемы программирования с помощью ассемблера, встроенного в компилятор Турбо Паскаля. Встроенный ассемблер имеется в версиях 6.0 и 7.0 Турбо Паскаля и в руках опытного программиста представляет собой мощный инструмент, позволяющий «выжать» из ПК все возможное.
Использование библиотеки CRT
Программирование клавиатуры
Текстовый вывод на экран
Программирование звукового генератора
Во многих случаях стандартные для Паскаля возможности ввода/вывода данных с помощью процедур Read, ReadLn, Write, WriteLn оказываются явно недостаточными для разработки удобных в использовании диалоговых программ. Например, процедуры Read/ReadLn вводят с клавиатуры только типизированные данные, причем с обязательным эхо-повтором набираемых символов на экране. С их помощью нельзя определить факт нажатия какой-либо специальной клавиши (функциональной клавиши, клавиши управления курсором и т.п.). Процедуры Write/WriteLn выводят сообщения, начиная с того места на экране, где в данный момент находится курсор, причем по мере вывода курсор автоматически сдвигается на экране, а если очередной символ выводится в самом нижнем правом углу экрана, осуществляется «прокрутка» экрана: его содержимое сдвигается вверх на одну строку. Все это сильно затрудняет создание и обновление различного рода окон, меню и других атрибутов современных диалоговых программ.
Разработчики Турбо Паскаля предусмотрели несколько подпрограмм, существенно увеличивающих возможности текстового ввода/вывода. Эти подпрограммы сосредоточены в библиотеке (модуле) CRT, входящей в комплект поставки Турбо Паскаля. В модуль включены также процедуры Sound, NoSound и Delay, которые позволяют программировать звуковой генератор ПК. В этой главе обсуждается использование подпрограмм модуля CRT.
Аббревиатура CRT соответствует русскоязычной аббревиатуре ЭЛТ - электронная лучевая трубка. На профессиональном жаргоне CRT означает устройство визуализации информации (дисплей) даже в том случае, когда вместо ЭЛТ используются иные физические устройства - плазменные панели, жидкокристаллические экраны и т.п.
Программирование клавиатуры
Дополнительные возможности управления клавиатурой реализуются двумя функциями: KeyPressed и ReadKey.
Функция KeyPressed.
Возвращает значение типа Boolean, указывающее состояние буфера клавиатуры: False означает, что буфер пуст, a True - что в буфере есть хотя бы один символ, еще не прочитанный программой.
В MS-DOS реализуется так называемый асинхронный буферизованный ввод с клавиатуры. По мере нажатия на клавиши соответствующие коды помещаются в особый буфер, откуда они могут быть затем прочитаны программой. Стандартная длина буфера рассчитана на хранение до 16 кодов символов. Если программа достаточно долго не обращается к клавиатуре, а пользователь нажимает клавиши, буфер может оказаться переполненным. В этот момент раздается звуковой сигнал и «лишние» коды теряются. Чтение из буфера обеспечивается процедурами Read/ReadLn и функцией ReadKey. Замечу, что обращение к функции KeyPressed не задерживает исполнения программы: функция немедленно анализирует буфер и возвращает то или иное значение, не дожидаясь нажатия клавиши.
Функция ReadKey.
Возвращает значение типа Char. При обращении к этой функции анализируется буфер клавиатуры: если в нем есть хотя бы один не прочитанный символ, код этого символа берется из буфера и возвращается в качестве значения функции, в противном случае функция будет ожидать нажатия на любую клавишу. Ввод символа с помощью этой функции не сопровождается эхо-повтором и содержимое экрана не меняется.
Пусть, например, в какой-то точке программы необходимо игнорировать все ранее нажатые клавиши, коды которых еще не прочитаны из буфера, т.е. необходимо очистить буфер. Этого можно достичь следующим способом:
Uses CRT;
var
С: Char;
begin
while KeyPressed do
С := ReadKey;
.......
end.
При использовании процедуры ReadKey необходимо учесть, что в клавиатурный буфер помещаются так называемые расширенные коды нажатых клавиш. Если нажимается любая алфавитно-цифровая клавиша, расширенный код совпадает с ASCII-кодом соответствующего символа. Например, если нажимается клавиша с латинской буквой «а» (в нижнем регистре), функция ReadKey возвращает значение chr (97), а если «А» (в верхнем регистре) - значение chr (65). При нажатии функциональных клавиш F1...F10, клавиш управления курсором, клавиш Ins, Home, Del, End, PgUp, PgDn в буфер помещается двухбайтная последовательность: сначала символ #0, а затем расширенный код клавиши. Таким образом, значение #0, возвращаемое функцией ReadKey, используется исключительно для того, чтобы указать программе на генерацию расширенного кода. Получив это значение, программа должна еще раз обратиться к функции, чтобы прочитать расширенный код клавиши.
Т.е. код сканирования клавиши. Этот код определяется порядком, в соответствии с которым микропроцессор клавиатуры Intel 8042 периодически опрашивает (сканирует) состояние клавиш.
Следующая простая программа позволит Вам определить расширенный код любой клавиши. Для завершения работы программы нажмите клавишу Esc.
Uses CRT;
var
С: Char;
begin
repeat
С := ReadKey;
if C<>#0 then
WriteLn(ord(C))
else
WriteLnCO1 ,ord(ReadKey) :8)
until C=#27 {27 - расширенный код клавиши Esc}
end.
Если Вы воспользуетесь этой программой, то обнаружите, что нажатие на некоторые клавиши игнорируется функцией ReadKey. Это прежде всего так называемые сдвиговые клавиши - Shift, Ctrl, Alt. Сдвиговые клавиши в MS-DOS обычно используются для переключения регистров клавиатуры и нажимаются в сочетании с другими клавишами. Именно таким способом, например, различается ввод прописных и строчных букв. Кроме того, функция игнорирует переключающие клавиши Caps Lock, Num. Lock, Scroll Lock, а также «лишние» функциональные клавиши F11 и F12 клавиатуры IBM AT, не имеющие аналога на клавиатуре ранних моделей IBMPC/XT (в этих машинах использовалась 84-клавишная клавиатура, в то время как на IBM AT - 101-клавишная).
В табл. 13.1 приводятся расширенные коды клавиш, возвращаемые функцией ord(ReadKey). Для режима ввода кириллицы приводятся коды, соответствующие альтернативному варианту кодировки.
Таблица 13.1
Расширенные коды клавиш
Программирование звукового генератора
Звуковые возможности ПК основаны на одноканальном управляемом звуковом генераторе, вырабатывающем электромагнитные колебания звуковой частоты. Колебания подаются на встроенный в ПК динамик и заставляют его звучать.
В модуль CRT включены три процедуры, с помощью которых Вы сможете запрограммировать произвольную последовательность звуков.
Процедура Sound.
Заставляет динамик звучать с нужной частотой. Заголовок процедуры:
Procedure Sound(F: Word);
Здесь F - выражение типа Word, определяющее частоту звука в герцах. После обращения к процедуре включается динамик и управление немедленно возвращается в основную программу, в то время как динамик будет звучать впредь до вызова процедуры NoSound.
Процедура No Sound.
Выключает динамик. Если он к этому моменту не был включен, вызов процедуры игнорируется.
Процедура Delay.
Обеспечивает задержку работы программы на заданный интервал времени. Заголовок процедуры:
Procedure Delay(T: Word);
Здесь Т - выражение типа Word, определяющее интервал времени (в миллисекундах), в течение которого задерживается выполнение следующего оператора программы.
Для генерации звукового сигнала обычно используется вызов описанных процедур по схеме Sound-Delay-NoSound. Следующая программа заставит ПК воспроизвести простую музыкальную гамму. Используемый в ней массив F содержит частоты всех полутонов в первой октаве от «до» до «си». При переходе от одной октавы к соседней частоты изменяются в два раза.
Uses CRT;
const
F: array [1..12] of Real =
(130.8, 138.6, 146.8, 155.6, 164.8, 174.6, 185.0, 196.0, 207.7, 220.0,
233.1, 246.9);{Массив частот 1-й октавы}
Temp = 100;{Темп исполнения}
var
k,n: Integer;
begin
{Восходящая гамма}
for k := 0 to 3 do for n := 1 to 12 do
begin
Sound(Round(F[n]*(1 shl k) )) ;
Delay(Temp);
NoSound
end ;
{Нисходящая гамма}
for k := 3 downto 0 do
for n := 12 downto 1 do
begin
Sound(Round(F[n]*(1 shl k)) ) ;
Delay(Temp);
NoSound
end
end.
Текстовый вывод на экран
Библиотека Turbo Vision способна удовлетворить самым высоким требованиям и я настоятельно рекомендую обращаться к ней при программировании сложных текстовых изображений (меню, окон и т.п.). Тем не менее вполне возможно, что некоторые из читателей захотят использовать значительно более простые, но достаточно эффективные средства модуля CRT, описываемые в этом разделе.
Используемое в ПК устройство визуального отображения информации - дисплей -состоит из двух основных частей: монитора, содержащего экран (электронно-лучевую трубку или жидкокристаллическую панель) с необходимыми компонентами (устройствами развертки изображения), и блока управления, который чаще называют дисплейным адаптером или просто адаптером. Обычно оба устройства согласуются друг с другом, но в отдельных случаях этого согласования может не быть (например, цветной монитор может работать с монохромным адаптером и наоборот). Будем считать оба устройства согласованными, поэтому, говоря о различных дисплеях, я буду говорить только о различных адаптерах, так как именно в них сосредоточены основные отличия дисплеев друг от друга.
Исторически первым адаптером (1981 г.), использованным на IBM PC, был так называемый монохромный адаптер (MDA). Его возможности очень скромны: он позволял выводить только текстовые сообщения в одном из двух форматов - 25 строк по 40 или по 80 символов в строке. Символы выводились в прямом изображении (светлые символы на темном фоне), причем их ширина оставалась одинаковой в обоих режимах, поэтому при выводе в режиме 40x25 использовалась только левая половина экрана. В MDA применялись два символьных шрифта - обычный и с подчеркиванием.
В 1982 году фирма Hercules выпустила адаптер HGC (от англ. Hercules Graphics Card - графическая карта Геркулес), который полностью эмулировал MDA в текстовом режиме, но в отличие от него мог еще воспроизводить и графические изображения с разрешением 720x350 точек (пикселей).
Примерно в это же время IBM выпустила цветной графический адаптер CGA (Color Graphics Adapter) и впервые на экране ПК появился цвет. CGA позволял выводить как текстовые сообщения, так и графические изображения (с разрешением 320x200 или 640x200 пикселей). В текстовом режиме выводились 40x25 или 80x25 символов как в монохромном, так и в цветном изображениях. При использовании монохромного режима символы, в отличие от MDA, не могли подчеркиваться, зато их можно было
выводить в негативном изображении (черные символы на светлом фоне). При выводе в цветном режиме использовалось 16 цветов для символов и 8 - для окружающего их фона.
Текстовые возможности CGA стали стандартом де-факто и поддерживаются во всех последующих разработках IBM - адаптерах EGA, MCGA, VGA и SVGA. Возможности модуля CRT рассматриваются применительно к адаптерам этого типа.
Процедура TextMode.
Используется для задания одного из возможных текстовых режимов работы адаптера. Заголовок процедуры:
Procedure TextMode(Mode: Word);
Здесь Mode - код текстового режима. В качестве значения этого выражения могут использоваться следующие константы, определенные в модуле CRT:
const
BW40=0{Черно-белый режим 40x25}
Со40=1{Цветной режим 40x25}
BW80=2{Черно-белый режим 80x25}
Со80=3{Цветной режим 80x25}
Mono=7{Используется с MDA}
Font8x8=256{Используется для загружаемого шрифта в режиме 80х43
или 80х50 с адаптерами EGA илиVGA}
Код режима, установленного с помощью вызова процедуры TextMode, запоминается в глобальной переменной LastMode модуля CRT и может использоваться для восстановления начального состояния экрана.
Следующая программа иллюстрирует использование этой процедуры в различных режимах. Замечу, что при вызове TextMode сбрасываются все ранее сделанные установки цвета и окон, экран очищается и курсор переводится в его левый верхний угол.
Uses CRT;
Procedure Print(S: String);
(Выводит сообщение S и ждет инициативы пользователя}
begin
WriteLn(S); {Выводим сообщение}
WriteLn('Нажмите клавишу Enter...');
ReadLn {Ждем нажатия клавиши Enter}
end; {Print}
var
LM: Word;{Начальный режим экрана}
begin
LM := LastMode; {Запоминаем начальный режим работы дисплея}
TextMode(Со40);
Print('Режим 40x25");
TextMode(CoSO) ;
Print('Режим 80x25');
TextMode(Co40+Font8x8);
Print('Режим Co40+Font8x8') ;
TextMode(Co80+Font8x8);
Print('Режим Co80+Font8x8');
{Восстанавливаем исходный режим работы:}
TextMode(LM)
end.
Процедура TextColpr.
Определяет цвет выводимых символов. Заголовок процедуры:
Procedure TextColor(Color: Byte);
Процедура TextBackground.
Определяет цвет фона. Заголовок:
Procedure TextBackground(Color: Byte);
Единственным параметром обращения к этим процедурам должно быть выражение типа Byte, задающее код нужного цвета. Этот код удобно определять с помощью следующих мнемонических констант, объявленных в модуле CRT:
const
Black = 0;{Черный}
Blue = 1;{Темно-синий}
Green = 2 ;{Темно-зеленый}
Cyan = 3;{Бирюзовый}
Red = 4 ;{Красный}
Magenta = 5;{Фиолетовый}
Brown = 6 ;{Коричневый}
LightGray = 7;{Светло-серый}
DarkGray = 8;{Темно-серый}
LightBlue = 9;{Синий}
LightGreen = 10;{Светло-зеленый}
LightCyan = 11;{Светло-бирюзовый}
LightRed = 12;{Розовый}
LightMagenta = 13;{Малиновый}
Yellow = 14;{Желтый}
White ' =15;{Белый}
Blink =128;{Мерцание символа}
Следующая программа иллюстрирует цветовые возможности Турбо Паскаля.
Uses CRT;
const
Col: array [1..15] of String [16] =
('темно-синий','темно-зеленый','бирюзовый','красный',
'фиолетовый','коричневый','светло-серый','темно-серый',
'синий','зеленый','светло-бирюзовый','розовый',
'малиновый','желтый','белый');
var
k: Byte;
begin
for k := 1 to 15 do
begin {Выводим 15 сообщений различными цветами}
TextColor(k);
WriteLn('Цвет ', k, ' - ',Col[k])
end;
TextColor(White+Blink); {Белые мигающие символы}
WriteLn('Мерцание символов');
{Восстанавливаем стандартный цвет}
TextColor(LightGray);
WriteLn
end.
Обратите внимание на последний оператор WriteLn: если его убрать, режим мерцания символов сохранится после завершения программы, несмотря на то, что перед ним стоит оператор
TextColor(LightGray)
Дело в том, что все цветовые определения предварительно заносятся в специальную переменную TextAttr модуля CRT и используются для настройки адаптера только при обращении к процедурам Write/WriteLn.
Процедура ClrScr.
Очищает экран или окно (см. ниже процедуру Window). После обращения к ней экран (окно) заполняется цветом фона и курсор устанавливается в его левый верхний угол. Например:
Uses CRT;
var
С: Char
begin
TextBackground(red) ;
ClrScr;{Заполняем экран красным цветом}
WriteLn('Нажмите любую клавишу...');
С := ReadKey; {Ждем нажатия любой клавиши}
TextBackground(Black) ;
ClrScr {Восстанавливаем черный фон экрана}
end.
Процедура Window.
Определяет текстовое окно - область экрана, которая в дальнейшем будет рассматриваться процедурами вывода как весь экран. Сразу после вызова процедуры курсор помещается в левый верхний угол окна, а само окно очищается (заполняется цветом фона). По мере вывода курсор, как обычно, смещается вправо и при достижении правой границы окна переходит на новую строку, а если он к этому моменту находился на последней строке, содержимое окна сдвигается вверх на одну строку, т.е. осуществляется «прокрутка» окна. Заголовок процедуры:
Procedure Window(XI,Y1,X2,Y2: Byte);
ЗдесьX1...Y2 - координаты левого верхнего (XI,Y1) и правого нижнего (X2,Y2) углов окна. Они задаются в координатах экрана, причем левый верхний угол экрана имеет координаты (1,1), горизонтальная координата увеличивается слева направо, а вертикальная - сверху вниз.
В следующем примере иллюстрируется вывод достаточно длинного сообщения в двух разных окнах.
Uses CRT;
var
k: integer;
begin
{Создаем левое окно -желтые символы на синем фоне:}
TextBackground(Blue);
Window(5,2,35,17);
TextColor(Yellow);
for k := 1 to 100 do
Write(' Нажмите клавишу Enter...');
ReadLn; {Ждем нажатия Enter}
ClrScr; {Очищаем окно}
{Создаем правое окно - белые символы на красном фоне:}
TextBackground(Red);
TextColor(White);
Window(40,2,70,17);
for k := 1 to 100 do
Write(' Нажмите клавишу Enter...');
ReadLn;
TextMode(C080) {Сбрасываем все установки}
end.
Обращение к процедуре Window игнорируется, если какая-либо из координат выходит за границы экрана или если нарушается одно из условий: Х2>Х1 и Y2>Y1. Каждое новое обращение к Window отменяет предыдущее определение окна. Границы текущего окна запоминаются в двух глобальных переменных модуля CRT: переменная WindMin типа Word хранит X1 и Y1 (XI - в младшем байте), а переменная того же типа WindMax - Х2 и Y2(X2 - в младшем байте). При желании Вы можете изменять их нужным образом без обращения к Window. Например, вместо оператора
Window(40,2,70,17);
можно было бы использовать два оператора
WindMin := 39+(1 shl 8);
WindMax := 69+(16 shl 8);
(в отличие от обращения к Window координаты, хранящиеся в переменных WindMin и WindMax, соответствуют началу отсчета 0,0).
Процедура GotoXY.
Переводит курсор в нужное место экрана или текущего окна. Заголовок процедуры:
Procedure GotoXY(X,Y: Byte);
Здесь X, Y - новые координаты курсора. Координаты задаются относительно границ экрана (окна), т.е оператор
GotoXY(1,1);
означает указание перевести курсор в левый верхний угол экрана (или окна, если к этому моменту на экране определено окно). Обращение к процедуре игнорируется, если новые координаты выходят за границы экрана (окна).
Функции whereX и WhereY.
С помощью этих функций типа Byte можно определить текущие координаты курсора: WhereX возвращает его горизонтальную, a WhereY - вертикальную координаты.
В следующей программе сначала в центре экрана создается окно, которое обводится рамкой, затем в окне выводится таблица из двух колонок.
Uses CRT;
const
LU =#218;{Левый верхний угол рамки}
RU =#191;{Правый верхний угол)}
LD =#192;{Левый нижний}
RD =#217;{Правый нижний}
H =#196;{Горизонтальная черта}
V =#179;{Вертикальная черта}
X1 =14;{Координаты окна}
Y1 =5;
X2 =66;
Y2 =20;
Txt = 'Нажмите клавишу Enter...';
var
k: integer;
begin
ClrScr; {Очищаем экран}
{Создаем окно в центре экрана - желтые символы на синем фоне:}
TextBackground(Blue);
TextColor(Yellow);
Window(X1,Y1,X2,У2);
ClrScr;
{Обводим окно рамкой}
Write(LU); {Левый верхний угол}
{Горизонтальная линия}
for k: = X1+1 to X2-1 do Write(H);
Write(RU);{Верхний правый угол}
for k := Y1+1 to Y2-1 do{Вертикальные линии}
begin
GotoXY(1,k-Y1+1);{Переходим к левой границе}
Write(V);{Левая черта}
GotoXY(X2-X1+1,WhereY){Правая граница}
Write(V){Правая черта}
end;
Write(LD);
{Левый нижний угол}
Window(X1,Y1,X2,Y2+1);{Расширяем вниз на одну строку координаты окна, иначе вывод в правый нижний угол вызовет прокрутку окна вверх}
GotoXY(2,Y2-Y1+1); { Возвращаем курсор из левого верхнего угла окна на нужное место}
{Горизонтальная рамка}
for k:= X1+1 to X2-1 do Write(H);
Write(RD); {Правый нижний угол}
{Определяем внутреннюю часть окна}
Window(X1+1,Y1+1,X2-1,Y2-1);
{Выводим левый столбец}
for k := Y1+1 to Y2-2 do
WriteLn('Левый столбец, строка ',k-Y1);;
{Ждем нажатия любой клавиши}
Write('Нажмите любую клавишу...');
k := ord(ReadKey); if k=0 then
k := ord(ReadKey);
DelLine; {Стираем приглашение}
{Выводим правый столбец}
for k := Y1+1 to Y2-2 do
begin
GotoXY((X2-X1) div 2,k-Y1);
Write('Правый столбец, строка ',k-Y1)
end ;
{Выводим сообщение и ждем нажатия клавиши Enter}
GotoXY((X2-X1-Length(Txt)) div 2,Y2-Y1-1);
TextColor(White);
Write(Txt);
ReadLn;
{Восстанавливаем стандартный режим}
TextMode(CO80)
end.
Три следующие процедуры без параметров могут оказаться полезными при разработке текстовых редакторов.
Процедура ClrEOL.
Стирает часть строки от текущего положения курсора до правой границы окна (экрана). Положение курсора не меняется.
Процедура DelLine.
Уничтожает всю строку с курсором в текущем окне (или на экране, если окно не создано). При этом все строки ниже удаляемой (если они есть) сдвигаются вверх на одну строку.
Процедура InsLine.
Вставляет строку: строка с курсором и все строки ниже ее сдвигаются вниз на одну строку; строка, вышедшая за нижнюю границу окна (экрана), безвозвратно теряется; текущее положение курсора не меняется.
Процедуры LowVideo, NormVideo и HighVideo.
С помощью этих процедур без параметров можно устанавливать соответственно пониженную, нормальную и повышенную яркость символов. Например:
Uses CRT;
begin
LowVideo;
WriteLn('Пониженная яркость');
NormVideo;
WriteLn('Нормальная яркость');
HighVideo;
WriteLn('Повышенная яркость')
end.
Замечу, что на практике нет разницы между пониженной и нормальной яркостью изображения.
Процедура AssignCRT.
Связывает текстовую файловую переменную F с экраном с помощью непосредственного обращения к видеопамяти (т.е. к памяти, используемой адаптером для создания изображения на экране). В результате вывод в такой текстовый файл осуществляется значительно (в 3...5 раз) быстрее, чем если бы этот файл был связан с экраном стандартной процедурой Assign. Заголовок процедуры:
Procedure AssignCRT(F: Text);
В следующей программе измеряется скорость вывода на экран с помощью стандартной файловой процедуры и с помощью непосредственного обращения к видеопамяти. Вначале файловая переменная F связывается «медленной» процедурой Assign со стандартным устройством CON (т.е. с экраном) и подсчитывается количество N1 циклов вывода некоторого текста за 5*55 = 275 миллисекунд системных часов. Затем файловая переменная связывается с экраном с помощью процедуры быстрого доступа AssignCRT и точно так же подсчитывается количество N2 циклов вывода. В конце программы счетчики N1 и N2 выводятся на экран.
Замечу, что показания системных часов хранятся в оперативной памяти компьютера в виде четырехбайтного слова по адресу [$0040:$006С] и наращиваются на единицу каждые 55 миллисекунд.
Uses CRT;
var
F: Text;
t: LongInt;{Начало отсчета времени}
N1,N2: Word;{Счетчики вывода}
const
txt = ' Text';
begin
{----- Стандартный вывод в файл -----}
Assign(F,'CON');
Rewrite(F);
N1 := 0;{Готовим счетчик вывода}
ClrScr;{Очищаем экран}
{Запоминаем начальный момент:}
t := MemL[$0040:$006C];
{Ждем начала нового 55-мс интервала, чтобы
исключить погрешность в определении времени:}
while MemL[$0040:$006C]=t do;
{Цикл вывода за 5 интервалов}
while MemL[$0040:$006С]<t+6 do
begin
inc(N1) ;
Write(F,txt)
end;
Close(F);
{----- Вывод с помощью быстрой процедуры прямого доступа к экрану - ----}
AssignCRT(F);
Rewrite(F);
N2 := 0;
ClrScr;
t := MemL[$0040:$006C];
while MemL[$0040:$006C]=t do;
while MemL[$0040:$006C]<t+6 do
begin
inc(N2);
Write(F,txt)
end ;
Close(F);
{Печатаем результат}
ClrScr;
WriteLn(Nl,N2:10)
end.
Следует учесть, что вывод на экран обычным образом - без использования файловой переменной (например, оператором Write (txt)) также осуществляется с помощью непосредственного доступа к видеопамяти, поэтому ценность процедуры AssignCRT весьма сомнительна. Прямой доступ к видеопамяти регулируется глобальной логической переменной DirectVideo модуля CRT: если эта переменная имеет значение True, доступ разрешен, если False - доступ к экрану осуществляется с помощью относительно медленных средств операционной системы MS-DOS. По умолчанию переменная DirectVideo имеет значение True.
Дуги, окружности, эллипсы
Процедура Circle.
Вычерчивает окружность. Заголовок:
Procedure Circle(X,Y: Integer; R: Word);
ЗдесьX, Y- координаты центра; R - радиус в пикселях.
Окружность выводится текущим цветом. Толщина линии устанавливается текущим стилем, вид линии всегда SolidLn (сплошная). Процедура вычерчивает правильную окружность с учетом изменения линейного размера радиуса в зависимости от его направления относительно сторон графического экрана, т.е. с учетом коэффициента GetAspectRatio. В связи с этим параметр R определяет количество пикселей в горизонтальном направлении.
В следующем примере в центре экрана создается окно, постепенно заполняющееся случайными окружностями. Для выхода из программы нажмите на любую клавишу.
Uses Graph, CRT;
var
d,r,e,x,y: Integer;
begin.
{Инициируем графику}
d i= Detect; InitGraph(d, r, '');
e := GraphResult; if e <> grOK then
WriteLn(GraphErrorMsg(e))
else
begin
{Создаем окно в центре экрана}
х := GetMaxX div 4;
у := GetMaxY div 4;
Rectangle(х,у,3*х,3*у);
SetViewPort(x+1,y+1,3*x-1,3*y-1,ClipOn);
{Цикл вывода случайных окружностей}
repeat
SetColor(succ(Random(white))); {Случайный цвет}
SetLineStyle(0,0,2*Random(2)+1); {и стиль линии}
х := Random(GetMaxX); {Случайное положение}
у := Random(GetMaxY); {центра окружности}
Circle(х,у,Random(GetMaxY div 4));
until KeyPressed;
if ReadKey=#0 then x := ord(ReadKey);
CloseGraph
end
end.
Процедура Arc.
Чертит дугу окружности. Заголовок:
Procedure Arc(X,Y: Integer; BegA,EndA,R: Word);
Здесь X, Y - координаты центра; BegA, EndA - соответственно начальный и конечный углы дуги; R - радиус.
Углы отсчитываются против часовой стрелки и указываются в градусах. Нулевой угол соответствует горизонтальному направлению вектора слева направо. Если задать значения начального угла 0 и конечного - 359, то будет выведена полная окружность. При вычерчивании дуги окружности используются те же соглашения относительно линий и радиуса, что и в процедуре Circle.
Вот как выглядят две дуги: одна с углами 0 и 90, вторая 270 и 540 градусов (рис. 14.6):
Рис.14.6. Иллюстрация процедуры Arc
Следующая программа создает это изображение:
Uses Graph, CRT;
var
d, r, е : Integer;
Xasp,Yasp: Word;
begin
{Инициируем графику}
d := Detect;
InitGraphtd, r, '');
e := GraphResult; if e <> grOK then
WriteLn(GraphErrorMsg(e))
else
begin
GetAspectRatio(Xasp,Yasp);
{R = 1/5 от вертикального размера экрана}
r := round(Yasp*GetMaxY/5/XAsp);
d := GetMaxX div 2; {Смещение второго графика}
e : = GetMaxY div 2; {Положение горизонтальной оси}
{Строим левый график}
Line (0,e,5*r div 2,e); {Горизонтальная ось}
Line (5*r div 4,e div 2,5*r div 4,3*e div 2) ;
Arc (5*r div 4,e,0,90,R); {Дуга}
OutTextXY(0,e+e div 8,'0 - 90'); {Надпись}
{Правый график}
Line (d,e,d+5*r div 2,e);
Line (d+5*r div 4,e div 2, d+5*r div 4,3*e div 2);
Arc (d+5*r div 4,e,270,540,R);
OutTextXY(d,e+e div 8,'270 - 540');
{Ждем нажатия на любую клавишу}
if ReadKey=#0 then d := ord(ReadKey);
CloseGraph
end
end.
Процедура GetArcCoords.
Возвращает координаты трех точек: центра, начала и конца дуги. Заголовок:
Procedure GetArcCoords(var Coords: ArcCoordsType);
Здесь Coords - переменная типа ArcCoordsType, в которой процедура возвращает координаты центра, начала и конца дуги.
Тип ArcCoordsType определен в модуле Graph следующим образом:
type
ArcCoordsType = record
X,Y : Integer; {Координаты центра}
Xstart,Ystart: Integer; {Начало дуги}
Xend,Yend : Integer; {Конец дуги}
end;
Совместное использование процедур Arc и GetArcCoords позволяет вычерчивать сопряжения двух прямых с помощью дуг. Обратите внимание на коррекцию длины радиуса в следующем примере, в котором вычерчивается прямоугольник со скругленными углами.
Uses Graph,CRT;
const
RadX = 50; {Горизонтальный радиус}
lx = 400; {Ширина}
ly = 100; {Высота}
var
d,r,e: Integer;
coo : ArcCoordsType;
x1,y1: Integer;
xa,ya: Word;
RadY : Integer; {Вертикальный радиус}
begin
{Инициируем графику}
d := Detect; InitGraph(d, r, ' ') ;
e := GraphResult; if e <> grOK then
WriteLn(GraphErrorMsg(e))
else
begin
GetAspectRatio(xa,ya) ; {Получаем отношение сторон}
{Вычисляем вертикальный радиус и положение фигуры с учетом отношения сторон экрана}
RadY := round (RadX *( xa /ya) );
x1 := (GetMaxX-lx) div 2;
y1 := (GetMaxY-2*RadY-ly) div 2;
{Вычерчиваем фигуру}
Line (x1,y1,x1+lx,y1); {Верхняя горизонтальная}
Arc (x1+lx,y1+RadY,0,90,RadX) ; {Скругление}
GetArcCoords(coo);
with coo do
begin
Line(Xstart,Ystart,Xstart,Ystart+ly);
{Правая вертикальная}
Arc(Xstart-RadX,Ystart+ly,270,0,RadX);
GetArcCoords (coo);
Line(Xstart,Ystart,Xstart-lx,Ystart);
{Нижняя горизонтальная}
Arc(Xstart-lx,Ystart-RadY,180,270,RadX);
GetArcCoords(coo);
Line(Xstart,Ystart,Xstart,Ystart-ly);
Arc(Xstart+RadX,Ystart-ly,90,180,RadX)
end ;
if ReadKey=#0 then d := ord(ReadKey);
CloseGraph
end
end.
Процедура Ellipse.
Вычерчивает эллипсную дугу. Заголовок:
Procedure Ellipse(X,Y: Integer; BegA,EndA,RX,RY: Word);
Здесь X, Y - координаты центра; BegA, EndA - соответственно начальный и конечный углы дуги; RX, RY- горизонтальный и вертикальный радиусы эллипса в пикселях.
При вычерчивании дуги эллипса используются те же соглашения относительно линий, что и в процедуре Circle, и те же соглашения относительно углов, что и в процедуре Arc. Если радиусы согласовать с учетом масштабного коэффициента GetAspectRatio, будет вычерчена правильная окружность.
В следующей программе вычерчиваются три эллипсных дуги (рис. 14.7) при разных отношениях радиусов. Замечу, что чем выше разрешение графического экрана, тем ближе к единице отношение сторон и тем меньше первый график отличается от третьего.
Рис.14.7. Эллипсные дуги
Uses Graph, CRT;
var
d,r,e: Integer;
xa,ya: Word;
begin
{Инициируем графику}
d := Detect; InitGraph(d, r, '');
e := GraphResult; if e <> grOK then
WriteLn(GraphErrorMsg(e))
else
begin
{Первый график}
OutTextXY(5 0,4 0,'RX = RY'); {Надпись}
Line (0,100,160,100); {Ось X}
Line (80,55,80,145); {Ось Y}
Ellipse (80,100,180,90,40,40);
{Второй график}
OutTextXY(260,40,'RX = 5*RY');
Line (190,100,410,100);
Line (300,55,300,145);
Ellipse (300,100,0,359,100,20);
{Третий график}
OutTextXY(465,40,'Aspect Ratio');
Line (440,100,600,100);
Line (520,55,520,145);
GetAspectRatio(xa, ya);
Ellipse (520,100,0,270,40,round(40*(xa/ya)));
if ReadKey=#0 then
d := ord(ReadKey);
CloseGraph
end
end.
Использование библиотеки Graph
Переход в графический режим и возврат в текстовый
Краткая характеристика графических режимов работы дисплейных адаптеров
Процедуры и функции
Координаты, окна, страницы
Линии и точки
Многоугольники
Дуги, окружности, эллипсы
Краски, палитры, заполнения
Сохранение и выдача изображений
Вывод текста
Включение драйвера и шрифтов в тело программы
Начиная с версии 4.0, в состав Турбо Паскаля включена мощная библиотека графических подпрограмм Graph, остающаяся практически неизменной во всех последующих версиях. Библиотека содержит в общей сложности более 50 процедур и функций, предоставляющих программисту самые разнообразные возможности управления графическим экраном. Для облегчения знакомства с библиотекой все входящие в нее процедуры и функции сгруппированы по функциональному принципу.
Координаты, окна, страницы
Многие графические процедуры и функции используют указатель текущей позиции на экране, который в отличие от текстового курсора невидим. Положение этого указателя, как и вообще любая координата на графическом экране, задается относительно левого верхнего угла, который, в свою очередь, имеет координаты 0,0. Таким образом, горизонтальная координата экрана увеличивается слева направо, а вертикальная - сверху вниз.
Функции GetMaxX и GetMaxY.
Возвращают значения типа Word, содержащие максимальные координаты экрана в текущем режиме работы соответственно по горизонтали и вертикали. Например:
Uses Graph;
var
a,b: Integer;
begin
a := Detect; InitGraph(a, b, '');
WriteLn(GetMaxX, GetMaxY:5);
ReadLn;
CloseGraph
end.
Функции GetX и GetY.
Возвращают значения типа Integer, содержащие текущие координаты указателя соответственно по горизонтали и вертикали. Координаты определяются относительно левого верхнего угла окна или, если окно не установлено, экрана.
Процедура SetViewPort.
Устанавливает прямоугольное окно на графическом экране. Заголовок:
Procedure SetViewPort(XI,Y1,X2,Y2: Integer; ClipOn: Boolean);
Здесь X1...Y2 - координаты левого верхнего (XI,Y1) и правого нижнего (X2,Y2) углов окна; СНрОп - выражение типа Boolean, определяющее «отсечку» не умещающихся в окне элементов изображения.
Координаты окна всегда задаются относительно левого верхнего угла экрана. Если параметр ClipOn имеет значение True, элементы изображения, не умещающиеся в пределах окна, отсекаются, в противном случае границы окна игнорируются. Для управления этим параметром можно использовать такие определенные в модуле константы:
const
ClipOn = True; {Включить отсечку}
ClipOff = False; {He включать отсечку}
Следующий пример иллюстрирует действие параметра СНрОп. Программа строит два прямоугольных окна с разными значениями параметра и выводит в них несколько окружностей. Для большей наглядности окна обводятся рамками (см. рис. 14.1).
Рис. 14.1. Отсечка изображения в окне
Uses Graph,CRT;
var
x,y,e: Integer;
xll,yll,xl2,yl2, {Координаты 1-го окна}
x21,x22, {Левый верхний угол 2-го}
R, {Начальный радиус}
k: Integer;
begin
DirectVideo := False {Блокируем прямой доступ к видеопамяти в модуле CRT}
{Инициируем графический режим}
х := Detect; InitGraph(x, у, '');
{Проверяем результат}
е := GraphResult; if e <> grOk then
WriteLn(GraphErrorMsg (e) ) {Ошибка}
else
begin {Нет ошибки}
{Вычисляем координаты с учетом разрешения экрана}
x11:=GetMaxX div 60;
x12:=GetMaxX div 3;
y11:=GetMaxY div 4; y12:=2*y11;
R:=(x12-x11) div 4; x21:=x12*2;
x22:=x21+x12-x11;
{Рисуем окна}
WriteLnt'ClipOn:':10,'ClipOff:':40);
Rectangle(x11, y11, x12, y12); Rectangle(x21, y11 x22, y12);
{Назначаем 1-е окно и рисуем четыре окружности}
SetViewPort(x11, y11, x12, y12, ClipOn);
for k := 1 to 4 do
Circle(0,y11,R*k);
{Назначаем 2-е окно и рисуем окружности}
SetViewPort(x21, y11, x22, y12, ClipOff);
for k := 1 to 4 do
Circle(0,y11,R*k);
{Ждем нажатия любой клавиши}
if ReadKey=#0 then k := ord(ReadKey);
CloseGraph
end
end.
Процедура GetViewSettings.
Возвращает координаты и признак отсечки текущего графического окна. Заголовок:
Procedure GetViewSettings(var Viewlnfo: ViewPortType);
Здесь Viewlnfo - переменная типа ViewPortType. Этот тип в модуле Graph определен следующим образом:
type
ViewPortType = record
x1,y1,x2,y2: Integer; {Координаты окна}
Clip : Boolean {Признак отсечки}
end ;
Процедура MoveTo.
Устанавливает новое текущее положение указателя. Заголовок:
Procedure MoveTo(X,Y: integer);
Здесь X, Y - новые координаты указателя соответственно по горизонтали и вертикали.
Координаты определяются относительно левого верхнего угла окна или, если окно не установлено, экрана.
Процедура MoveRel.
Устанавливает новое положение указателя в относительных координатах.
Procedure MoveRel(DX,DY: Integer);
Здесь DX.DY- приращения новых координат указателя соответственно по горизонтали и вертикали.
Приращения задаются относительно того положения, которое занимал указатель к моменту обращения к процедуре.
Процедура ClearDevice.
Очищает графический экран. После обращения к процедуре указатель устанавливается в левый верхний угол экрана, а сам экран заполняется цветом фона, заданным процедурой SetBkColor. Заголовок:
Procedure ClearDevice;
Процедура ClearViewPort.
Очищает графическое окно, а если окно не определено к этому моменту - весь экран. При очистке окно заполняется цветом с номером О из текущей палитры. Указатель перемещается в левый верхний угол окна. Заголовок:
Procedure ClearViewPort;
В следующей программе на экране создается окно, которое затем заполняется случайными окружностями (рис. 14.2). После нажатия на любую клавишу окно очищается. Для выхода из программы нажмите Enter.
Рис. 14.2. Окно со случайными окружностями
Uses CRT,Graph;
var
x1,y1,x2,y2,Err: Integer;
begin
{Инициируем графический режим}
xl := Detect; InitGraph(xl,x2,'');
Err := GraphResult; if ErrogrOk then
WriteLn(GraphErrorMsg(Err))
else
begin
{Определяем координаты окна с учетом разрешения экрана}
x1 := GetMaxX div 4,-y1 := GetMaxY div 4;
x2 := 3*x1; y2 := 3*y1;
{Создаем окно}
Rectangle(x1,y1,x2,y2);
SetViewPort(x1+1,y1+1,x2-1,y2-1,ClipOn);
{Заполняем окно случайными окружностями}
repeat
Сirclе(Random(Ge tMaxX),Random(Ge tMaxX)
Random(GetMaxX div 5))
until KeyPressed;
{Очищаем окно и ждем нажатия Enter}
ClearViewPort;
OutTextXY(0,0,'Press Enter...1);
ReadLn;
CloseGraph
end
end.
Процедура GetAspectRatio.
Возвращает два числа, позволяющие оценить соотношение сторон экрана. Заголовок:
Procedure GetAspectRatio(var X,Y: Word);
Здесь X, Y - переменные типа Word. Значения, возвращаемые в этих переменных, позволяют вычислить отношение сторон графического экрана в пикселях. Найденный с их помощью коэффициент может использоваться при построении правильных геометрических фигур, таких как окружности, квадраты и т.п. Например, если Вы хотите построить квадрат со стороной L пикселей по вертикали, Вы должны использовать операторы
GetAspectRatio (Xasp, Yasp);
Rectangle(x1, y1, x1+L*round (Yasp/Xasp), y1+L);
а если L определяет длину квадрата по горизонтали, то используется оператор
Rectangle (x1,y1,x1+L,y1+L*round(Xasp/Yasp));
Процедура SetAspectRatio.
Устанавливает масштабный коэффициент отношения сторон графического экрана. Заголовок:
Procedure SetAspectRatio(X,Y: Word);
Здесь X, Y- устанавливаемые соотношения сторон.
Следующая программа строит 20 окружностей с разными соотношениями сторон экрана (рис. 14.3).
Рис.14.3. Окружности при разных отношениях сторон экрана
Uses Graph,CRT;
const
R =.50;
dx = 1000;
var
d,m,e,k : Integer;
Xasp,Yasp: Word;
begin
d := Detect;
InitGraph(d, m,.'');
e : = GraphResult;
if e <> grOk then
WriteLn(GraphErrorMsg(e))
else
begin
GetAspectRatio(Xasp, Yasp);
for k := 0 to 20 do
begin
SetAspectRatio(Xasp+k*dx,Yasp);
Circle(GetMaxX div 2,GetMaxY div 2,R)
end;
if ReadKey=#0 then k := ord(ReadKey);
CloseGraph
end
end.
Процедура SetActivePage.
Делает активной указанную страницу видеопамяти. Заголовок:
Procedure SetActivePage(PageNum: Word);
Здесь PageNum - номер страницы.
Процедура может использоваться только с адаптерами, поддерживающими многостраничную работу (EGA, VGA и т.п.). Фактически процедура просто переадресует графический вывод в другую область видеопамяти, однако вывод текстов с помощью Write/WriteLn всегда осуществляется только на страницу, которая является видимой в данный момент (активная страница может быть невидимой). Нумерация страниц начинается с нуля.
Процедура SetVisualPage.
Делает видимой страницу с указанным номером. Обращение:
Procedure SetVisualPAge(PageNum: Word);
Здесь PageNum - номер страницы.
Процедура может использоваться только с адаптерами, поддерживающими многостраничную работу (EGA, VGA и т.п.). Нумерация страниц начинается с нуля.
Следующая программа сначала рисует квадрат в видимой странице и окружность -в невидимой. После нажатия на Enter происходит смена видимых страниц.
Uses Graph;
var
d,m,e: Integer;
s : String;
begin
d := Detect; InitGraph(d, m, '');
e := GraphResult; if e <> grOk then
WriteLn (GraphErrorMsg(e))
else { Нет ошибки. Проверяем, поддерживает ли драйвер многостраничную работу с видеопамятью:}
if d in [HercMono,EGA,EGA64,MCGA,VGA] then
begin {Используем многостраничный режим}
if d<>HercMono then
SetGraphMode(m-1);
{Заполняем видимую страницу}
Rectangle(10,10,GetMaxX div 2,GetMaxY div 2);
OutTextXY(0,0,'Page 0. Press Enter...');
{Заполняем невидимую}
SetActivePage (1);
Circle(GetMaxX div 2, GetMaxY div 2, 100);
OutTextXY(0,GetMaxY-10,'Page 1. Press Enter...');
{Демонстрируем страницы}
ReadLn;
SetVisualPage(1);
ReadLn;
SetVisualPage (0);
ReadLn;
CloseGraph
end
else
begin {Драйвер не поддерживает многостраничный режим}
s := GetDriverName; CloseGraph;
WriteLn('Адаптер ',s,' использует только 1 страницу')
end
end.
Обратите внимание на оператор
if doHercMono then
SetGraphMode(m-1);
С его помощью гарантированно устанавливается многостраничный режим работы на адаптерах EGA, MCGA, VGA. Как уже говорилось, после инициации графики с Driver=Detect устанавливается режим работы с максимально возможным номером; перечисленные адаптеры в этом режиме могут работать только с одной графической страницей, чтобы обеспечить работу с двумя страницами, следует уменьшить номер режима.
Краски, палитры, заполнения
Процедура SetColor.
Устанавливает текущий цвет для выводимых линий и символов. Заголовок:
Procedure SetColor(Color: Word);
Здесь Color - текущий цвет.
В модуле Graph определены точно такие же константы для задания цвета, как и в модуле СИГ (см. п.13.2).
Функция GetColor. Возвращает значение типа Word, содержащее код текущего цвета. Заголовок:
Function GetColor: Word;
Функция GetMaxColor.
Возвращает значение типа Word, содержащее максимальный доступный код цвета, который можно использовать для обращения к SetColor. Заголовок:
Function GetMaxColor: Word;
Процедура SetBkColor.
Устанавливает цвет фона. Заголовок:
Procedure SetBkColor(Color: Word);
Здесь Color - цвет фона.
В отличие от текстового режима, в котором цвет фона может быть только темного оттенка, в графическом режиме он может быть любым. Установка нового цвета фона немедленно изменяет цвет графического экрана. Это означает, что нельзя создать изображение, два участка которого имели бы разный цвет фона. Для CGA -адаптера в режиме высокого разрешения установка цвета фона изменяет цвет активных пикселей. Замечу, что после замены цвета фона на любой, отличный от 0 (Black) цвет, Вы не сможете более использовать цвет 0 как черный, он будет заменяться на цвет фона, т.к. процедуры модуля Graph интерпретируют цвет с номером 0 как цвет фона. Это означает, в частности, что Вы уже не сможете вернуть фону черный цвет!
Если Ваш ПК оснащен цветным экраном, следующая программа продемонстрирует работу процедуры SetBkColor. Программа выводит десять вложенных друг в друга прямоугольников, после чего циклически меняет цвет фона. Для выхода из программы достаточно нажать на любую клавишу.
Uses Graph, CRT;
const
NC: array [0..15] of String [12] =
('Black','Blue','Green','Cyan','Red','Magenta',
' Brown','LightGray','DarkGray','LightBlue',
'LightGreen1,'LightCyan1,'LightRed',
'LightMagenta','Yellow','White');
var
d, r, e, k, color, dx, dy: Integer;
begin
{Инициируем графику}
d := Detect; InitGraph(d, r, ' ') ;
e := GraphResult; if e <> grOK then
WriteLn(GraphErrorMsg(e))
else
begin
{Выводим текст в центре экрана}
OutTextXY(200,GetMaxY div 2,'BACKGROUND COLOR');
dx := GetMaxX div 30; {Приращение длины}
dy := GetMaxY div 25; {Приращение высоты}
for k := 0 to 9 do{Выводим 10 прямоугольников}
Rectangle(k*dx,k*dy,GetMaxX-k*dx,GetMaxY-k*dy);
color := black; {Начальный цвет фона}
repeat {Цикл смены фона}
SetBkColor(color) ;
SetFillStyle(0,Color);
Bar(345,GetMaxY div 2,440,GetMaxY div 2+8);
OutTextXY(345,GetMaxY div 2,NC[color]);
delay(1000);
inc(color);
if color > White then
color := Black until KeyPressed;
if ReadKey=#0 then
k := ord(ReadKey);
CloseGraph
end
end.
Функция GetBkColor.
Возвращает значение типа Word, содержащее текущий цвет фона. Заголовок:
Function GetBkColor: Word;
Процедура SetPalette.
Заменяет один из цветов палитры на новый цвет. Заголовок:
Procedure SetPalette(N: Word; Color: Shortlnt);
Здесь N - номер цвета в палитре; Color - номер вновь устанавливаемого цвета.
Данная процедура может работать только с адаптерами EGA или VGA. Она не должна использоваться с IBM8514 или 256-цветным вариантом VGA - для этих адаптеров предназначена особая процедура SetRGBPalette (см. ниже). Первоначальное размещение цветов в палитрах EGA/VGA соответствует последовательности их описания константами Black,....White, т.е. цвет с индексом 0 - черный, 1 - синий, 2 - зеленый и т.д. После обращения к процедуре все фрагменты изображения, выполненные цветом с индексом N из палитры цветов, получат цвет Color. Например, если выполнить оператор
SetPalette(2,White);
то цвет с индексом 2 (первоначально это - бирюзовый цвет Cyan) будет заменен на белый. Замечу, что цвет с индексом 0 отождествляется с цветом фона и может изменяться наряду с любым другим цветом.
Следующая программа выводит на экран ряд прямых разного цвета и затем случайным образом меняет цвета палитры.
Uses Graph, CRT;
var
d,r,e,N,k,color: Integer;
Palette : PaletteTyper;
begin
{Инициируем графику}
d := Detect; InitGraph(d, r, ' ') ;
e := GraphResult; if e <> grOK then
WriteLn(GraphErrorMsg(e))
else
begin
{Выбираем толстые сплошные линии}
SetLineStyle(SolidLn, 0, ThickWidth);
GetPalette(Palette) ; {Текущая палитра}
for Color := 0 to Palette.Size-1 do
begin
SetColor(Color);
Line(GetMaxX div 3,Color*10,2*GetMaxX div 3,Color*10)
end;
{Меняем палитру и ждем инициативы пользователя}
while not KeyPressed do
for e := 0 to Palette.Size-1 do
SetPalette(e,Random(Palette.Size));
if ReadKey=#0 then d := ord(ReadKey);
CloseGraph
end
end.
Процедура GetPalette.
Возвращает размер и цвета текущей палитры. Заголовок:
Procedure GetPalette(var Palettelnfo: PaletteType);
Здесь Palettelnfo - переменная типа PaletteType, возвращающая размер и цвета палитры.
В модуле Graph определена константа
const
MaxColors =15;
и тип
type
PaletteType = record
Size : Word; {Количество цветов в палитре}
Colors : array [0..MaxColors] of Shortlnt
{Номера входящих в палитру цветов}
end;
С помощью следующей программы можно вывести на экран номера всех возможных цветов из текущей палитры.
Uses Graph;
var
Palette: PaletteType;
d,r,e,k: Integer;
begin
{Инициируем графику}
d := Detect; InitGraph(d, r, ' ') ;
e := GraphResult; if e <> grOk then
WriteLn(GraphErrorMsg(e))
else
begin
GetPalette(Palette); {Получаем палитру}
CloseGraph; {Возвращаемся в текстовый режим}
with Palette do {Выводим номера цветов}
for k := 0 to pred(Size) do
Write(Colors[k]:5);
end
end.
Процедура SetAllPalette.
Изменяет одновременно несколько цветов палитры. Заголовок процедуры:
Procedure SetAllPalette(var Palette);
Параметр Palette в заголовке процедуры описан как нетипизированный параметр. Первый байт этого параметра должен содержать длину N палитры, остальные N байты - номера вновь устанавливаемых цветов в диапазоне от -1 до MaxColors. Код -1 означает, что соответствующий цвет исходной палитры не меняется.
В следующей программе происходит одновременная смена сразу всех цветов палитры.
Uses Graph, CRT;
var
Palette: array [0..MaxColors] of Shortint;
d,r,e,k: Integer;
begin
{Инициируем графику}
d := Detect; InitGraph(d, r, '');
e := GraphResult; if e <> grOk then
WriteLn(GraphErrorMsg(e))
else
begin
{Выбираем толстые сплошные линии}
SetLineStyle(SolidLn, 0, ThickWidth);
{Выводим линии всеми доступными цветами}
for k := 1 to GetMaxColor do
begin
SetColor(k);
Line(GetMaxX div 3,k*10,2*GetMaxX div 3,k*10)
end;
Palette[0] := MaxColors; {Размер палитры}
repeat {Цикл смены палитры}
for k := 1 to MaxColors do
Palette[k] := Random(succ(MaxCoLors));
SetAllPalette(Palette)
until KeyPressed;
if ReadKey=#0 then k := ord(ReadKey);
CloseGraph
end
end.
Функция GetPaletteSize.
Возвращает значение типа Integer, содержащее размер палитры (максимальное количество доступных цветов). Заголовок:
Function GetPaletteSize: Integer;
Процедура GetDefaultPalette.
Возвращает структуру палитры, устанавливаемую по умолчанию (в режиме автонастройки). Заголовок:
Procedure GetDefaultPalette(var Palette: PaletteType);
Здесь Palette - переменная типа PaletteType (см. процедуру GetPalette), в которой возвращаются размер и цвета палитры.
Процедура SetFillStyle.
Устанавливает стиль (тип и цвет) заполнения. Заголовок:
Procedure SetFillStyle(Fill,Color: Word);
Здесь Fill - тип заполнения; Color - цвет заполнения.
С помощью заполнения можно покрывать какие-либо фрагменты изображения периодически повторяющимся узором. Для указания типа заполнения используются следующие предварительно определенные константы:
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;{Узор определяется пользователем}
Программа из следующего примера продемонстрирует Вам все стандартные типы заполнения.
Uses Graph, CRT;
var
d,r,e,k,j,x,y: Integer;
begin
{Инициируем графику}
d := Detect; InitGraph(d, r, ' ') ;
e := GraphResult; if e <> grOk then
WriteLn(GraphErrorMsg(e))
else
begin
x := GetMaxX div 6;{Положение графика}
у := GetMaxY div 5;{на экране}
for j := 0 to 2 do{Два ряда}
for k := 0 to 3 do{По четыре квадрата}
begin
Rectangle((k+1)*x,(j+1)*y,(k+2)*x,(j+2)*y);
SetFillStyle(k+j*4,j+1);
Bar((k+1)*x+1,(j+1)*y+1,(k+2)*x-1,(j+2)*y-1)
end;
if ReadKey=#0 then k := ord(ReadKey);
CloseGraph
end
end.
Если параметр Fill имеет значение 12 (UserFill), то рисунок узора определяется программистом путем обращения к процедуре SetFillPattern.
Процедура SetFillPattern.
Устанавливает образец рисунка и цвет штриховки. Заголовок:
Procedure SetFillPattern(Pattern: FillPatternType;Color: Word);
Здесь Pattern - выражение типа FillPatternType; устанавливает образец рисунка для Fill - UserFill в процедуре SetFillStyle; Color - цвет заполнения.
Образец рисунка задается в виде матрицы из 8x8 пикселей и может быть представлен массивом из 8 байт следующего типа:
type
FillPatternType = array [1..8] of Byte;
Каждый разряд любого из этих байтов управляет светимостью пикселя, причем первый байт определяет 8 пикселей первой строки на экране, второй байт - 8 пикселей второй строки и т.д.
На рис. 14.8 показан пример двух образцов заполнения. На рисунке черточкой обозначается несветящийся пиксель, а прямоугольником - светящийся. Для каждых 8 пикселей приводится шестнадцатеричный код соответствующего байта.
Следующая программа заполняет этими образцами две прямоугольных области экрана.
Рис.14.8. Образцы заполнения и их коды
Uses Graph, CRT;
const
pattl: FillPatternType= ($49,$92,$49,$92,$49,$92,$49,$92);
patt2: FillPatternType= ($00,$18,$24,$42,$42,$24,$18,$00);
var
d,r,e: Integer;
begin {Инициируем графику}
d := Detect; InitGraph(d, r, '');
e := GraphResult; if e <> grOk then
WriteLn(GraphErrorMsg(e))
else
begin
if d=CGA then
SetGraphMode (0) ; {Устанавливаем цвет для CGA}
SetFillStyle(UserFill,White);
{Левый верхний квадрат}
SetFillPattern(Patt1,1);
Bar(0,0,GetMaxX div 2, GetMaxY div 2);
{Правый нижний квадрат}
SetFillPattern(Patt2,2);
Bar(GetMaxX div 2,GetMaxY div 2,GetMaxX,GetMaxY);
if ReadKey=#0 then d := ord(ReadKey);
CloseGraph
end
end.
Если при обращении к процедуре указан недопустимый код цвета, вызов процедуры игнорируется и сохраняется ранее установленный образец заполнения. В частности, если в предыдущем примере убрать оператор
if d=CGA then
SetGraphMode(0);
устанавливающий цветной режим работы CGA -адаптера, на экран ПК, оснащенного адаптером этого типа, будут выведены два одинаковых прямоугольника, так как обращение
SetFillPattern(patt2, 2);
содержит недопустимо большой для данного режима код цвета и обращение игнорируется. Сказанное, однако, не относится к процедуре SetFillStyle для значения параметра Fill в диапазоне от 0 до 11: программа будет нормально работать и в режиме высокого разрешения CGA-адаптера, причем все цвета палитры, кроме цвета фона, при этом заменяются на белый.
Процедура GetFillPattern.
Возвращает образец заполнения, установленный ранее процедурой SetFillPattern. Заголовок:
Procedure GetFillPattern(var Pattern: FillPatternType);
Здесь Pattern - переменная типа FillPatternType, в которой возвращается образец заполнения.
Если программа не устанавливала образец с помощью процедуры SetFillPattern, массив Pattern заполняется байтами со значением 255 ($FF).
Процедура GetFillSettings.
Возвращает текущий стиль заполнения. Заголовок:
Procedure GetFillSettings(var Pattlnfo: FillSettingsType);
Здесь Pattlnfo - переменная типа FillSettingsType, в которой возвращается текущий стиль заполнения,
В модуле Graph определен тип:
type
FillSettingsType = record
Pattern: Word; {Образец}
Color : Word {Цвет}
end;
Поля Pattern и Color в этой, записи имеют то же назначение, что и аналогичные параметры при обращении к процедуре SetFillStyle.
Процедура SetRGBPalette.
Устанавливает цветовую гамму при работе с дисплеем IBM 8514 и адаптером VGA. Заголовок:
Procedure SetRGBPalette(ColNum,RedVal, GreenVal,BlueVal:Integer);
Здесь ColNum - номер цвета; RedVal, GreenVal, BlueVal - выражения типа Integer, устанавливающие интенсивность соответственно красной, зеленой и синей составляющих цвета.
Эта процедура может работать только с дисплеем IBM 8514, а также с адаптером VGA, использующим видеопамять объемом 256 Кбайт. В первом случае параметр ColNum задается числом в диапазоне 0...255, во втором - в диапазоне 0...15. Для установки интенсивности используются 6 старших разрядов младшего байта любого из параметров RedVal, GreenVal, BlueVal.
В следующей программе в центре экрана выводится прямоугольник белым цветом, после чего этот цвет случайно изменяется с помощью процедуры SetRGBPalette. Для выхода из программы нужно нажать любую клавишу.
Uses Graph,CRT;
var
Driver, Mode, Err, xl, yl: Integer;
begin
{Инициируем графический режим}
Driver := Detect;
InitGraph(Driver, Mode, '');
Err := GraphResult;
if ErroO then
WriteLn(GraphErrorMsg(Err))
else if Driver in [IBM8514, VGA] then
begin
{Выводим прямоугольник в центре экрана}
x1 := GetMaxX div 4;
y1 := GetMaxY div 4;
SetColor(lS);
Bar(x1,y1,3*x1,3*y1);
{Изменяем белый цвет на случайный}
while not KeyPressed do
SetRGBPalette(15,Random(256),Random(256),Random(256));
CloseGraph
end
else
begin
CloseGraph; .
WriteLn('Адаптер не поддерживает ' , 'RGB-режим управления цветами')
end
end.
Процедура FloodFill.
Заполняет произвольную замкнутую фигуру, используя текущий стиль заполнения (узор и цвет). Заголовок:
Procedure FloodFill(X,Y: Integer; Border: Word);
Здесь X, Y- координаты любой точки внутри замкнутой фигуры; Border - цвет граничной линии.
Если фигура незамкнута, заполнение «разольется» по всему экрану.
Следует учесть, что реализованный в процедуре алгоритм просмотра границ замкнутой фигуры не отличается совершенством. В частности, если выводятся подряд две пустые строки, заполнение прекращается. Такая ситуация обычно возникает при заполнении небольших фигур с использованием типа LtSlashFill. В фирменном руководстве по Турбо Паскалю рекомендуется, по возможности, вместо процедуры FloodFill использовать FillPoly (заполнение прямоугольника).
Следующая программа демонстрирует заполнение случайных окружностей. Сначала в центре экрана создается окно, в котором заполняется небольшой прямоугольник. Часть прямоугольника останется незаполненной, в чем Вы можете убедиться, так как программа в этот момент приостанавливает работу, ожидая нажатия на клавишу Enter. Затем осуществляется вывод и заполнение случайных окружностей до тех пор, пока не будет нажата любая клавиша. Замечу, что прямоугольник заполняется полностью, если вместо типа LtSlashFill (косая штриховка линиями обычной толщины) используется SlashFill (штриховка утолщенными линиями). Если программа будет работать достаточно долго, она может «зависнуть», что лишний раз свидетельствует о несовершенстве реализованного в ней алгоритма.
Uses Graph, CRT;
var
d, r, е, х, у, с : Integer;
begin
{Инициируем графику}
d := Detect; InitGraph(d, r, ' ') ;
e := GraphResult;
if e <> grOk then . . WriteLn(GraphErrorMsg(e))
else
begin
{Создаем прямоугольное окно}
х := GetMaxX div 4;
у. := GetMaxY div 4;
Rectangle(х,у,3*x,3*y);
SetViewPort(x+1,y+1, 3*x-1,3*y-1,ClipOn);
{Демонстрируем заливку маленького прямоугольника}
SetPillStyle(LtSlashFill,GetMaxColor);
Rectangle(0,0,8,20); FloodFill(1,1,GetMaxColor);
OutTextXY(10,25,'Press Enter...');
ReadLn; {Ждем нажатия Enter}
{ Выводим окружности до тех пор, пока не будет нажата любая клавиша}
repeat
{Определяем случайный стиль заливки}
SetFillStyle(Random(12),Random(GetMaxColor+1));
{Задаем координаты центра и цвет окружности}
х := Random (GetMaxX div 2);
у := Random (GetMaxY div 2);
с := Random (succ(GetMaxColor));
SetColor(c);
{Выводим и заливаем окружность}
Circle(x, у, Random(GetMaxY div 5));
FloodFill (x, у, с)
until KeyPressed;
if ReadKey=#0 then
x := ord(ReadKey);
CloseGraph
end
end.
Процедура Bar.
Заполняет прямоугольную область экрана. Заголовок:
Procedure Bar(X1,Y1,X2,Y2: Integer);
Здесь XJ...Y2 - координаты левого верхнего (X1, Y1) и правого нижнего (Х2, Y2) углов закрашиваемой области.
Процедура закрашивает (но не обводит) прямоугольник текущим образцом узора и текущим цветом, которые устанавливаются процедурой SetFillStyle.
Следующая программа дает красивые цветовые эффекты (закраска случайных прямоугольников).
Uses Graph, CRT;
var
d, r, e : Integer;
begin
{Инициируем графику}
d : = Detect; InitGraph(d, r, '');
e := GraphResult; if e <> grOk then
WriteLn(GraphErrorMsg(e))
else
begin
{Создаем окно в центре экран}
d := GetMaxX div 4;
r := GetMaxY div 4; Rectangle(d,r,3*d,3*r);
SetViewPort(d+1,r+1,3*d-1,3*r-1,ClipOn);
{Цикл вывода и закраски случайных многоугольников}
repeat
SetFillStyle(Random(12),Random(succ(GetMaxColor)));
Bar(Random(Ge tMaxX),Random(Ge tMaxY),
Random(Ge tMaxX),Random(Ge tMaxY));
until KeyPressed;
if ReadKey=#0 then d := ord(ReadKey);
CloseGraph
end
end.
Процедура Ваr3D.
Вычерчивает трехмерное изображение параллелепипеда и закрашивает его переднюю грань . Заголовок:
Procedure Ваr3D (X1,Y1,X2,Y2,Depth: Integer; Top: Boolean);
Здесь X1... Y2 - координаты левого верхнего (X1, Y1) и правого нижнего (Х2, Y2) углов передней грани; Depth - третье измерение трехмерного изображения («глубина») в пикселях; Тор - способ изображения верхней грани.
Если параметр Тор имеет значение True, верхняя грань параллелепипеда вычерчивается, в противном случае - не вычерчивается (этот вариант используется для изображения поставленных друг на друга параллелепипедов, см. следующий пример). В качестве значения этого параметра может использоваться одна из следующих констант, определенных в модуле Graph:
const
TopOn = True;
TopOff = False;
При вычерчивании используется текущий стиль линий (SetLineStyle) и текущий цвет (SetColor). Передняя грань заливается текущим стилем заполнения (SetFillStyle).
Процедура обычно применяется при построении столбиковых диаграмм. Следует учесть, что параллелепипед «прозрачен», т.е. за его незакрашенными гранями могут быть видны другие элементы изображения.
Следующая программа иллюстрирует различные аспекты применения процедуры Bar3D.
Uses Graph,CRT;
var
d, r, e: Integer;
begin
{Инициируем графику}
d := Detect;
Ini-tGraph(d, r, ' ') ;
e := GraphResult;
if e <> grOk then
WriteLn(GraphErrorMsg(e))
else
begin
{Столбик с верхней гранью:}
Bar3D (80, 100, 120, 180, 15, TopOn);
{Столбик без верхней грани:}
Ваг3D (150, 150, 190, 180, 15, TopOff);
{Этот столбик "стоит" на следующем и прозрачен:}
Bar3D (230, 50, 250, 150, 15, TopOn);
Bar3D (220, 150, 260, 180, 15, TopOn);
{У этого столбика нет верхней грани, и поэтому он не мешает поставленному на него сверху:}
Bar3D (300, 150, 340, 180, 15, TopOff);
SetLineStyle(3,0,1);
SetColor(Yellow);
SetFillStyle(LtSlashFill,Yellow);
Bar3D (300, 50, 340, 150, 15, TopOn);
if ReadKey=#0 then d := ord(ReadKey);
CloseGraph;
end
end.
Процедура Fill Poly.
Обводит линией и закрашивает замкнутый многоугольник. Заголовок:
Procedure FillPoly(N: Word; var Coords);
Здесь N - количество вершин замкнутого многоугольника; Coords - переменная типа PointType, содержащая координаты вершин.
Координаты вершин задаются парой значений типа Integer: первое определяет горизонтальную, второе - вертикальную координаты. Для них можно использовать следующий определенный в модуле тип:
type
PointType = record
х, у : Integer
end;
Стиль и цвет линии контура задаются процедурами SetLineStyle и SetColor, тип и цвет заливки - процедурой SetFillStyle.
В следующем примере на экран выводятся случайные закрашенные многоугольники.
Uses Graph, CRT;
var
d, r, e: Integer;
p : array [1..6] of PointType; n, k : Word;
begin
{Инициируем графику}
d := Detect; InitGraph(d, r, ' ') ;
e := GraphResult; if e <> grOk then
WriteLn(GraphErrorMsg(e))
else
begin
{Создаем окно в центре экрана}
d := GetMaxX div 4;
r := GetMaxY div 4;
Rectangle(d,r,3*d,3*r);
SetViewPort(d+l,r+l,3*d-l,3*r-l,ClipOn);
{Цикл вывода случайных закрашенных многоугольников}
repeat
{Выбираем случайный цвет и узор)
SetFillStyle(Random(12),Random(succ(GetMaxColor)));
SetColor (Random(succ(GetMaxColor)));
{Назначаем случайные координаты}
n := Random (4) + 3 ; for k := 1 to n do with p[k] do
begin
x := Random (GetMaxX div 2);
у := Random (GetMaxY div 2)
end;
FillPoly (n, p) {Выводим и закрашиваем}
until KeyPressed;
if ReadKey=#0 then k := ord(ReadKey);
CloseGraph
end
end.
Процедура FillEllipse.
Обводит линией и заполняет эллипс. Заголовок:
Procedure FillEllipse(X,Y,RX,RY: Integer);
Здесь X, Y - координаты центра; RX, RY- горизонтальный и вертикальный радиусы эллипса в пикселях.
Эллипс обводится линией, заданной процедурами SetLineStyle и SetColor, и заполняется с использованием параметров, установленных процедурой SetFillStyle.
Процедура Sector.
Вычерчивает и заполняет эллипсный сектор. Заголовок: Procedure Sector(X,Y: Integer; BegA,EndA,RX,RY: Word);
Здесь BegA, EndA - соответственно начальный и конечный углы эллипсного сектора. Остальные параметры обращения аналогичны параметрам процедуры FillEllipse.
В следующей программе на экран выводятся случайные закрашенные эллипсы и секторы. Для выхода из программы нажмите любую клавишу.
Uses Graph, CRT;
var
d, r, e : Integer;
begin
{Инициируем графику}
d := Detect; InitGraph(d, r, '');
e := GraphResult; if e <> grOk then
WriteLn(GraphErrorMsg(e))
else
begin
{Создаем окно в центре экрана}
d := GetMaxX div 4;
r := GetMaxY div 4;
Rectangle(d,r,3*d,3*r);
SetViewPort(d+1,r+1,3*d-1,3*r-1,ClipOn);
{Цикл вывода}
repeat
SetFillStyle(Random(12), Random(succ(GetMaxColor)));
SetColor (Random(succ(GetMaxColor)));
Sector(Random(GetMaxX div),Random(GetMaxY div 2),
Random(360),Random(360),Random(GetMaxX div 5),
Random(GetMaxY div 5));
FillEl.lipse (Random (GetMaxX div 2),
Random(GetMaxY div 2),Random(GetMaxX div 5),
Random(GetMaxY div 5))
until KeyPressed;
if ReadKey=#0 then d := ord(ReadKey);
CloseGraph
end
end.
Процедура PieSlice.
Вычерчивает и заполняет сектор окружности. Заголовок:
Procedure PieSlice(X,Y: Integer; BegA,EndA,R: Word);
В отличие от процедуры Sector, указывается лишь один горизонтальный радиус R, остальные параметры аналогичны параметрам процедуры Sector.
Сектор обводится линией, заданной процедурами SetLineStyle и SetColor, и заполняется с помощью параметров, определенных процедурой SetFillStyle. Процедуру удобно использовать при построении круговых диаграмм, как, например, в следующей программе (рис. 14.9).
Рис. 14.9. Иллюстрация процедуры PieSlice
Uses Graph, CRT;
var
d, r, e : Integer;
begin
{Инициируем графический режим}
d := Detect;
InitGraph(d, r, '');
e := GraphResult; if e <> grOk then
WriteLn(GraphErrorMsg(e))
else
begin
{Выводим маленький сектор}
SetFillStyle(WideDotFill, White);
PieSlice(GetMaxX div 2+5,GetMaxY div 2+4,270,360,100);
{Выводим большой сектор}
SetFillStyle (SolidFill, Red);
PieSlice (GetMaxX div 2,GetMaxY div 2, 0,270,100).;
{Выводим надписи}
OutTextXY (GetMaxX div 2+90,GetMaxY div 2+70, '25%');
OutTextXY(GetMaxX div 2-50,GetMaxY div 2-20, '75%');
{Ждем нажатия на любую клавишу}
if ReadKey=#0 then d := ord(ReadKey);
Close,Graph
end
end.
Краткая характеристика графических режимов работы дисплейных адаптеров
Настройка графических процедур на работу с конкретным адаптером достигается за счет подключения нужного графического драйвера. Драйвер - это специальная программа, осуществляющая управление теми или иными техническими средствами ПК. Графический драйвер, как это не трудно догадаться, управляет дисплейным адаптером в графическом режиме. Графические драйверы разработаны фирмой Borland практически для всех типов адаптеров. Обычно они располагаются на диске в отдельном подкаталоге BGI в виде файлов с расширением BGI (от англ.: Borland Graphics Interface - графический интерфейс фирмы Borland). Например, CGA.BGI - драйвер для CG4-адаптера, EGA VGA.BGI - драйвер для адаптеров EGA и VGA и т.п.
Выпускаемые в настоящее время ПК оснащаются адаптерами, разработанными фирмой IBM, или совместимыми с ними. Если не учитывать уже упоминавшийся в гл.13 монохромный адаптер MDA, все они имеют возможность работы в графическом режиме. В этом режиме экран дисплея рассматривается как совокупность очень близко расположенных точек - пикселей, светимостью которых можно управлять с помощью программы.
Графические возможности конкретного адаптера определяются разрешением экрана, т.е. общим количеством пикселей, а также количеством цветов (оттенков), которыми может светиться любой из них. Кроме того, многие адаптеры могут работать с несколькими графическими страницами. Графической страницей называют область оперативной памяти, используемая для создания «карты» экрана, т.е. содержащая информацию о светимости (цвете) каждого пикселя. Ниже приводится краткая характеристика графических режимов работы наиболее распространенных адаптеров.
Адаптер CGA (Color Graphics Adapter - цветной графический адаптер) имеет 5 графических режимов. Четыре режима соответствуют низкой разрешающей способности экрана (320 пикселей по горизонтали и 200 по вертикали, т.е. 320x200) и отличаются только набором допустимых цветов - палитрой. Каждая палитра состоит из трех цветов, а с учетом черного цвета несветящегося пикселя - из четырех: палитра 0 (светло-зеленый, розовый, желтый), палитра 1 (светло-бирюзовый, малиновый, белый), палитра 2 (зеленый, красный, коричневый) и палитра 3 (бирюзовый, фиолетовый, светло-серый). Пятый режим соответствует высокому разрешению 640x200, но каждый пиксель в этом случае может светиться либо каким-то одним заранее выбранным и одинаковым для всех пикселей цветом, либо не светиться вовсе, т.е. палитра этого режима содержит два цвета. В графическом режиме адаптер CGA использует только одну страницу.
Адаптер EGA (Enhanced Graphics Adapter - усиленный графический адаптер) может полностью эмулировать графические режимы адаптера CGA. Кроме того, в нем возможны режимы: низкого разрешения (640x200, 16 цветов, 4 страницы) и высокого разрешения (640x350, 16 цветов, 1 страница). В некоторых модификациях используется также монохромный режим (640x350, 1 страница, 2 цвета).
Адаптер MCGA (Multi-Color Graphics Adapter - многоцветный графический адаптер) совместим с CGA и имеет еще один режим - 640x480, 2 цвета, 1 страница. Такими адаптерами оснащались младшие модели серии ПК PS/2 фирмы IBM. Старшие модели этой серии оснащаются более совершенными адаптерами VGA (Video Graphics Array -графический видеомассив. Адаптер VGA эмулирует режимы адаптеров CGA и EGA и дополняет их режимом высокого разрешения (640x480, 16 цветов, 1 страница).
Не так давно появились так называемые cynep-VGA адаптеры (SVGA) с разрешением 800x600 и более, использующие 256 и более цветовых оттенков. В настоящее время эти адаптеры получили повсеместное распространение, однако в библиотеке Graph для них нет драйверов. Поскольку SVGA совместимы с VGA, для управления современными графическими адаптерами приходится использовать драйвер EGAVGA.BGI и довольствоваться его относительно скромными возможностями.
Несколько особняком стоят достаточно популярные адаптеры фирмы Hercules. Адаптер HGC имеет разрешение 720x348, его пиксели могут светиться одним цветом (обычно светло-коричневым) или не светиться вовсе, т.е. это монохромный адаптер. Адаптер HGC+ отличается несущественными усовершенствованиями, а адаптер HIСС (Hercules In Color Card) представляет собой 16-цветный вариант HGC+.
Линии и точки
Процедура PutPixel.
Выводит заданным цветом точку по указанным координатам. Заголовок:
Procedure PutPixel(X,Y: Integer; Color: Word);
Здесь X, Y- координаты точки; Color - цвет точки.
Координаты задаются относительно левого верхнего угла окна или, если окно не установлено, относительно левого верхнего угла экрана.
Следующая программа периодически выводит на экран «звездное небо» и затем гасит его. Для выхода из программы нажмите любую клавишу.
Uses CRT, Graph;
type
PixelType = record
x, у : Integer; end;
const
N = 5000; {Количество "звезд"}
var
d,r,e,k: Integer;
x1,y1,x2,y2: Integer;
a: array [1..N] of PixelType; {Координаты}
begin
{Инициируем графику}
d := Detect; InitGraph(d, r, ' ') ;
e := GraphResult; if e<>grOk then
WriteLn(GraphErrorMsg(e))
else
begin
{Создаем окно в центре экрана}
x1 := GetMaxX div 4;
y1 := GetMaxY div 4;
x2 := 3*x1;
y2 := 3*y1;
Rectangle(x1,y1,x2,y2);
SetViewPort(x1+1,y1+1,x2-1,y2-1,ClipOn);
{Создаем и запоминаем координаты всех "звезд"}
for k := 1 to N do with a[k] do begin
x := Random(x2-x1);
у := Random(y2-y1)
end;
{Цикл вывода}
repeat
for k := 1 to N do
with a[k] do {Зажигаем "звезду"}
PutPixel(x,y,white);
if not KeyPressed then
for k := N downto 1 do with a[k] do {Гасим "звезду"}
PutPixel(x,y,black)
until KeyPressed;
while KeyPressed do k := ord(ReadKey);
CloseGraph
end;
end.
Функция GetPixel.
Возвращает значение типа Word, содержащее цвет пикселя с указанными координатами. Заголовок:
Function GetPixel(X,Y: Integer): Word;
Здесь X, Y - координаты пикселя.
Процедура Line.
Вычерчивает линию с указанными координатами начала и конца. Заголовок:
Procedure Line(X1,Y1,X2,Y2: Integer);
Здесь XL. .Yl - координаты начала (XI, Y1) и конца (Х2, Y2) линии.
Линия вычерчивается текущим стилем и текущим цветом. В следующей программе в центре экрана создается окно, которое затем расчерчивается случайными линиями. Для выхода из программы нажмите любую клавишу.
Uses CRT, Graph;
var
d,r,e : Integer;
x1,y1,x2,y2: Integer;
begin
{Инициируем графику}
d := Detect; InitGraph(d, r, '');
e := GraphResult; if e <> grOk then
WriteLn(GraphErrorMsg(e))
else
begin
{Создаем окно в центре экрана}
x1 := GetMaxX div 4;
y1 := GetMaxY div 4;
x2 := 3*x1;
y2 := 3*y1;
Rectangle(x1,y1,x2,y2);
SetViewPort(x1+1,y1+1,x2-1,y2-1,ClipOn);
{Цикл вывода случайных линий}
repeat
SetColor(succ(Random(16))); {Случайный цвет}
Line(Random(x2-x1), Random(y2-y1),
Random(x2-x1), Random(y2-y1))
until KeyPressed;
if ReadKey=#0 then d:= ord(ReadKey);
CloseGraph
end
end.
Процедура LineTo.
Вычерчивает линию от текущего положения указателя до положения, заданного его новыми координатами. Заголовок:
Procedure LineTo(X,Y: Integer);
Здесь X, Y - координаты нового положения указателя, они же - координаты второго конца линии.
Процедура LineRel.
Вычерчивает линию от текущего положения указателя до положения, заданного приращениями его координат. Заголовок:
Procedure LineRel (DX, DY: Integer);
Здесь DX, DY- приращения координат нового положения указателя. В процедурах LineTo и LineRel линия вычерчивается текущим стилем и текущим цветом.
Процедура SetLineStyle.
Устанавливает новый стиль вычерчиваемых линий. Заголовок:
Procedure SetLineStyle(Type,Pattern,Thick: Word)
Здесь Type, Pattern, Thick - соответственно тип, образец и толщина линии. Тип линии может быть задан с помощью одной из следующих констант:
const
SolidLn= 0; {Сплошная линия}
DottedLn= 1; {Точечная линия}
CenterLn= 2; {Штрих-пунктирная линия}
DashedLn= 3; {Пунктирная линия}
UserBitLn= 4; {Узор линии определяет пользователь}
Параметр Pattern учитывается только для линий, вид которых определяется пользователем (т.е. в случае, когда Туре = UserBitLn). При этом два байта параметра Pattern определяют образец линии: каждый установленный в единицу бит этого слова соответствует светящемуся пикселю в линии, нулевой бит - несветящемуся пикселю. Таким образом, параметр Pattern задает отрезок линии длиной в 16 пикселей. Этот образец периодически повторяется по всей длине линии.
Параметр Thick может принимать одно из двух значений:
const
NormWidth = 1; {Толщина в один пиксель}
ThickWidth = 3; {Толщина в три пикселя}
Отметим, что установленный процедурой стиль линий (текущий стиль) используется при построении прямоугольников, многоугольников и других фигур.
В следующем примере демонстрируются линии всех стандартных стилей, затем вводятся слово-образец и линия с этим образцом заполнения (рис. 14.4). Для выхода из программы введите ноль.
рис.14.4. Образцы линий
Uses CRT, Graph;
const
style: array [0..4] of String [9] = (
'SolidLn ', 'DottedLn ', 'CenterLn 'DashedLn', 'UserBitLn');
var
d,r,e,i,j,dx,dy: Integer;
p: Word;
begin
{Инициируем графику}
d := Detect; InitGraph(d, r, '');
e := GraphResult; if e <> grOk then
WriteLn (GraphErrorMsg(e))
else
begin
{Вычисляем смещение линий}
dx := GetMaxX div 6;
dy := GetMaxY div 10;
{Выводим стандартные линии}
for j := 0 to 1 do {Для двух толщин}
begin
for i := 0 to 3 do {Четыре типа линий}
begin
SetLineStyle(i, 0, j*2+1);
Line(0,(i+j*4+l)*dy,dx,(i+j*4+l)*dy);
OutTextXY(dx+10, (i+j*4+l)*dy,style [i])
end
end;
{Вводим образец и чертим линию}
j := 0;
dy := (GetMaxY+1) div 25;
repeat
OutTextXY(320,j*dy,'Pattern: ');
GotoXY(50,j+1);
ReadLn(p); if p <> 0 then
begin
SetLineStyle(UserBitLn,p,NormWidth);
Line(440,j*dy+4, 600, j*dy+4);
inc(j)
end
until p = 0;
CloseGraph
end
end.
Процедура GetLineSettings.
Возвращает текущий стиль линий. Заголовок:
Procedure GetLineSettings(var Stylelnfo: LineSettingsType)
Здесь Stylelnfo - переменная типа LineSettingsType, в которой возвращается текущий стиль линий.
Тип LineSettingsType определен в модуле Graph следующим образом:
type
LineSettingsType = record
LineStyle: Word; {Тип линии}
Pattern : Word; {Образец}
Thickness: Word {Толщина}
end;
Процедура SetWriteMode.
Устанавливает способ взаимодействия вновь выводимых линий с уже существующим на экране изображением. Заголовок:
Procedure SetWriteMode(Mode);
Здесь Mode - выражение типа Integer, задающее способ взаимодействия выводимых линий с изображением.
Если параметр Mode имеет значение 0, выводимые линии накладываются на существующее изображение обычным образом (инструкцией МОV центрального процессора). Если значение 1, то это наложение осуществляется с применением логической операции XOR (исключительное ИЛИ): в точках пересечения выводимой линии с имеющимся на экране изображением светимость пикселей инвертируется на обратную, так что два следующих друг за другом вывода одной и той же линии на экран не изменят его вид.
Режим, установленный процедурой SetWriteMode, распространяется на процедуры Drawpoly, Line, LineRel, LineTo и Rectangle. Для задания параметра Mode можно использовать следующие определенные в модуле константы:
const
CopyPut = 0;{Наложение операцией MOV}
XORPut = 1;{Наложение операцией XOR}
В следующем примере на экране имитируется вид часового циферблата (рис. 1.4.5). Для наглядной демонстрации темп хода «часов» ускорен в 600 раз (см. оператор Delay (100)). При желании Вы сможете легко усложнить программу, связав ее показания с системными часами и добавив секундную стрелку. Для выхода из программы нажмите на любую клавишу.
Рис. 14.5. Часовой циферблат
Uses Graph, CRT;
var
d,r,r1,r2,rr,k,
x1,y1,x2,y2,x01,y01: Integer;
Xasp,Yasp : Word;
begin
{Инициируем графику}
d := detect; InitGraph(d, r, '');
k := GraphResult; if k <> grOK then
WriteLn(GraphErrorMSG(k))
else
begin
{Определяем отношение сторон и размеры экрана}
x1 := GetMaxX div 2;
y1 := GetMaxY div 2;
GetAspectRatio(Xasp, Yasp);
{Вычисляем радиусы:}
r:= round(3*GetMaxY*Yasp/8/Xasp);
r1 := round(0.9*r); {Часовые деления}
г2 := round(0.95*r); {Минутные деления}
{Изображаем циферблат}
Circle(x1,y1,r); {Первая внешняя окружность}
Circle(x1,y1,round(1.02*г) ); {Вторая окружность}
for k := 0 to 59 do {Деления циферблата}
begin
if k mod 5=0 then
rr := r1 {Часовые деления}
else
rr : = r2; {Минутные деления}
{Определяем координаты концов делений}
x0l := x1+Round(rr*sin(2*pi*k/60));
y0l := y1-Round(rr*Xasp*cos(2*pi*k/60)/Yasp);
x2 := x1+Round(r*sin(2*pi*k/60));
y2 := y1-Round(r*Xasp*cos(2*pi*k/60)/Yasp);
Line(x01,y01,x2,y2) {Выводим деление}
end;
{Готовим вывод стрелок}
SetWriteMode(XORPut);
SetLineStyle(SolidLn,0,ThickWidth);
{Счетчик минут в одном часе}
{k = минуты}
r := 0;
{Цикл вывода стрелок}
repeat
for k := 0 to 59 do if not KeyPressed then begin
(Координаты часовой стрелки} x2 := x1+Round(0.85*r1*sin(2*pi*r/60/12));
y2 := y1-Round(0.85*r1*Xasp*cos(2*pi*r/60/12)/Yasp);
{Координаты минутной стрелки}
x01 := x1+Round(r2*sin(2*pi*k/60));
y01 := y1-Round(r2*Xasp*cos(2*pi*k/60)/Yasp);
{Изображаем стрелки}
Line(x1,y1,x2,y2);
Line(x1,y1,x01,y01) ;
Delay(100); {Для имитации реального темпа нужно установить задержку 60000}
{Для удаления стрелок выводим их еще раз!}
Line(x1,y1,x01,y01);
Line(x1,y1,х2,у2);
{Наращиваем и корректируем счетчик минут в часе}
inc(r); if r=12*60 then
r := 0
end
until KeyPressed;
if ReadKey=#0 then k := ord(ReadKey);
CloseGraph
end
end.
Многоугольники
Процедура Rectangle.
Вычерчивает прямоугольник с указанными координатами углов. Заголовок:
Procedure Rectangle(X1,Y1,X2,Y2: Integer);
Здесь X1... Y2 - координаты левого верхнего (X1, Y1) и правого нижнего (Х2, Y2) углов прямоугольника. Прямоугольник вычерчивается с использованием текущего цвета и текущего стиля линий.
В следующем примере на экране вычерчиваются 10 вложенных друг в друга прямоугольников.
Uses Graph, CRT;
var
d,r,e,xl,yl, x2,y2,dx,dy: Integer;
begin
{Инициируем графику}
d := Detect; InitGraph(d, r, ' ') ;
e := GraphResult; if e <> grOK then
WriteLn(GraphErrorMsg(e))
else
begin
{Определяем приращения сторон}
dx := GetMaxX div 20;
dy := GetMaxY div 20;
{Чертим вложенные прямоугольники}
for d := 0 to 9 do
Rectangle(d*dx,d*dy,GetMaxX-d*dx,GetMaxY-d*dy);
if ReadKey=#0 then d := ord(ReadKey);
CloseGraph
end
end.
Процедура DrawPoly.
Вычерчивает произвольную ломаную линию, заданную координатами точек излома.
Procedure DrawPoly(N: Word; var Points)
Здесь N - количество точек излома, включая обе крайние точки; Points - переменная типа PointType, содержащая координаты точек излома.
Координаты точек излома задаются парой значений типа Word: первое определяет горизонтальную, второе - вертикальную координаты. Для них можно использовать следующий определенный в модуле тип:
type
PointType = record
х, у : Word
end;
При вычерчивании используется текущий цвет и текущий стиль линий. Вот как, например, можно с помощью этой процедуры вывести на экран график синуса:
Uses Graph;
const
N = 100; {Количество точек графика}
var
d, r, e: Integer;
m : array [O..N+1] of PointType; k : Word;
begin
{Инициируем графику}
d := Detect; InitGraph(d, r, '');
e := GraphResult; if e <> grOk then
WriteLn(GraphErrorMsg(e))
else
begin
{Вычисляем координаты графика}
for k := 0 to N do with m[k] do
begin
x := trunc(k*GetMaxX/N);
у := trunc(GetMaxY*(-sin(2*Pi*k/N)+1)/2)
end;
{Замыкаем график прямой линией}
m[succ(N)].x := m[0] .x;
m[succ(n)].y := m[0] .у;
DrawPoly(N + 2, m);
ReadLn;
CloseGraph
end
end.
В этом примере для проведения горизонтальной прямой используется «замыкание» ломаной - первая и последняя координаты ее точек излома совпадают.
Замечу, что хотя количество точек излома N - выражение типа Word, на самом деле внутри процедуры на этот параметр накладываются ограничения, связанные с конечным размером используемой буферной памяти. Вы можете убедиться в этом с помощью, например, изменения N в предыдущем примере: при N=678 график перестанет выводиться на экран, а функция GraphResult будет возвращать значение -6 (не хватает памяти для просмотра областей). Таким образом, для этой программы пороговое значение количества точек излома составляет 679. В то же время для программы
Uses Graph;
const
N=510; {Предельное значение, при котором
на экране еще видна диагональная линия}
var
d,k: Integer;
Coo: array [1..N] of PointType;
begin
d := Detect; InitGraph(d,k,' ') ;
for k := 1 to N do with Coo[k] do
if odd(k) then
begin
X := 0;
Y := 0
end
else
begin
X := GetMaxX;
Y := GetMaxY
end;
DrawPoly(N,Coo);
ReadLn;
CloseGraph
end.
это значение равно 510. В этой программе ломаная задается в виде многократно накладывающихся друг на друга диагональных линий.
Переход в графический режим и возврат в текстовый
Стандартное состояние ПК после его включения, а также к моменту запуска программы из среды Турбо Паскаля соответствует работе экрана в текстовом режиме, поэтому любая программа, использующая графические средства компьютера, должна определенным образом инициировать графический режим работы дисплейного адаптера. После завершения работы программы ПК возвращается в текстовый режим.
Процедуры и функции
Процедура InitGraph. Инициирует графический режим работы адаптера. Заголовок процедуры:
Procedure InitGraph(var Driver,Mode: Integer; Path: String);
Здесь Driver - переменная типа Integer, определяет тип графического драйвера; Mode - переменная того же типа, задающая режим работы графического адаптера; Path - выражение типа String, содержащее имя файла драйвера и, возможно, маршрут его поиска.
К моменту вызова процедуры на одном из дисковых носителей информации должен находиться файл, содержащий нужный графический драйвер. Процедура загружает этот драйвер в оперативную память и переводит адаптер в графический режим работы. Тип драйвера должен соответствовать типу графического адаптера. Для указания типа драйвера в модуле предопределены следующие константы:
const
Detect=0;{Режим автоопределения типа}
CGA=1;
MCGA=2;
EGA=3;
EGA64=4;
EGAMono=5;
IBM8514=6;
HercMono=7;
ATT400=8;
VGA=9;
PC3270=10;
Большинство адаптеров могут работать в различных режимах. Для того, чтобы указать адаптеру требуемый режим работы, используется переменная Mode, значением которой в момент обращения к процедуре могут быть такие константы:
{Адаптер VGA:}
VGALo = 0; {640x200}
VGAMed = 1; {640x350}
VGAHi = 2; {640x480}
PC3270H1 = 0; {Аналог HercMonoHi}
{Адаптер 1ВМ8514}
IBM8514LO =0; {640x480, 256 цветов}
IBM8514H1 = 1; {1024x768, 256 цветов}
Пусть, например, драйвер CGA.BGI находится в каталоге TP\BGI на диске С и устанавливается режим работы 320x200 с палитрой 2. Тогда обращение к процедуре будет таким:
Uses Graph;
var
Driver, Mode : Integer;
begin
Driver := CGA;{Драйвер}
Mode := CGAC2;{Режим работы}
InitGraph(Driver, Mode,' С:\TP\BGI') ;
.......
Если тип адаптера ПК неизвестен или если программа рассчитана на работу с любым адаптером, используется обращение к процедуре с требованием автоматического определения типа драйвера:
Driver := Detect;
InitGraph(Driver, Mode, 'C:\TP\BGI');
После такого обращения устанавливается графический режим работы экрана, а при выходе из процедуры переменные Driver и Mode содержат целочисленные значения, определяющие тип драйвера и режим его работы. При этом для адаптеров, способных работать в нескольких режимах, выбирается старший режим, т.е. тот, что закодирован максимальной цифрой. Так, при работе с CGA -адаптером обращение к процедуре со значением Driver = Detect вернет в переменной Driver значение 1 (CGA) и в Mode -значение 4 (CGAHi), а такое же обращение к адаптеру VGA вернет Driver = 9 (VGA) и Mode = 2 (VGAHi).
Функция GraphResult. Возвращает значение типа Integer, в котором закодирован результат последнего обращения к графическим процедурам. Если ошибка не обнаружена, значением функции будет ноль, в противном случае - отрицательное число, имеющее следующий смысл:
const
grOk = 0;{Нет ошибок}
grlnitGraph =-1;{He инициирован графический режим}
grNotDetected =-2;{Не определен тип драйвера}
grFileNotFind =-3;{Не найден графический драйвер}
grlnvalidDriver =-4;{Неправильный тип драйвера}
grNoLoadMem =- 5;{Нет памяти для размещения драйвера}
grNoScanMem = - 6;{Нет памяти для просмотра областей}
grNoFloodMem =- 7;{Нет памяти для закраски областей}
grFontNotFound = -8;{Не найден файл со шрифтом}
grNoFontMem =- 9;{Нет памяти для размещения шрифта}
grlnvalidMode =-10;{Неправильный графический режим}
grError =-11;{Общая ошибка}
grIOError =-12;{Ошибка ввода-вывода}
grlnvalidFont =-13;{Неправильный формат шрифта}
grInvalidFontNum=-14; {Неправильный номер шрифта}
После обращения к функции GraphResult признак ошибки сбрасывается, поэтому повторное обращение к ней вернет ноль.
Функция GraphErrorMsg.
Возвращает значение типа String, в котором по указанному коду ошибки дается соответствующее текстовое сообщение. Заголовок функции:
Function GraphErrorMsg(Code: Integer): String;
Здесь Code - код ошибки, возвращаемый функцией GraphResult.
Например, типичная последовательность операторов для инициации графического режима с автоматическим определением типа драйвера и установкой максимального разрешения имеет следующий вид:
var
Driver, Mode, Error:Integer;
begin
Driver := Detect;{Автоопределение драйвера}
InitGraph(Driver, Mode,' ');{Инициируем графику}
Error := GraphResult;{Получаем результат}
if Error <> grOk then{Проверяем ошибку}
begin{Ошибка в процедуре инициации}
WriteLn(GraphErrorMsg(Error));{Выводим сообщение}
.......
end
else{Нет ошибки}
.......
Чаще всего причиной возникновения ошибки при обращении к процедуре InitGraph является неправильное указание местоположения файла с драйвером графического адаптера (например, файла CGA.BGI для адаптера CGA). Настройка на местоположение драйвера осуществляется заданием маршрута поиска нужного файла в имени драйвера при вызове процедуры InitGraph. Если, например, драйвер зарегистрирован в подкаталоге DRIVERS каталога PASCAL на диске D, то нужно использовать вызов:
InitGraph(Driver, Mode, 'd:\Pascal\Drivers');
Замечание. Во всех следующих примерах процедура InitGraph вызывается с параметром Driver в виде пустой строки. Такая форма обращения будет корректна только в том случае, когда нужный файл графического драйвера находится в текущем каталоге. Для упрощения повторения примеров скопируйте файл, соответствующий адаптеру Вашего ПК, в текущий каталог.
Процедура CloseGraph.
Завершает работу адаптера в графическом режиме и восстанавливает текстовый режим работы экрана. Заголовок:
Procedure CloseGraph;
Процедура RestoreCRTMode.
Служит для кратковременного возврата в текстовый режим. В отличие от процедуры CloseGraph не сбрасываются установленные параметры графического режима и не освобождается память, выделенная для размещения графического драйвера. Заголовок:
Procedure RestoreCRTMode;
Функция GetGraphMode.
Возвращает значение типа Integer, в котором содержится код установленного режима работы графического адаптера. Заголовок:
Function GetGraphMode: Integer;
Процедура
SetGraphMode.
Устанавливает новый графический режим работы адаптера. Заголовок:
Procedure SetGraphMode(Mode: Integer);
Здесь Mode - код устанавливаемого режима.
Следующая программа иллюстрирует переход из графического режима в текстовый и обратно:
Uses Graph;
var .
Driver, Mode, Error : Integer;
begin
{Инициируем графический режим}
Driver := Detect;
InitGraph(Driver, Mode, '');
Error := GraphResult; {Запоминаем результат}
i£ Error <> grOk then {Проверяем ошибку}
WriteLn(GraphErrorMsg(Error)) {Есть ошибка}
else
begin {Нет ошибки}
WriteLn ('Это графический режим');
WriteLn ('Нажмите "Enter"...':20);
ReadLn;
{Переходим в текстовый режим}
RestoreCRTMode;
WriteLn (' А это текстовый...');
ReadLn;
{Возвращаемся в графический режим}
SetGraphMode (GetGraphMode);
WriteLn ('Опять графический режим...');
ReadLn;
CloseGraph
end
end.
В этом примере для вывода сообщений как в графическом, так и в текстовом режиме используется стандартная процедура WriteLn. Если Ваш ПК оснащен нерусифицированным адаптером CGA, вывод кириллицы в графическом режиме таким способом невозможен, в этом случае замените соответствующие сообщения так, чтобы использовать только латинские буквы.
Процедура DetectGraph.
Возвращает тип драйвера и режим его работы. Заголовок:
Procedure DetectGraph(var Driver,Mode: Integer);
Здесь Driver - тип драйвера; Mode - режим работы.
В отличие от функции GetGraphMode описываемая процедура возвращает в переменной Mode максимально возможный для данного адаптера номер графического режима.
Функция GetDriverName.
Возвращает значение типа String, содержащее имя загруженного графического драйвера. Заголовок:
Function GetDriverName: String;
Функция GetMaxMode.
Возвращает значение типа Integer, содержащее количество возможных режимов работы адаптера. Заголовок:
Function GetMaxMode: Integer;
Функция GetModeName.
Возвращает значение типа String, содержащее разрешение экрана и имя режима работы адаптера по его номеру. Заголовок:
Function GetModName(ModNumber: Integer): String;
Здесь ModNumber - номер режима.
Следующая программа после инициации графического режима выводит на экран строку, содержащую имя загруженного драйвера, а также все возможные режимы его работы.
Uses Graph;
var
a,b: Integer;
begin
a := Detect;
InitGraph(a, b, '');
WriteLn(GetDriverName);
for a := 0 to GetMaxMode do
WriteLn(GetModeName(a):10);
ReadLn;
CloseGraph
end.
Процедура GetModeRange.
Возвращает диапазон возможных режимов работы заданного графического адаптера. Заголовок:
Procedure GetModeRange(Drv: Integer; var Min, Max: Integer);
Здесь Drv - тип адаптера; Min - переменная типа Integer, в которой возвращается нижнее возможное значение номера режима; Мах - переменная того же типа, верхнее значение номера.
Если задано неправильное значение параметра Drv, процедура вернет в обеих переменных значение -1. Перед обращением к процедуре можно не устанавливать графический режим работы экрана. Следующая программа выводит на экран названия всех адаптеров и диапазоны возможных номеров режимов их работы.
Uses Graph;
var
D,L,H: Integer;
const
N: array [1..11] of String [8] =
('CGA ', 'MCGA ', 'EGA ',
'EGA64 ', 'EGAMono ', ЧВМ8514 ',
'HercMono', 'ATT400 ', 'VGA ',
'PC3270 ', 'Ошибка ');
begin
WriteLn('Адаптер Мин. Макс.');
for D := 1 to 11 do
begin
GetModeRange(D, L, H);
WriteLn(N[D], L:7, H:10)
end
end.
Сохранение и выдача изображений
Функция ImageSize.
Возвращает размер памяти в байтах, необходимый для размещения прямоугольного фрагмента изображения. Заголовок:
Function ImageSize(X1,Y1,X2,Y2: Integer): Word;
Здесь X1... Y2 - координаты левого верхнего (X1, Y1) и правого нижнего (Х2, Y2) углов фрагмента изображения.
Процедура Getlmage.
Помещает в память копию прямоугольного фрагмента изображения. Заголовок:
Procedure Getlmage(X1,Y1,X2,Y2: Integer; var Buf)
Здесь X1...Y2 - координаты углов фрагмента изображения; Buf - переменная или участок кучи, куда будет помещена копия видеопамяти с фрагментом изображения.
Размер Buf должен быть не меньше значения, возвращаемого функцией ImageSize с теми же координатами X1....Y2.
Процедура Put Image.
Выводит в заданное место экрана копию фрагмента изображения, ранее помещенную в память процедурой Getlmage. Заголовок:
Procedure Putlmage(X,Y: Integer; var Buf; Mode: Word);
Здесь X,Y- координаты левого верхнего угла того места на экране, куда будет скопирован фрагмент изображения; Buf - переменная или участок кучи, откуда берется изображение; Mode - способ копирования.
Как видим, координаты правого нижнего угла не указываются, так как они полностью определяются размерами вновь выводимой на экран копии изображения. Координаты левого верхнего угла могут быть какими угодно, лишь бы только выводимая копия уместилась в пределах экрана (если копия не может разместиться на экране, она не выводится и экран остается без изменений).
Параметр Mode определяет способ взаимодействия вновь размещаемой копии с уже имеющимся на экране изображением. Взаимодействие осуществляется путем
применения кодируемых этим параметром логических операций к каждому биту копии и изображения. Для указания применяемой логической операции можно использовать одну из следующих предварительно определенных констант:
const
NormalPut= 0;{Замена существующего изображения на копию}
XorPut = 1;{Исключительное ИЛИ}
OrPut = 2;{Объединительное ИЛИ}
AndPut = 3;{Логическое И}
NotPut = 4;{Инверсия изображения}
Наиболее часто используются операции NormalPut, XORPut и NotPut. Первая из них просто стирает часть экрана и на это место помещает копию из памяти в том виде, как она там сохраняется. Операция NotPut делает то же самое, но копия выводится в инверсном виде. Для монохромного режима это означает замену светящихся пикселей на темные и наоборот. В цветном режиме операция NotPut применяется к коду цвета каждого пикселя. Например, для White (код 15 или в двоичном виде 1111) эта операция даст код 0000 = 0 = Black, для Red = 4 = 0100 получим 1011 = 11 = LightCyan и т.д. Операция XORPut, примененная к тому же месту экрана, откуда была получена копия, сотрет эту часть экрана. Если операцию применить дважды к одному и тому же участку, вид изображения на экране не изменится. Таким способом можно довольно просто перемещать изображения по экрану, создавая иллюзию движения.
Следующая программа рисует «Неопознанный Летающий Объект» - летающую тарелку на звездном фоне (рис. 14.10).
Рис.14.10. Иллюстрация процедур Getlmage/Putlmage
Uses Graph, CRT;
const
r = 20; {Характерный размер НЛО}
pause = 50; {Длительность паузы}
var
d,m,e,xm/ym,x,y/lx,ly,rx,ry,
Size,i,dx,dy,Width,Height: Integer;
Saucer : Pointer;
label
loop;
begin
{Инициируем графику}
d := Detect; lnitGraph(d, m, ' ') ;
e := GraphResult; if e <> grOk then
WriteLn(GraphErrorMsg(e))
else
begin
x := r*5;
у := r*2;
xm := GetMaxX div 4;
ym := GetMaxY div 4;
{Создаем "тарелку" из двух эллипсов с усами антенн}
Ellipse (х,у,0,360,r,r div 3+2); ,
Ellipse (х,у-4,190,357,r,r div 3);
Line (х+7,у-б,х+10,у-12);
Line (x-7,y-6, х-10, у-12);
Circle (x+10,y-12,2);
Circle (х-10,у-12,2);
FloodFill(x+l,y+4,White);
{Определяем габариты НЛО и помещаем его в кучу}
1х := х-r-1;
1у := у-14;
гх := х+r+1;
гу := у+r div 3+3;
Width := rx - lx + 1;
Height:= ry - ly + 1;
Size := ImageSize(lx, ly, rx, ry);
GetMem (Saucer, Size);
Getlmage (lx, ly, rx, ry, Saucer^);
{Стираем построенное}
Putlmage (lx, ly, Saucer^, xorPut);
{Создаем звездное небо}
Rectangle(xm,ym,3 *xm,3 *ym);
SetViewPort(xm+1,ym+1,3*xm-1,3*ym-1,ClipOn);
xm := 2*xm;
ym := 2*ym;
for i:=1 to 200 do
PutPixe1 (Random(xm), Random(ym), White) ;
{Задаем начальное положение НЛО и направление движения}
х := xm div 2;
у := ym div 2;
dx := 10;
dy := 10;
{Основной цикл}
repeat
Putlmage(x,y,Saucer^,xorPut); {Изображаем НЛО на}
Delay(pause); {новом месте и после}
Putlmage (x, у, Saucer^, XorPut);{паузы стираем его}
{Получаем новые координаты}
loop: x := x+dx;
у := y+dy;
{НЛО достиг границы экрана?}
if (x<0) or (x+Width+1>xm) or
(у<0) or (y+Height+1>ym) then
begin {Да - НЛО достиг границы: меняем направление его перемещения}
x := x-dx;
y:= y-dy;
dx : = GetMaxX div 10 - Random(GetMaxX div 5);
dy := GetMaxY div 30 - Random(GetMaxY div 15);
goto loop
end
until KeyPressed;
if ReadKey=#0 then x := ord(ReadKey);
CloseGraph
end
end.
Включение драйвера и шрифтов в тело программы
В Турбо Паскале имеется возможность включения графического драйвера и штриховых шрифтов непосредственно в тело программы. Такое включение делает программу независимой от местоположения и наличия на диске драйверов и шрифтов, а также ускоряет подготовку графических программ к работе (шрифты и драйвер загружаются вместе с программой).
Включение драйвера и шрифтов осуществляется по следующей общей схеме. Сначала с помощью вспомогательной программы BINOBJ.EXE, входящей в комплект поставки Турбо Паскаля, драйвер и шрифты преобразуются в OBJ-файл (файл с расширением .OBJ). Для этого вне среды Турбо Паскаля необходимо вызвать утилиту BINOBJ с тремя параметрами: именем преобразуемого файла, именем получаемого OBJ-файла и глобальным именем процедуры. Эти имена, в принципе, могут быть произвольными, правильными для MS-DOS именами. Например:
c:\tp\binobj cga.bgi cga cgadrv
В результате такого обращения из каталога ТР на диске С будет вызвана программа BINOBJ и ей будут переданы следующие параметры:
CGA.BGI - имя файла с преобразуемым драйвером;
CGA - имя файла с расширением .OBJ, т.е. CGA.OBJ, который будет получен в результате исполнения программы BINOBJ;
CGADRV- глобальное имя, под которым этот драйвер будет известен программе.
После этого можно написать следующий фрагмент программы:
Uses Graph;
Procedure CGADRV; external;
{$L CGA.OBJ}
var
d, r, e : Integer;
begin
if RegisterBGIDriver (@CGADRV) < 0 then
begin
WriteLn ('Ошибка при регистрации драйвера');
halt
end;
d := CGA; r := CGAHi;
InitGraph (d, r, '');
.......
Как видно из этого примера, в программе объявляется внешняя процедура с именем CGADRV (глобальное имя, указанное при обращении к BINOBJ), причем дается директива компилятору отыскать в текущем каталоге и загрузить файл CGA.OBJ, в котором находится эта процедура. Затем осуществляется регистрация драйвера путем обращения к функции RegisterBGIDriver. Единственным параметром этой функции является адрес начала драйвера в памяти (@CGADRV). Функция возвращает значение типа Integer, которое служит для контроля правильности завершения процедуры регистрации драйвера: если это значение меньше нуля, обнаружена ошибка, в противном случае функция возвращает номер зарегистрированного драйвера. В примере контролируется правильность регистрации драйвера и, если ошибка не обнаружена, инициируется графический режим работы экрана.
Аналогичным образом можно присоединить к программе стандартные штриховые шрифты (матричный шрифт 8x8 входит в состав модуля Graph и поэтому присоединять его не надо). Присоединение шрифта строится по описанной схеме за тем исключением, что для его регистрации вызывается функция RegisterBGIFont. Например, после преобразования
c:\Pascal\binobj litt.chr litt litt
можно использовать операторы
Procedure Litt;External;
{$L Litt.obj}
.......
if RegisterBGIFont (@litt) < 0 then ...
Обратите внимание: регистрация и драйвера, и шрифтов должна предшествовать инициации графического режима.
Регистрировать можно также драйверы (шрифты), которые не компилируются вместе с программой, а загружаются в динамическую память. Например:
Uses Graph;
var
р: Pointer;
f: file;
begin
Assign(f,'Litt.chr'); {Открываем файл}
Reset(f,1); {LITT.CHR для чтения}
GetMem(p,FileSize(f)) ; {Резервируем для него область кучи
нужного размера}
BlockRead(f,pA,FileSize(f)){Читаем файл}
WriteLn(RegisterBGIFont (p)){Регистрируем шрифт}
end.
Вывод текста
Описываемые ниже стандартные процедуры и функции поддерживают вывод текстовых сообщений в графическом режиме. Это не одно и то же, что использование процедур Write или WriteLn. Дело в том, что специально для графического режима разработаны процедуры, обеспечивающие вывод сообщений различными шрифтами в горизонтальном или вертикальном направлении, с изменением размеров и т.д. Однако в стандартных шрифтах, разработанных для этих целей фирмой Borland, отсутствует кириллица, что исключает вывод русскоязычных сообщений.
С другой стороны, процедуры Write и WriteLn после загрузки в память второй половины таблицы знакогенератора (а эта операция легко реализуется в адаптерах EGA и VGA) способны выводить сообщения с использованием национального алфавита, но не обладают мощными возможностями специальных процедур.
Ниже описываются стандартные средства модуля Graph для вывода текста.
Процедура OutText.
Выводит текстовую строку, начиная с текущего положения указателя. Заголовок:
Procedure OutText(Txt: String);
Здесь Txt - выводимая строка.
При горизонтальном направлении вывода указатель смещается в конец выведенного текста, при вертикальном - не меняет своего положения. Строка выводится в соответствии с установленным стилем и выравниванием. Если текст выходит за границы экрана, то при использовании штриховых шрифтов он отсекается, а в случае стандартного шрифта не выводится.
Процедура OutTextXY.
Выводит строку, начиная с заданного места. Заголовок:
Procedure OutTextXY (X,Y: Integer; Txt: String);
Здесь X, Y - координаты точки вывода; Txt - выводимая строка. Отличается от процедуры OutText только координатами вывода. Указатель не меняет своего положения.
Процедура SetTextStyle.
Устанавливает стиль текстового вывода на графический экран. Заголовок:
Procedure SetTextStyle(Font,Direct,Size: Word);
Здесь Font - код (номер) шрифта; Direct - код направления; Size - код размера шрифта.
Для указания кода шрифта можно использовать следующие предварительно определенные константы:
const
DefaultFont = 0;{Точечный шрифт 8x8}
TriplexFont = 1;{Утроенный шрифт TRIP.CHR}
SmallFont = 2;{Уменьшенный шрифт LITT.CHR}
SansSerifFont = 3;{Прямой шрифт SANS.CHR}
GothicFont = 4;{Готический шрифт GOTH.CHR}
Замечу, что эти константы определяют все шрифты для версий 4.0, 5.0, 5.5 и 6.0. В версии 7,0 набор шрифтов значительно расширен, однако для новых шрифтов не предусмотрены соответствующие мнемонические константы. В этой версии помимо перечисленных Вы можете при обращении к SetTextStyle использовать такие номера шрифтов:
Шрифт DefaultFont входит в модуль Graph и доступен в любой момент. Это -единственный матричный шрифт, т.е. его символы создаются из матриц 8x8 пикселей. Все остальные шрифты - векторные: их элементы формируются как совокупность векторов (штрихов), характеризующихся направлением и размером. Векторные шрифты отличаются более богатыми изобразительными возможностями, но главная их особенность заключается в легкости изменения размеров без существенного ухудшения качества изображения. Каждый из этих шрифтов размещается в отдельном дисковом файле. Если Вы собираетесь использовать какой-либо векторный шрифт, соответствующий файл должен находиться в Вашем каталоге, в противном случае вызов этого шрифта игнорируется и подключается стандартный.
Замечу, что шрифт DefaultFont создается графическим драйвером в момент инициации графики на основании анализа текстового шрифта. Поэтому, если Ваш ПК способен выводить кириллицу в текстовом режиме, Вы сможете с помощью этого шрифта выводить русскоязычные сообщения и в графическом режиме. В остальных шрифтах эта возможность появляется только после их модификации.
Для задания направления выдачи текста можно использовать константы:
const
HorizDir = 0;{Слева направо}
VertDir = 1;{Снизу вверх}
Как видим, стандартные процедуры OutText и OutTextXY способны выводить сообщения лишь в двух возможных направлениях - слева направо или снизу вверх. Зная структуру векторных шрифтов, нетрудно построить собственные процедуры вывода, способные выводить сообщения в любом направлении.
Каждый шрифт способен десятикратно изменять свои размеры. Размер выводимых символов кодируется параметром Size, который может иметь значение в диапазоне от 1 до 10 (точечный шрифт - в диапазоне от 1 до 32). Если значение параметра равно 0. устанавливается размер 1, если больше 10 - размер 10. Минимальный размер шрифта. при котором еще отчетливо различаются все его детали, равен 4 (для точечного шрифта - 1).
Следующая программа демонстрирует различные шрифты. Их размер выбран так. чтобы строки имели приблизительно одинаковую высоту. Перед исполнением программы скопируйте все шрифтовые файлы с расширением .CHR в текущий каталог.
Uses Graph, CRT;
const
FontNames: array [1..10] of String[4] =
( 'TRIP' , 'LITT'' SANS ' , ' GOTH ' , 'SCRI ' , ' SIMP ' ,'TSCR ' , ' LOOM ' , ' EURO',' BOLD ' );
Tabl = 50;
Tab2 = 150;
Tab3 =220;
var
d, r, Err,{Переменные для инициации графики}
Y,dY,{Ордината вывода и ее приращение}
Size,{Размер символов}
MaxFont,{Максимальный номер шрифта}
k: Integer;{Номер шрифта}
NT, SizeT, SynibT: String;{Строки вывода}
c: Char;
{-------------------}
Procedure OutTextWithTab ( S1, S2, S3, S4: String);
{Выводит строки S1..S4 с учетом позиций табуляции Таb1..ТаbЗ}
begin
MoveTo( (Tab1-TextWidth(Sl) ) div2,Y);
OutText (S1) ;
MoveTo(Tabl+(Tab2-Tabl-TextWidth(S2)) div2,Y);
OutText (S2) ;
MoveTo(Tab2+(Tab3-Tab2-TextWidth(S3)) div 2,Y);
OutText(S3);
if S4='Symbols' then {Заголовок колонки Symbols}
MoveTo((Tab3+GetMaxX-TextWidth(S4)) div 2,Y)
else {Остальные строки}
MoveTo(Tab3+3,Y);
OutText(S4)
end;
{------------}
begin
{Инициируем графику}
InitGraph(d,r, ' ');
Err := GraphResult; if ErrogrOk then
WriteLn(GraphErrorMsg(Err))
else
begin
{Определяем количество шрифтов:}
{$IFDEF VER70'}
MaxFont := 10; .
{$ELSE}
MaxFont := 4;
{$ENDIF}
SetTextStyle(l,0,4);
Y := 0;
OutTextWi thTab('N','Name',Size','Symbols');
{Определяем высоту Y линии заголовка}
Y := 4*TextHeight('Z') div3;
Line(0,Y,GetMaxX,Y) ;
{Определяем начало Y таблицы и высоту dY каждой строки}
Y := 3*TextHeight('Z') div 2;
dY := (GetMaxY-Y) div (MaxFont);
{Готовим строку символов}
SymbT := '';
for с := 'a' to 'z' do
SymbT := SymbT+c;
{Цикл вывода строк таблицы}
for k := 1 to MaxFont do
begin
Size := 0;
{Увеличиваем размер до тех пор, пока высота строки не станет приблизительно равна dY}
repeat
inc(Size);
SetTextStyle(k,0,Size+1);
until (TextHeight('Z')>=dY) or (Size=10)
or (Textwidth(FontNames[k])>(Tab2-Tab1));
{Готовим номер NT и размер SizeT шрифта}
Str(k,NT);
Str(Size,SizeT);
{Выводим строку таблицы}
SetTextStyle(k,HorizDir,Size);
OutTextWithTab(NT,FontNames[k],SizeT,SymbT);
inc(Y,dY)
end;
{Рисуем линии рамки}
Rectangle(0,0,GetMaxX,GetMaxY);
Line(Tab1,0,Tabl,GetMaxY);
Line(Tab2,0,Tab2,GetMaxY);
Line(Tab3,0,ТаЬЗ,GetMaxY);
{Ждем инициативы пользователя}
ReadLn;
CloseGraph
end
end.
Процедура SetTextJustify.
Задает выравнивание выводимого текста по отношению к текущему положению указателя или к заданным координатам. Заголовок:
Procedure SetTextJustify(Horiz,Vert: Word);
Здесь Horiz - горизонтальное выравнивание; Vert - вертикальное выравнивание. Выравнивание определяет как будет размещаться текст - левее или правее указанного места, выше, ниже или по центру. Здесь можно использовать такие константы:
const
LeftText = 0;{Указатель слева от текста}
CenterText= 1;{Симметрично слева и справа,верху и снизу}
RightText = 2;{Указатель справа от текста}
BottomText= 0;{Указатель снизу от текста}
TopText = 2;{Указатель сверху от текста}
Обратите внимание на неудачные, с моей точки зрения, имена мнемонических констант: если, например, Вы зададите LeftText, что в переводе означает «Левый Текст», сообщение будет расположено справа от текущего положения указателя (при выводе процедурой OutTextXY - справа от заданных координат). Также «наоборот» трактуются и остальные константы.
Следующая программа иллюстрирует различные способы выравнивания относительно центра графического экрана.
Uses Graph, CRT;
var
d, r, e : Integer;
begin
{Инициируем графику}
d := Detect; InitGraph(d,, r, ' ') ;
e := GraphResult;
if e <> grOk then
WriteLn(GraphErrorMsg(e))
else
begin
{Выводим перекрестие линий в центре экрана}
Line(0,GetMaxY div 2,GetMaxX,GetMaxY div 2);
Line(GetMaxX div 2,0,GetMaxX div 2,GetMaxY);
{Располагаем текст справа и сверху от центра}
SetTextStyle(TriplexFont,HorizDir,3);
SetTextJustify(LeftText,BottomText);
OutTextXY (GetMaxX div 2, GetMaxY div 2, 'LeftText,BottomText');
{Располагаем текст слева и снизу}
SetTextJustify (RightText, TopText);
OutTextXY (GetMaxX div 2, GetMaxY div 2,'RightText, TopText');
if ReadKey=#0 then d := ord(ReadKey);
CloseGraph
end
end.
Процедура SetUserCharSize.
Изменяет размер выводимых символов в соответствии с заданными пропорциями. Заголовок:
Procedure SetUserCharSize(XI,X2,Yl,Y2: Word);
Здесь X1...Y2 - выражения типа Word, определяющие пропорции по горизонтали и вертикали.
Процедура применяется только по отношению к векторным шрифтам. Пропорции задают масштабный коэффициент, показывающий во сколько раз увеличится ширина и высота выводимых символов по отношению к стандартно заданным значениям. Коэффициент по горизонтали находится как отношение X1 к Х2, по вертикали - как отношение Y1 к Y2. Чтобы, например, удвоить ширину символов, необходимо задать X1=2 и Х2=1. Стандартный размер символов устанавливается процедурой SetTextStyle, которая отменяет предшествующее ей обращение к SetUserCharSize.
В следующем примере демонстрируется изменение пропорций уменьшенного шрифта.
Uses Graph, CRT;
var
d, r, e : Integer;
begin
{Инициируем графику}
d := Detect; .InitGraph (d, r, '');
e := GraphResult;
if e <> grOk then
WriteLn(GraphErrorMsg(e))
else
begin
MoveTo (0, GetMaxY div 2); SetTextStyle (SmallFont, HorizDir, 5);
SetTextJustify (LeftText, BottomText);
{ Выводим сообщение стандартной высотой 5}
OutText ('Normal Width,');
{Удваиваем ширину шрифта}
SetUserCharSize (2, 1, 1, 1);
OutText (' Double Width, ');
{Удваиваем высоту, возвращаем стандартную ширину}
SetUserCharSize (I, 1, 2, 1) ;
OutText ('Double Height,');
SetUserCharSize (2, 1, 2, 1) ;
OutText (' Double Width and Height');
if ReadKey=#0 then d := ord(ReadKey);
CloseGraph
end
end.
Функция TextWidth.
Возвращает длину в пикселях выводимой текстовой строки. Заголовок:
Function TextWidth (Txjt: String): Word;
Учитываются текущий стиль вывода и коэффициенты изменения размеров символов, заданные соответственно процедурами SetTextStyle и SetUserCharSize.
Функция TextHeight.
Возвращает высоту шрифта в пикселях. Заголовок:
Function TextHeight(Txt: String): Word;
Процедура GetTextSettings.
Возвращает текущий стиль и выравнивание текста. Заголовок:
Procedure GetTextSettins(var Textlnfo: TextSettingsType);
Здесь Textlnfo - переменная типа TextSettingsType, который в модуле Graph определен следующим образом:
type
TextSettingsType = record
Font : Word; {Номер шрифта}
Direction: Word; {Направление}
CharSize : Word; {Код размера}
Horiz : Word; {Горизонтальное выравнивание}
Vert : Word; {Вертикальное выравнивание}
end;
Функция InstallUserFont.
Позволяет программе использовать нестандартный векторный шрифт. Заголовок функции:
Function InstallUserFont(FileName: String): Integer;
Здесь FileName - имя файла, содержащего векторный шрифт.
Как уже говорилось, в стандартную поставку Турбо Паскаля версий 4.0 - 6.0 включены три векторных шрифта, для версии 7.0 - 10. Функция InstallUserFont позволяет расширить этот набор. Функция возвращает идентификационный номер нестандартного шрифта, который может использоваться при обращении к процедуре SetTextStyle.
Функция InstallUserDriver.
Включает нестандартный графический драйвер в систему BGI-драйверов. Заголовок функции:
Function InstallUserDriver(FileName: String; AutoDetectPtr: Pointer): Integer;
Здесь FileName - имя файла, содержащего программу драйвера; AutoDetectPtr - адрес точки входа в специальную процедуру автоопределения типа дисплея, которая в числе прочих процедур должна входить в состав драйвера.
Эта функция расширяет и без того достаточно обширный набор стандартных графических драйверов и предназначена в основном для разработчиков аппаратных средств.
