/* Original implementation of the Sapphire compiler, in one file.
WARNING: THIS IS LEGACY. This was the original thing I wrote to make a simple compiler, but it was clear it wasn't gonna cut it.
The code was difficult to read with everything scattered across the file, and I had to throw random forward declarations everywhere.
Also, it was limited, since my intention was to make it output assembly code manually. As you can see, the definitions are for x86-64 Linux assembly.
Now I'm using LLVM, which will make it a lot easier to do stuff.
Eventually, I found that splitting the code into multiple files, using classes and such, would be much better and easier.
So I began a rewrite of this compiler in the src/ directory, which I found was way easier to write, and was more productive and more.
The src/ compiler has come a long way since then, and this code is just kept around for me to be able to see it in the future and facepalm at it.
I'm aware of Git, I'm using it, but I didn't think keeping this would make any harm. it's very clearly separated from the rest of the code. */
#include <iostream>
#include <string>
#include <stdlib.h>
#include <stdio.h>
#include <vector>
#include <regex>
#include <array>
#include <sstream>
#include <fstream>

#define IMPORT_MAX_DEEP 100

#define STRLEN "strlen: ; -- length of null-terminated string in rdi --\n    xor rax, rax\n    mov rcx, -1\n    cld\n    repne scasb\n    mov rax, rcx\n    add rax, 2\n    neg rax\n    ret\n"
#define PRINT "print: ; -- print null-terminated string in rdi --\n    mov rsi, rdi\n    call strlen\n    mov rdx, rax\n    mov rdi, 1\n    mov rax, 1\n    syscall\n    ret\n"

#define __FASM

#ifdef __FASM
#define ASM_HEADER "format ELF64 executable 3\n"
#define ASM_TEXT_SECTION "segment readable executable\n"
#define ASM_DATA_SECTION "segment readable writable\n"
#define ASM_BSS_SECTION ""
#define ASM_ENTRY "entry start\n"
#define ASM_ENTRY_DECL "start:\n"
#elif defined(__NASM)
#define ASM_HEADER "BITS 64\n"
#define ASM_TEXT_SECTION "section .text\n"
#define ASM_DATA_SECTION "section .data\n"
#define ASM_BSS_SECTION "section .bss\n"
#define ASM_ENTRY "global _start\n"
#define ASM_ENTRY_DECL "_start:\n"
#else
#endif

std::regex letter("[a-zA-Z_]");
std::regex identifier("[a-zA-Z0-9_]");
std::regex number("[0-9]");
std::regex whitespace("[\t \n]");
int g_importCount = 0;

std::string g_current_line;

std::vector<std::string> imported_files;

enum TokenType
{
    TT_Identifier,
    TT_Number,
    TT_Float,
    TT_Keyword,
    TT_String,
    TT_Plus,
    TT_Minus,
    TT_Mul,
    TT_Div,
    TT_At,
    TT_Equal,
    TT_LessThan,
    TT_GreaterThan,
    TT_LParen,
    TT_RParen,
    TT_LBracket,
    TT_RBracket,
    TT_Semicolon,
    TT_LoadedString,
    TT_EOF,
    TT_Null
};

static std::string token_strings[] = {
    "TT_IDENTIFIER",
    "TT_NUMBER",
    "TT_FLOAT",
    "TT_KEYWORD",
    "TT_STRING",
    "TT_PLUS",
    "TT_MINUS",
    "TT_MUL",
    "TT_DIV",
    "TT_AT",
    "TT_EQUAL",
    "TT_LESSTHAN",
    "TT_GREATERTHAN",
    "TT_LPAREN",
    "TT_RPAREN",
    "TT_LBRACKET",
    "TT_RBRACKET",
    "TT_SEMICOLON",
    "TT_LOADEDSTRING",
    "TT_EOF",
    "TT_NULL"
};

