asm.cpp

// Krishkumar
// 2401CS83

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <cstdint>
#include <algorithm>
#include <iomanip>

using namespace std;

//  Instruction format: 8-bit opcode, 24-bit signed operand

enum OperandType
{
    NONE,
    VALUE,
    OFFSET
};

struct OpcodeEntry
{
    int code;
    OperandType type;
};

map<string, OpcodeEntry> opcodeTable = {
    {"ldc", {0, VALUE}},
    {"adc", {1, VALUE}},
    {"ldl", {2, VALUE}},  // SP-relative offset — not PC-relative
    {"stl", {3, VALUE}},  // SP-relative offset — not PC-relative
    {"ldnl", {4, VALUE}}, // A-relative offset  — not PC-relative
    {"stnl", {5, VALUE}}, // A-relative offset  — not PC-relative
    {"add", {6, NONE}},
    {"sub", {7, NONE}},
    {"shl", {8, NONE}},
    {"shr", {9, NONE}},
    {"adj", {10, VALUE}},
    {"a2sp", {11, NONE}},
    {"sp2a", {12, NONE}},
    {"call", {13, OFFSET}}, // PC-relative
    {"return", {14, NONE}},
    {"brz", {15, OFFSET}},  // PC-relative
    {"brlz", {16, OFFSET}}, // PC-relative
    {"br", {17, OFFSET}},   // PC-relative
    {"HALT", {18, NONE}}};

struct ParsedLine
{
    string label;
    string mnemonic;
    string operand;
    string sourceLine;
    int lineNumber;
};

map<string, int> symbolTable;
vector<ParsedLine> parsedLines;
vector<uint32_t> machineCode;
vector<string> errors;
vector<string> rawLines;    // original source lines
vector<int> lineAddressMap; // PC for each parsedLine entry

ofstream logFile;

static void logOut(const string &msg)
{
    cout << msg;
    if (logFile.is_open())
        logFile << msg;
}

static void logErr(const string &msg)
{
    cerr << msg;
    if (logFile.is_open())
        logFile << msg;
}

//  trim whitespace

static string trim(const string &s)
{
    size_t start = s.find_first_not_of(" \t\r\n");
    if (start == string::npos)
        return "";
    size_t end = s.find_last_not_of(" \t\r\n");
    return s.substr(start, end - start + 1);
}

static bool isValidLabel(const string &name)
{
    if (name.empty())
        return false;
    // Must start with letter or underscore
    if (!isalpha((unsigned char)name[0]) && name[0] != '_')
        return false;
    for (size_t i = 1; i < name.size(); i++)
    {
        if (!isalnum((unsigned char)name[i]) && name[i] != '_')
            return false;
    }
    return true;
}

