8bitexe.h

#ifndef _8BITEXE_H
#define _8BITEXE_H
 
#include <algorithm>
#include "binary.h"
#include "gsos.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"
 
/* a collection of various simple 8-bit formats */
/* TODO: should this be reorganized? */
 
namespace Apple
{
    class AppleFormat : public Binary::GenericBinaryFormat
    {
    public:
        bool dos33_header;
 
        /* TODO: enable setting the base address as a parameter */
 
        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(const std::shared_ptr<Linker::Reader>& rd) override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
    };
 
    class SOSFormat : public Binary::GenericBinaryFormat
    {
    public:
        // TODO: untested
 
        std::shared_ptr<Linker::Contents> optional_header;
 
        /* TODO: enable setting the base address as a parameter */
 
        SOSFormat(uint64_t default_base_address = 0x9000, std::string default_extension = "") // TODO: what would be a good default address? this is lifted from the SOS reference manual
            : GenericBinaryFormat(default_base_address, default_extension)
        {
        }
 
        offset_t ImageSize() const override;
 
        void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
    };
 
    class AppleDriver : public Apple::GSOutputDriver
    {
    public:
        std::shared_ptr<Linker::OutputFormat> 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)
            : GSOutputDriver(TARGET_DATA_FORK, 0),
            header(header),
            file_type(file_type)
        {
        }
 
        AppleDriver(file_type_t file_type, target_format_t target)
            : GSOutputDriver(target, 0),
            header(HEADER_BIN),
            file_type(file_type)
        {
        }
 
    protected:
        void OnContainerCreated() override;
        void OnReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
        offset_t OnWriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
        void OnDump(Dumper::Dumper& dump) const override;
 
    public:
        void SetAppleSingleDoubleVersion(offset_t version);
 
        class DriverOptionCollector : public Linker::OptionCollector
        {
        public:
            Linker::Option<std::optional<offset_t>> asver{"asver", "Version of the AppleSingle/AppleDouble container (recognized values: 1, 2)"};
            Linker::Option<std::optional<offset_t>> adver{"adver", "Version of the AppleSingle/AppleDouble container (recognized values: 1, 2)"};
 
            DriverOptionCollector()
            {
                InitializeFields(asver, adver);
            }
        };
 
        std::shared_ptr<Linker::OptionCollector> GetOptions() override;
        void SetOptions(std::map<std::string, std::string>& options) override;
 
        void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
 
        void CalculateValues() 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 != OutputDriver::TARGET_DATA_FORK)
            {
                return false;
            }
 
            switch(header)
            {
            case HEADER_BIN:
                // only apply header if there is no NAPS suffix
                return (produce & OutputDriver::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;
    };
}
 
namespace Atari
{
    class AtariFormat : public Binary::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(const std::shared_ptr<Linker::Reader>& rd);
 
            void WriteFile(const std::shared_ptr<Linker::Writer>& wr) const;
 
            void ReadRelocations(const std::shared_ptr<Linker::Reader>& rd);
 
            void WriteRelocations(const std::shared_ptr<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(const std::shared_ptr<Linker::Reader>& rd) override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
    };
}
 
namespace Commodore
{
    class CommodoreFormat : public Binary::GenericBinaryFormat
    {
    public:
        class BASICLine : public Linker::Format
        {
        public:
            uint16_t line_address = 0;
            uint16_t line_number = 0;
            uint16_t next_address = 0;
            std::vector<uint8_t> tokens;
 
            /* BASIC token */
            enum Token
            {
                // using http://fileformats.archiveteam.org/wiki/Commodore_BASIC_tokenized_file
                END = 0x80,
                FOR = 0x81,
                NEXT = 0x82,
                DATA = 0x83,
                INPUT_HASH = 0x84,
                INPUT = 0x85,
                DIM = 0x86,
                READ = 0x87,
                LET = 0x88,
                GOTO = 0x89,
                RUN = 0x8A,
                IF = 0x8B,
                RESTORE = 0x8C,
                GOSUB = 0x8D,
                RETURN = 0x8E,
                REM = 0x8F,
                STOP = 0x90,
                ON = 0x91,
                WAIT = 0x92,
                LOAD = 0x93,
                SAVE = 0x94,
                VERIFY = 0x95,
                DEF = 0x96,
                POKE = 0x97,
                PRINT_HASH = 0x98,
                PRINT = 0x99,
                CONST = 0x9A,
                LIST = 0x9B,
                CLR = 0x9C,
                CMD = 0x9D,
                SYS = 0x9E,
                OPEN = 0x9F,
                CLOSE = 0xA0,
                GET = 0xA1,
                NEW = 0xA2,
                TAB_PAREN = 0xA3,
                TO = 0xA4,
                FN = 0xA5,
                SPC_PAREN = 0xA6,
                THEN = 0xA7,
                NOT = 0xA8,
                STEP = 0xA9,
                _PLUS = 0xAA,
                _MINUS = 0xAB,
                _MULTIPLY = 0xAC,
                _DIVIDE = 0xAD,
                _POWER = 0xAE,
                AND = 0xAF,
                OR = 0xB0,
                _GREATER = 0xB1,
                _EQUAL = 0xB2,
                _LESS = 0xB3,
                SGN = 0xB4,
                INT = 0xB5,
                ABS = 0xB6,
                USR = 0xB7,
                FRE = 0xB8,
                POS = 0xB9,
                SQR = 0xBA,
                RND = 0xBB,
                LOG = 0xBC,
                EXP = 0xBD,
                COS = 0xBE,
                SIN = 0xBF,
                TAN = 0xC0,
                ATN = 0xC1,
                PEEK = 0xC2,
                LEN = 0xC3,
                STR_DOLLAR = 0xC4,
                VAL = 0xC5,
                ASC = 0xC6,
                CHR_DOLLAR = 0xC7,
                LEFT_DOLLAR = 0xC8,
                RIGHT_DOLLAR = 0xC9,
                MID_DOLLAR = 0xCA,
                GO = 0xCB,
                _PI = 0xFF,
            };
 