struct Token
{
    TokenType tk_type;
    int int_value;
    std::string string_value;
    float float_value;
    int line;
    int column;
    std::string fname;
    std::string line_ctx;
    Token(const TokenType& type, const int& lineno, const int& colno, const std::string& name)
        : tk_type(type), line(lineno), column(colno), fname(name)
    {
        line_ctx = g_current_line;
    }

    Token(const TokenType& type, const int& val, const int& lineno, const int& colno, const std::string& name)
        : tk_type(type), int_value(val), line(lineno), column(colno), fname(name)
    {
        line_ctx = g_current_line;
    }

    Token(const TokenType& type, const std::string& val, const int& lineno, const int& colno, const std::string& name)
        : tk_type(type), string_value(val), line(lineno), column(colno), fname(name)
    {
        line_ctx = g_current_line;
    }

    Token(const TokenType& type, const float& val, const int& lineno, const int& colno, const std::string& name)
        : tk_type(type), float_value(val), line(lineno), column(colno), fname(name)
    {
        line_ctx = g_current_line;
    }

    std::string to_string() const
    {
        char linestr[32];
        sprintf(linestr,"%d",line);
        char colstr[32];
        sprintf(colstr,"%d",column);
        if(tk_type == TT_Number)
        {
            char num[32];
            sprintf(num,"%d",int_value);
            return "INT:" + std::string(num) + " (" + fname + ":" + std::string(linestr) + ":" + std::string(colstr) + ")";
        } else if (tk_type == TT_Float)
        {
            char num[64];
            sprintf(num,"%f",float_value);
            return "FLOAT:" + std::string(num) + " (" + fname + ":" + std::string(linestr) + ":" + std::string(colstr) + ")";
        }
        else if (tk_type == TT_Identifier){
            return "ID:" + string_value + " (" + fname + ":" + std::string(linestr) + ":" + std::string(colstr) + ")";
        } else if (tk_type == TT_Keyword){
            return "KEYWORD:" + string_value + " (" + fname + ":" + std::string(linestr) + ":" + std::string(colstr) + ")";
        } else if (tk_type == TT_String)
        {
            return "STRING:" + std::string("\'") + string_value + std::string("\'") + " (" + fname + ":" + std::string(linestr) + ":" + std::string(colstr) + ")";
        }
        std::string details = std::string(" (") + fname + ":" + std::string(linestr) + ":" + std::string(colstr) + ")";
        switch(tk_type)
        {
            case TT_EOF:
                return "EOF" + details;
            case TT_Plus:
                return "PLUS" + details;
            case TT_Minus:
                return "MINUS" + details;
            case TT_Mul:
                return "MUL" + details;
            case TT_Div:
                return "DIV" + details;
            case TT_At:
                return "AT" + details;
            case TT_Equal:
                return "EQUAL" + details;
            case TT_LessThan:
                return "LESSTHAN" + details;
            case TT_GreaterThan:
                return "GREATERTHAN" + details;
            case TT_LParen:
                return "LPAREN" + details;
            case TT_RParen:
                return "RPAREN" + details;
            case TT_LBracket:
                return "LBRACKET" + details;
            case TT_RBracket:
                return "RBRACKET" + details;
            case TT_Semicolon:
                return "SEMICOLON" + details;
            case TT_LoadedString:
                return "LDSTRING" + details;
        }
        return "";
    }
};

std::string tokentype_as_string(const TokenType& type)
{
    return token_strings[type];
}

struct Sentence
{
    std::string type_name;
};

struct Function : public Sentence
{
    std::string type_name = "function";
    std::vector<Token> fun_tokens;
    Function(std::vector<Token> tokens) : fun_tokens(tokens){}
};

struct DeclVar : public Sentence
{
    std::string type_name = "decl";
    std::vector<Token> vtokens;
    DeclVar(std::vector<Token> tokens) : vtokens(tokens){}
};

struct Variable
{
    int size;
    std::string identifier;

    Variable(int _size, std::string _identifier) : size(_size), identifier(_identifier){}
};

struct StringLiteral
{
    std::string data;
    std::string identifier;

    StringLiteral(std::string _data, std::string _identifier) : data(_data), identifier(_identifier){}
};

