dumper.h

#ifndef DUMPER_H
#define DUMPER_H
 
#include <iostream>
#include <iomanip>
#include <set>
#include <vector>
#include "../common.h"
#include "../linker/writable.h"
 
namespace Dumper
{
 
class Dumper;
 
template <typename ... Ts>
    class Display
{
public:
    virtual ~Display() { }
 
    virtual bool IsMissing(std::tuple<Ts...>& values)
    {
        //return is_missing(values);
        return values == std::tuple<Ts...>();
    }
 
    virtual void DisplayValue(Dumper& dump, std::tuple<Ts...> values) = 0;
};
 
class ChoiceDisplay : public Display<offset_t>
{
public:
    std::map<offset_t, std::string> names;
    std::string default_name;
 
    bool missing_on_value;
    offset_t missing_value;
 
    ChoiceDisplay(std::map<offset_t, std::string> names, std::string default_name, bool missing_on_value, offset_t missing_value)
        : names(names), default_name(default_name), missing_on_value(true), missing_value(missing_value)
    {
    }
 
    static std::shared_ptr<ChoiceDisplay> Make(std::map<offset_t, std::string> names, std::string default_name = "unknown")
    {
        return std::make_shared<ChoiceDisplay>(names, default_name, false, 0);
    }
 
    static std::shared_ptr<ChoiceDisplay> Make(std::map<offset_t, std::string> names, offset_t missing_value, std::string default_name = "unknown")
    {
        return std::make_shared<ChoiceDisplay>(names, default_name, true, missing_value);
    }
 
    static std::shared_ptr<ChoiceDisplay> Make(std::string on_true, std::string on_false)
    {
        std::map<offset_t, std::string> names;
        /* TODO: alternative?
            default_name = on_true;
            names[0] = on_false;
        */
        names[0] = on_false;
        names[1] = on_true;
        return std::make_shared<ChoiceDisplay>(names, "", false, 0);
    }
 
    static std::shared_ptr<ChoiceDisplay> Make(std::string on_true)
    {
        std::map<offset_t, std::string> names;
        /* TODO: alternative?
            default_name = on_true;
            missing_on_value = true;
            missing_value = 0;
        */
        names[1] = on_true;
        return std::make_shared<ChoiceDisplay>(names, "unknown", false, 0);
    }
 
    bool IsMissing(std::tuple<offset_t>& values) override;
    void DisplayValue(Dumper& dump, std::tuple<offset_t> values) override;
};
 
class HexDisplay : public Display<offset_t>
{
public:
    unsigned width;
    HexDisplay(unsigned width)
        : width(width)
    {
    }
 
    static std::shared_ptr<HexDisplay> Make(unsigned width = 8)
    {
        return std::make_shared<HexDisplay>(width);
    }
 
    void DisplayValue(Dumper& dump, std::tuple<offset_t> values) override;
};
 
class DecDisplay : public Display<offset_t>
{
public:
    std::string suffix;
    DecDisplay(std::string suffix)
        : suffix(suffix)
    {
    }
 
    static std::shared_ptr<DecDisplay> Make(std::string suffix = "")
    {
        return std::make_shared<DecDisplay>(suffix);
    }
 
    void DisplayValue(Dumper& dump, std::tuple<offset_t> values) override;
};
 
class SegmentedDisplay : public Display<offset_t, offset_t>
{
public:
    unsigned width;
    SegmentedDisplay(unsigned width)
        : width(width)
    {
    }
 
    static std::shared_ptr<SegmentedDisplay> Make(unsigned width = 4)
    {
        return std::make_shared<SegmentedDisplay>(width);
    }
 
    void DisplayValue(Dumper& dump, std::tuple<offset_t, offset_t> values) override;
};
 
class VersionDisplay : public Display<offset_t, offset_t>
{
public:
    std::string separator;
    VersionDisplay(std::string separator)
        : separator(separator)
    {
    }
 
    static std::shared_ptr<VersionDisplay> Make(std::string separator = ".")
    {
        return std::make_shared<VersionDisplay>(separator);
    }
 
    void DisplayValue(Dumper& dump, std::tuple<offset_t, offset_t> values) override;
};
 
template <typename ... Ts>
    class SectionedDisplay : public Display<offset_t, Ts...>
{
public:
    std::string suffix;
    std::shared_ptr<Display<Ts...>> offset_display;
 
