bindgen_main.cpp

Go to the documentation of this file.

#include <algorithm>
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <string>
#include <algorithm>
 
const std::vector<std::string> PATCHES = {"#pragma warning(disable:4996)", "#pragma warning(disable:4244)"};
 
struct Param
{
    std::string type;
    std::string name;
};
 
struct Function
{
    std::string        returnType;
    std::string        name;
    std::vector<Param> params;
    std::string        rawLine;
    int                lineNumber = 0;
};
 
bool isHandleType(const std::string &type)
{
    return type == "HANDLE" || type == "HMODULE" || type == "HWND" || type == "HINSTANCE" || type == "HDC";
}
 
bool isSupportedParam(const std::string &type)
{
    if (isHandleType(type))
    {
        return true;
    }
 
    std::string t = type;
    std::erase(t, ' ');
    return t == "BOOL" || t == "DWORD" || t == "int" || t == "LONG" || t == "UINT" || t == "ULONG" || t == "float" ||
           t == "double" || t == "LPCSTR" || t == "LPSTR" || t == "constchar*" || t == "LPCWSTR" || t == "LPWSTR" ||
           t == "constwchar_t*";
}
 
std::string trim(const std::string &str)
{
    size_t start = str.find_first_not_of(" \t\r\n");
    if (start == std::string::npos)
    {
        return "";
    }
    size_t end = str.find_last_not_of(" \t\r\n");
    return str.substr(start, end - start + 1);
}
 
Function parseFunction(const std::string &line, int lineNumber)
{
    Function f;
    f.rawLine = line;
    f.lineNumber = lineNumber;
 
    std::string clean = line;
    std::erase(clean, ';');
 
    size_t paren = clean.find('(');
    if (paren == std::string::npos)
    {
        return f;
    }
 
    std::string retAndName = clean.substr(0, paren);
    std::string paramStr = clean.substr(paren + 1, clean.find(')') - paren - 1);
 
    std::istringstream iss(retAndName);
    iss >> f.returnType >> f.name;
 
    paramStr = trim(paramStr);
    if (paramStr.empty() || paramStr == "void")
    {
        return f;
    }
 
    std::istringstream pstream(paramStr);
    std::string        param;
    while (std::getline(pstream, param, ','))
    {
        param = trim(param);
        if (param.empty())
        {
            continue;
        }
 
        std::istringstream ps(param);
        Param              p;
        ps >> p.type >> p.name;
 
        if (!isSupportedParam(p.type))
        {
            f.returnType.clear();
            break;
        }
 
        f.params.push_back(p);
    }
 
    return f;
}
 
void generateWrapper(const Function &f, std::ostream &out)
{
    if (f.returnType.empty())
    {
        return;
    }
 
    out << "// " << f.rawLine << " @ln:" << f.lineNumber << "\n";
    out << "static PhasorValue win32_" << f.name
        << "([[maybe_unused]] PhasorVM* vm, [[maybe_unused]] int argc, [[maybe_unused]] const PhasorValue* argv) {\n";
 
    for (size_t i = 0; i < f.params.size(); ++i)
    {
        const auto &p = f.params[i];
 
        if (isHandleType(p.type))
        {
            out << "    " << p.type << " " << p.name << " = HandleSystem::resolve<" << p.type << ">(phasor_to_int(argv["
                << i << "]));\n";
            continue;
        }
 
        std::string conv;
        if (p.type == "BOOL")
        {
            conv = "phasor_to_bool(argv[" + std::to_string(i) + "])";
        }
        else if (p.type == "DWORD" || p.type == "int" || p.type == "LONG" || p.type == "UINT" || p.type == "ULONG")
        {
            conv = "(" + p.type + ")phasor_to_int(argv[" + std::to_string(i) + "])";
        }
        else if (p.type == "float" || p.type == "double")
        {
            conv = "(" + p.type + ")phasor_to_float(argv[" + std::to_string(i) + "])";
        }
        else if (p.type == "LPCSTR" || p.type == "constchar*")
        {
            conv = "(const char*)phasor_to_string(argv[" + std::to_string(i) + "])";
        }
        else if (p.type == "LPSTR")
        {
            conv = "(char*)phasor_to_string(argv[" + std::to_string(i) + "])";
        }
        else if (p.type == "LPCWSTR" || p.type == "constwchar_t*")
        {
            conv = "(const wchar_t*)phasor_to_string(argv[" + std::to_string(i) + "])";
        }
        else
        {
            conv = "(wchar_t*)phasor_to_string(argv[" + std::to_string(i) + "])";
        }
 
        out << "    " << p.type << " " << p.name << " = " << conv << ";\n";
    }
 
    out << "    auto result = " << f.name << "(";
    for (size_t i = 0; i < f.params.size(); ++i)
    {
        if (i != 0u)
        {
            out << ", ";
        }
        out << f.params[i].name;
    }
    out << ");\n";
 
    if (isHandleType(f.returnType))
    {
        out << "    auto id = HandleSystem::store(result);\n";
        out << "    return phasor_make_int(id);\n";
    }
    else if (f.returnType == "BOOL")
    {
        out << "    return phasor_make_bool(result);\n";
    }
    else if (f.returnType == "float" || f.returnType == "double")
    {
        out << "    return phasor_make_float(result);\n";
    }
    else if (f.returnType == "DWORD" || f.returnType == "int" || f.returnType == "LONG" || f.returnType == "UINT" ||
             f.returnType == "ULONG")
    {
        out << "    return phasor_make_int(result);\n";
    }
    else
    {
        out << "    return phasor_make_null();\n";
    }
 
    out << "}\n\n";
}
 
int main(int argc, char **argv)
{
    std::string inputFile = "winapi.h";
    std::string outputFile = "phasor_winapi.cpp";
 
    if (argc >= 2)
    {
        inputFile = argv[1];
    }
    if (argc >= 4 && std::string(argv[2]) == "-o")
    {
        outputFile = argv[3];
    }
 
    std::ifstream infile(inputFile);
    std::ofstream outfile(outputFile);
 
    outfile << "#define PHASOR_FFI_BUILD_DLL\n";
    outfile << "#include <PhasorFFI.h>\n";
    outfile << "#include <windows.h>\n";
    outfile << "#include \"../src/Bindings/win32/handle.hpp\"\n\n";
    outfile << "// =====BEGIN PATCHES=====\n";
    for (const auto &patch : PATCHES)
    {
        outfile << patch << "\n";
    }
    outfile << "// ======END PATCHES======\n\n";
 
    std::string           line;
    int                   lineNumber = 0;
    std::vector<Function> funcs;
 
    while (std::getline(infile, line))
    {
        lineNumber++;
        if (line.empty())
        {
            continue;
        }
 
        Function f = parseFunction(line, lineNumber);
        if (!f.returnType.empty())
        {
            funcs.push_back(f);
        }
    }
 
    for (const auto &f : funcs)
    {
        generateWrapper(f, outfile);
    }
 
    outfile << "PHASOR_FFI_EXPORT void phasor_plugin_entry(const PhasorAPI* api, PhasorVM* vm) {\n";
    for (const auto &f : funcs)
    {
        outfile << "    api->register_function(vm, \"win32_" << f.name << "\", win32_" << f.name << ");\n";
    }
    outfile << "}\n";
}