binary.h

#ifndef BINARY_H
#define BINARY_H
 
#include "../common.h"
#include "../linker/module.h"
#include "../linker/segment.h"
#include "../linker/segment_manager.h"
#include "../linker/writer.h"
#include "mzexe.h"
 
/* TODO:
    refactor, use an Image for writing, introduce base_address and zero_fill fields? maybe only for specific subclasses (such as PRL)
*/
 
namespace Binary
{
    class GenericBinaryFormat : public virtual Linker::SegmentManager
    {
    public:
        /* * * General members * * */
 
        std::shared_ptr<Linker::Image> image = nullptr;
 
        void Clear() override;
 
        GenericBinaryFormat(uint64_t default_base_address = 0, std::string default_extension = "")
            : position_independent(false), base_address(default_base_address), extension(default_extension)
        {
        }
 
        GenericBinaryFormat(std::string default_extension)
            : position_independent(true), extension(default_extension)
        {
        }
 
        ~GenericBinaryFormat()
        {
            Clear();
        }
 
        void ReadFile(Linker::Reader& rd) override;
 
        offset_t ImageSize() const override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(Linker::Writer& wr) const override;
 
        void Dump(Dumper::Dumper& dump) const override;
 
        /* * * Writer members * * */
        bool position_independent;
        uint64_t base_address = 0;
        std::string extension;
 
        void OnNewSegment(std::shared_ptr<Linker::Segment> segment) override;
 
        void CreateDefaultSegments();
 
        virtual std::unique_ptr<Script::List> GetScript(Linker::Module& module);
 
        virtual bool ProcessRelocation(Linker::Module& module, Linker::Relocation& rel, Linker::Resolution resolution);
 
        void Link(Linker::Module& module);
 
        void ProcessModule(Linker::Module& module) override;
 
        void CalculateValues() override;
 
        void GenerateFile(std::string filename, Linker::Module& module) override;
 
        using Linker::OutputFormat::GetDefaultExtension;
        std::string GetDefaultExtension(Linker::Module& module, std::string filename) const override;
    };
 
    class BinaryFormat : public GenericBinaryFormat
    {
    public:
        /* * * General members * * */
 
        std::unique_ptr<Microsoft::MZFormat::PIF> pif = nullptr;
 
        void Clear() override;
 
        BinaryFormat(uint64_t default_base_address = 0, std::string default_extension = "")
            : GenericBinaryFormat(default_base_address, default_extension)
        {
        }
 
        BinaryFormat(std::string default_extension)
            : GenericBinaryFormat(default_extension)
        {
        }
 
        ~BinaryFormat()
        {
            Clear();
        }
 
        void ReadFile(Linker::Reader& rd) override;
 
        offset_t ImageSize() const override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(Linker::Writer& wr) const override;
 
        void Dump(Dumper::Dumper& dump) const override;
 
        /* * * Writer members * * */
        bool FormatSupportsSegmentation() const override;
 
        bool FormatIs16bit() const override;
 
        unsigned FormatAdditionalSectionFlags(std::string section_name) const override;
 
        enum memory_model_t
        {
            MODEL_DEFAULT,
            MODEL_TINY,
            MODEL_SMALL,
            MODEL_COMPACT,
            MODEL_LARGE,
        };
        memory_model_t memory_model = MODEL_DEFAULT;
 
        void SetModel(std::string model) override;
 
        std::unique_ptr<Script::List> GetScript(Linker::Module& module) override;
 
        void ProcessModule(Linker::Module& module) override;
    };
 
}
 
#endif /* BINARY_H */