    SectionedDisplay(std::string suffix, std::shared_ptr<Display<Ts...>> offset_display)
        : suffix(suffix), offset_display(offset_display)
    {
    }
 
    static std::shared_ptr<SectionedDisplay> Make(std::shared_ptr<Display<Ts...>> offset_display)
    {
        return Make("", offset_display);
    }
 
    static std::shared_ptr<SectionedDisplay> Make(std::string suffix, std::shared_ptr<Display<Ts...>> offset_display)
    {
        return std::make_shared<SectionedDisplay>(suffix, offset_display);
    }
 
    void DisplayValue(Dumper& dump, std::tuple<offset_t, Ts...> values) override;
};
 
class BitFieldDisplay : public HexDisplay, public std::enable_shared_from_this<BitFieldDisplay>
{
public:
    class BitField
    {
    public:
        unsigned offset, length;
        std::shared_ptr<Display<offset_t>> display;
        bool optional_field;
        BitField(unsigned offset, unsigned length, std::shared_ptr<Display<offset_t>> display, bool optional_field)
            : offset(offset), length(length), display(display), optional_field(optional_field)
        {
        }
 
        bool ShouldDisplay(std::tuple<offset_t>& values)
        {
            return !optional_field || !display->IsMissing(values);
        }
    };
 
    std::map<unsigned, std::unique_ptr<BitField>> bitfields;
 
    BitFieldDisplay(unsigned width)
        : HexDisplay(width)
    {
    }
 
    static std::shared_ptr<BitFieldDisplay> Make(unsigned width = 8)
    {
        return std::make_shared<BitFieldDisplay>(width);
    }
 
    std::shared_ptr<BitFieldDisplay> AddBitField(unsigned offset, unsigned length, std::shared_ptr<Display<offset_t>> display, bool optional_field)
    {
        bitfields[offset] = std::make_unique<BitField>(offset, length, display, optional_field);
        return shared_from_this();
    }
 
    void DisplayValue(Dumper& dump, std::tuple<offset_t> values) override;
};
 
class StringDisplay : public Display<std::string>
{
public:
    offset_t width;
    std::string open_quote, close_quote;
 
    StringDisplay(size_t width, std::string open_quote, std::string close_quote)
        : width(width), open_quote(open_quote), close_quote(close_quote)
    {
    }
 
    static std::shared_ptr<StringDisplay> Make(size_t width, std::string open_quote, std::string close_quote)
    {
        return std::make_shared<StringDisplay>(width, open_quote, close_quote);
    }
 
    static std::shared_ptr<StringDisplay> Make(size_t width, std::string quote = "")
    {
        return std::make_shared<StringDisplay>(width, quote, quote);
    }
 
    static std::shared_ptr<StringDisplay> Make(std::string quote = "")
    {
        return std::make_shared<StringDisplay>(-1, quote, quote);
    }
 
    bool IsMissing(std::tuple<std::string>& values) override;
    void DisplayValue(Dumper& dump, std::tuple<std::string> values) override;
 
    using Display<std::string>::IsMissing;
    bool IsMissing(std::tuple<offset_t>& values);
    using Display<std::string>::DisplayValue;
    void DisplayValue(Dumper& dump, std::tuple<offset_t> values);
};
 
class Field
{
public:
    std::string label;
    bool optional_field;
    bool internal;
 
    Field(std::string label, bool optional_field, bool internal)
        : label(label), optional_field(optional_field), internal(internal)
    {
    }
 
    virtual ~Field();
 
    virtual bool ShouldDisplay() = 0;
    virtual void DisplayValue(Dumper& dump) = 0;
};
 
template <typename ... Ts>
    class FieldOf : public Field
{
public:
    std::shared_ptr<Display<Ts...>> display;
    std::tuple<Ts...> values;
 
    FieldOf(std::string label, std::shared_ptr<Display<Ts...>> display, Ts... values, bool optional_field = false, bool internal = false)
        : Field(label, optional_field, internal), display{display}, values{values...}
    {
    }
 
    bool ShouldDisplay() override
    {
        return !internal && (!optional_field || !display->IsMissing(values));
    }
 