std::array<std::string, 3> keywords{"out", "var","import"};

std::vector<Variable> registered_vars;
std::vector<StringLiteral> registered_strings;

std::string make_asm_string(StringLiteral str);
std::vector<Token> lex_tokens(const std::string&, const std::string&);
std::vector<Token> evaluate_imports(const std::string& text, const std::vector<Token>& tokens);
std::string read_file(const std::string&);
void compiler_error(const std::string& text, const int& line, const int& column, const std::string& fname, const std::string& details);
void compiler_warning(const std::string& text, const int& line, const int& column, const std::string& fname, const std::string& details);
std::vector<Sentence> parse_tokens(const std::vector<Token>& tokens);

int main(int argc, char** argv)
{
    std::string fname;
    if(argc < 2)
    {
        fname = "test.sp";
    }
    else fname = (const char*)argv[1];
    std::string command = read_file(fname);
    std::vector<Token> main_tokens = lex_tokens(command,fname);
    imported_files.push_back(fname.substr(0,fname.find_last_of('.')));
    main_tokens = evaluate_imports(command,main_tokens);
    parse_tokens(main_tokens);
    std::string assembly;
    assembly += ASM_HEADER;
    assembly += "; Assembly generated by the Sapphire compiler.\n";
    assembly += ASM_TEXT_SECTION;
    assembly += ASM_ENTRY;
    assembly += STRLEN;
    assembly += PRINT;
    assembly += ASM_ENTRY_DECL;
    assembly += "; -- exit with code 0 --\n";
    assembly += "    mov rax, 60\n";
    assembly += "    xor rdi, rdi\n";
    assembly += "    syscall\n";
    if(registered_strings.size() != 0)
    {
        assembly += "\n";
        assembly += ASM_DATA_SECTION;
        for(auto asm_string : registered_strings)
        {
            assembly += make_asm_string(asm_string);
        }
    }
    std::string outfile_basename = fname.substr(0,fname.find_last_of('.'));
    std::ofstream outfile(outfile_basename + ".asm");
    outfile << assembly;
    outfile.close();
    #ifdef __NASM
    system(std::string("nasm -f elf64 " + outfile_basename + ".asm -o" + outfile_basename + ".o").c_str());
    system(std::string("ld " + outfile_basename + ".o -o" + outfile_basename).c_str());
    #else
    system(std::string("fasm " + outfile_basename + ".asm").c_str());
    system((std::string("chmod +x ") + outfile_basename).c_str());
    #endif
    std::cout << fname + " > " + std::string(outfile_basename) + "\n";
}

Token construct_identifier(const std::string&, int& , int&, int&, const std::string&);
Token construct_number(const std::string&, int&, int&, int&, const std::string&);
Token construct_string(const std::string&, int&, int&, int&, const std::string&);


std::string read_file(const std::string& fname)
{
    std::ifstream main_file;
    main_file.open(fname);
    if(!main_file.is_open()) return "";
    std::vector<char> file_chars;
    char fchar;
    while ( main_file ) {
        fchar = main_file.get();
        if(fchar != -1 ) file_chars.push_back(fchar);
    }
    main_file.close();
    return std::string(file_chars.begin(),file_chars.end());
}

std::string recalculate_current_line(const std::string& text, int index)
{
    std::string final_str;
    ++index;
    while(index != text.size() && text[index] != '\n')
    {
        final_str += text[index];
        ++index;
    }
    return final_str;
}

std::string rewind_current_line(const std::string& text, int index)
{
    --index;
    while(text[index] != '\n')
    {
        --index;
        if(index == 0)
        {
            return recalculate_current_line(text,-1);
        }
    }
    return recalculate_current_line(text,index);
}

