                           Ч А С Т Ь  4.

          ИСПОЛЬЗОВАНИЕ TURBO PASCAL С ЯЗЫКОМ АССЕМБЛЕРА.

                             ГЛАВА 22.

                       ВСТРОЕННЫЙ АССЕМБЛЕР.

     Встроенный Ассемблер  Turbo  Pascal   позволяет   Вам   писать
ассемблерный код   для   8086/8087  и  80286/80287  прямо  в  Ваших
программах на  Паскале.  Конечно,  Вы  еще  можете  преобразовывать
ассемблерные инструкции  в машинный код вручную для использования в
операторах inline  или  подредактироватьь   .OBJ   файлы,   которые
содержат external  процедуры  и функции,  когда Вы хотите смешивать
Паскаль и Ассемблер.

     Встроенный Ассемблер    реализует     большое     подмножество
синтаксиса, поддерживаемого   Turbo  Assembler  и  макроассемблером
Microsoft. Встроенный Ассемблер поддерживает все коды операций 8086
/8087 и   80286/80287   и   почти  все  операторы  выражений  Turbo
Assembler.

     За исключением DB,  DW,  DD (определить байт,  слово и двойное
слово) ни  одна из директив Turbo Assembler,  таких как EQU,  PROC,
STRUC, SEGMENT и MACRO не  поддерживается  встроенным  Ассемблером.
Однако операции,  поддерживаемые  директивами  Turbo Assembler,  во
многом соответствуют  соответствующим  конструкциям  Turbo  Pascal.
Например большинство  директив EQU соответствует объявлениям const,
var и type в Turbo Pascal, директива PROC соответствует объявлениям
procedure и function, а директива STRUC соответсвует типам record в
Turbo Pascal.  В  действительности  можно   думать   о   встроенном
Ассемблере Turbo  Pascal,  как  о  компиляторе  с  языка Ассемблер,
который использует синтаксис Паскаля для всех объявлений.


                           Оператор asm.

     К встроенному   Ассемблеру   обращаются  через  оператор  asm.
Синтаксис оператора asm:

     asm AsmStatement < Separator AsmStatement > end

     где AsmStatement - это ассемблерный оператор,  а  Separator  -
это ";",  новая строка или комментарий Паскаля.  Несколько примеров
оператора 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
       mov    CharCode,al
       mov    ScanCode,ah
     end;

     asm
       push   ds
       lds    si,Source
       les    di,Dest
       mov    cx,Count
       cld
       rep    movsb
       pop    ds
     end;

     Заметим, что  на  одной  строке  можно   поместить   несколько
операторов Ассемблера,  разделенных ";". Заметим так же, что ";" не
требуется между двумя ассемблерными операторами, если они на разных
строках. Наконец  заметим,  что  ";"  не указывает,  что оставшаяся
часть строки - комментарий,  т.к. комментарий должен быть написан в
стиле Паскаля, используя {} и (* *).


                     Использование регистров.

     Правила использования регистров в операторе asm  в общем такие
же, как  и  в  external процедурах и функциях.  Оператор asm должен
сохранять регистры BP,  SP,  SS и  DS  и  может  свободно  изменять
регистры AX, BX, CX, DX, SI, DI, ES и Flags. На входе оператора asm
BP указывает на текущий стек,  SP указывает на  вершину  стека,  SS
содержит сегментный адрес сегмента стека,  а DS содержит сегментный
адрес сегмента данных. За исключением BP, SP, SS и DS, оператор asm
не должен делать предположений о содержимом остальных регистров при
входе в оператор.


                Синтаксис ассемблерных операторов.

     Синтаксис ассемблерного оператора:

    [ Label ":" ] < Prefix > [ Opcode [ Operand < "," Operand > ] ]

     где Label - идентификатор метки, Prefix - код префикса, Opcode
- директива или инструкция  Ассемблера  и  Opеrand  -  ассемблерное
выражение.

     Комментарии разрешены  между  ассемблерными операторами, но не
внутри их. Например, это разрешено:

     asm
       mov   ax,1        {Initial value}
       mov   cx,100      {Count}
     end;

     а это нет:

     asm
       mov   {Initial value} ax,1
       mov   cx,{Count} 100
     end;


                              Метки.

     Метки определяются   в  Ассемблере  так  же,  как  в  Паскале,
