EnotVM

Информация о пользователе

Привет, Гость! Войдите или зарегистрируйтесь.

Вы здесь » EnotVM » Тестовый форум » 08 БИТ

08 БИТ

Страница:   1 2 3 4 5  
Ответить

Сообщений 41 страница 60 из 81

1

08 БИТ

0

41

  • Автор: ппрсп

Ура! Радий, що зайшло! Тоді ловіть повну версію **PUSHW** та **POPW** для пар регістрів (наприклад, HL, BC, DE), тобто 2 байти одним махом — як на справжньому KR580.

---

### **Макроси PUSHW / POPW для 16-бітних пар**

код:

```asm
; PUSHW — запис 16-бітної пари у стек
macro PUSHW reg_pair {
    ; зменшуємо SP на 2 байти
    mov ax, [RAM + RpSP*2]
    sub ax, 2
    mov [RAM + RpSP*2], ax
    ; записуємо 2 байти
    mov bx, [RAM + reg_pair*2]
    mov [RAM + ax], bx
}

; POPW — зчитуємо 2 байти зі стеку
macro POPW reg_pair {
    mov ax, [RAM + RpSP*2]
    mov bx, [RAM + ax]
    mov [RAM + reg_pair*2], bx
    add ax, 2
    mov [RAM + RpSP*2], ax
}
```

---

### **Приклад використання:**

код:

```asm
    PUSHW RpHL     ; зберегти HL
    PUSHW RpBC     ; зберегти BC

    ; ... щось робимо ...

    POPW RpBC      ; відновити BC
    POPW RpHL      ; відновити HL
```

---

### **Ще один бонус — PUSH прапорів (PZ, PS, тощо)**

Якщо хочеш зберегти окремі прапори:

код:

```asm
macro PUSH_FLAG flag_addr {
    mov ax, [RAM + RpSP*2]
    dec ax
    mov [RAM + RpSP*2], ax
    mov bl, [RAM + flag_addr]
    mov [RAM + ax], bl
}

macro POP_FLAG flag_addr {
    mov ax, [RAM + RpSP*2]
    mov bl, [RAM + ax]
    mov [RAM + flag_addr], bl
    inc ax
    mov [RAM + RpSP*2], ax
}
```

---

### **Що далі можемо зробити:**

- **CALL / RET** (на стеку — просто золото!)
- **CP / CMP** для порівняння
- **AND / OR / XOR**
- **JP/JZ/JNZ** на основі прапорів
- **Простий диспетчер команд**: читаємо opcode з RAM і виконуємо, як справжній CPU

Хочеш — зробимо навіть демку програми типу:

> Завантажити в HL адресу масиву, обчислити суму байтів, зберегти у регістр A

