Assembler.h

#pragma once
#ifndef ASSEMBLER_H
#define ASSEMBLER_H

#include <string>
#include <vector>
#include <cstdint>
#include <sstream>
#include <algorithm>
#include <cctype>
#include "Memory.h"
#include "CU.h"

using namespace std;

class Assembler {
private:
    CU cu;

    // 문자열 trim
    string trim(const string& str) {
        size_t first = str.find_first_not_of(" \t\r\n");
        if (first == string::npos) return "";
        size_t last = str.find_last_not_of(" \t\r\n");
        return str.substr(first, last - first + 1);
    }

    // 소문자->대문자로 변환
    string toUpper(const string& str) {
        string result = str;
        transform(result.begin(), result.end(), result.begin(), ::toupper);
        return result;
    }

public:
    Assembler() {}

    // 어셈블리 코드를 16bit 기계어로 변환
    // return : 성공시 true, 실패시 false
    bool assembleLine(const string& line, uint16_t& result) {
        string trimmed = trim(line);
        if (trimmed.empty() || trimmed[0] == '#' || trimmed[0] == ';') {
            return false;
        }

        // opcode와 operand 분리
        stringstream ss(trimmed);
        string opcode, operandStr;
        ss >> opcode >> operandStr;

        opcode = toUpper(opcode);
        operandStr = toUpper(operandStr);

        // opcode 변환
        int opcodeValue = cu.stringToOpcode(opcode);
        if (opcodeValue < 0) {
            cerr << "[Assembler Error] Unknown opcode: " << opcode << endl;
            return false;
        }

        // operand 변환
        uint16_t operand = 0;
        if (!operandStr.empty()) {
            if (operandStr.substr(0, 2) == "0X") {
                operandStr = operandStr.substr(2);
            }

            try {
                operand = static_cast<uint16_t>(stoul(operandStr, nullptr, 16));
            }
            catch (...) {
                cerr << "[Assembler Error] Invalid operand: " << operandStr << endl;
                return false;
            }
        }

        if (operand > 0x0FFF) {
            cerr << "[Assembler Error] Operand exceeds 12 bits: " << operandStr << endl;
            return false;
        }

        // 16bit 명령어 조합: opcode(4bit) | operand(12bit)
        result = (static_cast<uint16_t>(opcodeValue) << 12) | operand;
        return true;
    }

    // 여러 줄의 어셈블리를 메모리에 로드
    // return : 로드된 명령어 수
    int loadProgram(Memory* memory, const vector<string>& lines, unsigned int startAddr) {
        int count = 0;
        unsigned int currentAddr = startAddr;

        for (const string& line : lines) {
            uint16_t instruction;
            if (assembleLine(line, instruction)) {
                if (!memory->isValidAddress(currentAddr + 1)) {
                    cerr << "[Assembler Error] Memory address overflow" << endl;
                    break;
                }
                memory->write(currentAddr, instruction);

                cout << "  0x" << hex << setw(3) << setfill('0') << currentAddr
                    << ": " << trim(line) << " -> 0x"
                    << setw(4) << setfill('0') << instruction << dec << endl;

                currentAddr += 2;  // 16bit = 2bytes
                count++;
            }
        }

        return count;
    }
};

#endif