    void DisplayValue(Dumper& dump) override
    {
        display->DisplayValue(dump, values);
    }
};
 
class Container
{
public:
    std::string name;
 
    std::map<std::string, std::shared_ptr<Field>> field_names;
    std::vector<std::shared_ptr<Field>> fields;
 
    Container(std::string name = "")
        : name(name)
    {
    }
 
    std::shared_ptr<Field> FindField(std::string name)
    {
        auto it = field_names.find(name);
        if(it == field_names.end())
            return nullptr;
        return it->second;
    }
 
    template <typename T>
        T GetField(std::string name, offset_t default_value = T())
    {
        auto it = field_names.find(name);
        if(it == field_names.end())
            return default_value;
        if(auto field = std::dynamic_pointer_cast<FieldOf<T>>(it->second))
        {
            return std::get<0>(field->values);
        }
        return default_value;
    }
 
#if 0
    offset_t GetField(std::string name, int index, offset_t default_value)
    {
        auto it = field_names.find(name);
        if(it == field_names.end())
            return default_value;
        return it->second->values[index];
    }
#endif
 
    void AddField(std::shared_ptr<Field> field)
    {
        fields.push_back(field);
        field_names[field->label] = field;
    }
 
    void AddField(size_t index, std::shared_ptr<Field> field)
    {
        fields.insert(fields.begin() + index, field);
        field_names[field->label] = field;
    }
 
    template <typename D, typename ... Ts>
        void AddField(std::string label, std::shared_ptr<D> display, Ts... values)
    {
        AddField(std::make_shared<FieldOf<Ts...>>(label, display, values..., false, false));
    }
 
    template <typename D, typename ... Ts>
        void AddOptionalField(std::string label, std::shared_ptr<D> display, Ts... values)
    {
        AddField(std::make_shared<FieldOf<Ts...>>(label, display, values..., true, false));
    }
 
    template <typename D, typename ... Ts>
        void AddHiddenField(std::string label, std::shared_ptr<D> display, Ts... values)
    {
        AddField(std::make_shared<FieldOf<Ts...>>(label, display, values..., false, true));
    }
 
    template <typename D, typename ... Ts>
        void InsertField(size_t index, std::string label, std::shared_ptr<D> display, Ts... values)
    {
        AddField(index, std::make_shared<FieldOf<Ts...>>(label, display, values..., false, false));
    }
 
    template <typename D, typename ... Ts>
        void InsertOptionalField(size_t index, std::string label, std::shared_ptr<D> display, Ts... values)
    {
        AddField(index, std::make_shared<FieldOf<Ts...>>(label, display, values..., true, false));
    }
 
    template <typename D, typename ... Ts>
        void InsertHiddenField(size_t index, std::string label, std::shared_ptr<D> display, Ts... values)
    {
        AddField(index, std::make_shared<FieldOf<Ts...>>(label, display, values..., false, true));
    }
 
    virtual void Display(Dumper& dump);
};
 
class Region : public Container
{
public:
    Region(std::string name, offset_t offset, offset_t length, unsigned display_width)
        : Container(name)
    {
        AddField("Offset", HexDisplay::Make(display_width), offset);
        AddField("Length", HexDisplay::Make(display_width), length);
    }
 
    static std::shared_ptr<Region> Make(std::string name, offset_t offset, offset_t length, unsigned display_width)
    {
        return std::make_shared<Region>(name, offset, length, display_width);
    }
 
//  void Display(Dumper& dump);
};
 
class Entry : public Container
{
public:
    offset_t number;
    offset_t offset;
    unsigned display_width;
 
    Entry(std::string name, offset_t number, offset_t offset = offset_t(-1), unsigned display_width = 8)
        : Container(name), number(number), offset(offset), display_width(display_width)
    {
    }
 
    void Display(Dumper& dump) override;
};
 
class Block : public Region
{
public:
    unsigned offset_display_width;
    unsigned position_display_width;
    unsigned address_display_width;
 
    static char32_t encoding_default[256];
    static char32_t encoding_cp437[256];
    static char32_t encoding_st[256];
 
    std::shared_ptr<Linker::Writable> image;
 
    std::set<offset_t> signal_starts;
    std::set<offset_t> signal_ends;
 
