main.cpp

#include "globals.h"
#include "boards/pico.h"
#include "boards/gamebuino.h"
#include "boards/picosystem.h"
#include <bit>

u4 countArgs(std::string str)
{
    int count = 0;
    if (str[0] != '(')
    {
        throw fmt::format("Invalid descriptor. Should start with '(', got '{}'!", str[0]);
    }

    for (size_t index = 1; index < str.size(); ++index)
    {
        switch (str[index])
        {
        case ')':
            index = str.size();
            break;
        case 'L':
            ++count;
            while (str[index] != ';') ++index;
            break;
        case 'I':
        case 'Z':
        case 'F':
        case 'B':
        case 'S':
            ++count;
            break;
        case '[':
            break;
        default:
            throw fmt::format("Invalid or unhandled type used as a parameter type: '{}'.", str[index]);
        }
    }

    return count;
}

attribute_info readAttribute(Buffer & buffer);

std::vector<Instruction> convertBytecode(Buffer & buffer, std::string function, u2 depth);

int main([[maybe_unused]] int argc, [[maybe_unused]] char** argv)
{
    std::vector<std::string> javaFiles;
    for (auto const& dir_entry : std::filesystem::directory_iterator{"."})
    {
        if (dir_entry.is_regular_file())
        {
            auto filename_entry = dir_entry.path().filename().string();
            if (filename_entry.ends_with(".java"))
            {
                javaFiles.push_back(filename_entry);
            }
        }
    }

    if (!javaFiles.size())
    {
        fmt::print("No .java file detected. Aborting.\n");
        return 0;
    }

    for (auto & file : javaFiles)
    {
        int r = system(fmt::format("javac -cp api {}", file).data());

        if (r != 0)
        {
            fmt::print("{} has errors. Aborting.\n", file);
            return 0;
        }
    }

    try
    {
        std::string project_name, board_name;
        for (auto & file : javaFiles)
        {
            ClassFile tmp(file, ""s, true);
            if (tmp.hasBoard())
            {
                project_name = tmp.fileName;
                board_name = tmp.boardName();
            }
        }

        for (const fs::directory_entry& dir_entry :
                fs::recursive_directory_iterator("."))
        {
            if (dir_entry.is_regular_file() && dir_entry.path().extension().string() == ".class")
            {
                ClassFile tmp(dir_entry.path().string(), ""s, true);
                ClassFile::partialClasses.push_back(tmp);
            }
        }

        std::vector<ClassFile> classFiles;
        for (auto & file : javaFiles)
        {
            classFiles.push_back(ClassFile(file, project_name));
        }

        auto board = getBoardTypeFromString(board_name);
        if (board == Board::Gamebuino)
        {
            build_gamebuino(project_name, classFiles);
        }
        else if (board == Board::Picosystem)
        {
            build_picosystem(project_name, classFiles);
        }
        else
        {
            build_pico(project_name, getBoardTypeFromString(board_name), classFiles);
        }

        fmt::print("\n");
    }
    catch (const std::string & str)
    {
        fmt::print("{}\n", str);
    }

    return 0;
}

u1 read8(Buffer & buffer)
{
    auto byte = buffer.front();
    buffer.erase(buffer.begin());
    return byte;
}

u2 read16(Buffer & buffer)
{
    auto MSB = read8(buffer);
    auto LSB = read8(buffer);

    return MSB << 8 | LSB;
}

u4 read32(Buffer & buffer)
{
    auto MSB = read16(buffer);
    auto LSB = read16(buffer);

    return MSB << 16 | LSB;
}

s1 reads8(Buffer & buffer)
{
    return r8();
}

s2 reads16(Buffer & buffer)
{
    return r16();
}

s4 reads32(Buffer & buffer)
{
    return r32();
}

