cpm86.h

#ifndef CPM86_H
#define CPM86_H
 
#include <array>
#include <map>
#include <set>
#include <vector>
#include "../common.h"
#include "../linker/linker.h"
#include "../linker/module.h"
#include "../linker/segment.h"
#include "../linker/writer.h"
#include "../dumper/dumper.h"
 
namespace DigitalResearch
{
    class CPM86Format : public virtual Linker::OutputFormat, public Linker::LinkerManager
    {
    public:
        /* * * General members * * */
 
        class Descriptor
        {
        public:
            enum group_type
            {
                Undefined,
                Code = 1,
                Data,
                Extra,
                Stack,
                Auxiliary1,
                Auxiliary2,
                Auxiliary3,
                Auxiliary4,
                SharedCode,
 
                Fixups = Auxiliary4, /* FlexOS 286 only */
                FastLoad = 0xFE, /* TODO */
                Libraries = 0xFF, /* TODO */
 
                ActualAuxiliary4 = 0x100 | Auxiliary4,
                ActualFixups = 0x200 | Fixups,
            };
            group_type type = Undefined;
            uint16_t size_paras = 0;
            uint16_t load_segment = 0;
            uint16_t min_size_paras = 0;
            uint16_t max_size_paras = 0;
            uint32_t offset = 0;
            std::shared_ptr<Linker::Writable> image = nullptr;
            bool attach_zero_page = false;
 
            virtual void Clear();
 
            ~Descriptor()
            {
                Clear();
            }
 
            virtual uint16_t GetSizeParas(const CPM86Format& module) const;
 
            void ReadDescriptor(Linker::Reader& rd);
 
            void WriteDescriptor(Linker::Writer& wr, const CPM86Format& module);
 
            virtual void WriteData(Linker::Writer& wr, const CPM86Format& module);
 
            std::string GetDefaultName();
 
            virtual void ReadData(Linker::Reader& rd, const CPM86Format& module);
        };
 
        struct relocation_source
        {
            number_t segment;
            offset_t offset;
 
            relocation_source()
                : segment(0), offset(0)
            {
            }
 
            relocation_source(size_t segment, offset_t offset)
                : segment(segment), offset(offset)
            {
            }
 
            bool operator<(const relocation_source& other) const;
        };
 
        struct Relocation
        {
            uint8_t source = 0;
            uint16_t paragraph = 0;
            uint8_t offset = 0;
            uint8_t target = 0;
 
            Relocation()
            {
            }
 
            Relocation(uint8_t source, uint16_t paragraph, uint16_t offset, uint8_t target)
                : source(source), paragraph(paragraph), offset(offset), target(target)
            {
            }
 
            Relocation(relocation_source source, uint8_t target)
                : source(source.segment), paragraph(source.offset >> 4), offset(source.offset & 0xF), target(target)
            {
            }
 
            operator bool() const;
 
            void Read(Linker::Reader& rd, CPM86Format& module, bool is_library = false);
 
            void Write(Linker::Writer& wr);
 
            relocation_source GetSource() const;
        };
 
        struct rsx_record
        {
            std::string name;
            uint16_t offset_record = 0;
            std::shared_ptr<CPM86Format> module = nullptr;
            static std::shared_ptr<CPM86Format> dynamic_module;
#define RSX_TERMINATE (std::shared_ptr<CPM86Format>(nullptr))
#define RSX_DYNAMIC   (::DigitalResearch::CPM86Format::rsx_record::dynamic_module)
 
            void Clear();
 
            void Read(Linker::Reader& rd);
 
            void ReadModule(Linker::Reader& rd);
 
            void Write(Linker::Writer& wr);
 
            void WriteModule(Linker::Writer& wr);
        };
 
        struct library_id
        {
            std::string name;
            uint16_t major_version = 0;
            uint16_t minor_version = 0;
            uint32_t flags = 0x11010000;
 
            library_id() { }
 
            library_id(std::string name, uint16_t major_version, uint16_t minor_version)
                : name(name), major_version(major_version), minor_version(minor_version)
            {
            }
 
            library_id(std::string name, uint16_t major_version, uint16_t minor_version, uint32_t flags)
                : name(name), major_version(major_version), minor_version(minor_version), flags(flags)
            {
            }
 
            void Write(Linker::Writer& wr);
 
            void Read(Linker::Reader& rd);
        };
 
        struct library : public library_id
        {
            std::vector<Relocation> relocations;
            uint16_t relocation_count = 0;
 
            uint16_t first_selector = 0;
            uint16_t unknown = 1;
 
            library()
            {
            }
 
            library(std::string name, uint16_t major_version, uint16_t minor_version)
                : library_id(name, major_version, minor_version)
            {
            }
 
