compiler.cpp

#include <fstream>
#include <iostream>
#include <string>
#include <array>
#include <vector>
#include <map>
#include <algorithm>
#include <utility>

// keyword "map"
std::array<std::string, 18> keywords = {"if", "elif", "else", "for", "while", "do", "break", "true",
                                        "false", "print", "input", "int", "float", "str", "bool",
                                        "void", "def", "return"};
std::array<std::string, 24> operators = {"=", "==", "!=", "<", "<=", ">", ">=", "!", "&&", "&", "||",
                                         "|", "^", "+", "-", "*", "/", "(", ")", "{", "}", ";", "\"",
                                         ","};

unsigned int row = 1;
unsigned int column = 1;

struct depths{
    bool operator==(const depths& rhs) const{
        return rhs.graphical == graphical && rhs.inbetween == inbetween;
    }
    unsigned int graphical;
    bool inbetween;
    depths(){
        graphical = 0;
        inbetween = false;
    }
    depths(unsigned int new_graphical, bool new_inbetween){
        graphical = new_graphical;
        inbetween = new_inbetween;
    };
};

depths depth = depths();

// first char of the block after the next
char look_ahead;
// next complete block
std::string value;
// id of the next block
// -1 no value, 0-17 kw-id, 30 '\0', 31 '\n', 32 ' ', 33 '\t', 50-73 op-id,
// 100 identifier, 101 int literal, 102 float literal, 103 string literal
int kw_code;

struct type_with_depth{
    std::string type;
    depths depth;
    type_with_depth(std::string new_type, depths new_depth){
        type = new_type;
        depth = new_depth;
    };
};
struct var{
    std::string name;
    std::string type;
    var(std::string new_name, std::string new_type){
        name = new_name;
        type = new_type;
    };
};
struct function_annotation{
    std::string return_type;
    std::vector<var> parameters;
    function_annotation(std::string new_return_type){
        return_type = new_return_type;
        parameters = {};
    };
    function_annotation(){
        return_type = "";
        parameters = {};
    };
};
/*struct annotation_with_depth{
    function_annotation function;
    depths depth;
    annotation_with_depth(function_annotation new_function, depths new_depth){
        function = new_function;
        depth = new_depth;
    };
};*/

std::map<std::string, std::vector<type_with_depth>> variables = {};
std::map<std::string, std::vector<function_annotation>> functions = {};
//std::map<std::string, std::vector<annotation_with_depth>> lamdas = {};


// input
std::ifstream code;
// output
std::ofstream out;


// used to indicate error in code and exit
struct ExitCompilation
{
};

void write_string(std::string output)
{
    out << output;
}

void write_char(char output)
{
    write_string(std::string(1, output));
}

void print_indent()
{
    write_string(std::string((depth.graphical - 1) * 4, ' '));
}

std::string human_readable(char unreadable)
{
    switch (unreadable)
    {
    case '\0':
        return "End of File";
    case '\n':
        return "End of line";
    case '\t':
        return "Tab";
    case '\r':
        return "Carriage return";
    case '\\':
        return "Backslash";
    default:
        if (isprint(unreadable))
            return std::string(1, unreadable);
        else
            return "Non-printable";
    }
}

std::string human_readable(std::string unreadable)
{
    std::string res = "";
    for (char c : unreadable)
        res += human_readable(c);
    return res;
}

void lookup_keyword()
{
    for (int i = 0; i <= keywords.size(); ++i)
    {
        if (keywords[i] == value)
        {
            kw_code = i;
            return;
        }
    }
    kw_code = -1;
}

void lookup_operator()
{
    for (int i = 0; i <= operators.size(); ++i)
    {
        if (operators[i] == value)
        {
            kw_code = 50 + i;
            return;
        }
    }
    kw_code = -1;
}

void error(std::string expected, std::string found)
{
    std::cout << "Error in line " << row << " column " << column - found.size() << ": '";
    std::cout << human_readable(expected) << "' was expected but '" << human_readable(found);
    std::cout << "' was found.\n";
    throw ExitCompilation{};
}

