Frontend.cpp

Go to the documentation of this file.

#include "../../Language/Phasor/Lexer/Lexer.hpp"
#include "../../Language/Phasor/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>
 
int Phasor::Frontend::runScript(const std::string &source, VM *vm, const std::filesystem::path &path, bool verbose)
{
    int           status = 0;
    bool          ownVM = false;
    CodeGenerator codegen;
    Lexer         lexer(source);
    Parser        parser(lexer.tokenize());
    if (!path.empty() && std::filesystem::exists(path))
    {
        parser.setSourcePath(path);
    }
 
    auto program = parser.parse();
#ifndef TRACING
    if (verbose)
    {
#else
    (void)verbose;
#endif
        std::println("AST:");
        program->print();
        std::println("");
#ifndef TRACING
    }
#endif
    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, path);
    });
 
    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 Phasor::Frontend::runRepl(VM *vm, bool verbose)
{
    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([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, path);
    });
 
    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("Phasor 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 (line.starts_with("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();
#ifndef TRACING
            if (verbose)
            {
#else
            (void)verbose;
#endif
                std::println("AST:");
                program->print();
                std::println("");
#ifndef TRACING
            }
#endif
            auto bytecode = codegen.generate(*program, globalVars, nextVarIdx, true);
 
            globalVars = bytecode.variables;
            nextVarIdx = bytecode.nextVarIndex;
 
            status = vm->run(bytecode);
        }
        catch (const std::exception &e)
        {
            error(std::format("{}\n", e.what()));
        }
    }
 
    if (ownVM)
        delete vm;
 
    if (cleanExit)
        return 0;
 
    return status;
}