std::vector<Token> lex_tokens(const std::string& text, const std::string& fname)
{
    int line = 1;
    int column = 0;
    int index = -1;
    std::vector<Token> result;
    bool comment = false;
    g_current_line = recalculate_current_line(text,-1);

    while(index < (int)text.size())
    {
        ++index;
        ++column;

        if(text[index] == '\n')
        {
            ++line;
            column = 0;
            g_current_line = recalculate_current_line(text,index);
            comment = false;
        }
        if(comment) continue;
        char cstyle_char[2]{text[index],'\0'};
        const char* character = (const char*)cstyle_char;
        if(std::regex_match(character,whitespace))
        {
            continue;
        }
        else if(std::regex_match(character,letter))
        {
            result.push_back(construct_identifier(text,index,line,column,fname));
        }
        else if(std::regex_match(character,number))
        {
            result.push_back(construct_number(text,index,line,column,fname));
        } else if (text[index] == '\'')
        {
            result.push_back(construct_string(text,index,line,column,fname));
        } else if(index == text.size())
        {
            result.push_back(Token(TT_EOF,line,column,fname));
        } else switch(text[index])
        {
            case '+':
                result.push_back(Token(TT_Plus,line,column,fname));
                break;
            case '-':
                result.push_back(Token(TT_Minus,line,column,fname));
                break;
            case '*':
                result.push_back(Token(TT_Mul,line,column,fname));
                break;
            case '/':
                if(index != text.size())
                {
                    if(text[index+1] == '/')
                    {
                        comment = true;
                        break;
                    }
                }
                result.push_back(Token(TT_Div,line,column,fname));
                break;
            case '@':
                result.push_back(Token(TT_At,line,column,fname));
                break;
            case '=':
                result.push_back(Token(TT_Equal,line,column,fname));
                break;
            case '<':
                result.push_back(Token(TT_LessThan,line,column,fname));
                break;
            case '>':
                result.push_back(Token(TT_GreaterThan,line,column,fname));
                break;
            case '(':
                result.push_back(Token(TT_LParen,line,column,fname));
                break;
            case ')':
                result.push_back(Token(TT_RParen,line,column,fname));
                break;
            case '{':
                result.push_back(Token(TT_LBracket,line,column,fname));
                break;
            case '}':
                result.push_back(Token(TT_RBracket,line,column,fname));
                break;
            case ';':
                result.push_back(Token(TT_Semicolon,line,column,fname));
                break;
            default:
                compiler_error(g_current_line,line,column,fname,"unknown character");
                break;
        }
    }

    return result;
}

std::string get_line(const std::string&, int);

Token construct_identifier(const std::string& text, int& index, int& line, int& column, const std::string& fname)
{
    std::vector<char> id_symbols;
    int prev_column = column * 1;
    int prev_line = line * 1;

    char cstyle_char[2]{text[index],'\0'};
    const char* character = (const char*)cstyle_char;

    if(std::regex_match(character,identifier))
    {
        id_symbols.push_back(text[index]);
    } else 
    {
        --index;
        --column;
        if(text[index] == '\n')
        {
            --line;
            column = get_line(text,line-1).size() + 1;
            g_current_line = rewind_current_line(text,index);
        }
        std::string identifier(id_symbols.begin(), id_symbols.end());
        std::string* location = std::find(keywords.begin(),keywords.end(),identifier);
        if(location != keywords.end())
        {
            return Token(TT_Keyword,identifier,prev_line,prev_column,fname);
        }
        return Token(TT_Identifier,identifier,prev_line,prev_column,fname);
    }

    while(index < text.size() || index == -1)
    {
        ++index;
        ++column;
        if(text[index] == '\n')
        {
            ++line;
            g_current_line = recalculate_current_line(text,index);
            column = 0;
        }
        char cstyle_char[2]{text[index],'\0'};
        const char* character = (const char*)cstyle_char;

        if(std::regex_match(character,identifier))
        {
            id_symbols.push_back(text[index]);
        } else 
        {
            --index;
            --column;
            if(text[index] == '\n')
            {
                --line;
                column = get_line(text,line-1).size() + 1;
                g_current_line = rewind_current_line(text,index);
            }
            std::string identifier(id_symbols.begin(), id_symbols.end());
            std::string* location = std::find(keywords.begin(),keywords.end(),identifier);
            if(location != keywords.end())
            {
                return Token(TT_Keyword,identifier,prev_line,prev_column,fname);
            }
            return Token(TT_Identifier,identifier,prev_line,prev_column,fname);
        }
    }
    std::string identifier(id_symbols.begin(), id_symbols.end());
    std::string* location = std::find(keywords.begin(),keywords.end(),identifier);
    if(location != keywords.end())
    {
        return Token(TT_Keyword,identifier,prev_line,prev_column,fname);
    }
    return Token(TT_Identifier,identifier,prev_line,prev_column,fname);
}

