main.cpp

#include <iostream>
#include <fstream>
#include <string>
#include "ast.h"

extern FILE* yyin;
extern int yyparse();
extern Program* program;

void usage() {
    std::cerr << "Usage: linguo [options] file.linguo" << std::endl;
    std::cerr << "Options:" << std::endl;
    std::cerr << "  -emit-ir          Output LLVM IR to file.ll" << std::endl;
    std::cerr << "  -emit-bc          Output LLVM bitcode to file.bc" << std::endl;
    std::cerr << "  -optimize         Run optimization passes" << std::endl;
    std::cerr << "  -run              Run the program immediately" << std::endl;
    std::cerr << "  -verbose          Print additional information" << std::endl;
    std::cerr << "  -tokens           Display parsed tokens" << std::endl;
    std::cerr << "  -help             Display this help message" << std::endl;
}

// Function to output the AST structure
void printAST(Program* program) {
    std::cout << "Parsed tokens:" << std::endl;
    std::cout << "==============" << std::endl;
    
    // Print out the program structure
    if (program) {
        program->printTokens();
    } else {
        std::cout << "No tokens parsed or empty program." << std::endl;
    }
    std::cout << "==============" << std::endl;
}

int main(int argc, char** argv) {
    // Parse command line arguments
    bool emitIR = false;
    bool emitBC = false;
    bool optimize = false;
    bool runProgram = false;
    bool verbose = false;
    bool showTokens = false;
    std::string inputFile;
    
    for (int i = 1; i < argc; i++) {
        std::string arg = argv[i];
        if (arg == "-emit-ir") {
            emitIR = true;
        } else if (arg == "-emit-bc") {
            emitBC = true;
        } else if (arg == "-optimize") {
            optimize = true;
        } else if (arg == "-run") {
            runProgram = true;
        } else if (arg == "-verbose") {
            verbose = true;
        } else if (arg == "-tokens") {
            showTokens = true;
        } else if (arg == "-help" || arg == "--help" || arg == "-h") {
            usage();
            return 0;
        } else if (arg[0] == '-') {
            std::cerr << "Unknown option: " << arg << std::endl;
            usage();
            return 1;
        } else {
            inputFile = arg;
        }
    }
    
    // Check for input file
    if (inputFile.empty()) {
        std::cerr << "No input file specified." << std::endl;
        usage();
        return 1;
    }
    
    // Open the input file
    FILE* file = fopen(inputFile.c_str(), "r");
    if (!file) {
        std::cerr << "Could not open input file: " << inputFile << std::endl;
        return 1;
    }
    
    // Set the input file for flex
    yyin = file;
    
    // Parse the input file
    if (verbose) {
        std::cout << "Parsing input file: " << inputFile << std::endl;
    }
    
    int parseResult = yyparse();
    
    // Close the input file
    fclose(file);
    
    if (parseResult != 0) {
        std::cerr << "Parsing failed." << std::endl;
        return 1;
    }
    
    if (verbose) {
        std::cout << "Parsing successful." << std::endl;
    }
    
    // Display tokens if requested
    if (showTokens) {
        printAST(program);
    }
    
    // Generate LLVM IR
    if (verbose) {
        std::cout << "Generating LLVM IR..." << std::endl;
    }
    
    CodeGenContext context;
    
    try {
        context.generateCode(program);
        
        // Always print IR in verbose mode
        if (verbose) {
            std::cout << "\nGenerated LLVM IR:\n" << std::endl;
            context.printIR();
        }
        
        // Run optimization passes if requested
        if (optimize) {
            if (verbose) {
                std::cout << "Running optimization passes..." << std::endl;
            }
            context.optimize();
            
            if (verbose) {
                std::cout << "Optimized IR:" << std::endl;
                context.printIR();
            }
        }
        
        // Output LLVM IR if requested
        if (emitIR) {
            std::string irFile = inputFile.substr(0, inputFile.find_last_of('.')) + ".ll";
            if (verbose) {
                std::cout << "Writing LLVM IR to: " << irFile << std::endl;
            }
            context.writeIR(irFile);
        }
        
        // Run the program if requested
        if (runProgram) {
            if (verbose) {
                std::cout << "\n=== Running program ===\n" << std::endl;
            }
            context.runJIT();
            if (verbose) {
                std::cout << "\n=== Program execution completed ===\n" << std::endl;
            }
        }
    } catch (const std::exception& ex) {
        std::cerr << "Error during code generation or execution: " << ex.what() << std::endl;
        return 1;
    } catch (...) {
        std::cerr << "Unknown error during code generation or execution" << std::endl;
        return 1;
    }
    
    // Clean up
    delete program;
    
    return 0;
}