записывая идентификатор метки с двоеточием до оператора;  как  и  в
Паскале, метки,  определенные  в  Ассемблере,  должны объявляться в
декларативной части label в блоке,  содержащем оператор 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         Повтор строковой операции пока =/0
     REPNE/REPNZ       Повтор строковой операции пока (не =)/(не 0)
     SEGCS             Перекрытие CS (сегмент кода)
     SEGDS             Перекрытие DS (сегмент данных)
     SEGES             Перекрытие ES (экстра сегмент)
     SEGSS             Перекрытие SS (сегмент стека)
———————————————————————————————————————————————————————————————————

     С ассемблерной инструкцией могут  быть  указаны  0  или  более
префиксов. Например:

     asm
       rep    movsb
       SEGES  lodsw
       SEGCS  mov ax,[bx]
       SEGES
       mov    WORD PTR [DI],0
     end;

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

     Код инструкции  очень  редко  имеет более одного префикса и не
может быть указано более  3  префиксов  (LOC,  затем  SEGxx,  затем
REPxx). Будьте внимательны при использовании нескольких префиксов -
их порядок важен и некоторые процессоры 80х86 не могут обрабатывать
все комбинации  правильно.  Например,  8086  или 8088 помнят только
префикс REPxx,  если  в  середине  строковой  инструкции  возникает
прерывание. Поэтому  префиксы  LOC  и  SEGxx  не могут быть надежно
закодированы до REPxx в строковой инструкции.


                         Коды инструкций.

     Встроенный Ассемблер    поддерживает   все   коды   инструкций
8086/8087 и 80286/80287. Коды 8087 допустимы только в состоянии {$N
+} (числовой  процессор  разрешен),  коды  80286 допустимы только в
состоянии {$G+} ( генерация кода 80286  разрешена),  и  коды  80287
разрешены только в состоянии {$G+,N+}.

     Полное описание этих инструкций см.  в руководствах по 80х86 и
80х87.


                      Размер инструкции RET.

     Инструкция RET   генерирует   ближний   или   дальний  возврат
в зависимости от модели вызова текущей процедуры или функции.

     procedure NearProc; near;
     begin
       asm
         ret     {генерирует ближний вызов}
       end;
     end;

     procedure FarProc; far;
     begin
       asm
         ret     {генерирует дальний вызов}
       end;
     end;

     С другой стороны,  инструкции RETN и  RETF  всегда  генерируют
ближний возврат и дальний возврат, вне зависимости от модели вызова
текущей процедуры или функции.


                  Автоматический размер перехода.

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

     Для инструкции безусловного перехода JMP  встроенный Ассемблер
генерирует короткий   переход  (1  байт  кода  операции  и  1  байт
смещения), если расстояние до  метки  назначения  внутри  диапазона
от -128  до  127  байт;  иначе генерируется ближний переход (1 байт
кода операции и 2 байта смещения).

     Для инструкции  условного   перехода   генерируется   короткий
переход (1  байт кода и 1 байт смещения),  если расстояние до метки
назначения от -128 до 127 байт; иначе генерируется короткий переход
с обратным  условием,  который  обходит  ближний  переход  на метку
назначения (5 байт в итоге). Например оператор

     JC Stop

     где Stop не внутри диапазона короткого перехода, преобразуется
в машинный код

     jnc Skip
     jmp Stop
     Skip:

     Переходы на   точки  входа  процедур  и  функций  всегда  либо
ближние, либо дальние,  и никогда не короткие,  а условные перехода
на процедуры и функции не разрешены.  Вы можете указать встроенному
Ассемблеру генерировать безусловный ближний или дальний  переход на
метку, используя   конструкцию  NEAR  PTR  или  FAR  PTR.  Например
операторы

     jmp NEAR PTR Stop
     jmp FAR PTR Stop

    всегда генерируют  ближний  и  дальний переходы соответственно,
даже если Stop внутри диапазона короткого перехода.


                       Директивы Ассемблера.

     Встроенный Ассемблер  Turbo  Pascal  поддерживает  3 директивы
