ScriptingRuntime.cpp

Go to the documentation of this file.

#include "ScriptingRuntime.hpp"
#include "../../Language/Pulsar/Lexer/Lexer.hpp"
#include "../../Language/Pulsar/Parser/Parser.hpp"
#include "../../Codegen/CodeGen.hpp"
#include "../../Frontend/Pulsar/Frontend.hpp"
#include "../../Runtime/Stdlib/StdLib.hpp"
#include "../../Runtime/VM/VM.hpp"
#include <filesystem>
#include <print>
#include <fstream>
#include <iostream>
#include <sstream>
#include <version.h>
#include <nativeerror.h>
 
namespace pulsar
{
 
Interpreter::Interpreter(int argc, char *argv[])
{
    parseArguments(argc, argv);
}
 
int Interpreter::run()
{
    if (m_args.inputFile.empty())
        return 0;
 
    return runSource();
}
 
int Interpreter::runSource()
{
    std::ifstream file(m_args.inputFile);
    if (!file.is_open())
    {
        std::cerr << "Could not open file: " << m_args.inputFile << "\n";
        return 1;
    }
 
    std::stringstream buffer;
    buffer << file.rdbuf();
    std::string source = buffer.str();
 
    try
    {
        auto vm = createVm();
        runSourceString(source, *vm);
    }
    catch (const std::exception &e)
    {
        std::string errorMsg = std::string(e.what()) + "\n";
        error(errorMsg);
        return 1;
    }
 
    return 0;
}
 
int Interpreter::runSourceString(const std::string &source, Phasor::VM &vm)
{
    Lexer                 lexer(source);
    Parser                parser(lexer.tokenize());
    Phasor::CodeGenerator codegen;
    auto                  program = parser.parse();
 
    if (m_args.verbose)
    {
        std::println("AST:");
        program->print();
        std::println();
    }
    auto bytecode = codegen.generate(*program);
 
    return vm.run(bytecode);
}
 
std::unique_ptr<Phasor::VM> Interpreter::createVm()
{
    auto vm = std::make_unique<Phasor::VM>();
    Phasor::StdLib::registerFunctions(*vm);
    Phasor::StdLib::argv = m_args.scriptArgv;
    Phasor::StdLib::argc = m_args.scriptArgc;
 
#if defined(_WIN32)
    vm->initFFI("plugins");
#elif defined(__APPLE__)
    vm->initFFI("/Library/Application Support/org.Phasor.Phasor/plugins");
#elif defined(__linux__)
    vm->initFFI("/opt/Phasor/plugins");
#endif
 
    vm->setImportHandler([this, vm_ptr = vm.get()](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();
        runSourceString(buffer.str(), *vm_ptr);
    });
 
    return vm;
}
 
void Interpreter::parseArguments(int argc, char *argv[])
{
    m_args.program = std::filesystem::path(argv[0]);
    int defaultArgLocation = 1;
    for (int i = 1; i < argc; i++)
    {
        std::string arg = argv[i];
 
        if (arg == "-v" || arg == "--verbose")
        {
            m_args.verbose = true;
        }
        if (arg == "-c" || arg == "--command")
        {
            auto vm = createVm();
            runSourceString(argv[i + 1], *vm);
            int ret = vm->getStatus();
            exit(ret);
        }
        else if (arg == "-h" || arg == "--help")
        {
            showHelp();
            exit(0);
        }
        else if (arg == "--version")
        {
            std::println(PHASOR_VERSION_STRING);
            exit(0);
        }
        else
        {
            defaultArgLocation = i;
            m_args.inputFile = arg;
            break;
        }
    }
    m_args.scriptArgv = argv + defaultArgLocation;
    m_args.scriptArgc = argc - defaultArgLocation;
}
 
void Interpreter::showHelp()
{
    std::println("Pulsar Scripting Language (Phasor v{})\n"
                 "(C) 2026 Daniel McGuire - Licensed under Apache 2.0\n\n"
                 "Usage:\n"
                 "  {} [inFile] [...script args]\n\n"
                 "Options:\n"
                 "  -v, --verbose       Enable verbose output (print AST)\n"
                 "  -h, --help          Show this help message\n"
                 "      --version       Print version string to stdout\n"
                 "  -c, --command       Run a source string from argv",
                 PHASOR_VERSION_STRING, m_args.program.stem().string());
}
 
} // namespace pulsar