/*
 * Copyright 2021 cpu-dev
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <stdint.h>
#include <ctype.h>

//#define DEBUG

#define MODE_BIN 0
#define MODE_VERILOG 1

struct label {
    char name;
    uint8_t addr;
    struct label *next;
};

struct label *head;

typedef enum {
    MOV = 0,
    ADD,
    AND = 3,
    OR,
    NOT,
    SLL,
    SRL,
    SRA,
    CMP,
    JE,
    JMP,
    LDIH,
    LDIL,
    LD,
    ST,
    IRET,
    LDI
} inst_t;

typedef enum {
    R0,
    R1,
    R2,
    R3
} reg_t;

int8_t
opcode(char *mnemonic)
{
    if(!strncmp(mnemonic, "mov", 3))
        return MOV;
    if(!strncmp(mnemonic, "add", 3))
        return ADD;
    if(!strncmp(mnemonic, "and", 3))
        return AND;
    if(!strncmp(mnemonic, "or", 2))
        return OR;
    if(!strncmp(mnemonic, "not", 3))
        return NOT;
    if(!strncmp(mnemonic, "sll", 3))
        return SLL;
    if(!strncmp(mnemonic, "srl", 3))
        return SRL;
    if(!strncmp(mnemonic, "sra", 3))
        return SRA;
    if(!strncmp(mnemonic, "cmp", 3))
        return CMP;
    if(!strncmp(mnemonic, "je", 2))
        return JE;
    if(!strncmp(mnemonic, "jmp", 3))
        return JMP;
    if(!strncmp(mnemonic, "ldih", 4))
        return LDIH;
    if(!strncmp(mnemonic, "ldil", 4))
        return LDIL;
    if(!strncmp(mnemonic, "ldi", 3))
        return LDI;
    if(!strncmp(mnemonic, "ld", 2))
        return LD;
    if(!strncmp(mnemonic, "st", 2))
        return ST;
    if(!strncmp(mnemonic, "iret", 4))
        return IRET;
    return -1;
}

void
new_label(char name, int addr)
{
    struct label *p;
    p = head;

    while(p->next != NULL)
        p = p->next;

    p->next = (struct label *)malloc(sizeof(struct label));
    p->next->name = name;
    p->next->addr = addr;
    p->next->next = NULL;
}

uint8_t
search_label(char name)
{
    struct label *p;
    p = head->next;

    while(p != NULL) {
        if(p->name == name) {
            return p->addr;
        }
        p = p->next;
    }
    printf("unknown label referenced: %c\n", name);
    exit(-1);
}

uint8_t
rs(char *p)
{
#ifdef DEBUG
    printf("arguments(rs): %s\n", p);
#endif
    return strtol(++p, &p, 16);
}

uint8_t
imm(char *p)
{
#ifdef DEBUG
    printf("arguments(imm): %s\n", p);
#endif
    return strtol(p, &p, 16);
}

uint8_t
ex_imm(char *p)
{
#ifdef DEBUG
    printf("arguments(ex_imm): %s\n", p);
#endif
    if(isalpha(*p))
        return search_label(*p);
    return strtol(p, &p, 16);
}

uint8_t
rdrs(char *p)
{
#ifdef DEBUG
    printf("arguments(rd/rs): %s\n", p);
#endif
    int rd, rs;
    rd = strtol(++p, &p, 16);
    while(isspace(*p) || *p == ',')
        ++p;
    rs = strtol(++p, &p, 16);
    return (rd << 2) + rs;
}

int
main(int argc, char *argv[])
{
    char mode = MODE_BIN;
    char buf[256];
    char *p;
    int8_t inst, result;
    int i;
    FILE *in, *out;

    if((in = fopen(argv[1], "r")) == NULL) {
        puts("file open error!");
        return -1;
    }

    if(argc > 2) {
        if(strncmp(argv[2], "verilog", 7) == 0)
            mode = MODE_VERILOG;
    }

    if(mode == MODE_BIN) {
        if((out = fopen("out.bin", "wb")) == NULL) {
            puts("file open error!");
            return -1;
        }
    }
    else {
        if((out = fopen("out.txt", "w")) == NULL) {
            puts("file open error!");
            return -1;
        }
    }

    head = (struct label *)malloc(sizeof(struct label));
    head->name = 0;
    head->addr = 0;
    head->next = NULL;

    i = 0;
    while(fgets(buf, 256, in) != NULL) {
        if(*buf == '\n') continue;
        p = buf;
        while(isspace(*p)) ++p;
        if(!strncmp(p, "//", 2)) continue;
        inst = opcode(p);
        while(isalpha(*p)) ++p;
        if(*p == ':') {
#ifdef DEBUG
            printf("new label in L%d: %c\n", i, *(p-1));
#endif
            new_label(*(p-1), i);
        }
        else {
            if(inst == LDI) ++i;
            ++i;
            continue;
        }
    }

    rewind(in);
    i = 0;
    while(fgets(buf, 256, in) != NULL) {
        if(*buf == '\n') continue;
        p = buf;
        while(isspace(*p)) ++p;
        if(!strncmp(p, "//", 2)) continue;
        inst = opcode(p);
#ifdef DEBUG
        printf("instruction number: %d\n", inst);
#endif
        while(isalpha(*p)) ++p;
        if(*p == ':') continue;
        while(isspace(*p)) ++p;
        switch(inst) {
            case -1:
                printf("invalid instruction!!!\n");
                return -1;
            case JE:
            case JMP:
                result = (inst << 4) | rs(p);
                mode == MODE_BIN 
                    ? fwrite(&result, 1, 1, out) 
                    : fprintf(out, "mem[%d] = 0x%02x;\n", i++, result & 0x000000ff);
                break;
            case LDIH:
            case LDIL:
                result = (inst << 4) | imm(p);
                mode == MODE_BIN 
                    ? fwrite(&result, 1, 1, out) 
                    : fprintf(out, "mem[%d] = 0x%02x;\n", i++, result & 0x000000ff);
                break;
            case IRET:
                result = 0xb4;
                mode == MODE_BIN
                    ? fwrite(&result, 1, 1, out)
                    : fprintf(out, "mem[%d] = 0x%02x;\n", i++, result & 0x000000ff);
                break;
            case LDI:
                result = (LDIH << 4) | (ex_imm(p) >> 4);
                mode == MODE_BIN
                    ? fwrite(&result, 1, 1, out)
                    : fprintf(out, "mem[%d] = 0x%02x;\n", i++, result & 0x000000ff);
                result = (LDIL << 4) | (ex_imm(p) & 0x0f);
                mode == MODE_BIN
                    ? fwrite(&result, 1, 1, out)
                    : fprintf(out, "mem[%d] = 0x%02x;\n", i++, result & 0x000000ff);
                break;
            default:
                result = (inst << 4) | rdrs(p);
                mode == MODE_BIN 
                    ? fwrite(&result, 1, 1, out) 
                    : fprintf(out, "mem[%d] = 0x%02x;\n", i++, result & 0x000000ff);
                break;
        }
    }
    return 0;
}