BinaryEdgeArrows.h

#ifndef Rose_BinaryAnalysis_Unparser_EdgeArrows_H
#define Rose_BinaryAnalysis_Unparser_EdgeArrows_H

#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <Partitioner2/BasicTypes.h>
#include <Sawyer/Graph.h>
#include <Sawyer/Interval.h>
#include <Sawyer/IntervalMap.h>
#include <Sawyer/Map.h>
#include <StringUtility.h>
#include <ostream>
#include <vector>

namespace Rose {
namespace BinaryAnalysis {
namespace Unparser {

// Basic block arrow information

class EdgeArrows {
public:
    enum OutputPart {
        FIRST_LINE,                                     
        LAST_LINE,                                      
        MIDDLE_LINE,                                    
        INTER_LINE                                      
    };

    typedef rose_addr_t VertexId;

    typedef Sawyer::Container::Graph<VertexId, Sawyer::Nothing, VertexId> Graph;

    struct ArrowStyle {
        size_t charactersPerColumn;                     
        bool pointsRight;                               
        std::string sourceThenDown;                     
        std::string sourceThenUp;                       
        std::string verticalLine;                       
        std::string downToTarget;                       
        std::string upToTarget;                         
        std::string blank;                              
        std::string sourceHorizontal;                   
        std::string targetHorizontal;                   
    };

    enum ArrowStylePreset {
        UNICODE_1,                                      
        UNICODE_2,                                      
        ASCII_1,                                        
        ASCII_2,                                        
        ASCII_3                                         
    };

    enum ArrowSide {
        LEFT,                                           
        RIGHT                                           
    };
    
private:
    // Location of a vertex in the output. Each vertex is assumed to occupy four lines: a first line for incoming edges,
    // a middle line representative of all lines of output between the first and last lines, a last line for outgoing
    // edges, and a separator line representative of all lines of output between vertices.
    typedef Sawyer::Container::Interval<size_t> OutputLocation;

    // Mapping from vertex ID to its location in the output.
    typedef Sawyer::Container::Map<VertexId, OutputLocation> VertexLocations;

    // Edge properties
    struct Arrow {
        OutputLocation location;                        // line numbers occupied by the arrow
        bool isForward;                                 // arrow points to a later vertex?

        Arrow()
            : isForward(true) {}

        Arrow(const OutputLocation &location, bool isForward)
            : location(location), isForward(isForward) {}

        bool operator==(const Arrow &other) {
            return location == other.location && isForward == other.isForward;
        }
    };
    
    // One column of arrows. Maps line numbers of output to line numbers of edges.
    typedef Sawyer::Container::IntervalMap<OutputLocation /*line number*/, Arrow> Column;

    // Columns of arrows
    typedef std::vector<Column> Columns;

private:
    OutputLocation outputHull_;                         // entire output
    VertexLocations vertexLocations_;                   // location of each vertex in the output
    Columns columns_;                                   // columns of arrows
    ArrowStyle arrowStyle_;                             // how to render arrows

public:
    EdgeArrows() {
        arrowStyle_ = asciiL3();                        // maximum portability but slightly less clarity than unicodeL2
    }
    
    void computeLayout(const Graph&, const std::vector<VertexId> &order = std::vector<VertexId>());

    void computeCfgBlockLayout(const Partitioner2::Partitioner&, const Partitioner2::FunctionPtr&);

    void computeCfgEdgeLayout(const Partitioner2::Partitioner&, const Partitioner2::FunctionPtr&);

    static VertexId cfgEdgeSourceEndpoint(size_t edgeId);
    static VertexId cfgEdgeTargetEndpoint(size_t edgeId);
    void reset();

    size_t nArrowColumns() const;

    const ArrowStyle& arrowStyle() const { return arrowStyle_; }
    void arrowStyle(const ArrowStyle &t) { arrowStyle_ = t; }
    void arrowStyle(ArrowStylePreset, ArrowSide);

    static ArrowStyle unicodeL1();
    static ArrowStyle unicodeR1();
    static ArrowStyle unicodeL2();
    static ArrowStyle unicodeR2();
    static ArrowStyle asciiL1();
    static ArrowStyle asciiR1();
    static ArrowStyle asciiL2();
    static ArrowStyle asciiR2();
    static ArrowStyle asciiL3();
    static ArrowStyle asciiR3();
    static ArrowStyle asciiL4();
    static ArrowStyle asciiR4();
    std::string renderBlank() const;

    std::string render(VertexId, OutputPart) const;

    size_t nSources(VertexId) const;

    size_t nTargets(VertexId) const;

    void debug(std::ostream&) const;
    
private:
    // Append a vertex to the output. This doesn't actually create any output, it just reserves space for it.
    void appendVertex(VertexId);

    // Is the length of arrow A less than the length of arrow B?
    static bool ascendingLength(const Arrow &a, const Arrow &b);

};

} // namespace
} // namespace
} // namespace

#endif
#endif