assembler.cpp

// Two-pass SIC/XE Assembler - Hash SYMTAB, Linear OPTAB, H/T/M/E records
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
using namespace std;

// Functions
string toUpper(string s) {
    for (int i = 0; i < s.length(); i++) 
        s[i] = toupper(s[i]);
    return s;
}

string toHex(unsigned long val, int w) {
    char buf[20]; sprintf(buf, "%0*lX", w, val); 
        return string(buf);
}

bool isNumber(string s) {
    if (s.empty()) return false;
    for (int i = 0; i < s.length(); i++) 
        if (!isdigit(s[i])) 
            return false;
    return true;
}

int getRegNum(string r) {
    if (r=="A") 
        return 0; 
    if (r=="X") 
        return 1; 
    if (r=="L") 
        return 2;
    if (r=="B") 
        return 3; 
    if (r=="S") 
        return 4; 
    if (r=="T") 
        return 5;
    if (r=="F") 
        return 6; 
    return 0;
}

int findChar(string s, char c) {
    for (int i = 0; i < s.length(); i++) 
        if (s[i] == c) 
            return i;
    return -1;
}
int findStr(string s, string sub) {
    for (int i = 0; i <= (int)s.length()-(int)sub.length(); i++) {
        bool m = true;
        for (int j = 0; j < sub.length(); j++) 
            if (s[i+j]!=sub[j]){ 
                m=false; break;
            }
        if (m) return i;
    }
    return -1;
}
bool hasNoOperand(string op) {
    return op=="RSUB"||op=="FIX"||op=="FLOAT"||op=="NORM"||op=="HIO"||op=="SIO"||op=="TIO";
}

// parse BYTE operand: find the content between quotes
// returns {type char, content string, valid flag}
int getByteLen(string op) {
    if (op.length()<4 || op[1]!='\'') 
        return 0;

    int eq = op.length()-1;

    while (eq>1 && op[eq]!='\'') eq--;
        if (eq<=1) 
            return 0;
    int n = eq-2;

    return toupper(op[0])=='C' ? n : (n+1)/2;
}
string getbyteobj(string op) {
    if (op.length()<4 || op[1]!='\'') 
        return "";
    int eq = op.length()-1;
    while (eq>1 && op[eq]!='\'') eq--;
        if (eq<=1) 
            return "";

    string val = op.substr(2, eq-2), result = "";
    if (toupper(op[0])=='C') {
        for (int i = 0; i < val.length(); i++) result += toHex((unsigned char)val[i], 2);
        } 
        else {
        result = toUpper(val);
        if (result.length()%2 == 1) result = "0"+result;
    }
    return result;
}

//SYMTAB
#define TABLE_SIZE 101
struct Symbol { string name; int address; Symbol *next; };
Symbol *symtab[TABLE_SIZE];

unsigned int hashFunc(string key) {
    unsigned long h = 0;
    for (int i = 0; i < key.length(); i++) h = h*31 + key[i];
        return h % TABLE_SIZE;
}
void initSymtab() { for (int i = 0; i < TABLE_SIZE; i++) symtab[i] = NULL; }

bool symInsert(string name, int addr) {
    unsigned int idx = hashFunc(name);
    for (Symbol *c = symtab[idx]; c; c = c->next)
        if (c->name == name) 
            return false;
    Symbol *s = new Symbol; s->name = name; s->address = addr;
    s->next = symtab[idx]; symtab[idx] = s;
    return true;
}
int symLookup(string name) {
    unsigned int idx = hashFunc(name);
    for (Symbol *c = symtab[idx]; c; c = c->next)
        if (c->name == name) 
            return c->address;
    return -1;
}
void printSymtab() {
    printf("\n--- SYMBOL TABLE ---\n%-12s %-10s %s\n", "Symbol", "Address", "Hash Slot");
    cout << "--------------------------------" << endl;
    for (int i = 0; i < TABLE_SIZE; i++)
        for (Symbol *c = symtab[i]; c; c = c->next)
            printf("%-12s %s    %d\n", c->name.c_str(), toHex(c->address,6).c_str(), i);
    cout << "--------------------------------\n" << endl;
}

