const jump_save_to_ram 4
const jump_output_ram 20
const jump_continue_output 24
const iterations 32
# reg_0 SP (Stack Pointer)

# set index RAM[reg_0], reg_0=0  
0b11000000 #1 opcode ADD 0+0
0b00000000 #2 arg1 source ImVal
0b00000000 #3 arg2 source ImVal
0b00000000 #4 destination reg_0

# jump_save_to_ram ROM[4] -------------------
# копировать с input в RAM
# (через ALU ADD с нулем)
0b01000000 #1 opcode ADD INPUT 0
0b00000111 #2 arg1 source INPUT
0b00000000 #3 arg2 source ImVal
0b00001000 #4 destination RAM

# increment index RAM[reg_0], reg_0+=1 
0b10000000 #1 opcode ADD reg_0+1
0b00000001 #2 arg1 source ImVal
0b00000000 #3 arg2 source reg_0 
0b00000000 #4 destination reg_0

# если reg_0 >= 32 то начать выводить
0b01100101 #1 cond reg_0 >= arg2
0b00000000 #2 arg1 source reg_0
iterations #3 arg2 source ImVal
jump_output_ram #4

# всегда прыгать 
0b11100000 #1 cond arg1 == arg2
0b00000000 #2 arg1 source ImVal
0b00000000 #3 arg2 source ImVal
jump_save_to_ram #4

# jump_output_ram ROM[20] -------------------
# сброс index RAM, reg_0=0 
0b11000000 #1 opcode ADD 0+0
0b00000000 #2 arg1 source ImVal
0b00000000 #3 arg2 source ImVal
0b00000000 #4 destination reg_0

# jump_continue_output ROM[24]
0b01000000 #1 opcode ADD RAM + 0
0b00001000 #2 arg1 source RAM
0b00000000 #3 arg2 source ImVal
0b00000111 #4 destination Output

# increment index RAM[reg_0], reg_0+=1 
0b10000000 #1 opcode ADD reg_0+1
0b00000001 #2 arg1 source ImVal
0b00000000 #3 arg2 source reg_0 
0b00000000 #4 destination reg_0

# всегда прыгать 
0b11100000 #1 cond arg1 == arg2
0b00000000 #2 arg1 source ImVal
0b00000000 #3 arg2 source ImVal
jump_continue_output

const jump_while 12  
const jump_output 28
# 1. Dividend input to reg_1
0b01000000 #1 opcode ADD INPUT 0
0b00000111 #2 arg1 source INPUT
0b00000000 #3 arg2 source ImVal
0b00000001 #4 destination reg_1
 
# 2. Divisor input to reg_2
0b01000000 #1 opcode ADD INPUT 0
0b00000111 #2 arg1 source INPUT
0b00000000 #3 arg2 source ImVal
0b00000010 #4 destination reg_2

# 3. Quotient set 0 to reg_3
0b11000000 #1 opcode ADD 0 0
0b00000000 #2 arg1 source ImVal
0b00000000 #3 arg2 source ImVal
0b00000011 #4 destination reg_3

# jump_while ROM[12]
# 4. IF_LESS  
0b00100010   #1 opcode Cond IF_LESS
0b00000001   #2 arg1 source reg_1
0b00000010   #3 arg2 source reg_2
jump_output #4 destination

# 5. SUB reg_1 - reg_2 = reg_1
0b00000001 #1 opcode SUB
0b00000001 #2 arg1 source reg_1
0b00000010 #3 arg2 source reg_2
0b00000001 #4 destination reg_1

# 6. Quotient ADD 1
0b10000000 #1 opcode ADD 1 reg_3
0b00000001 #2 arg1 source ImVal
0b00000011 #3 arg2 source reg_3
0b00000011 #4 destination reg_3

# always jump
0b11100000  #1 cond arg1 == arg2
0b00000000  #2 arg1 source ImVal
0b00000000  #3 arg2 source ImVal
jump_while #4 destination

# jump_output ROM[28]
# 7. Output Quotient
0b10000000 #1 opcode ADD 0 Quotient
0b00000000 #2 arg1 source ImVal
0b00000011 #3 arg2 source reg_3
0b00000111 #4 destination Output

# 8. Output Remainder
0b10000000 #1 opcode ADD 0 reg_1
0b00000000 #2 arg1 source ImVal
0b00000001 #3 arg2 source reg_1
0b00000111 #4 destination Output

Схема не изменилась с уровня RAM.

# Когда ввод равен 0, 
# pop значение из стека и вывести его 

# Когда вход не равен 0, 
# push это значение в стек
const start_while 4  
const start_pop 28

# reg_4 - Stack Pointer (SP)
# reg_1 - INPUT
# reg_0 - RAM Pointer

# ------------------------------
# Stack Pointer (SP) reg_4
0b11000000 #1 ALU ADD 0 255
0b00000000 #2 arg1 source ImVal
0b11111111 #3 arg2 source 255
0b00000100 #4 destination reg_4

#-------------------------------
# start_while
 
# take INPUT
0b10000000 #1 ALU ADD 0 INPUT
0b00000000 #2 arg1 source ImVal
0b00000111 #3 arg2 source INPUT
0b00000001 #4 destination reg_1

# cond IF_EQUAL 0 == reg_1
0b10100000 #1 cond IF_EQUAL 
0b00000000 #2 arg1 source ImVal
0b00000001 #3 arg2 source reg_1
start_pop #4 destination jump

# start push--------------------
# reg_0=reg_4
0b10000000 #1 ALU ADD 0+reg_4 
0b00000000 #2 arg1 source ImVal
0b00000100 #3 arg2 source reg_4
0b00000000 #4 destination reg_0

# SP-1 push
0b01000001 #1 ALU SUB reg_4-1
0b00000100 #2 arg1 source reg_4
0b00000001 #3 arg2 source ImVal
0b00000100 #4 destination reg_4

# push INPUT значение в стек
0b10000000 #1 ADD 0 reg_1
0b00000000 #2 arg1 source ImVal
0b00000001 #3 arg2 source reg_1
0b00001000 #4 destination RAM

# always jump
0b11100000  #1 cond IF_EQUAL arg1 == arg2
0b00000000  #2 arg1 source ImVal
0b00000000  #3 arg2 source ImVal
start_while #4 destination

# start_pop------------------
# pop значение из стека и вывести его 
# SP+1 pop
0b10000000 #1 ADD 1+reg_4
0b00000001 #2 arg1 source ImVal
0b00000100 #3 arg2 source reg_4
0b00000100 #4 destination reg_4

# reg_0=reg_4
0b10000000 #1 ADD 0+reg_4 
0b00000000 #2 arg1 source ImVal
0b00000100 #3 arg2 source reg_4
0b00000000 #4 destination reg_0

# stack output
0b10000000 #1 ADD 0+reg_4
0b00000000 #2 arg1 source ImVal
0b00001000 #3 arg2 source RAM
0b00000111 #4 destination OUTPUT
 
# ------------------------
# always jump
0b11100000  #1 cond IF_EQUAL arg1 == arg2
0b00000000  #2 arg1 source ImVal
0b00000000  #3 arg2 source ImVal
start_while #4 destination

# Когда ввод равен 0, 
# pop значение из стека и вывести его 

# Когда вход не равен 0, 
# push это значение в стек

# reg_1 - INPUT
#-----------------------------
label jump_while
# MOV INPUT to REG_1
0b00001100 #1 MOV  
0b00000111 #2 INPUT
0          #3 unused
0b00000001 #4 REG_1
 
