Файл 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========¦========¦========¦========¦========¦========¦========¦========+