pdp-11_1

from pyparsing import (Word, Literal, Optional, Group, OneOrMore,
                      alphas, nums, hexnums, Combine, Suppress, ParseException,
                      restOfLine)
import struct
import re

# Конфигурация парсера
octal_number = Combine(Literal('0') + Word('01234567')).setParseAction(lambda t: int(t[0], 8))
decimal_number = Word(nums).setParseAction(lambda t: int(t[0]))
hex_number = Combine(Literal('0') + (Literal('x') | Literal('X')) + Word(hexnums)).setParseAction(lambda t: int(t[0], 16))
number = octal_number | hex_number | decimal_number

register = Word('Rr', nums, max=2).setParseAction(lambda t: f"R{t[0][1:]}")
indirect = Suppress('(') + register + Suppress(')')
auto_dec = Suppress('-(') + register + Suppress(')')
auto_inc = Suppress('(') + register + Suppress(')+')
indirect_inc = Suppress('@(') + register + Suppress(')+')
immediate = Suppress('#') + number

operand = (indirect_inc | auto_dec | auto_inc | indirect | immediate | register | number)

instruction = Word(alphas.upper(), max=4)
instr_operands = Group(Optional(operand + Optional(Suppress(',') + Optional(operand))))
comment = Suppress(';') + restOfLine
assembly_line = instruction("opcode") + instr_operands("operands") + Optional(comment)

# Таблица опкодов PDP-11 (расширенная)
OPCODES = {
    'MOV': 0o010000, 'MOVB': 0o110000,
    'ADD': 0o060000, 'SUB': 0o160000,
    'CMP': 0o020000, 'CMPB': 0o120000,
    'BIT': 0o030000, 'BITB': 0o130000,
    'BIC': 0o040000, 'BICB': 0o140000,
    'BIS': 0o050000, 'BISB': 0o150000,
    'CLR': 0o005000, 'CLRB': 0o105000,
    'COM': 0o005100, 'COMB': 0o105100,
    'INC': 0o005200, 'INCB': 0o105200,
    'DEC': 0o005300, 'DECB': 0o105300,
    'NEG': 0o005400, 'NEGB': 0o105400,
    'ADC': 0o005500, 'ADCB': 0o105500,
    'SBC': 0o005600, 'SBCB': 0o105600,
    'TST': 0o005700, 'TSTB': 0o105700,
    'ROR': 0o006000, 'RORB': 0o106000,
    'ROL': 0o006100, 'ROLB': 0o106100,
    'ASR': 0o006200, 'ASRB': 0o106200,
    'ASL': 0o006300, 'ASLB': 0o106300,
    'BR': 0o000400, 'BNE': 0o001000,
    'JMP': 0o000100, 'JSR': 0o004000,
    'RTS': 0o000200, 'HALT': 0o000000
}

# Режимы адресации
ADDR_MODES = {
    'R0': 0o00, 'R1': 0o01, 'R2': 0o02, 'R3': 0o03,
    'R4': 0o04, 'R5': 0o05, 'R6': 0o06, 'R7': 0o07,
    '(R0)': 0o10, '(R1)': 0o11, '(R2)': 0o12, '(R3)': 0o13,
    '(R4)': 0o14, '(R5)': 0o15, '(R6)': 0o16, '(R7)': 0o17,
    '-(R0)': 0o20, '-(R1)': 0o21, '-(R2)': 0o22, '-(R3)': 0o23,
    '-(R4)': 0o24, '-(R5)': 0o25, '-(R6)': 0o26, '-(R7)': 0o27,
    '(R0)+': 0o30, '(R1)+': 0o31, '(R2)+': 0o32, '(R3)+': 0o33,
    '(R4)+': 0o34, '(R5)+': 0o35, '(R6)+': 0o36, '(R7)+': 0o37,
    '@(R0)+': 0o40, '@(R1)+': 0o41, '@(R2)+': 0o42, '@(R3)+': 0o43,
    '@(R4)+': 0o44, '@(R5)+': 0o45, '@(R6)+': 0o46, '@(R7)+': 0o47,
    '#': 0o50
}


def encode_operand(op):
    """Кодирует операнд в режим адресации и дополнительное слово"""
    if isinstance(op, int):
        return 0o67, op  # Непосредственная адресация (абсолютный режим)

    if op.startswith('R'):
        return ADDR_MODES[op], 0

    if op.startswith('('):
        if op.startswith('-('):
            return ADDR_MODES[f"-({op[3:-1]})"], 0
        elif op.endswith(')+'):
            if op.startswith('@'):
                return ADDR_MODES[f"@({op[3:-2]})+"], 0
            return ADDR_MODES[f"({op[1:-2]})+"], 0
        return ADDR_MODES[f"({op[1:-1]})"], 0

    if op.startswith('#'):
        return ADDR_MODES['#'], int(op[1:])

    return 0o67, int(op)  # Абсолютная адресация