# cond IF_EQUAL 0 == reg_1
0b10100000 #1 cond IF_EQUAL 
0          #2 arg1 source ImVal
0b00000001 #3 arg2 source reg_1
jump_pop   #4 destination jump

# push INPUT значение в стек
0b00010111 #1 PUSH 
0b00000001 #2 arg1 source reg_1
0          #3 arg2 unused
0b00001000 #4 destination RAM

# always jump
0b11100000  #1 cond IF_EQUAL arg1 == arg2
0b00000000  #2 arg1 source ImVal
0b00000000  #3 arg2 source ImVal
jump_while #4 destination

label jump_pop
# pop значение из стека и вывести его 
0b00010101 #1 POP
0          #2 arg1 Unused
0          #3 arg2 Unused
0b00000111 #4 destination OUTPUT

# always jump
0b11100000 #1 cond IF_EQUAL arg1 == arg2
0          #2 arg1 source ImVal
0          #3 arg2 source ImVal
jump_while #4 destination

Проверка механизма CALL и RET. Реализуем функцию удвоения числа и вызовем ее два раза.

# reg_4 - Stack Pointer (SP)
# reg_0 - RAM Pointer
# reg_1 - arg_1
# reg_2 - result
# CALL opcode `xxxx1xxx` (8)
# RET opcode `xxx1xxxx` (16)
const jump_fn_double 24
const CALL 0b00001000
const RET 0b00010000

# first call fn ----------------------
# set arg_1=5 
0b11000000 #1 opcode ADD 5+0
0b00000101 #2 arg1 source ImVal
0b00000000 #3 arg2 source ImVal
0b00000001 #4 destination reg_1

# CALL fn double
CALL        #1 opcode CALL
0b00000000  #2 arg1 source unused
0b00000000  #3 arg2 source unused
jump_fn_double #4 destination PC

# output result
0b10000000 #1 opcode ADD 0+reg_2
0b00000000 #2 arg1 source ImVal
0b00000010 #3 arg2 source reg_2
0b00000111 #4 destination OUTPUT
# ------------------------------------

# second call fn----------------------
# set arg_1=8 
0b11000000 #1 opcode ADD 8+0
0b00001000 #2 arg1 source ImVal
0b00000000 #3 arg2 source ImVal
0b00000001 #4 destination reg_1

# CALL fn double
CALL        #1 opcode CALL
0b00000000  #2 arg1 source unused
0b00000000  #3 arg2 source unused
jump_fn_double #4 destination PC

# output result
0b10000000 #1 opcode ADD 0+reg_2
0b00000000 #2 arg1 source ImVal
0b00000010 #3 arg2 source reg_2
0b00000111 #4 destination OUTPUT
# -------------------------------------
 
# HALT (!unimplemented opcode)

# jump_fn_double ---------------------
# function implementation 
# fn double(arg_1){reg_2=arg_1+arg_1; return reg_2}
0b00000000 #1 opcode ADD arg_1+arg_1
0b00000001 #2 arg1 source reg_1
0b00000001 #3 arg2 source reg_1
0b00000010 #4 destination reg_2

# RET
RET         #1 opcode RET
0b00000000  #2 arg1 source unused
0b00000000  #3 arg2 source unused
0b00000000  #4 destination unused
# ------------------------------------

• MOV: регистр → регистр
• LOAD: память → регистр
• STORE: регистр → память

Команда MOV
Нам нужна операция MOV, что бы мы могли записать данные, минуя ALU

Opcode: xx0011xx
Arg 1: Source
Arg 2: Unused
Result addr: Destination

Как работают регистры при одновременном чтении и записи? - Они могут одновременно выдавать своё старое значение и принимать новое.
 
-----------------------------------------
# Сценарий проверки режима MOV/LOAD/STORE
# reg_4 - Stack Pointer (SP)
# reg_0 - RAM Pointer
# CALL opcode 00001000 (8)
# RET opcode 00010000 (16)
# MOV opcode xx0011xx
 
const CALL 0b00001000
const RET 0b00010000
 
# MOV ImVal to reg_1
0b10001100 #1 opcode MOV
0b00000101 #2 arg1 source ImVal
0b00000000 #3 arg2 source unused
0b00000001 #4 destination reg_1

# MOV reg_1 to reg_2
0b00001100 #1 opcode MOV
0b00000001 #2 arg1 source reg_1
0b00000000 #3 arg2 source unused
0b00000010 #4 destination reg_2

# MOV reg_2 to OUTPUT
0b00001100 #1 opcode MOV
0b00000010 #2 arg1 source reg_2
0b00000000 #3 arg2 source unused
0b00000111 #4 destination OUTPUT

# MOV (STORE) 
# reg_2 to RAM 
0b00001100 #1 opcode MOV
0b00000010 #2 arg1 source ImVal
0b00000001 #3 arg2 source unused
0b00001000 #4 destination RAM

# MOV (LOAD)
# RAM to reg_3
0b00001100 #1 opcode MOV
0b00001000 #2 arg1 source RAM
0b00000001 #3 arg2 source unused
0b00000011 #4 destination reg_3

# JMP (MOV)  
0b10001100 #1 opcode MOV source destination
0b00000000 #2 arg1 source ImVal
0b00000001 #3 arg2 Unused
0b00000110 #4 destination PC

CJ - Условный переход реализован через команду COND с Result Address в PC:

# CJ always 
0b11100000  #1 cond IF_EQUAL arg1 == arg2
0b00000000  #2 arg1 source ImVal
0b00000000  #3 arg2 source ImVal
0           #4 destination

JMP безусловный переход реализован через MOV с Result Address в PC:

# JMP  
0b10001100 #1 opcode MOV source destination
0b00000000 #2 arg1 source ImVal
0b00000000 #3 arg2 Unused
0b00000110 #4 destination PC

Команда CALL:

Opcode: 0b00001000
Arg 1: Unused
Arg 2: Unused
Result addr: Destination PC

Команда RET:

Opcode: 0b00010000
Arg 1: Unused
Arg 2: Unused
Result addr: Unused (Destination PC)

Проверка механизма CALL и RET. Реализуем функцию удвоения числа и вызовем ее два раза.

# reg_0 - RAM Pointer
# reg_1 - arg_1
# reg_2 - result
# CALL opcode xxxx1xxx (8)
# RET opcode xxx1xxxx (16)
const jump_fn_double 24
const CALL 0b00001000
const RET 0b00010000

# first call fn ----------------------
# set arg_1=5 
0b11000000 #1 opcode ADD 5+0
5          #2 arg1 source ImVal
0          #3 arg2 source ImVal
0b00000001 #4 destination reg_1

# CALL fn double
CALL        #1 opcode CALL
0           #2 arg1 source unused
0           #3 arg2 source unused
jump_fn_double #4 destination PC

# output result
0b10000000 #1 opcode ADD 0+reg_2
0          #2 arg1 source ImVal
0b00000010 #3 arg2 source reg_2
0b00000111 #4 destination OUTPUT
# ------------------------------------

# second call fn----------------------
# set arg_1=8 
0b11000000 #1 opcode ADD 8+0
0          #2 arg1 source ImVal
0          #3 arg2 source ImVal
0b00000001 #4 destination reg_1

# CALL fn double
CALL        #1 opcode CALL
0           #2 arg1 source unused
0           #3 arg2 source unused
jump_fn_double #4 destination PC

# output result
0b10000000 #1 opcode ADD 0+reg_2
0          #2 arg1 source ImVal
0b00000010 #3 arg2 source reg_2
0b00000111 #4 destination OUTPUT
# -------------------------------------
 
