অ্যাসেম্বলি ল্যাঙ্গুয়েজ বেসিকস

# -- এটি বাস্তব হার্ডওয়্যার নয়, একটি টয় assembler + simulator: রেজিস্টার ও মেমরি স্রেফ Python dict/list হিসেবে সিমুলেট করা হয়েছে

OPCODES = {'ADD': 0, 'ADDI': 1, 'LOAD': 2, 'STORE': 3, 'BEQ': 4}

def encode_r_type(opcode, rd, rs1, rs2):
    """L24-স্টাইল: opcode(4bit) | rd(4bit) | rs1(4bit) | rs2(4bit) -- একটি ১৬-বিট ইনস্ট্রাকশনে প্যাক"""
    return (opcode << 12) | (rd << 8) | (rs1 << 4) | rs2

def encode_i_type(opcode, rd, rs1, imm):
    """L24-স্টাইল: opcode(4bit) | rd(4bit) | rs1(4bit) | imm(4bit) -- শিক্ষার সুবিধার্থে ছোট্ট ৪-বিট imm ফিল্ড"""
    return (opcode << 12) | (rd << 8) | (rs1 << 4) | (imm & 0xF)

def assemble(lines):
    """অ্যাসেম্বলি টেক্সট লাইনগুলো পার্স করে ইনস্ট্রাকশন dict + বাস্তব বাইনারি এনকোডিং -- দুটোই তৈরি করে"""
    program = []
    for raw_line in lines:
        line = raw_line.split(';')[0].strip()  # কমেন্ট বাদ
        if not line:
            continue
        parts = line.replace(',', ' ').split()
        mnemonic = parts[0].upper()
        args = parts[1:]

        if mnemonic == 'ADD':
            rd, rs1, rs2 = (int(a[1:]) for a in args)
            enc = encode_r_type(OPCODES['ADD'], rd, rs1, rs2)
            program.append({'op': 'ADD', 'rd': rd, 'rs1': rs1, 'rs2': rs2, 'encoded': enc})
        elif mnemonic == 'ADDI':
            rd, rs1 = int(args[0][1:]), int(args[1][1:])
            imm = int(args[2])
            enc = encode_i_type(OPCODES['ADDI'], rd, rs1, imm)
            program.append({'op': 'ADDI', 'rd': rd, 'rs1': rs1, 'imm': imm, 'encoded': enc})
        elif mnemonic == 'LOAD':
            rd = int(args[0][1:])
            off_str, rs1_str = args[1].split('(')
            offset, rs1 = int(off_str), int(rs1_str.rstrip(')')[1:])
            enc = encode_i_type(OPCODES['LOAD'], rd, rs1, offset)
            program.append({'op': 'LOAD', 'rd': rd, 'rs1': rs1, 'imm': offset, 'encoded': enc})
        elif mnemonic == 'STORE':
            rs2 = int(args[0][1:])
            off_str, rs1_str = args[1].split('(')
            offset, rs1 = int(off_str), int(rs1_str.rstrip(')')[1:])
            enc = encode_i_type(OPCODES['STORE'], rs2, rs1, offset)
            program.append({'op': 'STORE', 'rs2': rs2, 'rs1': rs1, 'imm': offset, 'encoded': enc})
        elif mnemonic == 'BEQ':
            rs1, rs2 = int(args[0][1:]), int(args[1][1:])
            offset = int(args[2])
            enc = encode_i_type(OPCODES['BEQ'], rs2, rs1, offset)
            program.append({'op': 'BEQ', 'rs1': rs1, 'rs2': rs2, 'imm': offset, 'encoded': enc})
    return program

def simulate(program, registers, memory, max_steps=20):
    registers[0] = 0  # r0 সবসময় ০ -- L26-এর হার্ডওয়্যার্ড-জিরো নিয়ম
    pc, steps, trace = 0, 0, []
    while 0 <= pc < len(program) and steps < max_steps:
        ins = program[pc]
        next_pc = pc + 1
        if ins['op'] == 'ADD':
            result = registers[ins['rs1']] + registers[ins['rs2']]
            if ins['rd'] != 0:
                registers[ins['rd']] = result
            trace.append(f"PC={pc}: ADD  r{ins['rd']} = r{ins['rs1']}+r{ins['rs2']} = {result}")
        elif ins['op'] == 'ADDI':
            result = registers[ins['rs1']] + ins['imm']
            if ins['rd'] != 0:
                registers[ins['rd']] = result
            trace.append(f"PC={pc}: ADDI r{ins['rd']} = r{ins['rs1']}+{ins['imm']} = {result}")
        elif ins['op'] == 'BEQ':
            equal = registers[ins['rs1']] == registers[ins['rs2']]
            if equal:
                next_pc = pc + 1 + ins['imm']
            trace.append(
                f"PC={pc}: BEQ  r{ins['rs1']}({registers[ins['rs1']]}) == "
                f"r{ins['rs2']}({registers[ins['rs2']]}) ? {equal} -> PC হবে {next_pc}"
            )
        pc = next_pc
        steps += 1
    return trace

asm_lines = [
    "BEQ r1, r2, 1",
    "BEQ r0, r0, 1",
    "ADDI r3, r1, 1",
]
program = assemble(asm_lines)
print("এনকোড হওয়া বাইনারি:", [ins['encoded'] for ins in program])

print("\n--- কেস ১: a == b (a=5, b=5) ---")
regs1 = [0, 5, 5, 999, 0, 0, 0, 0]   # r3 আগে থেকেই 999 (সেন্টিনেল) -- বদলালো কিনা দেখার জন্য
for line in simulate(program, regs1, {}):
    print(" ", line)
print(f"ফলাফল: c = r3 = {regs1[3]}  (প্রত্যাশিত: a+1 = 6)")

print("\n--- কেস ২: a != b (a=5, b=3) ---")
regs2 = [0, 5, 3, 999, 0, 0, 0, 0]
for line in simulate(program, regs2, {}):
    print(" ", line)
print(f"ফলাফল: c = r3 = {regs2[3]}  (প্রত্যাশিত: অপরিবর্তিত, 999 -- ADDI এড়িয়ে গেছে)")

assert regs1[3] == 6, "কেস ১ ভুল!"
assert regs2[3] == 999, "কেস ২ ভুল -- ব্রাঞ্চ ঠিকমতো স্কিপ করেনি!"
print("\nদুটো কেসই সঠিক -- BEQ ব্রাঞ্চ সঠিকভাবে এক্সিকিউট/স্কিপ করছে।")