            void AddToken(Token token);
            void AddString(std::string text);
            void AddDecimal(int value);
            offset_t ImageSize() const override; // including header
 
            void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
            using Linker::Format::WriteFile;
            offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
            void CalculateValues();
            void Dump(Dumper::Dumper& dump) const override;
            void Dump(Dumper::Dumper& dump, std::optional<uint16_t> line_index, int display_flags) const;
        };
 
        class BASICFile : public Linker::Format
        {
        public:
            uint16_t load_address = 0;
            std::vector<BASICLine> lines;
            uint16_t end_address = 0;
 
            void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
            using Linker::Format::WriteFile;
            offset_t ImageSize() const override;
            offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
            void CalculateValues();
            void Dump(Dumper::Dumper& dump) const override;
            void Dump(Dumper::Dumper& dump, int display_flags) const;
        };
 
        static const uint16_t PET_BASIC_START = 0x0401;
        static const uint16_t VIC_BASIC_START = 0x1001;
        static const uint16_t C64_BASIC_START = 0x0801;
 
        class CommodoreOptionCollector : public Linker::OptionCollector
        {
        public:
            class SystemTypeEnumeration : public Linker::Enumeration<uint16_t>
            {
            public:
                SystemTypeEnumeration()
                    : Enumeration(
                        "PET", PET_BASIC_START,
                        "VIC20", VIC_BASIC_START,
                        "VIC-20", VIC_BASIC_START,
                        "VIC", VIC_BASIC_START,
                        "C64", C64_BASIC_START)
                {
                    descriptions = {
                        { PET_BASIC_START, "Commodore PET" },
                        { VIC_BASIC_START, "Commodore VIC-20" },
                        { C64_BASIC_START, "Commodore 64" },
                    };
                }
            };
 
            Linker::Option<Linker::ItemOf<SystemTypeEnumeration>> system{"system", "Target Commodore system type", C64_BASIC_START};
            Linker::Option<std::optional<offset_t>> load_address{"load_address", "Load address for BASIC code"};
 
            CommodoreOptionCollector()
            {
                InitializeFields(system, load_address);
            }
        };
 
        uint16_t load_address = 0;
        std::shared_ptr<Linker::Contents> loader;
 
        uint16_t GetLoadAddress() const;
 
        void Clear() override;
 
        ~CommodoreFormat()
        {
            Clear();
        }
 
        void SetupDefaultLoader();
        uint16_t GetImagePaddingSize() const;
 
        std::shared_ptr<Linker::OptionCollector> GetOptions() override;
        void SetOptions(std::map<std::string, std::string>& options) override;
 
        void ProcessModule(Linker::Module& module) override;
 
        void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
        void CalculateValues() override;
        offset_t ImageSize() const override;
        using Linker::Format::WriteFile;
        offset_t WriteFile(const std::shared_ptr<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;
    };
}
 
namespace DigitalResearch
{
    class PRLFormat;
 
    class CPM3Format : public Binary::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(const std::shared_ptr<Linker::Reader>& rd) override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
 
        void CalculateValues() override;
    };
 
    class PRLFormat : public Binary::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(const std::shared_ptr<Linker::Reader>& rd) override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
 
        void ReadWithoutHeader(const std::shared_ptr<Linker::Reader>& rd, uint16_t image_size);
 
        void WriteWithoutHeader(const std::shared_ptr<Linker::Writer>& wr) const;
 
        void Dump(Dumper::Dumper& dump) const override;
    };
}
 
namespace FLEX
{
    class FLEXFormat : public Binary::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(const std::shared_ptr<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(const std::shared_ptr<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;
    };
}
 
namespace UZI
{
    class UZIFormat : public Binary::GenericBinaryFormat
    {
    public:
        /* TODO */
        bool uzi180_header;
        uint16_t entry;
 
        void ProcessModule(Linker::Module& module) override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(const std::shared_ptr<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 Binary::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(const std::shared_ptr<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 */