void error(std::string expected, char found)
{
    std::string temp = "";
    temp.push_back(found);
    error(expected, temp);
}

void abort(std::string cause)
{
    std::cout << "Error in line " << row << ": '" << cause <<  "'\n";
    throw ExitCompilation{};
}

void read_char()
{
    look_ahead = '\0';
    code.get(look_ahead);
    if (look_ahead == '\n')
    {
        row += 1;
        column = 0;
    }
    else
        column += 1;
    kw_code = -1;
}

bool is_if() { return kw_code == 0; }
bool is_elif() { return kw_code == 1; }
bool is_else() { return kw_code == 2; }
bool is_for() { return kw_code == 3; }
bool is_while() { return kw_code == 4; }
bool is_do() { return kw_code == 5; }
bool is_break() { return kw_code == 6; }
bool is_true() { return kw_code == 7; }
bool is_false() { return kw_code == 8; }
bool is_print() { return kw_code == 9; }
bool is_input() { return kw_code == 10; }
bool is_type_int() { return kw_code == 11; }
bool is_type_float() { return kw_code == 12; }
bool is_type_str() { return kw_code == 13; }
bool is_type_bool() { return kw_code == 14; }
bool is_type_void() { return kw_code == 15; }
bool is_type() { return is_type_int() || is_type_float() || is_type_str() || is_type_bool() || is_type_void(); }
bool is_var_type() { return is_type_int() || is_type_float() || is_type_str() || is_type_bool(); }
bool is_function_def() { return kw_code == 16; }
bool is_return() { return kw_code == 17; }

bool is_eof() { return kw_code == 30; }
bool is_newline() { return kw_code == 31; }
bool is_space() { return kw_code == 32; }
bool is_tab() { return kw_code == 33; }

bool is_assign() { return kw_code == 50; }
bool is_equals() { return kw_code == 51; }
bool is_nequals() { return kw_code == 52; }
bool is_less() { return kw_code == 53; }
bool is_lessequal() { return kw_code == 54; }
bool is_greater() { return kw_code == 55; }
bool is_greaterequal() { return kw_code == 56; }
bool is_neqop() { return kw_code == 57; }
bool is_double_and() { return kw_code == 58; }
bool is_and() { return kw_code == 59; }
bool is_double_or() { return kw_code == 60; }
bool is_or() { return kw_code == 61; }
bool is_xor() { return kw_code == 62; }
bool is_plus() { return kw_code == 63; }
bool is_minus() { return kw_code == 64; }
bool is_mult() { return kw_code == 65; }
bool is_div() { return kw_code == 66; }
bool is_open_normal_bracket() { return kw_code == 67; }
bool is_close_normal_bracket() { return kw_code == 68; }
bool is_open_curly_bracket() { return kw_code == 69; }
bool is_close_curly_bracket() { return kw_code == 70; }
bool is_semicolon() { return kw_code == 71; }
bool is_quote() { return kw_code == 72; }
bool is_comma() { return kw_code == 73; }

bool is_identifier() { return kw_code == 100; }
bool is_int() { return kw_code == 101; }
bool is_float() { return kw_code == 102; }
bool is_numeric() { return is_int() || is_float(); }

bool next_is_alpha() { return isalpha(look_ahead); }
bool next_is_numeric() { return isdigit(look_ahead); }
bool next_is_printable() {
    return isalnum(look_ahead) || ispunct(look_ahead) || look_ahead == ' ' || look_ahead == '\t';
}

void skip_white()
{
    while (look_ahead == ' ' || look_ahead == '\t')
        read_char();
}

void scan();

void skip_empty_lines()
{
    while (is_newline())
        scan();
}

void get_name()
{
    std::string name = "";
    if (!next_is_alpha())
        error("Name", look_ahead);
    do
    {
        name += look_ahead;
        read_char();
    } while (isalnum(look_ahead));
    skip_white();
    value = name;
}