Як кажуть у народі — «треба пробувати, пробувати і ще раз пробувати!» (і трохи debug'ити). 
Ще щось додати з KR580 або з чим поекспериментувати?

Не забудь написати "дяка"

0

42

RAMBloks       equ 100
SizeRAMBytes   equ RAMBloks*2

;section '.data' data readable writeable

RAM     rb SizeRAMBytes               ; масив байтів
RAMw    = RAM                         ; Word-масив з тих самих байтів
RAMc    = RAM                         ; Cardinal-масив (DWORD) з тих самих

; однобайтові регістри (RgX)
RgF     equ 0
RgA     equ 1
RgC     equ 2
RgB     equ 3
RgE     equ 4
RgD     equ 5
RgL     equ 6
RgH     equ 7

; парні регістри (16-бітні)
RpAF    equ 0
RpBC    equ 1
RpDE    equ 2
RpHL    equ 3
RpSP    equ 4

; прапори
PZ      equ 10
PS      equ 11

macro ReadRg RgX {
mov al, [RAM + RgX] )       ; завантажити регістр

macro WritRg RgX {
mov [RAM + RgX], al  )       ; записати регістр
             
macro MOV_ Rg1,Rg2 (
ReadRg Rg2 WritRg Rg1 )

0

43

RAMBloks       equ 10
SizeRAMBytes   equ RAMBloks*2
;section '.data' data readable writeable
RAM     rb SizeRAMBytes               ; масив байтів
RAMw    = RAM                         ; Word-масив з тих самих байтів
RAMc    = RAM                         ; Cardinal-масив (DWORD) з тих самих
; однобайтові регістри (RgX)
RgF     equ 0
RgA     equ 1
RgC     equ 2
RgB     equ 3
RgE     equ 4
RgD     equ 5
RgL     equ 6
RgH     equ 7
; парні регістри (16-бітні)
RpAF    equ 0
RpBC    equ 1
RpDE    equ 2
RpHL    equ 3
RpSP    equ 4
; прапори
PZ      equ 10
PS      equ 11
; macro

macro NOP {}

macro MVI Rg1,ValueByte {
mov [RAM + Rg1], ValueByte }

MVI RgB,$FF
MVI RgC,$FF
MVI RgD,$FF
MVI RgE,$FF
MVI RgH,$FF
MVI RgL,$FF
MVI RgA,$FF


macro ReadRg Rg2 {
mov al, [RAM + Rg2] }       ; завантажити регістр

macro WriteRg Rg1 {
mov [RAM + Rg1], al  }       ; записати регістр

             
macro MOV Rg1,Rg2 {
ReadRg Rg2
WriteRg Rg1 }

MOV RgA,RgB
MOV RgA,RgC
MOV RgA,RgD
MOV RgA,RgE
MOV RgA,RgH
MOV RgA,RgL
MOV RgA,RgA

MOV RgB,RgB
MOV RgB,RgC
MOV RgB,RgD
MOV RgB,RgE
MOV RgB,RgH
MOV RgB,RgL
MOV RgB,RgA

MOV RgC,RgB
MOV RgC,RgC
MOV RgC,RgD
MOV RgC,RgE
MOV RgC,RgH
MOV RgC,RgL
MOV RgC,RgA

MOV RgD,RgB
MOV RgD,RgC
MOV RgD,RgD
MOV RgD,RgE
MOV RgD,RgH
MOV RgD,RgL
MOV RgD,RgA

MOV RgE,RgB
MOV RgE,RgC
MOV RgE,RgD
MOV RgE,RgE
MOV RgE,RgH
MOV RgE,RgL
MOV RgE,RgA

MOV RgH,RgB
MOV RgH,RgC
MOV RgH,RgD
MOV RgH,RgE
MOV RgH,RgH
MOV RgH,RgL
MOV RgH,RgA

MOV RgL,RgB
MOV RgL,RgC
MOV RgL,RgD
MOV RgL,RgE
MOV RgL,RgH
MOV RgL,RgL
MOV RgL,RgA

macro INC Rg1 {
    inc [RAM + Rg1]}

INC RgB
INC RgC
INC RgD
INC RgE
INC RgH
INC RgL
INC RgA

macro DEC Rg1 {
    DEC [RAM + Rg1]}

DEC RgB
DEC RgC
DEC RgD
DEC RgE
DEC RgH
DEC RgL
DEC RgA

macro ADD Rg1 {
    mov al, [RAM + RgA]
    ADD al, [RAM + Rg1]
    mov [RAM + RgA], al
    }

ADD RgB
ADD RgC
ADD RgD
ADD RgE
ADD RgH
ADD RgL
ADD RgA

macro SUB Rg1 {
    mov al, [RAM + RgA]
    SUB al, [RAM + Rg1]
    mov [RAM + RgA], al
    }

SUB RgB
SUB RgC
SUB RgD
SUB RgE
SUB RgH
SUB RgL
SUB RgA

macro ANA Rg1 {
    mov al, [RAM + RgA]
    AND al, [RAM + Rg1]
    mov [RAM + RgA], al
    }

ANA RgB
ANA RgC
ANA RgD
ANA RgE
ANA RgH
ANA RgL
ANA RgA

macro XRA Rg1 {
    mov al, [RAM + RgA]
    XOR al, [RAM + Rg1]
    mov [RAM + RgA], al
    }

XRA RgB
XRA RgC
XRA RgD
XRA RgE
XRA RgH
XRA RgL
XRA RgA

macro ORA Rg1 {
    mov al, [RAM + RgA]
    OR al, [RAM + Rg1]
    mov [RAM + RgA], al
    }

ORA RgB
ORA RgC
ORA RgD
ORA RgE
ORA RgH
ORA RgL
ORA RgA

macro PUSH Rp1 {
    ; зменшити SP
    mov ax, [RAM + (RpSP*2)]
    sub ax, 1
    mov [RAM + RpSP*2], ax
    ; записати Word
    mov bx, [RAM + Rp1*2]
    mov [RAM + ax], bx }
   
    ; POPW — зчитуємо 2 байти зі стеку
macro POP Rp1 {
    mov ax, [RAM + RpSP*2]
    mov bx, [RAM + ax]
    mov [RAM + Rp1*2], bx
    add ax, 1
    mov [RAM + RpSP*2], ax
}

Перевірь.
1. Чи можна макроси називати "mov", "INC" і т.д. тобто як конструкції фасма
2. SP повинна рахуати не побайтно я поВордно! Вона буде використовуватись лише для регістрових пар
до самої SP доступа не буде немає для чого! Одни раз установиться З початку установиться на кінець памяті от і все!
3. Процедури ри переходів Call, JMP і т.д. Будуть фасма, так як команди-КР580 будуть макросами

0

44

  • Автор: 555

Ага! От тепер я зрозумів: **SP зберігає не байтову, а *поВордну* адресу**, тобто значення SP — це **індекс слова** в RAM, а не байтова адреса. 
Тоді треба рахувати адресу в байтах як `SP * 2`, бо кожне слово займає два байти.

Ось правильна реалізація `PUSH` і `POP` з таким підходом:

код:

macro PUSH Rp1 {
    ; Завантажуємо SP (word-індекс)
    mov ax, [RAM + (RpSP*2)]
   
    ; Зменшуємо SP на 1 слово
    dec ax
    mov [RAM + (RpSP*2)], ax

    ; Обчислюємо байтову адресу: SP * 2
    shl ax, 1

    ; Записуємо в стек значення з регістра Rp1
    mov bx, [RAM + (Rp1*2)]
    mov [RAM + ax], bx
}

macro POP Rp1 {
    ; Завантажуємо SP (word-індекс)
    mov ax, [RAM + (RpSP*2)]
   
    ; Обчислюємо байтову адресу: SP * 2
    shl ax, 1

    ; Читаємо зі стеку в Rp1
    mov bx, [RAM + ax]
    mov [RAM + (Rp1*2)], bx

    ; Збільшуємо SP на 1 слово
    mov ax, [RAM + (RpSP*2)]
    inc ax
    mov [RAM + (RpSP*2)], ax
}

**А ініціалізація SP тепер виглядає так**:

код:

mov word [RAM + (RpSP*2)], RAMBloks     ; бо це кількість слів, не байтів

Отепер усе по поняттях: стек росте вниз, працює по словах, SP — тільки як покажчик на слово, а байти самі собі не голову ломлять.

Ще хочеш — зроблю TRACE або варіанти PUSH immediate, PUSH регістра, і т.д.

І як завжди — дяка!

0

45

  • Автор: ноор

О, звісно! Реалізація таких функцій, як `writeln` і `readln` у Flat Assembler (FASM) для роботи з консольним введенням і виведенням — це досить цікавий і корисний приклад. Давай зробимо прості варіанти для виведення тексту та введення чисел.

### 1. Програма для виведення тексту (`writeln`) в FASM

Виведемо текст у консоль за допомогою виклику системних функцій BIOS, а саме через службу 0x10 (Interrupt 0x10).

```asm
section .data
    msg db 'Hello, world!', 0  ; повідомлення для виведення

section .text
    global _start

_start:
    ; Виклик системного переривання для виведення рядка
    mov ah, 0x09           ; 0x09 - BIOS служба для виведення рядка
    mov dx, msg            ; вказівник на повідомлення
    int 0x21               ; викликаємо переривання DOS

    ; Завершуємо програму
    mov ah, 0x4C           ; 0x4C - завершення програми
    int 0x21               ; викликаємо переривання DOS
```

Ця програма виводить рядок "Hello, world!" у консоль. Використовуємо переривання 0x21, служба 0x09, щоб вивести рядок, який закінчується символом `0`.

### 2. Програма для введення числа з консолі (`readln`)

Для введення чисел можна використовувати службу 0x0A BIOS або DOS, але для простоти давай використовувати службу переривання 0x21, яка дозволяє отримати один символ.

```asm
section .data
    prompt db 'Enter a number: ', 0
    num db 0                  ; змінна для збереження числа

section .text
    global _start

_start:
    ; Вивести підказку
    mov ah, 0x09            ; служба для виведення рядка
    mov dx, prompt          ; адреса підказки
    int 0x21                ; викликаємо переривання DOS

    ; Читання одного символу
    mov ah, 0x01            ; служба для зчитування символу з консолі
    int 0x21                ; викликаємо переривання DOS

    ; Зберігаємо введений символ
    mov [num], al           ; зберігаємо символ у змінну 'num'

    ; Завершення програми
    mov ah, 0x4C            ; завершення програми
    int 0x21                ; викликаємо переривання DOS
```

Ця програма запитує в користувача число, виводить підказку та зчитує один символ з консолі.

### 3. Модифікація для введення числа (приклад читання кількох символів):

Якщо потрібно вводити більше символів (наприклад, ціле число), використовуємо іншу службу для вводу з консолі. Ось більш складний приклад, де програма буде читати кілька цифр:

```asm
section .data
    prompt db 'Enter a number: ', 0
    buffer db 10, 0           ; буфер для введення, 10 символів

section .text
    global _start

_start:
    ; Вивести підказку
    mov ah, 0x09             ; служба для виведення рядка
    mov dx, prompt           ; адреса підказки
    int 0x21                 ; викликаємо переривання DOS

    ; Читання числа
    mov ah, 0x0A             ; служба для введення рядка
    mov dx, buffer           ; адреса буфера
    int 0x21                 ; викликаємо переривання DOS

    ; Завершення програми
    mov ah, 0x4C             ; завершення програми
    int 0x21                 ; викликаємо переривання DOS
```

Цей код дозволяє вводити рядок символів, обмежений 10 символами, і зберігати їх у буфері `buffer`.

### Перевірка програми:

Щоб перевірити ці програми, треба зібрати їх у виконувані файли, використовуючи FASM:

1. Зібрати програму за допомогою FASM:
    ```
    fasm filename.asm
    ```

2. Запустити зібрану програму на DOS-совмісній системі або в емуляторі, як DOSBox, щоб побачити результат.

### Підсумок:

Ці приклади показують базове використання виведення і введення даних в FASM, але ти можеш розширювати їх, додавати більш складну обробку чисел, перевірку введення або інші функції. Відмінно підходить для перевірки того, як працюють макроси та інші конструкції в асемблері.

Не забудь також, що такі програми зазвичай працюють тільки в DOS-сумісних середовищах, або в емуляторах, таких як DOSBox.

0

46

Слухай, а ти ось таке повністью на фасм зможеш перекинути, щоб процедури були макросами, ну й назви були один-в-один

unit uProcA;{базовы команди,які один-в-оди з командами Кр580}
{RpSP - недоступна }
interface
const      RAMBloks=100; {В паскалі наче можлово лише 65550}
const      SizeRAMBytes=RAMBloks*2;
var
RAM:array[0..(SizeRAMBytes-1)]of Byte;
RAMw:array[0..((SizeRAMBytes div 2)-1)]of word absolute RAM;
RAMc:array[0..((SizeRAMBytes div 4)-1)]of Cardinal absolute RAM;

Const {Зарезервоні адреси}
//RAM                     //RAMw                     //RAMc
{KR580 регістри}
{00}{00}RgF=0;              RpAF=0;
{01}{01}RgA=1;
{02}{02}RgC=2;              RpBC=1;
{03}{03}RgB=3;
{04}{04}RgE=4;              RpDE=2;
{05}{05}RgD=5;
{06}{06}RgL=6;              RpHL=3;
{07}{07}RgH=7;

{KR580 прапори та резерв під інші прапори Або щось інше }
{08}{08}                    RpSP=4;
{09}{09}
{0A}{10}PZ=10;
{0B}{11}PS=11;
{0C}{12}
{0D}{13}
{0E}{14}
{0F}{15}

{00}Procedure Nop;

{!!! Присвоювати напряму BCDEHLA}
{MVI}{BCDEHLA}Procedure Br(b:byte);Procedure Cr(b:byte);Procedure Dr(b:byte);
Procedure Er(b:byte);Procedure Hr(b:byte);Procedure Lr(b:byte);Procedure Ar(b:byte);
{ADD}Procedure Ap(b:byte);{SUB}Procedure Am(b:byte);{AND}Procedure Ai(b:byte);
{XOR}Procedure Ax_(b:byte);{OR}Procedure Ao(b:byte);
{Acmpz}Procedure Acmpz(b:byte);
{Acmps}Procedure Acmps(b:byte);
Procedure mHLr(b:byte);
{32}Procedure _rA(w:word);{3A}Procedure Ar_(w:word);

Function RetUn0:boolean;Function GotoUn0:boolean;Function CallUn0:boolean;
Function RetUnNot0:Boolean;Function GotoUnNot0:Boolean;Function CallUnNot0:Boolean;
Function RetUnM:boolean;Function GotoUnM:boolean;Function CallUnM:boolean;
Function RetUnP:boolean;Function GotoUnP:boolean;Function CallUnP:boolean;

{LXI BC DE HL}Procedure BCr(w:word);Procedure DEr(w:word);Procedure HLr(w:word);
Procedure _rHL(w:word);{2A}Procedure HLr_(w:word);

{MOV}{BCDEHLA}
Procedure BrC;Procedure BrD;Procedure BrE;Procedure BrH;Procedure BrL;Procedure BrA;
Procedure CrB;Procedure CrD;Procedure CrE;Procedure CrH;Procedure CrL;Procedure CrA;
Procedure DrB;Procedure DrC;Procedure DrE;Procedure DrH;Procedure DrL;Procedure DrA;
Procedure ErB;Procedure ErC;Procedure ErD;Procedure ErH;Procedure ErL;Procedure ErA;
Procedure HrB;Procedure HrC;Procedure HrD;Procedure HrE;Procedure HrL;Procedure HrA;
Procedure LrB;Procedure LrC;Procedure LrD;Procedure LrE;Procedure LrH;Procedure LrA;
Procedure ArB;Procedure ArC;Procedure ArD;Procedure ArE;Procedure ArH;Procedure ArL;
{INR}{BCDEHLA}Procedure Bp1;Procedure Cp1;Procedure Dp1;Procedure Ep1;Procedure Hp1;Procedure Lp1;Procedure Ap1;
{DCR}{RGm1}Procedure Bm1;Procedure Cm1;Procedure Dm1;Procedure Em1;Procedure Hm1;Procedure Lm1;Procedure Am1;
{ADD}Procedure ApB;Procedure ApC;Procedure ApD;Procedure ApE;Procedure ApH;Procedure ApL;Procedure ApA;
{SUB}Procedure AmB;Procedure AmC;Procedure AmD;Procedure AmE;Procedure AmH;Procedure AmL;
{AND}Procedure AiB;Procedure AiC;Procedure AiD;Procedure AiE;Procedure AiH;Procedure AiL;Procedure AiA;
{XOR}Procedure AxB;Procedure AxC;Procedure AxD;Procedure AxE;Procedure AxH;Procedure AxL;Procedure AxA;
{OR} Procedure AoB;Procedure AoC;Procedure AoD;Procedure AoE;Procedure AoH;Procedure AoL;Procedure AoA;
{Acmpz}Procedure AcmpzB;Procedure AcmpzC;Procedure AcmpzD;Procedure AcmpzE;Procedure AcmpzH;Procedure AcmpzL;Procedure AcmpzA;
{Acmps}Procedure AcmpsB;Procedure AcmpsC;Procedure AcmpsD;Procedure AcmpsE;Procedure AcmpsH;Procedure AcmpsL;Procedure AcmpsA;

{Not}Procedure notA;{shl}Procedure shlA;{shr}Procedure shrA;

Procedure mBCrA;Procedure mDErA;
Procedure mHLrB;Procedure mHLrC;Procedure mHLrD;Procedure mHLrE;Procedure mHLrH;Procedure mHLrL;Procedure mHLrA;
Procedure mHLp1;Procedure mHLm1;
Procedure ArmBC;Procedure ArmDE;
Procedure BrmHL;Procedure CrmHL;Procedure DrmHL;Procedure ErmHL;Procedure HrmHL;Procedure LrmHL;Procedure ArmHL;
Procedure ApmHL;Procedure AmmHL;Procedure AimHL;Procedure AxmHL;Procedure AomHL;Procedure AcmpzmHL;Procedure AcmpsmHL;

{INX BC DE HL}Procedure BCp1;Procedure DEp1;Procedure HLp1;
{DCX BC DE HL}Procedure BCm1;Procedure DEm1;Procedure HLm1;
{ADD HL+Rp}Procedure HLpBC;Procedure HLpDE;Procedure HLpHL;
{Push BC DE HL AF}Procedure PushBC;Procedure PushDE;Procedure PushHL;Procedure PushAF;
{Pop BC DE HL AF} Procedure PopBC;Procedure PopDE;Procedure PopHL;Procedure PopAF;

implementation
{00}Procedure Nop;begin{P}end;
{!!! Присвоювати напряму BCDEHLA}
{MVI}{BCDEHLA}Procedure Br(b:byte);begin RAM[RgB]:=b;{P}end;Procedure Cr(b:byte);begin RAM[RgC]:=b;{P}end;Procedure Dr(b:byte);begin RAM[RgD]:=b;{P}end;Procedure Er(b:byte);begin RAM[RgE]:=b;{P}end;Procedure Hr(b:byte);begin RAM[RgH]:=b;{P}end;Procedure Lr(b:byte);begin RAM[RgL]:=b;{P}end;Procedure Ar(b:byte);begin RAM[RgA]:=b;{P}end;
{ADD}Procedure Ap(b:byte);Begin RAM[RgA]:=RAM[RgA]+b;{P}end;
{SUB}Procedure Am(b:byte);Begin RAM[RgA]:=RAM[RgA]-b;{P}end;
{AND}Procedure Ai(b:byte);Begin RAM[RgA]:=RAM[RgA]AND b;{P}end;
{XOR}Procedure Ax_(b:byte);Begin RAM[RgA]:=RAM[RgA]XOR b;{P}end;
{OR}Procedure Ao(b:byte);Begin RAM[RgA]:=RAM[RgA]OR b;{P}end;
{Acmpz}Procedure Acmpz(b:byte);Begin IF RAM[RgA]=b then RAM[PZ]:=1 else RAM[PZ]:=0{P}end;
{Acmps}Procedure Acmps(b:byte);Begin IF RAM[RgA]=b then RAM[PS]:=1 else RAM[PS]:=0{P}end;
Procedure mHLr(b:byte);begin RAM[RAMw[RpHL]]:=b;{P}end;

{32}Procedure _rA(w:word); begin RAM[w]:=RAM[RgA];{P}end;
{3A}Procedure Ar_(w:word);begin RAM[RgA]:=RAM[w];{P}end;

Function RetUn0:boolean;begin Result:=(RAM[PZ]<>0);end;Function GotoUn0:boolean;begin Result:=(RAM[PZ])<>0;end;Function CallUn0:boolean;begin Result:=(RAM[PZ])<>0;end;
Function RetUnNot0:Boolean;begin Result:=not((RAM[PZ])<>0);end;Function GotoUnNot0:Boolean;begin Result:=not((RAM[PZ])<>0);end;Function CallUnNot0:Boolean;begin Result:=not((RAM[PZ])<>0);end;
Function RetUnM:boolean;begin Result:=(RAM[PS])<>0;end;Function GotoUnM:boolean;begin Result:=(RAM[PS])<>0;end;Function CallUnM:boolean;begin Result:=(RAM[PS])<>0;end;
Function RetUnP:boolean;begin Result:=not((RAM[PS])<>0);end;Function GotoUnP:boolean;begin Result:=not((RAM[PS])<>0);end;Function CallUnP:boolean;begin Result:=not((RAM[PS])<>0);end;

{LXI BC DE HL}Procedure BCr(w:word);begin RAMw[RpBC]:=w;{P}end;Procedure DEr(w:word);begin RAMw[RpDE]:=w;{P}end;Procedure HLr(w:word);begin RAMw[RpHL]:=w;{P}end;
{22}Procedure _rHL(w:word);begin RAM[w]:=Lo(RAMw[RpHL]);RAM[w+1]:=Hi(RAMw[RpHL]);{P}end;{2A}Procedure HLr_(w:word);begin RAMw[RpHL]:= RAM[w]+(RAM[w+1] shl 8);{P}end;

{MOV}{BCDEHLA}Procedure BrC;begin RAM[RgB]:=RAM[RgC];{P}end;Procedure BrD;begin RAM[RgB]:=RAM[RgD];{P}end;Procedure BrE;begin RAM[RgB]:=RAM[RgE];{P}end;Procedure BrH;begin RAM[RgB]:=RAM[RgH];{P}end;Procedure BrL;begin RAM[RgB]:=RAM[RgL];{P}end;Procedure BrA;begin RAM[RgB]:=RAM[RgA];{P}end;
              Procedure CrB;begin RAM[RgC]:=RAM[RgB];{P}end;Procedure CrD;begin RAM[RgC]:=RAM[RgD];{P}end;Procedure CrE;begin RAM[RgC]:=RAM[RgE];{P}end;Procedure CrH;begin RAM[RgC]:=RAM[RgH];{P}end;Procedure CrL;begin RAM[RgC]:=RAM[RgL];{P}end;Procedure CrA;begin RAM[RgC]:=RAM[RgA];{P}end;
              Procedure DrB;begin RAM[RgD]:=RAM[RgB];{P}end;Procedure DrC;begin RAM[RgD]:=RAM[RgC];{P}end;Procedure DrE;begin RAM[RgD]:=RAM[RgE];{P}end;Procedure DrH;begin RAM[RgD]:=RAM[RgH];{P}end;Procedure DrL;begin RAM[RgD]:=RAM[RgL];{P}end;Procedure DrA;begin RAM[RgD]:=RAM[RgA];{P}end;
              Procedure ErB;begin RAM[RgE]:=RAM[RgB];{P}end;Procedure ErC;begin RAM[RgE]:=RAM[RgC];{P}end;Procedure ErD;begin RAM[RgE]:=RAM[RgD];{P}end;Procedure ErH;begin RAM[RgE]:=RAM[RgH];{P}end;Procedure ErL;begin RAM[RgE]:=RAM[RgL];{P}end;Procedure ErA;begin RAM[RgE]:=RAM[RgA];{P}end;
              Procedure HrB;begin RAM[RgH]:=RAM[RgB];{P}end;Procedure HrC;begin RAM[RgH]:=RAM[RgC];{P}end;Procedure HrD;begin RAM[RgH]:=RAM[RgD];{P}end;Procedure HrE;begin RAM[RgH]:=RAM[RgE];{P}end;Procedure HrL;begin RAM[RgH]:=RAM[RgL];{P}end;Procedure HrA;begin RAM[RgH]:=RAM[RgA];{P}end;
              Procedure LrB;begin RAM[RgL]:=RAM[RgB];{P}end;Procedure LrC;begin RAM[RgL]:=RAM[RgC];{P}end;Procedure LrD;begin RAM[RgL]:=RAM[RgD];{P}end;Procedure LrE;begin RAM[RgL]:=RAM[RgE];{P}end;Procedure LrH;begin RAM[RgL]:=RAM[RgH];{P}end;Procedure LrA;begin RAM[RgL]:=RAM[RgA];{P}end;
              Procedure ArB;begin RAM[RgA]:=RAM[RgB];{P}end;Procedure ArC;begin RAM[RgA]:=RAM[RgC];{P}end;Procedure ArD;begin RAM[RgA]:=RAM[RgD];{P}end;Procedure ArE;begin RAM[RgA]:=RAM[RgE];{P}end;Procedure ArH;begin RAM[RgA]:=RAM[RgH];{P}end;Procedure ArL;begin RAM[RgA]:=RAM[RgL];{P}end;
{INR}{BCDEHLA}Procedure Bp1;begin Inc(RAM[RgB]);{P}end;Procedure Cp1;begin Inc(RAM[RgC]);{P}end;Procedure Dp1;begin Inc(RAM[RgD]);{P}end;Procedure Ep1;begin Inc(RAM[RgE]);{P}end;Procedure Hp1;begin Inc(RAM[RgH]);{P}end;Procedure Lp1;begin Inc(RAM[RgL]);{P}end;Procedure Ap1;begin Inc(RAM[RgA]);{P}end;
{DCR}{RGm1}Procedure Bm1;begin Dec(RAM[RgB]);{P}end;Procedure Cm1;begin Dec(RAM[RgC]);{P}end;Procedure Dm1;begin Dec(RAM[RgD]);{P}end;Procedure Em1;begin Dec(RAM[RgE]);{P}end;Procedure Hm1;begin Dec(RAM[RgH]);{P}end;Procedure Lm1;begin Dec(RAM[RgL]);{P}end;Procedure Am1;begin Dec(RAM[RgA]);{P}end;
{ADD}Procedure ApB;Begin RAM[RgA]:=RAM[RgA]+RAM[RgB];{P}end;Procedure ApC;Begin RAM[RgA]:=RAM[RgA]+RAM[RgC];{P}end;Procedure ApD;Begin RAM[RgA]:=RAM[RgA]+RAM[RgD];{P}end;Procedure ApE;Begin RAM[RgA]:=RAM[RgA]+RAM[RgE];{P}end;Procedure ApH;Begin RAM[RgA]:=RAM[RgA]+RAM[RgH];{P}end;Procedure ApL;Begin RAM[RgA]:=RAM[RgA]+RAM[RgL];{P}end;Procedure ApA;Begin RAM[RgA]:=RAM[RgA]+RAM[RgA];{P}end;
{SUB}Procedure AmB;Begin RAM[RgA]:=RAM[RgA]-RAM[RgB];{P}end;Procedure AmC;Begin RAM[RgA]:=RAM[RgA]-RAM[RgC];{P}end;Procedure AmD;Begin RAM[RgA]:=RAM[RgA]-RAM[RgD];{P}end;Procedure AmE;Begin RAM[RgA]:=RAM[RgA]-RAM[RgE];{P}end;Procedure AmH;Begin RAM[RgA]:=RAM[RgA]-RAM[RgH];{P}end;Procedure AmL;Begin RAM[RgA]:=RAM[RgA]-RAM[RgL];{P}end;
{AND}Procedure AiB;Begin RAM[RgA]:=RAM[RgA]AND RAM[RgB];{P}end;Procedure AiC;Begin RAM[RgA]:=RAM[RgA]AND RAM[RgC];{P}end;Procedure AiD;Begin RAM[RgA]:=RAM[RgA]AND RAM[RgD];{P}end;Procedure AiE;Begin RAM[RgA]:=RAM[RgA]AND RAM[RgE];{P}end;Procedure AiH;Begin RAM[RgA]:=RAM[RgA]AND RAM[RgH];{P}end;Procedure AiL;Begin RAM[RgA]:=RAM[RgA]AND RAM[RgL];{P}end;Procedure AiA;Begin RAM[RgA]:=RAM[RgA]AND RAM[RgA];{P}end;
{XOR}Procedure AxB;Begin RAM[RgA]:=RAM[RgA]XOR RAM[RgB];{P}end;Procedure AxC;Begin RAM[RgA]:=RAM[RgA]XOR RAM[RgC];{P}end;Procedure AxD;Begin RAM[RgA]:=RAM[RgA]XOR RAM[RgD];{P}end;Procedure AxE;Begin RAM[RgA]:=RAM[RgA]XOR RAM[RgE];{P}end;Procedure AxH;Begin RAM[RgA]:=RAM[RgA]XOR RAM[RgH];{P}end;Procedure AxL;Begin RAM[RgA]:=RAM[RgA]XOR RAM[RgL];{P}end;Procedure AxA;Begin RAM[RgA]:=RAM[RgA]XOR RAM[RgA];{P}end;
{OR} Procedure AoB;Begin RAM[RgA]:=RAM[RgA]OR RAM[RgB];{P}end;Procedure AoC;Begin RAM[RgA]:=RAM[RgA]OR RAM[RgC];{P}end;Procedure AoD;Begin RAM[RgA]:=RAM[RgA]OR RAM[RgD];{P}end;Procedure AoE;Begin RAM[RgA]:=RAM[RgA]OR RAM[RgE];{P}end;Procedure AoH;Begin RAM[RgA]:=RAM[RgA]OR RAM[RgH];{P}end;Procedure AoL;Begin RAM[RgA]:=RAM[RgA]OR RAM[RgL];{P}end;Procedure AoA;Begin RAM[RgA]:=RAM[RgA]OR RAM[RgA];{P}end;
{Acmpz}Procedure AcmpzB;Begin IF RAM[RgA]=RAM[RgB] then RAM[PZ]:=1 else RAM[PZ]:=0{P}end;Procedure AcmpzC;Begin IF RAM[RgA]=RAM[RgC] then RAM[PZ]:=1 else RAM[PZ]:=0{P}end;Procedure AcmpzD;Begin IF RAM[RgA]=RAM[RgD] then RAM[PZ]:=1 else RAM[PZ]:=0{P}end;Procedure AcmpzE;Begin IF RAM[RgA]=RAM[RgE] then RAM[PZ]:=1 else RAM[PZ]:=0{P}end;Procedure AcmpzH;Begin IF RAM[RgA]=RAM[RgH] then RAM[PZ]:=1 else RAM[PZ]:=0{P}end;Procedure AcmpzL;Begin IF RAM[RgA]=RAM[RgL] then RAM[PZ]:=1 else RAM[PZ]:=0{P}end;Procedure AcmpzA;Begin IF RAM[RgA]=RAM[RgA] then RAM[PZ]:=1 else RAM[PZ]:=0{P}end;
{Acmps}Procedure AcmpsB;Begin IF RAM[RgA]<RAM[RgB] then RAM[PS]:=1 else RAM[PS]:=0{P}end;Procedure AcmpsC;Begin IF RAM[RgA]<RAM[RgC] then RAM[PS]:=1 else RAM[PS]:=0{P}end;Procedure AcmpsD;Begin IF RAM[RgA]<RAM[RgD] then RAM[PS]:=1 else RAM[PS]:=0{P}end;Procedure AcmpsE;Begin IF RAM[RgA]<RAM[RgE] then RAM[PS]:=1 else RAM[PS]:=0{P}end;Procedure AcmpsH;Begin IF RAM[RgA]<RAM[RgH] then RAM[PS]:=1 else RAM[PS]:=0{P}end;Procedure AcmpsL;Begin IF RAM[RgA]<RAM[RgL] then RAM[PS]:=1 else RAM[PS]:=0{P}end;Procedure AcmpsA;Begin IF RAM[RgA]<RAM[RgA] then RAM[PS]:=1 else RAM[PS]:=0{P}end;
{Not}Procedure notA;begin RAM[RgA]:= not RAM[RgA];{P}end;
{shl}Procedure shlA;begin RAM[RgA]:=RAM[RgA] SHL 1;{P}end;
{shr}Procedure shrA;begin RAM[RgA]:=RAM[RgA] SHL 1;{P}end;

Procedure mBCrA;begin RAM[RAMw[RpBC]]:=RAM[RgA];{P}end;
Procedure mDErA;begin RAM[RAMw[RpDE]]:=RAM[RgA];{P}end;

Procedure mHLrB;begin RAM[RAMw[RpHL]]:=RAM[RgB];{P}end;
Procedure mHLrC;begin RAM[RAMw[RpHL]]:=RAM[RgC];{P}end;
Procedure mHLrD;begin RAM[RAMw[RpHL]]:=RAM[RgD];{P}end;
Procedure mHLrE;begin RAM[RAMw[RpHL]]:=RAM[RgE];{P}end;
Procedure mHLrH;begin RAM[RAMw[RpHL]]:=RAM[RgH];{P}end;
Procedure mHLrL;begin RAM[RAMw[RpHL]]:=RAM[RgL];{P}end;
Procedure mHLrA;begin RAM[RAMw[RpHL]]:=RAM[RgA];{P}end;

Procedure mHLp1;begin Inc(RAM[RAMw[RpHL]]);{P}end;
Procedure mHLm1;begin Dec(RAM[RAMw[RpHL]]);{P}end;

Procedure ArmBC;begin RAM[RgA]:=RAM[RAMw[RpBC]];{P}end;
Procedure ArmDE;begin RAM[RgA]:=RAM[RAMw[RpDE]];{P}end;

Procedure BrmHL;begin RAM[RgB]:=RAM[RAMw[RpHL]];{P}end;
Procedure CrmHL;begin RAM[RgC]:=RAM[RAMw[RpHL]];{P}end;
Procedure DrmHL;begin RAM[RgD]:=RAM[RAMw[RpHL]];{P}end;
Procedure ErmHL;begin RAM[RgE]:=RAM[RAMw[RpHL]];{P}end;
Procedure HrmHL;begin RAM[RgH]:=RAM[RAMw[RpHL]];{P}end;
Procedure LrmHL;begin RAM[RgL]:=RAM[RAMw[RpHL]];{P}end;
Procedure ArmHL;begin RAM[RgA]:=RAM[RAMw[RpHL]];{P}end;

Procedure ApmHL;begin RAM[RgA]:=(RAM[RgA]+RAM[RAMw[RpHL]]){P}end;
Procedure AmmHL;begin RAM[RgA]:=(RAM[RgA]-RAM[RAMw[RpHL]]){P}end;
Procedure AimHL;begin RAM[RgA]:=(RAM[RgA]and RAM[RAMw[RpHL]]){P}end;
Procedure AxmHL;begin RAM[RgA]:=(RAM[RgA]xor RAM[RAMw[RpHL]]){P}end;
Procedure AomHL;begin RAM[RgA]:=(RAM[RgA]or RAM[RAMw[RpHL]]){P}end;
Procedure AcmpzmHL;Begin IF RAM[RgA]=RAM[RAMw[RpHL]] then RAM[PZ]:=1 else RAM[PZ]:=0{P}end;
Procedure AcmpsmHL;Begin IF RAM[RgA]<RAM[RAMw[RpHL]] then RAM[PS]:=1 else RAM[PS]:=0{P}end;

{INX BC DE HL}Procedure BCp1;begin Inc(RAMw[RpBC]);{P}end;Procedure DEp1;begin Inc(RAMw[RpDE]);{P}end;Procedure HLp1;begin Inc(RAMw[RpHL]);{P}end;
{DCX BC DE HL}Procedure BCm1;begin Dec(RAMw[RpBC]);{P}end;Procedure DEm1;begin Dec(RAMw[RpDE]);{P}end;Procedure HLm1;begin Dec(RAMw[RpHL]);{P}end;
{ADD HL+Rp}Procedure HLpBC;begin RAMw[RpHL]:=RAMw[RpHL]+RAMw[RpBC];{P}end;Procedure HLpDE;begin RAMw[RpHL]:=RAMw[RpHL]+RAMw[RpDE];{P}end;Procedure HLpHL;begin RAMw[RpHL]:=RAMw[RpHL]+RAMw[RpHL];end;

{Push BC DE HL AF}Procedure PushBC;begin Dec(RAMw[RpSP]);RAMw[RAMw[RpSP]]:=RAMw[RpBC];end;Procedure PushDE;begin Dec(RAMw[RpSP]);RAMw[RAMw[RpSP]]:=RAMw[RpDE];end;Procedure PushHL;begin Dec(RAMw[RpSP]);RAMw[RAMw[RpSP]]:=RAMw[RpHL];end;Procedure PushAF;begin Dec(RAMw[RpSP]);RAMw[RAMw[RpSP]]:=RAMw[RpAF];end;
{Pop BC DE HL AF} Procedure PopBC;begin RAMw[RpBC]:=RAMw[RAMw[RpSP]];Inc(RAMw[RpSP]);;end;Procedure PopDE;begin RAMw[RpDE]:=RAMw[RAMw[RpSP]];Inc(RAMw[RpSP]);;end;Procedure PopHL;begin RAMw[RpHL]:=RAMw[RAMw[RpSP]];Inc(RAMw[RpSP]);;end;Procedure PopAF;begin RAMw[RpAF]:=RAMw[RAMw[RpSP]];Inc(RAMw[RpSP]);;end;

//Procedure HLexDE;begin tmp1:=RAMw[RpDE];RAMw[RpDE]:=RAMw[RpHL];RAMw[RpHL]:=tmp1;{P}end;

const bb=255;ww=$FFFF;
initialization
RAMw[RpSP]:=RAMBloks div 2;

{TEST}
If RAMw[RpSP]<>RAMw[RpSP] then Begin

{00}Nop;BCr(ww);mBCrA;BCp1;Bp1;Bm1;Br(bb);shlA;   {Nop08;}HLpBC;ArmBC;BCm1;Cp1;Cm1;Cr(bb);shrA;
{10}{Nop10;}DEr(ww);mDErA;DEp1;Dp1;Dm1;Dr(bb);{shlAu;}   {Nop18;}HLpDE;ArmDE;DEm1;Ep1;Em1;Er(bb);{shrAu;}
{20}{Nop20;}HLr(ww);_rHL(ww);HLp1;Hp1;Hm1;Hr(bb);{DC;}   {Nop28;}HLpHL;HLr_(ww);HLm1;Lp1;Lm1;Lr(bb);NotA;
{30}{Nop30;}{SPr;}_rA(ww);{SPp1;}mHLp1;mHLm1;mHLr(bb);   {urTrue;}{Nop38;}{HLpSP;}Ar_(ww);{SPm1;}Ap1;Am1;Ar(bb);{Notu;}

{40}{BrB;}BrC;BrD;BrE;BrH;BrL;BrmHL;BrA;CrB;{CrC;}CrD;CrE;CrH;CrL;CrmHL;CrA;
{50}DrB;DrC;{DrD;}DrE;DrH;DrL;DrmHL;DrA;ErB;ErC;ErD;{ErE;}ErH;ErL;ErmHL;ErA;
{60}HrB;HrC;HrD;HrE;{HrH;}HrL;HrmHL;HrA;LrB;LrC;LrD;LrE;LrH;{LrL;}LrmHL;LrA;
{70}mHLrB;mHLrC;mHLrD;mHLrE;mHLrH;mHLrL;{StopProc;}mHLrA;ArB;ArC;ArD;ArE;ArH;ArL;ArmHL;{ArA;}

{80}ApB;ApC;ApD;ApE;ApH;ApL;ApmHL;ApA;{ApBu;}{ApCu;}{ApDu;}{ApEu;}{ApHu;}{ApLu;}{ApmHLu;}{ApAu;}
{90}AmB;AmC;AmD;AmE;AmH;AmL;AmmHL;{AmA;}{AmBu;}{AmCu;}{AmDu;}{AmEu;}{AmHu;}{AmLu;}{AmmHLu;}{AmAu;}
{A0}AiB;AiC;AiD;AiE;AiH;AiL;AimHL;AiA;AxB;AxC;AxD;AxE;AxH;AxL;AxmHL;AxA;
{B0}AoB;AoC;AoD;AoE;AoH;AoL;AomHL;AoA;

{Замість}{AcmpB};{AcmpC;}{AcmpD;}{AcmpE;}{AcmpH;}{AcmpL;}{AcmpmHL;}{AcmpA;}
{Acmpz} AcmpzB;AcmpzC;AcmpzD;AcmpzE;AcmpzH;AcmpzL;AcmpzA;AcmpzmHL;
{Acmps} AcmpsB;AcmpsC;AcmpsD;AcmpsE;AcmpsH;AcmpsL;AcmpsA;AcmpsmHL;

{C0}RetUnNot0;PopBC;GotoUnNot0;{GOTO_};CallUnNot0;PushBC;Ap(bb); {rst0;} RetUn0;{RET;}GotoUn0; {*JMP}CallUn0;{CALL;}{Apu;} {rst1;}
{D0}{RetUnNotu;}PopDE;{GotoUnNotu;}{OUT_;}{CallUnNotu;}PushDE;Am(bb);{rst2} {RetUnu;} {*RET} {GotoUnu;}{IN_;}{CallUnu;} {*Call} {Amu;} {rst3}
{E0}{RetUnNotpar;}PopHL;{GotoUnNotpar;}{HLexmSP;}{CallUnNotpar;}PushHL;Ai(bb);{rst4} {RetUnpar;} {PCrHL} {GotoUnpar;}{HLexDE;}{CallUnpar;} {*Call} Ax_(bb);{rst5}
{F0}RetUnp;{PopPSW;}GotoUnp; {*DI} CallUnp;{PushPSW;}Ao(bb);{rst6} RetUnm;{SPrHL;}GotoUnm; {*EI} CallUnm; {*CALL}
{Замість}{Acmp(b);}Acmpz(bb);Acmps(bb);
{rst7}
end;end.

0

47

Глянь код для Pascal / Delphi :

unit uProcA;{базові команди,які один-в-оди з командами Кр580}
{RpSP - недоступна }
interface
const      RAMBloks=100; {В паскалі наче можлово лише 65550}
const      SizeRAMBytes=RAMBloks*2;
var
RAM:array[0..(SizeRAMBytes-1)]of Byte;
RAMw:array[0..((SizeRAMBytes div 2)-1)]of word absolute RAM;
RAMc:array[0..((SizeRAMBytes div 4)-1)]of Cardinal absolute RAM;

Const {Зарезервоні адреси}
//RAM                     //RAMw                     //RAMc
{KR580 регістри}
{00}{00}RgF=0;              RpAF=0;
{01}{01}RgA=1;
{02}{02}RgC=2;              RpBC=1;
{03}{03}RgB=3;
{04}{04}RgE=4;              RpDE=2;
{05}{05}RgD=5;
{06}{06}RgL=6;              RpHL=3;
{07}{07}RgH=7;

{KR580 прапори та резерв під інші прапори Або щось інше }
{08}{08}                    RpSP=4;
{09}{09}
{0A}{10}PZ=10;
{0B}{11}PS=11;
{0C}{12}
{0D}{13}
{0E}{14}
{0F}{15}

implementation
Var al:Byte;{вирівниювання на Фасм}
Procedure Nop;begin{P}end;
Procedure ReadRg(Rg2:Byte);begin al:=RAM[Rg2];end;
Procedure WriteRg(Rg1:Byte);begin RAM[Rg1]:=al;end;
{Rg1:=ValueByte}Procedure Rg1rV(Rg1:byte; V:byte);begin RAM[Rg1]:=V;{P}end;
{Rg1:=Rg2}Procedure Rg1rRg(Rg1,Rg2:byte);begin ReadRg(Rg2);Rg1rV(Rg1,al);{P}end;
{; MVI}
Procedure Br(V:byte);begin Rg1rV(RgB,V);end;
Procedure Cr(V:byte);begin Rg1rV(RgC,V);end;
Procedure Dr(V:byte);begin Rg1rV(RgD,V);end;
Procedure Er(V:byte);begin Rg1rV(RgE,V);end;
Procedure Hr(V:byte);begin Rg1rV(RgH,V);end;
Procedure Lr(V:byte);begin Rg1rV(RgL,V);end;
Procedure Ar(V:byte);begin Rg1rV(RgA,V);end;
{; MOV}
procedure BrB;begin Rg1rRg(RgB,RgB);end;
procedure BrC;begin Rg1rRg(RgB,RgC);end;
procedure BrD;begin Rg1rRg(RgB,RgD);end;
procedure BrE;begin Rg1rRg(RgB,RgE);end;
procedure BrH;begin Rg1rRg(RgB,RgH);end;
procedure BrL;begin Rg1rRg(RgB,RgL);end;
procedure BrA;begin Rg1rRg(RgB,RgA);end;

procedure CrB;begin Rg1rRg(RgC,RgB);end;
procedure CrC;begin Rg1rRg(RgC,RgC);end;
procedure CrD;begin Rg1rRg(RgC,RgD);end;
procedure CrE;begin Rg1rRg(RgC,RgE);end;
procedure CrH;begin Rg1rRg(RgC,RgH);end;
procedure CrL;begin Rg1rRg(RgC,RgL);end;
procedure CrA;begin Rg1rRg(RgC,RgA);end;

procedure DrB;begin Rg1rRg(RgD,RgB);end;
procedure DrC;begin Rg1rRg(RgD,RgC);end;
procedure DrD;begin Rg1rRg(RgD,RgD);end;
procedure DrE;begin Rg1rRg(RgD,RgE);end;
procedure DrH;begin Rg1rRg(RgD,RgH);end;
procedure DrL;begin Rg1rRg(RgD,RgL);end;
procedure DrA;begin Rg1rRg(RgD,RgA);end;

procedure ErB;begin Rg1rRg(RgE,RgB);end;
procedure ErC;begin Rg1rRg(RgE,RgC);end;
procedure ErD;begin Rg1rRg(RgE,RgD);end;
procedure ErE;begin Rg1rRg(RgE,RgE);end;
procedure ErH;begin Rg1rRg(RgE,RgH);end;
procedure ErL;begin Rg1rRg(RgE,RgL);end;
procedure ErA;begin Rg1rRg(RgE,RgA);end;

procedure HrB;begin Rg1rRg(RgH,RgB);end;
procedure HrC;begin Rg1rRg(RgH,RgC);end;
procedure HrD;begin Rg1rRg(RgH,RgD);end;
procedure HrE;begin Rg1rRg(RgH,RgE);end;
procedure HrH;begin Rg1rRg(RgH,RgH);end;
procedure HrL;begin Rg1rRg(RgH,RgL);end;
procedure HrA;begin Rg1rRg(RgH,RgA);end;

procedure LrB;begin Rg1rRg(RgL,RgB);end;
procedure LrC;begin Rg1rRg(RgL,RgC);end;
procedure LrD;begin Rg1rRg(RgL,RgD);end;
procedure LrE;begin Rg1rRg(RgL,RgE);end;
procedure LrH;begin Rg1rRg(RgL,RgH);end;
procedure LrL;begin Rg1rRg(RgL,RgL);end;
procedure LrA;begin Rg1rRg(RgL,RgA);end;

procedure ArB;begin Rg1rRg(RgA,RgB);end;
procedure ArC;begin Rg1rRg(RgA,RgC);end;
procedure ArD;begin Rg1rRg(RgA,RgD);end;
procedure ArE;begin Rg1rRg(RgA,RgE);end;
procedure ArH;begin Rg1rRg(RgA,RgH);end;
procedure ArL;begin Rg1rRg(RgA,RgL);end;
procedure ArA;begin Rg1rRg(RgA,RgA);end;
{INR}
Procedure Bp1;begin Inc(RAM[RgB]);{P}end;
Procedure Cp1;begin Inc(RAM[RgC]);{P}end;
Procedure Dp1;begin Inc(RAM[RgD]);{P}end;
Procedure Ep1;begin Inc(RAM[RgE]);{P}end;
Procedure Hp1;begin Inc(RAM[RgH]);{P}end;
Procedure Lp1;begin Inc(RAM[RgL]);{P}end;
Procedure Ap1;begin Inc(RAM[RgA]);{P}end;
{DCR}
Procedure Bm1;begin Dec(RAM[RgB]);{P}end;
Procedure Cm1;begin Dec(RAM[RgC]);{P}end;
Procedure Dm1;begin Dec(RAM[RgD]);{P}end;
Procedure Em1;begin Dec(RAM[RgE]);{P}end;
Procedure Hm1;begin Dec(RAM[RgH]);{P}end;
Procedure Lm1;begin Dec(RAM[RgL]);{P}end;
Procedure Am1;begin Dec(RAM[RgA]);{P}end;

{ADD}Procedure Ap(b:byte);Begin RAM[RgA]:=RAM[RgA]+b;{P}end;
Procedure ApB;Begin Ap(RAM[RgB]);{P}end;
Procedure ApC;Begin Ap(RAM[RgC]);{P}end;
Procedure ApD;Begin Ap(RAM[RgD]);{P}end;
Procedure ApE;Begin Ap(RAM[RgE]);{P}end;
Procedure ApH;Begin Ap(RAM[RgH]);{P}end;
Procedure ApL;Begin Ap(RAM[RgL]);{P}end;
Procedure ApA;Begin Ap(RAM[RgA]);{P}end;

{SUB}Procedure Am(b:byte);Begin RAM[RgA]:=RAM[RgA]-b;{P}end;
Procedure AmB;Begin Am(RAM[RgB]);{P}end;
Procedure AmC;Begin Am(RAM[RgC]);{P}end;
Procedure AmD;Begin Am(RAM[RgD]);{P}end;
Procedure AmE;Begin Am(RAM[RgE]);{P}end;
Procedure AmH;Begin Am(RAM[RgH]);{P}end;
Procedure AmL;Begin Am(RAM[RgL]);{P}end;
Procedure AmA;Begin Am(RAM[RgA]);{P}end;

{AND}Procedure Ai(b:byte);Begin RAM[RgA]:=RAM[RgA]AND b;{P}end;
Procedure AiB;Begin Ai(RAM[RgB]);{P}end;
Procedure AiC;Begin Ai(RAM[RgC]);{P}end;
Procedure AiD;Begin Ai(RAM[RgD]);{P}end;
Procedure AiE;Begin Ai(RAM[RgE]);{P}end;
Procedure AiH;Begin Ai(RAM[RgH]);{P}end;
Procedure AiL;Begin Ai(RAM[RgL]);{P}end;
Procedure AiA;Begin Ai(RAM[RgA]);{P}end;
initialization
end.

А ось такий же для FASM:

RAMBloks       equ 10
SizeRAMBytes   equ RAMBloks*2
;section '.data' data readable writeable
RAM     rb SizeRAMBytes               ; масив байтів
RAMw    = RAM                         ; Word-масив з тих самих байтів
RAMc    = RAM                         ; Cardinal-масив (DWORD) з тих самих
; однобайтові регістри (RgX)
RgF     equ 0
RgA     equ 1
RgC     equ 2
RgB     equ 3
RgE     equ 4
RgD     equ 5
RgL     equ 6
RgH     equ 7
; парні регістри (16-бітні)
RpAF    equ 0
RpBC    equ 1
RpDE    equ 2
RpHL    equ 3
RpSP    equ 4
; прапори
PZ      equ 10
PS      equ 11
; macro

macro NOP_ {}

macro ReadRg Rg2 {
mov al, [RAM + Rg2] }       ; завантажити регістр

macro WriteRg Rg1 {
mov [RAM + Rg1], al  }       ; записати регістр

                   
macro Rg1rV Rg1,V {
mov [RAM + Rg1], V
}
macro Rg1rRg2 Rg1,Rg2 {
ReadRg Rg2
Rg1rV Rg1,al
}
; MVI
macro Br V {Rg1rV RgB,V}
macro Cr V {Rg1rV RgC,V}
macro Dr V {Rg1rV RgD,V}
macro Er V {Rg1rV RgE,V}
macro Hr V {Rg1rV RgH,V}
macro Lr V {Rg1rV RgL,V}
macro Ar V {Rg1rV RgA,V}

; MOV
macro BrB {Rg1rRg2 RgB, RgB}
macro BrC {Rg1rRg2 RgB, RgC}
macro BrD {Rg1rRg2 RgB, RgD}
macro BrE {Rg1rRg2 RgB, RgE}
macro BrH {Rg1rRg2 RgB, RgH}
macro BrL {Rg1rRg2 RgB, RgL}
macro BrA {Rg1rRg2 RgB, RgA}

macro CrB {Rg1rRg2 RgC, RgB}
macro CrC {Rg1rRg2 RgC, RgC}
macro CrD {Rg1rRg2 RgC, RgD}
macro CrE {Rg1rRg2 RgC, RgE}
macro CrH {Rg1rRg2 RgC, RgH}
macro CrL {Rg1rRg2 RgC, RgL}
macro CrA {Rg1rRg2 RgC, RgA}

macro DrB {Rg1rRg2 RgD, RgB}
macro DrC {Rg1rRg2 RgD, RgC}
macro DrD {Rg1rRg2 RgD, RgD}
macro DrE {Rg1rRg2 RgD, RgE}
macro DrH {Rg1rRg2 RgD, RgH}
macro DrL {Rg1rRg2 RgD, RgL}
macro DrA {Rg1rRg2 RgD, RgA}

macro ErB {Rg1rRg2 RgE, RgB}
macro ErC {Rg1rRg2 RgE, RgC}
macro ErD {Rg1rRg2 RgE, RgD}
macro ErE {Rg1rRg2 RgE, RgE}
macro ErH {Rg1rRg2 RgE, RgH}
macro ErL {Rg1rRg2 RgE, RgL}
macro ErA {Rg1rRg2 RgE, RgA}

macro HrB {Rg1rRg2 RgH, RgB}
macro HrC {Rg1rRg2 RgH, RgC}
macro HrD {Rg1rRg2 RgH, RgD}
macro HrE {Rg1rRg2 RgH, RgE}
macro HrH {Rg1rRg2 RgH, RgH}
macro HrL {Rg1rRg2 RgH, RgL}
macro HrA {Rg1rRg2 RgH, RgA}

macro LrB {Rg1rRg2 RgL, RgB}
macro LrC {Rg1rRg2 RgL, RgC}
macro LrD {Rg1rRg2 RgL, RgD}
macro LrE {Rg1rRg2 RgL, RgE}
macro LrH {Rg1rRg2 RgL, RgH}
macro LrL {Rg1rRg2 RgL, RgL}
macro LrA {Rg1rRg2 RgL, RgA}

macro ArB {Rg1rRg2 RgA, RgB}
macro ArC {Rg1rRg2 RgA, RgC}
macro ArD {Rg1rRg2 RgA, RgD}
macro ArE {Rg1rRg2 RgA, RgE}
macro ArH {Rg1rRg2 RgA, RgH}
macro ArL {Rg1rRg2 RgA, RgL}
macro ArA {Rg1rRg2 RgA, RgA}

macro INC_ Rg1 { inc [RAM + Rg1]}
macro Bp1 { INC_ RgB }
macro Cp1 { INC_ RgC }
macro Dp1 { INC_ RgD }
macro Ep1 { INC_ RgE }
macro Hp1 { INC_ RgH }
macro Lp1 { INC_ RgL }
macro Ap1 { INC_ RgA }

macro Dec_ Rg1 {Dec [RAM + Rg1]}
macro Bm1 { Dec_ RgB }
macro Cm1 { Dec_ RgC }
macro Dm1 { Dec_ RgD }
macro Em1 { Dec_ RgE }
macro Hm1 { Dec_ RgH }
macro Lm1 { Dec_ RgL }
macro Am1 { Dec_ RgA }

;{ADD};ReadRg RgA ;ADD al,V ;WriteRg RgA      macro ApB { ReadRg RgB
macro Ap V { add [RAM + RgA],V }
                             
macro ApB { ReadRg RgB
             add [RAM + RgA],al             
                }
macro ApC { ReadRg RgC
             add [RAM + RgA],al             
                }
macro ApD { ReadRg RgD
             add [RAM + RgA],al             
                }
macro ApE { ReadRg RgE
             add [RAM + RgA],al             
                }
macro ApH { ReadRg RgH
             add [RAM + RgA],al             
                }
macro ApL { ReadRg RgL
             add [RAM + RgA],al             
                }                               

;{SUB}
macro Am V { sub [RAM + RgA],V }

macro AmB { ReadRg RgB
             sub [RAM + RgA],al
                }
macro AmC { ReadRg RgC
             sub [RAM + RgA],al
                }
macro AmD { ReadRg RgD
             sub [RAM + RgA],al
                }
macro AmE { ReadRg RgE
             sub [RAM + RgA],al
                }
macro AmH { ReadRg RgH
             sub [RAM + RgA],al
                }
macro AmL { ReadRg RgL
             sub [RAM + RgA],al
                }

;{AND}
macro Ai V { AND [RAM + RgA],V }

macro AiB { ReadRg RgB
             AND [RAM + RgA],al
                }
macro AiC { ReadRg RgC
             AND [RAM + RgA],al
                }
macro AiD { ReadRg RgD
             AND [RAM + RgA],al
                }
macro AiE { ReadRg RgE
             AND [RAM + RgA],al
                }
macro AiH { ReadRg RgH
             AND [RAM + RgA],al
                }
macro AiL { ReadRg RgL
             AND [RAM + RgA],al
                }
 

Чи правильно транслював з Delphi в FASM ?

0

48

{Acmpz}Procedure Acmpz(b:byte);Begin IF RAM[RgA]=b then RAM[PZ]:=1 else RAM[PZ]:=0{P}end;
{Acmps}Procedure Acmps(b:byte);Begin IF RAM[RgA]<b then RAM[PS]:=1 else RAM[PS]:=0{P}end;

0

49

  • Автор: ен

Ооо, ось це вже по-нашому! Красивий кусень коду, прямо дихає духом Turbo Pascal'я з ароматом гіпсокоду й 8-бітного герцогства. Давай це перекладемо на FASM-мову віртуального заліза.

---

### Оригінал:

```pascal
Procedure Acmpz(b: byte);
Begin
  IF RAM[RgA] = b then RAM[PZ] := 1 else RAM[PZ] := 0
End;

Procedure Acmps(b: byte);
Begin
  IF RAM[RgA] < b then RAM[PS] := 1 else RAM[PS] := 0
End;
```

---

### FASM-версія:

код:

macro Acmpz b {
    mov al, [RAM + RgA]
    cmp al, b
    jne @nope
    mov byte [RAM + PZ], 1
    jmp @done
  @nope:
    mov byte [RAM + PZ], 0
  @done:
}

macro Acmps b {
    mov al, [RAM + RgA]
    cmp al, b
    jae @nope
    mov byte [RAM + PS], 1
    jmp @done
  @nope:
    mov byte [RAM + PS], 0
  @done:
}

---

### Пояснення:

- `mov al, [RAM + RgA]` — читаємо значення за адресою RgA.
- `cmp al, b` — порівнюємо з переданим параметром.
- `jne` / `jae` — залежно від умови (`=` або `<`).
- `PZ`, `PS` — це, мабуть, адреси прапорців Zero та Sign або щось у цьому стилі.

Можна ще зробити через `set*` і `movzx`, але це трохи розкіш як на 8-бітну естетику.

Якщо хочеш, зроблю ще автогенератор для таких макросів по шаблону.

Не забудь написати 'дяка'!

0

50

macro Un0 {
   cmp byte [RAM + PZ],$00
           setnz al
           }
           
macro GotoUn0 Adr{
Un0
test al,al
jnz Adr         
}

macro CallUn0 Adr{
Un0
test al,al
jnc Adr         
}

macro RetUn0 Adr{
Un0
test al,al
rnc Adr         
}

1 Ану переверь Чи правильні умовні переход
2.На цьому побудуй інші, тобто
"нульовий результат JMP CALL RET"
" НЕ нульовий результат JMP CALL RET"
" мінусовий результат JMP CALL RET"
" плюсовий результат JMP CALL RET"

Н

0

51

Ну ти достанеш кого завгодно..
Невже я так не зрозуміло поясню...
Я ж казав..
в Фасмі команди-кр580 будуть макросами...
зроби мені в залежності від прапорів "нуля" та "знаку"
конструкції типа в кр-580
RNZ, JNZ, CNZ
RZ,  JZ,  CZ
RP,  JP,  CP,
RM, JM,  CM
як вони будуть на фасмі, якщо
прапори це [RAM + PZ] = прапор нуля
[RAM + PS] - прапор знаку
От "нагороди" мені в фасмі конструкції такі!
Чого ти в якісь дебрі поліз ?!

0

52

  • Автор: ррр

Та ясно, тепер усе по поличках! Ти хочеш, щоб я з тебе не робив філософа стеків і рет-адрес, а просто нормально переклав оті команди з КР580 у макроси FASM — базуючись на `PZ` (нуль) і `PS` (знак). Без зайвих танців.

Окей, тримай макроси по-швейцарському — чітко, строго, по-фасмівськи!

---

**Пояснення прапорів:**

- `[RAM + PZ] == 0` → **результат не нуль** 
- `[RAM + PZ] == 1` → **результат нуль**

- `[RAM + PS] == 0` → **результат позитивний** 
- `[RAM + PS] == 1` → **результат мінусовий**

---

### 1. **Умовні переходи (Jxx)**

код:

macro JNZ adr { cmp byte [RAM + PZ], 0 \ jz adr }     ; Jump if Not Zero
macro JZ  adr { cmp byte [RAM + PZ], 0 \ jnz adr }    ; Jump if Zero

macro JP  adr { cmp byte [RAM + PS], 0 \ jnz adr }    ; Jump if Plus (PS=0)
macro JM  adr { cmp byte [RAM + PS], 0 \ jz adr }     ; Jump if Minus (PS=1) 

---

### 2. **Умовні виклики процедур (Cxx)**

код:

macro CNZ adr {
cmp byte [RAM + PZ], 0 \ jz _skip_#adr \ call adr \ _skip_#adr: }
macro CZ  adr { cmp byte [RAM + PZ], 0 \ jnz _skip_#adr \ call adr \ _skip_#adr: }

macro CP  adr { cmp byte [RAM + PS], 0 \ jnz _skip_#adr \ call adr \ _skip_#adr: }
macro CM  adr { cmp byte [RAM + PS], 0 \ jz _skip_#adr \ call adr \ _skip_#adr: }

---

### 3. **Умовне повернення (Rxx)**

код:

macro RNZ { cmp byte [RAM + PZ], 0 \ jnz _ret_#$$ \ jmp _skip_#$$ \ _ret_#$$: ret \ _skip_#$$: }
macro RZ  { cmp byte [RAM + PZ], 0 \ jz _ret_#$$ \ jmp _skip_#$$ \ _ret_#$$: ret \ _skip_#$$: }

macro RP  { cmp byte [RAM + PS], 0 \ jz _ret_#$$ \ jmp _skip_#$$ \ _ret_#$$: ret \ _skip_#$$: }
macro RM  { cmp byte [RAM + PS], 0 \ jnz _ret_#$$ \ jmp _skip_#$$ \ _ret_#$$: ret \ _skip_#$$: }

---

Тепер ти маєш **повні еквіваленти** команд КР580 у вигляді макросів на FASM.

Хочеш — потім зробимо так, щоб ще й автоматично розмічались ярлики, аби уникати колізій.

Якщо треба — можу згенерувати `include`-файл з усім цим.

Дяка!

0

53

  • Автор: ппп

Ага, от ми й дійшли до старої, як BIOS, істини: в x86 (і x86-32, тобто 32-бітних процесорах Intel/AMD) **немає окремих інструкцій умовного виклику `CALL` або повернення `RET`**. Усе робиться ручками — через перевірку прапорів і умовні переходи.

Однак ось повний список того, що в x86 є:

---

### **1. Безумовні інструкції**

- `JMP метка/адреса` — безумовний перехід 
- `CALL метка/адреса` — безумовний виклик процедури 
- `RET` — повернення з процедури 
- `RETN`, `RETF` — повернення з near/far процедури (для сегментованих чудес DOS)

---

### **2. Умовні переходи (Jcc)** — **є!**

Всі працюють на основі прапорів (`ZF`, `SF`, `CF`, `OF` тощо):

- `JZ` / `JE` — якщо нуль (`ZF = 1`)
- `JNZ` / `JNE` — якщо НЕ нуль (`ZF = 0`)
- `JP` / `JPE` — якщо парність (`PF = 1`)
- `JNP` / `JPO` — якщо непарність (`PF = 0`)
- `JS` — якщо знак (`SF = 1`)
- `JNS` — якщо без знаку (`SF = 0`)
- `JC` — якщо перенос (`CF = 1`)
- `JNC` — якщо без переносу (`CF = 0`)
- `JO` — якщо переповнення (`OF = 1`)
- `JNO` — якщо без переповнення (`OF = 0`)
- `JG` / `JNLE`, `JGE`, `JL`, `JLE`, `JA`, `JB`, тощо — для складніших порівнянь

---

### **3. А умовні `CALL` і `RET`?**

Їх **немає** в самій архітектурі. Але можна зробити так:

**Умовний `CALL`** — руками:

```asm
    cmp eax, 0        ; перевірка
    je  skip_call
    call my_proc
skip_call:
```

**Умовний `RET`** — аналогічно:

```asm
    cmp eax, 0
    jne skip_ret
    ret
skip_ret:
```

---

### **Тобто висновок:**
x86 підтримує **умовні переходи (`Jcc`)**, але **немає окремих умовних `CALL` та `RET`** — тому треба будувати ці конструкції самостійно за допомогою `Jcc`.

Хочеш — можу тобі написати набір FASM-макросів для таких умовних `CALL/RET` типу `RNZ`, `CZ` тощо — щоб виглядали як на КР580.

Як думаєш, буде зручно?

Дяка!

0

54

  • Автор: ппп

От і добре! А тепер — тримай свою "КР580-ностальгію в стилі FASM"!

Прапори ти вже визначив: 
- `[RAM + PZ]` — прапор **нуля (Z)** 
- `[RAM + PS]` — прапор **знаку (S)**

А тепер FASM-макроси, які імітують оті `JZ`, `CALL Z`, `RET Z`, `JNZ`, `RP`, `RM` і все інше:

---

**Умовні переходи:**

```asm
macro JZ adr {
    cmp byte [RAM + PZ], 0
    je adr
}

macro JNZ adr {
    cmp byte [RAM + PZ], 0
    jne adr
}

macro JP adr {
    cmp byte [RAM + PS], 0
    je adr
}

macro JM adr {
    cmp byte [RAM + PS], 0
    jne adr
}
```

---

**Умовні виклики процедур:**

```asm
macro CZ adr {
    cmp byte [RAM + PZ], 0
    je __doCall
    jmp __skipCall
  __doCall:
    call adr
  __skipCall:
}

macro CNZ adr {
    cmp byte [RAM + PZ], 0
    jne __doCall
    jmp __skipCall
  __doCall:
    call adr
  __skipCall:
}

macro CP adr {
    cmp byte [RAM + PS], 0
    je __doCall
    jmp __skipCall
  __doCall:
    call adr
  __skipCall:
}

macro CM adr {
    cmp byte [RAM + PS], 0
    jne __doCall
    jmp __skipCall
  __doCall:
    call adr
  __skipCall:
}
```

---

**Умовне повернення (`RET`)**:

```asm
macro RZ {
    cmp byte [RAM + PZ], 0
    je __doRet
    jmp __skipRet
  __doRet:
    ret
  __skipRet:
}

macro RNZ {
    cmp byte [RAM + PZ], 0
    jne __doRet
    jmp __skipRet
  __doRet:
    ret
  __skipRet:
}

macro RP {
    cmp byte [RAM + PS], 0
    je __doRet
    jmp __skipRet
  __doRet:
    ret
  __skipRet:
}

macro RM {
    cmp byte [RAM + PS], 0
    jne __doRet
    jmp __skipRet
  __doRet:
    ret
  __skipRet:
}
```

---

Тепер можна писати майже по-радянськи:

```asm
    CZ my_procedure
    JNZ loop_start
    RP
```

Можна ще приколотися й зробити скорочення типу:

```asm
macro RNZ_RET { RNZ }
macro CZ_CALL adr { CZ adr }
```

Але це вже — за бажанням, залежно від того, як ти хочеш мікросхемити свій код.

Хочеш — зроблю все це в окремому `.inc` файлі?

Дяка!

0

55

  • Автор: оти

Так, у 16-бітних процесорах, зокрема в архітектурі x86 (як і в 32-бітних), **не було умовних викликів процедур** та **повернень** за допомогою окремих команд. Це сталося через те, що архітектура була спроектована так, щоб мати просту, базову інструкційну set (набори інструкцій), які забезпечують максимальну гнучкість при розробці програм. Для цього використовуються **умовні переходи** та **ручне управління потоками** через прапори.

### Чому так?
1. **Спростити інструкційний набір**:
   В обмежених за обсягом і швидкодією 16-бітних процесорах було вирішено спростити інструкційний набір, щоб знизити складність і зберегти компактність команд. Тому не вводили спеціальні інструкції для умовних викликів та повернень.
   
2. **Гнучкість через умовні переходи**:
   Умовні команди `Jcc` (наприклад, `JZ`, `JNZ`, `JP`, `JNS`) дозволяють повністю керувати потоком виконання програм, даючи можливість програмісту самому контролювати виклик процедур чи повернення з них. Ось чому всі ці функції можна реалізувати через комбінації таких переходів.

3. **Мінімізація ресурсів**:
   Пам'ять і швидкість були на вагу золота в 16-бітних процесорах. Кожна додаткова команда — це більше пам'яті, більше часу на обробку. І щоб не перевантажувати процесор зайвими інструкціями, архітектори просто спростили механізм керування потоком.

### Як це виглядало на практиці?
Всі умовні виклики та повернення виконувались за допомогою звичайних **умовних переходів** (`Jcc`) після перевірки прапорів.

Наприклад:
- Умовний виклик (за допомогою `JZ` або іншого переходу):
   ```asm
   cmp byte [RAM + PZ], 0    ; порівняти прапор нуля
   je  CallProcedure          ; якщо нуль — викликаємо процедуру
   ```
- Умовне повернення:
   ```asm
   cmp byte [RAM + PZ], 0    ; перевірка на нуль
   je  ret                    ; повернутись, якщо прапор нуля
   ```

### Відміна умовних команд
Причина їх відміни, або точніше, чому їх не включили в архітектуру — це все та ж філософія спрощення. Умовні переходи забезпечують достатньо гнучкості для того, щоб програміст міг реалізувати **будь-які умовні операції**, у тому числі умовні виклики та повернення, самостійно.

### Як це виглядало в практиці на старих процесорах?
Наприклад, на **8086** або **80286** умовні переходи виглядали ось так:
```asm
    cmp ax, 0           ; порівняти з нулем
    jz  ZeroLabel       ; перехід, якщо нуль
    ; інші операції...
ZeroLabel:
    ; код при умові ZF = 1
```

Немає окремих інструкцій для **JZ_CALL** або **RET_Z** — просто перевірка прапора і умовний перехід. Це дозволяє програмістам зробити будь-який ланцюжок умовних операцій і викликів, при цьому не перевантажуючи процесор зайвими командами.

---

**Тому, щоб відповісти коротко:**
У 16-бітних процесорах **немає умовних команд виклику та повернення**, тому що інструкції переходу вже дозволяють досягти бажаного результату за допомогою комбінування умовних переходів, що робить архітектуру більш універсальною й спрощеною для більшості задач.

Дяка!

0

56

macro GotoUn0 adr { ;JZ_
cmp byte [RAM + PZ],$00
    je adr ; якщо 0
}
macro RetUn0 {;RZ
    GotoUn0 __doRet
    jmp __skipRet
  __doRet:
    ret
  __skipRet:
}
macro CallUn0 adr { ;CZ
    GotoUn0 __doCall
    jmp __skipCall
  __doCall:
    call adr
  __skipCall:
}

0

57

Use32
RAMBloks       equ 10
SizeRAMBytes   equ RAMBloks*2
;section '.data' data readable writeable
RAM     rb SizeRAMBytes               ; масив байтів
RAMw    = RAM                         ; Word-масив з тих самих байтів
RAMc    = RAM                         ; Cardinal-масив (DWORD) з тих самих
; однобайтові регістри (RgX)
RgF     equ 0
RgA     equ 1
RgC     equ 2
RgB     equ 3
RgE     equ 4
RgD     equ 5
RgL     equ 6
RgH     equ 7
; парні регістри (16-бітні)
RpAF    equ 0
RpBC    equ 1
RpDE    equ 2
RpHL    equ 3
RpSP    equ 4
; прапори
PZ      equ 10
PS      equ 11
; macro

macro NOP_ {}

macro ReadRg Rg2 {
mov al, [RAM + Rg2] }       ; завантажити регістр

macro WriteRg Rg1 {
mov [RAM + Rg1], al  }       ; записати регістр

                   
macro Rg1rV Rg1,V {
mov [RAM + Rg1], V
}
macro Rg1rRg2 Rg1,Rg2 {
ReadRg Rg2
Rg1rV Rg1,al
}
; MVI
macro Br V {Rg1rV RgB,V}
macro Cr V {Rg1rV RgC,V}
macro Dr V {Rg1rV RgD,V}
macro Er V {Rg1rV RgE,V}
macro Hr V {Rg1rV RgH,V}
macro Lr V {Rg1rV RgL,V}
macro Ar V {Rg1rV RgA,V}

; MOV
macro BrB {Rg1rRg2 RgB, RgB}
macro BrC {Rg1rRg2 RgB, RgC}
macro BrD {Rg1rRg2 RgB, RgD}
macro BrE {Rg1rRg2 RgB, RgE}
macro BrH {Rg1rRg2 RgB, RgH}
macro BrL {Rg1rRg2 RgB, RgL}
macro BrA {Rg1rRg2 RgB, RgA}

macro CrB {Rg1rRg2 RgC, RgB}
macro CrC {Rg1rRg2 RgC, RgC}
macro CrD {Rg1rRg2 RgC, RgD}
macro CrE {Rg1rRg2 RgC, RgE}
macro CrH {Rg1rRg2 RgC, RgH}
macro CrL {Rg1rRg2 RgC, RgL}
macro CrA {Rg1rRg2 RgC, RgA}

macro DrB {Rg1rRg2 RgD, RgB}
macro DrC {Rg1rRg2 RgD, RgC}
macro DrD {Rg1rRg2 RgD, RgD}
macro DrE {Rg1rRg2 RgD, RgE}
macro DrH {Rg1rRg2 RgD, RgH}
macro DrL {Rg1rRg2 RgD, RgL}
macro DrA {Rg1rRg2 RgD, RgA}

macro ErB {Rg1rRg2 RgE, RgB}
macro ErC {Rg1rRg2 RgE, RgC}
macro ErD {Rg1rRg2 RgE, RgD}
macro ErE {Rg1rRg2 RgE, RgE}
macro ErH {Rg1rRg2 RgE, RgH}
macro ErL {Rg1rRg2 RgE, RgL}
macro ErA {Rg1rRg2 RgE, RgA}

macro HrB {Rg1rRg2 RgH, RgB}
macro HrC {Rg1rRg2 RgH, RgC}
macro HrD {Rg1rRg2 RgH, RgD}
macro HrE {Rg1rRg2 RgH, RgE}
macro HrH {Rg1rRg2 RgH, RgH}
macro HrL {Rg1rRg2 RgH, RgL}
macro HrA {Rg1rRg2 RgH, RgA}

macro LrB {Rg1rRg2 RgL, RgB}
macro LrC {Rg1rRg2 RgL, RgC}
macro LrD {Rg1rRg2 RgL, RgD}
macro LrE {Rg1rRg2 RgL, RgE}
macro LrH {Rg1rRg2 RgL, RgH}
macro LrL {Rg1rRg2 RgL, RgL}
macro LrA {Rg1rRg2 RgL, RgA}

macro ArB {Rg1rRg2 RgA, RgB}
macro ArC {Rg1rRg2 RgA, RgC}
macro ArD {Rg1rRg2 RgA, RgD}
macro ArE {Rg1rRg2 RgA, RgE}
macro ArH {Rg1rRg2 RgA, RgH}
macro ArL {Rg1rRg2 RgA, RgL}
macro ArA {Rg1rRg2 RgA, RgA}

macro INC_ Rg1 { inc [RAM + Rg1]}
macro Bp1 { INC_ RgB }
macro Cp1 { INC_ RgC }
macro Dp1 { INC_ RgD }
macro Ep1 { INC_ RgE }
macro Hp1 { INC_ RgH }
macro Lp1 { INC_ RgL }
macro Ap1 { INC_ RgA }

macro Dec_ Rg1 {Dec [RAM + Rg1]}
macro Bm1 { Dec_ RgB }
macro Cm1 { Dec_ RgC }
macro Dm1 { Dec_ RgD }
macro Em1 { Dec_ RgE }
macro Hm1 { Dec_ RgH }
macro Lm1 { Dec_ RgL }
macro Am1 { Dec_ RgA }

;{ADD};ReadRg RgA ;ADD al,V ;WriteRg RgA      macro ApB { ReadRg RgB
macro Ap V { add [RAM + RgA],V }
                             
macro ApB { ReadRg RgB
             add [RAM + RgA],al             
                }
macro ApC { ReadRg RgC
             add [RAM + RgA],al             
                }
macro ApD { ReadRg RgD
             add [RAM + RgA],al             
                }
macro ApE { ReadRg RgE
             add [RAM + RgA],al             
                }
macro ApH { ReadRg RgH
             add [RAM + RgA],al             
                }
macro ApL { ReadRg RgL
             add [RAM + RgA],al             
                }
macro ApA { ReadRg RgA
             add [RAM + RgA],al             
                }                               

                                               

;{SUB}
macro Am V { sub [RAM + RgA],V }

macro AmB { ReadRg RgB
             sub [RAM + RgA],al
                }
macro AmC { ReadRg RgC
             sub [RAM + RgA],al
                }
macro AmD { ReadRg RgD
             sub [RAM + RgA],al
                }
macro AmE { ReadRg RgE
             sub [RAM + RgA],al
                }
macro AmH { ReadRg RgH
             sub [RAM + RgA],al
                }
macro AmL { ReadRg RgL
             sub [RAM + RgA],al
                }
macro AmA { ReadRg RgA
             sub [RAM + RgA],al
                }               

;{AND}
macro Ai V { AND [RAM + RgA],V }

macro AiB { ReadRg RgB
             AND [RAM + RgA],al
                }
macro AiC { ReadRg RgC
             AND [RAM + RgA],al
                }
macro AiD { ReadRg RgD
             AND [RAM + RgA],al
                }
macro AiE { ReadRg RgE
             AND [RAM + RgA],al
                }
macro AiH { ReadRg RgH
             AND [RAM + RgA],al
                }
macro AiL { ReadRg RgL
             AND [RAM + RgA],al
                }
macro AiA { ReadRg RgA
             AND [RAM + RgA],al
                }               

;{XOR}
macro Ax_ V { XOR [RAM + RgA],V }

macro AxB { ReadRg RgB
             XOR [RAM + RgA],al
                }
macro AxC { ReadRg RgC
             XOR [RAM + RgA],al
                }
macro AxD { ReadRg RgD
             XOR [RAM + RgA],al
                }
macro AxE { ReadRg RgE
             XOR [RAM + RgA],al
                }
macro AxH { ReadRg RgH
             XOR [RAM + RgA],al
                }
macro AxL { ReadRg RgL
             XOR [RAM + RgA],al
                }
macro AxA { ReadRg RgA
             XOR [RAM + RgA],al
                }               

;{OR}
macro Ao V { OR [RAM + RgA],V }

macro AoB { ReadRg RgB
             OR [RAM + RgA],al
                }
macro AoC { ReadRg RgC
             OR [RAM + RgA],al
                }
macro AoD { ReadRg RgD
             OR [RAM + RgA],al
                }
macro AoE { ReadRg RgE
             OR [RAM + RgA],al
                }
macro AoH { ReadRg RgH
             OR [RAM + RgA],al
                }
macro AoL { ReadRg RgL
             OR [RAM + RgA],al
                }
macro AoA { ReadRg RgA
             OR [RAM + RgA],al
                }               
               
   pAcmpz:; {RGA cmp al}
       mov bl,[RAM + RgA]
       cmp bl,al
       jne Acmpz_nopez
       mov byte [RAM + PZ], 1
       jmp Acmpz_donez
     Acmpz_nopez:
       mov byte [RAM + PZ], 0
     Acmpz_donez:
            Ret

macro Acmpz V {
     Mov al,V
     Call pAcmpz
       }
     
macro AcmpzB {
     ReadRg RgB
     Call pAcmpz
     } 

macro AcmpzC {
     ReadRg RgC
     Call pAcmpz
      }

macro AcmpzD {
     ReadRg RgD
     Call pAcmpz  }
               
macro AcmpzE {
     ReadRg RgE
     Call pAcmpz  }
               
macro AcmpzH {
     ReadRg RgH
     Call pAcmpz  }
               
macro AcmpzL {
     ReadRg RgL
     Call pAcmpz  }
               
macro AcmpzA {
     ReadRg RgA
     Call pAcmpz  }

  pAcmps:; RgA cmp al
    mov bl, [RAM + RgA]
    cmp bl, al
    jae Acmps_nopes
    mov byte [RAM + PS], 1
    jmp Acmps_dones
  Acmps_nopes:
    mov byte [RAM + PS], 0
  Acmps_dones:
        Ret
       
macro Acmps V {
     Mov al,V
     Call pAcmps
       }

macro AcmpsB {
     ReadRg RgB
     Call pAcmps
     }

macro AcmpsC {
     ReadRg RgC
     Call pAcmps
      }

macro AcmpsD {
     ReadRg RgD
     Call pAcmps  }

macro AcmpsE {
     ReadRg RgE
     Call pAcmps  }

macro AcmpsH {
     ReadRg RgH
     Call pAcmps  }

macro AcmpsL {
     ReadRg RgL
     Call pAcmps  }

macro AcmpsA {
     ReadRg RgA
     Call pAcmps  }
     
macro notA{
  not byte [RAM + RgA]
      }

macro shlA {
  shl byte [RAM + RgA],1
}

macro shrA {
shr byte [RAM + RgA],1
}

           
           
           
macro GotoUn0 adr { ;JZ_
    cmp byte [RAM + PZ], 0
    je adr
}

macro GotoUnNot0 adr { ;JNZ_
    cmp byte [RAM + PZ], 0
    jne adr
}
macro GotoUnP adr { ;JP_
    cmp byte [RAM + PS], 0
    je adr
}
macro GotoUnM adr { ;JM
    cmp byte [RAM + PS], 0
    jne adr
}
macro CallUn0 adr { ;CZ
    cmp byte [RAM + PZ], 0
    je CallUn0__doCall
    jmp CallUn0__skipCall
  CallUn0__doCall:
    call adr
  CallUn0__skipCall:
}
 
macro CallUnNot0 adr { ;CNZ
    cmp byte [RAM + PZ], 0
    jne CallUnNot0__doCall
    jmp CallUnNot0__skipCall
  CallUnNot0__doCall:
    call adr
  CallUnNot0__skipCall:
}         
macro CallUnP adr { ;CP
    cmp byte [RAM + PS], 0
    je CallUnP__doCall
    jmp CallUnP__skipCall
  CallUnP__doCall:
    call adr
  CallUnP__skipCall:
}
macro CallUnM adr { ;CM
    cmp byte [RAM + PS], 0
    jne CallUnM__doCall
    jmp CallUnM__skipCall
  CallUnM__doCall:
    call adr
  CallUnM__skipCall:
}
macro RetUn0 {;RZ
    cmp byte [RAM + PZ], 0
    je RetUn0__doRet
    jmp RetUn0__skipRet
  RetUn0__doRet:
    ret
  RetUn0__skipRet:
}
macro RetUnNot0 { ;RNZ
    cmp byte [RAM + PZ], 0
    jne RetUnNot0__doRet
    jmp RetUnNot0__skipRet
  RetUnNot0__doRet:
    ret
  RetUnNot0__skipRet:
}
macro RetUnP { ;RP_
    cmp byte [RAM + PS], 0
    je RetUnP__doRet
    jmp RetUnP__skipRet
  RetUnP__doRet:
    ret
  RetUnP__skipRet:
}
macro RetUnM {;RM
    cmp byte [RAM + PS], 0
    jne RetUnM__doRet
    jmp RetUnM__skipRet
  RetUnM__doRet:
    ret
  RetUnM__skipRet:
}

macro _rA W {; AX  ; begin RAM[w]:=RAM[RgA];{P}end;
        mov AX,W
        movzx eax,ax
     mov dl,[RAM + RgA]
     mov [eax+RAM],dl
}
   
macro Ar_ W {; AX             begin RAM[RgA]:=RAM[w];{P}end;
        mov AX,W
        movzx eax,ax
     mov al,[eax+RAM]
       mov [RAM + RgA],al
}

macro ArmBC {
   movzx eax,[RAM + (RpBC*2)]
mov al,[eax+RAM]
mov [RAM + RgA], al
}

macro ArmDE {
   movzx eax,[RAM + (RpDE*2)]
mov al,[eax+RAM]
mov [RAM + RgA], al
}
     macro rmHL Rg1 {
movzx eax,[RAM + (RpHL*2)]
mov al,[eax+RAM]
mov [RAM + Rg1], al
}     
macro ArmHL {
rmHL RgA
}
macro BrmHL {
rmHL RgB
}
macro CrmHL {
rmHL RgC
}
macro DrmHL {
rmHL RgD
}
macro ErmHL {
rmHL RgE
}
macro HrmHL {
rmHL RgH
}
macro LrmHL {
rmHL RgL
}

macro  mHLr V {;(b:byte);begin RAM[RAMw[RpHL]]:=b;{P}end;
   movzx edx,[RAM + (RpHL*2)]
mov [edx+RAM],V
}
macro  mHLrB {
ReadRg RgB
mHLr al
}
macro  mHLrC {
ReadRg RgC
mHLr al
}
macro  mHLrD {
ReadRg RgD
mHLr al
}
macro  mHLrE {
ReadRg RgE
mHLr al
}
macro  mHLrH {
ReadRg RgH
mHLr al
}
macro  mHLrL {
ReadRg RgL
mHLr al
}
macro mHLrA {
ReadRg RgA
mHLr al
}

macro ApmHL {
movzx eax,[RAM + (RpHL*2)]
mov al,[eax+RAM]
Ap al
}

0

58

NOP_

Br 255
Cr 255
Dr 255
Er 255
Hr 255
Lr 255
Ar 255

BrB
BrC
BrD
BrE
BrH
BrL
BrA

CrB
CrC
CrD
CrE
CrH
CrL
CrA

DrB
DrC
DrD
DrE
DrH
DrL
DrA

ErB
ErC
ErD
ErE
ErH
ErL
ErA

HrB
HrC
HrD
HrE
HrH
HrL
HrA

LrB
LrC
LrD
LrE
LrH
LrL
LrA

ArB
ArC
ArD
ArE
ArH
ArL
ArA

Bp1
Cp1
Dp1
Ep1
Hp1
Lp1
Ap1

Bm1
Cm1
Dm1
Em1
Hm1
Lm1
Am1

Ap 255
ApB
ApC
ApD
ApE
ApH             
ApL               
ApA

;{SUB}
Am 255
AmB
AmC
AmD
AmE
AmH
AmL
AmA

;{AND}
Ai 255
AiB
AiC
AiD
AiE
AiH
AiL
AiA

;{XOR}
Ax_ 255
AxB
AxC
AxD
AxE
AxH
AxL
AxA

;{OR}
Ao 255
AoB
AoC
AoD
AoE
AoH
AoL
AoA

Acmpz 255
AcmpzB
AcmpzC
AcmpzD
AcmpzE
AcmpzH
AcmpzL
AcmpzA

Acmps 255
AcmpsB
AcmpsC
AcmpsD
AcmpsE
AcmpsH
AcmpsL
AcmpsA

notA
shlA
shrA

GotoUn0 m1
GotoUnNot0 m1
GotoUnP m1
GotoUnM m1

CallUn0 m1
CallUnNot0 m1
CallUnP m1
CallUnM m1

RetUn0
RetUnNot0
RetUnP
RetUnM
   
_rA 60000
Ar_ 60000

ArmHL
BrmHL
CrmHL
DrmHL
ErmHL
HrmHL
LrmHL

m1:

0

59

unit uFORM;

interface
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ExtCtrls;

type
  TForm1 = class(TForm)
    Timer1: TTimer;
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
    procedure FormDblClick(Sender: TObject);
    procedure Timer1Timer(Sender: TObject);
    procedure ClearMainCanvas;
    procedure CanvasStretchDraw;
    procedure FormCreate(Sender: TObject);
    procedure StartProgram;
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;
  var MainCanvas: tbitmap;
SizeScreenX:Integer=-32760;{Розмір екрану X (встановлений через InitGraph)}
SizeScreenY:Integer=-32760;{Розмір екрану Y (встановлений через InitGraph)}
fCreateFORM:Boolean=false;{Ініціалізація та створення форми, True - форма створена та ініціалізована}
var VideoRAM:array[0..640,0..480] of Cardinal;{Масив відео, для піксельного порівняння, перед виводом на MainCanvas}

procedure INITuFORM;{Ініціалізація та створення форми при умові (fCreateFORM=false) та (Stub.ModeStartDE=4)}
procedure InitGraphForm(var GraphDriver : integer;var GraphMode   : integer);{вмикання “графічного режиму” для форми по аналогії InitGraph}

implementation
uses uProgram;

{$R *.dfm}
procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);{Якщо користувач закриває форму, (жме “хрестик” форми), відбувається вихід}begin Halt;end;
procedure TForm1.CanvasStretchDraw;{виведення MainCanvas на екран}begin Canvas.StretchDraw(rect(0,0,Form1.ClientWidth,Form1.ClientHeight),MainCanvas);end;

procedure TForm1.Timer1Timer(Sender: TObject);{перемальовує форму згідно встановленого Timer1.Inerval:=20, тобто 20/1000 = 50 разів в секунду}
begin //CanvasStretchDraw;
StartProgram;
end;
procedure TForm1.FormDblClick(Sender: TObject);{подвійний клик на формі — розмір форми згідно встановленого режиму}begin Form1.ClientWidth:=SizeScreenX;Form1.ClientHeight:=SizeScreenY;end;
procedure TForm1.ClearMainCanvas;{Очищення MainCanvas та  VideoRAM}
var cx,cy:Cardinal;
begin for cY:=0 to SizeScreenY do for cX:=0 to SizeScreenX do If fCreateFORM=true then MainCanvas.Canvas.Pixels[cX,cY]:=0;
for cY:=0 to SizeScreenY do for cX:=0 to SizeScreenX do VideoRAM[cX,cY]:=0;end;

procedure InitGraphForm(var GraphDriver : integer;var GraphMode   : integer);{вмикання “графічного режиму” для форми по аналогії InitGraph}
const VGA=9; VGALo=0; VGAMed=1; VGAHi=2;
begin
case   GraphDriver of
VGA: case GraphMode of
VGALo:Begin{ 640x200 16 color 4 page } end;
VGAMed:Begin { 640x350 16 color 2 page } end;
VGAHi:Begin { 640x480 16 color 1 page } SizeScreenX:=639;SizeScreenY:=479;end;
end; end;

If ((SizeScreenX>0) and (SizeScreenY>0)) then Begin
  If fCreateFORM=true then begin
MainCanvas.Width:=SizeScreenX+1; MainCanvas.Height:=SizeScreenY+1;
Form1.ClearMainCanvas;
Form1.ClientWidth:=SizeScreenX;Form1.ClientHeight:=SizeScreenY;
Form1.Visible:=True;end;
end else begin {видача помилки}GraphDriver:=-2; GraphMode:=-2;end;
end;

procedure INITuFORM;{Ініціалізація та створення форми при умові (fCreateFORM=false) та (Stub.ModeStartDE=4)}
begin
If (fCreateFORM=false) {and (Stub.ModeStartDE=4)} then Begin
fCreateFORM:=True;
Application.Initialize;
Application.CreateForm(TForm1, Form1);
MainCanvas:=tbitmap.Create;
Form1.Show;
Form1.HIDE;
SizeScreenX:=-32760; SizeScreenY:=-32760;

{ExtractFilePath_:=ExtractFilePath(Application.ExeName);}
end;
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
Form1.ClientWidth:=0;Form1.ClientHeight:=0;
end;

var CallAPMValue:Cardinal=0;{номер апм}
var PraporHALT:Cardinal=0;{прапор виходу}
procedure TForm1.StartProgram;   label BEGINProgram,ENDProgram;
                                 label APM,APM1end;
begin
if PraporHALT=1 then begin Timer1.Enabled:=False; end
                Else {PraporHALT=0}
begin                           begin case CallAPMValue of  0:begin end;
                                  //  1:Begin goto APM1end;end;
                                end; end;

BEGIN
BEGINProgram:

//{APM}begin CallAPMValue:={номер APM}1;Goto APM;end;APM1end:CallAPMValue:=0;

ENDProgram:
END;          PraporHALT:=1;  APM:end; {PraporHALT=0} end;
end.

Max Size FORM 112..1836, 27..616

Form1.ClientWidth:=104;Form1.ClientHeight:=0;
Form1.ClientWidth:=1828;Form1.ClientHeight:=589;

0

60

Чи правильна відповідність кольорів Паскаля та Дельфі
код
{Відповідність кольорів Delphi та PascalGUI}
Const ColorGPas:array[0..15] of TColor=(
0,{Black=0;}$AA0000{Blue=1;},$00AA00{Green=2;},
$AAAA00{Cyan=3;},$0000AA{Red=4;},$AA00AA{Magenta=5;},
$0055AA{Brown=6;},$AAAAAA{LightGray=7;},$555555{ DarkGray=8;},
$FF0000{clBlue}{LightBlue=9;},$00FF00{clLime}{LightGreen=10;},
$FFFF00{clAqua}{LightCyan=11;},$0000FF{clRed}{LightRed=12;},
$FF00FF{clFuchsia}{LightMagenta=13;},$00FFFF{clYellow}{Yellow=14;},
$FFFFFF{clWhite}{lWhite=15;});

0

Ответить
Страница:   1 2 3 4 5  

Быстрый ответ

Напишите ваше сообщение и нажмите «Отправить»


Вы здесь » EnotVM » Тестовый форум » 08 БИТ