Ассемблера:

     DB, DW, DD (определить байт, слово и двойное слово)

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

     Директива DB   генерирует   последовательность   байт.  Каждый
операнд может быть константным выражением со значением от  -128  до
255 или   строкой   символов  любой  длины.  Константное  выражение
генерирует 1 байт кода, а строка генерирует последовательность байт
со значениями, соответствующими ASCII кода каждого символа.

     Директива DW   генерирует   последовательность   слов.  Каждый
операнд может быть константным выражением со значением от -32768 до
65535 или  адресным выражением.  Для адресного выражения встроенный
Ассемблер генерирует ближний указатель,  который содержит  смещение
этого адреса.

     Директива DD   генерирует   последовательность  двойных  слов.
Каждый операнд может быть константным выражением  со  значением  от
-2,147,483,648 до   4,294,967,295   или  адресным  выражением.  Для
адресного  выражения  встроенный   Ассемблер   генерирует   дальний
указатель, который содержит и смещение и сегментную часть адреса.

     Данные, генерируемые директивами DB,  DW, DD всегда хранятся в
кодовом сегменте так же,  как код, генерируемый другими операторами
встроенного Ассемблера. Чтобы генерировать неинициализированные или
инициализированные данные, в сегменте данных Вы должны использовать
обычные объявления Var или Const Паскаля.

     Примеры директив DB, DW, DD:

     asm
       DB   0FFH
       DB   0,99
       DB   'A'
       DB   'Hello world...',0DH,0AH
       DB   12,"Turbo Pascal"
       DW   0FFFFH
       DW   0,9999
       DW   'A'
       DW   'BA'
       DW   MyVar
       DW   MyProc
       DD   0FFFFFFFFH
       DD   0,999999999
       DD   'A'
       DD   'DCBA'
       DD   MyVar
       DD   MyProc
     end;

     Примечание: В Turbo Assembler, когда идентификатор стоит перед
директивой DB,  DW и  DD,  это  приводит  к  объявлению  переменной
размером в байт,  слово или двойное слово по адресу этой директивы.
Например, Turbo Assembler разрешает:

     ByteVar   DB    ?
     WordVar   DW    ?
     ...
               mov   al,ByteVar
               mov   bx,WordVar

     Встроенный Ассемблер   не   поддерживает   такое    объявление
переменных. В Turbo Pascal единственный символ,  который может быть
определен в операторе  встроенного  Ассемблера  -  это  метка.  Все
переменные должны   быть   объявлены  с  использованием  синтаксиса
Паскаля и предыдущий пример соответствует:

     var
       ByteVar: Byte;
       WordVar: 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           QWORD         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 во время
компиляции. Встроенный    Ассемблер   для   пересылки   суммы   X+Y
генерирует:

     asm
       mov   ax,X
       add   ax,Y
       mov   Z,ax
     end;

     Другое важное отличие между выражениями Паскаля  и встроенного
Ассемблера в способе интерпретации переменных.  В выражении Паскаля
ссылка на переменную интерпретируется как содержимое  переменной, а
в выражении  встроенного  Ассемблера  ссылка на переменную означает
адрес этой переменной.  Например,  в Паскале выражение X+4, где Х -
переменная, означает содержимое X+4, а во встроенном Ассемблере это
означает содержимое слова с адресом на 4 байта выше,  чем адрес  Х.
Так даже если Вы можете написать

     asm
       mov   ax,X+4
     end;

     этот код не загружает значение Х+4 в AX,  а загружает значение
слова, хранящегося по адресу на 4 байта выше Х.  Корректный  способ
добавить 4 к содержимому Х:

     asm
       MOV   AX,X
       ADD   AX,4
     end;


                        Элементы выражения.

     Основные элементы  выражения  -  это  константы,  регистры   и
символы.


                            Константы.

     Встроенный Ассемблер поддерживает 2  типа  констант:  числовые
константы и строковые константы.


                        Числовые константы.

     Числовые константы должны быть целыми  и  их  значения  должны
быть в диапазоне от -2,147,483,648 до 4,294,967,295.

     Числовые константы по умолчанию используют десятичную нотацию,