void get_number()
{
    std::string number = "";
    if (!next_is_numeric())
        error("Integer' or 'Float", look_ahead);
    bool had_decimal_point = false;
    bool last_was_decimal_point = false;
    do
    {
        if (look_ahead == '.')
        {
            if (had_decimal_point)
                break;
            look_ahead = '.';
            had_decimal_point = true;
            last_was_decimal_point = true;
        }
        else
            last_was_decimal_point = false;
        number += look_ahead;
        read_char();
    } while (next_is_numeric() || look_ahead == '.');
    if (last_was_decimal_point)
        abort("Float literal ending on decimal point.");
    skip_white();
    value = number;
    if (had_decimal_point)
        kw_code = 102;
    else
        kw_code = 101;
}

void get_string()
{
    std::string string_val = "";
    if (!(next_is_printable() || look_ahead == '\\'))
        error("String", look_ahead);
    bool last_was_back_slash = false;
    do
    {
        if (last_was_back_slash && look_ahead != '\\' && look_ahead != 'n' && look_ahead != 't' && look_ahead != '\"')
            error("\\', 'n', 't' or '\"' after unescaped '\\", "\\" + look_ahead);
        if (!last_was_back_slash && look_ahead == '\"')
            break;
        string_val += look_ahead;
        if (look_ahead == '\\' && !last_was_back_slash)
            last_was_back_slash = true;
        read_char();
    } while (next_is_printable() || look_ahead == '\\');
    skip_white();
    value = string_val;
    kw_code = 103;
}

void get_operator()
{
    bool matches_any = false;
    for (std::string op : operators)
    {
        if (look_ahead == op[0])
        {
            matches_any = true;
            break;
        }
    }
    if (!matches_any)
        error("Operator", look_ahead);
    value = std::string(1, look_ahead);
    read_char();
    value.push_back(look_ahead);
    for (std::string op : operators)
    {
        if (value == op)
        {
            read_char();
            return;
        }
    }
    value.pop_back();
}

void scan()
{
    skip_white();
    if (next_is_alpha())
    {
        get_name();
        lookup_keyword();
        if (kw_code == -1)
            kw_code = 100;
    }
    else if (next_is_numeric())
        get_number();
    else if (look_ahead == '\0')
    {
        read_char();
        value = "\0";
        kw_code = 30;
    }
    else if (look_ahead == '\n')
    {
        read_char();
        value = "\n";
        kw_code = 31;
    }
    else if (look_ahead == ' ')
    {
        read_char();
        value = " ";
        kw_code = 32;
    }
    else if (look_ahead == '\t')
    {
        read_char();
        value = "\t";
        kw_code = 33;
    }
    else
    {
        get_operator();
        lookup_operator();
    }
}

std::string bool_expression();

std::string identifier()
{
    if (!is_identifier())
        error("Identifier", value);
    if (look_ahead == '(')
    {
        if (functions.find(value) == functions.end())
            abort("Can not call undefined function " + value);
        if (variables.find(value) != variables.end() && variables[value].back().depth.graphical > 1)
            abort("Can not call function that is shadowed by variable.");
        std::string ret_value = functions[value].back().return_type;
        std::vector<var> parameter = functions[value].back().parameters;
        write_string(value);
        scan();
        if (!is_open_normal_bracket())
            error("(", value);
        scan();
        write_char('(');
        for (int i = 0; i < parameter.size(); ++i)
        {
            std::string type = bool_expression();
            if (type != parameter[i].type)
                abort("Parameter type mismatch (found '" + type + "', expected '" + ret_value + "'.");
            if (!is_comma())
                error("Comma", value);
            scan();
            if (i != parameter.size() - 1)
                write_string(", ");
        }
        if (!is_close_normal_bracket())
            error(")", value);
        write_char(')');
        scan();
        return ret_value;
    }
    if (variables.find(value) == variables.end())
        abort("Undefined variable " + value);
    write_string(value);
    std::string ret_value = variables[value].back().type;
    scan();
    return ret_value;
}