# HALT (!unimplemented opcode)

# jump_fn_double ---------------------
# function implementation 
# fn double(arg_1){reg_2=arg_1+arg_1; return reg_2}
0b00000000 #1 opcode ADD arg_1+arg_1
0b00000001 #2 arg1 source reg_1
0b00000001 #3 arg2 source reg_1
0b00000010 #4 destination reg_2

# RET
RET  #1 opcode RET
0    #2 arg1 source unused
0    #3 arg2 source unused
0    #4 destination unused
# ------------------------------------

• PUSH - добавить в стек
• POP - забрать из стека

Мы можем использовать RAM как стек с последних адресов и использовать регистр REG_0 в роли Stack Pointer (SP) (Указатель стека).

На данный момент для реализации поведения стека мы используем две инструкции

• изменение индекса регистра Stack Pointer (SP)
• запись/чтение из стека RAM[SP]

Для команд PUSH/POP необходимо ограничится одной инструкцией т.е. изменение SP должно происходить в железе. А возможность реализовать стек используя REG_0 в роли SP осталась, просто область адресов нужно выбирать выше адресов стека.

Чтобы не потерять/затереть значение в регистре, в начале вызова функции делают PUSH (кладут значение в RAM «на хранение»), а в конце — POP (забирают обратно).
Это позволит делать функции с любым количеством аргументов, не боясь, что они перезапишут регистры основной программы.

Push

Opcode: xx010111
Arg 1: Source  
Arg 2: Unused
Result addr: Unused (destination RAM 0b00001000) 

p.s. свободные два байта можно было бы использовать:

• Arg 2 при наличии его, по прямому назначению для ALU
• Result addr в роли инструкций ALU/Cond

Pop

Opcode: xx010101
Arg 1: Unused (source RAM 0b00001000)  
Arg 2: Unused
Result addr: Destination

Реализация (auto-increment/decrement)

# test PUSH/POP

# 2. PUSH
# 1. POP
#--------------------
# expected behavior:
# OUTPUT: 3, 2, 1, 3, 2, 1...
#--------------------
label jump_start
# PUSH
0b10010111 #1 opcode PUSH
0b00000001 #2 arg1 source ImVal
0          #3 arg2 Unused
0          #4 destination Unused
 
# PUSH
0b10010111 #1 opcode PUSH
0b00000010 #2 arg1 source ImVal
0          #3 arg2 Unused
0b00000100 #4 destination Unused
 
# PUSH
0b10010111 #1 opcode PUSH
0b00000011 #2 arg1 source ImVal
0          #3 arg2 Unused
0 #4 destination Unused

# POP
0b00010101 #1 opcode POP
0          #2 arg1 Unused
0          #3 arg2 Unused
0b00000111 #4 destination OUTPUT

# POP
0b00010101 #1 opcode POP
0          #2 arg1 Unused
0          #3 arg2 Unused
0b00000111 #4 destination OUTPUT
 
# POP
0b00010101 #1 opcode POP
0          #2 arg1 Unused
0          #3 arg2 Unused
0b00000111 #4 destination OUTPUT
 
# JMP  
0b10001100 #1 opcode MOV source destination
jump_start #2 arg1 source ImVal
0          #3 arg2 Unused
0b00000110 #4 destination PC

[первый байт][второй байт    ][трейтий байт   ][четвертый байт       ]
[что делать ][источник 1     ][источник 2     ][куда девать результат]
[Opcode 8bit][Argument 1 8bit][Argument 2 8bit][Result address 8bit  ]

Opcode 8bit:

ALU:
биты xx000111 режима ALU, результат его работы в общую шину:
0: ALU xxxxxxx1 #1
1: ALU xxxxxx1x #2
2: ALU xxxxx1xx #4

ALU DIV:
opcode: xx010100
arg_1 : Source 
arg_2 : Source 
result_addr: Destination

CALL:
бит режима CALL, данные из Result address (четвертый байт ISA инс.) в общую шину для PC:
3: CALL 00001000 #8 идентификатор режима

RET:
бит режима RET, данные из Result address (четвертый байт ISA инс.) в общую шину для PC:
4: RET 00010000 #16 идентификатор режима

COND:
биты xx1xx111 режима COND, данные из Result address (четвертый байт ISA инс.) в общую шину для PC. 
0: COND xxxxxxx1 #1
1: COND xxxxxx1x #2
2: COND xxxxx1xx #4
5: COND xx1xxxxx #32 идентификатор режима, если бит установлен

Immediate values:
биты 11xxxxxx режима Immediate values:
6: x1xxxxxx #64 выбор в роли Immediate values Argument 2 (трейтий байт ISA инс.) идентификатор режима, если бит установлен
7: 1xxxxxxx #128 выбор в роли Immediate values Argument 1 (второй байт ISA инс.) идентификатор режима, если бит установлен

MOV:
биты xx0011xx режима MOV
opcode: xx0011xx
arg_1: Source
arg_2: Unused
result_addr: Destination (для JMP Result addr = 6 PC)

PUSH:
opcode: xx010111
arg_1 : Source  
arg_2 : Unused
result_addr: Unused (target RAM) 

POP:
opcode: xx010101
arg_1 : Unused (зафиксирован источник RAM 0b00001000)  
arg_2 : Unused
result_addr: Destination

Argument 1/Argument 2/Result address 8bit:

биты xxxx1111 кодируют адрес исчтоника/пунтка назначения:
0: #1 участвует в кодировании восьми адресов (Register 0-5, PC, Input/Output)
1: #2 участвует в кодировании восьми адресов (Register 0-5, PC, Input/Output)
2: #4 участвует в кодировании восьми адресов (Register 0-5, PC, Input/Output)
4: #8 xxxx1xxx только для RAM

Результат декодирования трех младших бит xxxxx111:
0: Register 0
1: Register 1
2: Register 2
3: Register 3
4: Register 4
5: Register 5
6: Counter (PC)
7: Input (для Argument 1 и Argument 2) или Output (для Result address)

CC - Условный CALL (Conditional CALL)

Сейчас нет возможности одной инструкцией выполнить проверку условия и выполнить вызов CALL.

Это позволит писать код типа if (a == 10) run_function().

• Если arg1 == arg2, мы не просто меняем PC, мы сначала запоминаем, где мы стояли, чтобы потом вернуться (командой RET)
• Нужно в «железе» объединить логику записи в стек и логику проверки условия.

Сейчас для этого нужно две инструкции (сначала COND для прыжка на вызов, а потом сам CALL с запоминанием адреса возврата).

Режим CC

Opcode: xx1010xx и xx1011xx
Arg 1: Source  
Arg 2: Source 
Result addr: Destination 

xx1011xx - для условий COND: IF_GREATER_OR_EQUAL,IF_GREATER
xx1010xx - для остальных условий COND

# Поведение сейчас:
    # always jump
    0b11100000  #1 cond IF_EQUAL arg1 == arg2
    0b00000000  #2 arg1 source ImVal
    0b00000000  #3 arg2 source ImVal
    jump_while #4 destination

    # и тут мы не можем выполнить RET так как адрес возврата никто не запоминал. Адрес возврата запоминается при команде CALL но не COND
    # ...

# Поведение которое нам нужно:
    # always jump
    0b11010100  #1 COND_CALL IF_EQUAL arg1 == arg2
    0b00000000  #2 arg1 source ImVal
    0b00000000  #3 arg2 source ImVal
    jump_while #4 destination

    # метка jump_while и нас сюда перебросил PC
    # мы выполняем RET и нас перебрасывает на следующую инструкцию после места с которого мы пришли по условию COND_CALL
    RET         #1 opcode RET
    0b00000000  #2 arg1 source unused
    0b00000000  #3 arg2 source unused
    0b00000000  #4 destination unused

