symbol_name.h

#ifndef SYMBOL_NAME_H
#define SYMBOL_NAME_H
 
#include <iostream>
#include <optional>
#include <string>
#include "../common.h"
 
namespace Linker
{
    class SymbolName
    {
    protected:
        std::optional<std::string> library;
            /* internal symbols: empty, imported symbols: refers to the library (NE, LE, PE) */
        std::optional<std::string> name;
            /* symbols imported by ordinal: empty (NE, LE, PE), other symbols: the name of the symbol */
        std::optional<uint16_t> hint;
            /* symbols imported not by ordinal: empty (NE, LE), except PE where it is a hint, other symbols: ordinal */
 
    public:
        offset_t addend = 0;
 
        SymbolName(std::string name)
            : name(name)
        {
        }
 
        SymbolName(std::string library, std::string name)
            : library(library), name(name)
        {
        }
 
        SymbolName(std::string library, std::string name, uint16_t hint)
            : library(library), name(name), hint(hint)
        {
        }
 
        SymbolName(std::string library, uint16_t ordinal)
            : library(library), hint(ordinal)
        {
        }
 
        struct LibraryMark { };
        static LibraryMark IsLibrary;
 
        SymbolName(std::string library, LibraryMark is_library)
            : library(library)
        {
            (void) is_library;
        }
 
        bool LoadName(std::string& result) const;
 
        bool LoadLibraryName(std::string& result) const;
 
        bool LoadOrdinalOrHint(uint16_t& result) const;
 
        bool GetLocalName(std::string& result) const;
 
        bool GetImportedName(std::string& result_library, std::string& result_name) const;
 
        bool GetImportedName(std::string& result_library, std::string& result_name, uint16_t& result_hint) const;
 
        bool GetImportedOrdinal(std::string& result_library, uint16_t& result_ordinal) const;
 
        bool GetImportedLibrary(std::string& result_library) const;
 
        bool operator ==(const SymbolName& other) const;
 
        bool operator !=(const SymbolName& other) const;
 
        static SymbolName GOT;
    };
 
    std::ostream& operator<<(std::ostream& out, const SymbolName& symbol);
 
    class ExportedSymbolName
    {
    protected:
        bool by_ordinal;
        std::string name;
        std::optional<uint16_t> ordinal;
 
    public:
        ExportedSymbolName(std::string name)
            : by_ordinal(false), name(name), ordinal()
        {
        }
 
        ExportedSymbolName(std::string name, uint16_t hint)
            : by_ordinal(false), name(name), ordinal(hint)
        {
        }
 
        ExportedSymbolName(uint16_t ordinal, std::string internal_name)
            : by_ordinal(true), name(internal_name), ordinal(ordinal)
        {
        }
 
        bool IsExportedByOrdinal() const;
 
        bool LoadName(std::string& result) const;
 
        bool LoadOrdinalOrHint(uint16_t& result) const;
 
        bool GetExportedByName(std::string& result) const;
 
        bool GetExportedByName(std::string& result, uint16_t& hint) const;
 
        bool GetExportedByOrdinal(uint16_t& result) const;
 
        bool GetExportedByOrdinal(uint16_t& result, std::string& result_name) const;
 
        bool operator ==(const ExportedSymbolName& other) const;
 
        bool operator !=(const ExportedSymbolName& other) const;
 
        bool operator <(const ExportedSymbolName& other) const;
 
        bool operator >=(const ExportedSymbolName& other) const;
 
        bool operator >(const ExportedSymbolName& other) const;
 
        bool operator <=(const ExportedSymbolName& other) const;
    };
 
    std::ostream& operator<<(std::ostream& out, const ExportedSymbolName& symbol);
}
 
#endif /* SYMBOL_NAME_H */