std::string factor()
{
    bool was_plus_or_minus = is_plus() || is_minus();
    if (is_plus())
        scan();
    else if (is_minus())
    {
        write_char('-');
        scan();
    }

    if (is_open_normal_bracket())
    {
        write_char('(');
        scan();
        std::string ret_type = bool_expression();
        if (!is_close_normal_bracket())
            error(")", value);
        write_char(')');
        scan();
        if (was_plus_or_minus && ret_type != "float" && ret_type != "int")
            abort("Cannot add a minus or plus to a value of type: " + ret_type);
        return ret_type;
    }
    else if (is_identifier())
    {
        std::string ret_type = identifier();
        if (was_plus_or_minus && ret_type != "float" && ret_type != "int")
            abort("Cannot add a minus or plus to a value of type: " + ret_type);
        return ret_type;
    }
    else if (is_int())
    {
        write_string(value);
        scan();
        return "int";
    }
    else if (is_float())
    {
        write_string(value);
        scan();
        return "float";
    }
    else if (is_quote())
    {
        if (look_ahead != '\"')
            get_string();
        else
            value = "";
        write_string("\"" + value);
        scan();
        if (!is_quote())
            error("\"' at the end of string literal", value);
        write_char('\"');
        scan();
        return "str";
    }
    else
        error("(', 'Identifier', 'Number' or 'String", value);
    std::unreachable();
}

std::string term()
{
    std::string ret_type = factor();
    while (is_mult() || is_div())
    {
        if (is_mult())
            write_string(" * ");
        else if (is_div())
            write_string(" / ");
        else
            error("Mulop", value);
        scan();
        std::string ret_type2 = factor();
        if (ret_type == "str" || ret_type == "bool" || ret_type == "void")
            abort("Can not multiply or divide '" + ret_type + "' with '" + ret_type2 + "'.");
        if (ret_type2 == "str" || ret_type2 == "bool" || ret_type2 == "void")
            abort("Can not multiply or divide '" + ret_type + "' with '" + ret_type2 + "'.");
        if (ret_type == "float" || ret_type2 == "float")
            ret_type = "float";
    }
    return ret_type;
}

std::string expression()
{
    std::string ret_type = term();
    while (is_plus() || is_minus())
    {
        bool was_add = is_plus();
        if (is_plus())
            write_string(" + ");
        else if (is_minus())
            write_string(" - ");
        else
            error("Addop", value);
        scan();
        std::string ret_type2 = term();
        if (ret_type == "bool" || ret_type == "void" || ret_type2 == "bool" || ret_type2 == "void")
            abort("Can not add or substract '" + ret_type + "' to or from '" + ret_type2 + "'.");
        if (was_add && (ret_type == "str" ^ ret_type2 == "str"))
            abort("Can not add '" + ret_type + "' to '" + ret_type2 + "'.");
        if (!was_add && (ret_type == "str" || ret_type2 == "str"))
            abort("Can not substract '" + ret_type + "' from '" + ret_type2 + "'.");
        if (ret_type == "float" || ret_type2 == "float")
            ret_type = "float";
    }
    return ret_type;
}

std::string relation()
{
    std::string ret_type = expression();
    bool was_equals_or_nequals = is_equals() || is_nequals();
    if (is_equals())
        write_string(" == ");
    else if (is_nequals())
        write_string(" != ");
    else if (is_less())
        write_string(" < ");
    else if (is_lessequal())
        write_string(" <= ");
    else if (is_greater())
        write_string(" > ");
    else if (is_greaterequal())
        write_string(" >= ");
    else
        return ret_type;
    scan();
    std::string ret_type2 = expression();
    if (ret_type == "void" || ret_type2 == "void")
        abort("Can not compare '" + ret_type + "' to '" + ret_type2 + "'.");
    if (ret_type == "str" || ret_type == "bool" || ret_type2 == "str" || ret_type2 == "bool")
    {
        if (ret_type != ret_type2)
            abort("Can not compare '" + ret_type + "' to '" + ret_type2 + "'.");
        if (!was_equals_or_nequals)
            abort("Can not compare '" + ret_type + "' to '" + ret_type2 + "' without using '==' or '!='.");
    }
    return "bool";
}

