Подключите Ваш компьютер к проекту распределённых вычислений!
Этим Вы окажете большую помощь науке и медицине.
См. подробнее: http://solidstate.karelia.ru/~yura/pyldin/yura/computing.htm


<< Вернуться к содержанию





Файл UNIPAS.TXT
===========================================================================


    UniPascal е реализация на езика Pascal на микрокомпютърите от
типа Пълдин 601/601А.
    При реализирането му се използува така наречения смесен метод
- компилация до междинен псевдо код и след това интерпретация на
този код.  Ефекта от избора на този вид реализация е в
намаляването на обема на генерирания псевдо код (от 2 до 5 пъти в
сравнение с 16 битовите компютри от типа на IBM PC), което при
сравнително ограниченото количество памет е особено съществено
предимство.
    По начина си на реализация UniPascal донякъде прилича на
широко разпространения UCSD Pascal, но по възможности далеч
го надхвърля и се приближава до една друга също широко
разпространена реализация на Pascal, но за 16 битови
микрокомшютри, а именно до Turbo Pascal. Нещо повече при
проектирането на езика е взета в предвид общата насоченост на
микрокомютъра Пълдин като по-малък брат на IBM PC и UniPascal има
силна съвместимост с Turbo Pascal - една от най-добрите
реализации на Pascal за IBM PC.
    Ако трябва да направим сравнение между UniPascal и вече
цитираните UCSD Pascal и Turbo Pascal, трябва да кажем че
UniPascal превъзхожда UCSD Pascal по всички параметри и отстъпва
на Turbo Pascal по бързодействие, но не трябва да се забравя, че
той работи на значително по-слаб клас микрокомпютри.
    UniPascal се придържа към ISO стандарта на Pascal, като в
болшинството случаи представлява надмножество на този стандрат.
    В досегашните версии на UniPascal от ISO стандарта не са
реализирани само съвместяемите масиви параметри и предаването на
процедури и функции като параметри.

    От възможностите и особенностите на UniPascal внимание
заслужават следните:
    ¦ два типа условна компилация, позволяващи да се постигне
      почти пълна съвместимост с другите реализации на Pascal;
    ¦ практически пълна съвместимост на файловете с данни
      използувани от UniPascal и тези от реализациите на Pascal и
      от други езици за програмиране за IBM PC;
    ¦ автоматично поддържане на овърлейни процедури и функции;
    ¦ разрешаването на константни изрази в декларациите;
    ¦ 16 и 32 битова целочислена аритметика;
    ¦ 32 битова реална аритметика по IEEE стандарт;
    ¦ поддръжка на стандартния тип string, за обработване на
      символна информация;
    ¦ широк набор стандартни процедури и функции (надстройка на
      ISO стандарта) позволяващи удобна работа на програмиста и
      ускоряване изпълнението на програмата;
    ¦ интерпретатора на междинния код се разпространява на ROM,
      който, поради архитектурата на микрокомпютъра Пълдин, не
      отнема на потребителя нито байт от свободната памет;
    ¦ практически всички системни програми съществуват в cross
      варианти работещи на IBM PC и при желание на потребителя
      могат да бъдат включени в дистрибутивния пакет, което
      позволява разработката на голяма част от програмното
      осигуряване да се извършва на по-мощни компютри;
    ¦ на дистрибутивния диск ще намерите повече от 20 примерни
      програми написани на UniPascal.

    От версия 1.10 нататък са реализирани и следните съществени
възможности, липсващи в предишните версии:
    ¦ разделно модулна компилация, реализирана чрез използуване
      на модули (unit - както е в UCSD и Turbo Pascal);
    ¦ удобна връзка с подпрограми написани на асемблер.

    Освен това в момента се разработват следните помощни програми:
    ¦ оптимизатор на програмите написани на UniPascal, намаляващ
      генерирания код и ускоряващ работата им;
    ¦ програми за статистическо измерване на времето и честотата
      на използуване на процедурите по време на работа на Pascal
      програма, което дава възможност за по-добра оптимаизация на
      алгоритмите от старана на програмиста.







Файл CALLASM.
============================================================================


     Параметрите се предават чрез стека в обратен ред, т.е. последния параметър
е на върха на стека. Големината на параметрите е кратна на дума (2 байта).
Функциите връщат резултата си в стека (една или две думи). Всички типве данни
се представят в Negative Byte Sex (първо младшия после старшия байт), с
изключение на указателите (адресите) те са в нормалния за процесора Positive
Byte Sex (първо старшия после младшия байт).
     NB: На върха на стека се намира return address където трябва да се върне
подпрограмата на асемблер и едва след него са параметрите. За целта трябва да
се спаси този адрес и после да се извадят параметрите (евентуално на излизане
да се напъха резултата на функцията). Възможно е и друго решение: адреса от
вурха на стека се изхвърля с две инструкции INS и после връщатането става чрез
jmp $befe.
    Вид на параметрите:
    1) по стойност
      a) всички параметри с големина до две думи (4 байта) ако не са от тип
         string[?] се предават директно в стека;
      б) за всички останали (string и по-големи от две думи) се предава адрес;
    2) по адрес (VAR)
      а) ако типа е STRING (само STRING без описател за дължина) се предават
         две думи първо в стека е пъхнат адреса на променливата и след него
         (т.е. отгоре му) се намира спецификатора за дължина на фактическия
         параметър. Пример:  procedure bz(var s: string);
         се вика BZ(sss); където var sss: string[77];
         тогава в стека след адреса е напъхана дума в която пише 77.
      б) за другите е ясно (предава се адреса им);
    3) константни (const) аналогично на тези по стойност.

Внимавай с пакетирането.







Файл CFILE.
===============================================================================


-------------------------------------------------------------------------------
---------------------------- Описание на YcodeFile ----------------------------
-------------------------------------------------------------------------------

    Първите няколко байта от всеки YcodeFile са със следния строго фиксиран
формат. Даденото съдържание обикновено се отнася до Пълдинската реализация.

offset   size  съдържание       Описание
------------------------------------------------------------------------------
               ------¦          Всеки YcodeFile ТРЯБВА да съдържа в първите си
$0000  2 bytes Lc0 deL          два байта $c0 $de (code).
               +--+---
$0002  1 byte  L10L             Големина на една дума в битове            ($10)
               +--L
$0003  1 byte  L00L             Byte sex (0 - negative).                  ($00)
               +--+--¦
$0004  2 bytes L01 xxL          Version (Major.Minor) на вида на YcodeFile.
               +--+--L
$0006  2 bytes L00 00L          Unused. обикновено има 0.               ($0000)
               +--+--L
$0008  1 word  L20 00L          Големина на параграф (32 байта) даден в Bsex-
               +--+--L
$000a  1 word  L00 02L          Големина на блок (512 байта) даден в Bsex-
               +--+--L
$000c  1 word  Lxx xxL          Номер на параграф в който е записан
               +--+--L          Module Descriptor на първия модул.
$000e          |  U  |          версия 1.00 на codefile това е unused до края
               |  n  |          на параграфа а за следващите версии > 1.00
  .            |  u  |          се използуват последните 4 или 8 байта
  :            |  s  |          взависимост от версията (ако е > $80 то 8bytes)
               |  e  |
$0017          |  d  |
               +-----+-----¦
$0018  LongWrd L Check Sum L    CheckSum of a file (if MinVer > $80)
               +--+--+--+--L
$001c  LongWrd L serial No L    serial number (Compiler/Linker/Optimizer)
               L--+--+--+---

------------------------------ Module Descriptor ------------------------------
------------------------¦
L module name 8 chars   L       Име на модула. 8 буквено.
+--+--+--+--+--+--+--+---
L Ver L  (word)                 Версия на модула(все още има само 0 обикновено)
+--+--L
LDate L  (2 bytes)              Дата на компилация (на interface частта)
+--+--L
LTime L  (2 bytes)              Време (час, мин ...) на компилация
+--+--L
LNext L  (word)                 Номер на параграф на следващия ModuleDescriptor
+--+--L
LMseg L  (word)                 Номер на параграф на главния сегмент
+--+--L
LLang L  (2 bytes)              Език на който е написан.
+--+--L
LCstrtL  (word)                 Информация за компилатора. Начален блок на
+--+--L                         interface парчето. (Block No)
LCsizeL  (word)                 Информация за компилатора. Дължина на
+--+--L                         interface парчето. (in bytes)
LUsageL  (word)                 Offset of first paragraph in usage list
+--+--L
L     L
+--+--L
L     L
+--+---
LNeL     (byte)                 брой външни сегменти (модули/units/)
+--L
LNiL     (byte)                 брой вътрешни сегменти (сегментни процедури)
L---

Пояснения: Версията, датата и времето на модула се вземат от неговия interface.
Те се използуват при следния случай: Нужен ни е модул X, в такъв случай търсим
такъв (как това е отделен въпрос) и когато намерим модул със същото име
проверяваме версията
  ако версията съвпада
     то и датата и времето трябва да съвпадат иначе не сме намерили това което
     ни трябва и търсим друг удовлетворяващ изискванията.
  ако версиите са различни, но версията на намерения е по-голяма от версията на
     търсения, и ако датата и времето на намерения са по-големи от тези на
     търсения то този модул ни върши работа и си го прибираме.
  във всички останали случай намерения модул не ни върши работа и трябва да
     потърсим друг удовлетворяващ изискванията за съвместимост.

Language:това е една дума в която ако я представим като полубайтове ще получим:

 ------------- Главен номер на езика: 0 - асемблери (native code)
 L                                    1 - Pascal.
 L   --------- Подномер на езика.
 L --+-¦
----T---¦
LX YLx yL
L-+-+-+--

    Номер език $0000 е невалиден.

    Номер $01xx - е запазен за MC6800 native code
          $02xx - е запазен за MCS6502 native code

    Номер $1Xxx - е запазен за Pascal.

    Номер $2Xxx - е запазен за Modula-2.

--------T-------¦
L HiByte LowByteL   Date: заема два байта и описанието е дадено побитово
L+++++++++++++++-
L--T---+-T-+-T---
   L     L   L------ day         (1..31)   (5 bits)
   L     L---------- month       (1..12)   (4 bits)
   L---------------- year - 1980 (0..127)  (7 bits)

--------T-------¦
L HiByte LowByteL     Time: заема два байта и описанието е дадено побитово
L+++++++++++++++-
L--T-+---T-+-T---
   L     L   L------ sec / 2 (0..29)    (5 bits)
   L     L---------- min     (0..59)    (6 bits)
   L---------------- hour    (0..23)    (5 bits)

------------------------------- Usage Paragraph -------------------------------
------------------------¦
L module name 8 chars   L       Име на модула. 8 буквено.
+--+--+--+--+--+--+--+---
L Ver L  (word)                 Версия на модула(все още има само 0 обикновено)
+--+--L
LDate L  (2 bytes)              Дата на компилация (на interface частта)
+--+--L
LTime L  (2 bytes)              Време (час, мин ...) на компилация
+--+--L
LNext L  (word)                 Номер на параграф на следващия UsageParagraph
+--+--L
L     L \
+--+--L  \
L     L   \
+--+--L    \
L     L     \
+--+--L      \
L     L       \
+--+--L        >             unused now
L     L       /
+--+--L      /
L     L     /
+--+--L    /
L     L   /
+--+--L  /
L     L /
L--+---

----------------------------- Segment Descriptor ------------------------------

------------------------¦
L segment name 8 chars  L       Име на сегмента. 8 буквено. Използува се само
+--+--+--+--+--+--+--+---       само за проверка за вярност .
LStartL  (word)                 Start block of a code segment
+--+--L
LSize L  (word)                 Size in bytes of a code segment
+--+--L
LNo   L  (word)                 Segment No (0 for main)
+--+--L
LNext L  (word)                 Next Segment (pragraph No)
+--+--L
L     L
+--+--L
L     L
+--+--L
L     L
+--+--L
L     L
+--+--L
L     L
+--+--L
L     L
+--+--L
L     L
+--+--L
L     L
L--+---

----------------------------- Описание на сегмент -----------------------------

              ---------------------------------------------------------¦
              L-------------------------------------------¦            L
              LL-------------------------¦                L          | L
              LLL                        V                V          | V
-----------------T----------------------T----------------T-----------T--------¦
L Segment Header L Ycode for Procedures L ProcDictionary L ConstPool L RelTbl L
L----------------+----------------------+----------------+-----------+---------
                   ^    ^      ^          L L      L                 | cut this
                   L    L      L----------- L ...  L                 |  after
                   L    L--------------------      L                 relocation
                   L--------------------------------

