emxaout.h

#ifndef EMXAOUT_H
#define EMXAOUT_H
 
#include "mzexe.h"
#include "aout.h"
#include "leexe.h"
#include "../common.h"
#include "../dumper/dumper.h"
#include "../linker/module.h"
#include "../linker/options.h"
#include "../linker/segment.h"
#include "../linker/segment_manager.h"
#include "../linker/writer.h"
 
namespace EMX
{
    class EMXAOutFormat : public virtual AOut::AOutFormat, protected virtual Microsoft::LEFormat
    {
    public:
        EMXAOutFormat()
            : AOutFormat(AOutFormat::EMX, AOutFormat::ZMAGIC), LEFormat(LEFormat::OS2, LEFormat::OUTPUT_CON)
        {
            LEFormat::module_flags = LEFormat::GUIAware | LEFormat::NoInternalFixup;
            LEFormat::signature[1] = 'X';
        }
 
        bool bound_image = false;
        uint32_t aout_header_offset = 0;
        std::array<char, 64> dos_options;
        /* patch area inside the LX data object */
        uint32_t text_base = 0;
        uint32_t text_end = 0;
        uint32_t data_base = 0;
        uint32_t data_end = 0;
        uint32_t bss_base = 0;
        uint32_t bss_end = 0;
        uint32_t heap_base = 0;
        uint32_t heap_end = 0;
        uint32_t heap_brk = 0;
        uint32_t heap_off = 0;
        uint32_t os2_dll = 0;
        uint32_t stack_base = 0;
        uint32_t stack_end = 0;
        uint32_t flags = 0;
        std::array<char, 64> os2_options;
 
        void ReadFile(Linker::Reader& rd) override;
 
        offset_t ImageSize() const override;
 
        using Linker::Format::WriteFile;
        offset_t WriteFile(Linker::Writer& wr) const override;
 
        void Dump(Dumper::Dumper& dump) const override;
 
        /* * * Reader members * * */
 
        using Linker::InputFormat::GenerateModule;
        void GenerateModule(Linker::Module& module) const override;
 
        /* * * Writer members * * */
 
        class EMXOptionCollector : public Linker::OptionCollector
        {
        public:
            Linker::Option<std::string> stub{"stub", "Filename for stub that gets prepended to executable"};
 
            EMXOptionCollector()
            {
                InitializeFields(stub);
            }
        };
 
        using LEFormat::stub;
 
        static std::vector<Linker::OptionDescription<void> *> ParameterNames;
        std::vector<Linker::OptionDescription<void> *> GetLinkerScriptParameterNames() override;
 
        std::shared_ptr<Linker::OptionCollector> GetOptions() override;
        void SetOptions(std::map<std::string, std::string>& options) override;
 
        void OnNewSegment(std::shared_ptr<Linker::Segment> segment) override;
 
        void ProcessModule(Linker::Module& module) override;
 
        void CalculateValues() override;
 
        void GenerateFile(std::string filename, Linker::Module& module) override;
 
        using Linker::OutputFormat::GetDefaultExtension;
        std::string GetDefaultExtension(Linker::Module& module, std::string filename) const override;
        std::string GetDefaultExtension(Linker::Module& module) const override;
    };
}
 
#endif /* EMXAOUT_H */