Token construct_number(const std::string& text, int& index, int& line, int& column, const std::string& fname)
{
    std::vector<char> num_symbols;
    int dot_count = 0;
    int prev_column = column * 1;
    int prev_line = line * 1;

    char cstyle_char[2]{text[index],'\0'};
    const char* character = (const char*)cstyle_char;

    if(std::regex_match(character,number))
    {
        num_symbols.push_back(text[index]);
    } else if (text[index] == '.')
    {
        if (dot_count == 0)
        {
            num_symbols.push_back(text[index]);
            ++dot_count;
        } else 
        {
            --index;
            --column;
            if(text[index] == '\n')
            {
                --line;
                g_current_line = rewind_current_line(text,index);
                column = get_line(text,line-1).size() + 1;
            }
            float tk_value = std::stof(std::string(num_symbols.begin(), num_symbols.end()).c_str());
            return Token(TT_Float,tk_value,prev_line,prev_column,fname);
        }
    }else 
    {
        --index;
        --column;
        if(text[index] == '\n')
        {
            --line;
            column = get_line(text,line-1).size() + 1;
            g_current_line = rewind_current_line(text,index);
        }
        if(dot_count != 0)
        {
            float tk_value = std::stof(std::string(num_symbols.begin(), num_symbols.end()).c_str());
            return Token(TT_Float,tk_value,prev_line,prev_column,fname);
        }
        int tk_value = atoi(std::string(num_symbols.begin(), num_symbols.end()).c_str());
        return Token(TT_Number,tk_value,prev_line,prev_column,fname);
    }

    while(index < text.size()  || index == -1)
    {
        ++index;
        ++column;
        if(text[index] == '\n')
        {
            ++line;
            column = 0;
            g_current_line = recalculate_current_line(text,index);
        }

        char cstyle_char[2]{text[index],'\0'};
        const char* character = (const char*)cstyle_char;

        if(std::regex_match(character,number))
        {
            num_symbols.push_back(text[index]);
        } else if (text[index] == '.')
        {
            if (dot_count == 0)
            {
                num_symbols.push_back(text[index]);
                ++dot_count;
            } else 
            {
                --index;
                --column;
                if(text[index] == '\n')
                {
                    --line;
                    g_current_line = rewind_current_line(text,index);
                    column = get_line(text,line-1).size() + 1;
                }
                float tk_value = std::stof(std::string(num_symbols.begin(), num_symbols.end()).c_str());
                return Token(TT_Float,tk_value,prev_line,prev_column,fname);
            }
        }else 
        {
            --index;
            --column;
            if(text[index] == '\n')
            {
                --line;
                column = get_line(text,line-1).size() + 1;
                g_current_line = rewind_current_line(text,index);
            }
            if(dot_count != 0)
            {
                float tk_value = std::stof(std::string(num_symbols.begin(), num_symbols.end()).c_str());
                return Token(TT_Float,tk_value,prev_line,prev_column,fname);
            }
            int tk_value = atoi(std::string(num_symbols.begin(), num_symbols.end()).c_str());
            return Token(TT_Number,tk_value,prev_line,prev_column,fname);
        }
    }
    --index;
    --column;
    if(text[index] == '\n')
    {
        --line;
        column = get_line(text,line-1).size() + 1;
        g_current_line = rewind_current_line(text,index);
    }
    if(dot_count != 0)
    {
        float tk_value = std::stof(std::string(num_symbols.begin(), num_symbols.end()).c_str());
        return Token(TT_Float,tk_value,prev_line,prev_column,fname);
    }
    int tk_value = atoi(std::string(num_symbols.begin(), num_symbols.end()).c_str());

    return Token(TT_Number,tk_value,prev_line,prev_column,fname);
}