    void AddSignal(offset_t off, offset_t len)
    {
        offset_t end = off + len - 1;
        signal_starts.insert(off);
        signal_ends.insert(end);
    }
 
    Block(std::string name, offset_t offset, std::shared_ptr<Linker::Writable> image, offset_t address, unsigned display_width,
            unsigned offset_display_width = 8, unsigned address_display_width = -1u, unsigned position_display_width = -1u)
        : Region(name, offset, image ? image->ActualDataSize() : 0, display_width),
            offset_display_width(offset_display_width),
            position_display_width(position_display_width != -1u ? position_display_width
                : address_display_width != -1u ? address_display_width : offset_display_width),
            address_display_width(address_display_width != -1u ? address_display_width : offset_display_width),
            image(image)
    {
        AddField("Address", HexDisplay::Make(display_width), address);
    }
 
    static std::shared_ptr<Block> Make(std::string name, offset_t offset, std::shared_ptr<Linker::Writable> image, offset_t address, unsigned display_width,
            unsigned offset_display_width = 8, unsigned address_display_width = -1u, unsigned position_display_width = -1u)
    {
        return std::make_shared<Block>(name, offset, image, address, display_width, offset_display_width, address_display_width, position_display_width);
    }
 
    void Display(Dumper& dump) override;
};
 
class Dumper
{
public:
    std::ostream& out;
    bool use_ansi;
 
    char32_t (* encoding)[256];
 
    Dumper(std::ostream& out)
        : out(out), use_ansi(true), encoding(nullptr)
    {
    }
 
    void SetEncoding(char32_t (& encoding)[256], bool force = false)
    {
        if(this->encoding == nullptr || force)
        {
            this->encoding = &encoding;
        }
    }
 
    void SetTitle(std::string title)
    {
        out << "=== " << title << " ===" << std::endl;
    }
 
//  std::vector<Field> fields;
 
    void PrintHex(offset_t value, unsigned width, std::string prefix = "0x")
    {
        out << prefix << std::hex << std::setw(width) << std::setfill('0') << value;
    }
 
#if 0
    void PrintHex(offset_t value, unsigned width, bool prefixed)
    {
        PrintHex(value, width, prefixed ? "0x" : "");
    }
#endif
 
    void PrintDec(offset_t value, std::string prefix = "#")
    {
        out << prefix << std::dec << value;
    }
 
#if 0
    void PrintDec(offset_t value, bool prefixed)
    {
        PrintDec(value, prefixed ? "#" : "");
    }
#endif
 
    void PutChar(char32_t c)
    {
        /* TODO: this should be customizable */
        if(c < 0x80)
        {
            out.put(c);
        }
        else if(c < 0x800)
        {
            out.put((c >> 6) | 0xC0);
            out.put((c & 0x3F) | 0x80);
        }
        else if(c < 0x10000)
        {
            out.put((c >> 12) | 0xE0);
            out.put(((c >> 6) & 0x3F) | 0x80);
            out.put((c & 0x3F) | 0x80);
        }
        else
        {
            out.put(((c >> 18) & 0x07) | 0xF0);
            out.put(((c >> 12) & 0x3F) | 0x80);
            out.put(((c >> 6) & 0x3F) | 0x80);
            out.put((c & 0x3F) | 0x80);
        }
    }
 
    void BeginUnderline()
    {
        if(use_ansi)
            out << "\33[4m";
    }
 
    void EndUnderline()
    {
        if(use_ansi)
            out << "\33[m";
    }
};
 
template <unsigned I, size_t ... Is, typename ... Ts>
    inline auto rest_(std::tuple<Ts...> elements, std::index_sequence<Is...> s)
{
    return std::make_tuple(std::get<I + Is>(elements)...);
}
 
template <unsigned I, typename ... Ts>
    inline auto rest(std::tuple<Ts...> elements)
{
    return rest_<I>(elements, std::make_index_sequence<sizeof...(Ts) - I>());
}
 
template <typename ... Ts>
    void SectionedDisplay<Ts...>::DisplayValue(Dumper& dump, std::tuple<offset_t, Ts...> values)
{
    dump.PrintDec(std::get<0>(values), "");
    dump.out << suffix << ':';
    offset_display->DisplayValue(dump, rest<1>(values));
}
 
}
 
#endif /* DUMPER_H */