std::string bool_factor()
{
    bool was_negated = is_neqop();
    if (is_neqop())
    {
        write_char('!');
        scan();
    }

    if (is_true())
    {
        write_string("true");
        scan();
        return "bool";
    }
    else if (is_false())
    {
        write_string("false");
        scan();
        return "bool";
    }
    else
    {
        std::string ret_type = relation();
        if (was_negated && ret_type != "bool")
            abort("Can not negate '" + ret_type + "'.");
        return ret_type;
    }
}

std::string bool_term()
{
    std::string ret_type = bool_factor();
    while (is_double_and() || is_and())
    {
        bool was_bit_op = is_and();
        if (is_double_and())
            write_string(" && ");
        else if (is_and())
            write_string(" & ");
        scan();
        std::string ret_type2 = bool_factor();
        if ((!(was_bit_op && ret_type == "int" && ret_type2 == "int")) && (ret_type != "bool" || ret_type2 != "bool"))
            abort("Can not use (some or all of) '&&' or '&' on '" + ret_type + "' and '" + ret_type2 + "'.");
    }
    return ret_type;
}

std::string bool_expression()
{
    std::string ret_type = bool_term();
    while (is_double_or() || is_or() || is_xor())
    {
        bool was_bit_op = is_or() || is_xor();
        if (is_double_or())
            write_string(" || ");
        else if (is_or())
            write_string(" | ");
        else if (is_xor())
            write_string(" ^ ");
        scan();
        std::string ret_type2 = bool_term();
        if ((!(was_bit_op && ret_type == "int" && ret_type2 == "int")) && (ret_type != "bool" || ret_type2 != "bool"))
            abort("Can not use (some or all of) '||', '|' or '^' on '" + ret_type + "' and '" + ret_type2 + "'.");
    }
    return ret_type;
}

void inline_assignment()
{
    if (variables.find(value) == variables.end())
        abort("Cannot assign value to undefined variable " + value);
    write_string(value);
    std::string type = variables[value].back().type;
    scan();
    if (!is_assign())
        error("=", value);
    write_string(" = ");
    scan();
    std::string ret_type = bool_expression();
    if (type == "float" && ret_type != "float" && ret_type != "int")
        abort("Can not convert '" + ret_type + "' to 'float'.");
    if (ret_type == "void")
        abort("Can not store void in variable.");
    if (ret_type != type && !(ret_type == "int" && type == "float"))
        abort("Can not store '" + ret_type + "' value in variable of type '" + type + "'.");
}

void inline_assignment(std::string type)
{
    std::string name = value;
    if (variables.find(name) != variables.end() && variables[name].back().depth == depth)
        abort("Cannot redefine variable " + name);
    if (functions.find(name) != functions.end())
        abort("Cannot redefine function to be a variable " + name);
    write_string(type + " " + name);
    scan();
    if (!is_assign())
        error("=", value);
    write_string(" = ");
    scan();
    std::string ret_type = bool_expression();
    if (type == "float" && ret_type != "float" && ret_type != "int")
        abort("Can not convert '" + ret_type + "' to 'float'.");
    if (ret_type == "void")
        abort("Can not store void in variable.");
    if (ret_type != type && !(ret_type == "int" && type == "float"))
        abort("Can not store '" + ret_type + "' value in variable of type '" + type + "'.");
    if (variables.find(name) == variables.end())
        variables[name] = {};
    variables[name].push_back(type_with_depth(type, depth));
}

void assignment()
{
    inline_assignment();
    if (!is_newline())
        error("\n", value);
    scan();
    write_string(";\n");
}

void assignment(std::string type)
{
    inline_assignment(type);
    if (!is_newline())
        error("\n", value);
    scan();
    write_string(";\n");
}

