symbol.h

#ifndef SYMBOLNAME_H
#define SYMBOLNAME_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:
        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)
        {
        }
 
        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 operator ==(const SymbolName& other) const;
 
        bool operator !=(const SymbolName& other) const;
    };
 
    std::ostream& operator<<(std::ostream& out, const SymbolName& symbol);
 
    class ExportedSymbol
    {
    protected:
        bool by_ordinal;
        std::string name;
        std::optional<uint16_t> ordinal;
 
    public:
        ExportedSymbol(std::string name)
            : by_ordinal(false), name(name), ordinal()
        {
        }
 
        ExportedSymbol(std::string name, uint16_t hint)
            : by_ordinal(false), name(name), ordinal(hint)
        {
        }
 
        ExportedSymbol(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 ExportedSymbol& other) const;
 
        bool operator !=(const ExportedSymbol& other) const;
 
        bool operator <(const ExportedSymbol& other) const;
 
        bool operator >=(const ExportedSymbol& other) const;
 
        bool operator >(const ExportedSymbol& other) const;
 
        bool operator <=(const ExportedSymbol& other) const;
    };
 
    std::ostream& operator<<(std::ostream& out, const ExportedSymbol& symbol);
 
    class CommonSymbol
    {
    public:
        std::string name;
        offset_t size, align;
 
        CommonSymbol(std::string name = "", offset_t size = 0, offset_t align = 1)
            : name(name), size(size), align(align)
        {
        }
    };
 
    std::ostream& operator<<(std::ostream& out, const CommonSymbol& symbol);
}
 
#endif /* SYMBOLNAME_H */