но встроенный Ассемблер так же поддерживает двоичную, 8-ричную и 16
-ричную нотации.  Двоичная  нотация  выбирается  написанием В после
числа, 8-ричная нотация выбирается написанием буквы О после числа и
16-ричная нотация  выбирается  написанием  Н  после  числа или $ до
числа.

     Примечание: Суффиксы B,  O,  H не поддерживаются в  выражениях
Паскаля. Выражения  Паскаля допускают только десятичную нотацию (по
умолчанию) и 16-ричную нотацию (используя префикс $).

     Числовые константы должны начинаться с одной из цифр  0..9 или
символа $;  так,  когда  Вы  пишите 16-ричную константу,  используя
суффикс Н,  требуется дополнительный 0 в начале числа,  если первая
значащая цифра  одна  из  16-ричных цифр А..F.  Например,  0BAD4H и
$BAD4 - 16-ричные константы,  а BAD4H  -  идентификатор,  поскольку
начинается с буквы, а не с цифры.


                       Строковые константы.

     Строковые константы  должны  быть  заключены  в  кавычки   или
апострофы. Две  последовательные  "" или '' внутри строки считаются
как один символ. Примеры строковых констант:

     'Z'
     'Turbo Pascal'
     "That's all folks"
     '"That"s all folks,"he said.'
     '100'
     '"'
     "'"

     Заметим, что  в  4  строке  использовались  2  апострофа   для
указания одиночного символа "апостроф".

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

     Ord(Ch1) + Ord(Ch2) shl 8 + Ord(Ch3) shl 16 + Ord(Ch4) shl 24

     где Ch1 наиболее правый (последний) символ,  а Ch4 -  наиболее
левый (первый) символ.  Если строка короче 4 символов,  самые левые
символы устанавливаются в 0.  Несколько примеров строковых констант
и соответствующих числовых значений:

     'a'       00000061H
     'ba'      00006261H
     'cba'     00636261H
     'dcba'    64636261H
     'a '      00006120H
     '   a'    20202061H
     'a'*2     000000E2H
     'a'-'A'   00000020H
     not'a'    FFFFFF9EH


                             Регистры.

     Следующие зарезервированные символы означают регистры 8086:

     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)  могут использоваться
вместе с  ":"  как  перекрытие  сегмента  для  указания   сегмента,
отличного от того, который процессор выбирает по умолчанию.

     Символ S  означает  самый  верхний  регистр из регистров стека
8087. Каждый  из  8  регистров  с  плавающей  точкой   может   быть
использован с  помощью  ST(x),  где  х  -  константа  от  1  до  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
                константы
   Тип          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]

     Встроенный Ассемблер всегда интерпретирует var параметр как 32
-битный указатель  и  размер  var  параметра   всегда   4   (размер
32-битного указателя).  В  Паскале  синтаксис  для  доступа  к  var
параметру и параметру  значению  одинаков.  Не  так  во  встроенном
Ассемблере. Поскольку  var  параметры в действительности указатели,
Вы должны интерпретировать их так во  встроенном  Ассемблере.  Так,
чтобы обратиться к содержимому var параметра, Вы вначале загружаете
32-битный указатель,  а затем обращаетесь к памяти,  на которую  он
указывает. Например, если X и Y - var параметры функции 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;

     Идентификатор типа можно использовать для  создания переменных
"на лету".   Каждая   инструкция   ниже  генерирует  машинный  код,
загружающий содержимое ES:[DI+4] в AX.

     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;

     Сфера действия символа  типа  поля  или  записи  -  это  сфера
действия записи или объекта этого типа.  Кроме того,  идентификатор
модуля открывает сферу действия определенного модуля  так  же,  как
полный квалифицированный идентификатор в Паскале.


                         Классы выражений.

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

     Выражение, которое  состоит  только  из  имени  регистра - это
регистровое выражение.  Пример регистрового выражения - это AX, CL,
DI и  ES.  Используемые  как операнды,  регистровые выражения прямо
ассемблируются в  инструкции,  которые  воздействуют  на   регистры
процессора.

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

     Выражения, которые  не  относятся  к  регистрам и не связаны с
