Compiler.cpp

Go to the documentation of this file.

#include "Compiler.hpp"
#include "../../Language/Phasor/Lexer/Lexer.hpp"
#include "../../Language/Phasor/Parser/Parser.hpp"
#include "../../Codegen/Bytecode/BytecodeSerializer.hpp"
#include "../../Codegen/CodeGen.hpp"
#include "../../Codegen/IR/PhasorIR.hpp"
#include <version.h>
#include <filesystem>
#include <fstream>
#include <sstream>
#include <iostream>
#include <print>
 
namespace Phasor
{
 
Compiler::Compiler(int argc, char *argv[])
{
    parseArguments(argc, argv);
}
 
int Compiler::run()
{
    if (m_args.inputFile.empty())
    {
        std::println(std::cerr, "Error: No input file provided\n");
        return 1;
    }
 
    if (m_args.irMode)
    {
        return compileToIR();
    }
 
    return compileToBytecode();
}
 
int Compiler::compileToBytecode()
{
    if (std::filesystem::path(m_args.inputFile).extension() == ".phsb")
    {
        std::println(std::cerr, "Error: Cannot compile a bytecode file (use phasordecomp)");
        return 1;
    }
 
    std::ifstream file(m_args.inputFile);
    if (!file.is_open())
    {
        println(std::cerr, "Could not open file: {}", m_args.inputFile);
        return 1;
    }
 
    std::stringstream buffer;
    buffer << file.rdbuf();
    std::string source = buffer.str();
 
    try
    {
        Lexer         lexer(source);
        Parser        parser(lexer.tokenize(), m_args.inputFile);
        auto          program = parser.parse();
        CodeGenerator codegen;
        auto          bytecode = codegen.generate(*program);
 
        if (m_args.outputFile.empty())
        {
            m_args.outputFile = m_args.inputFile;
            std::filesystem::path path(m_args.outputFile);
            path.replace_extension(".phsb");
            m_args.outputFile = path.string();
        }
 
        BytecodeSerializer serializer;
        if (!serializer.saveToFile(bytecode, m_args.outputFile))
        {
            std::println(std::cerr, "Failed to save bytecode to: {}", m_args.outputFile);
            return 1;
        }
 
        std::println("Compiled successfully: {} -> {}", m_args.inputFile, m_args.outputFile);
        return 0;
    }
    catch (const std::exception &e)
    {
        std::println(std::cerr, "Compilation Error: {}", e.what());
        return 1;
    }
}
 
int Compiler::compileToIR()
{
    if (std::filesystem::path(m_args.inputFile).extension() == ".phir")
    {
        std::println(std::cerr, "Error: Cannot compile a Phasor IR file (use phasorasm)");
        return 1;
    }
 
    std::ifstream file(m_args.inputFile);
    if (!file.is_open())
    {
        std::println(std::cerr, "Could not open file: {}\n", m_args.inputFile);
        return 1;
    }
 
    std::stringstream buffer;
    buffer << file.rdbuf();
    std::string source = buffer.str();
 
    try
    {
        Lexer         lexer(source);
        Parser        parser(lexer.tokenize(), m_args.inputFile);
        auto          program = parser.parse();
        CodeGenerator codegen;
        auto          bytecode = codegen.generate(*program);
 
        if (m_args.outputFile.empty())
        {
            m_args.outputFile = m_args.inputFile;
            std::filesystem::path path(m_args.outputFile);
            path.replace_extension(".phir");
            m_args.outputFile = path.string();
        }
 
        if (!PhasorIR::saveToFile(bytecode, m_args.outputFile))
        {
            std::println(std::cerr, "Failed to save Phasor IR to: {}", m_args.outputFile);
            return 1;
        }
 
        std::println("Compiled successfully to IR: {} -> {}", m_args.inputFile, m_args.outputFile);
        return 0;
    }
    catch (const std::exception &e)
    {
        std::println(std::cerr, "Compilation Error: {}", e.what());
        return 1;
    }
}
 
void Compiler::parseArguments(int argc, char *argv[])
{
    int defaultArgLocation = 1;
    for (int i = 1; i < argc; i++)
    {
        std::string arg = argv[i];
 
        if (arg == "-v" || arg == "--verbose")
        {
            m_args.verbose = true;
        }
        else if (arg == "-o" || arg == "--output")
        {
            if (i + 1 < argc)
            {
                m_args.outputFile = argv[++i];
            }
            else
            {
                std::print(std::cerr, "Error: {} requires an argument", arg);
                exit(1);
            }
        }
        else if (arg == "-i" || arg == "--ir")
        {
            m_args.irMode = true;
        }
        else if (arg == "-h" || arg == "--help")
        {
            showHelp(argv[0]);
            exit(0);
        }
        else
        {
            defaultArgLocation = i;
            m_args.inputFile = arg;
            break; // Stop parsing after finding the input file
        }
    }
    m_args.scriptArgv = argv + defaultArgLocation;
    m_args.scriptArgc = argc - defaultArgLocation;
}
 
void Compiler::showHelp(const std::string &programName)
{
    std::string filename = std::filesystem::path(programName).filename().string();
 
    std::println("Phasor Compiler v{}\n"
                 "(C) 2026 Daniel McGuire - Licensed under Apache 2.0\n\n"
                 "Usage:\n"
                 "  {} [options] <file.phs>\n\n"
                 "Options:\n  -o, --output FILE   Specify output file\n"
                 "  -i, --ir            Compile to IR format (.phir) instead of bytecode\n"
                 "  -v, --verbose       Enable verbose output\n"
                 "  -h, --help          Show this help message",
                 PHASOR_VERSION_STRING, filename);
}
 
} // namespace Phasor