def assemble_instruction(parsed_line, pc, labels):
    """Генерирует машинный код для одной инструкции"""
    try:
        opcode = parsed_line.opcode
        operands = parsed_line.operands.asList() if parsed_line.operands else []

        if opcode not in OPCODES:
            raise ValueError(f"Неизвестная инструкция: {opcode}")

        base_op = OPCODES[opcode]

        # Обработка инструкций без операндов
        if opcode in ['HALT', 'NOP', 'RTS']:
            return struct.pack('<H', base_op)

        # Обработка ветвлений
        if opcode in ['BR', 'BNE', 'BEQ', 'BPL', 'BMI']:
            if not operands:
                raise ValueError(f"Отсутствует операнд для инструкции {opcode}")
            offset = labels.get(operands[0], pc) - pc
            return struct.pack('<H', base_op | (offset & 0o377))

        # Обработка инструкций с одним операндом
        if len(operands) == 1:
            mode, value = encode_operand(operands[0])
            instruction = base_op | (mode << 6)
            machine_code = struct.pack('<H', instruction)
            if mode == 0o67 or (mode == 0o50 and value > 0o177777):
                machine_code += struct.pack('<H', value)
            return machine_code

        # Обработка инструкций с двумя операндами
        if len(operands) == 2:
            src_mode, src_value = encode_operand(operands[0])
            dst_mode, dst_value = encode_operand(operands[1])
            instruction = base_op | (src_mode << 6) | dst_mode
            machine_code = struct.pack('<H', instruction)

            # Добавляем дополнительные слова для операндов
            if src_mode == 0o67 or (src_mode == 0o50 and src_value > 0o177777):
                machine_code += struct.pack('<H', src_value)
            if dst_mode == 0o67 or (dst_mode == 0o50 and dst_value > 0o177777):
                machine_code += struct.pack('<H', dst_value)

            return machine_code

        raise ValueError(f"Неподдерживаемое количество операндов для {opcode}")

    except ParseException as e:
        print(f"Ошибка разбора строки: {e}")
        return None


def assemble_file(input_file, output_file):
    """Основная функция ассемблирования"""
    labels = {}
    pc = 0

    # Первый проход: сбор меток
    with open(input_file, 'r') as f:
        for line_num, line in enumerate(f, 1):
            line = re.sub(r';.*', '', line).strip()
            if not line:
                continue

            # Обработка меток
            if ':' in line:
                label, _ = line.split(':', 1)
                labels[label.strip()] = pc
                line = line.split(':', 1)[1].strip()
                if not line:
                    continue

            try:
                parsed = assembly_line.parseString(line)
                if parsed.opcode in OPCODES:
                    pc += 2  # Базовый размер инструкции
                    # Учет дополнительных слов
                    if parsed.operands:
                        ops = parsed.operands.asList()
                        for op in ops:
                            if isinstance(op, str) and op.startswith('#'):
                                value = int(op[1:])
                                if value > 0o177777:
                                    pc += 2
                            elif not any(c.isalpha() for c in str(op)):
                                pc += 2
            except ParseException:
                continue

    # Второй проход: генерация кода
    with open(input_file, 'r') as f_in, open(output_file, 'wb') as f_out:
        pc = 0
        for line_num, line in enumerate(f_in, 1):
            line = re.sub(r';.*', '', line).strip()
            if not line:
                continue

            # Пропускаем строки с метками
            if ':' in line:
                line = line.split(':', 1)[1].strip()
                if not line:
                    continue

            try:
                parsed = assembly_line.parseString(line)
                machine_code = assemble_instruction(parsed, pc, labels)
                if machine_code:
                    f_out.write(machine_code)
                    pc += len(machine_code)
            except (ParseException, ValueError) as e:
                print(f"Ошибка в строке {line_num}: {e}")


# Пример программы на PDP-11
sample_program = """
    MOV #1000, R0    ; Загрузить значение в R0
    LOOP:
    ADD R1, R0       ; Добавить R1 к R0
    CMP R0, #2000    ; Сравнить с 2000
    BNE LOOP         ; Повторять если не равно
    HALT             ; Останов
"""

# Сохраняем пример в файл
with open("pdp11_sample.asm", "w") as f:
    f.write(sample_program)

# Ассемблируем
assemble_file("pdp11_sample.asm", "pdp11_output.bin")
print("Ассемблирование завершено. Результат в pdp11_output.bin")