положением в памяти,  - это непосредственные значения;  эта  группа
включает нетипированные константы и типы Паскаля.

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

     const
       Start = 10;
     var
       Count: Integer;
     ...
     asm
       mov   ax,Start                 { MOV AX,xxxx }
       mov   bx,Count                 { MOV BX,[xxxx] }
       mov   cx,[Start]               { MOV CX,[xxxx] }
       mov   dx,OFFSET Count          { MOV DX,xxxx }
     end;

     Поскольку Start  -  это непосредственное значение,  первая MOV
ассемблируется в инструкцию пересылки  непосредственного  значения.
Вторая MOV транслируется в инструкцию пересылки памяти,  т.к. Count
- это  ссылка  на  память.  В  третий  MOV  []   используются   для
преобразования Start  в  ссылку  на  память (в этом случае слово со
смещением 10 в сегменте данных) и в четвертой MOV  оператор  OFFSET
используется для  преобразования  Count в непосредственное значение
(смещение Count в сегменте данных).

     Как Вы видите,  [] и OFFSET дополняют друг друга.  В  терминах
результирующего машинного  кода  следующий  оператор  asm идентичен
двум первым строкам предыдущего оператора asm:

     asm
       mov   ax,OFFSET [Start]
       mov   bx,[OFFSET Count]
     end;

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

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

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


                          Типы выражений.

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

     var
       QuitFlag: Boolean;
       OutBufPtr: Word;
     ...
     asm
       mov   al,QuitFlag
       mov bx,OutBufPtr
     end;

     встроенный ассемблер проверяет что размер QuitFlag - 1  байт, а
размер OutBufPtr  -  2 байта.  Если тип неправильный,  то возникает
ошибка; например, неверно:

     asm
       mov   dl,OutBufPtr
     end;

     поскольку DL - регистр байтового размера, а OutBufPtr - слово.
Тип ссылки  на память может быть изменен с помощью приведения типа;
корректный способ написания предыдущей инструкции:

     asm
       mov   dl,BYTE PTR OutBufPtr
       mov   dl,Byte(OutBufPtr)
       mov   dl,OutBufPtr.Byte
     end;

     ссылаются на  первый  байт  (наименее   значащий)   переменной
OutBufPtr.
     В некоторых случаях ссылки на память нетипированные,  т.е.  не
имеют типа. Пример с непосредственным значением, заключенным в []:

     asm
       mov   al,[100H]
       mov   bx,[100H]
     end;

     Встроенный асссемблер  разрешает  обе  инструкции,   поскольку
выражение в  [100H]  не  имеет  типа  - это означает "содержимое по
адресу 100H  в  сегменте  данных",  и  тип  может быть определен из
первого операнда (байт для AL,  слово для BX). В случае если тип не
может  быть  определен  из  другого операнда,  встроенный Ассемблер
требует явного приведения типов:

     asm
       inc   BYTE PTR [100H]
       imul  WORD PTR [100H]
     end;

     Таблица 22.2 суммирует предопределенные типы символов, которые
встроенный Ассемблер предоставляет в дополнение к типа Паскаля.

           Таблица 22.2 Предопределенные типы символов.

                   ————————————————————————————————
                        Символ           Тип
                   ————————————————————————————————
                        BYTE             1
                        WORD             2
                        DWORD            4
                        QWORD            8
                        TBYTE            10
                        NEAR             0FFFEH
                        FAR              0FFFFH
                   ————————————————————————————————


     Заметим, что  псевдотипы  NEAR и FAR используются для указания
модели вызова процедур и функций. Вы можете использовать NEAR и FAR
в приведении типов точно так же, как другие символы. Например, если
FarProc - FAR процедура

     procedure FarProc; far;

     и, если Вы пишете ассемблерный код в  том  же  модуле,  что  и
FarProc, Вы можете использовать более эффективный NEAR вызов:

     asm
       push   cs
       call   NEAR PTR FarProc
     end;



                       Операторы выражений.

     Встроенный Ассемблер предоставляет операторы,  разделенные  на
12 классов   по   приоритетам.   Таблица  22.3  приводит  операторы
встроенного Ассемблера в порядке уменьшения их приоритета.

     Таблица 22.3. Операторы выражений встроенного Ассемблера.

