format.h

#ifndef FORMAT_H
#define FORMAT_H
 
#include <map>
#include <optional>
#include <string>
#include "../common.h"
#include "image.h"
 
namespace Dumper
{
    class Dumper;
}
 
namespace Linker
{
    class Module;
    class ModuleCollector;
    class OptionCollector;
    template <typename T>
        class OptionDescription;
    class Reader;
    class Writer;
 
    class Format : public virtual Image
    {
    public:
        offset_t file_offset;
 
        Format(offset_t file_offset = 0)
            : file_offset(file_offset)
        {
        }
 
        virtual ~Format() = default;
        virtual void Clear();
        virtual void ReadFile(Reader& rd) = 0;
        offset_t WriteFile(Writer& wr) const override = 0;
        virtual void Dump(Dumper::Dumper& dump) const;
 
        offset_t ImageSize() const override;
        offset_t WriteFile(Writer& wr, offset_t count, offset_t offset = 0) const override;
    };
 
    class OutputFormat : public virtual Format
    {
    public:
        virtual bool AddSupplementaryOutputFormat(std::string subformat);
        virtual std::vector<OptionDescription<void>> GetMemoryModelNames();
        virtual std::vector<OptionDescription<void> *> GetLinkerScriptParameterNames();
        virtual std::vector<OptionDescription<void>> GetSpecialSymbolNames();
        virtual std::shared_ptr<OptionCollector> GetOptions();
        virtual void SetOptions(std::map<std::string, std::string>& options);
 
        std::optional<std::string> FetchOption(std::map<std::string, std::string>& options, std::string name);
 
        std::string FetchOption(std::map<std::string, std::string>& options, std::string name, std::string default_value);
 
        std::optional<offset_t> FetchIntegerOption(std::map<std::string, std::string>& options, std::string name);
 
        virtual void SetModel(std::string model);
        virtual void SetLinkScript(std::string script_file, std::map<std::string, std::string>& options);
        virtual void ProcessModule(Module& object);
        virtual void CalculateValues();
        virtual void GenerateFile(std::string filename, Module& module);
        virtual std::string GetDefaultExtension(Module& module, std::string filename) const;
        virtual std::string GetDefaultExtension(Module& module) const;
        /* x86 only */
        virtual bool FormatSupportsSegmentation() const;
        virtual bool FormatIs16bit() const;
        virtual bool FormatIsProtectedMode() const;
        virtual bool FormatIsLinear() const;
        /* general */
        virtual bool FormatSupportsResources() const;
        virtual bool FormatSupportsLibraries() const; /* imports/exports, fileformat level support, not system support */
        virtual unsigned FormatAdditionalSectionFlags(std::string section_name) const;
    };
 
    class InputFormat : public virtual Format, public std::enable_shared_from_this<InputFormat>
    {
    public:
        virtual void SetupOptions(std::shared_ptr<OutputFormat> format);
        virtual void ProduceModule(ModuleCollector& linker, Reader& rd, std::string file_name);
        virtual void ProduceModule(Module& module, Reader& rd);
        virtual void GenerateModule(ModuleCollector& linker, std::string file_name, bool is_library = false) const;
        virtual void GenerateModule(Module& module) const;
    public:
        /* x86 only */
        virtual bool FormatProvidesSegmentation() const;
        /* w65 only */
        virtual bool FormatRequiresDataStreamFix() const;
        /* general */
        virtual bool FormatProvidesResources() const;
        virtual bool FormatProvidesLibraries() const;
    };
}
 
#endif /* FORMAT_H */