static bool parseNumber(const string &s, int32_t &value)
{
    if (s.empty())
        return false;
    try
    {
        size_t pos = 0;
        if (s.size() > 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
        {
            value = static_cast<int32_t>(stoul(s, &pos, 16));
        }
        else if (s[0] == '-' || s[0] == '+')
        {
            value = static_cast<int32_t>(stol(s, &pos, 10));
        }
        else
        {
            value = static_cast<int32_t>(stoul(s, &pos, 10));
        }
        return pos == s.size();
    }
    catch (...)
    {
        return false;
    }
}

//  1. readFile()

bool readFile(const string &filename)
{
    ifstream fin(filename);
    if (!fin.is_open())
    {
        logErr("Error: cannot open file '" + filename + "'\n");
        return false;
    }
    string line;
    while (getline(fin, line))
    {
        rawLines.push_back(line);
    }
    fin.close();
    return true;
}

//  2. parseLine()

ParsedLine parseLine(const string &raw, int lineNumber)
{
    ParsedLine p;
    p.sourceLine = raw;
    p.lineNumber = lineNumber;

    // Strip comment (everything from ';' onward)
    string line = raw;
    size_t commentPos = line.find(';');
    if (commentPos != string::npos)
        line = line.substr(0, commentPos);
    line = trim(line);

    if (line.empty())
        return p;

    // Tokenise by whitespace
    istringstream iss(line);
    vector<string> tokens;
    string tok;
    while (iss >> tok)
        tokens.push_back(tok);

    int idx = 0;

    // Check for label (token ending with ':')
    if (!tokens.empty() && tokens[0].back() == ':')
    {
        p.label = tokens[0].substr(0, tokens[0].size() - 1);
        idx = 1;
    }

    // Mnemonic
    if (idx < (int)tokens.size())
    {
        p.mnemonic = tokens[idx];
        idx++;
    }

    // Operand (rest of tokens joined)
    if (idx < (int)tokens.size())
    {
        p.operand = tokens[idx];
        for (int i = idx + 1; i < (int)tokens.size(); i++)
            p.operand += " " + tokens[i];
    }

    return p;
}

//  3. buildSymbolTable()  — Pass 1

bool buildSymbolTable()
{
    int pc = 0;

    for (int i = 0; i < (int)rawLines.size(); i++)
    {
        ParsedLine p = parseLine(rawLines[i], i + 1);

        if (!p.label.empty())
        {
            if (!isValidLabel(p.label))
            {
                errors.push_back("Line " + to_string(p.lineNumber) +
                                 ": Invalid label name '" + p.label + "'");
            }
            else if (symbolTable.count(p.label))
            {
                errors.push_back("Line " + to_string(p.lineNumber) +
                                 ": Duplicate label '" + p.label + "'");
            }
            else
            {
                if (p.mnemonic == "SET")
                {
                    int32_t val;
                    if (parseNumber(p.operand, val))
                    {
                        symbolTable[p.label] = val;
                    }
                    else
                    {
                        errors.push_back("Line " + to_string(p.lineNumber) +
                                         ": Invalid number '" + p.operand + "'");
                    }
                }
                else
                {
                    symbolTable[p.label] = pc;
                }
            }
        }

        if (!p.mnemonic.empty() && p.mnemonic != "SET")
        {
            if (p.mnemonic != "data" && opcodeTable.find(p.mnemonic) == opcodeTable.end())
            {
                errors.push_back("Line " + to_string(p.lineNumber) +
                                 ": Invalid mnemonic '" + p.mnemonic + "'");
            }
            else
            {
                pc++;
            }
        }

        parsedLines.push_back(p);
    }

    return errors.empty();
}

//  4. secondPassGenerateCode()  — Pass 2

bool secondPassGenerateCode()
{
    int pc = 0;

    for (auto &p : parsedLines)
    {
        if (p.mnemonic.empty() || p.mnemonic == "SET")
            continue;

        lineAddressMap.push_back(pc);

        if (p.mnemonic == "data")
        {
            int32_t val = 0;
            if (!p.operand.empty())
            {
                if (!parseNumber(p.operand, val))
                {
                    if (symbolTable.count(p.operand))
                    {
                        val = symbolTable[p.operand];
                    }
                    else
                    {
                        errors.push_back("Line " + to_string(p.lineNumber) +
                                         ": Undefined label or invalid number '" +
                                         p.operand + "'");
                    }
                }
            }
            machineCode.push_back(static_cast<uint32_t>(val));
            pc++;
            continue;
        }

        auto it = opcodeTable.find(p.mnemonic);
        if (it == opcodeTable.end())
        {
            machineCode.push_back(0);
            pc++;
            continue;
        }

        int opcode = it->second.code;
        OperandType opType = it->second.type;
        int32_t operandVal = 0;

        if (opType == NONE && !p.operand.empty())
        {
            errors.push_back("Line " + to_string(p.lineNumber) +
                             ": Unexpected operand for '" + p.mnemonic + "'");
        }

        if (opType != NONE)
        {
            if (p.operand.empty())
            {
                errors.push_back("Line " + to_string(p.lineNumber) +
                                 ": Missing operand for '" + p.mnemonic + "'");
            }
            else if (p.operand.find(',') != string::npos)
            {
                errors.push_back("Line " + to_string(p.lineNumber) +
                                 ": Malformed operand '" + p.operand + "'");
            }
            else if (!parseNumber(p.operand, operandVal))
            {
                if (symbolTable.count(p.operand))
                {
                    operandVal = symbolTable[p.operand];
                    if (opType == OFFSET)
                    {
                        operandVal = operandVal - (pc + 1);
                    }
                }
                else if (isValidLabel(p.operand))
                {
                    errors.push_back("Line " + to_string(p.lineNumber) +
                                     ": Undefined label '" + p.operand + "'");
                }
                else
                {
                    errors.push_back("Line " + to_string(p.lineNumber) +
                                     ": Invalid number '" + p.operand + "'");
                }
            }
        }

        uint32_t word = ((uint32_t)(opcode & 0xFF) << 24) |
                        ((uint32_t)(operandVal) & 0x00FFFFFF);
        machineCode.push_back(word);
        pc++;
    }

    return errors.empty();
}

//  5. writeObjectFile()

bool writeObjectFile(const string &filename)
{
    ofstream fout(filename, ios::binary);
    if (!fout.is_open())
    {
        logErr("Error: cannot create object file '" + filename + "'\n");
        return false;
    }
    for (uint32_t word : machineCode)
    {
        fout.write(reinterpret_cast<const char *>(&word), sizeof(uint32_t));
    }
    fout.close();
    return true;
}

//  6. writeListingFile()

bool writeListingFile(const string &filename)
{
    ofstream fout(filename);
    if (!fout.is_open())
    {
        logErr("Error: cannot create listing file '" + filename + "'\n");
        return false;
    }

    int codeIdx = 0;
    for (auto &p : parsedLines)
    {
        if (p.mnemonic.empty() || p.mnemonic == "SET")
        {
            fout << "                    " << p.sourceLine << endl;
        }
        else
        {
            uint32_t word = machineCode[codeIdx];
            int addr = lineAddressMap[codeIdx];
            fout << hex << setw(8) << setfill('0') << addr << "  "
                 << hex << setw(8) << setfill('0') << word << "  "
                 << p.sourceLine << endl;
            codeIdx++;
        }
    }

    fout.close();
    return true;
}

int main(int argc, char *argv[])
{
    if (argc < 2)
    {
        cerr << "Usage: asm <source.asm>" << endl;
        return 1;
    }

    string srcFile = argv[1];

    // Derive base name (strip extension)
    string baseName = srcFile;
    size_t dotPos = baseName.rfind('.');
    if (dotPos != string::npos)
        baseName = baseName.substr(0, dotPos);

    // Open log file early so ALL output (errors included) is captured
    string logFilename = baseName + ".log";
    logFile.open(logFilename);
    if (!logFile.is_open())
    {
        cerr << "Warning: cannot create log file '" << logFilename << "'" << endl;
    }

    // Log header
    logOut("Assembler log for: " + srcFile + "\n");
    logOut("\n");

    if (!readFile(srcFile))
    {
        logFile.close();
        return 1;
    }

    buildSymbolTable();
    secondPassGenerateCode();

    if (!errors.empty())
    {
        for (auto &e : errors)
            logErr("ERROR: " + e + "\n");

        ostringstream oss;
        oss << errors.size() << " error(s) found. No output files produced.\n";
        logErr(oss.str());

        logFile.close();
        return 1;
    }

    string objFile = baseName + ".obj";
    string lstFile = baseName + ".lst";

    writeObjectFile(objFile);
    writeListingFile(lstFile);

    logOut("Assembly successful.\n");
    logOut("Object file : " + objFile + "\n");
    logOut("Listing file: " + lstFile + "\n");
    logOut("Log file    : " + logFilename + "\n");

    logFile.close();
    return 0;
}