void block(bool, bool);

void else_branch(bool in_loop)
{
    if (!is_newline())
        error("\n", value);
    scan();
    write_string("else\n");
    if (!is_open_curly_bracket())
        error("{", value);
    scan();
    if (!is_newline())
        error("\n", value);
    scan();
    print_indent();
    write_string("{\n");
    block(in_loop, false);
    if (!is_close_curly_bracket())
        error("}", value);
    scan();
    if (!is_newline())
        error("\n", value);
    scan();
    print_indent();
    write_string("}\n");
}

void branch(bool in_loop)
{
    if (!is_open_normal_bracket())
        error("(", value);
    scan();
    write_string("if (");
    std::string type = bool_expression();
    if (type != "bool")
        abort("Expression evaluating to bool was expected in if but expression evluated to '" + type + "'.");
    if (!is_close_normal_bracket())
        error(")", value);
    scan();
    if (!is_newline())
        error("\n", value);
    scan();
    write_string(")\n");
    if (!is_open_curly_bracket())
        error("{", value);
    scan();
    if (!is_newline())
        error("\n", value);
    scan();
    print_indent();
    write_string("{\n");
    block(in_loop, false);
    if (!is_close_curly_bracket())
        error("}", value);
    scan();
    if (!is_newline())
        error("\n", value);
    scan();
    print_indent();
    write_string("}\n");
    if (is_elif())
    {
        scan();
        print_indent();
        write_string("else ");
        branch(in_loop);
    }
    else if (is_else())
    {
        scan();
        print_indent();
        else_branch(in_loop);
    }
}

void while_loop()
{
    if (!is_open_normal_bracket())
        error("(", value);
    scan();
    write_string("while (");
    std::string type = bool_expression();
    if (type != "bool")
        abort("Expression evaluating to bool was expected in while but expression evluated to '" + type + "'.");
    if (!is_close_normal_bracket())
        error(")", value);
    scan();
    if (!is_newline())
        error("\n", value);
    scan();
    write_string(")\n");
    if (!is_open_curly_bracket())
        error("{", value);
    scan();
    if (!is_newline())
        error("\n", value);
    scan();
    print_indent();
    write_string("{\n");
    block(true, false);
    if (!is_close_curly_bracket())
        error("}", value);
    scan();
    if (!is_newline())
        error("\n", value);
    scan();
    print_indent();
    write_string("}\n");
}

void do_while_loop()
{
    if (!is_newline())
        error("\n", value);
    scan();
    write_string("do\n");
    if (!is_open_curly_bracket())
        error("{", value);
    scan();
    if (!is_newline())
        error("\n", value);
    scan();
    print_indent();
    write_string("{\n");
    block(true, false);
    if (!is_close_curly_bracket())
        error("}", value);
    scan();
    if (!is_newline())
        error("\n", value);
    scan();
    print_indent();
    write_string("}\n");
    if (!is_while())
        error("while", value);
    scan();
    if (!is_open_normal_bracket())
        error("(", value);
    scan();
    print_indent();
    write_string("while (");
    std::string type = bool_expression();
    if (type != "bool")
        abort("Expression evaluating to bool was expected in do-while but expression evluated to '" + type + "'.");
    if (!is_close_normal_bracket())
        error(")", value);
    scan();
    if (!is_newline())
        error("\n", value);
    scan();
    write_string(");\n");
}