———————————————————————————————————————————————————————————————————
            Оператор                   Комментарий
———————————————————————————————————————————————————————————————————
     &                         Оператор перекрытия идентификатора
     ()                        Селектор элемента структуры
     []
     .
     HIGH LOW
     + -                       Унарные операторы
     :                         Оператор перекрытия сегмента
     OFFSET SEG TYPE PTR *
     / MOD SHL SHR
     + -                       Бинарные операторы
     NOT AND OR XOR            Побитовые операторы
———————————————————————————————————————————————————————————————————

     Примечание: Приоритет   операторов   встроенного    Ассемблера
отличается от Паскаля.  Например, в ассемблерном выражении оператор
AND имеет меньший приоритет,  чем операторы +  и  -,  а  в  Паскале
наоборот.

     &
     Перекрытие идентификатора.  Идентификатор,  следующий   за   &
интерпретируется как символ,  определенный пользователем, даже если
он совпадает с зарезервированным словом встроенного Ассемблера.

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

     [...]
     Ссылка на память. Выражение внутри [] полностью вычисляется до
интерпретации, как один  элемент  выражения.  Выражение  внутри  []
может быть комбинировано с регистрами BX,  BP,  SI,  DI,  используя
оператор +  для  указания  индексации.   Другое   выражение   может
предшествовать выражению в []; результат становится суммой значений
двух выражений с типом первого выражения.  Результат всегда  ссылка
на память.

     "."
     Селектор элемента структуры.  Результат - сумма  выражения  до
точки и  выражения  после  точки  с  типом  выражения  после точки.
Символы, лежащие  в  сфере  действия,  определяемой  выражением  до
точки, могут использоваться в выражении после точки.

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

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

     "+"
     Унарный плюс.  Возвращает  выражение,  следующее  за  +,  без
изменений.   Выражение   должно  быть  абсолютным  непосредственным
значением.

     "-"
     Унарный минус.   Возвращает   выражение,  следующее  за  -,  с
отрицательным значением.   Выражение   должно    быть    абсолютным
непосредственным значением.

     ":"
     Перекрытие сегмента. Указывает Ассемблеру, что выражение после
":" относится к сегменту с именем сегментного регистра (CS, DS, SS,
ES) до ":".  Результат - ссылка на память  со  значением  выражения
после ":".   Когда  перекрытие  сегмента  используется  в  операнде
инструкции, инструкция будет предварена  соответствующим  префиксом
перекрытия сегмента,   гарантируя,   что   будет  выбран  указанный
сегмент.

     OFFSET
     Возвращает смещение  (младшее слово) выражения,  следующего за
оператором. Результат - непосредственное значение.

     SEG
     Возвращает сегментную   часть   (старшее   слово)   выражения,
следующего за оператором. Результат - непосредственное значение.

     TYPE
     Возвращает тип  (размер  в  байтах)  выражения,  следующего за
оператором. Тип непосредственного значения - 0.

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

     "*"
     Умножение. Оба    выражения    должны     быть     абсолютными
непосредственными значениями     и     результат    -    абсолютное
непосредственное значение.

     /
     Целое деление.   Оба   выражения   должны   быть   абсолютными
непосредственными   значениями    и    результат    -    абсолютное
непосредственное значение.

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

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

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

     "+"
     Сложение. Выражения  могут  быть  непосредственными значениями
или ссылками к памяти,  но только  одно  из  выражений  может  быть
перемещаемым значением.  Если  одно  из  выражений  -  перемещаемое
значение, то результат так же перемещаемое значение.  Если одно  из
выражений - ссылка на память, то результат так же ссылка на память.

     "-"
     Вычитание. Первое выражение может быть любого класса, а второе
выражение должно   быть   абсолютным   непосредственным  значением.
Результат того же класса, что и первое значение.

     NOT
     Побитовое отрицание.    Выражение   должно   быть   абсолютным
непосредственным    значением    и    результат    -     абсолютное
непосредственное значение.

     AND
     Побитовое "и".   Оба   выражения   должны   быть   абсолютными
непосредственными    значениями    и    результат    -   абсолютное
непосредственное значение.

     OR
     Побитовое "или".   Оба   выражения   должны  быть  абсолютными
