Frontend.cpp

Go to the documentation of this file.

#include "../../Language/Pulsar/Lexer/Lexer.hpp"
#include "../../Language/Pulsar/Parser/Parser.hpp"
#include "../../Codegen/IR/PhasorIR.hpp"
#include "../../Runtime/Stdlib/StdLib.hpp"
#include "../../Runtime/VM/VM.hpp"
 
#include <fstream>
#include <print>
#include <sstream>
#include <string>
#include <version.h>
#include <sscanf.h>
 
#include "Frontend.hpp"
#include <nativeerror.h>
 
bool startsWith(const std::string &input, const std::string &prefix)
{
    if (input.size() >= prefix.size() && input.compare(0, prefix.size(), prefix) == 0)
    {
        return true;
    }
    return false;
}
 
int pulsar::Frontend::runScript(const std::string &source, Phasor::VM *vm)
{
    int           status = 0;
    bool          ownVM = false;
    CodeGenerator codegen;
    Lexer         lexer(source);
    Parser        parser(lexer.tokenize());
 
    auto program = parser.parse();
    auto bytecode = codegen.generate(*program);
 
    if (vm == nullptr)
    {
        ownVM = true;
        vm = new VM();
        StdLib::registerFunctions(*vm);
    }
 
#if defined(_WIN32)
    vm->initFFI("plugins");
#elif defined(__APPLE__)
    vm->initFFI("/Library/Application Support/org.Phasor.Phasor/plugins");
#elif defined(__linux__)
    vm->initFFI("/usr/lib/phasor/plugins/");
#endif
 
    vm->setImportHandler([vm](const std::filesystem::path &path) {
        std::ifstream file(path);
        if (!file.is_open())
        {
            throw std::runtime_error("Could not open imported file: " + path.string());
        }
        std::stringstream buffer;
        buffer << file.rdbuf();
        runScript(buffer.str(), vm);
    });
 
    try
    {
        status = vm->run(bytecode);
 
        if (status != 0)
        {
            if (!ownVM)
            {
                vm->resetStatus();
                vm->reset(true, false, false);
            }
        }
    }
    catch (...)
    {
        if (ownVM)
            delete vm;
        throw;
    }
 
    if (ownVM)
        delete vm;
 
    return status;
}
 
int pulsar::Frontend::runRepl(Phasor::VM *vm)
{
    int           status = 0;
    bool          ownVM = false;
    CodeGenerator codegen;
 
    if (vm == nullptr)
    {
        ownVM = true;
        vm = new VM();
        StdLib::registerFunctions(*vm);
    }
 
#if defined(_WIN32)
    vm->initFFI("plugins");
#elif defined(__APPLE__)
    vm->initFFI("/Library/Application Support/org.Phasor.Phasor/plugins");
#elif defined(__linux__)
    vm->initFFI("/usr/lib/phasor/plugins/");
#endif
 
    vm->setImportHandler([](const std::filesystem::path &path) {
        std::ifstream file(path);
        if (!file.is_open())
        {
            throw std::runtime_error("Could not open imported file: " + path.string());
        }
        std::stringstream buffer;
        buffer << file.rdbuf();
        runScript(buffer.str());
    });
 
    if (status != 0)
    {
        if (ownVM)
            delete vm;
        std::println(std::cerr, "Failed to create FFI handler!");
        return status;
    }
 
    std::unordered_map<std::string, int> globalVars;
    int                                  nextVarIdx = 0;
    std::string                          line;
    bool                                 cleanExit = false;
 
    std::println("Pulsar REPL (using Phasor VM v{})\n"
                 "(C) 2026 Daniel McGuire - Licensed under Apache 2.0\n\n"
                 "Type 'exit()' to quit. Function declarations will not work.",
                 PHASOR_VERSION_STRING);
 
    while (true)
    {
        try
        {
            std::print("\n> ");
            if (!std::getline(std::cin, line))
                break;
 
            if (startsWith(line, "exit"))
            {
                cleanExit = true;
                break;
            }
            if (line.empty())
            {
                std::println(std::cerr, "Empty line");
                continue;
            }
 
            Lexer  lexer(line);
            Parser parser(lexer.tokenize());
 
            auto program = parser.parse();
            auto bytecode = codegen.generate(*program, globalVars, nextVarIdx, true);
 
            globalVars = bytecode.variables;
            nextVarIdx = bytecode.nextVarIndex;
 
            status = vm->run(bytecode);
        }
        catch (const std::exception &e)
        {
            std::string errorMsg = std::string(e.what()) + " | " + vm->getInformation() + "\n";
            error(errorMsg);
        }
    }
 
    if (ownVM)
        delete vm;
 
    if (cleanExit)
        return 0;
 
    return status;
}