# Сценарий проверки режима CC
# MOV opcode xx0011xx
# CC opcode xx1010xx для остальных условий COND
# CC opcode xx1011xx для условий COND: IF_GREATER_OR_EQUAL,IF_GREATER
const RET 0b00010000
#--------------------
# expected behavior:
# OUTPUT: 6, 7, 8, 6, 7, 8...
#--------------------
label jump_start
 
# test CC IF 0==0
0b11101000   #1 CC
0            #2 arg1 source ImVal
0            #3 arg2 source ImVal
jump_success #4 destination
 
# print 7
0b11000000 #1 ALU ADD
4          #2 arg1 source ImVal
3          #3 arg2 source ImVal
0b00000111 #4 destination OUTPUT

# test CC IF 1==0
0b11101000   #1 CC
1            #2 arg1 source ImVal
0            #3 arg2 source ImVal
jump_success #4 destination

# print 8
0b11000000 #1 ALU ADD
4          #2 arg1 source ImVal
4          #3 arg2 source ImVal
0b00000111 #4 destination OUTPUT

# always jump 
0b11100000  #1 COND IF_EQUAL arg1 == arg2
0b00000000  #2 arg1 source ImVal
0b00000000  #3 arg2 source ImVal
jump_start  #4 destination

label jump_success
# print 6
0b11000000 #1 ALU ADD
4          #2 arg1 source ImVal
2          #3 arg2 source ImVal
0b00000111 #4 destination OUTPUT
 
RET        #1 RET
0b00000000 #2 arg1 source
0b00000000 #3 arg2 source 
0b00000000 #4 destination

Про Indirect Jump:

• Косвенный переход (Indirect Jump)
• Сейчас Result address (4-й байт) — это всегда число (адрес в RAM). Но что, если мы захотим прыгнуть по адресу, который лежит в регистре?
• Это нужно для реализации оператора switch (таблицы переходов)
• "Возьми адрес для прыжка не из 4-го байта Result address (Immediate values), а из reg_N, на который этот байт указывает".
  • И эта возможность у нас уже реализованна в режиме ALU (или MOV), мы просто для Result address выбираем PC и результат операции ADD данных из reg_N + 0 перезапишет PC

Про Indirect Conditional CALL (ICC):

• Реализуя поведение Indirect Jump вместе с Conditional и CALL, получим Indirect Conditional CALL (ICC), что позволит выполнять переход на указанный адрес из регистра/RAM по условию с сохранением адреса возврата.

Opcode: xx1111xx и xx1100xx 
Arg 1: Source  
Arg 2: Source
Result addr: используется в роли Source для Result addr 

xx1111xx - для условий COND: IF_GREATER_OR_EQUAL,IF_GREATER
xx1100xx - для остальных условий COND

# Сценарий проверки режима ICC

# MOV opcode xx0011xx
# CC opcode xx1011xx для условий COND: IF_GREATER_OR_EQUAL,IF_GREATER
# CC opcode xx1010xx для остальных условий COND
# ICC opcode xx1111xx для условий COND: IF_GREATER_OR_EQUAL,IF_GREATER
# ICC opcode xx1100xx для остальных условий COND
const RET 0b00010000
#--------------------
# expected behavior:
# OUTPUT: 6,7,8,6,7,8...  
#--------------------
 
label jump_start
# MOV 12 to reg_4
0b10001100   #1 MOV
jump_success #2 arg1 source ImVal
0b00000000   #3 arg2 source unused
0b00000100   #4 destination reg_4

# ICC cond IF_EQUAL 44==44
0b11110000 #1 ICC
44         #2 arg1 source ImVal
44         #3 arg2 source ImVal
0b00000100 #4 destination reg_4

# print 7
0b11000000 #1 ALU ADD
5          #2 arg1 source ImVal
2          #3 arg2 source ImVal
0b00000111 #4 destination OUTPUT

0b10001100 jump_second_step 0 6 #jump

label jump_success
# print 6
0b11000000 #1 ALU ADD
4          #2 arg1 source ImVal
2          #3 arg2 source ImVal
0b00000111 #4 destination OUTPUT

RET        #1 RET
0b00000000 #2 arg1 source
0b00000000 #3 arg2 source 
0b00000000 #4 destination

label jump_second_step
# ICC cond IF_EQUAL reg_4==0
0b01110000 #1 ICC
0b00000100 #2 arg1 source reg_4
0b00000000 #3 arg2 source ImVal
0b00000100 #4 destination reg_4
 
# print 8
0b11000000 #1 ALU ADD
4          #2 arg1 source ImVal
4          #3 arg2 source ImVal
0b00000111 #4 destination OUTPUT

# JMP  
0b10001100 #1 MOV source destination
jump_start #2 arg1 source ImVal
0b00000000 #3 arg2 Unused
0b00000110 #4 destination PC

Плюс третий декодер источников специально для этого режима, и регистры заменились на прозрачные т.е. всегда LOAD, тогда может и декодеры для выбора источника не нужны?

Поддержка относительных переходов (Relative Jumps)

• Сейчас в режиме COND Result address — это всегда абсолютный адрес (например, "прыгни на 100").
• Это мешает делать перемещаемый код (когда мы можем скопировать кусок программы в другое место памяти, и он продолжит работать).
• Логика: Значение из Result address не просто заменяет PC, а складывается с текущим PC. Это позволит делать короткие циклы типа "прыгни на 5 байт назад".

Про Relative Jumps (RJ): (unimplemented)

• RJ относительный переход

p.s. команда RJ не использует старшие биты, что дает возможность закодировать еще +3 команды без условных операций.

Про Indirect Relative Jumps (IRJ):

• IRJ относительный переход

Opcode: xx010110 
Arg 1: Source  
Arg 2: Source
Result addr: Unused (target ADD Source+Source=PC) 

------------------------
# test IRJ:
#--------------------
# expected behavior:
# jump to jump_success
# OUTPUT: 3,3...  
#--------------------
label jump_start
# MOV 6 to reg_3
0b10001100 #1 MOV
6          #2 arg1 source ImVal
0          #3 arg2 unused
0b00000011 #4 destination reg_3
 
# IRJ ADD source+source=PC
0b10010110 #1 IRJ 2+6=8 result addr
2          #2 arg1 source ImVal
0b00000011 #3 arg2 source reg_3
0          #4 unused

# print 5
0b10001100 #1 MOV
5          #2 arg1 source ImVal
0          #3 arg2 Unused
0b00000111 #4 destination OUTPUT
 
label jump_success
# print 3
0b10001100 #1 MOV
3          #2 arg1 source ImVal
0          #3 arg2 Unused
0b00000111 #4 destination OUTPUT

# JMP  
0b10001100 #1 MOV source destination
jump_start #2 arg1 source ImVal
0          #3 arg2 Unused
0b00000110 #4 destination PC

Про Conditional Relative Jumps (CRJ):

• CRJ условный относительный переход, т.е. мы по условию выполняем прыжок по результату сложения текущего адреса PC с значением из Result addr
• Применяется когда мы хотим просто прыгнуть по условию внутри if или цикла (без возврата) но без сохранения адреса возврата в стеке.

Opcode: xx0110xx и xx0111xx 
Arg 1: Source  
Arg 2: Source
Result addr: ImVal 