void for_loop()
{
    depth.graphical += 1;
    depth.inbetween = true;
    if (!is_open_normal_bracket())
        error("(", value);
    scan();
    write_string("for (");
    if (is_var_type())
    {
        std::string type = value;
        scan();
        inline_assignment(type);
    }
    else if (is_type_void() || !is_identifier())
        error("non-void Type' or 'Variable", value);
    else
        inline_assignment();
    if (!is_semicolon())
        error(";", value);
    scan();
    write_string("; ");
    std::string type = bool_expression();
    if (type != "bool")
        abort("Expression evaluating to bool was expected in for but expression evluated to '" + type + "'.");
    if (!is_semicolon())
        error(";", value);
    write_string("; ");
    scan();
    if (is_var_type())
    {
        std::string type = value;
        scan();
        inline_assignment(type);
    }
    else if (is_type_void() || !is_identifier())
        error("non-void Type' or 'Variable", value);
    else
        inline_assignment();
    if (!is_close_normal_bracket())
        error(")", value);
    scan();
    if (!is_newline())
        error("\n", value);
    scan();
    write_string(")\n");
    if (!is_open_curly_bracket())
        error("{", value);
    scan();
    if (!is_newline())
        error("\n", value);
    scan();
    depth.graphical -= 1;
    depth.inbetween = false;
    print_indent();
    write_string("{\n");
    block(true, false);
    if (!is_close_curly_bracket())
        error("}", value);
    scan();
    if (!is_newline())
        error("\n", value);
    scan();
    print_indent();
    write_string("}\n");
}

void break_statement()
{
    if (!is_newline())
        error("\n", value);
    scan();
    write_string("break;\n");
}

void print()
{
    write_string("std::cout << ");
    if (!is_open_normal_bracket())
        error("(", value);
    scan();
    bool_expression();
    if (!is_close_normal_bracket())
        error(")", value);
    scan();
    if (!is_newline())
        error("\n", value);
    scan();
    write_string(";\n");
}

void input()
{
    write_string("std::cin >> ");
    if (!is_open_normal_bracket())
        error("(", value);
    scan();
    if (!is_identifier())
        error("Variable", value);
    if (variables.find(value) == variables.end())
        abort("Can't read into undeclared variable.");
    write_string(value);
    scan();
    if (!is_close_normal_bracket())
        error(")", value);
    scan();
    if (!is_newline())
        error("\n", value);
    scan();
    write_string(";\n");
}

void function_def()
{
    if (depth.inbetween)
        abort("Function definition in for loop or parameter list of other function?!");
    if (!is_type())
        error("Type", value);
    std::string return_type = value;
    scan();
    if (!is_identifier())
        error("Identifier", value);
    std::string name = value;
    scan();
    if (depth.graphical == 1)
    {
        if (functions.find(name) != functions.end())
            abort("Can not overload function '" + name + "'.");
        functions[name] = {};
        functions[name].push_back(function_annotation(return_type));
        write_string("\n" + return_type + " " + name);
        if (!is_open_normal_bracket())
            error("(", value);
        scan();
        write_string(" (");
        bool another_comma = false;
        depth.graphical += 1;
        depth.inbetween = true;
        while (is_var_type())
        {
            if (another_comma)
                write_string(", ");
            another_comma = true;
            std::string type = value;
            scan();
            if (!is_identifier())
                error("Identifier", value);
            functions[name].back().parameters.push_back(var(value, type));
            variables[value].push_back(type_with_depth(type, depth));
            write_string(type + " " + value);
            scan();
            if (!is_comma())
                error("Comma", value);
            scan();
        }
        depth.graphical -= 1;
        depth.inbetween = false;
        if (!is_close_normal_bracket())
            error(")", value);
        scan();
        if (!is_newline())
            error("\n", value);
        scan();
        write_string(")\n");
        if (!is_open_curly_bracket())
            error("{", value);
        scan();
        print_indent();
        write_string("{\n");
        block(false, true);
        if (!is_return())
            error("return statement", value);
        print_indent();
        write_string("return");
        scan();
        if (return_type != "void")
        {
            write_char(' ');
            std::string type = bool_expression();
            if (return_type == "float" && type != "float" && type != "int")
                abort("Can not convert '" + type + "' to 'float'.");
            if (type != return_type && !(type == "int" && return_type == "float"))
                abort("Can not return '" + type + "' in function returning type '" + return_type + "'.");
        }
        for (auto [name, occurrences] : variables)
        {
            if (occurrences.back().depth.graphical == depth.graphical)
                variables[name].pop_back();
        }
        std::erase_if(variables, [](const auto& key_value){return key_value.second.empty();});
        depth.graphical -= 1;
        write_string(";\n");
        if (!is_newline())
            error("\n", value);
        scan();
        if (!is_close_curly_bracket())
            error("}", value);
        scan();
        print_indent();
        write_string("}\n\n");
    }
    else
    {
        abort("Lambda functions are not defined yet.");
        /*if (variables.find(name) != variables.end() && variables[name].back().depth == depth)
            abort("Can not define inline method with the same name as variable declared on that level.");
        if (lamdas.find(name) != lamdas.end())
            if (lamdas[name].back().depth == depth)
                abort("Can not redefine inline method on the same level.");
        else
            lamdas[name] = {};
        lamdas[name].push_back(annotation_with_depth(function_annotation(return_type), depth));
        // TODO: write lambda def out
        write_string("");
        // TODO: parse argument list and add to function_annotation
        // TODO: handle lambda body*/
    }
}

