aboutsummaryrefslogtreecommitdiff
path: root/src/clients/reconcilio/littlelf/elf_dynamic_section.hh
blob: 2e17a2e2d45a75f3e14dba7a18d0623433142489 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
#ifndef ELFDYNAMICSECTION_HH_
#define ELFDYNAMICSECTION_HH_

#include "elf_sections.hh"

#include <paludis/util/clone.hh>
#include <paludis/util/instantiation_policy.hh>
#include <paludis/util/private_implementation_pattern.hh>
#include <paludis/util/tr1_memory.hh>
#include <paludis/util/visitor.hh>
#include <paludis/util/wrapped_forward_iterator-fwd.hh>

#include <string>
#include <iosfwd>

template <typename ElfType_> class DynamicEntry;
template <typename ElfType_> class DynamicEntryUnknown;
template <typename ElfType_> class DynamicEntryValue;
template <typename ElfType_> class DynamicEntryPointer;
template <typename ElfType_> class DynamicEntryString;
template <typename ElfType_> class DynamicEntryFlag;

template <typename ElfType_>
struct DynamicEntryVisitorTypes :
    paludis::VisitorTypes<
        DynamicEntryVisitorTypes<ElfType_>,
        DynamicEntry<ElfType_>,
        DynamicEntryUnknown<ElfType_>,
        DynamicEntryValue<ElfType_>,
        DynamicEntryPointer<ElfType_>,
        DynamicEntryString<ElfType_>,
        DynamicEntryFlag<ElfType_>
        >
{
};

template <typename ElfType_>
class DynamicEntriesVisitor :
    public paludis::Visitor<DynamicEntryVisitorTypes<ElfType_> >
{
    public:
        virtual void visit(DynamicEntryUnknown<ElfType_> &) {}
        virtual void visit(DynamicEntryString<ElfType_> &)  {}
        virtual void visit(DynamicEntryPointer<ElfType_> &) {}
        virtual void visit(DynamicEntryValue<ElfType_> &)   {}
        virtual void visit(DynamicEntryFlag<ElfType_> &)    {}
};

template <typename ElfType_>
class DynamicEntry :
    public virtual paludis::AcceptInterface<DynamicEntryVisitorTypes<ElfType_> >,
    public virtual paludis::Cloneable<DynamicEntry<ElfType_> >
{
    private:
        std::string _tag_name;

    public:
        DynamicEntry(const std::string &);
        ~DynamicEntry();
        virtual void initialize(const typename ElfType_::DynamicEntry & entry) = 0;

        std::string tag_name() const
        {
            return _tag_name;
        }
};

template <typename ElfType_>
class DynamicEntryUnknown :
    public virtual DynamicEntry<ElfType_>,
    public paludis::AcceptInterfaceVisitsThis<DynamicEntryVisitorTypes<ElfType_> , DynamicEntryUnknown<ElfType_> >,
    public paludis::CloneUsingThis<DynamicEntry<ElfType_>, DynamicEntryUnknown<ElfType_> >
{
    public:
        DynamicEntryUnknown();
        virtual ~DynamicEntryUnknown();
        virtual void initialize(const typename ElfType_::DynamicEntry &);
};

template <typename ElfType_>
class DynamicEntryFlag :
    public virtual DynamicEntry<ElfType_>,
    public paludis::AcceptInterfaceVisitsThis<DynamicEntryVisitorTypes<ElfType_> , DynamicEntryFlag<ElfType_> >,
    public paludis::CloneUsingThis<DynamicEntry<ElfType_>, DynamicEntryFlag<ElfType_> >
{
    public:
        DynamicEntryFlag(const std::string &);
        ~DynamicEntryFlag();
        virtual void initialize(const typename ElfType_::DynamicEntry &);
};

