CodeGen.hpp

Go to the documentation of this file.

#pragma once
#include "../AST/AST.hpp"
#ifndef CMAKE_PCH
#include <Value.hpp>
#endif
#include "../ISA/ISA.hpp"
#include <phsint.hpp>
#include <map>
#include <unordered_map>
#include <string>
#include <vector>
 
#include <platform.h>
 
namespace Phasor
{
struct Instruction
{
    OpCode  op;       
    i32 operand1; 
    i32 operand2; 
    i32 operand3; 
 
    // Default constructor
    Instruction() : op(OpCode::HALT), operand1(0), operand2(0), operand3(0)
    {
    }
 
    // Full constructor
    Instruction(OpCode op, i32 op1 = 0, i32 op2 = 0, i32 op3 = 0)
        : op(op), operand1(op1), operand2(op2), operand3(op3)
    {
    }
};

struct StructInfo
{
    std::string              name;            
    int                      firstConstIndex; 
    int                      fieldCount;      
    std::vector<std::string> fieldNames;      
};

struct Bytecode
{
    std::vector<Instruction>             instructions;        
    std::vector<Value>                   constants;           
    std::unordered_map<std::string, int> variables;           
    std::unordered_map<std::string, int> functionEntries;     
    std::unordered_map<std::string, int> functionParamCounts; 
    int                                  nextVarIndex = 0;    
 
    // Struct section (planned usage by future struct codegen)
    std::vector<StructInfo>              structs;       
    std::unordered_map<std::string, int> structEntries; 

    int addConstant(const Value &value)
    {
        constants.push_back(value);
        return static_cast<int>(constants.size()) - 1;
    }

    int addStringConstant(const std::string &s)
    {
        auto it = stringConstantCache.find(s);
        if (it != stringConstantCache.end())
        {
            return it->second;
        }
        int idx = addConstant(Value(s));
        stringConstantCache[s] = idx;
        return idx;
    }
 
    std::unordered_map<std::string, int> stringConstantCache; 

    int getOrCreateVar(const std::string &name)
    {
        auto it = variables.find(name);
        if (it != variables.end())
        {
            return it->second;
        }
        int index = nextVarIndex++;
        variables[name] = index;
        return index;
    }

    void emit(OpCode op, i32 op1 = 0, i32 op2 = 0, i32 op3 = 0)
    {
        instructions.emplace_back(op, op1, op2, op3);
    }
};

class CodeGenerator
{
  public:
    Bytecode generate(const AST::Program &program, const std::unordered_map<std::string, int> &existingVars = {},
                      int nextVarIdx = 0, bool replMode = false);
 
  private:
    Bytecode bytecode;       
    bool     isRepl = false; 
    // Inferred types for variables (simple, flow-insensitive mapping)
    std::unordered_map<std::string, ValueType> inferredTypes;
 
    // Register allocation for v2.0
    u8           nextRegister = 0; 
    std::vector<bool> registerInUse;    

    u8 allocateRegister()
    {
        for (size_t i = 0; i < MAX_REGISTERS; i++)
        {
            if (i >= registerInUse.size())
            {
                registerInUse.resize(i + 1, false);
            }
            if (!registerInUse[i])
            {
                registerInUse[i] = true;
                return static_cast<u8>(i);
            }
        }
        throw std::runtime_error("Out of registers");
    }

    void freeRegister(u8 reg)
    {
        if (reg < registerInUse.size())
        {
            registerInUse[reg] = false;
        }
    }

    void resetRegisters()
    {
        registerInUse.clear();
        nextRegister = 0;
    }

    static bool isLiteralExpression(const AST::Expression *expr, Value &outValue);

    ValueType inferExpressionType(const AST::Expression *expr, bool &known);
 
    void generateStatement(const AST::Statement *stmt);                          
    void generateExpression(const AST::Expression *expr, bool resultNeeded = true); 
    void generateVarDecl(const AST::VarDecl *varDecl);                 
    void generateExpressionStmt(const AST::ExpressionStmt *exprStmt);  
    void generatePrintStmt(const AST::PrintStmt *printStmt);           
    void generateImportStmt(const AST::ImportStmt *importStmt);        
    void generateExportStmt(const AST::ExportStmt *exportStmt);        
    void generateNumberExpr(const AST::NumberExpr *numExpr);           
    void generateStringExpr(const AST::StringExpr *strExpr);           
    void generateIdentifierExpr(const AST::IdentifierExpr *identExpr); 
    void generateUnaryExpr(const AST::UnaryExpr *unaryExpr);           
    void generateCallExpr(const AST::CallExpr *callExpr);              
    void generateBinaryExpr(const AST::BinaryExpr *binExpr);           
    void generateBlockStmt(const AST::BlockStmt *blockStmt);           
    void generateIfStmt(const AST::IfStmt *ifStmt);                    
    void generateWhileStmt(const AST::WhileStmt *whileStmt);           
    void generateForStmt(const AST::ForStmt *forStmt);                 
    void generateReturnStmt(const AST::ReturnStmt *returnStmt);        
    void generateUnsafeBlockStmt(
        const AST::UnsafeBlockStmt *unsafeStmt);                  
    void generateFunctionDecl(const AST::FunctionDecl *funcDecl); 
    void generateBooleanExpr(const AST::BooleanExpr *boolExpr);   
    void generateNullExpr(const AST::NullExpr *nullExpr);         
    void generateAssignmentExpr(
        const AST::AssignmentExpr *assignExpr); 
    void generateStructDecl(const AST::StructDecl *decl);
    void generateStructInstanceExpr(const AST::StructInstanceExpr *expr);
    void generateFieldAccessExpr(const AST::FieldAccessExpr *expr);
    void generatePostfixExpr(const AST::PostfixExpr *expr, bool resultNeeded = true);
    void generateBreakStmt();
    void generateContinueStmt();
    void generateSwitchStmt(const AST::SwitchStmt *switchStmt);
    void generateArrayLiteralExpr(const AST::ArrayLiteralExpr *arrayLit, bool resultNeeded);
    void generateArrayAccessExpr(const AST::ArrayAccessExpr *arrayAccess, bool resultNeeded);
 
    // Loop context for break/continue
    std::vector<int>              loopStartStack;     // Stack of loop start positions
    std::vector<std::vector<int>> breakJumpsStack;    // Stack of break jump positions to patch
    std::vector<std::vector<int>> continueJumpsStack; // Stack of continue jump positions to patch
 
    int switchCounter = 0; // Monotonic counter for unique switch temp variable names
};
 
} // namespace Phasor