macro flagi : {load rn,flags;}
macro _flagi : {load rm,flags;}
macro mov reg1,reg2:{add reg1,reg2,z;}
macro inc reg: {add reg,z,nz;}


EQU AX:R0
EQU CX:R1
EQU DX:R2
EQU BX:R3
EQU SP:R4
EQU BP:R5
EQU SI:R6
EQU DIN:R7
EQU CS:R8
EQU SS:R9
EQU DS:R10
EQU LR:R15
EQU RR:R14

LINK L:CT,RDM

Link rb:8,9,10
Link ra:0,1,2 \\Zadanie D_1

DW 4455fH:0100010100000000B
DW 44560H:0101000001111111B
DW 44561H:0101100011111011B \\kod programu
DW 44562H:1001001100000000B
DW 44563H:0100100100000000B

DW 00020H:FFFFH
DW 00021H:AAAAH \\stos dla zadania na 3 - mozna wywalic
DW 00022H:0001H

ACCEPT CS:3456h
ACCEPT LR:FFFFh
ACCEPT SS:4457h \->
ACCEPT SP:0000h \-> ustawienia dla stosu z zadania D_2
ACCEPT AX:ABCDh
ACCEPT BX:FaFah


ORG 070h \\orgi trzeba tak ustawic jak w zadaniu D_7 - trzeba policzyc ile jest komend jedna komenda to jedna komorka
\\(prawdopodobnie etykiety tez trzeba liczyc)

zaladowanie_rozkazu
{mov R12,CS;}
{MOV RQ,LR;}
{push nz,1;}
{rpct adres;} \jednorazowy skok do "adres"


{R;add RR,BUS_D,z;cjp RDM,cp;} /*R-sygnal odczytu z pamieci operacyjnej zapis do RR argumentu (BUS_D)
znajdujacego sie na magistrali danych RDM-sygnal gotowosci RAM */
{cjp nz,dekodowanie;}

ORG 150h

dekodowanie
\SPRAWDZ CZY INC
{AND R13,RR,1111100000000000B;} \\spisanie pierwszych 5 bitow do R13
{XOR R13,R13,0100000000000000B;_flagi;} \\porownanie R13 z kodem rozkazu
{cjp rM_z,wykonanie_inc;} \\jesli wyjda same zera to skok
\SPRAWDZ CZY DEC
{AND R13,RR,1111100000000000B;}
{XOR R13,R13,0100100000000000B;_flagi;}
{cjp rM_z,wykonanie_dec;}
\SPRAWDZ CZY PUSH
{AND R13,RR,1111100000000000B;}
{XOR R13,R13,0101000000000000B;_flagi;}
{cjp rM_z,wykonanie_push;}
\SPRAWDZ CZY POP
{AND R13,RR,1111100000000000B;}
{XOR R13,R13,0101100000000000B;_flagi;}
{cjp rM_z,wykonanie_pop;}
\SPRAWDZ CZY XCHG
{AND R13,RR,1111100000000000B;}
{XOR R13,R13,1001000000000000B;_flagi;}
{cjp rM_z,wykonanie_xchg;}

{END;}

ORG 000h

wykonanie_inc \\inkremetacja = +1
{push nz,1;}
{rpct rejestr;} \\skok do "rejestr"
{LOAD RM,RN;} \\zapamietanie flag
{Add rb,1,z;_flagi;CEM_C;} \\dodanie 1; komenda CEM_C zabrania zapisu flagi Carry
{LOAD RN,RM;} \\wpisanie flag na nowo
{ADD LR,LR,1;_flagi;} \\zwiekszenie licznika rozkazow
{cjp rM_c,poprawa;} \\jesli w poprzenim wystapilo Carry to skok do "poprawa"
{cjp nz,zaladowanie_rozkazu;} \\skok do poczatku

wykonanie_dec
{push nz,1;}
{rpct rejestr;}
{LOAD RM,RN;}
{sub rb,rb,z;_flagi;CEM_C;} \\ -1
{LOAD RN,RM;}
{ADD LR,LR,1;_flagi;}
{cjp rM_c,poprawa;}
{cjp nz,zaladowanie_rozkazu;}

wykonanie_push
{push nz,1;}
{rpct rejestr;}
{SUB SP,Z;_flagi;} \\odjecie od wskaznika stosu 1
{push nz,1;}
{rpct push_stos;} \\skok do "push_stos"

{mov R12,SS;}
{MOV RQ,SP;} \\przygotowanie rejestrow do poprawnego wykonania "adres"
{push nz,1;}
{rpct adres;}

{mov RQ,RB;}
{W;add nil,z,RQ;oey;cjp RDM,cp;} \\zapis na stos

{ADD LR,LR,1;_flagi;}
{cjp rm_c,poprawa;}
{cjp nz,zaladowanie_rozkazu;}

wykonanie_pop
{push nz,1;}
{rpct rejestr;}
{mov R12,SS;push nz,4;}
{rpct petla;}

{mov R12,SS;}
{MOV RQ,SP;}
{push nz,1;}
{rpct adres;}

{R;MOV RB,BUS_D;cjp RDM,cp;} \\odczyt ze stosu

{ADD SP,Z,NZ;_flagi;} \\wskaznik stosu +1
{CJP RM_C,pop_stos;}
pop
{ADD LR,LR,1;_flagi;}
{cjp rm_c,poprawa;}
{cjp nz,zaladowanie_rozkazu;}

wykonanie_xchg
{push nz,1;}
{rpct rejestr;}
{mov rq,rb;} \\przeniesienie z RB do RQ
{mov rb,ax;} \\przeniesienie z AX do RB
{mov ax,rq;} \\przeniesienie z RQ do AX
{ADD LR,LR,1;_flagi;}
{cjp RM_C,poprawa;}
{cjp nz,zaladowanie_rozkazu;}

ORG 100h

push_stos \\to samo co robi "poprawa" tylko dla segmentu stosu z tym, ze odejmuje 1000h
{SUB SS,1000H,nz;}
{CRTN NZ;}

pop_stos
{SUB SS,1000H,nz;}
{jmap pop;}

poprawa \\aby po przepelnieniu LR (FFFFh + 1) odczytac kolejna komorke z pamieci nalezy do segmentu dodac 1000h
{ADD CS,1000H;}
{jmap zaladowanie_rozkazu;}

rejestr \\tu dekoduje sie o jaki rejestr chodzi w rozkazie AX,BX itd. - zadanie D_5
{AND R13,RR,0000011100000000B;}
{add nil,R13,z;oey;ewb;} \\komenda ewb ustawia rejestr RB aby wskazywal na ktorys z rejestrow Rx; 000 - R1, 001 - R2, 010 - R3, itd.
{CRTN NZ;}

petla
{SLL R12;}
{SL.25 R13;} \\mnozenie segmentu razy 16 (po czterech powtórzeniach)
{RPCT petla;}
{crtn nz;}

adres \\zadanie D_4
{push nz,4;}
{rpct petla;} \\4x wykonaj do petla
{add nil,R12,RQ;OEY;EWL;_flagi;} /*OEY-zezwolenie wyslania rezultatu ALU na magistrale danych MD
EWL-zapis 16 mlodszych bitów adresu do rejestru adresu RgA */
{Add NIL,r13,z,RM_C;OEY;EWH;} \EWH-zapis 4 starszych bitów (0000)
{crtn nz;}
{end;}