Token construct_string(const std::string& text, int& index, int& line, int& column, const std::string& fname)
{
    std::vector<char> string_chars;
    int prev_column = column * 1;
    int prev_line = line * 1;

    while(index < text.size())
    {
        ++index;
        ++column;

        if(text[index] == '\n')
        {
            compiler_error(g_current_line,line,column,fname,"expected \', but got a newline");
        }

        if(text[index] == '\'')
        {
            return Token(TT_String,std::string(string_chars.begin(),string_chars.end()),prev_line,prev_column,fname);
        }

        if(text[index] == '\\')
        {
            if(index + 1 == text.size())
            {
                compiler_error(g_current_line,line,column,fname,"unfinished escape sequence");
            }
            switch(text[index+1])
            {
                case 'n':
                    string_chars.push_back('\n');
                    break;
                case '\'':
                    string_chars.push_back('\'');
                    break;
                case '\\':
                    string_chars.push_back('\\');
                    break;
                default:
                    compiler_error(g_current_line,line,column,fname,"unknown escape sequence");
            }
            ++index;
            ++column;
            continue;
        }

        string_chars.push_back(text[index]);
    }
    compiler_error(text,line,column,fname,"expected \', but got EOF");
    exit(127);
}

std::string get_spaces(int);

void compiler_error(const std::string& text, const int& line, const int& column, const std::string& fname, const std::string& details)
{
    char linestr[32];
    sprintf(linestr,"%d",line);
    char colstr[32];
    sprintf(colstr,"%d",column);
    std::cerr << "\033[1;1m";
    std::cerr << fname;
    std::cerr << ":";
    std::cerr << linestr;
    std::cerr << ":";
    std::cerr << colstr;
    std::cerr << ": ";
    std::cerr << "\033[31;49m";
    std::cerr << "error: ";
    std::cerr << "\033[0;0m";
    std::cerr << details;
    std::cerr << std::endl;
    std::cerr << linestr;
    std::cerr << get_spaces(4);
    std::cerr << text;
    std::cerr << std::endl;
    std::cerr << get_spaces(4 + std::string(linestr).size());
    std::cerr << get_spaces(column - 1);
    std::cerr << "\033[31;49m";
    std::cerr << "^";
    std::cerr << "\033[0;0m";
    std::cerr << std::endl;
    exit(1);
}

void compiler_warning(const std::string& text, const int& line, const int& column, const std::string& fname, const std::string& details)
{
    char linestr[32];
    sprintf(linestr,"%d",line);
    char colstr[32];
    sprintf(colstr,"%d",column);
    std::cout << "\033[1;1m";
    std::cout << fname;
    std::cout << ":";
    std::cout << linestr;
    std::cout << ":";
    std::cout << colstr;
    std::cout << ": ";
    std::cout << "\033[33;49m";
    std::cout << "warning: ";
    std::cout << "\033[0;0m";
    std::cout << details;
    std::cout << std::endl;
    std::cout << linestr;
    std::cout << get_spaces(4);
    std::cout << text;
    std::cout << std::endl;
    std::cout << get_spaces(4 + std::string(linestr).size());
    std::cout << get_spaces(column - 1);
    std::cout << "\033[33;49m";
    std::cout << "^";
    std::cout << "\033[0;0m";
    std::cout << std::endl;
}

std::string get_line(const std::string& str, int line_no)
{
    std::string line;
    std::istringstream stream(str);
    while (line_no-- >= 0)
        std::getline(stream, line);
    return line;
}

std::string get_spaces(int spacenum)
{
    std::string output = "";
    for(int i = 0; i < spacenum; i++)
    {
        output += " ";
    }
    return output;
}

