section.h

#ifndef SECTION_H
#define SECTION_H
 
#include <algorithm>
#include <iostream>
#include <string>
#include <variant>
#include <vector>
#include "../common.h"
#include "buffer.h"
 
namespace Linker
{
    class Position;
    class Reader;
    class Segment;
 
    typedef uint32_t ResourceIdentifier_Integer;
    typedef std::string ResourceIdentifier_String;
    typedef std::variant<ResourceIdentifier_String, ResourceIdentifier_Integer> ResourceIdentifier;
 
    class Section : public Buffer
    {
    public:
        std::string name;
    private:
        /* depends on whether it is zero filled or not */
        //std::vector<uint8_t> data; /* inherited */
        offset_t size = 0; /* only use if ZeroFilled */
    public:
        enum section_flags
        {
            Readable = 1 << 0,
            Writable = 1 << 1,
            Executable = 1 << 2,
            Mergeable = 1 << 3,
            ZeroFilled = 1 << 4, /* note: data should be empty if ZeroFilled is set */
            Fixed = 1 << 5,
            Resource = 1 << 6,
            Optional = 1 << 7,
            Stack = 1 << 8,
            Heap = 1 << 9,
            CustomFlag = 1 << 10,
        };
        section_flags flags;
    private:
        union
        {
            offset_t address; /* only use if fixed is true */
            offset_t align; /* only use if fixed is false */
        };
    public:
        offset_t bias = 0;
 
        ResourceIdentifier resource_type = "    ";
        ResourceIdentifier resource_id = uint16_t(0);
        ResourceIdentifier resource_language = uint16_t(0); // TODO: not currently used
 
        std::weak_ptr<Segment> segment;
        std::string collection_name;
 
        Section(std::string name, int flags = Readable)
            :
                name(name),
                flags(section_flags(flags)),
                align(1)
        {
        }
 
        static std::shared_ptr<Section> ReadFromFile(Reader& rd, std::string name, int flags = Readable);
        static std::shared_ptr<Section> ReadFromFile(Reader& rd, offset_t count, std::string name, int flags = Readable);
 
    private:
        void AlterFlags(bool state, unsigned flags_mask);
 
    public:
        void SetFlag(unsigned newflags);
 
        unsigned GetFlags() const;
 
        bool IsReadable() const;
 
        void SetReadable(bool state);
 
        bool IsWritable() const;
 
        void SetWritable(bool state);
 
        bool IsExecutable() const;
 
        void SetExecutable(bool state);
 
        bool IsMergeable() const;
 
        void SetMergeable(bool state);
 
        bool IsFixed() const;
 
        bool IsZeroFilled() const;
 
        virtual offset_t SetZeroFilled(bool is_zero_filled);
 
        offset_t GetAlign() const;
 
        void SetAlign(offset_t new_align);
 
        offset_t GetStartAddress() const;
 
        offset_t GetEndAddress() const;
 
        offset_t SetAddress(offset_t new_address);
 
        void ResetAddress(offset_t new_address);
 
        virtual offset_t Size() const;
 
        offset_t Expand(offset_t new_size);
 
        offset_t RealignEnd(offset_t align);
 
        size_t ReadData(size_t bytes, offset_t offset, void * buffer) const override;
 
        offset_t WriteData(size_t bytes, offset_t offset, const void * buffer);
 
        offset_t WriteWord(size_t bytes, offset_t offset, uint64_t value, EndianType endiantype);
 
        offset_t WriteWord(size_t bytes, offset_t offset, uint64_t value);
 
        offset_t WriteWord(size_t bytes, uint64_t value, EndianType endiantype);
 
        offset_t WriteWord(size_t bytes, uint64_t value);
 
        offset_t Append(const void * new_data, size_t length);
 
        offset_t Append(const char * new_data);
 
        offset_t Append(const Section& other);
 
        offset_t Append(Buffer& buffer);
 
        Position Start() const;
 
        Position Base() const;
 
        using Buffer::ReadFile;
        virtual void ReadFile(std::istream& in);
 
        void ReadFile(Reader& rd) override;
 
        using Buffer::WriteFile;
 
        virtual offset_t WriteFile(std::ostream& out, offset_t bytes, offset_t offset = 0) const;
 
        offset_t WriteFile(std::ostream& out) const;
 
        virtual void Reset();
    };
 
    std::ostream& operator<<(std::ostream& out, const Section& section);
}
 
#endif /* SECTION_H */