SystemCallItem.hxx

#pragma once
 
// C++
#include <iosfwd>
#include <string_view>
#include <type_traits>
 
// cosmos
#include <cosmos/BitMask.hxx>
#include <cosmos/utils.hxx>
 
// clues
#include <clues/types.hxx>
 
namespace clues {
 
class SystemCall;
class Tracee;

enum class ItemType {
        PARAM_IN,     
        PARAM_OUT,    
        PARAM_IN_OUT, 
        RETVAL        
};


class CLUES_API SystemCallItem {
        friend SystemCall;
public: // types
 
 
        enum class Flag {

                DEFER_FILL = 1 << 0
        };
 
        using Flags = cosmos::BitMask<Flag>;
 
public: // functions


        explicit SystemCallItem(
                const ItemType type,
                const std::string_view short_name = {},
                const std::string_view long_name = {}) :
                        m_type{type},
                        m_short_name{short_name},
                        m_long_name{long_name}
        {}
 
        virtual ~SystemCallItem() {}
 
        auto type() const { return m_type; }
 
        bool isIn() const          { return m_type == ItemType::PARAM_IN; }
        bool isOut() const         { return m_type == ItemType::PARAM_OUT; }
        bool isInOut() const       { return m_type == ItemType::PARAM_IN_OUT; }
        bool isReturnValue() const { return m_type == ItemType::RETVAL; }

        void fill(const Tracee &proc, const Word word);

        bool needsUpdate() const { return m_type != ItemType::PARAM_IN; }

        std::string_view shortName() const { return m_short_name; }
        std::string_view longName() const {
                return m_long_name.empty() ? shortName() : m_long_name; }
 
        auto hasLongName() const { return !m_long_name.empty(); }


        virtual std::string str() const;

        bool isZero() const {
                return value() == Word::ZERO;
        }

        Word value() const { return m_val; }


        template <typename OTHER>
        OTHER valueAs() const {
                const auto baseval = cosmos::to_integral(m_val);
                if constexpr (std::is_enum_v<OTHER>) {
                        const auto baseret = static_cast<typename std::underlying_type<OTHER>::type>(baseval);
                        return OTHER{baseret};
                }
 
                if constexpr (std::is_pointer_v<OTHER>) {
                        return reinterpret_cast<OTHER>(baseval);
                }
 
                if constexpr (!std::is_enum_v<OTHER> && !std::is_pointer_v<OTHER>) {
                        return static_cast<OTHER>(baseval);
                }
        }
 
        ForeignPtr asPtr() const {
                return valueAs<ForeignPtr>();
        }
 
        Flags flags() const {
                return m_flags;
        }
 
        bool deferFill() const {
                return m_flags[Flag::DEFER_FILL];
        }
 
protected: // functions


        virtual void processValue(const Tracee &) {}


        virtual void updateData(const Tracee &t) {
                processValue(t);
        }

        void setSystemCall(const SystemCall &sc) { m_call = &sc; }
 
protected: // data

        const SystemCall *m_call = nullptr;
        const ItemType m_type;
        std::string_view m_short_name;
        std::string_view m_long_name;
        Word m_val;
        Flags m_flags;
};
 
} // end ns
 
CLUES_API std::ostream& operator<<(
        std::ostream &o,
        const clues::SystemCallItem &value
);