непосредственными   значениями    и    результат    -    абсолютное
непосредственное значение.

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


                 Ассемблерные процедуры и функции.

     До сих  пор  каждая  конструкция  asm...end  была  заключена в
операторную часть begin...end.  Ассемблерная директива Turbo Pascal
позволяет Вам   написать   процедуру   или   функцию  полностью  на
встроенном Ассемблере,  не требуя  операторной  части  begin...end.
Пример ассемблерной функции:

     function LongMul(X, Y: Integer): Longint; assembler;
     asm
       mov   ax,X
       imul  Y
     end;

     Директива Ассемблера  заставляет  Turbo  Pascal  выполнить ряд
оптимизаций при генерации кода:

     - Компилятор  не  генерирует  код  для  копирования   значения
параметров в  локальные  переменные.  Это действует на все значения
параметров строкового типа и другие значения параметров  с размером
не 1,  2  или 4 байт.  Внутри процедуры или функции такие параметры
должны интерпретироваться, как если бы они были var параметрами.

     - Компилятор не распределяет переменную результата  функции  и
ссылка на   символ  @Result  является  ошибкой.  Строковые  функции
являются исключением  из  этого  правила.  Они  всегда   используют
указатель @Result, который распределяется вызывающей программой.

     - Компилятор  не генерирует кадра стека для процедур и функций
без параметров и локальных переменных.

     - Автоматически  генерируется   код   входа   и   выхода   для
ассемблерных процедур и функций, выглядящих как:

     push   bp
     mov    bp,sp
     sub    sp,Locals
     ...
     mov    sp,bp
     pop    bp
     ret    Params

     где Locals  -  размер  локальных  переменных,  Params - размер
параметров. Если Locals и Params ноль,  то входного кода нет, а код
выхода состоит из инструкции RET.

     Функции, использующие директиву Ассемблера,  должны возвращать
результаты:

     - Функции  порядкового  типа   (Integer,   Char,   Boolean   и
перечислимые типы  возвращают  результаты в AL (8-битное значение),
AX (16-битное значение), или DX:AX (32-битное значение).

     - Функции типа Real возвращают результат в DX:BX:AX

     - Функции с результатами типа 8087 (Single, Double, Extended и
Comp) возвращают его в регистре ST(0) сопроцессора 8087.

     - Результат типа указатель возвращается в DX:AX.

     - Результат  типа  строка возвращается через временную память,
на которую указывает @Result.

     Ассемблерная директива  во  многом   сравнима   с   директивой
external, а  ассемблерные  процедуры и функции должны следовать тем
же правилам,  что и external процедуры и функции. Следующие примеры
демонстрируют некоторые  отличия  между операторами asm в обычных и
ассемблерных фунциях.  Первый  пример  использует  оператор  asm  в
обычной функции   для  преобразования  строки  в  прописные  буквы.
Заметим, что значение параметра Str  в  этом  случае  ссылается  на
локальную переменную, поскольку компилятор автоматически генерирует
входной код,  который копирует действительный параметр в  локальную
память.

     function UpperCase(Str: String): String;
     begin
       asm
         cld
         lea    si,Str
         les    di,@Result
         SEGSS  lodsb
         stosb
         xor    ah,ah
         xchg   ax,cx
         jcxz   @3
       @1:
         SEGSS  lodsb
         cmp    al,'a'
         ja     @2
         cmp    a1,'z'
         jb     @2
         sub    a1,20H
       @2:
         stosb
         loop
       @3:
       end;
     end;

     Второй пример  - это ассемблерная версия функции UpperCase.  В
этом случае Str не копируется в локальную память,  и функция должна
интерпретировать Str как var параметр.

     function UpperCase(S: String): String; assembler;
     asm
       push   ds
       cld
       lds    si,Str
       les    di,@Result
       lodsb
       stosb
       xor    ah,ah
       xchg   ax,cx
       jcxz   @3
     @1:
       lodsb
       cmp    a1,'a'
       ja     @2
       cmp    a1,'z'
       jb     @2
       sub    a1,20H
     @2:
       stosb
       loop   @1
     @3:
       pop    ds
     end;
