o65.h

#ifndef O65_H
#define O65_H
 
#include "../common.h"
#include "../dumper/dumper.h"
#include "../linker/image.h"
#include "../linker/reader.h"
#include "../linker/segment_manager.h"
#include "../linker/writer.h"
 
/* o65 object format (input only) */
namespace O65
{
    class O65Format : public virtual Linker::InputFormat
    {
    public:
        class Module
        {
        public:
            struct header_option
            {
                static const int TYPE_FILENAME = 0x00;
                static const int TYPE_SYSTEM = 0x01;
                static const int TYPE_ASSEMBLER = 0x02;
                static const int TYPE_AUTHOR = 0x03;
                static const int TYPE_CREATION = 0x04;
 
                uint8_t type;
                std::vector<uint8_t> data;
 
                header_option(uint8_t type)
                    : type(type), data()
                {
                }
 
                header_option(uint8_t type, std::vector<uint8_t>& data)
                    : type(type), data(data)
                {
                }
            };
 
            struct relocation
            {
                static const int RELOC_TYPE_MASK = 0xE0;
                static const int RELOC_TYPE_LOW = 0x20;
                static const int RELOC_TYPE_HIGH = 0x40;
                static const int RELOC_TYPE_WORD = 0x80;
                static const int RELOC_TYPE_SEG = 0xA0;
                static const int RELOC_TYPE_SEGADDR = 0xC0;
 
                static const int RELOC_SEGMENT_MASK = 0x1F;
                static const int RELOC_SEGMENT_UNDEFINED = 0x00;
                static const int RELOC_SEGMENT_ABSOLUTE = 0x01;
                static const int RELOC_SEGMENT_TEXT = 0x02;
                static const int RELOC_SEGMENT_DATA = 0x03;
                static const int RELOC_SEGMENT_BSS = 0x04;
                static const int RELOC_SEGMENT_ZERO = 0x05;
 
                uint8_t type_segment;
                offset_t symbol_index;
                offset_t value;
 
                relocation()
                    : type_segment(0), symbol_index(0), value(0)
                {
                }
 
                relocation(uint8_t type_segment, offset_t value = 0, offset_t symbol_index = 0)
                    : type_segment(type_segment), symbol_index(symbol_index), value(value)
                {
                }
            };
 
            struct exported_global
            {
                std::string name;
                uint8_t segment_id;
                offset_t value;
 
                exported_global(std::string_view name, uint8_t segment_id, offset_t value)
                    : name(name), segment_id(segment_id), value(value)
                {
                }
            };
 
            static const int MODE_ALIGN_MASK = 0x0003;
            static const int MODE_ALIGN_BYTE = 0x0000;
            static const int MODE_ALIGN_WORD = 0x0001;
            static const int MODE_ALIGN_LONG = 0x0002;
            static const int MODE_ALIGN_PAGE = 0x0003;
 
            static const int MODE_CPU_MASK = 0x00F0;
            static const int MODE_CPU_6502 = 0x0000;
            static const int MODE_CPU_65C02 = 0x0010;
            static const int MODE_CPU_65SC02 = 0x0020;
            static const int MODE_CPU_65CE02 = 0x0030;
            static const int MODE_CPU_NMOS = 0x0040;
            static const int MODE_CPU_65816 = 0x0050;
 
            static const int MODE_BSS_ZERO = 0x0200;
            static const int MODE_CHAIN = 0x0400;
            static const int MODE_SIMPLE = 0x0800;
            static const int MODE_OBJ = 0x1000;
            static const int MODE_SIZE = 0x2000;
            static const int MODE_PAGE_RELOC = 0x4000;
            static const int MODE_65816 = 0x8000;
 
            uint16_t mode_word = 0;
 
            offset_t code_base = 0;
            std::shared_ptr<Linker::Contents> code_image = nullptr;
            offset_t data_base = 0;
            std::shared_ptr<Linker::Contents> data_image = nullptr;
            offset_t bss_base = 0;
            offset_t bss_size = 0;
            offset_t zero_base = 0;
            offset_t zero_size = 0;
            offset_t stack_size = 0;
 
            std::vector<header_option> header_options;
            std::vector<std::string> undefined_references;
 
            std::map<offset_t, relocation> code_relocations;
            std::map<offset_t, relocation> data_relocations;
 
            std::vector<exported_global> exported_globals;
 
            ~Module()
            {
                Clear();
            }
 
            void Clear();
 
            bool IsPageRelocatable() const;
            bool IsChained() const;
        private:
            void SetChained();
            friend class O65Format;
        public:
            int GetWordSize() const;
            offset_t ReadUnsigned(const std::shared_ptr<Linker::Reader>& rd) const;
            void WriteWord(const std::shared_ptr<Linker::Writer>& wr, offset_t value) const;
 
            void ReadFile(const std::shared_ptr<Linker::Reader>& rd);
            void CalculateValues();
            void WriteFile(const std::shared_ptr<Linker::Writer>& wr) const;
            void GenerateModule(Linker::Module& module) const;
        };
 
    protected:
        std::vector<std::unique_ptr<Module>> modules;
 
    public:
        offset_t GetModuleCount();
        std::unique_ptr<O65Format::Module>& GetModule(offset_t index);
        std::unique_ptr<O65Format::Module>& AddModule();
 
        ~O65Format()
        {
            Clear();
        }
 
        void Clear() override;
 
        void ReadFile(const std::shared_ptr<Linker::Reader>& rd) override;
        using Linker::Format::WriteFile;
        void CalculateValues() /*override*/;
        offset_t WriteFile(const std::shared_ptr<Linker::Writer>& wr) const override;
        void Dump(Dumper::Dumper& dump) const override;
        using Linker::InputFormat::GenerateModule;
        void GenerateModule(Linker::Module& module) const override;
    };
}
 
#endif /* O65_H */