/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef CFA_RULE_H
#define CFA_RULE_H


#include "Types.h"


enum cfa_rule_type {
        CFA_RULE_UNDEFINED,
        CFA_RULE_SAME_VALUE,
        CFA_RULE_LOCATION_OFFSET,
        CFA_RULE_VALUE_OFFSET,
        CFA_RULE_REGISTER,
        CFA_RULE_LOCATION_EXPRESSION,
        CFA_RULE_VALUE_EXPRESSION
};


enum cfa_cfa_rule_type {
        CFA_CFA_RULE_UNDEFINED,
        CFA_CFA_RULE_REGISTER_OFFSET,
        CFA_CFA_RULE_EXPRESSION
};


struct CfaExpression {
        const void*     block;
        size_t          size;
};


class CfaRule {
public:
        inline                                          CfaRule();

                        cfa_rule_type           Type() const    { return fType; }

                        int64                           Offset() const          { return fOffset; }
                        uint32                          Register() const        { return fRegister; }
                        const CfaExpression& Expression() const { return fExpression; }

        inline  void                            SetToUndefined();
        inline  void                            SetToSameValue();
        inline  void                            SetToLocationOffset(int64 offset);
        inline  void                            SetToValueOffset(int64 offset);
        inline  void                            SetToRegister(uint32 reg);
        inline  void                            SetToLocationExpression(const void* block,
                                                                        size_t size);
        inline  void                            SetToValueExpression(const void* block,
                                                                        size_t size);

private:
                        cfa_rule_type           fType;
                        union {
                                int64                   fOffset;
                                uint32                  fRegister;
                                CfaExpression   fExpression;
                        };
};


class CfaCfaRule {
public:
        inline                                          CfaCfaRule();

                        cfa_cfa_rule_type       Type() const    { return fType; }

                        uint64                          Offset() const
                                                                        { return fRegisterOffset.offset; }
                        uint32                          Register() const
                                                                        { return fRegisterOffset.reg; }
                        const CfaExpression& Expression() const { return fExpression; }

        inline  void                            SetToUndefined();
        inline  void                            SetToRegisterOffset(uint32 reg, uint64 offset);
        inline  void                            SetToExpression(const void* block, size_t size);

        inline  void                            SetRegister(uint32 reg);
        inline  void                            SetOffset(uint64 offset);

private:
                        cfa_cfa_rule_type       fType;
                        union {
                                struct {
                                        uint64          offset;
                                        uint32          reg;
                                }                               fRegisterOffset;
                                CfaExpression   fExpression;
                        };
};


// #pragma mark - CfaRule


CfaRule::CfaRule()
        :
        fType(CFA_RULE_UNDEFINED)
{
}


void
CfaRule::SetToUndefined()
{
        fType = CFA_RULE_UNDEFINED;
}


void
CfaRule::SetToSameValue()
{
        fType = CFA_RULE_SAME_VALUE;
}


void
CfaRule::SetToLocationOffset(int64 offset)
{
        fType = CFA_RULE_LOCATION_OFFSET;
        fOffset = offset;
}


void
CfaRule::SetToValueOffset(int64 offset)
{
        fType = CFA_RULE_VALUE_OFFSET;
        fOffset = offset;
}


void
CfaRule::SetToRegister(uint32 reg)
{
        fType = CFA_RULE_REGISTER;
        fRegister = reg;
}


void
CfaRule::SetToLocationExpression(const void* block, size_t size)
{
        fType = CFA_RULE_LOCATION_EXPRESSION;
        fExpression.block = block;
        fExpression.size = size;
}


void
CfaRule::SetToValueExpression(const void* block, size_t size)
{
        fType = CFA_RULE_VALUE_EXPRESSION;
        fExpression.block = block;
        fExpression.size = size;
}


// #pragma mark - CfaCfaRule


CfaCfaRule::CfaCfaRule()
        :
        fType(CFA_CFA_RULE_UNDEFINED)
{
}


void
CfaCfaRule::SetToUndefined()
{
        fType = CFA_CFA_RULE_UNDEFINED;
}


void
CfaCfaRule::SetToRegisterOffset(uint32 reg, uint64 offset)
{
        fType = CFA_CFA_RULE_REGISTER_OFFSET;
        fRegisterOffset.reg = reg;
        fRegisterOffset.offset = offset;
}


void
CfaCfaRule::SetToExpression(const void* block, size_t size)
{
        fType = CFA_CFA_RULE_EXPRESSION;
        fExpression.block = block;
        fExpression.size = size;
}


void
CfaCfaRule::SetRegister(uint32 reg)
{
        fRegisterOffset.reg = reg;
}


void
CfaCfaRule::SetOffset(uint64 offset)
{
        fRegisterOffset.offset = offset;
}


#endif  // CFA_RULE_H