template <typename ElfType_>
class DynamicEntryValue :
    public virtual DynamicEntry<ElfType_>,
    public paludis::AcceptInterfaceVisitsThis<DynamicEntryVisitorTypes<ElfType_> , DynamicEntryValue<ElfType_> >,
    public paludis::CloneUsingThis<DynamicEntry<ElfType_>, DynamicEntryValue<ElfType_> >
{
    private:
        typename ElfType_::DynamicValue _value;

    public:
        DynamicEntryValue(const std::string &);
        virtual ~DynamicEntryValue();
        virtual void initialize(const typename ElfType_::DynamicEntry & entry);

        typename ElfType_::DynamicValue operator() () const
        {
            return _value;
        }
};

template <typename ElfType_>
class DynamicEntryPointer :
    public virtual DynamicEntry<ElfType_>,
    public paludis::AcceptInterfaceVisitsThis<DynamicEntryVisitorTypes<ElfType_> , DynamicEntryPointer<ElfType_> >,
    public paludis::CloneUsingThis<DynamicEntry<ElfType_>, DynamicEntryPointer<ElfType_> >
{
    private:
        typename ElfType_::DynamicPointer _pointer;

    public:
        DynamicEntryPointer(const std::string &);
        virtual ~DynamicEntryPointer();
        virtual void initialize(const typename ElfType_::DynamicEntry &);

        typename ElfType_::DynamicPointer operator() () const
        {
            return _pointer;
        }
};

namespace littlelf_internals
{
    template <typename ElfType_> class DynEntriesStringResolvingVisitor;
}

template <typename ElfType_>
class DynamicEntryString :
    public virtual DynamicEntry<ElfType_>,
    public paludis::AcceptInterfaceVisitsThis<DynamicEntryVisitorTypes<ElfType_> , DynamicEntryString<ElfType_> >,
    public paludis::CloneUsingThis<DynamicEntry<ElfType_>, DynamicEntryString<ElfType_> >
{
    friend class littlelf_internals::DynEntriesStringResolvingVisitor<ElfType_>;

    private:
        typename ElfType_::DynamicValue _value;
        std::string _str;

    public:
        DynamicEntryString(const std::string &);
        virtual ~DynamicEntryString();
        virtual void initialize(const typename ElfType_::DynamicEntry &);

        std::string operator() () const
        {
            return _str;
        }

    private:
        void resolve_string(std::string str)
        {
            _str = str;
        }

        typename ElfType_::DynamicValue get_string_index() const
        {
            return _value;
        }
};

template <typename ElfType_>
class DynamicEntries :
    public paludis::InstantiationPolicy<DynamicEntries<ElfType_>, paludis::instantiation_method::SingletonTag>,
    private paludis::PrivateImplementationPattern<DynamicEntries<ElfType_> >
{
    using paludis::PrivateImplementationPattern<DynamicEntries>::_imp;
    friend class paludis::InstantiationPolicy<DynamicEntries, paludis::instantiation_method::SingletonTag>;

    public:
        void register_type(typename ElfType_::DynamicTag, paludis::tr1::shared_ptr<DynamicEntry<ElfType_> >);

        paludis::tr1::shared_ptr<DynamicEntry<ElfType_> > get_entry(typename ElfType_::DynamicTag) const;
        bool has_entry(typename ElfType_::DynamicTag) const;

    private:
        DynamicEntries();
        ~DynamicEntries();
};

template <typename ElfType_>
class DynamicSection :
    public Section<ElfType_>,
    public paludis::AcceptInterfaceVisitsThis<SectionVisitorTypes<ElfType_> , DynamicSection<ElfType_> >,
    private paludis::PrivateImplementationPattern<DynamicSection<ElfType_> >
{
    using paludis::PrivateImplementationPattern<DynamicSection>::_imp;

    public:
        DynamicSection(const typename ElfType_::SectionHeader &, std::istream &, bool);
        virtual ~DynamicSection();

        virtual std::string get_type() const;

        void resolve_entry_names(Section<ElfType_> &);

        typedef paludis::WrappedForwardIterator<enum EntryIteratorTag { }, DynamicEntry<ElfType_> > EntryIterator;
        EntryIterator entry_begin() const;
        EntryIterator entry_end() const;
};

#endif /*ELFDYNAMICSECTION_HH_*/