Документация на Паскаль. Редакция 1990 года.

Подключите Ваш компьютер к проекту распределённых вычислений!
Этим Вы окажете большую помощь науке и медицине.
См. подробнее: 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 : 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 : 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 . 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 . 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 Зареждане константата като 16 битова L L L дума в стека (старши байт $00). L ------+----------+------------------------------------------+------------------ 81 L LDCNB b L LoaD Constant negative Byte L { } -> { w } L L Зареждане константата като 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 Зареждане константата като 32 битова L L L двойна дума в стека (старша част $000000)L ------+----------+------------------------------------------+------------------ 86 L LDCNBD b L LoaD Constant negative Byte as Dbl word L { } -> { dw } L L Зареждане константата като 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========¦========¦========¦========¦========¦========¦========¦========+