segment_manager.h

#ifndef SEGMENT_MANAGER_H
#define SEGMENT_MANAGER_H
 
#include <fstream>
#include <memory>
#include <optional>
#include <string>
#include <variant>
#include "format.h"
#include "../script/script.h"
 
namespace Script
{
    class List;
    class Node;
}
 
namespace Linker
{
    class Location;
    class Module;
    class OutputFormat;
    class Reader;
    class Section;
    class Segment;
    class Writer;
 
    class SegmentManager : public virtual OutputFormat
    {
    protected:
        offset_t current_address = 0;
 
        bool current_is_template_head = false;
        bool current_is_template = false;
        offset_t template_counter = 0;
        bool condition_failed = false;
        std::string current_template_name;
    public:
        offset_t current_base = 0;
        std::vector<std::shared_ptr<Segment>> segment_vector;
        std::map<std::string, std::shared_ptr<Segment>> segment_map;
        std::shared_ptr<Segment> current_segment;
        std::map<std::string, Location> linker_parameters;
        std::string linker_script;
 
        void ClearSegmentManager();
 
        void SetLinkScript(std::string script_file, std::map<std::string, std::string>& options) override;
 
        std::unique_ptr<Script::List> GetScript(Module& module);
 
        offset_t GetCurrentAddress() const;
 
        void SetCurrentAddress(offset_t address);
 
        void AlignCurrentAddress(offset_t align);
 
        void SetLatestBase(offset_t address);
 
        void FinishCurrentSegment();
 
        virtual void OnNewSegment(std::shared_ptr<Segment> segment);
 
        virtual void OnCallDirective(std::string identifier);
 
        std::shared_ptr<Segment> AppendSegment(std::string name);
 
        void AppendSegment(std::shared_ptr<Segment> segment);
 
        std::shared_ptr<Segment> FetchSegment(std::string name);
 
        void AppendSection(std::shared_ptr<Section> section);
 
        void ProcessScript(std::unique_ptr<Script::List>& directives, Module& module);
        void ProcessAction(std::unique_ptr<Script::Node>& action, Module& module);
        void PostProcessAction(std::unique_ptr<Script::Node>& action, Module& module);
        void ProcessCommand(std::unique_ptr<Script::Node>& command, Module& module);
        bool CheckPredicate(std::unique_ptr<Script::Node>& predicate, std::shared_ptr<Section> section, Module& module);
        offset_t EvaluateExpression(std::unique_ptr<Script::Node>& expression, Module& module);
    };
}
 
#endif /* SEGMENT_MANAGER_H */