=== Segment Header Info (32 байта) ===

------------------------¦
L segment name 8 chars  L       Име на сегмента. 8 буквено. Използува се
+--+--+--+--+--+--+--+---       само за проверка за вярност.
L10L     (byte)                 големина на думата в битове (16)
+--L
L00L     (byte)                 byte sex (0 - negative)
+--+--¦
L01.00L  (2 bytes)              Ycode version (major.minor)
+--+--L
LTsizeL  (word)                 Total size (in bytes без тези 32 байта header),
+--+--L                         но + дължината на ConstPool
LCsizeL  (word)                 Const Pool size. (in bytes)
+--+--L
|  .  |                         10 неизползувани (засега) байта
|  :  |
+-----L
LRelctL  (word)                 Pointer to Relocation Tables
+-----L
LPdictL  (word)                 Pointer to ProcDictionary
+--+--L
LCPoolL  (word)                 Pointer to Const Pool
L--+---

Както се вижда от диаграмата местата на ProcDictionary, ConstPool и процедурите
се получават от разните му там указатели. По тази ми ти причина те могат да
бъдат в произволен ред.

=== ProcDictionary ===

----T---T---T     ---¦
LN 0L p1L p2L ...  pnL
L-+-+-+-+-+-+     -+--
 ^    ^   ^        ^
 L    L---+-- ... -+--- offset на съответната процедура от началото на сегмента
 L--------------------- общ брой процедури

=== ConstPool ===
засега представлява една сбирщина от байтове.

=== RelTbl (Relocation table) ===

  Relocation table представлява информация за relocate-ване на асемблерските
процедури (MC6800 Пълдин). Организирацията и е строго специфична за Пълдин.
Това са таблиците генерирани за всеки obj файл залепени една след друга, като
всяка от тях завършва с 0 и започва с отместване от началото на сегмента. Ако
отместването е отрицателно то това е и края на таблиците. От таблицата
генерирана от асемблера се изхвърлят първите два байта т.е. Nitems.

Забележка: Таблиците трябва да са последни защото след relocate се изхвърлят,
           като цялата памет след тях се освобождава.


=== Procedure ===

  --------------------------------------¦
  |    exit code of a procedure         |
->|  exit:                           |
| |    Ycode of a procedure.            |
| |                                     |
L +-----T--------------------------------
L-Lexit L (word) ExitPtr: къде се скача ако се прави exit от тази процедура.
  +--+--L
  LPsizeL (word) ParamSize: колко байта параметри има процедурата.
  +--+--L
  LDsizeL (word) DataSize: колко байта данни има процедурата. (без Params)
  +--+---
  LLxL  (byte) LexLevel: Лексическо Ниво на процедурата.
  +--L   ------------------------------------------------------------------
  LNoL  (byte) ProcNo: Номер на процедурата: трябва да бъде който трябва
  L---                 Използува се само за проверка за правилност
                       Ако е 0 следователно процедурата е асемблерска и
                       там важат други хави. Които са следните:
                       Първия байт (както вече стана ясно) и втория е $00
                       след това е кода на процедурката на Ассемблер.


-------------------------------------------------------------------------------
-------------------------- Описание на SYM файловете --------------------------
-------------------------------------------------------------------------------

               ------------------------------¦
$0000 10 bytes L U  n  i  P  a  s  c  a  l 00L идентификатор
               +--+--+--+--+--+--+--+--+--+---
$000a  2 bytes L01 xxL                         версия на SYM файл организацията
               +--+--+-----¦
$000c  4 bytes L serial No L                   compiler's serial number
               +--+--+--+--+-----------¦
$0010  8 bytes L module name 8 chars   L
               +--+--+--+--+--+--+--+---
$0018  2 bytes L Ver L  (word)
               +--+--L
$001a  2 bytes LDate L  (2 bytes)
               +--+--L
$001c  2 bytes LTime L  (2 bytes)
               +--+--L
$001e  2 bytes LdsizeL  (word)                 size of interfaced variables
               +--+---
$0020  1 byte  L0xL                            x = 0/1 (interface/
               +--L                                     interface only) unit
$0021  1 byte  LnnL                            nn = number of external units
               +--+--------------------¦
       8 bytes L module name 8 chars   L   \
               +--+--+--+--+--+--+--+---   |
       2 bytes L Ver L  (word)              \   Тази информация я има за всеки
               +--+--L                       >       използуван UNIT (модул),
       2 bytes LDate L  (2 bytes)           /   но без unit STANDARD.
               +--+--L                     |
       2 bytes LTime L  (2 bytes)          /
               +--+--L
$0022  2 bytes LCsizeL                         Interfaced const pool size
               +--+--L
              /|     |                         Large constants itself (Cpool)
       Csize < |     |                              size in bytes = Csize
              \+--+---
               |  |                            Forward definitions
               |  |                            for all exported type Idents
               |  |
               +--L
               LFFL                            завършват с $FF
               +--L
               |  |                            Dump of all identifiers
               |  |
               +--L
               LFFL                            завършват с $FF
               +--L
               |  |                            Type definitions
               |  |                            for all exported types
               |  |
               +--+--¦
               L$ffffL                          свършват на $ffff
               L--+---

-------------------------------------------------------------------------------






Файл CONVENTI.
==============================================================================


                   Съглашения при използуването на UniPascal

