8bitexe.h

#ifndef _8BITEXE_H
#define _8BITEXE_H
 
#include <algorithm>
#include "binary.h"
#include "../common.h"
#include "../dumper/dumper.h"
#include "../linker/module.h"
#include "../linker/options.h"
#include "../linker/reader.h"
#include "../linker/segment.h"
#include "../linker/writer.h"
 
/* TODO: this is all pretty much preliminary */
/* TODO: combine into binary.h? */
 
namespace Binary
{
    class AppleFormat : public Binary::GenericBinaryFormat
    {
    public:
        /* TODO: untested */
 
        /* TODO: enable setting the base address as a parameter */
        /* TODO: SYS files are pure binary loaded at 0x2000 */
 
        AppleFormat(uint64_t default_base_address = 0x0803, std::string default_extension = ".bin")
            : GenericBinaryFormat(default_base_address, default_extension)
        {
        }
 
        void ReadFile(Linker::Reader& rd) override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(Linker::Writer& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
    };
 
    class AtariFormat : public GenericBinaryFormat
    {
    public:
        /* exe, obj, com are also used */
        AtariFormat(uint64_t default_base_address = 0, std::string default_extension = ".xex")
            : GenericBinaryFormat(default_base_address, default_extension)
        {
        }
 
        struct Segment
        {
        public:
            enum segment_type : uint16_t
            {
                SIGNATURE_LOW = 0xFFFA,
                SDX_FIXED = 0xFFFA,
                SDX_SYMREQ = 0xFFFB,
                SDX_SYMDEF = 0xFFFC,
                SDX_FIXUPS = 0xFFFD,
                SDX_RAMALLOC = 0xFFFE,
                SDX_POSIND = 0xFFFE,
                ATARI_SEGMENT = 0xFFFF,
            };
            segment_type header_type = ATARI_SEGMENT;
            bool header_type_optional = false;
            uint16_t address = 0;
            uint8_t block_number = 0;
            enum control_byte_type : uint8_t
            {
                CB_CONVRAM = 0x00,
                CB_SYSEXTAREA = 0x02,
                CB_PROGEXTAREA = 0x04,
                CB_PAGEALIGNED = 0x40,
                CB_RAMALLOC = 0x80,
            };
            control_byte_type control_byte = control_byte_type(0);
            uint16_t size = 0;
            char symbol_name[8] = { };
            std::shared_ptr<Linker::Image> image;
            std::set<uint16_t> relocations; // TODO: multiple blocks?
 
            Segment(bool header_type_optional = true)
                : header_type(ATARI_SEGMENT), header_type_optional(header_type_optional)
            {
            }
 
            Segment(uint16_t header_type)
                : header_type(segment_type(header_type)), header_type_optional(false)
            {
            }
 
            offset_t GetSize() const;
 
            void ReadFile(Linker::Reader& rd);
 
            void WriteFile(Linker::Writer& wr) const;
 
            void ReadRelocations(Linker::Reader& rd);
 
            void WriteRelocations(Linker::Writer& wr) const;
        };
 
        std::vector<std::unique_ptr<Segment>> segments;
 
        static const uint16_t LOADER_ADDRESS = 0x02E2;
 
        static const uint16_t ENTRY_ADDRESS = 0x02E0;
 
        bool HasEntryPoint() const;
        void AddEntryPoint(uint16_t entry);
 
        void OnNewSegment(std::shared_ptr<Linker::Segment> segment) override;
 
        void ProcessModule(Linker::Module& module) override;
 
        void ReadFile(Linker::Reader& rd) override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(Linker::Writer& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
    };
 
    class CommodoreFormat : public GenericBinaryFormat
    {
    public:
        /* TODO */
 
        static const uint16_t BASIC_START = 0x0801;
 
        enum
        {
            BASIC_SYS = 0x9E, /* BASIC token */
        };
 
        std::shared_ptr<Linker::Segment> loader; /* loader routine in BASIC */
 
        void Clear() override;
 
        ~CommodoreFormat()
        {
            Clear();
        }
 
        void SetupDefaultLoader();
 
        void ProcessModule(Linker::Module& module) override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(Linker::Writer& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
 
        using Linker::OutputFormat::GetDefaultExtension;
        std::string GetDefaultExtension(Linker::Module& module, std::string filename) const override;
    };
 
    class PRLFormat;
 
    class CPM3Format : public GenericBinaryFormat
    {
    public:
        class CPM3OptionCollector : public Linker::OptionCollector
        {
        public:
            Linker::Option<std::optional<std::vector<std::string>>> rsx_file_names{"rsx", "List of filenames to append as Resident System Extensions"};
 
            CPM3OptionCollector()
            {
                InitializeFields(rsx_file_names);
            }
        };
 
