Часть 4. Использование Турбо Паскаля с языком Ассемблера
Глава 22. Встроенный Ассемблер
Встроенный Ассемблер Турбо Паскаля позволяет вам непосредственно в программах Паскаля записывать код Ассемблера для процессоров 8087/8087 и 80286/80287. Вы, можете конечно, если требуется, чередовать код Паскаля и Ассемблера, можете преобразовать код Ассемблера в машинные инструкции вручную и воспользоваться затем операторами inline, либо выполнять компоновку с файлами .OBJ, которые содержат внешние процедуры и функции (external).
Встроенные операторы Ассемблера представляют собой большое подмножество синтаксиса, поддерживаемого Турбо Ассемблером и Макроассемблером фирмы Microsoft. Встроенный Ассемблер поддерживает все коды операций процессором 8086/8087 и 80286/80287 и некоторые из операций, используемых в выражениях Турбо Ассемблера.
За исключением директив DB (определить байт), DW (определить слово) и DD (определить двойное слово) никакие другие директивы Турбо Ассемблера, типа EQU, STRUC, SEGMENT или MACRO, встроенным Ассемблером не поддерживаются. Однако, операции, реализуемые с помощью директив Турбо Ассемблера, близко соответствуют конструкциям Турбо Паскаля. Например, большинство директив EQU соответствуют описаниям Турбо Паскаля const, var и type, директива PROC - описаниям procedure и function, а директива STRUC - типам record Турбо Паскаля. Фактически, встроенный Ассемблер Турбо Паскаля можно рассматривать, как компилятор языка Ассемблера, использующий для всех описаний синтаксис Паскаля.
Оператор asm
Встроенный Ассемблер становится доступным с помощью операторов asm. Оператор asm имеет следующий синтаксис:
asm оператор_Ассемблера < разделитель оператор_Ассемблера > end
где "оператор_Ассемблера" представляет собой оператор языка Ассемблера, а "разделитель " - это точка с запятой, новая строка или комментарий Паскаля. Приведем некоторые примеры операторов asm:
if EnableInts then
asm
sti
end
else
asm
cli
end;
asm
mov ax,Left; xchg ax,Right; mov Left,ax;
end;
asm
mov ah,0 { считать с клавиатуры код функции }
int 16H { для чтения клавиши вызвать BIOS }
mov CharCode,al { сохранить код ASCII }
mov ScanCode,ah { сохранить код опроса }
end;
asm
push ds { сохранить DS }
lds si,Source { загрузить указатель источника }
les di,Dest { загрузить указатель приемника }
mov cx,Count { загрузить размер блока }
cld { переместить }
rep movsb { скопировать блок }
pop ds { восстановить DS }
end;
Заметим, что на одной строке можно разместить несколько операторов Ассемблера, разделив их точками с запятой. Кроме того следует отметить, что если операторы Ассемблера размещаются на разных строках, разделять их точками с запятой не требуется. Заметим также, что точка с запятой не говорит о том, что остальная часть строки представляет собой комментарий. Комментарии следует записывать, используя синтаксис Паскаля: с помощью { и } или (* и *).
Использование регистров
Правила использования регистров в операторе asm в основном совпадают с этими правилами для внешних процедур и функций. Оператор asm должен сохранять регистры BP, SP, SS и DS, но может свободно изменять AX, BX, CX, DX, SI, DI, ES и регистр флагов. На входе в оператор asm регистр BP указывает на текущий кадр стека, SP указывает на вершину стека, регистр SS содержит адрес сегмента стека, а DS - адрес сегмента данных. За исключением регистров BP, SP, SS и DS, оператор asm не может делать никаких предположений относительно содержимого регистров на входе в этот оператор.
Синтаксис операторa Ассемблера
Оператор Ассемблера имеет следующий синтаксис:
[ метка":" ] < префикс > [код_операции [операнд < "," операнд >]] где "метка" - это идентификатор метки, "префикс" - префикс кода операции Ассемблера. "Код_операции" - код инструкции или директива Ассемблера, а "операнд" - выражение Ассемблера.
Между операторами Ассемблера (но не в них) допускается включать комментарии. Допустимо, например, следующее:
asm
mov ax,1 { начальное значение }
mov cx,100 { счетчик }
end;
однако следущая запись ошибочна:
asm
mov { начальное значение } ax,1
mov cx, { счетчик } 100
end;
Метки
Метки в Ассемблере определяются также, как в Паскале: перед оператором записывается идентификатор метки и двоеточие. Как и в Паскале, метки в Ассемблере должны описываться в объявлении label того блока, который содержит оператор asm. Однако из этого правила есть одно исключение. Это локальные метки.
Локальные метки - это метки, которые начинаются с символа @. Поскольку этот символ не может быть частью идентификатора Паскаля, такие локальные метки автоматически ограничиваются использованием их в операторах asm. Локальная метка известна только в определяющем ее операторе asm (то есть область действия локальной метки начинается от ключевого слова asm и заканчивается ключевым словом end оператора asm, который ее содержит).
В отличие от обычной метки, локальную метку перед ее использованием не требуется описывать в объявлении label.
Идентификатор локальной метки состоит из символа @, за которым следует одна или более букв (A..Z) цифр (0..9) символов подчеркивания или символов @. Как и все метки, идентификатор завершается двоеточием.
Следующий фрагмент программы показывает использование в операторах asm обычных и локальных меток:
label Start, Stop;
...
begin
asm
Start:
...
jz Stop
@1:
.
.
loop @1
end;
asm
@1:
.
.
jc @2
.
.
jmp @1
@2:
end;
goto Start;
Stop:
end;
Отметим, что обычные метки могут определяться в операторе asm, а ссылаться на них можно вне оператора asm и наоборот. Кроме того отметим, что одно и то же имя локальной метки можно использовать в разных операторах asm.
Префиксы операций
Встроенный Ассемблер поддерживает следующие префиксы кодов операций:
─────────────────────────────────────────────────────────────────
LOCK блокировка шины
REP повторение строковой операции
REPE/REPZ повторение строковой операции, пока равно/пока ноль
REPNE/REPNZ повторение строковой операции, пока не равно/пока
не ноль
SEGCS переопределение сегмента CS (сегмента кода)
SEGDS переопределение сегмента DS (сегмента данных)
SEGES переопределение сегмента ES (дополнительного
сегмента)
SEGSS переопределение сегмента SS (сегмента стека)
─────────────────────────────────────────────────────────────────
Перед инструкцией Ассемблера может указываться 0 или более этих префиксов. Например:
asm
rep movsb { переместить CX байт из DS:SI в ES:DI }
SEGES lodsw { загрузить слово из ES:SI }
SEGES mov ax,[bx] { то же, что MOV AX,CS:[BX] }
SEGES { влияет на следующий оператор Ассемблера }
mov WORD PTR [DI},0 { становится MOV WORD PTR ES:[DI],0 }
Заметим, что префикс операции можно задавать без кода инструкции в данной строке. В этом случае префикс операции влияет на следующий оператор Ассемблера.
Коды инструкции редко имеют более одного префикса. В общем случае имеет смысл не более трех префиксов (LOCK, затем SEGxx, затем REPxx). Несколько префиксов следует использовать аккуратно, учитывая их порядок. Некоторые процессоры 80х86 не могут корректно обрабатывать все их сочетания. Например, если в процессе повторения строковой инструкции происходит прерывание, процессор 8086 или 8088 "помнит" только префикс REPxx, поэтому префиксы LOCK или SEGxx перед префиксом REPxx лучше не указывать.
Коды инструкций
Встроенный Ассемблер поддерживает инструкции процессоров 8086/8087 и 80286/80287. Инструкции процессора 8087 доступны только в состоянии {$N+} (разрешено использование арифметического сопроцессора), а инструкции процессора 80286 - только в состоянии {$G+} (разрешена генерация кода для процессора 80286), а инструкции сопроцессора 80287 - только в состоянии {$G+,N+}.
Полное описание каждой инструкции содержится в справочных материалах по процессорам 80х86 и 80х87.
Размер инструкции RET
Инструкция REP генерирует код машинной инструкции возврата ближнего (NEAR) или дальнего (FAR) типа, в зависимости от модели вызова текущей процедуры или функции.
procedure NearProc; near;
begin
asm
ret { генерируется ближний возврат }
end;
end;
procedure FarProc; far
begin
asm
ret { генерируется дальний возврат }
end;
end;
С другой стороны, инструкции RETN и RETF всегда генерируют ближний или дальний возврат соответственно, независимо от модели вызова текущей процедуры или функции.
Автоматическое определение размера перехода
Если не указывается противное, встроенный Ассемблер оптимизирует инструкции перехода, автоматически выбирая наиболее короткую, и, следовательно, наиболее эффективную форму инструкции перехода. Такое автоматическое определение размера перехода применяется к инструкции безусловного перехода (JMP) и всем инструкциям условного перехода, когда переход выполняется на метку, а не на процедуру или функцию.
Для инструкции безусловного перехода встроенный Ассемблер генерирует короткий переход (один байт кода операции, за которым следует один байт смещения), если расстояние до целевой метки находится в границах от -128 до 127 байт. В противном случае генерируется ближний переход (один байт кода операции, за которым следуют два байта смещения).
Для инструкций условного перехода короткий переход (один байт кода операции, за которым следует один байт смещения) генерируется, если расстояние до целевой метки находится в пределах от -128 до 127 байт, в противном случае встроенный Ассемблер генерирует короткий переход с обратным условием, который выполняет переход на целевую метку через ближний переход (в общем случае 5 байт). Например, оператор Ассемблера:
JC Stop
где метка Stop не находится в границах короткого перехода, преобразуется в последовательность машинных кодов, соответствующих инструкциям:
jnc Skip
jmp Stop
Skip:
Переходы на точки входа в процедуру или функцию всегда имеют ближний или дальний тип (но не короткий), а условные переходы на процедуру или функцию не допускаются. Вы можете указать встроенному Ассемблеру, что нужно генерировать ближний или дальний переход, используя конструкцию NEAR PTR или FAR PTR. Например, операторы Ассемблера:
jmp NEAR PTR Stop
jmp FAR PTR Stop
будут всегда генерировать соответственно ближний и дальний переход, даже если на метку Stop можно перейти с помощью короткого перехода.
Директивы Ассемблера
Встроенный Ассемблер Турбо Паскаля поддерживает три директивы Ассемблера: DB (определить байт), DW (определить слово) и DD (определить двойное слово). Каждая из них генерирует данные, соответствующие разделенным запятым операндам, которые следуют за директивой.
Директива DB генерирует последовательность байт. Каждый операнд может представлять собой выражение-константу со значением от -128 до 255, или строку символов любой длины. Выражение-константа генерирует 1 байт кода, а строки генерируют последовательность байт со значениями, соответсвующим коду ASCII каждого символа.
Директива DW генерирует последовательность слов. Каждый операнд может представлять собой выражение-константу со значением от -32768 до 65535, или адресное выражение. Для адресного выражения встроенный Ассемблер генерирует указатель ближнего типа, то есть слово, содержащие смещения адреса.
Директива DD герерирует последовательность двойных слов. Каждый операнд может представлять собой выражение-константу со значением от -2147483648 до 4294967295 или адресное выражение. Для адресного выражения встроенный Ассемблер генерирует указатель дальнего типа, то есть слово, содержащие смещения адреса, за которым следует слово, содержащее сегментную часть адреса.
Данные, генерируемые по директивам DB, DW и DD, всегда записываются в сегмент кода, аналогично коду, генерируемому другими операторами встроенного Ассемблера. Чтобы сгенерировать инициализированные или неинициализированные данные в сегменте данных, вам следует использовать обычные описания Паскаля типа var или const.
Приведем некоторые примеры директив DB, DW и DD:
asm
DB 00FH { 1 байт }
DB 0,99 { 2 байта }
DB 'A' { Ord('A) }
DB 'Пример',0DH,OAH { строка, за которой
следуют возврат каретки и перевод строки }
DB 12,"Turbo Pascal" { строка Паскаля }
DW 0FFFFH { 1 слово }
DW 0,9999 { 2 слова }
DW 'A' { эквивалентно DB 'A',0 }
DW 'BA' { эквивалентно DB 'A','B' }
DW MyVar { смещение MyVar }
DW MyProc { смещение MyProc }
DD 0FFFFFFFH { 1 двойное слово }
DD 0,99999999 { 2 двойных слова }
DD 'A' { эквивалентно DB 'A',0,0,0 }
DD 'DBCA' { эквивалентно DS 'A','B','C','D' }
DD MyVar { указатель на MyVar }
DD MyProc { указатель на MyProc }
end;
В Турбо Ассемблере указание перед идентификатором директивы DB, DW или DD приводит к генерации в том месте, где указана директива, переменной размером в байт, слово или двойное слово. Например, Турбо Ассемблер допускает следующее:
ByteVar DB ?
WordVar DW ?
...
mov al,ByteVar
mov bx,WordVar
Встроенный Ассемблер не поддерживает такие описания переменных. В Турбо Паскале единственным видом идентификатора, который можно определить в операторе встроенного Ассемблера, является метка. Все переменные должны описываться с помощью синтаксиса Паскаля, и предыдущая конструкция соответствует следующему:
var
ByteVar: Byte;
WordWat: Word;
...
asm
mov al,ByteVar
mov bx,WordVar
end;
Операнды
Операнды встроенного Ассемблера представляют собой выражения, которые состоят из сочетания констант, регистров, идентификаторов и операций. Хотя выражения встроенного Ассемблера формируются с использованием тех же основных принципов, что и выражения Паскаля, имеется ряд важных отличий, которые необходимо пояснить.
Во встроенном Ассемблере предопределенный смысл имеют следующие зарезервированные слова:
AH CL FAR SEG
AL CS HIGH SHL
AND CX LOW SHR
AX DH MOD SI
BH DI NEAR SP
BL DL NOT SS
BP DS OFFSET ST
BX DWORD OR TBYTE
BYTE DX PTR TYPE
CH ES WQORD WORD
XOR
Зарезервированные слова всегда имеют больший приоритет, чем определенные пользователем идентификаторы. Например, во фрагменте программы:
var
ch: Char;
...
asm
mov ch,1
end;
1 будет загружаться в регистр CH, а не в переменную CH. Для доступа к определенному пользователем имени нужно использовать амперсанд - операцию переопределения идентификатора (&).
asm
mov &ch,1
end;
Мы настоятельно рекомендуем не использовать определенные пользователем идентификаторы с теми же именами, что и зарезервированные слова встроенного Ассемблера, поскольку такая путаница имен может легко приводить к очень трудноуловимым ошибкам.
Выражения
Встроенный Ассемблер вычисляет все выражения, как 32-разрядные значения-указатели. Он не поддерживает значения с плавающей точкой и строковые значения, за исключением строковых констант.
Выражения встроенного Ассемблера строятся из элементов выражений и операций, а каждая операция имеет соответствующий класс выражения и тип выражения. Эти принципы поясняются в следующий разделах.
Различия между выражениями Паскаля и Ассемблера
Большинство важных различий между выражениями Паскаля и выражениями встроенного Ассемблера состоит в том, что выражения встроенного Ассемблера должны при вычислении сводиться к значению-константе, другими словами, к значению, которое можно вычислить на этапе компиляции. Например, с учетом описаний:
const
X = 10;
Y = 20;
var
Z: Integer;
следующий оператор является во встроенном Ассемблере допустимым:
asm
mov Z,X+Y
end;
Поскольку X и Y - это константы, выражение X + Y представляет собой просто удобный способ записи константы 30, и полученная в результате инструкция помещает непосредственное значение 30 в переменную Z размером в слово. Но если вы опишете X и Y, как переменные:
var
X, Y: Integer;
то встроенный Ассемблер не сможет на этапе компиляции вычислить значение X + Y. Корректной конструкцией встроенного Ассемблера в этом случае будет:
asm
mov ax,X
add ax,Y
mov Z,ax
end;
Другим важным отличием выражений Паскаля и встроенного Ассемблера является способ интерпретации переменных. В выражении Паскаля ссылка не переменную интерпретируется, как содержимое переменной, но в выражении встроенного Ассемблера ссылка на переменную означает адрес переменной. Например, в Паскале выражение X + 4, где X - переменная, означает содержимое X, плюс 4, а во встроенном Ассемблере это означает содержимое в слове по адресу на 4 байта выше, чем адрес X. Поэтому, хотя допустима запись:
asm
mov ax,X+4
end;
этот код не загружает значения X плюс 4 в регистр AX, а загружает значение слова, записанного через 4 байта после X. Корректной записью сложения 4 с содержимым X будет:
asm
MOV AX,X
ADD AX,4
end;
Элементы выражений
Основными элементами выражения являются константы, регистры и идентификаторы.
Константы
Встроенный Ассемблер поддерживает два типа констант: числовые константы и строковые константы.
Числовые константы
Числовые константы должны быть целыми и принимать значения в диапазоне от -2147483648 до 4294967295.
По умолчанию числовые константы являются десятичными, однако встроенный Ассемблер поддерживает также двоичные, восьмеричные и шестнадцатиричные константы. Двоичное представление обозначается записью после числа буквы B, восьмеричное - записью буквы O, а шестнадцатиричное - записью после числа H или указанием перед числом символа $.
В выражениях Паскаля суффиксы B, O и H не поддерживаются. Выражения Паскаля допускают только десятичную (по умолчанию) и шестнадцатиричную запись (используется префикс $).
Числовые константы должны начинаться с одной из цифр или символа $. Таким образом, когда вы записываете шестнадцатиричную константу с помощью суффикса H, то если первой значащей цифрой является одна из шестнадцатиричных цифр от A до F, то требуется указать дополнительный ноль. Например, 0BAD4H и $BAD4 представляют собой шестнадцатиричные константы, а BAD4H - это идентификатор, так как он начинается с буквы, а не с цифры.
Строковые константы
Строковые константы должны заключаться в одиночные или двойные кавычки. Указание двух последовательных кавычек одного типа в качестве закрывающих кавычекю считается за один символ. Приведем некоторые примеры строковых констант:
'Z'
'Turbo Pascal'
"That's all folks"
"That's all falks," he said.'
'100
'"'
"'"
Заметим, что в четвертой строке для обозначения одиночного символа двойных кавычек используется две последовательных одиночных кавычки.
В директивах DB допускаются строковые константы любой длины. Это приводит к выделению последовательности байт, содержащих значения (ASCII) символов строки. Во всех других случаях строковые константы не могут превышать четырех символов и обозначают числовое значение, которое может участвовать в выражениях. Числовое значение строки вычисляется следующим образом:
Ord(Ch1) + Ord(Ch2) shl 8 + Ord(Ch3) shl 16 + Ord(Ch4) shl 24
где Ch1 - это самый правый (последний) символ, а Ch4 - самый левый (первый) символ. Если строка короче 4 символов, то самые левые (первые) символы считаются нулевыми. Приведем некоторые примеры строковых констант и их значений:
'a' 00000061H
'ba' 00006261H
'cba' 00636261H
'dcba' 64636261H
'a' 00006120H
' a' 20202061H
'a'*2 000000E2H
'a'-'A' 00000020H
not 'a' FFFFFF9EH
Регистры
Следующие зарезервированные идентификаторы обозначают регистры ЦП:
──────────────────────────────────────────────────────────────
16-разрядные регистры общего назначения: AX BX CX DX
8-разрядные младшие полурегистры: AL BL CL DL
8-разрядные старшие полурегистры: AH BH CH DH
16-разрядные указатели или индексные регистры: SP BP SI DI
16-разрядные сегментные регистры: CS DS SS ES
регистр стека процессора 8087 ST
──────────────────────────────────────────────────────────────
Когда операнд состоит исключительно из имени регистра, он называется регистровым операндом. Все регистры можно использовать, как регистровые операнды. Кроме того, некоторые регистры могут использоваться в других контекстах.
Базовые регистры (BX или BP) и индексные регистры (SI или DI) можно записывать в квадратных скобках для указания индексации. Допустимым сочетанием базового/индексного регистра являются следующие сочетания: [BX], [BP], [SI], [DI], [BX+SI], [BX+DI], [BP+SI] и [BP+DI].
Сегментные регистры (ES, CS, SS и DS) могут использоваться вместе с операцией переопределения сегмента (:) и указывать на другой сегмент, отличный от того, который процессор выбирает по умолчанию.
Идентификатор ST обозначает верхний регистр стека регистров с плавающей точкой сопроцессора 8087. На каждый из 8 регистров с плавающей точкой можно ссылаться с помощью ST(x), где x - константа от 0 до 7, указывающая на расстояние от вершины стека регистров.
Идентификаторы
Встроенный Ассемблер позволяет в выражениях Ассемблера получить доступ ко всем идентификаторам Паскаля, включая метки, константы, типы, переменные, процедуры и функции. Кроме того, во встроенном Ассемблере реализованы следующие специальные идентификаторы:
@Code @Data @Result
Идентификаторы @Code и @Data представляют текущие сегменты кода и данных соответственно. Их следует использовать только в сочетании с операцией SEG:
asm
mov ax,SEG @Data
mov ds,ax
end;
Идентификатор @Result в операторной части функции представляет переменную - результат функции. Например, в функции:
function Sum(X, Y: Integer): Integer;
begin
Sum := X + Y;
end;
в операторе, присваивающем результат функции переменной Sum, можно было бы при записи на встроенном Ассемблере использовать переменную @Result:
function Sum(X, Y: Integer): Integer;
begin
asm
mov ax,X
add ax,Y
mov @Result,ax
end;
end;
В выражениях встроенного Ассемблера нельзя использовать следующие идентификаторы:
- стандартные процедуры и функции (например, WriteLn, Chr);
- специальные массивы Mem, MemW, MemL, Port, PortW;
- строки, значения с плавающей точкой и константы множественного типа;
- процедуры и функции, описанные с директивой inline;
- метки, которые не описаны в текущем блоке;
- идентификатор @Result вне функции.
В Таблице 22.1 приведены значение, класс и тип различного вида идентификаторов, которые можно использовать в выражениях встроенного Ассемблера (классы и типы выражений описываются в следующем разделе):
Таблица 22.1 Значения, классы и типы идентификаторов
─────────────────────────────────────────────────────────────────
Идентификатор Значение Класс Тип
─────────────────────────────────────────────────────────────────
Метка Адрес метки Память SHORT
Константа Значение константы Непосредственный Размер типа
Тип 0 Память Размер типа
Поле Смещение поля Память Размер типа
Переменная Адрес переменной Память Размер типа
Процедура Адрес процедуры Память NEAR или FAR
Функция Адрес функции Память NEAR или FAR
Модуль 0 Непосредственный 0
@Code Адрес сегмента кода Память 0FFF0H
@Data Адрес сегмента данных Память 0FFF0H
@Result Смещение переменной- Память Размер типа
результата
─────────────────────────────────────────────────────────────────
Локальные переменные (переменные, описанные в процедурах и функциях) всегда распределяются в стеке и доступны относительно SS:BP, а значение идентификатора локальной переменной представляет собой ее смещение со знаком от SS:BP. Ассемблер автоматически добавляет [BP] к ссылкам на локальные переменные. Например, с учетом описаний:
procedure Test;
var
Count: Integer;
инструкции:
asm
mov ax,Count
end;
ассемблируются в MOV AX,[BP-2].
Встроенный Ассемблер всегда интерпретирует параметр-переменную, как 32-разрядный указатель, а размер параметра-переменной всегда равен 4 (размеру 32-разрядного указателя). В Паскале синтаксис для доступа к параметру-переменной и к значению параметра одинаков. В случае встроенного Ассемблера это не так. Поэтому для доступа к содержимому параметра-переменной вам сначала придется загрузить 32-разрядный указатель, а затем обратиться к ячейке, на которую он указывает. Например, если X и Y - параметры-переменные приведенной выше функции Sum, то она может выглядеть следующим образом:
function Sum(var X, Y: Integer): Integer;
begin
asm
les bx,X
mov ax,es:[bx]
les bx,Y
add ax,es:[bx]
mov @Result,ax
end;
end;
Некоторые идентификаторы, такие, как переменные типа запись, имеют область действия, позволяющую обращаться к ним с помощью операции выбора элементы структуры - точки (.). Например, с учетом описаний:
type
Point = record
X, Y: Integer;
end;
Rect = record
A, B: Point;
end;
var
P: Point;
R: Rect;
для доступа к полям в переменных P и R можно использовать следующие конструкции:
asm
mov ax,P.X
mov dx,P.Y
mov cx,R.A.X
mov bx,R.B.Y
end;
Для непосредственного построения переменной можно использовать идентификатор типа. Каждая из приведенных ниже инструкций генерирует один и тот же машинный код, загружающий в AX ES:[DI+4]:
asm
mov ax,(Rect PTR es:[di]).B.X
mov ax,Rect(es:[di].B.X
mov ax,es:Rect[di].B.X
mov ax,Rect[es:di].B.X
mov ax,es:[di].Rect.B.X
end;
Область действия задается типом, полем и идентификатором переменной типа записи или объектного типа. Кроме того, идентификатор модуля открывает область действия конкретного модуля (как полностью уточненный идентификатор в Паскале).
Классы выражений