std::string getReturnType(std::string descriptor, u1 flags)
{
    auto paren = descriptor.find(')');
    auto type = descriptor.substr(paren + 1);

    std::string prefix;
    std::string suffix;
    if (flags & CONST_TYPE)    prefix += "const ";
    if (flags & UNSIGNED_TYPE) prefix += "u";
    if (flags & POINTER_TYPE)  suffix += "*";

    if (type == "V")
    {
        return "void";
    }

    if (type == "I")
    {
        return prefix + "int32_t" + suffix;
    }

    if (type == "B")
    {
        return prefix + "int8_t" + suffix;
    }

    if (type == "S")
    {
        return prefix + "int16_t" + suffix;
    }

    if (type == "Z")
    {
        return "bool" + suffix;
    }

    if (type == "D")
    {
        return prefix + "double" + suffix;
    }

    if (type.starts_with("L") && type.ends_with(";"))
    {
        auto jt = type.substr(1, type.size() - 2);

        if (jt == "java/lang/String")
        {
            return prefix + "std::string" + suffix;
        }
        else
        {
            return prefix + javaToCpp(jt) + suffix;
        }
    }

    throw fmt::format("Invalid or unhandled type used as a return type: '{}'.", type);
}

Board getBoardTypeFromString(std::string board_name)
{
    std::transform(begin(board_name), end(board_name), begin(board_name), [](auto c) { return std::tolower(c); });

    if (board_name == "pico")         return Board::Pico;
    if (board_name == "picow")        return Board::PicoW;
    if (board_name == "tiny2040")     return Board::Tiny2040;
    if (board_name == "tiny2040_2mb") return Board::Tiny2040_2mb;
    if (board_name == "badger2040")   return Board::Badger2040;
    if (board_name == "gamebuino")    return Board::Gamebuino;
    if (board_name == "picosystem")    return Board::Picosystem;

    throw fmt::format("Invalid board: '{}'.", board_name);
}

std::string generateParameters(std::string descriptor, std::vector<u1> flags, bool isMethod)
{
    std::string ret;

    int count = isMethod ? 1 : 0;
    if (descriptor[0] != '(')
    {
        throw fmt::format("Invalid descriptor. Should start with '(', got '{}'!", descriptor[0]);
    }

    int arrayCount = 0;
    for (size_t index = 1; index < descriptor.size(); ++index)
    {
        switch (descriptor[index])
        {
        case ')':
            index = descriptor.size();
            break;
        case 'L':
        {
            std::string type;
            ++index;
            while (descriptor[index] != ';')
            {
                type += descriptor[index];
                ++index;
            }

            if (flags[count] & POINTER_TYPE) ++arrayCount;

            if (type == "java/lang/String")
            {
                ret += fmt::format(", std::string {}local_{}", std::string(arrayCount, '*'), count);
            }
            else if (type == "pimoroni/buffer")
            {
                ret += fmt::format(", pimoroni::buffer {}local_{}", std::string(arrayCount, '*'), count);
            }
            else
            {
                throw fmt::format("classes are not supported as function arguments.");
            }
            break;
        }
        case 'I':
        case 'Z':
        {
            ret += fmt::format(", {} {}local_{}", getTypeFromDescriptor(descriptor[index]+""s, flags[count]), std::string(arrayCount, '*'), count);
            arrayCount = 0;
            ++count;
            break;
        }
        case '[':
            ++arrayCount;
            break;
        default:
            throw fmt::format("Invalid character in descriptor: '{}'.", descriptor[index]);
        }
    }

    if (ret.size() > 0)
    {
        ret = ret.substr(2);
    }
    return ret;
}

std::string javaToCpp(std::string name)
{
    return boost::replace_all_copy(name, "/"s, "::"s);
}

void copyUserFiles(fs::path currentPath)
{
    for (auto ext : { ".h"s, ".cpp"s })
    {
        if (fs::exists(currentPath / (USER_FILE + ext)))
        {
            fs::copy_file(currentPath / (USER_FILE + ext), fs::current_path() / (USER_FILE + ext), fs::copy_options::overwrite_existing);
        }
        else
        {
            fs::remove(fs::current_path() / (USER_FILE + ext));
        }
    }
}