        uint8_t preinit_code[10] = { 0xC9 }; /* z80 return instruction */
        bool loader_active = true;
        struct rsx_record
        {
            std::string rsx_file_name;
            std::string name;
            uint16_t offset = 0;
            uint16_t length = 0;
            bool nonbanked_only = false;
            std::shared_ptr<PRLFormat> module;
 
            void OpenAndPrepare();
        };
        std::vector<rsx_record> rsx_table;
 
        void Clear() override;
 
        CPM3Format()
            : GenericBinaryFormat(0x0100, ".com")
        {
        }
 
        ~CPM3Format()
        {
            Clear();
        }
 
        std::shared_ptr<Linker::OptionCollector> GetOptions() override;
 
        void SetOptions(std::map<std::string, std::string>& options) override;
 
        void ReadFile(Linker::Reader& rd) override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(Linker::Writer& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
 
        void CalculateValues() override;
    };
 
    class FLEXFormat : public GenericBinaryFormat
    {
    public:
        /* TODO: enable setting the base address, default should be ??? */
 
        struct Segment
        {
        public:
            uint16_t address;
            uint16_t size; /* it is supposed to be at most 255, but we can store larger segments by cutting them into pieces */
            std::shared_ptr<Linker::Image> image;
 
            void WriteFile(Linker::Writer& wr) const;
        };
 
        std::vector<std::unique_ptr<Segment>> segments;
 
        void OnNewSegment(std::shared_ptr<Linker::Segment> segment) override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(Linker::Writer& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
 
        using Linker::OutputFormat::GetDefaultExtension;
        std::string GetDefaultExtension(Linker::Module& module, std::string filename) const override;
    };
 
    class PRLFormat : public GenericBinaryFormat
    {
    public:
        class PRLOptionCollector : public Linker::OptionCollector
        {
        public:
            Linker::Option<bool> banked{"banked", "Generated .SPR file for banked CP/M 3"};
 
            PRLOptionCollector()
            {
                InitializeFields(banked);
            }
        };
 
        uint16_t zero_fill = 0;
        uint16_t load_address = 0; // TODO: implement
        uint16_t cslen = 0; // TODO: implement
 
        bool suppress_relocations;
 
        bool option_banked_bios = false; // TODO: make flag, implement behavior
 
        std::set<uint16_t> relocations;
 
        enum application_type
        {
            APPL_UNKNOWN,
            APPL_PRL,
            APPL_RSX,
            APPL_RSM,
            APPL_RSP,
            APPL_BRS,
            APPL_SPR,
            APPL_OVL,
        };
        application_type application;
 
        static uint16_t GetDefaultBaseAddress(application_type application);
        static std::string GetDefaultApplicationExtension(application_type application);
 
        PRLFormat(application_type application = APPL_PRL)
            :
                GenericBinaryFormat(GetDefaultBaseAddress(application), GetDefaultApplicationExtension(application)),
                suppress_relocations(application == APPL_OVL),
                application(application)
        {
        }
 
        std::shared_ptr<Linker::OptionCollector> GetOptions() override;
        void SetOptions(std::map<std::string, std::string>& options) override;
 
        std::unique_ptr<Script::List> GetScript(Linker::Module& module) override;
 
        void OnNewSegment(std::shared_ptr<Linker::Segment> segment) override;
 
        bool ProcessRelocation(Linker::Module& module, Linker::Relocation& rel, Linker::Resolution resolution) override;
 
        void ProcessModule(Linker::Module& module) override;
 
        void ReadFile(Linker::Reader& rd) override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(Linker::Writer& wr) const override;
 
        void ReadWithoutHeader(Linker::Reader& rd, uint16_t image_size);
 
        void WriteWithoutHeader(Linker::Writer& wr) const;
 
        void Dump(Dumper::Dumper& dump) const override;
    };
 
    class UZIFormat : public GenericBinaryFormat
    {
    public:
        /* TODO */
        bool uzi180_header;
        uint16_t entry;
 
        void ProcessModule(Linker::Module& module) override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(Linker::Writer& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
 
        using Linker::OutputFormat::GetDefaultExtension;
        std::string GetDefaultExtension(Linker::Module& module) const override;
    };
 
    class UZI280Format : public GenericBinaryFormat
    {
    public:
        std::shared_ptr<Linker::Image> code, data;
 
        void OnNewSegment(std::shared_ptr<Linker::Segment> segment) override;
 
        /* TODO: apparently both .code and .data are loaded at 0x0100 */
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(Linker::Writer& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
 
        using Linker::OutputFormat::GetDefaultExtension;
        std::string GetDefaultExtension(Linker::Module& module) const override;
    };
}
 
#endif /* _8BITEXE_H */