operations.hpp

/* Copyright 2025 Jonathan S. Arney
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      https://github.com/jarney/gyoji/blob/master/LICENSE
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
#pragma once
 
#include <gyoji-misc/pointers.hpp>
#include <gyoji-mir/types.hpp>
#include <gyoji-context.hpp>
 
#include <string>
#include <map>
#include <vector>
 
namespace Gyoji::mir {
    class Operation {
    public:
    typedef enum {
        // Global symbols
        OP_FUNCTION_CALL,
        
        OP_DESTRUCTOR,
 
        OP_SYMBOL,
 
        // Cast operations
        OP_WIDEN_SIGNED,    // Widen a signed integer to a larger type.
 
        OP_WIDEN_UNSIGNED,  // Widen an unsigned integer to a larger type.
 
        OP_WIDEN_FLOAT,     // Widen a floating-point to a larger type.
 
        OP_ARRAY_INDEX,     // Pointer types -> Pointer Target type
 
        OP_DOT,             // class types -> Found member type
 
        // Variable access
        OP_LOCAL_DECLARE,   // N/A
 
        OP_LOCAL_UNDECLARE, // N/A
        
        OP_LOCAL_VARIABLE,
        
            // Literals
        OP_LITERAL_CHAR,
        OP_LITERAL_STRING,
        OP_LITERAL_INT,
        OP_LITERAL_FLOAT,
        OP_LITERAL_BOOL,
 
        OP_LITERAL_NULL,
 
        OP_ANONYMOUS_STRUCTURE,
        
        OP_ADDRESSOF,   // Any type -> Pointer type
        OP_DEREFERENCE, // Pointer types -> Pointer Target type
 
        OP_NEGATE,      // Numeric types -> Numeric type
 
        OP_BITWISE_NOT, // Integer types -> Integer Type
        OP_LOGICAL_NOT, // Boolean types -> Boolean
        
        OP_SIZEOF_TYPE, // Any type -> u64
 
        // Binary operations: arithmetic
        OP_ADD,         // Matching Numeric types -> Operand type
        OP_SUBTRACT,    // Matching Numeric types -> Operand type
        OP_MULTIPLY,    // Matching Numeric types -> Operand type
        OP_DIVIDE,      // Matching Integer types -> Operand type
 
        OP_MODULO,      // Matching Integer types -> Operand type
 
        // Binary operations: logical
        OP_LOGICAL_AND, // Boolean types -> Boolean
        OP_LOGICAL_OR,  // Boolean types -> Boolean
 
        // Binary operations: bitwise
        OP_BITWISE_AND, // Matching integer types -> Integer type
        OP_BITWISE_OR,  // Matching integer types -> Integer type
        
        OP_BITWISE_XOR, // Matching integer types -> Integer type
        OP_SHIFT_LEFT,  // Matching integer types -> Integer type
        OP_SHIFT_RIGHT, // Matching integer types -> Integer type
 
        // Binary operations: comparisons
        OP_COMPARE_LESS,  // Primitive types -> Boolean
        OP_COMPARE_GREATER,  // Primitive types -> Boolean
        OP_COMPARE_LESS_EQUAL,  // Primitive types -> Boolean
        OP_COMPARE_GREATER_EQUAL,  // Primitive types -> Boolean
        OP_COMPARE_NOT_EQUAL,  // Pointer types, Primitive types, recursive for class types.
        OP_COMPARE_EQUAL,  // Pointer types, Primitive types, recursive for class types.
        
        // Binary operations: assignments
        OP_ASSIGN,      // Primitive types, pointer types, recursive for class types.
 
        // Branch and flow control
        OP_JUMP_CONDITIONAL, // Boolean types
        OP_JUMP,
        OP_RETURN,
        OP_RETURN_VOID
    } OperationType;
 
    Operation(
        OperationType _type,
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result
        );
    Operation(
        OperationType _type,
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        size_t _operand
        );
    Operation(
        OperationType _type,
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        size_t _operand_a,
        size_t _operand_b
        );
    Operation(
        OperationType _type,
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        size_t _operand_a,
        size_t _operand_b,
        size_t _operand_c
        );
    virtual ~Operation();
 
    void dump(FILE *out, size_t operation_index) const;
 
    OperationType get_type() const;
 
    const std::vector<size_t> & get_operands() const;
 
    size_t get_result() const;
 
    bool is_terminating() const;
 
    std::vector<size_t> get_connections() const;
    const Gyoji::context::SourceReference & get_source_ref() const;
    
    virtual std::string get_description() const;
 
#if 0
    // XXX Is this really the way to handle this?
    bool get_readsfrom(size_t tmpvar) const;
    bool get_writesto(size_t tmpvar) const;
#endif
    protected:
    OperationType type;
    const Gyoji::context::SourceReference & src_ref;
    std::vector<size_t> operands;
    size_t result;
 
    void add_operand(size_t operand);
 
#if 0
    // XXX Is this really the way to handle this?
    bool contains(size_t tmpvar) const;
#endif
    };
 
    class OperationUnary : public Operation {
    public:
    OperationUnary(
        OperationType _type,
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        size_t _operand
        );
    virtual ~OperationUnary();
    size_t get_a() const;
    };
    
    class OperationCast : public OperationUnary {
    public:
    OperationCast(
        OperationType _type,
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        size_t _operand,
        const Type *_cast_type
        );
    virtual ~OperationCast();
    const Type* get_cast_type() const;
    protected:
    virtual std::string get_description() const;
    private:
    const Type *cast_type;
    };
 
    class OperationBinary : public Operation {
    public:
    OperationBinary(
        OperationType _type,
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        size_t _operand_a,
        size_t _operand_b
        );
    virtual ~OperationBinary();
    size_t get_a() const;
    size_t get_b() const;
    };
 
    class OperationGetMethod : public Operation {
    public:
    OperationGetMethod(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        size_t _object_to_call,
        std::string _method_name
        );
    virtual ~OperationGetMethod();
 
    const std::string & get_method() const;
    protected:
    virtual std::string get_description() const;
    private:
    size_t object_to_call;
    std::string method_name;
    };
 
    class OperationFunctionCall : public Operation {
    public:
    OperationFunctionCall(
        OperationType _type,
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        size_t _callee_tmpvar,
        std::vector<size_t> _arg_args
        );
    virtual ~OperationFunctionCall();
    };
 
    class OperationSymbol : public Operation {
    public:
    OperationSymbol(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        std::vector<size_t> _partial_operands,
        std::string _symbol_name
        );
    virtual ~OperationSymbol();
    const std::string & get_symbol_name() const;
    
    protected:
    virtual std::string get_description() const;
    private:
    const std::string symbol_name;
    };
 
    class OperationArrayIndex : public OperationBinary {
    public:
    OperationArrayIndex(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        size_t _array_tmpvar,
        size_t _index_tmpvar
        );
    virtual ~OperationArrayIndex();
    private:
    };
 
    class OperationDot : public OperationUnary {
    public:
    OperationDot(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        size_t _operand,
        std::string _member_name
        );
    virtual ~OperationDot();
    const std::string & get_member_name() const;
    
    protected:
    virtual std::string get_description() const;
    private:
    const std::string member_name;
    };
 
    class OperationLocalVariable : public Operation {
    public:
    OperationLocalVariable(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        std::string _symbol_name,
        const Type * _var_type);
    virtual ~OperationLocalVariable();
    const std::string & get_symbol_name() const;
    const Type * get_var_type() const;
    
    protected:
    virtual std::string get_description() const;
    private:
    const std::string symbol_name;
    const Type * var_type;
    };
 
    class OperationLiteralChar : public Operation {
    public:
    OperationLiteralChar(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        char _literal_char
        );
    virtual ~OperationLiteralChar();
    char get_literal_char() const;
    protected:
    virtual std::string get_description() const;
    private:
    const char literal_char;
    };
    class OperationLiteralString : public Operation {
    public:
    OperationLiteralString(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        std::string _literal_string
        );
    virtual ~OperationLiteralString();
    const std::string & get_literal_string() const;
    protected:
    virtual std::string get_description() const;
    private:
    const std::string literal_string;
    };
    class OperationLiteralInt : public Operation {
    public:
    OperationLiteralInt(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        Type::TypeType _literal_type,
        unsigned char _literal_u8
        );
    OperationLiteralInt(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        Type::TypeType _literal_type,
        unsigned short _literal_u16
        );
    OperationLiteralInt(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        Type::TypeType _literal_type,
        unsigned int _literal_u32
        );
    OperationLiteralInt(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        Type::TypeType _literal_type,
        unsigned long _literal_u64
        );
    OperationLiteralInt(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        Type::TypeType _literal_type,
        char _literal_i8
        );
    OperationLiteralInt(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        Type::TypeType _literal_type,
        short _literal_i16
        );
    OperationLiteralInt(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        Type::TypeType _literal_type,
        int _literal_i32
        );
    OperationLiteralInt(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        Type::TypeType _literal_type,
        long _literal_i64
        );
    virtual ~OperationLiteralInt();
    Type::TypeType get_literal_type() const;
    unsigned char get_literal_u8() const;
    unsigned short get_literal_u16() const;
    unsigned int get_literal_u32() const;
    unsigned long get_literal_u64() const;
 
    char get_literal_i8() const;
    short get_literal_i16() const;
    int get_literal_i32() const;
    long get_literal_i64() const;
 
    protected:
    virtual std::string get_description() const;
    private:
    Type::TypeType literal_type;
 
    // Should these be a union?
    unsigned char literal_u8;
    unsigned short literal_u16;
    unsigned int literal_u32;
    unsigned long literal_u64;
    char literal_i8;
    short literal_i16;
    int literal_i32;
    long literal_i64;
    };
    class OperationLiteralFloat : public Operation {
    public:
    OperationLiteralFloat(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        float _literal_float
        );
    OperationLiteralFloat(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        double _literal_float
        );
    virtual ~OperationLiteralFloat();
    float get_literal_float() const;
    double get_literal_double() const;
    Type::TypeType get_literal_type() const;
    protected:
    virtual std::string get_description() const;
    private:
    Type::TypeType literal_type;
    float literal_float_f32;
    double literal_float_f64;
    
    };
 
    class OperationLiteralBool : public Operation {
    public:
    OperationLiteralBool(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        bool _literal_bool
        );
    virtual ~OperationLiteralBool();
    bool get_literal_bool() const;
    protected:
    virtual std::string get_description() const;
    private:
    bool literal_bool;
    };
 
    class OperationLiteralNull : public Operation {
    public:
    OperationLiteralNull(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result
        );
    virtual ~OperationLiteralNull();
    protected:
    virtual std::string get_description() const;
    private:
    };
 
    class OperationAnonymousStructure : public Operation {
    public:
    OperationAnonymousStructure(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        std::vector<std::pair<std::string, size_t>> _fields
        );
    virtual ~OperationAnonymousStructure();
    const std::map<std::string, size_t> & get_fields() const;
    protected:
    virtual std::string get_description() const;
    private:
    std::map<std::string, size_t> fields;
    };
    
    class OperationSizeofType : public Operation {
    public:
    OperationSizeofType(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _result,
        const Type *_type
        );
    virtual ~OperationSizeofType();
 
    const Type * get_type() const;
    private:
    const Type* type;
    };
 
    class OperationJumpConditional : public Operation {
    public:
    OperationJumpConditional(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _operand,
        size_t _if_block,
        size_t _else_block
        );
    virtual ~OperationJumpConditional();
    size_t get_if_block() const;
    size_t get_else_block() const;
    protected:
    virtual std::string get_description() const;
    size_t if_block;
    size_t else_block;
    private:
    };
 
    class OperationJump : public Operation {
    public:
    OperationJump(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _block
        );
    virtual ~OperationJump();
    size_t get_jump_block() const;
    protected:
    virtual std::string get_description() const;
    size_t jump_block;
    private:
    };
 
    class OperationReturn : public Operation {
    public:
    OperationReturn(
        const Gyoji::context::SourceReference & _src_ref,
        size_t _operand
        );
    virtual ~OperationReturn();
    protected:
    virtual std::string get_description() const;
    };
    class OperationReturnVoid : public Operation {
    public:
    OperationReturnVoid(
        const Gyoji::context::SourceReference & _src_ref
        );
    virtual ~OperationReturnVoid();
    protected:
    virtual std::string get_description() const;
    };
 
    class OperationLocalDeclare : public Operation {
    public:
    OperationLocalDeclare(
        const Gyoji::context::SourceReference & _src_ref,
        std::string _variable,
        const Type *_variable_type
        );
    virtual ~OperationLocalDeclare();
    const std::string & get_variable() const;
    const Type *get_variable_type() const;
    protected:
    virtual std::string get_description() const;
    private:
    std::string variable;
    const Type *variable_type;
    };
    class OperationLocalUndeclare : public Operation {
    public:
    OperationLocalUndeclare(
        const Gyoji::context::SourceReference & _src_ref,
        std::string _variable
        );
    virtual ~OperationLocalUndeclare();
    protected:
    virtual std::string get_description() const;
    private:
    std::string variable;
    };
 
    
    void operation_static_init();
};