xx0111xx CRJ - для условий COND: IF_GREATER_OR_EQUAL,IF_GREATER
xx0110xx CRJ - для остальных условий COND

--------------------------
# test CRJ:
#--------------------
# expected behavior:
# jump to jump_success
# OUTPUT: 6,7,6,7...  
#--------------------
label jump_start
# print 7
0b11000000 #1 ADD
4          #2 arg1 source ImVal
3          #3 arg2 source ImVal
0b00000111 #4 destination OUTPUT
 
# CRJ cond IF_EQUAL 0==0
0b11011000 #1 CRJ +16
0          #2 arg1 source ImVal
0          #3 arg2 source ImVal
16         #4 destination ImVal

# print 5
0b11000000 #1 ADD
0b00000100 #2 arg1 source ImVal
0b00000001 #3 arg2 source ImVal
0b00000111 #4 destination OUTPUT

label jump_second_step
# CRJ cond IF_EQUAL 1==0
0b11011000 #1 CRJ +8
1          #2 arg1 source reg_1
0          #3 arg2 source reg_2
8          #4 destination ImVal

# JMP  
0b10001100 #1 MOV source destination
jump_start #2 arg1 source ImVal
0          #3 arg2 Unused
0b00000110 #4 destination PC

label jump_success
# print 6
0b11000000 #1 ADD
4          #2 arg1 source ImVal
2          #3 arg2 source ImVal
0b00000111 #4 destination OUTPUT

# JMP  
0b10001100 #1 MOV source destination
jump_second_step #2 arg1 source ImVal
0          #3 arg2 Unused
0b00000110 #4 destination PC

Про Indirect Conditional Relative CALL (ICRC):

• ICRC Косвенный условный относительный переход с сохранением адреса возврата (т.е нам нужно выполнять RET)

Opcode: xx1101xx и xx1110xx 
Arg 1: Source  
Arg 2: Source
Result addr: используется в роли Source для Result addr 

xx1101xx ICRC - для условий COND: IF_GREATER_OR_EQUAL,IF_GREATER
xx1110xx ICRC - для остальных условий COND


--------------------------------
 
# test ICRC
#--------------------
# expected behavior:
# jump to jump_success
# OUTPUT: 5,6,7,5,6,7 ...  
#-------------------- 
# RET opcode 00010000 (16)
const RET 0b00010000

label jump_start
# MOV reg_4 20
0b10001100 #1 MOV
20         #2 arg1 source ImVal
0b00000000 #3 arg2 Unused
0b00000100 #4 destination reg_4

# ICRC cond IF_EQUAL 1==1
0b11111000 #1 ICRC +reg_4
1          #2 arg1 source ImVal
1          #3 arg2 source ImVal
0b00000100 #4 destination reg_4

# print 6
0b11000000 #1 ADD
3          #2 arg1 source ImVal
3          #3 arg2 source ImVal
0b00000111 #4 destination OUTPUT

# ICRC cond IF_EQUAL 1==0
0b11111000 #1 ICRC +reg_4
1          #2 arg1 source ImVal
0          #3 arg2 source ImVal
0b00000100 #4 destination reg_4

# print 7
0b11000000 #1 ADD
4          #2 arg1 source ImVal
3          #3 arg2 source ImVal
0b00000111 #4 destination OUTPUT

# JMP  
0b10001100 #1 MOV source destination
jump_start #2 arg1 source ImVal
0b00000000 #3 arg2 Unused
0b00000110 #4 destination PC

label jump_success
# print 5
0b11000000 #1 ADD
4          #2 arg1 source ImVal
1          #3 arg2 source ImVal
0b00000111 #4 destination OUTPUT

# RET
RET #1 RET
0 #2 arg1 source
0 #3 arg2 source 
0 #4 destination

# JMP  
0b10001100 #1 opcode MOV source destination
jump_start #2 arg1 source ImVal
0          #3 arg2 Unused
0b00000110 #4 destination PC

Арифметичиеские операции - это основа вычислений, поэтому они должны быть максимально реализованы.

• INC/DEC (увеличение/уменьшение на 1)
• MUL/IMUL (умножение без/со знаком)
• DIV/IDIV (деление)

Архитектура ALU через флаги.

Флаги — это специальные биты (Zero, Carry, Sign и др.), которые автоматически обновляются процессором после арифметических или логических операций.

• Z (Zero) Результат = 0
• N (Negative) Результат < 0 (старший бит)
• C (Carry) Была перенос/заём при сложении/вычитании
• V (Overflow) Переполнение знакового числа

Зачем они нужны:

1. Для условных переходов: Позволяют выполнять if/else, while и for на основе результата предыдущей операции (например, «если результат равен нулю», «если число отрицательное»).
2. Для математики: Позволяют обрабатывать переносы (carry) при вычислениях с числами больше разрядности процессора (например, 16-битное число на 8-битном процессоре).
3. Экономия ресурсов: Позволяют принимать логические решения, не сохраняя промежуточные результаты вычислений в регистры.

У нас еще не реализована возможность завершить работу процессора, остановив счетчик программ PC или CLOCK - HALT

Двухуровневая архитектура, с 8-ми битными инструкциями для скорости и 32-х битными для мощности.

Возможность процессора мгновенно бросить выполнение текущей программы, если нажата клавиша или сработал таймер.

Для многозадачности (переключение программ по таймеру) и мгновенной реакции на ввод-вывод.

.org 0
.text
jump_start:
    # comment
    MOV 1, r3 # comment
    MOV 2, ram
    MOV 3, pc
    MOV 4, io

    MOV r1, r2
    MOV ram, r2
    MOV ram, ram
    MOV ram, pc
    MOV pc, ram
    MOV io, ram
    MOV io, pc
    MOV io, io

    PUSH r0
    PUSH 255
    PUSH ram
    PUSH io
    PUSH pc
    POP r0
    POP ram
    POP io
    POP pc

    ADD 5, r2, r3
    ADD r1, r2, r3

    SUB 5, r2, r3
    SUB r1, r2, r3

    AND 5, r2, r3
    AND r1, r2, r3

    OR 5, r2, r3
    OR r1, r2, r3

    NOT 5, r3
    NOT r1, r3

    XOR 5, r2, r3
    XOR r1, r2, r3

    NAND 5, r2, r3
    NAND r1, r2, r3 

    NOR 5, r2, r3
    NOR r1, r2, r3 

    DIV 5, r2, r3
    DIV r1, r2, r3 

    CALL jump_here

    CJE 5, 4, jump_start
    CJNE 5, 4, jump_start
    CJL 5, 4, jump_start
    CJLE 5, 4, jump_start
    CJG 5, 4, jump_start
    CJGE 5, 4, jump_start

    JMP jump_start

    MOV [var_1], r1 # косвенная адресация не поддерживается LEG
    MOV var_1, r1   # подстановка констант Immediate Value
    MOV 40, r1          # Immediate Value
    MOV r2, r1

jump_here:
    NOR 5, r2, r3
    NOR r1, r2, r3  
    RET
.data
var_1:
    .byte 42  
var_2:
    .byte 43    

use disassembly::decode;
use std::collections::HashMap;
  
#[derive(Debug)]
enum ParsedLine {
    Label(String),
    Instruction(Instruction),
    Directive(Directive),
    Empty,
}

#[derive(Debug)]
enum Directive {
    Data,
    Text,
    Org(u8),
    Byte(u8),
}

#[derive(Debug)]
enum Operand {
    Source(u8),
    Immediate(u8),
    IndirectAddr(String),
    MemLabel(String),
}

