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([](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;
        return status;
    }
 
    status = vm->run(bytecode);
 
    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::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\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;
}