1. Разпределение на нулевата страница ($0000..$00ff)

  $0000..$007f - reserved for BIOS, UniBIOS & UniDOS
  $0080..$00af - reserved for UniPascal (don't touch)
  $00b0..$00df - work locations for UniPascal (can be used)
  $00e0..$00f0 - Free for use (never used by UniPascal Interpreter)

2. Обработване на специален тип файлове

                section $00aa
IOsize          ds      2       ; $aa - size
IObuff          ds      2       ; $ac - Buffer address
IOfile          ds      2       ; $ae - address of Pascal File variable
                ends







Файл FPCODES.
==============================================================================


                         Описание на FP instructions

OpCodeL Mnemonic L Description                              L   Stack Status
------+----------+------------------------------------------+------------------
00..7fL SLR_0..7fL Short Load Real Constant                 L  { } -> { r }
      L          L r = кода на инструкцията - $40, т.е. товаL
      L          L са реалните константи -64.0 .. +63.0     L
------+----------+------------------------------------------+------------------
 80   L addR     L Add Reals.                   r:= r2 + r1 L {r1, r2} -> { r }
------+----------+------------------------------------------+------------------
 81   L subR     L Subtract reals.              r:= r2 - r1 L {r1, r2} -> { r }
------+----------+------------------------------------------+------------------
 82   L mulR     L Multiply Reals.              r:= r2 * r1 L {r1, r2} -> { r }
------+----------+------------------------------------------+------------------
 83   L divR     L Divide reals.                r:= r2 / r1 L {r1, r2} -> { r }
------+----------+------------------------------------------+------------------
 84   L absR     L Absolute value of real       r:= abs(r1) L { r1 } -> { r }
------+----------+------------------------------------------+------------------
 85   L negR     L Neagte real                     r:= - r1 L { r1 } -> { r }
------+----------+------------------------------------------+------------------
 86   L sqrR     L Square Real                  r:= r1 * r1 L { r1 } -> { r }
------+----------+------------------------------------------+------------------
 87   L sqrt     L Square Root of real         r:= sqrt(r1) L { r1 } -> { r }
------+----------+------------------------------------------+------------------
 88   L sin      L Calculate SIN                r:= sin(r1) L { r1 } -> { r }
------+----------+------------------------------------------+------------------
 89   L cos      L Calculate COS                r:= cos(r1) L { r1 } -> { r }
------+----------+------------------------------------------+------------------
 8a   L exp      L Calculate EXP                r:= exp(r1) L { r1 } -> { r }
------+----------+------------------------------------------+------------------
 8b   L ln       L Calculate LN                  r:= ln(r1) L { r1 } -> { r }
------+----------+------------------------------------------+------------------
 8c   L Atan     L Calculate ArcTan            r:= atan(r1) L { r1 } -> { r }
------+----------+------------------------------------------+------------------
 8d   L intR     L get integer part of real     r:= int(r1) L { r1 } -> { r }
------+----------+------------------------------------------+------------------
 8e   L fracR    L get fraction part of real   r:= frac(r1) L { r1 } -> { r }
------+----------+------------------------------------------+------------------
 8f   L randomR  L generate random real number   r:= random L { } -> { r }
------+----------+------------------------------------------+------------------
 90   L equR     L Compare reals (for = )       b:= r2 = r1 L {r1, r2} -> { b }
------+----------+------------------------------------------+------------------
 91   L equR     L Compare reals (for <> )     b:= r2 <> r1 L {r1, r2} -> { b }
------+----------+------------------------------------------+------------------
 92   L lesR     L Compare reals (for < )       b:= r2 < r1 L {r1, r2} -> { b }
------+----------+------------------------------------------+------------------
 93   L leqR     L Compare reals (for <= )     b:= r2 <= r1 L {r1, r2} -> { b }
------+----------+------------------------------------------+------------------
 94   L grtR     L Compare reals (for > )       b:= r2 > r1 L {r1, r2} -> { b }
------+----------+------------------------------------------+------------------
 95   L geqR     L Compare reals (for >= )     b:= r2 >= r1 L {r1, r2} -> { b }
------+----------+------------------------------------------+------------------
 96   L trunc    L Convert real to LongInt     i:= trunc(r) L { r } -> { li }
------+----------+------------------------------------------+------------------
 97   L round    L Convert real to LongInt     i:= round(r) L { r } -> { li }
------+----------+------------------------------------------+------------------
 98   L i2real   L Integer to real. Convert top of stack    L { i } -> { r }
      L          L integer number to 4 byte IEEE real       L
------+----------+------------------------------------------+------------------
 99   L c2real   L Cardinal to real. Convert top of stack   L { c } -> { r }
      L          L cardinal number to 4 byte IEEE real      L
------+----------+------------------------------------------+------------------
 9a   L l2real   L LongInt to real. Convert top of stack    L { li } -> { r }
      L          L LongInt number to 4 byte IEEE real       L
------+----------+------------------------------------------+------------------
 9b   L LwRcnst wL Load word as Real constant (convert cnst L { } -> { r }
      L          L from integer format to real).      r:= w L
------+----------+------------------------------------------+------------------

                          Таблица на FPcode инструкциите

   г========T========T========T========T========T========T========T========+
   ¦ .0 /.8 ¦ .1 /.9 ¦ .2 /.a ¦ .3 /.b ¦ .4 /.c ¦ .5 /.d ¦ .6 /.e ¦ .7 /.f ¦
г==+========+========+========+========+========+========+========+========+==+
¦80¦  addR  ¦  subR  ¦  mulR  ¦  divR  ¦  absR  ¦  negR  ¦  sqr   ¦  sqrt  ¦87¦
¦==+========+========+========+========+========+========+========+========+==¦
¦88¦  sin   ¦  cos   ¦  exp   ¦  ln    ¦  Atan  ¦  intR  ¦  fracR ¦ randomR¦8f¦
¦==+========+========+========+========+========+========+========+========+==¦
¦90¦  equR  ¦  neqR  ¦  lesR  ¦  leqR  ¦  grtR  ¦  geqR  ¦  trunc ¦  round ¦97¦
¦==+========+========+========+========+========+========+========+========+==¦
¦98¦ i2real ¦ c2real ¦ l2real ¦ LwRcnst¦        ¦        ¦        ¦        ¦9f¦
¦  ¦        ¦        ¦        ¦  word  ¦        ¦        ¦        ¦        ¦  ¦
L==+========+========+========+========+========+========+========+========+==+
   ¦ .0 /.8 ¦ .1 /.9 ¦ .2 /.a ¦ .3 /.b ¦ .4 /.c ¦ .5 /.d ¦ .6 /.e ¦ .7 /.f ¦
   L========¦========¦========¦========¦========¦========¦========¦========+








Файл LYCODES.
==============================================================================


                      Описание на Long Ycode instructions

    При описанието се използуват същите означения както и при Ycode
инструкциите, за повече подробности виж там.

                         Long Ycode instructions

OpCodeL Mnemonic L Description                              L   Stack Status
------+----------+------------------------------------------+------------------
  08  L IOrslt   L Return IOresult                          L  { } -> { w }
------+----------+------------------------------------------+------------------
  09  L SetIOr   L Store <w> in IOresult                    L  { w } -> { }

------+----------+------------------------------------------+------------------
  0d  L SNCI byteL Short Native code info                   L  { [?] } -> { }
      L          L Извикваме с jsr кода който е след това   L
      L          L и който е дълъг <byte> байта.      L
------+----------+------------------------------------------+------------------
  0e  L NCI word L Native code info                         L  { [?] } -> { }
      L          L Извикваме с jsr кода който е след това   L
      L          L и който е дълъг <word> байта.      L
------+----------+------------------------------------------+------------------
  0f  L UsrBpnt  L User Breack Point                        L  { w } -> { }

------+----------+------------------------------------------+------------------
  12  L IdSrch   L Identifier Search  (виж Lexical)         L  { p } -> { w }
------+----------+------------------------------------------+------------------
  13  L Scan byteL Scan for char                            L  { ... } -> { i }
      L          L function Scan(ch: char;                  L
      L          L               const buffer;              L
      L          L               offset: Cardinal;          L
      L          L               Limit: integer): integer;  L
      L          L Търсим <Ch> в buffer започвайки от offsetL
      L          L позиция, и търсейки в Limit позиции,     L
      L          L ако Limit е < 0 търсим назад и връщаме   L
      L          L отрицателна стойност                     L
------+----------+------------------------------------------+------------------
  14  L str2val bL string -> value                          L  { ... } -> { ? }
      L          L Convert packed array of byte to          L
      L          L   Numeric Value                          L
      L          L function Str2Val(const Buff;             L
      L          L                  Ndx, limit: cardinal;   L
      L          L                  var Nchars: Cardinal):  L
      L          L                  (LongInt/Real);         L
      L          L <b>: IHUSxxxxx                           L
      L          L      ^^^^________ allow sign             L
      L          L      |||_________ allow underscores      L
      L          L      ||__________ get hex number (if int)L
      L          L      |___________ int/real convert (0/1) L
------+----------+------------------------------------------+------------------
  15  L val2str bL value -> string                          L  { ... } -> { }
      L          L Convert value to string                  L
      L          L procedure Int2Str (Value: (LWord/LInt);  L
      L          L                    var s: string);       L
      L          L procedure Real2Str(Value: real;          L
      L          L                    w: natural;           L
      L          L                    var s: string);       L
      L          L <b>: negative/positive - real/longint    L
      L          L      0 - integer, 1 - LongWord,          L
      L          L      2 - Word, 3 - Byte                  L
      L          L      $80 - exponential form,             L
      L          L      $81 - fraction form                 L
      L          L                                          L
      L          L незадължителния параметър w се дава само L
      L          L ако е нужно да се превръща от real       L

------+----------+------------------------------------------+------------------
  18  L Qsearch  L Queue Search                             L { ... } -> { b }
      L          L function QueueSearch(Root: pointer;      L
      L          L          LinkOffs,                       L
      L          L          SortOffs: Natural;              L
      L          L          var LastSrch: pointer;          L
      L          L          const SrchFor;                  L
      L          L          Special: word): boolean;        L
      L          L Започвайки от Root търсим в списък като  L
      L          L знаем че LinkOffs е отместване от        L
      L          L началото на този списък на полето в      L
      L          L което е записан указателя към следващия  L
      L          L елемент от списъка, в SortOffs е записаноL
      L          L отместването на полето по което се търси,L
      L          L SrchFor е това което се търси. LastSrch еL
      L          L намереният елемент от списъка или        L
      L          L елемента след които трябва да включим    L
      L          L търсения елемент ако не е намерен.       L
      L          L Special: LSByte -                        L
      L          L   %ABCDEFGH                              L
      L          L   ^****^^^                               L
      L          L   |    |||-> FGH = 100, 010, 000 -       L
      L          L   |          >, <, <> подредба           L
      L          L   ---------> 0/1 Packed/String           L
      L          L MSByte - Size of searched (packed only)  L

------+----------+------------------------------------------+------------------
  1a  L compB    L compare bytes                            L { ... } -> { w }
      L          L function Compare(limit: natural;         L
      L          L          const Src;                      L
      L          L          SRCoffset:  natural;            L
      L          L          const Dest;                     L
      L          L          Destoffset: natural): natural;  L
      L          L Сравняваме Src и Dest и връщаме          L
      L          L къде се различават                       L

------+----------+------------------------------------------+------------------
  20  L Lo_Hi bt L Get Lo/Hi byte/word                      L
      L          L <bt> = $90 (hi word), $b0 (lo word)      L { dw } -> { w }
      L          L <bt> = $08 (hi byte), $18 (lo byte)      L { w } -> { w }
------+----------+------------------------------------------+------------------
  21  L Swap  bt L SwapWord / LongSwap                      L
      L          L <bt> = $90 (longswap)                    L { dw } -> { dw }
      L          L <bt> = $08 (swap word)                   L { w } -> { w }

------+----------+------------------------------------------+------------------
  26  L GetDate  L get date and store in Day, Month, Year   L {^d,^m,^y} -> {}
------+----------+------------------------------------------+------------------
  27  L GetTime  L get time and store in s100, Sec, min,HourL{^s1,^s,^m,^h}->{}

------+----------+------------------------------------------+------------------
  34  L ULcase btL Up/Lo case char/string                   L { ch } -> { ch }
      L          L ако <bt> A.....GH                        L       or
      L          L          ^     ^^-- 0/1 char/string      L { addr } -> { }
      L          L          |     ---- 0/1 ASCII/ASCII + CYRL
      L          L          ---------- 0/1 Lo/UpCase        L
------+----------+------------------------------------------+------------------
  35  L delete   L Delete W chars starting from w position  L {W,w,w0,s} -> {}
      L          L in string s (w0 - unused)                L
------+----------+------------------------------------------+------------------
  36  L insert   L Insert s1 in s2 starting from pos w      L {W,w,s2,s1} -> {}
      L          L max string length (s2) is W              L
------+----------+------------------------------------------+------------------
  37  L POS      L return start position of s1 in s2        L {s2, s1} -> { i }

------+----------+------------------------------------------+------------------
  38  L FillCh   L FillChar(buff, offset, count, ch)        L{w, w, w, p} -> {}
      L          L Запълваме count пъти с ch започвайки от  L
      L          L адрес buff + offset.                     L
------+----------+------------------------------------------+------------------
  39  L FillW    L FillWord(buff, count, word)              L{ w, w, p } -> { }
      L          L Запълваме count пъти с word започвайки отL
      L          L адрес buff, но този път пълним думи.     L
------+----------+------------------------------------------+------------------
  3a  L MoveB    L Move(src, Soffs, dest, Sdest, sz)        L{w,w,p,w,p} -> {}
------+----------+------------------------------------------+------------------
  3b  L MoveW    L MoveWords(src, dest, size)               L{ w,Sp,Dp } -> { }

------+----------+------------------------------------------+------------------
  3e  L dupW     L duplicate  word                          L{ w } -> { w, w }

------+----------+------------------------------------------+------------------
  40  L AbsI     L ABSolute value of Integer    i:= abs(i1) L  { i1 } -> { i }
------+----------+------------------------------------------+------------------
  41  L AbsL     L ABSolute value of LongInt    l:= abs(l1) L  { l1 } -> { l }
------+----------+------------------------------------------+------------------
  42  L NegI     L NEGative value of Integer        i:= -i1 L  { i1 } -> { i }
------+----------+------------------------------------------+------------------
  43  L NegL     L NEGative value of LongInt        l:= -l1 L  { l1 } -> { l }
------+----------+------------------------------------------+------------------
  44  L SqrI     L SQUare integer                i1:= i * i L  { i } -> { i1 }
------+----------+------------------------------------------+------------------
  45  L SqrC     L SQUare cardinal               c1:= c * c L  { c } -> { c1 }
------+----------+------------------------------------------+------------------
  46  L SqrL     L SQUare Long Integer           l1:= l * l L  { l } -> { l1 }
------+----------+------------------------------------------+------------------
  47  L Random btL Randon/Randomize  <bt> = xy (two nybbles)L  { X } -> { Y }
      L          L В стека X е с големина x бйата, а Y - y. L
      L          L има пет възможни случая bt = (xy):       L
      L          L $00 - randomize                          L
      L          L $20 - initialize with word               L
      L          L $40 - initialize with longword           L
      L          L $02 - return random cardinal number      L
      L          L $22 - return random cardinal number < TOSL
      L          L $40 - това е нещо което вече не работи   L

------+----------+------------------------------------------+------------------
  58  L GetWrds  L GET WoRDS from heap                      L  { w } -> { p }
      L          L Allocate memory with size <w> words and  L
      L          L return start address                     L
------+----------+------------------------------------------+------------------
  59  LFreeWrds  L FREE WoRDS from heap                     L  { w, p } -> { }
      L          L Free memory starting from address p and  L
      L          L with size (in words) = w.                L
------+----------+------------------------------------------+------------------
  5a  L Mark     L MARK heap state                          L  { } -> { p }
      L          L Return heap state                        L
------+----------+------------------------------------------+------------------
  5b  L Release  L RELEASE marked heap                      L  { p } -> { }
------+----------+------------------------------------------+------------------
  5c  L getW_d   L GET WoRDS from data stack                L  { w } -> { p }
      L          L Allocate memory with size <w> words and  L
      L          L return start address (but not on heap)   L
------+----------+------------------------------------------+------------------
  5d  LfreeW_d   L FREE WoRDS from data stack               L  { w, p } -> { }
      L          L Free memory starting from address p and  L
      L          L with size (in words) = w. (not heap)     L
------+----------+------------------------------------------+------------------
  5e  L MaxAvl   L return size of largest free contigiuous  L  { } -> { w }
      L          L block of AVaiLable MEMory in words       L
------+----------+------------------------------------------+------------------
  5f  L MemAvl   L return size of AVaiLable MEMory in words L  { } -> { w }
      L          L i.e. sum of all free blocks in heap      L
------+----------+------------------------------------------+------------------
  60  L Return   L RETURN from procedure                    L  { [?] } -> { }
      L          L В стека е възможно да е останала някаква L
      L          L боза и тя трябва да се изхвърли.         L
------+----------+------------------------------------------+------------------
  61  L Return1  L RETURN from function with one word value L {w, [?]} -> { w }
      L          L В стека (под return value) е възможно да L
      L          L е останала някаква боза и тя трябва да сеL
      L          L изхвърли.                                L
------+----------+------------------------------------------+------------------
  62  L Return2  L RETURN from function with dbl word value L {dw, [?]} -> {dw}
      L          L В стека (под return value) е възможно да L
      L          L е останала някаква боза и тя трябва да сеL
      L          L изхвърли.                                L

------+----------+------------------------------------------+------------------
  67  L XitFrom  L eXIT FROM procedure No = bt2 from        L
      L  bt1, bt2L segment No = bt1                         L
------+----------+------------------------------------------+------------------
  68  L SegInit bL INITialize SEGment number <b>.     L  { [w] } -> { }
      L          L В стека има една дума само при b = $ff,  L
      L          L т.е. това е случая на Init Standard unit L
      L          L и тази дума означава default in/out filesL
------+----------+------------------------------------------+------------------
  69  LSegFinit bL FINIT SEGment number <b>.                  L  { } -> { }
------+----------+------------------------------------------+------------------
  6a  LChkSeg  btL force run time error if seg <bt> is in   L  { } -> { }
      L          L initialize                               L

------+----------+------------------------------------------+------------------
  6c  LSegLoad btL Load resident segment (seg no in stack)  L  { w } -> { }
------+----------+------------------------------------------+------------------
  6d  LSegFree btL Free resident segment (seg no in stack)  L  { w } -> { }
------+----------+------------------------------------------+------------------
  6e  L Halt     L Terminate program execution              L  { w } -> { }
      L          L Край на изпълнението на програмата, като L
      L          L думата от стека е exit code. Всъщност се L
      L          L прави exit(MainProgram).                 L
------+----------+------------------------------------------+------------------
  6f  L IReturn  L RETURN from Initialize                   L  { [?] } -> { }
      L          Lако се намираме в инициализация на сегментL
      L          Lсе прави return а иначе не.               L
------+----------+------------------------------------------+------------------
  70  LLFTjump...L Long For To jump (big, Rword)            L  { w } -> { }
      L          L Ако локалната променлива с адрес big е   L
      L          L равна на върха на стека, не се прави нищоL
      L          L а ако не е равна то тя се увеличава и се L
      L          L изпълнява long jump.                     L
------+----------+------------------------------------------+------------------
  71  LSFTjump...L Short For To jump (big, rel-)            L  { w } -> { }
      L          L Ако локалната променлива с адрес big е   L
      L          L равна на върха на стека, не се прави нищоL
      L          L а ако не е равна то тя се увеличава и се L
      L          L изпълнява short jump.                    L
------+----------+------------------------------------------+------------------
  72  LLFDjump...L Long For Downto jump (big, Rword)        L  { w } -> { }
      L          L Ако локалната променлива с адрес big е   L
      L          L равна на върха на стека, не се прави нищоL
      L          L а ако не е равна то тя се намалява и се  L
      L          L изпълнява long jump.                     L
------+----------+------------------------------------------+------------------
  73  LSFDjump...L Short For Downto jump (big, Rword)       L  { w } -> { }
      L          L Ако локалната променлива с адрес big е   L
      L          L равна на върха на стека, не се прави нищоL
      L          L а ако не е равна то тя се намалява и се  L
      L          L изпълнява short jump.                    L
------+----------+------------------------------------------+------------------
74,75 L CjumpT...L Case jump by address table               L  { w } -> { }
      L          L CjumpT min,max,ElseLab,array[0..max-min] L
      L          L                               of Address;L
      L          L Хващаме думата от върха на стека и       L
      L          L сравняваме с min и max параметрите на    L
      L          L инструкцията, ако е между тях то вадим   L
      L          L min, умножаваме по две и получаваме      L
      L          L offset в таблицата jump-ваме по посоченияL
      L          L Address който е даден относно началото наL
      L          L ElseLab.                                 L

------+----------+------------------------------------------+------------------
  77  L Cjump ...L Case jump by value-address table         L  { w } -> { }
      L          L Cjump big, ElseLab, array[1..big] of     L
      L          L                       (Value, Address);  L
      L          L Хващаме думата от върха на стека и       L
      L          L сравняваме с Value парчетата от таблицатаL
      L          L и ако не дай боже съвпадне то jump-ваме  L
      L          L по сътоветния Address който е даден      L
      L          L относно началото на ElseLab.             L

------+----------+------------------------------------------+------------------
  7f  LInitFor...L INITialize FOR loop (big, byte, (rw/r+)) L{w2,w1} ->{}/{w2}
      L          L На върха на стека има две думи които са  L
      L          L пресметнатите изрази от for ?:= w1 to w2 L
      L          L параметъра на инструкцията byte: 0000xxyzL
      L          L xx - 11 - integer, 10 - cardinal for loopL
      L          L      01 longint (unimplemented),00 unusedL
      L          L  y - 0/1 initialize to/downto loop       L
      L          L  z - 0/1 третия параметър е rw/r+        L
------+----------+------------------------------------------+------------------

                       Таблица на Long Ycode инструкциите

   г========T========T========T========T========T========T========T========+
   ¦ .0 /.8 ¦ .1 /.9 ¦ .2 /.a ¦ .3 /.b ¦ .4 /.c ¦ .5 /.d ¦ .6 /.e ¦ .7 /.f ¦
г==+========+========+========+========+========+========+========+========+==+
¦00¦        ¦        ¦        ¦        ¦        ¦        ¦        ¦        ¦07¦
¦==+========+========+========+========+========+========+========+========+==¦
¦08¦ IOrslt ¦ SetIOr ¦        ¦        ¦        ¦  SNCI  ¦  NCI   ¦ UsrBpnt¦0f¦
¦  ¦        ¦        ¦        ¦        ¦        ¦  byte  ¦  word  ¦        ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦10¦        ¦        ¦ IdSrch ¦ Scan   ¦ str2val¦ val2str¦        ¦        ¦17¦
¦  ¦        ¦        ¦        ¦ byte   ¦  byte  ¦  byte  ¦        ¦        ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦18¦ Qsearch¦        ¦ compB  ¦        ¦        ¦        ¦        ¦        ¦1f¦
¦  ¦        ¦        ¦        ¦        ¦        ¦        ¦        ¦        ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦20¦ Lo_Hi  ¦ Swap   ¦        ¦        ¦        ¦        ¦ GetDate¦ GetTime¦27¦
¦  ¦ byte   ¦ byte   ¦        ¦        ¦        ¦        ¦        ¦        ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦28¦        ¦        ¦        ¦        ¦        ¦        ¦        ¦        ¦2f¦
¦==+========+========+========+========+========+========+========+========+==¦
¦30¦        ¦        ¦        ¦        ¦ ULcase ¦ delete ¦ insert ¦  pos   ¦37¦
¦  ¦        ¦        ¦        ¦        ¦  byte  ¦        ¦        ¦        ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦38¦ FillCh ¦  FillW ¦ MoveB  ¦ MoveW  ¦        ¦        ¦ dupW   ¦        ¦3f¦
¦==+========+========+========+========+========+========+========+========+==¦
¦40¦  AbsI  ¦  AbsL  ¦  NegI  ¦  NegL  ¦  SqrI  ¦  SqrC  ¦  SqrL  ¦ Random ¦47¦
¦  ¦        ¦        ¦        ¦        ¦        ¦        ¦        ¦  byte  ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦48¦        ¦        ¦        ¦        ¦        ¦        ¦        ¦        ¦4f¦
¦==+========+========+========+========+========+========+========+========+==¦
¦50¦        ¦        ¦        ¦        ¦        ¦        ¦        ¦        ¦57¦
¦==+========+========+========+========+========+========+========+========+==¦
¦58¦ GetWrds¦FreeWrds¦  Mark  ¦ Release¦ getW_d ¦ freeW_d¦ MaxAvl ¦ MemAvl ¦5f¦
¦==+========+========+========+========+========+========+========+========+==¦
¦60¦ Return ¦ Return1¦ Return2¦        ¦        ¦        ¦        ¦ XitFrom¦67¦
¦  ¦        ¦        ¦        ¦        ¦        ¦        ¦        ¦ bt, bt ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦68¦ SegInit¦SegFinit¦ ChkSeg ¦        ¦ SegLoad¦ SegFree¦  Halt  ¦ Ireturn¦6f¦
¦  ¦  byte  ¦  byte  ¦ byte   ¦        ¦        ¦        ¦        ¦        ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦70¦ LFTjump¦ SFTjump¦ LFDjump¦ SFDjump¦ CjumpT ¦ CjumpT ¦        ¦ Cjump  ¦77¦
¦  ¦ bg, rw ¦ bg, r- ¦ bg, rw ¦ bg, r- ¦  ...   ¦  ...   ¦        ¦  ...   ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦78¦        ¦        ¦        ¦        ¦        ¦        ¦        ¦InitFor ¦7f¦
¦  ¦        ¦        ¦        ¦        ¦        ¦        ¦        ¦bg,bt,??¦  ¦
L==+========+========+========+========+========+========+========+========+==+
   ¦ .0 /.8 ¦ .1 /.9 ¦ .2 /.a ¦ .3 /.b ¦ .4 /.c ¦ .5 /.d ¦ .6 /.e ¦ .7 /.f ¦
   L========¦========¦========¦========¦========¦========¦========¦========+








Файл OPCODES.
==============================================================================


                         Описание на Ycode instructions

При описанието се използуват следните означения:
    { x, y, z } състояние на стека. На върха на стека е x под него y и т.н.
    { ... } -> { ... } стека преди и след изпълнението на инструкцията
                       означението {} означава, че инструкцията не очаква
                       нищо в стека (той може и да е празен), или че
                       инструкцията не връща нищо в стека. Във всички случай
                       се предполага че инструкцията вади каквото има в стека и
                       после връща каквото се очаква от нея.

Елементите в стека се означават с букви като се използуват следните означения:

    w   - word.         (Negative Byte Sex)
    dw  - double word.  (Negative Byte Sex)

    b   - boolean.      Това е дума която ако е 0 значи имаме false инак true.
    i   - integer.      Това е дума (word), но със знак.
    c   - cardinal.     Това е 16 битово число без знак (word).
    li  - long integer. Това е двойна дума, но със знак.
    p   - pointer.      Това е адрес. (Positive Byte Sex заради MC6800)
    r   - real.         Това е 4 байтово реално число в IEEE стандард
    s   - set.          Това е множество с дескриптор за дължина.

Параметрите на инструкциите се означават с:
    byte  (bt) - byte parameter
    big   (bg) - big parameter
    word  (w)  - word (Bsex -)
    dw         - double word (Bsex -)
    rel+  (r+) - forward relative
    rel-  (r-) - backword relative
    Rword (rw) - relative word
    prefix     - prfeix instruction

Забележка: Всъщност Byte Sex-а (разположението на старши - младши байт) зависи
           изцяло от компютъра. Тук за пълнота е описано положението при
           Пълдин реализацията.

                               Ycode instructions

OpCodeL Mnemonic L Description                              L   Stack Status
------+----------+------------------------------------------+------------------
00..0fL SLDC_x   L Short LoaD Constant <x>                  L   {} -> { w }
      L          L Зарежда собствения си код в стека.       L
------+----------+------------------------------------------+------------------
10..1fL SLDL_x   L Short LoaD Local word <x>                L   {} -> { w }
      L          L Зарежда локална дума с номер x в стека.  L
------+----------+------------------------------------------+------------------
20..2fL SLDG_x   L Short LoaD Global word <x>               L   {} -> { w }
      L          L Зарежда глобална дума с номер x в стека. L
------+----------+------------------------------------------+------------------
30..37L SCXP_x btL Short Call eXternal Procedure No <bt>    L {params}-> {rslt}
      L          L Активиране на процедура с номер <bt>     L
      L          L намираща се в сегмент <x>. В стека са    L
      L          L параметрите й. След завършване на нейнотоL
      L          L изпълнение в стека остава резултата.     L
------+----------+------------------------------------------+------------------
38..3fL SIND_x   L Short load INDirect word with offset <x>.L   { p } -> { w }
      L          L Зарежда в стека дума която се намира на  L
      L          L адрес: p + 2*x (x е offset в думи)       L
------+----------+------------------------------------------+------------------
  40  L ADDw     L ADD Words.                   w:= w2 + w1 L {w1, w2} -> { w }
------+----------+------------------------------------------+------------------
  41  L SUBw     L SUBtract Words.              w:= w2 - w1 L {w1, w2} -> { w }
------+----------+------------------------------------------+------------------
  42  L ANDw     L bitwize AND Words.         w:= w2 and w1 L {w1, w2} -> { w }
------+----------+------------------------------------------+------------------
  43  L ORw      L bitwize OR Words.           w:= w2 or w1 L {w1, w2} -> { w }
------+----------+------------------------------------------+------------------
  44  L XORw     L bitwize XOR Words.         w:= w2 xor w1 L {w1, w2} -> { w }
------+----------+------------------------------------------+------------------
  45  L MULi     L MILtiply Integers.           i:= i2 * i1 L {i1, i2} -> { i }
------+----------+------------------------------------------+------------------
  46  L DIVi     L DIVide Integers.           i:= i2 div i1 L {i1, i2} -> { i }
------+----------+------------------------------------------+------------------
  47  L MODi     L MODulo Integers.           i:= i2 mod i1 L {i1, i2} -> { i }
------+----------+------------------------------------------+------------------
  48  L          L                                          L
------+----------+------------------------------------------+------------------
  49  L          L                                          L
------+----------+------------------------------------------+------------------
  4a  L ItoL     L convert Integer TO Long integer          L { i } -> { li }
------+----------+------------------------------------------+------------------
  4b  L WtoD     L convert Word TO Double Word              L { w } -> { dw }
------+----------+------------------------------------------+------------------
  4c  L DtoW     L convert Double word TO Word flush MSword L { dw } -> { w }
------+----------+------------------------------------------+------------------
  4d  L MULc     L MILtiply Cardinals.          c:= c2 * c1 L {c1, c2} -> { c }
------+----------+------------------------------------------+------------------
  4e  L DIVc     L DIVide Cardinals.          c:= c2 div c1 L {c1, c2} -> { c }
------+----------+------------------------------------------+------------------
  4f  L MODc     L MODulo Cardinals.          c:= c2 mod c1 L {c1, c2} -> { c }
------+----------+------------------------------------------+------------------
  50  L ADDd     L ADD Double words.         dw:= dw2 + dw1 L {dw1, dw2}-> {dw}
------+----------+------------------------------------------+------------------
  51  L SUBd     L SUBtract Double words.    dw:= dw2 - dw1 L {dw1, dw2}-> {dw}
------+----------+------------------------------------------+------------------
  52  L ANDd     L bitwize AND Double words dw:= dw2 and dw1L {dw1, dw2}-> {dw}
------+----------+------------------------------------------+------------------
  53  L ORd      L bitwize OR Double words. dw:= dw2 or dw1 L {dw1, dw2}-> {dw}
------+----------+------------------------------------------+------------------
  54  L XORd     L bitwize XOR Double words dw:= dw2 xor dw1L {dw1, dw2}-> {dw}
------+----------+------------------------------------------+------------------
  55  L MULl     L MILtiply Long integers.   li:= li2 * li1 L {li1, li2}-> {li}
------+----------+------------------------------------------+------------------
  56  L DIVl     L DIVide Long integers.   li:= li2 div li1 L {li1, li2}-> {li}
------+----------+------------------------------------------+------------------
  57  L MODl     L MODulo Long integers.   li:= li2 mod li1 L {li1, li2}-> {li}
------+----------+------------------------------------------+------------------
  58  L CNP byte L Call iNternal Procedure No <byte>          L{params} -> {rslt}
      L          L Активиране на процедура с номер <byte>   L
      L          L намираща се в същия сегмент. В стека са  L
      L          L параметрите й. След завършване на нейнотоL
      L          L изпълнение в стека остава резултата.     L
------+----------+------------------------------------------+------------------
  59  L CXP b1,b2L Call eXternal Procedure No <b2> SegNo<b1>L{params} -> {rslt}
      L          L Активиране на процедура с номер <b2> от  L
      L          L сегмент с номер <b1>. В стека са парамет-L
      L          L рите й. След завършване на нейното       L
      L          L изпълнение в стека остава резултата.     L
------+----------+------------------------------------------+------------------
  5a  L CGP byte L Call Global Procedure No <byte>            L{params} -> {rslt}
      L          L Активиране на процедура с номер <byte>   L
      L          L намираща се в Глобалния сегмент. В стека L
      L          L са параметрите й. След завършване на     L
      L          L изпълнението й в стека остава резултата. L
------+----------+------------------------------------------+------------------
  5b  L          L                                          L
------+----------+------------------------------------------+------------------
  5c  L          L                                          L
------+----------+------------------------------------------+------------------
  5d  L FP prefixL FloatingPoint instructions prefix.       L { ? } -> { ? }
      L          L Всички инструкция за FP аритметиката     L
      L          L започват с така.                         L
------+----------+------------------------------------------+------------------
  5e  L StdIO    L STanDard I/O proc/funcs prefix           L
------+----------+------------------------------------------+------------------
  5f  L LYC      L Long Ycode instructions prefix           L
------+----------+------------------------------------------+------------------
  60  L EQUw     L EQUal Words                  b:= w1 = w2 L {w2,w1} -> { b }
------+----------+------------------------------------------+------------------
  61  L NEQw     L Not EQual Words             b:= w1 <> w2 L {w2,w1} -> { b }
------+----------+------------------------------------------+------------------
  62  L LESi     L LESs than Integers           b:= i1 < i2 L {i2,i1} -> { b }
------+----------+------------------------------------------+------------------
  63  L LEQi     L Less than or EQual Integers b:= i1 <= i2 L {i2,i1} -> { b }
------+----------+------------------------------------------+------------------
  64  L LESc     L LESs than Cardinals          b:= c1 < c2 L {c2,c1} -> { b }
------+----------+------------------------------------------+------------------
  65  L LEQc     L Less than or EQual Cardinals b:= c1 <= c2L {c2,c1} -> { b }
------+----------+------------------------------------------+------------------
  66  L EQUptr   L EQUal PoinTeRs               b:= p1 = p2 L {p2,p1} -> { b }
------+----------+------------------------------------------+------------------
  67  L NEQptr   L Not EQual PoinTeRs          b:= p1 <> p2 L {p2,p1} -> { b }
------+----------+------------------------------------------+------------------
  68  L EQUd     L EQUal Double words         b:= dw1 = dw2 L {dw2,dw1} -> {b}
------+----------+------------------------------------------+------------------
  69  L NEQd     L Not EQual Double words    b:= dw1 <> dw2 L {dw2,dw1} -> {b}
------+----------+------------------------------------------+------------------
  6a  L LESl     L LESs than LongInts         b:= li1 < li2 L {li2,li1} -> {b}
------+----------+------------------------------------------+------------------
  6b  L LEQl     L Less than or EQual LongInts b:= li1<=li2 L {li2,li1} -> {b}
------+----------+------------------------------------------+------------------
  6c  L          L                                          L
------+----------+------------------------------------------+------------------
  6d  L          L                                          L
------+----------+------------------------------------------+------------------
  6e  L NOP      L No OPeration (do nothing)                L { } -> { }
------+----------+------------------------------------------+------------------
  6f  L BNOT     L Boolean NOT                  b2:= not b1 L { b1 } -> { b2 }
------+----------+------------------------------------------+------------------
  70  L Ljump rw L Long unconditional JUMP                  L { } -> { }
------+----------+------------------------------------------+------------------
  71  L SFjump r+L Short Forward unconditional JUMP         L { } -> { }
------+----------+------------------------------------------+------------------
  72  L SBjump r+L Short Backword unconditional JUMP        L { } -> { }
------+----------+------------------------------------------+------------------
  73  L LFjump rwL Long False JUMP                          L { b } -> { }
------+----------+------------------------------------------+------------------
  74  LSFFjump r+L Short False Forward JUMP                 L { b } -> { }
------+----------+------------------------------------------+------------------
  75  LSFBjump r+L Short False Backword JUMP                L { b } -> { }
------+----------+------------------------------------------+------------------
  76  L LOjump rwL Long Or else JUMP                        L { b } -> { }  или
      L          L Ако на върха на стека има TRUE се прави  L { b } -> { b }
      L          L преход и стека остава същия, а ако има   L
      L          L FALSE не се прави преход, но от стека се L
      L          L вади това FALSE. Прехода е дълъг т.е. па-L
      L          L раметъра е дума (relative)               L
------+----------+------------------------------------------+------------------
  77  L SOjump r+L Short Or else JUMP                       L { b } -> { }  или
      L          L Положениeтo е аналогично не LOjump, но   L { b } -> { b }
      L          L прехода е къс преход напред (short rel)  L
      L          L и при това е само напред.                L
------+----------+------------------------------------------+------------------
  78  L          L                                          L
------+----------+------------------------------------------+------------------
  79  L          L                                          L
------+----------+------------------------------------------+------------------
  7a  L          L                                          L
------+----------+------------------------------------------+------------------
  7b  L LTjump rwL Long True JUMP                           L { b } -> { }
------+----------+------------------------------------------+------------------
  7c  LSTFjump r+L Short True Forward JUMP                  L { b } -> { }
------+----------+------------------------------------------+------------------
  7d  LSTBjump r+L Short True Backword JUMP                 L { b } -> { }
------+----------+------------------------------------------+------------------
  7е  L LAjump rwL Long And then JUMP                       L { b } -> { }  или
      L          L Ако на върха на стека има FALSE се прави L { b } -> { b }
      L          L преход и стека остава същия, а ако има   L
      L          L TRUE не се прави преход, но от стека се  L
      L          L вади това TRUE. Прехода е дълъг т.е. па- L
      L          L раметъра е дума (relative)               L
------+----------+------------------------------------------+------------------
  7f  L SAjump r+L Short And then JUMP                      L { b } -> { }  или
      L          L Положениeтo е аналогично не LAjump, но   L { b } -> { b }
      L          L прехода е къс преход напред (short rel)  L
      L          L и при това е само напред.                L
------+----------+------------------------------------------+------------------
  80  L LDCB b   L LoaD Constant Byte                       L { } -> { w }
      L          L Зареждане константата <b> като 16 битова L
      L          L дума в стека (старши байт $00).          L
------+----------+------------------------------------------+------------------
  81  L LDCNB b  L LoaD Constant negative Byte              L { } -> { w }
      L          L Зареждане константата <b> като 16 битова L
      L          L дума в стека със старши байт $ff.        L
------+----------+------------------------------------------+------------------
  82  L LDCW  w  L LoaD Constant Word                       L { } -> { w }
      L          L Зареждане константата <w> като дума 16bitL
------+----------+------------------------------------------+------------------
  83  L LDCDW dw L LoaD Constant Double Word                L { } -> { dw }
------+----------+------------------------------------------+------------------
  84  L LDCWD w  L LoaD Constant Word as Double word        L { } -> { dw }
      L          L Зареждане константата <w> като 32 битова L
      L          L двойна дума в стека (старша част $0000)  L
------+----------+------------------------------------------+------------------
  85  L LDCBD b  L LoaD Constant Byte as Double word        L { } -> { dw }
      L          L Зареждане константата <b> като 32 битова L
      L          L двойна дума в стека (старша част $000000)L
------+----------+------------------------------------------+------------------
  86  L LDCNBD b L LoaD Constant negative Byte as Dbl word  L { } -> { dw }
      L          L Зареждане константата <b> като 32 битова L
      L          L двойна дума в стека (старша част $ffffff)L
------+----------+------------------------------------------+------------------
  87  L LDCN     L LoaD Constant Nil                        L { } -> { p }
      L          L Зареждане на константата Nil.            L
------+----------+------------------------------------------+------------------
  88  L LDB      L LoaD Byte                                L { w, p } -> { w }
      L          L Зареждане на байт намиращ се на адрес    L
      L          L addr = p + w, като 16 битова дума.       L
      L          L Баита е число без знак (0..255)          L
------+----------+------------------------------------------+------------------
  89  L STB      L STore Byte                               L {w1,w2,p} -> { }
      L          L Записваме байта от върха на стека <w1>   L
      L          L (представен като 16 битова дума) по адресL
      L          L addr = p + w.                            L
------+----------+------------------------------------------+------------------
  8a  L LDSB     L LoaD Signed Byte                         L { w, p } -> { w }
      L          L Зареждане на байт намиращ се на адрес    L
      L          L addr = p + w, като 16 битова дума.       L
      L          L Баита е число със знак (-128..127)       L
------+----------+------------------------------------------+------------------
  8b  L          L                                          L
------+----------+------------------------------------------+------------------
  8c  L          L                                          L
------+----------+------------------------------------------+------------------
  8d  L LDCA w   L LoaD Constant Address                    L { } -> { p }
      L          L Зареждане адреса на константа от Cpool наL
      L          L текущия сегмент.                         L
------+----------+------------------------------------------+------------------
  8е  L LDGCA w  L LoaD Global Constant Address             L { } -> { p }
      L          L Зареждане адреса на константа от Cpool наL
      L          L глобалния сегмент.                       L
------+----------+------------------------------------------+------------------
  8f  LLDXCA bt,wL LoaD eXternal Constant Address           L { } -> { p }
      L          L Зареждане адреса на константа от Cpool наL
      L          L сегмент номер <bt>.                      L
------+----------+------------------------------------------+------------------
  90  L LAL big  L Load address of Local (offset = big)     L  { } -> { p }
------+----------+------------------------------------------+------------------
  91  L LAG big  L Load address of Global (offset = big)    L  { } -> { p }
------+----------+------------------------------------------+------------------
  92  L LAI bt,bgL Load address of Intermediate(bt lexs out)L  { } -> { p }
------+----------+------------------------------------------+------------------
  93  L LAX bt,bgL Load address of eXternal (from seg bt)   L  { } -> { p }
------+----------+------------------------------------------+------------------
94..97L SLAX_x bgL Short Load address of eXternal           L  { } -> { p }
------+----------+------------------------------------------+------------------
  98  L LDL big  L Load Local word (offset = big)           L  { } -> { w }
------+----------+------------------------------------------+------------------
  99  L LDG big  L Load Global word (offset = big)          L  { } -> { w }
------+----------+------------------------------------------+------------------
  9a  L LDI bt,bgL Load Intermediate word (bt lexs out)     L  { } -> { w }
------+----------+------------------------------------------+------------------
  9b  L LDX bt,bgL Load eXternal word                       L  { } -> { w }
------+----------+------------------------------------------+------------------
9b..9fL SLDX_x bgL Short Load eXternal word                 L  { } -> { w }
------+----------+------------------------------------------+------------------
  a0  L LDDL big L Load Double Local word (offset = big)    L  { } -> { dw }
------+----------+------------------------------------------+------------------
  a1  L LDDG big L Load Double Global word (offset = big)   L  { } -> { dw }
------+----------+------------------------------------------+------------------
  a2  LLDDI bt,bgL Load Dbl Intermediate word (bt lexs out) L  { } -> { dw }
------+----------+------------------------------------------+------------------
  a3  LLDDX bt,bgL Load Dbl eXternal word                   L  { } -> { dw }
------+----------+------------------------------------------+------------------
a4..a7LSLDDX_x bgL Short Load Dbl eXternal word             L  { } -> { dw }
------+----------+------------------------------------------+------------------
  a8  L STL big  L Store Local word (offset = big)          L  { w } -> { }
------+----------+------------------------------------------+------------------
  a9  L STG big  L Store Global word (offset = big)         L  { w } -> { }
------+----------+------------------------------------------+------------------
  aa  L STI bt,bgL Store Intermediate word (bt lexs out)    L  { w } -> { }
------+----------+------------------------------------------+------------------
  ab  L STX bt,bgL Store eXternal word                      L  { w } -> { }
------+----------+------------------------------------------+------------------
ac..afL SSTX_x bgL Short Store eXternal word                L  { w } -> { }
------+----------+------------------------------------------+------------------
  b0  L STDL big L Store Local Double word (offset = big)   L  { dw } -> { }
------+----------+------------------------------------------+------------------
  b1  L STDG big L Store Global Double word (offset = big)  L  { dw } -> { }
------+----------+------------------------------------------+------------------
  b2  LSTDI bt,bgL Store Intermediate Dbl word (bt lexs out)L  { dw } -> { }
------+----------+------------------------------------------+------------------
  b3  LSTDX bt,bgL Store Dbl eXternal word                  L  { dw } -> { }
------+----------+------------------------------------------+------------------
b4..b7LSSTDX_x bgL Short Store Dbl eXternal word            L  { dw } -> { }
------+----------+------------------------------------------+------------------
  b8  L SLAI1 bg L Load address of Parent variable          L  { } -> { p }
------+----------+------------------------------------------+------------------
  b9  L SLAI2 bg L Load address of GrandParent variable     L  { } -> { p }
------+----------+------------------------------------------+------------------
  ba  L ID_wrd btL Increment/Decrement WoRD                 L
      L          L Ако старшия бит на дадения байт е 0      L
      L          L се прави increment иначе decrement       L
      L          L Ако останалите 7 бита от байта са 0 то =>L { w, p } -> { }
      L          L  се увеличава/намалява думата чиито адресL
      L          L  е даден от p със стойността на думата w L
      L          L иначе                                  =>L { p } -> { }
      L          L  стойността на думата с адрес p се       L
      L          L  увеличава/намалява с байта без първия   L
      L          L  бит (0..127)                            L
------+----------+------------------------------------------+------------------
  bb  L ID_dbl btL Increment/Decrement DouBLe word          L
      L          L Ако старшия бит на дадения байт е 0      L
      L          L се прави increment иначе decrement       L
      L          L Ако останалите 7 бита от байта са 0 то =>L { dw, p } -> { }
      L          L  се увеличава/намалява двойната думата   L
      L          L  чиито адрес е даден от p със стойността L
      L          L  на двойната дума dw                     L
      L          L иначе                                  =>L { p } -> { }
      L          L  стойността на двойната дума с адрес p   L
      L          L  се увеличава/намалява с байта без       L
      L          L  първия бит (0..127)                     L
------+----------+------------------------------------------+------------------
  bc  L ID_bt  btL Increment/Decrement byte                 L
      L          L Ако старшия бит на дадения байт е 0      L
      L          L се прави increment иначе decrement       L
      L          L Ако останалите 7 бита от байта са 0 то =>L { w, p } -> { }
      L          L  се увеличава/намалява байта             L
      L          L  чиито адрес е даден от p със стойността L
      L          L  на думата w                             L
      L          L иначе                                  =>L { p } -> { }
      L          L  стойността на байта с адрес p           L
      L          L  се увеличава/намалява с байта без       L
      L          L  първия бит (0..127)                     L
------+----------+------------------------------------------+------------------
  bd  L LoChk    L Check Lo bound                           L {l, li} -> { li }
      L          L Check that l <= li and leave li in stack L
      L          L if OK, force run time error if not       L
------+----------+------------------------------------------+------------------
  be  L HiChk    L Check Hi bound                           L {l, li} -> { li }
      L          L Check that li <= l and leave li in stack L
      L          L if OK, force run time error if not       L
------+----------+------------------------------------------+------------------
  bf  L IOchk    L CHecK for I/O error (force runtime error)L  {} -> {}
------+----------+------------------------------------------+------------------
  c0  L SLDI1 bg L Load word from Parent proc               L  { } -> { w }
------+----------+------------------------------------------+------------------
  c1  L SLDI2 bg L Load word from GrandParent proc          L  { } -> { w }
------+----------+------------------------------------------+------------------
  c2  L IXFA byteL Index Foraml array                       L{p,w...w,p} -> {p}
      L          L Stack: { at, xN, ... x2, x1, a } -> { A }L
      L          L индексиране на формален масив това значи:L
      L          L x1,x2, ...,xN са индексите в масив които L
      L          L са на брой <byte>, at е адрес на таблица L
      L          L от вида: m1,s1,m2,s2,... където m1,m2,...L
      L          L са долните граници в масива, а s1,s2, ...L
      L          L са големините на подмасивите за съответ- L
      L          L ната размерност. <a> е началния адрес на L
      L          L масива. <A> е получения адрес.сметката е:L
      L          L A = a+[(m1-x1)*s1+...+(mN-xN)*sN]; като  L
      L          L това което е в счупени скоби трябва      L
      L          L да се умножи по 2 ако става въпрос за    L
      L          L думови неща, щото m1,m2,... са в думи    L
------+----------+------------------------------------------+------------------
  c3  L IXFPA bt L Index Foraml Packed array                L{p,w...w,p} -> {p}
      L          L виж IXFA                                 L
------+----------+------------------------------------------+------------------
  c4  L SIXA1    L Short IndeX Array element size 1 word    L { i, p } -> { P }
      L          L P:= p + i * 2 * 1, i - index in array    L
      L          L                    p - array address     L
------+----------+------------------------------------------+------------------
  c5  L SIXA2    L Short IndeX Array element size 2 words   L { i, p } -> { P }
      L          L P:= p + i * 2 * 2, i - index in array    L
      L          L                    p - array address     L
------+----------+------------------------------------------+------------------
  c6  L IXA  big L IndeX Array with element size big words  L { i, p } -> { P }
      L          L P:= p + i * 2 * big, i - index in array  L
      L          L                      p - array address   L
------+----------+------------------------------------------+------------------
  c7  L SIXA4    L Short IndeX Array element size 4 words   L { i, p } -> { P }
      L          L P:= p + i * 2 * 4, i - index in array    L
      L          L                    p - array address     L
------+----------+------------------------------------------+------------------
  c8  L SLDDI1 bgL Load Double word from Parent proc        L  { } -> { dw }
------+----------+------------------------------------------+------------------
  c9  L SLDDI2 bgL Load Double word from GrandParent proc   L  { } -> { dw }
------+----------+------------------------------------------+------------------
  ca  L          L                                          L
------+----------+------------------------------------------+------------------
  cb  L          L                                          L
------+----------+------------------------------------------+------------------
  cc  L INDD big L Load Indirect Double word                L { p } -> { dw }
      L          L load double word pointed at by p+<big>*2 L
------+----------+------------------------------------------+------------------
  cd  L SINDD0   L Short Load indirect double word          L { p } -> { dw }
      L          L load double word pointed at by p         L
------+----------+------------------------------------------+------------------
  ce  L INCFP bg L Increment Field Pointer                  L { p } -> { p1 }
      L          L calculate addr of field with <big> offs  L
      L          L p1:= p + big * 2                         L
------+----------+------------------------------------------+------------------
  cf  L IND  big L load INDirect word with offset <big>.    L     { p } -> { w }
      L          L Зарежда в стека дума която се намира на  L
      L          L адрес: p + 2*big (big е offset в думи)   L
------+----------+------------------------------------------+------------------
  d0  L SSTI1 bg L Store word in Parent proc                L  { w } -> { }
------+----------+------------------------------------------+------------------
  d1  L SSTI2 bg L Store word in GrandParent proc           L  { w } -> { }
------+----------+------------------------------------------+------------------
  d2  L          L                                          L
------+----------+------------------------------------------+------------------
  d3  L          L                                          L
------+----------+------------------------------------------+------------------
  d4  L          L                                          L
------+----------+------------------------------------------+------------------
  d5  L          L                                          L
------+----------+------------------------------------------+------------------
  d6  L          L                                          L
------+----------+------------------------------------------+------------------
  d7  L pckAddr  L Convert packed pointer to pointer        L { w, p } -> { w }
------+----------+------------------------------------------+------------------
  d8  L SSTDI1 bgL Stroe Double word in Parent proc         L  { dw } -> { }
------+----------+------------------------------------------+------------------
  d9  L SSTDI2 bgL Store Double word in GrandParent proc    L  { dw } -> { }
------+----------+------------------------------------------+------------------
  da  L MOV  big L Transfer a source block of <big> words,  L{Psrc, Pdest} ->{}
      L          L pointed to by <Psrc>, to a similar       L
      L          L destination block pointed to by <Pdest>. L
------+----------+------------------------------------------+------------------
  db  L MOVp big L Transfer a source block of <big> bytes,  L{Osrc,Psrc,
      L          L pointed to by <Psrc> + <Osrc>, to a      L Odest,Pdest} ->{}
      L          L similar destination block pointed to by  L
      L          L <Pdest> + <Odest>.                       L
------+----------+------------------------------------------+------------------
  dc  L SSTO     L Short STOre indirect word         p^:= w L  { w, p } -> { }
------+----------+------------------------------------------+------------------
  dd  L SSTOD    L Short Store Indirect Double word         L { dw, p } -> { }
------+----------+------------------------------------------+------------------
  de  L STO  big L STOre indirect word        p^[big*2]:= w L  { w, p } -> { }
------+----------+------------------------------------------+------------------
  df  L STOD big L STOre indirect Double word (with offset) L { dw, p } -> { }
------+----------+------------------------------------------+------------------
  e0  L sas  byteL String assign                            L { Sp, Dp } -> {}
------+----------+------------------------------------------+------------------
  e1  L sasf     L String Assign formal                     L {Sp,sz,Dp} -> {}
------+----------+------------------------------------------+------------------
  e2  L ch2str   L Convert Char to string                   L { w } -> { p }
------+----------+------------------------------------------+------------------
  e3  L eqstr    L Equal strings                b:= s2 = s1 L {s1, s2} -> { b }
------+----------+------------------------------------------+------------------
  e4  L neqstr   L Not Equal strings           b:= s2 <> s1 L {s1, s2} -> { b }
------+----------+------------------------------------------+------------------
  e5  L lesstr   L Less than strings            b:= s2 < s1 L {s1, s2} -> { b }
------+----------+------------------------------------------+------------------
  e6  L leqstr   L Less than or equal strings  b:= s2 <= s1 L {s1, s2} -> { b }
------+----------+------------------------------------------+------------------
  e7  L NULLSTR  L loae aeeress of NULL STRing (i.e. '')    L  { } -> { p }
------+----------+------------------------------------------+------------------
  e8  L SLEN     L return String LENgth (TOS is aeer(s))    L  { p } -> { w }
------+----------+------------------------------------------+------------------
  e9  L          L                                          L
------+----------+------------------------------------------+------------------
  ea  L          L                                          L
------+----------+------------------------------------------+------------------
  eb  L          L                                          L
------+----------+------------------------------------------+------------------
  ec  L          L                                          L
------+----------+------------------------------------------+------------------
  ed  L          L                                          L
------+----------+------------------------------------------+------------------
  ee  L          L                                          L
------+----------+------------------------------------------+------------------
  ef  LpackCMP btL Compare packed array of char (size in bg)L
      L        bgL в <bt> пише вида на сравнението и на     L
      L          L адресите в стека, ако bt < 0 то ===>     L{Do,Dp,So,Sp}->{b}
      L          L   в стека има pack pointers (src, dest)  L
      L          L иначе в стека има обикновени ptr         L {Dp, Sp} -> {b}
------+----------+------------------------------------------+------------------
  f0  L LCset    L Load Constant SET                        L  { p } -> { s }
      L          L На върха на стека е адрес на константно  L
      L          L м-во, основната разлика с LdSet инстр.   L
      L          L е че в константното мн-во влиза и дълж.  L
------+----------+------------------------------------------+------------------
  f1  L Adjust btL Adjust set to occuy N bytes              L { s } -> { s' }
------+----------+------------------------------------------+------------------
  f2  L SRS      L Build Subrange Set          s:= [i2..i1] L {i1, i2} -> { s }
------+----------+------------------------------------------+------------------
  f3  L SGS      L Build Singleton Set              s:= [i] L  { i } -> { s }
------+----------+------------------------------------------+------------------
  f4  L SetUni   L Set Union                    s:= s2 + s1 L {s1, s2} -> { s }
------+----------+------------------------------------------+------------------
  f5  L SetInt   L Set Intersection             s:= s2 * s1 L {s1, s2} -> { s }
------+----------+------------------------------------------+------------------
  f6  L SetDiff  L Set Difference               s:= s2 - s1 L {s1, s2} -> { s }
------+----------+------------------------------------------+------------------
  f7  L IN  byte L word/long IN set                         L { s, w } -> { b }
      L          L Ако параметъра на инструкцията <byte> е сL{ s, dw } -> { b }
      L          L вдигнат първи бит - значи имаме LongInt. L { p, w } -> { b }
      L          L Ако <byte> and $7f е <> 0 значи на върха L{ p, dw } -> { b }
      L          L на стека е адреса на мн-во и това е size,L
      L          L иначе мн-вото е на върха на стека.       L
------+----------+------------------------------------------+------------------
  f8  L InExcl btL INclude/EXCLude word to/from set         L  { w, p } -> { }
      L          L Ако параметъра на инструкцията <bt> е с  L
      L          L вдигнат първи бит - Exclude. Останалите 7L
      L          L бита са дължина на множеството в байтове.L
------+----------+------------------------------------------+------------------
  f9  L StoSet btL STOre SET (<bt> is set's size)    p^:= s L  { s, p } -> { }
------+----------+------------------------------------------+------------------
  fa  L LdSet bt L LoaD SET with size <bt>                    L  { p } -> { s }
      L          L На върха на стека е адрес на м-во, основ-L
      L          L ната разлика с LCSet инструкцията е че   L
      L          L дължината се дава от инструкцията.       L
------+----------+------------------------------------------+------------------
  fb  L EqSet    L Equal Sets                   b:= s2 = s1 L {s1, s2} -> { b }
------+----------+------------------------------------------+------------------
  fc  L NeqSet   L Not Equal Sets              b:= s2 <> s1 L {s1, s2} -> { b }
------+----------+------------------------------------------+------------------
  fd  L LeqSet   L Subset (less than or = )    b:= s2 <= s1 L {s1, s2} -> { b }
------+----------+------------------------------------------+------------------
  fe  L GeqSet   L Superset(greater than or =) b:= s2 >= s1 L {s1, s2} -> { b }
------+----------+------------------------------------------+------------------
  ff  L EmptySet L push EMPTY SET onto stack                L  { } -> { [] }
------+----------+------------------------------------------+------------------

                          Таблица на Ycode инструкциите

   г========T========T========T========T========T========T========T========+
   ¦ .0 /.8 ¦ .1 /.9 ¦ .2 /.a ¦ .3 /.b ¦ .4 /.c ¦ .5 /.d ¦ .6 /.e ¦ .7 /.f ¦
г==+========¦========¦========¦========¦========¦========¦========¦========+==+
¦00¦ SLDC_0 L SLDC_1 L SLDC_2 L SLDC_3 L SLDC_4 L SLDC_5 L SLDC_6 L SLDC_7 ¦07¦
¦==¦--------+--------+--------+--------+--------+--------+--------+--------¦==¦
¦08¦ SLDC_8 L SLDC_9 L SLDC_a L SLDC_b L SLDC_c L SLDC_d L SLDC_e L SLDC_f ¦0f¦
¦==+=======================================================================+==¦
¦10¦ SLDL_0 L SLDL_1 L SLDL_2 L SLDL_3 L SLDL_4 L SLDL_5 L SLDL_6 L SLDL_7 ¦17¦
¦==¦--------+--------+--------+--------+--------+--------+--------+--------¦==¦
¦18¦ SLDL_8 L SLDL_9 L SLDL_a L SLDL_b L SLDL_c L SLDL_d L SLDL_e L SLDL_f ¦1f¦
¦==+=======================================================================+==¦
¦20¦ SLDG_0 L SLDG_1 L SLDG_2 L SLDG_3 L SLDG_4 L SLDG_5 L SLDG_6 L SLDG_7 ¦27¦
¦==¦--------+--------+--------+--------+--------+--------+--------+--------¦==¦
¦28¦ SLDG_8 L SLDG_9 L SLDG_a L SLDG_b L SLDG_c L SLDG_d L SLDG_e L SLDG_f ¦2f¦
¦==+=======================================================================+==¦
¦30¦ SCXP_0 L SCXP_1 L SCXP_2 L SCXP_3 L SCXP_4 L SCXP_5 L SCXP_6 L SCXP_7 ¦37¦
¦  ¦  byte  L  byte  L  byte  L  byte  L  byte  L  byte  L  byte  L  byte  ¦37¦
¦==+=======================================================================+==¦
¦38¦ SIND_0 L SIND_1 L SIND_2 L SIND_3 L SIND_4 L SIND_5 L SIND_6 L SIND_7 ¦3f¦
¦==+========T========T========T========T========T========T========T========+==¦
¦40¦ ADDw   ¦ SUBw   ¦ ANDw   ¦ ORw    ¦ XORw   ¦ MULi   ¦ DIVi   ¦ MODi   ¦47¦
¦==+========+========+========+========+========+========+========+========+==¦
¦48¦        ¦        ¦ ItoL   ¦ WtoD   ¦ DtoW   ¦ MULc   ¦ DIVc   ¦ MODc   ¦4f¦
¦==+========+========+========+========+========+========+========+========+==¦
¦50¦ ADDd   ¦ SUBd   ¦ ANDd   ¦ ORd    ¦ XORd   ¦ MULl   ¦ DIVl   ¦ MODl   ¦57¦
¦==+========+========+========+========+========+========+========+========+==¦
¦58¦ CNP    ¦ CXP    ¦ CGP    ¦        ¦        ¦   FP   ¦ StdIO  ¦   LYC  ¦5f¦
¦  ¦ byte   ¦ bt,bt  ¦ byte   ¦        ¦        ¦ prefix ¦ prefix ¦ prefix ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦60¦ EQUw   ¦ NEQw   ¦ LESi   ¦ LEQi   ¦ LESc   ¦ LEQc   ¦ EQUptr ¦ NEQptr ¦67¦
¦==+========+========+========+========+========+========+========+========+==¦
¦68¦ EQUd   ¦ NEQd   ¦ LESl   ¦ LEQl   ¦        ¦        ¦ NOP    ¦  bnot  ¦6f¦
¦==+========+========+========+========+========+========+========+========+==¦
¦70¦ Ljump  ¦ SFjump ¦ SBjump ¦ LFjump ¦ SFFjump¦ SFBjump¦ LOjump ¦ SOjump ¦77¦
¦  ¦ Rword  ¦  rel+  ¦  rel-  ¦ Rword  ¦  rel+  ¦  rel-  ¦ Rword  ¦  rel+  ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦78¦        ¦        ¦        ¦ LTjump ¦ STFjump¦ STBjump¦ LAjump ¦ SAjump ¦7f¦
¦  ¦        ¦        ¦        ¦ Rword  ¦  rel+  ¦  rel-  ¦ Rword  ¦  rel+  ¦  ¦
L==+========+========+========+========+========+========+========+========+==+
   ¦ .0 /.8 ¦ .1 /.9 ¦ .2 /.a ¦ .3 /.b ¦ .4 /.c ¦ .5 /.d ¦ .6 /.e ¦ .7 /.f ¦
   L========¦========¦========¦========¦========¦========¦========¦========+

   г========T========T========T========T========T========T========T========+
   ¦ .0 /.8 ¦ .1 /.9 ¦ .2 /.a ¦ .3 /.b ¦ .4 /.c ¦ .5 /.d ¦ .6 /.e ¦ .7 /.f ¦
г==+========+========+========+========+========+========+========+========+==+
¦80¦  ldcb  ¦  ldcNb ¦  ldcw  ¦  ldcdw ¦  ldcwD ¦  ldcbd ¦ ldcNbd ¦  ldcn  ¦87¦
¦  ¦  byte  ¦  byte  ¦  word  ¦dbl word¦  word  ¦  byte  ¦  byte  ¦        ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦88¦  ldb   ¦  stb   ¦  ldsb  ¦        ¦        ¦ LDCA   ¦ LDGCA  ¦ LDXCA  ¦8f¦
¦  ¦        ¦        ¦        ¦        ¦        ¦ word   ¦ word   ¦  bt,w  ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦90¦  lal   ¦  lag   ¦  lai   ¦  lax   ¦ slax_1 ¦ slax_2 ¦ slax_3 ¦ slax_4 ¦97¦
¦  ¦  big   ¦  big   ¦byte,big¦byte,big¦  big   ¦  big   ¦  big   ¦  big   ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦98¦  ldl   ¦  ldg   ¦  ldi   ¦  ldx   ¦ sldx_1 ¦ sldx_2 ¦ sldx_3 ¦ sldx_4 ¦9f¦
¦  ¦  big   ¦  big   ¦byte,big¦byte,big¦  big   ¦  big   ¦  big   ¦  big   ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦a0¦  lddl  ¦  lddg  ¦  lddi  ¦  lddx  ¦ slddx_1¦ slddx_2¦ slddx_3¦ slddx_4¦a7¦
¦  ¦  big   ¦  big   ¦byte,big¦byte,big¦  big   ¦  big   ¦  big   ¦  big   ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦a8¦  stl   ¦  stg   ¦  sti   ¦  stx   ¦ sstx_1 ¦ sstx_2 ¦ sstx_3 ¦ sstx_4 ¦af¦
¦  ¦  big   ¦  big   ¦byte,big¦byte,big¦  big   ¦  big   ¦  big   ¦  big   ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦b0¦  stdl  ¦  stdg  ¦  stdi  ¦  stdx  ¦ sstdx_1¦ sstdx_2¦ sstdx_3¦ sstdx_4¦b7¦
¦  ¦  big   ¦  big   ¦byte,big¦byte,big¦  big   ¦  big   ¦  big   ¦  big   ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦b8¦  slai1 ¦  slai2 ¦ ID_wrd ¦ ID_dbl ¦ ID_bt  ¦ LOchk  ¦ HIchk  ¦  IOchk ¦bf¦
¦  ¦  big   ¦  big   ¦  byte  ¦  byte  ¦  byte  ¦        ¦        ¦        ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦c0¦  sldi1 ¦  sldi2 ¦  ixfa  ¦ ixfpa  ¦  sixa1 ¦  sixa2 ¦  ixa   ¦  sixa4 ¦c7¦
¦  ¦  big   ¦  big   ¦  byte  ¦  byte  ¦        ¦        ¦  big   ¦        ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦c8¦ slddi1 ¦ slddi2 ¦        ¦        ¦  indd  ¦ sindd0 ¦ incfp  ¦  ind   ¦cf¦
¦  ¦  big   ¦  big   ¦        ¦        ¦  big   ¦        ¦  big   ¦  big   ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦d0¦  ssti1 ¦  ssti2 ¦        ¦        ¦        ¦        ¦        ¦ pckAddr¦d7¦
¦  ¦  big   ¦  big   ¦        ¦        ¦        ¦        ¦        ¦        ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦d8¦ sstdi1 ¦ sstdi2 ¦  mov   ¦ movp   ¦  ssto  ¦  sstod ¦  sto   ¦  stod  ¦df¦
¦  ¦  big   ¦  big   ¦  big   ¦  big   ¦        ¦        ¦  big   ¦  big   ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦e0¦  sas   ¦  sasf  ¦ ch2str ¦  eqStr ¦ neqStr ¦ lesStr ¦ leqStr ¦ nullStr¦e7¦
¦  ¦  byte  ¦        ¦        ¦        ¦        ¦        ¦        ¦        ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦e8¦  slen  ¦        ¦        ¦        ¦        ¦        ¦        ¦ PackCmp¦ef¦
¦  ¦        ¦        ¦        ¦        ¦        ¦        ¦        ¦ bt,bg  ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦f0¦ LCset  ¦ Adjust ¦  srs   ¦  sgs   ¦ setUni ¦ setInt ¦ setDif ¦   IN   ¦f7¦
¦  ¦        ¦  byte  ¦        ¦        ¦        ¦        ¦        ¦  byte  ¦  ¦
¦==+========+========+========+========+========+========+========+========+==¦
¦f8¦ InExcl ¦ StoSET ¦  LdSet ¦ EqSet  ¦ NeqSet ¦ LeqSet ¦ GeqSet ¦EmptySet¦ff¦
¦  ¦  byte  ¦  byte  ¦  byte  ¦        ¦        ¦        ¦        ¦        ¦  ¦
L==+========+========+========+========+========+========+========+========+==+
   ¦ .0 /.8 ¦ .1 /.9 ¦ .2 /.a ¦ .3 /.b ¦ .4 /.c ¦ .5 /.d ¦ .6 /.e ¦ .7 /.f ¦
   L========¦========¦========¦========¦========¦========¦========¦========+








Файл STDPROC.
=============================================================================


                        Описание на Standard Proc/Funcs

-------------------------------------------------------------------------------
{ $02 } function RdInt: integer;

        Stack: { } -> { i }

-------------------------------------------------------------------------------
{ $03 } function RdCard: cardinal;

        Stack: { } -> { c }

-------------------------------------------------------------------------------
{ $04 } function RdLong: longint;

        Stack: { } -> { li }

-------------------------------------------------------------------------------
{ $05 } procedure WrLwrd(L: LongWord; Width: integer);
        begin write(L: Width); end;

        Stack: { Width, L } -> { }

-------------------------------------------------------------------------------
{ $06 } function RdReal: real;

        Stack: { } -> { r }

-------------------------------------------------------------------------------
{ $08 } function RdChar: char;

        Stack: { } -> { ch }

-------------------------------------------------------------------------------
{ $09 } procedure RdStr(var s: string);

        Stack: { sz, ^s } -> {  }

-------------------------------------------------------------------------------
{ $0a } function EOLN: boolean;

        Stack: { } -> { b }

-------------------------------------------------------------------------------
{ $0b } procedure RdLn;

        Stack: { } -> { }

-------------------------------------------------------------------------------
{ $0c } procedure WrInt(I: Integer; Width: integer);
        begin write(I: Width); end;

        Stack: { Width, I } -> { }

-------------------------------------------------------------------------------
{ $0d } procedure WrCard(C: Cardinal; Width: integer);
        begin write(C: Width); end;

        Stack: { Width, C } -> { }

-------------------------------------------------------------------------------
{ $0e } procedure WrLong(L: LongInt; Width: integer);
        begin write(L: Width); end;

        Stack: { Width, L } -> { }

-------------------------------------------------------------------------------
{ $0f } procedure WrWord(w: word; Width: integer; ndigits: word {= 2/4});

        Stack: { ndigits, Width, w } -> { }

-------------------------------------------------------------------------------
{ $10 } procedure WrReal(r: real; width, fraction: integer);

        Stack: { fraction, width, r } -> { }

-------------------------------------------------------------------------------
{ $12 } procedure WrChr(ch: char; Width: integer);
        begin write(ch: Width); end;

        Stack: { Width, ch } -> { }

-------------------------------------------------------------------------------
{ $13 } procedure WrStr(const s: string; Width: integer);
        begin write(s: Width); end;

        Stack: { Width, addr(s) } -> { }

-------------------------------------------------------------------------------
{ $14 } procedure WrPack(const Buff: packed array [0..Size-1] of char;
                 Width, Size: integer);
        begin write(Buff: Width); end;

        Stack: { Size, Width, addr(Buff) } -> { }

-------------------------------------------------------------------------------
{ $15 } procedure WrLine;
        begin writeln; end;

        Stack: { } -> { }

-------------------------------------------------------------------------------
{ $16 } function fRdInt(var f): integer;

        Stack: { f } -> { i }

-------------------------------------------------------------------------------
{ $17 } function RdCard(var f): cardinal;

        Stack: { f } -> { c }

-------------------------------------------------------------------------------
{ $18 } function RdLong(var f): longint;

        Stack: { f } -> { li }

-------------------------------------------------------------------------------
{ $19 } procedure fWrLwrd(var f; L: LongWord; Width: integer);
        begin write(f, L: Width); end;

        Stack: { Width, L, ^f } -> { ^f }

-------------------------------------------------------------------------------
{ $1a } function fRdReal(var f): real;

        Stack: { f } -> { r }

-------------------------------------------------------------------------------
{ $1c } function fRdChar(var f): char;

        Stack: { ^f } -> { ch }

-------------------------------------------------------------------------------
{ $1d } procedure fRdStr(var f; var s: string);

        Stack: { sz, ^s, ^f } -> {  }

-------------------------------------------------------------------------------
{ $1e } function fEOLN: boolean;

        Stack: { ^f } -> { b }

-------------------------------------------------------------------------------
{ $1f } procedure fRdLn;

        Stack: { ^f } -> { }

-------------------------------------------------------------------------------
{ $20 } procedure fWrInt(var f: text; I: Integer; Width: integer);
        begin write(f, I: Width); end;

        Stack: { Width, I, addr(f) } -> { addr(f) }

-------------------------------------------------------------------------------
{ $21 } procedure fWrCard(var f: text; C: Cardinal; Width: integer);
        begin write(f, C: Width); end;

        Stack: { Width, C, addr(f) } -> { addr(f) }

-------------------------------------------------------------------------------
{ $22 } procedure fWrLong(var f: text; L: LongInt; Width: integer);
        begin write(f, L: Width); end;

        Stack: { Width, L, addr(f) } -> { addr(f) }

-------------------------------------------------------------------------------
{ $23 } procedure fWrWord(var f; w:word; Width:integer; ndigits:word {= 2/4});

        Stack: { ndigits, Width, w, f } -> { f }

-------------------------------------------------------------------------------
{ $24 } procedure fWrReal(var f; r: real; width, fraction: integer);

        Stack: { fraction, width, r, ^f } -> { ^f }

-------------------------------------------------------------------------------
{ $26 } procedure fWrChr(var f: file; ch: char; Width: integer);
        begin write(f, ch: Width); end;

        Stack: { Width, ch, addr(f) } -> { addr(f) }

-------------------------------------------------------------------------------
{ $27 } procedure fWrStr(var f: file; const s: string; Width: integer);
        begin write(f, s: Width); end;

        Stack: { Width, addr(s), addr(f) } -> { addr(f) }

-------------------------------------------------------------------------------
{ $28 } procedure fWrPack(var f: text;
                          const Buff: packed array [0..Size-1] of char;
                          Width, Size: integer);
        begin write(f, Buff: Width); end;

        Stack: { Size, Width, addr(Buff), addr(f) } -> { addr(f) }

-------------------------------------------------------------------------------
{ $29 } procedure fWrLine(var f: text);
        begin writeln(f); end;

        Stack: { addr(f) } -> { }

-------------------------------------------------------------------------------
{ $2a } procedure Finit(var f: file; RecSize: Cardinal;
                        Kind: (Normal, Packed, text, file));
        begin
           initialize file pointed at by <file>
           with record size <RecSize> and
           <Kind> = 0 - normal, 1 - packed, 2 - text, 3 - file
           { този вид номерация се генерира от стария компилатор }
           желателно е да бъде сменена на 0 - file, 1 - normal, 2 - text
        end;

        Stack: { Kind, RecSize, addr(f) } -> { }

------------------------------------------------------------------------------
{ $2b } procedure Fopen(var f: file; const Name: string; mode: word);
        begin
           open file pointed at by <file>
           if ^name = nil значи имаме reset(f) или подобните му там
            Open file with required mode = Hi(mode) send to UniDOS as Bregister
            Lo(mode): ABCDEFGH
                         |||\|__ Write/Read mode
                         |||____ append (ако е 1 то Write = 1 също)
                         ||_____ temporary
                         |______ create new file only
        end;

        Stack: { mode, ^name, ^f } -> { }

-------------------------------------------------------------------------------
{ $2c } procedure: Fclose(var f: file; mode: (FromCompiler,
                                              FromClose,
                                              TruncateClose,
                                              TruncOnly));
        Stack: { mode, ^f } -> { }

-------------------------------------------------------------------------------
{ $2d } function EOF: boolean;
        begin return(eof); end;

        Stack: { } -> { b }

-------------------------------------------------------------------------------
{ $2e } function fEOF(var f): boolean;
        begin return(eof(f)); end;

        Stack: { ^f } -> { b }

-------------------------------------------------------------------------------
{ $2f } procedure EndWr;
        generated at the end of every WRITE (but not WRITELN) procedure

        Stack: { } -> { }

-------------------------------------------------------------------------------
{ $30 } procedure fEndWr;
        generated at the end of every WRITE (but not WRITELN) procedure

        Stack: { } -> { }

-------------------------------------------------------------------------------
{ $31 } procedure BlockRW(var f: file; var Buff; Offset, Nbytes: Cardinal;
                          var Processed: word; Write: boolean);
        begin
        if processed <> nil then
          if write then
            blockwrite(f, buff[offset], Nbytes, processed^)
          else
            blockread(f, buff[offset], Nbytes, processed^)
        else
          if write then
            blockwrite(f, buff[offset], Nbytes)
          else
            blockread(f, buff[offset], Nbytes);
        end;

        Stack     { RW, addrP, Nbytes, Offset, AddrBuff, f } -> { }

-------------------------------------------------------------------------------
{ $32 } function Fpos(var f): longint;
        begin return(FilePos(f)); end;

        Stack: { f } -> { L }

-------------------------------------------------------------------------------
{ $33 } procedure Seek(var f; pos: longint);
        begin seek(f, pos) end;

        Stack: { L, f } -> { }

-------------------------------------------------------------------------------
{ $34 } function ParamCnt: Cardinal;
        begin return(ParamCnt); end;

        Stack: { } -> { w }

-------------------------------------------------------------------------------
{ $35 } procedure ParamStr(No: Natural; var s: string);
        begin s:= ParamStr(No); end;

        Stack: { sz, addr(s), w } -> { }

-------------------------------------------------------------------------------
{ $36 } function MsgLmt: Natural;
        begin return(ScreenSize(X)) end;

        Stack: { } -> { w }

-------------------------------------------------------------------------------
{ $37 } procedure Remove(const name: string);

        Stack: { ^name } -> { }

-------------------------------------------------------------------------------
{ $38 } function Fsize(var f): longint;
        begin return(FileSize(f)); end;

        Stack: { f } -> { L }

-------------------------------------------------------------------------------
{ $39 } procedure StdPut(var f; const buffer);

        Stack: { ^buffer, f } -> { }

-------------------------------------------------------------------------------
{ $3a } procedure StdGet(var f; var buffer);

        Stack: { ^buffer, f } -> { }

-------------------------------------------------------------------------------
{ $3b } procedure Rename(const old, new: string);

        Stack: { ^new, ^old } -> { }

-------------------------------------------------------------------------------


                         Таблица на Standard Proc/Funcs

   г========T========T========T========T========T========T========T========+
   ¦ .0 /.8 ¦ .1 /.9 ¦ .2 /.a ¦ .3 /.b ¦ .4 /.c ¦ .5 /.d ¦ .6 /.e ¦ .7 /.f ¦
г==+========+========+========+========+========+========+========+========+==+
¦00¦        ¦        ¦ RdInt  ¦ RdCard ¦ RdLong ¦ WrLwrd ¦ RdReal ¦        ¦07¦
¦==+========+========+========+========+========+========+========+========+==¦
¦08¦ RdChar ¦ RdStr  ¦ Eoln   ¦ RdLn   ¦ WrInt  ¦ WrCard ¦ WrLong ¦ WrWord ¦0f¦
¦==+========+========+========+========+========+========+========+========+==¦
¦10¦ WrReal ¦        ¦  WrChr ¦ WrStr  ¦ WrPack ¦ WrLine ¦ fRdInt ¦ fRdCard¦17¦
¦==+========+========+========+========+========+========+========+========+==¦
¦18¦ fRdLong¦ fWrLwrd¦ fRdReal¦        ¦ fRdChr ¦ fRdStr ¦ fEoln  ¦ fRdLn  ¦1f¦
¦==+========+========+========+========+========+========+========+========+==¦
¦20¦ fWrInt ¦ fWrCard¦ fWrLong¦ fWrWord¦ fWrReal¦        ¦ fWrChr ¦ fWrStr ¦27¦
¦==+========+========+========+========+========+========+========+========+==¦
¦28¦ fWrPack¦ fWrLine¦  Finit ¦ Fopen  ¦ Fclose ¦ EOF    ¦ fEOF   ¦ EndWr  ¦2f¦
¦==+========+========+========+========+========+========+========+========+==¦
¦30¦ fEndWr ¦BlockRW ¦ Fpos   ¦ seek   ¦ParamCnt¦ParamStr¦ MsgLmt ¦ Remove ¦37¦
¦==+========+========+========+========+========+========+========+========+==¦
¦38¦ Fsize  ¦ StdPut ¦ StdGet ¦ Rename ¦        ¦        ¦        ¦        ¦3f¦
L==+========+========+========+========+========+========+========+========+==+
   ¦ .0 /.8 ¦ .1 /.9 ¦ .2 /.a ¦ .3 /.b ¦ .4 /.c ¦ .5 /.d ¦ .6 /.e ¦ .7 /.f ¦
   L========¦========¦========¦========¦========¦========¦========¦========+