#[derive(Debug)]
struct SourceOperand{
    imm_flag: u8,
    src: Operand
}
impl SourceOperand {
    pub fn new(imm_flag: u8, src: Operand) -> Self{
        Self{imm_flag, src}
    }
}

#[derive(Debug)]
enum Instruction {
    Mov { src: SourceOperand, dst: u8 },
    Push { src: SourceOperand},
    Pop { dst: u8 },
    Jmp { label: String },
    Cj { a: SourceOperand, b: SourceOperand, label: String, inst: u8 },
    Add { a: SourceOperand, b: SourceOperand, dst: u8 },
    Sub { a: SourceOperand, b: SourceOperand, dst: u8 },
    And { a: SourceOperand, b: SourceOperand, dst: u8 },
    Or { a: SourceOperand, b: SourceOperand, dst: u8 },
    Not { a: SourceOperand, dst: u8 },
    Xor { a: SourceOperand, b: SourceOperand, dst: u8 },
    Nand { a: SourceOperand, b: SourceOperand, dst: u8 },
    Nor { a: SourceOperand, b: SourceOperand, dst: u8 },
    Div { a: SourceOperand, b: SourceOperand, dst: u8 },
    Call { label: String },
    Ret,
}

#[derive(Debug)]
struct EncodedInstruction {
    opcode: u8,
    arg1: u8,
    arg2: u8,
    result: u8,
}

enum AluOp {
    Add,
    Sub,
    And,
    Or,
    Xor,
    Nand,
    Nor,
    Div,
}

#[derive(Clone, Copy, PartialEq)]
enum Section {
    Text,
    Data,
}

static INPUT_ASM_CODE: &str = "
jump_start:
    comment
    MOV 1, r3 # comment
    MOV 2, ram
    MOV 3, pc
    MOV 4, io

    MOV r1, r2
    MOV ram, r2
    MOV ram, ram
    MOV ram, pc
    MOV pc, ram
    MOV io, ram
    MOV io, pc
    MOV io, io

    PUSH r0
    PUSH 255
    PUSH ram
    PUSH io
    PUSH pc
    POP r0
    POP ram
    POP io
    POP pc

    ADD 5, r2, r3
    ADD r1, r2, r3

    SUB 5, r2, r3
    SUB r1, r2, r3

    AND 5, r2, r3
    AND r1, r2, r3

    OR 5, r2, r3
    OR r1, r2, r3

    NOT 5, r3
    NOT r1, r3

    XOR 5, r2, r3
    XOR r1, r2, r3

    NAND 5, r2, r3
    NAND r1, r2, r3 

    NOR 5, r2, r3
    NOR r1, r2, r3 

    DIV 5, r2, r3
    DIV r1, r2, r3 

    CALL jump_here

    CJE 5, 4, jump_start
    CJNE 5, 4, jump_start
    CJL 5, 4, jump_start
    CJLE 5, 4, jump_start
    CJG 5, 4, jump_start
    CJGE 5, 4, jump_start

    JMP jump_start

jump_here:
    NOR 5, r2, r3
    NOR r1, r2, r3  
    RET
";

fn main() {
    const INSTRUCTION_BIT_DEPTH: u8 = 4;
 
    let input = INPUT_ASM_CODE;
    let lines: Vec<&str> = input.lines().collect();
    let mut data_values: HashMap<String, u8> = HashMap::new();

    // PASS 1: collect labels
    let mut labels = HashMap::new();
    let mut address: u8 = 0;
    let mut last_label: Option<String> = None;

    let mut section = Section::Text;
    let mut text_end: u8 = 0;
    let mut data_org: Option<u8> = None;

    for line in &lines {
        match parse_line(line) {
            ParsedLine::Label(name) => {
                labels.insert(name.clone(), address);
                last_label = Some(name);
            }
            ParsedLine::Instruction(_) => {
                address = address.checked_add(INSTRUCTION_BIT_DEPTH)
                .unwrap_or_else(|| panic!("Address overflow! \nThe maximum address value is 255. \nCurrent address:{} + depth:{} > 255",address,INSTRUCTION_BIT_DEPTH));
            }
            ParsedLine::Directive(d) => {
                match d {
                    Directive::Org(addr) => {
                        if section == Section::Data {
                            data_org = Some(addr);

                            if addr < text_end {
                                panic!("Error: data section overlaps with text section");
                            }
                        }
                        address = addr;
                    }
                    Directive::Byte(value) => {
                         if section == Section::Data {
                            if let Some(label) = &last_label {
                                data_values.insert(label.clone(), value);
                            } else {
                                panic!(".byte without label in data section");
                            }
                        }
                        address = address.checked_add(1)
                       .unwrap_or_else(|| panic!("Address overflow! \nThe maximum address value is 255. \nCurrent address:{} + 1 > 255",address));
                    }
                    Directive::Text => {
                        section = Section::Text;
                    }
                    Directive::Data => {
                        section = Section::Data;
                        // фиксируем конец текста
                        text_end = address;
                        let data_start = match data_org {
                            Some(addr) => addr,
                            None => text_end,
                        };
                        if data_start < text_end {
                            panic!("Error: data section overlaps with text section");
                        }
                        address = data_start;
                    }
                }
            }
            ParsedLine::Empty => {}
        }
    }

    // Debug label addresses
    println!("# label addresses:");
    for (key, value) in &labels {
        println!("# {}: {:03}", key, value); 
    }
    println!("# ------------------------------");
    
    
    // PASS 2: encode instructions
    let mut output: Vec<u8> = vec![0; 256];
    let mut max_address: u8 = 0;
    address = 0;

    let mut section = Section::Text;
    let mut text_end: u8 = 0;
    let mut data_org: Option<u8> = None;
 
    for line in &lines {
        match parse_line(line) {
            ParsedLine::Instruction(instr) => {
                let encoded = encode_instruction(instr, &labels, &data_values);

                output[address as usize] = encoded.opcode;
                output[(address + 1) as usize] = encoded.arg1;
                output[(address + 2) as usize] = encoded.arg2;
                output[(address + 3) as usize] = encoded.result;

                address += INSTRUCTION_BIT_DEPTH;
                max_address = max_address.max(address);
            }

            ParsedLine::Directive(d) => {
                match d {
                    Directive::Org(addr) => {
                        if section == Section::Data {
                            data_org = Some(addr);
                        }
                        address = addr;
                    }
                    Directive::Byte(value) => {
                        output[address as usize] = value;
                        address += 1;
                        max_address = max_address.max(address);
                    }
                    Directive::Text => {
                        section = Section::Text;
                    }
                    Directive::Data => {
                        section = Section::Data;
                        text_end = address;
                        let data_start = match data_org {
                            Some(addr) => addr,
                            None => text_end,
                        };
                        if data_start < text_end {
                            panic!("Error: data section overlaps with text section");
                        }
                        address = data_start;
                    }
                }
            }
            ParsedLine::Label(_) | ParsedLine::Empty => {}
        }
    }

    let used = max_address as usize;

    // show assembly code
    /*
        for  (chunk_idx, inst) in output[..used].chunks(INSTRUCTION_BIT_DEPTH as usize).enumerate(){
            if inst.len() < 4 {
                break;
            }
            println!("0b{:08b}", inst[0]);
            println!("0b{:08b}", inst[1]);
            println!("0b{:08b}", inst[2]);
            println!("0b{:08b}", inst[3]); 
            println!();
        }
    */

    // Debug
    println!("# Program size: {max_address} bytes");
    println!("# ------------------------------\n");
    println!("# bytes    |:addr|text instruction");
    for  (chunk_idx, inst) in output[..used].chunks(INSTRUCTION_BIT_DEPTH as usize).enumerate(){
        if inst.len() < 4 {
            break;
        }
        let base_addr = chunk_idx * INSTRUCTION_BIT_DEPTH as usize;

        let text_inst = decode(inst[0], inst[1], inst[2], inst[3]);

        println!("0b{:08b} #:{:03} |{}", inst[0],base_addr,text_inst);
        println!("0b{:08b} #:{:03}", inst[1],base_addr+1);
        println!("0b{:08b} #:{:03}", inst[2],base_addr+2);
        println!("0b{:08b} #:{:03}", inst[3],base_addr+3); 
        println!();
    }
   
}