void statement()
{
    if (is_print())
    {
        scan();
        print();
    }
    else if (is_input())
    {
        scan();
        input();
    }
    else if (is_function_def())
    {
        scan();
        function_def();
    }
    else if (is_type())
    {
        if (is_type_void())
            abort("Found type void outside of functiondefinition.");
        std::string type = value;
        scan();
        assignment(type);
    }
    else if (is_identifier() && look_ahead == '=')
        assignment();
    else
    {
        bool_expression();
        if (!is_newline())
            error("\n", value);
        scan();
        write_string(";\n");
    }
}

void block(bool in_loop, bool function_block)
{
    depth.graphical += 1;
    skip_empty_lines();
    while (!(is_eof() || is_close_curly_bracket() || is_return()))
    {
        print_indent();
        if (depth.graphical == 1)
        {
            if (!(is_function_def() || is_var_type()))
                error("Function definition or variable initialization", value);
            statement();
        }
        else if (is_if())
        {
            scan();
            branch(in_loop);
        }
        else if (is_while())
        {
            scan();
            while_loop();
        }
        else if (is_do())
        {
            scan();
            do_while_loop();
        }
        else if (is_for())
        {
            scan();
            for_loop();
        }
        else if (is_break())
        {
            if (!in_loop)
                abort("Found break statement outside of an loop.");
            scan();
            break_statement();
            if (!is_close_curly_bracket())
            {
                std::cout << "Warning: Unreachable code after break statement in line " << row;
                std::cout << " column " << column - value.size() << '\n';
            }
        }
        else
            statement();
        skip_empty_lines();
    }
    if (!function_block)
    {
        for (auto [name, occurrences] : variables)
        {
            if (occurrences.back().depth.graphical == depth.graphical)
                variables[name].pop_back();
        }
        std::erase_if(variables, [](const auto& key_value){return key_value.second.empty();});
        depth.graphical -= 1;
    }
}

void init()
{
    write_string("#include <iostream>\n#include <string>\n\nusing str = std::string;\n\n");
    read_char();
    scan();
    skip_empty_lines();
}

int main(int argc, char * argv[])
{
    if (argc != 3)
    {
        std::cout << "You have to pass two arguments.\n";
        std::cout << "The first one is your path to the file containing your code.\n";
        std::cout << "The second argument is the file path to which the c++ code should be written.";
    }

    try
    {
        code = std::ifstream{argv[1]};
    }
    catch(const std::exception& e)
    {
        std::cerr << "While trying to open the given input file the following error occured:\n" << e.what() << '\n';
    }

    try
    {
        out = std::ofstream{argv[2]};
    }
    catch(const std::exception& e)
    {
        std::cerr << "While trying to open the given output file the following error occured:\n" << e.what() << '\n';
    }

    try
    {
        init();
        block(false, false);
        if (!is_eof())
            error("\0", value);
        if (functions.find("main") == functions.end())
            error("Mainmethod", '\0');
    }
    catch (const ExitCompilation)
    {
    }
}