8bitexe.h

#ifndef _8BITEXE_H
#define _8BITEXE_H
 
#include <algorithm>
#include "binary.h"
#include "macos.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 */
        bool dos33_header;
 
        /* 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 = "", bool dos33_header = true)
            : GenericBinaryFormat(default_base_address, default_extension), dos33_header(dos33_header)
        {
        }
 
        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 GSOutput : public Linker::OutputFormat
    {
    public:
        enum target_format_t
        {
            TARGET_NONE,
            TARGET_DATA_FORK,
            TARGET_RESOURCE_FORK,
            TARGET_APPLE_SINGLE,
            TARGET_APPLE_DOUBLE,
            // /** @brief Main file as a MacBinary */
            // TARGET_MAC_BINARY,
            // TODO: Binary II
        };
        target_format_t target;
 
        enum produce_format_t
        {
            PRODUCE_RESOURCE_FORK = 1 << 0,
            // /** @brief Places a Finder Information file under the directory .finf */
            // PRODUCE_FINDER_INFO = 1 << 1,
            PRODUCE_APPLE_DOUBLE = 1 << 2,
            // /** @brief Creates a MacBinary with the .mbin extension */
            // PRODUCE_MAC_BINARY = 1 << 3,
            PRODUCE_NAPS_SUFFIX = 1 << 4,
        };
        produce_format_t produce;
 
        /* the ProDOS file type */
        enum file_type_t : uint8_t
        {
            FILE_TYPE_BIN = 0x06,
            FILE_TYPE_SOS = 0x0C,
            FILE_TYPE_S16 = 0xB3,
            FILE_TYPE_EXE = 0xB5,
            FILE_TYPE_SYS = 0xFF,
        };
 
        unsigned apple_single_double_version = 2;
        /* Only relevant for version 1 */
        Apple::AppleSingleDouble::hfs_type home_file_system = Apple::AppleSingleDouble::HFS_UNDEFINED;
 
        //MacBinary::version_t macbinary_version = MacBinary::MACBIN3, macbinary_minimum_version = MacBinary::MACBIN2;
 
        GSOutput(target_format_t target = TARGET_DATA_FORK)
            : target(target),
            produce(target == TARGET_DATA_FORK ? PRODUCE_APPLE_DOUBLE
                : produce_format_t(0))
        {
        }
 
        GSOutput(target_format_t target, int produce)
            : target(target), produce(produce_format_t(produce))
        {
        }
 
        bool AddSupplementaryOutputFormat(std::string subformat) override;
 
    protected:
        enum container_format_t
        {
            CONTAINER_NONE,
            CONTAINER_APPLE_SINGLE,
            // /** @brief Use a MacBinary container as well as an AppleSingle container */
            // CONTAINER_MAC_BINARY,
        };
        container_format_t container = CONTAINER_NONE;
 
        std::shared_ptr<Apple::AppleSingleDouble> apple_single;
        // /** @brief Container for MacBinary */
        // std::shared_ptr<MacBinary> mac_binary;
 
        virtual void OnContainerCreated();
        virtual void OnCalculateValues();
        virtual void OnReadFile(Linker::Reader& rd);
        virtual offset_t OnWriteFile(Linker::Writer& wr) const;
        virtual void OnDump(Dumper::Dumper& dump) const;
 
    public:
        void GenerateFiles(std::string filename, std::shared_ptr<Contents> data_fork, std::shared_ptr<Contents> resource_fork, uint8_t file_type, uint16_t auxiliary_file_type);
 
        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 AppleDriver : public GSOutput
    {
    public:
        std::shared_ptr<AppleFormat> data_fork;
 
        enum header_format_t
        {
            HEADER_BIN,
            HEADER_DOS33,
            HEADER_RAW,
        };
        header_format_t header;
 
        file_type_t file_type;
        /* TODO: enable setting the base address as a parameter */
 
        AppleDriver(file_type_t file_type = FILE_TYPE_BIN, header_format_t header = HEADER_BIN)
            : GSOutput(TARGET_DATA_FORK, 0),
            header(header),
            file_type(file_type)
        {
        }
 
        AppleDriver(file_type_t file_type, target_format_t target)
            : GSOutput(target, 0),
            header(HEADER_BIN),
            file_type(file_type)
        {
        }
 
    protected:
        void OnContainerCreated() override;
        void OnCalculateValues() override;
        void OnReadFile(Linker::Reader& rd) override;
        offset_t OnWriteFile(Linker::Writer& wr) const override;
        void OnDump(Dumper::Dumper& dump) const override;
 
    public:
        void ReadFile(Linker::Reader& rd) override;
 
        void GenerateFile(std::string filename, Linker::Module& module) override;
        void Dump(Dumper::Dumper& dump) const override;
 
        uint8_t GetFileType() const;
        uint16_t GetAuxiliaryFileType() const;
 
        bool UseDOS33Header() const
        {
            if(file_type != FILE_TYPE_BIN || target != TARGET_DATA_FORK)
            {
                return false;
            }
 
            switch(header)
            {
            case HEADER_BIN:
                // only apply header if there is no NAPS suffix
                return (produce & PRODUCE_NAPS_SUFFIX) == 0;
            case HEADER_DOS33:
                return true;
            default:
            case HEADER_RAW:
                return false;
            }
        }
 
        using Linker::OutputFormat::GetDefaultExtension;
        std::string GetDefaultExtension(Linker::Module& module, std::string filename) 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::Contents> 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::Contents> 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::Contents> 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 */