fn strip_comment(line: &str) -> &str {
    if let Some(pos) = line.find('#') {
        &line[..pos]
    } else {
        line
    }
}

fn parse_line(line: &str) -> ParsedLine {
    let line = line.trim();
    let code = strip_comment(line).trim();

    if code.is_empty() {
        return ParsedLine::Empty;
    }

    if code.ends_with(':') {
        let label = code.trim_end_matches(':').to_string();
        return ParsedLine::Label(label);
    }

    let tokens: Vec<&str> = code
        .split([' ', ','])
        .filter(|s| !s.is_empty())
        .collect();

    if tokens.is_empty() {
        return ParsedLine::Empty;
    }

    match tokens[0] {
        ".data" => ParsedLine::Directive(Directive::Data),
        ".text" => ParsedLine::Directive(Directive::Text),
        ".org" => {
            let value = parse_number(tokens[1]);
            ParsedLine::Directive(Directive::Org(value))
        }
        ".byte" => {
            let value = parse_number(tokens[1]);
            ParsedLine::Directive(Directive::Byte(value))
        },

        "MOV" => parse_mov(&tokens),
        "PUSH" => parse_push(&tokens),
        "POP" => parse_pop(&tokens),
        "JMP" => {
            let label = tokens[1].to_string();
            ParsedLine::Instruction(Instruction::Jmp { label })
        },
        "CJE"|"CJNE"|"CJL"|"CJLE"|"CJG"|"CJGE" => parse_cj(&tokens),
        "ADD" => parse_alu(&tokens, AluOp::Add),
        "SUB" => parse_alu(&tokens, AluOp::Sub),
        "AND" => parse_alu(&tokens, AluOp::And),
        "OR" => parse_alu(&tokens, AluOp::Or),
        "NOT" => parse_not(&tokens),
        "XOR" => parse_alu(&tokens, AluOp::Xor),
        "NAND" => parse_alu(&tokens, AluOp::Nand),
        "NOR" => parse_alu(&tokens, AluOp::Nor),
        "DIV" => parse_alu(&tokens, AluOp::Div),
        "CALL" => {
            let label = tokens[1].to_string();
            ParsedLine::Instruction(Instruction::Call { label })
        },
        "RET" => ParsedLine::Instruction(Instruction::Ret),
        _ => panic!("Unknown instruction: {}", tokens[0]),
    }
}
 
// MOV: 
// * src регистров/RAM/INPUT/PC/Immediate Value 
// * dest регистр/RAM/OUTPUT/PC
fn parse_mov(tokens: &[&str]) -> ParsedLine {
    let src = parse_operand(tokens[1], 128);
    let dst = parse_source( tokens[2]);
    ParsedLine::Instruction(Instruction::Mov {
        src,
        dst
    })
}

fn parse_push(tokens: &[&str]) -> ParsedLine {
    let src = parse_operand(tokens[1], 128);
    ParsedLine::Instruction(Instruction::Push {src})
}

fn parse_pop(tokens: &[&str]) -> ParsedLine {
    let dst= {
        match tokens[1] {
            "r0" | "r1" | "r2" | "r3" | "r4" | "r5" |
            "pc" | "io" | "ram" => {
                parse_source(tokens[1])
            }
            _ => {
                panic!("Unknown source: {}", tokens[1]);
            }
        }
    };
    ParsedLine::Instruction(Instruction::Pop {
        dst, 
    })
}
 
fn parse_cj(tokens: &[&str]) -> ParsedLine {
    let a = parse_operand(tokens[1], 128);
    let b = parse_operand(tokens[2], 64);
    let label = tokens[3].to_string();
    let inst = {
        let inst = tokens[0];
        match inst {
            "CJE" => {0b00100000}, // 32 IF_EQUAL
            "CJNE" => {0b00100001},// 33 IF_NOT_EQUAL
            "CJL" => {0b00100010}, // 34 IF_LESS
            "CJLE" => {0b00100011},// 35 IF_LESS_OR_EQUAL 
            "CJG" => {0b00100100}, // 36 IF_GREATER
            "CJGE" => {0b00100101},// 37 IF_GREATER_OR_EQUAL
            _ => panic!("Unknown command:{}",inst)
        }
    };
    ParsedLine::Instruction(Instruction::Cj {a, b, label, inst })
}

fn parse_alu(tokens: &[&str], kind: AluOp) -> ParsedLine {
    let a = parse_operand(tokens[1], 128);
    let b = parse_operand(tokens[2], 64);
    let dst = parse_source(tokens[3]);
    match kind{
        AluOp::Add => {ParsedLine::Instruction(Instruction::Add {a, b, dst })},
        AluOp::Sub => {ParsedLine::Instruction(Instruction::Sub {a, b, dst })},
        AluOp::And => {ParsedLine::Instruction(Instruction::And { a, b, dst })},
        AluOp::Or => {ParsedLine::Instruction(Instruction::Or {a, b, dst })},
        AluOp::Xor => {ParsedLine::Instruction(Instruction::Xor {a, b, dst })},
        AluOp::Nand => {ParsedLine::Instruction(Instruction::Nand {a, b, dst })},
        AluOp::Nor => {ParsedLine::Instruction(Instruction::Nor {a, b, dst })},
        AluOp::Div => {ParsedLine::Instruction(Instruction::Div {a, b, dst })},
    }
}

fn parse_not(tokens: &[&str]) -> ParsedLine {
    let a = parse_operand(tokens[1], 128);

    let dst = parse_source(tokens[2]);

    ParsedLine::Instruction(Instruction::Not {a, dst })
}

fn parse_operand(s: &str, imm_flag: u8) -> SourceOperand {
    // [label] — адрес
    if s.starts_with('[') && s.ends_with(']') {
        let label = &s[1..s.len() - 1];
        return SourceOperand::new(imm_flag, Operand::IndirectAddr(label.to_string()));
    }

    // регистр
    match s {
        "r0" | "r1" | "r2" | "r3" | "r4" | "r5" |
        "pc" | "io" | "ram" => {
            return SourceOperand::new(0, Operand::Source(parse_source(s)));
        }
        _ => {}
    }

    // число
    if let Ok(num) = s.parse::<u8>() {
        return SourceOperand::new(imm_flag, Operand::Immediate(num));
    }

    // иначе это метка с константой
    SourceOperand::new(imm_flag, Operand::MemLabel(s.to_string()))
}

fn parse_source(name: &str) -> u8 {
    match name {
        "r0" => 0,
        "r1" => 1,
        "r2" => 2,
        "r3" => 3,
        "r4" => 4,
        "r5" => 5,
        "pc" => 6,
        "io" => 7,
        "ram" => 8,
        _ => panic!("Unknown register: {}", name),
    }
}