//opcoe table
struct Opcode { string mnemonic; int code; int format; };
Opcode opcodeTable[] = {
    {"FIX",0xC4,1},{"FLOAT",0xC0,1},{"HIO",0xF4,1},{"NORM",0xC8,1},{"SIO",0xF0,1},{"TIO",0xF8,1},
    {"ADDR",0x90,2},{"CLEAR",0xB4,2},{"COMPR",0xA0,2},{"DIVR",0x9C,2},{"MULR",0x98,2},{"RMO",0xAC,2},
    {"SHIFTL",0xA4,2},{"SHIFTR",0xA8,2},{"SUBR",0x94,2},{"SVC",0xB0,2},{"TIXR",0xB8,2},
    {"ADD",0x18,3},{"ADDF",0x58,3},{"AND",0x40,3},{"COMP",0x28,3},{"COMPF",0x88,3},{"DIV",0x24,3},
    {"DIVF",0x64,3},{"J",0x3C,3},{"JEQ",0x30,3},{"JGT",0x34,3},{"JLT",0x38,3},{"JSUB",0x48,3},
    {"LDA",0x00,3},{"LDB",0x68,3},{"LDCH",0x50,3},{"LDF",0x70,3},{"LDL",0x08,3},{"LDS",0x6C,3},
    {"LDT",0x74,3},{"LDX",0x04,3},{"LPS",0xD0,3},{"MUL",0x20,3},{"MULF",0x60,3},{"OR",0x44,3},
    {"RD",0xD8,3},{"RSUB",0x4C,3},{"SSK",0xEC,3},{"STA",0x0C,3},{"STB",0x78,3},{"STCH",0x54,3},
    {"STF",0x80,3},{"STI",0xD4,3},{"STL",0x14,3},{"STS",0x7C,3},{"STSW",0xE8,3},{"STT",0x84,3},
    {"STX",0x10,3},{"SUB",0x1C,3},{"SUBF",0x5C,3},{"TD",0xE0,3},{"TIX",0x2C,3},{"WD",0xDC,3},
};
int NUM_OPCODES = sizeof(opcodeTable)/sizeof(opcodeTable[0]);

int findOpcode(string m) {
    for (int i = 0; i < NUM_OPCODES; i++) if (opcodeTable[i].mnemonic==m) 
        return i;
    return -1;
}

struct Line {
    string label, opcode, operand, objCode;
    bool isExtended, isComment;
    int address, length;
};
Line newLine() { return {"","","","",false,false,0,0}; }

Line parseLine(string raw) {
    Line ln = newLine();
    if (raw.empty() || raw[0]=='.') { 
        ln.isComment = true; return ln; 
    }

    vector<string> tokens;
    istringstream stream(raw); string word;

    while (stream >> word) { 
        if (word[0]=='.') 
            break; 
        tokens.push_back(word); 
    }

    if (tokens.empty()) { 
        ln.isComment = true; 
        return ln; 
    }

    int pos = 0;
    if (raw[0]!=' ' && raw[0]!='\t') { 
        ln.label = toUpper(tokens[pos++]); 
    }

    if (pos < tokens.size()) {
        string op = toUpper(tokens[pos++]);
        if (op[0]=='+') { ln.isExtended = true; op = op.substr(1); }
        ln.opcode = op;
    }

    if (!hasNoOperand(ln.opcode) && pos < tokens.size()) {
        ln.operand = tokens[pos];
        if (ln.opcode != "BYTE") ln.operand = toUpper(ln.operand);
    }
    return ln;
}

void output(ofstream &f, string t){ 
    cout << t << endl; 
    f << t << endl; 
}

