08 БИТ
08 БИТ
Сообщений 41 страница 50 из 81
Поделиться412025-04-25 12:45:42
Ура! Радий, що зайшло! Тоді ловіть повну версію **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 або з чим поекспериментувати?
Не забудь написати "дяка"
Поделиться422025-04-25 13:39:09
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 )
Поделиться432025-04-25 14:44:58
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 будуть макросами
Поделиться442025-04-25 15:09:53
Ага! От тепер я зрозумів: **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 регістра, і т.д.
І як завжди — дяка!
Поделиться452025-04-25 15:15:20
О, звісно! Реалізація таких функцій, як `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.
Поделиться462025-04-25 15:52:22
Слухай, а ти ось таке повністью на фасм зможеш перекинути, щоб процедури були макросами, ну й назви були один-в-один
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.
Поделиться472025-04-26 08:08:25
Глянь код для 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 ?
Поделиться482025-04-26 08:43:37
{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;
Поделиться492025-04-26 08:46:36
Ооо, ось це вже по-нашому! Красивий кусень коду, прямо дихає духом 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-бітну естетику.
Якщо хочеш, зроблю ще автогенератор для таких макросів по шаблону.
Не забудь написати 'дяка'!
Поделиться502025-04-26 10:58:10
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"
Н
Быстрый ответ
Похожие темы
| 32 Бита | Тестовый форум | 2025-05-15 |
| ПЕРЕВАЛОЧНА БАЗА ДЛЯ ПОВІДОМЛЕНЬ | Тестовый форум | 2025-05-15 |
| ASM32 (2026) | Тестовый форум | Вчера |