fn parse_number(s: &str) -> u8 {
    s.parse::<u8>().expect("Invalid number")
}

fn encode_src(src: SourceOperand, labels: &HashMap<String, u8>, data_values: &HashMap<String, u8>) -> u8 {
    match src.src {
        Operand::Source(s) => {s},
        Operand::Immediate(v) => {v},
        Operand::IndirectAddr(label) => {
            *labels.get(&label).expect("Unknown label")  
        } 
        Operand::MemLabel(label) => {
           // Если есть значение в data_values - берем его как immediate
            if let Some(val) = data_values.get(&label) {
                *val
            } else {
                // иначе используем адрес (если, например, jump)
                *labels.get(&label).expect("Unknown label")
            } 
        }                 
    }
}

fn encode_instruction(
    instr: Instruction,
    labels: &HashMap<String, u8>,
    data_values: &HashMap<String, u8>
) -> EncodedInstruction {
    match instr {
        Instruction::Mov { src, dst } => EncodedInstruction {
            opcode: src.imm_flag|0b00001100,  
            arg1: encode_src(src, labels, data_values),
            arg2: 0,
            result: dst,
        },
        Instruction::Push { src } => EncodedInstruction {
            opcode: src.imm_flag|0b00010111,  
            arg1: encode_src(src, labels, data_values),
            arg2: 0,
            result: 0b00001000,
        },
        Instruction::Pop { dst } => EncodedInstruction {
            opcode: 0b00010101,  
            arg1: 0,
            arg2: 0,
            result: dst,
        },
        Instruction::Add { a, b, dst } => EncodedInstruction {
            opcode: a.imm_flag|b.imm_flag,
            arg1: encode_src(a, labels, data_values),
            arg2: encode_src(b, labels, data_values),
            result: dst,
        },
        Instruction::Sub { a, b, dst } => EncodedInstruction {
            opcode: a.imm_flag|b.imm_flag|0b00000001,
            arg1: encode_src(a, labels, data_values),
            arg2: encode_src(b, labels, data_values),
            result: dst,
        },   
        Instruction::And { a, b, dst } => EncodedInstruction {
            opcode: a.imm_flag|b.imm_flag|0b00000010,
            arg1: encode_src(a, labels, data_values),
            arg2: encode_src(b, labels, data_values),
            result: dst,
        },  
        Instruction::Or { a, b, dst } => EncodedInstruction {
            opcode: a.imm_flag|b.imm_flag|0b00000011,
            arg1: encode_src(a, labels, data_values),
            arg2: encode_src(b, labels, data_values),
            result: dst,
        },  
        Instruction::Not { a,dst } => EncodedInstruction {
            opcode: a.imm_flag|0b00000100,
            arg1: encode_src(a, labels, data_values),
            arg2: 0,
            result: dst,
        },  
        Instruction::Xor { a, b, dst } => EncodedInstruction {
            opcode: a.imm_flag|b.imm_flag|0b00000101,
            arg1: encode_src(a, labels, data_values),
            arg2: encode_src(b, labels, data_values),
            result: dst,
        },  
        Instruction::Nand { a, b, dst } => EncodedInstruction {
            opcode: a.imm_flag|b.imm_flag|0b00000110,
            arg1: encode_src(a, labels, data_values),
            arg2: encode_src(b, labels, data_values),
            result: dst,
        },  
        Instruction::Nor { a, b, dst } => EncodedInstruction {
            opcode: a.imm_flag|b.imm_flag|0b00000111,
            arg1: encode_src(a, labels, data_values),
            arg2: encode_src(b, labels, data_values),
            result: dst,
        },  
        Instruction::Div { a, b, dst } => EncodedInstruction {
            opcode: a.imm_flag|b.imm_flag|0b00010100,
            arg1: encode_src(a, labels, data_values),
            arg2: encode_src(b, labels, data_values),
            result: dst,
        },  
        Instruction::Call { label} => {
            let addr = *labels
                .get(&label)
                .expect("Unknown label");

            EncodedInstruction {
                opcode: 0b00001000,
                arg1: 0,
                arg2: 0,
                result: addr,
            }
        },
        Instruction::Jmp { label } => {
            let addr = *labels
                .get(&label)
                .expect("Unknown label");

            EncodedInstruction {
                opcode: 0b10001100,
                arg1: addr,
                arg2: 0,
                result: 0b00000110,
            }
        },
        Instruction::Cj { a, b, label, inst} => {
            let addr = *labels
                .get(&label)
                .expect("Unknown label");

            EncodedInstruction {
                opcode:  a.imm_flag|b.imm_flag|inst|0b00100000,
                arg1: encode_src(a, labels, data_values),
                arg2: encode_src(b, labels, data_values),
                result: addr,
            }
        },
        Instruction::Ret => EncodedInstruction {
            opcode: 0b00010000,
            arg1: 0,
            arg2: 0,
            result: 0,
        },
    }
}

pub mod disassembly {

    fn reg_name(id: u8) -> &'static str {
        match id {
            0 => "r0",
            1 => "r1",
            2 => "r2",
            3 => "r3",
            4 => "r4",
            5 => "r5",
            6 => "pc",
            7 => "io",
            8 => "ram",
            _ => "unk",
        }
    }

    fn decode_operand(flag: bool, value: u8) -> String {
        if flag {
            value.to_string()
        } else {
            reg_name(value).to_string()
        }
    }

    pub fn decode(opcode: u8, arg1: u8, arg2: u8, result: u8) -> String {
        let ai = opcode & 0b10000000 != 0;
        let bi = opcode & 0b01000000 != 0;
        let base = opcode & 0b00111111;

        let a = decode_operand(ai, arg1);
        let b = decode_operand(bi, arg2);
        let dst = reg_name(result);

        match base {
            0b00000000 => format!("ADD {}, {}, {}", a, b, dst),
            0b00000001 => format!("SUB {}, {}, {}", a, b, dst),
            0b00000010 => format!("AND {}, {}, {}", a, b, dst),
            0b00000011 => format!("OR {}, {}, {}", a, b, dst),
            0b00000100 => format!("NOT {}, {}", a, dst),
            0b00000101 => format!("XOR {}, {}, {}", a, b, dst),
            0b00000110 => format!("NAND {}, {}, {}", a, b, dst),
            0b00000111 => format!("NOR {}, {}, {}", a, b, dst),
            0b00001100 => {
                let src = decode_operand(ai, arg1);
                let dst = reg_name(result);
                format!("MOV {}, {}", src, dst)
            },
            0b00010111 => {
                let src = decode_operand(ai, arg1);
                format!("PUSH :{}", src)
            },
            0b00010101 => {
                let dst = reg_name(result);
                format!("POP {}", dst)
            },
            0b00010100 => format!("DIV {}, {}, {}", a, b, dst),
            0b00001000 => {
                format!("CALL :{:03}", result)
            },
            0b00010000 => "RET".to_string(),
            0b00100000 => format!("CJE {}, {}, :{:03}", a, b, result),
            0b00100001 => format!("CJNE {}, {}, :{:03}", a, b, result),
            0b00100010 => format!("CJL {}, {}, :{:03}", a, b, result),
            0b00100011 => format!("CJLE {}, {}, :{:03}", a, b, result),
            0b00100100 => format!("CJG {}, {}, :{:03}", a, b, result),
            0b00100101 => format!("CJGE {}, {}, :{:03}", a, b, result),
            _ => format!(
                "Unknown opcode={:08b} arg1={} arg2={} dst={:08}",
                opcode, arg1, arg2, result
            ),
        }
    }
}