//main
int main(int argc, char *argv[]) {
    string filename = (argc > 1) ? argv[1] : "input.asm";
    initSymtab();
    vector<Line> program;
    string progName = "";
    int startAddr = 0, locctr = 0, baseReg = -1;

    cout << "----- PASS 1 -----" << endl << endl;
    ifstream inputFile(filename);
    if (!inputFile.is_open()) { cerr << "Error: cannot open " << filename << endl; return 1; }

    string rawLine;
    while (getline(inputFile, rawLine)) {
        Line ln = parseLine(rawLine);
        if (ln.isComment) { 
            program.push_back(ln); 
            continue; 
        }

        if (ln.opcode == "START") {
            progName = ln.label;
            if (!ln.operand.empty()) locctr = stoi(ln.operand, NULL, 16);
                startAddr = locctr; ln.address = locctr;
            if (!ln.label.empty()) symInsert(ln.label, locctr);
                program.push_back(ln); continue;
        }
        if (ln.opcode == "END") { 
            ln.address = locctr; program.push_back(ln); 
            break; 
        }

        ln.address = locctr;
        if (!ln.label.empty() && !symInsert(ln.label, locctr))
            cerr << "Error: duplicate symbol " << ln.label << endl;

        // advance location counter
        if (ln.opcode=="BASE" || ln.opcode=="NOBASE") 
            ln.length = 0;
        else if (ln.opcode=="WORD") { 
            ln.length = 3; locctr += 3; 
        }
        else if (ln.opcode=="RESW")  { 
            ln.length = 3*stoi(ln.operand); locctr += ln.length; 
        }
        else if (ln.opcode=="RESB")  { 
            ln.length = stoi(ln.operand); locctr += ln.length; 
        }
        else if (ln.opcode=="BYTE")  { 
            ln.length = getByteLen(ln.operand); locctr += ln.length; 
        }
        else {
            int idx = findOpcode(ln.opcode);
            if (idx != -1) { 
                ln.length = ln.isExtended ? 4 : opcodeTable[idx].format; 
                locctr += ln.length; 
            }
            else cerr << "Error: unknown opcode " << ln.opcode << endl;
        }
        program.push_back(ln);
    }
    inputFile.close();
    int progLen = locctr - startAddr;

    // print pass 1 listing
    printf("  Loc   Label     Op        Operand\n  ");
    cout << string(44,'-') << endl;
    for (int i = 0; i < program.size(); i++) {
        if (program[i].isComment) 
            continue;
        Line ln = program[i];
        string opStr = ln.isExtended ? "+"+ln.opcode : ln.opcode;
        printf("  %s  %-10s%-10s%s\n", toHex(ln.address,4).c_str(), ln.label.c_str(), opStr.c_str(), ln.operand.c_str());
    }
    printf("\n  Program size: %s (%d bytes)\n", toHex(progLen,6).c_str(), progLen);
    printSymtab();

    cout << "----- PASS 2 -----" << endl << endl;
    vector<int> modAddrs;

    for (int i = 0; i < program.size(); i++) {
        Line &ln = program[i];
        if (ln.isComment || ln.opcode=="START" || ln.opcode=="END") 
            continue;
        if (ln.opcode=="BASE")   { 
            baseReg = symLookup(toUpper(ln.operand)); 
            continue; 
        }
        if (ln.opcode=="NOBASE") { 
            baseReg = -1; 
            continue; 
        }
        if (ln.opcode=="RESW" || ln.opcode=="RESB") 
            continue;
        if (ln.opcode=="BYTE"){ 
            ln.objCode = getbyteobj(ln.operand); 
            continue; 
        }
        if (ln.opcode=="WORD"){ 
            ln.objCode = toHex(stoi(ln.operand), 6); 
            continue; 
        }

        int idx = findOpcode(ln.opcode);
        if (idx == -1) 
            continue;
        int opcode = opcodeTable[idx].code, format = opcodeTable[idx].format;

        if (format == 1) { 
            ln.objCode = toHex(opcode, 2); 
            continue; 
        }
        if (format == 2) {
            int r1=0, r2=0, comma = findChar(ln.operand, ',');
            if (comma!=-1) { 
                r1 = getRegNum(ln.operand.substr(0,comma)); 
                r2 = getRegNum(ln.operand.substr(comma+1)); 
            }
            else if (!ln.operand.empty()) 
                r1 = getRegNum(ln.operand);
            ln.objCode = toHex((opcode<<8)|(r1<<4)|r2, 4); 
            continue;
        }

        // FORMAT 3/4
        int n=1, ii=1, x=0, b=0, p=0, e = ln.isExtended ? 1 : 0, disp=0;
        string arg = ln.operand;

        if (!arg.empty() && arg[0]=='#') { 
            n=0; 
            ii=1; 
            arg = arg.substr(1); 
        }

        else if (!arg.empty() && arg[0]=='@') { 
            n=1; 
            ii=0; 
            arg = arg.substr(1); 
        }
        int xpos = findStr(arg, ",X");
        if (xpos != -1) { 
            x = 1; 
            arg = arg.substr(0, xpos); 
        }

        if (ln.opcode=="RSUB" || arg.empty()) disp = 0;
        else if (isNumber(arg)) disp = stoi(arg);
        else {
            int target = symLookup(arg);
            if (target == -1) 
                cerr << "Error: undefined symbol " << arg << endl;
            else if (ln.isExtended) { 
                disp = target; 
                modAddrs.push_back(ln.address+1); 
            }

            else {
                int pcDisp = target - (ln.address+3);
                if (pcDisp >= -2048 && pcDisp <= 2047) { 
                    p=1; 
                    disp = pcDisp & 0xFFF; 
                }
                else if (baseReg != -1) {
                    int bDisp = target - baseReg;
                    if (bDisp>=0 && bDisp<=4095) { 
                        b=1; 
                        disp = bDisp; 
                    }
                    else cerr << "Error: displacement out of range for " << arg << endl;
                } 
                else cerr << "Error: cannot compute displacement for " << arg << endl;
            }
        }

        unsigned int fb = (opcode & 0xFC) | (n<<1) | ii;
        unsigned int fl = (x<<3) | (b<<2) | (p<<1) | e;
        if (ln.isExtended) ln.objCode = toHex((fb<<24)|(fl<<20)|((unsigned)disp & 0xFFFFF), 8);
        else ln.objCode = toHex((fb<<16)|(fl<<12)|((unsigned)disp & 0xFFF), 6);
    }

    // print pass 2 listing
    printf("  Loc   Label     Op        Operand         Object Code\n  ");
    cout << string(56,'-') << endl;
    for (int i = 0; i < program.size(); i++) {
        if (program[i].isComment) 
            continue;
        Line ln = program[i];
        string opStr = ln.isExtended ? "+"+ln.opcode : ln.opcode;
        printf("  %s  %-10s%-10s%-16s%s\n", toHex(ln.address,4).c_str(), ln.label.c_str(), opStr.c_str(), ln.operand.c_str(), ln.objCode.c_str());
    }

    cout << "\n----- OBJECT PROGRAM -----\n" << endl;
    ofstream outFile("output.obj");
    string pn = progName;
    while (pn.length() < 6) pn += ' ';
    output(outFile, "H^"+pn+"^"+toHex(startAddr,6)+"^"+toHex(progLen,6));

    // text records
    string textCode = ""; int textStart = 0, textLen = 0; bool newRec = true;
    for (int i = 0; i < program.size(); i++) {
        Line ln = program[i];
        if (ln.isComment || ln.opcode=="START" || ln.opcode=="END" || ln.opcode=="BASE" || ln.opcode=="NOBASE") 
            continue;
        if (ln.opcode=="RESW" || ln.opcode=="RESB") {
            if (!textCode.empty()) {
                output(outFile, "T^"+toHex(textStart,6)+"^"+toHex(textLen,2)+"^"+textCode);
                textCode = ""; textLen = 0;
            }
            newRec = true; continue;
        }
        if (ln.objCode.empty()) 
            continue;
        int nb = ln.objCode.length()/2;
        if (newRec) { 
            textStart = ln.address; 
            textLen = 0; 
            textCode = ""; 
            newRec = false; }

        if (textLen+nb > 30) {
            output(outFile, "T^"+toHex(textStart,6)+"^"+toHex(textLen,2)+"^"+textCode);
            textStart = ln.address; textLen = 0; textCode = "";
        }

        textCode += ln.objCode; textLen += nb;
    }
    if (!textCode.empty())
        output(outFile, "T^"+toHex(textStart,6)+"^"+toHex(textLen,2)+"^"+textCode);

    for (int i = 0; i < modAddrs.size(); i++)
        output(outFile, "M^"+toHex(modAddrs[i],6)+"^05");

    int execAddr = startAddr;
    for (int i = 0; i < program.size(); i++)
        if (program[i].opcode=="END" && !program[i].operand.empty()) {
            int a = symLookup(toUpper(program[i].operand));
            if (a != -1) execAddr = a; break;
        }
    output(outFile, "E^"+toHex(execAddr,6));
    outFile.close();
    cout << "\nObject program written to output.obj" << endl;
    return 0;
}