            library(std::string name, uint16_t major_version, uint16_t minor_version, uint32_t flags)
                : library_id(name, major_version, minor_version, flags)
            {
            }
 
            void Write(Linker::Writer& wr);
 
            void WriteExtended(Linker::Writer& wr);
 
            void Read(Linker::Reader& rd);
 
            void ReadExtended(Linker::Reader& rd);
        };
 
        class LibraryDescriptor : public Descriptor
        {
        public:
            std::vector<library> libraries;
 
            void Clear() override;
 
            bool IsFastLoadFormat() const;
 
            uint16_t GetSizeParas(const CPM86Format& module) const override;
 
            void WriteData(Linker::Writer& wr, const CPM86Format& module) override;
 
            void ReadData(Linker::Reader& rd, const CPM86Format& module) override;
        };
 
        class FastLoadDescriptor : public Descriptor
        {
        public:
            uint16_t maximum_entries = 0;
            uint16_t first_free_entry = 0;
            uint16_t index_base = 0;
            uint16_t first_used_index = 0;
 
            struct ldt_descriptor
            {
                uint16_t limit;
                uint32_t address;
                uint8_t group;
                uint16_t reserved;
 
                void Read(Linker::Reader& rd);
 
                void Write(Linker::Writer& wr);
            };
 
            std::vector<ldt_descriptor> ldt;
 
            void Clear() override;
 
            uint16_t GetSizeParas(const CPM86Format& module) const override;
 
            void WriteData(Linker::Writer& wr, const CPM86Format& module) override;
 
            void ReadData(Linker::Reader& rd, const CPM86Format& module) override;
        };
 
        std::array<Descriptor, 8> descriptors;
        LibraryDescriptor library_descriptor;
        FastLoadDescriptor fastload_descriptor;
        library_id lib_id;
        std::vector<Relocation> relocations;
        uint32_t relocations_offset = 0;
        std::array<rsx_record, 8> rsx_table;
        uint32_t rsx_table_offset = 0;
        uint8_t flags = 0; /* TODO: make parameter */
        uint32_t file_offset = 0;
 
        enum
        {
            FLAG_FIXUPS = 0x80,
            FLAG_OPTIONAL_8087 = 0x40,
            FLAG_REQUIRED_8087 = 0x20,
            FLAG_RSX = 0x10,
            FLAG_DIRECT_VIDEO = 0x08
        };
 
        void Clear() override;
 
        enum format_type
        {
            FORMAT_UNKNOWN,
            FORMAT_8080,
            FORMAT_SMALL,
            FORMAT_COMPACT,
            FORMAT_FLEXOS, /* TODO: the documentation claims there are multiple models, is it about the model and not the format? */
        };
        format_type format = FORMAT_SMALL;
 
        CPM86Format(format_type format = FORMAT_UNKNOWN)
            : format(format)
        {
        }
 
        ~CPM86Format()
        {
            Clear();
        }
 
        uint16_t GetRelocationSizeParas() const;
 
        size_t CountValidGroups();
 
        number_t FindSegmentGroup(unsigned group) const;
 
        void CheckValidSegmentGroup(unsigned group);
 
        bool IsFastLoadFormat() const;
 
        void ReadRelocations(Linker::Reader& rd);
 
        void WriteRelocations(Linker::Writer& wr);
 
        void ReadFile(Linker::Reader& rd) override;
 
        void WriteFile(Linker::Writer& wr) override;
 
        offset_t GetFullFileSize() const;
 
        void Dump(Dumper::Dumper& dump) override;
 
        void CalculateValues() override;
 
        /* * * Writer members * * */
 
        bool shared_code = false; /* TODO: make parameter */
        bool option_no_relocation = false;
 
        enum memory_model_t
        {
            MODEL_DEFAULT,
            MODEL_TINY,
            MODEL_SMALL,
            MODEL_COMPACT,
            /* TODO: FlexOS model */
        };
        memory_model_t memory_model = MODEL_SMALL;
 
        bool FormatSupportsSegmentation() const override;
 
        bool FormatIs16bit() const override;
 
        unsigned FormatAdditionalSectionFlags(std::string section_name) const override;
 
        std::vector<std::shared_ptr<Linker::Segment>>& Segments();
 
        unsigned GetSegmentNumber(std::shared_ptr<Linker::Segment> segment);
 
        using LinkerManager::SetLinkScript;
 
        void SetModel(std::string model) override;
 
        void SetOptions(std::map<std::string, std::string>& options) override;
 
        std::unique_ptr<Script::List> GetScript(Linker::Module& module);
 
        void Link(Linker::Module& module);
 
        void ProcessModule(Linker::Module& module) override;
 
        void GenerateFile(std::string filename, Linker::Module& module) override;
 
        std::string GetDefaultExtension(Linker::Module& module, std::string filename) override;
    };
 
}
 
#endif /* CPM86_H */