std::string make_asm_string(StringLiteral str)
{
    std::string result;
    result += str.identifier;
    result += ": ; -- string literal -- \n";
    result += "    db ";
    char code_point[4];
    sprintf(code_point,"%d",str.data[0]);
    result += std::string(code_point);
    for(int i = 1; i < str.data.size(); i++)
    {
        char code_point[4];
        sprintf(code_point,"%d",str.data[i]);
        result += (", " + std::string(code_point));
    }
    result += ", 0";
    result += "\n";
    return result;
}

std::vector<Token> evaluate_imports(const std::string& text, const std::vector<Token>& tokens)
{
    int i = 0;
    std::vector<Token> ret_tk = tokens;
    std::vector<Token> new_tokens;
    while(tokens[i].tk_type != TT_EOF)
    {
        if (g_importCount > IMPORT_MAX_DEEP) {
            compiler_error(tokens[i].line_ctx,tokens[i].line,tokens[i].column,tokens[i].fname,"import tree too deep");
        }
        if(tokens[i].tk_type == TT_Keyword && tokens[i].string_value == keywords[2])
        {
            if(tokens[i+1].tk_type == TT_EOF) {compiler_error(text,tokens[i].line,tokens[i].column,tokens[i].fname,"did not expect EOF after 'import' keyword");}
            if(tokens[i+1].tk_type == TT_Identifier)
            {
                if(std::find(imported_files.begin(), imported_files.end(), tokens[i+1].string_value) != imported_files.end()) {
                    compiler_error(tokens[i+2].line_ctx,tokens[i+2].line,tokens[i+2].column,tokens[i+2].fname,"file already imported");
                }
                if(tokens[i+2].tk_type != TT_Semicolon) {compiler_error(text,tokens[i+2].line,tokens[i+2].column,tokens[i+2].fname,"expected a semicolon after import statement");}
                std::ifstream ifile(tokens[i+1].string_value + ".sp");

                if (!ifile.good()) {
                    compiler_error(tokens[i+1].line_ctx,tokens[i+1].line,tokens[i+1].column,tokens[i+1].fname,"file '" + tokens[i+1].string_value + ".sp' not found");
                }
                ifile.close();

                std::string imported_file_contents = read_file(tokens[i+1].string_value + ".sp");

                std::vector<Token> imported_tokens = lex_tokens(imported_file_contents,tokens[i+1].string_value + ".sp");
                imported_tokens.pop_back(); // remove EOF at end of token stream

                new_tokens.insert(new_tokens.end(),imported_tokens.begin(),imported_tokens.end());
                ret_tk[i] = Token(TT_Null,ret_tk[i].line,ret_tk[i].column,ret_tk[i].fname); // remove import data
                ret_tk[i+1] = Token(TT_Null,ret_tk[i+1].line,ret_tk[i+1].column,ret_tk[i+1].fname); // remove import data
                ret_tk[i+2] = Token(TT_Null,ret_tk[i+2].line,ret_tk[i+2].column,ret_tk[i+2].fname); // remove import data
                imported_files.push_back(tokens[i+1].string_value);
            } else {
                compiler_error(tokens[i+1].line_ctx,tokens[i+1].line,tokens[i+1].column,tokens[i+1].fname,"import statement must use an identifier");
            }
        }
        ++i;
    }
    if(new_tokens.size() != 0)
    {
        new_tokens.insert(new_tokens.end(),ret_tk.begin(),ret_tk.end());
        ++g_importCount;
        return evaluate_imports(text,new_tokens);
    }
    return ret_tk;
}

std::vector<Sentence> parse_tokens(const std::vector<Token>& tokens)
{
    int i = 0;
    while(i < tokens.size())
    {
        if(tokens[i].tk_type == TT_Null)
        {
            ++i;
            continue;
        }
        std::cout << tokens[i].to_string() << std::endl;
        ++i;
    }
    return std::vector<Sentence>();
}