EdgeArrows.h

#ifndef ROSE_BinaryAnalysis_Unparser_EdgeArrows_H
#define ROSE_BinaryAnalysis_Unparser_EdgeArrows_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
#include <Sawyer/Graph.h>
#include <Sawyer/Interval.h>
#include <Sawyer/IntervalMap.h>
#include <Sawyer/Map.h>
#include <Rose/StringUtility.h>
#include <ROSE_DEPRECATED.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                                      
    };
    enum OutputPart {…};
 
    using EndpointId = size_t;
 
    using ArrowId = size_t;
 
    using Graph = Sawyer::Container::Graph<EndpointId, ArrowId, EndpointId, ArrowId>;
 
    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;                   
    };
    struct ArrowStyle {…};
 
    enum ArrowStylePreset {
        UNICODE_1,                                      
        UNICODE_2,                                      
        ASCII_1,                                        
        ASCII_2,                                        
        ASCII_3                                         
    };
    enum ArrowStylePreset {…};
 
    enum ArrowSide {
        LEFT,                                           
        RIGHT                                           
    };
    enum ArrowSide {…};
    
private:
    // Logical location of an arrow endpoint in the output. Each endpoint is assumed to occupy four logical lines, although each
    // logical line may consist of multiple physical lines of output). They are:
    //
    //    1. a first line for the endpoint,
    //
    //    2. a middle line representative of all lines between #1 and #3
    //
    //    3. a last line for the endpoint
    //
    //    4. a separator line representative of all lines of output between #4 of this endpoint and #1 of the next endpoint.
    using OutputLocation = Sawyer::Container::Interval<size_t>;
 
    // Mapping from an endpoint to its logical location in the output.
    using EndpointLocations = Sawyer::Container::Map<EndpointId, OutputLocation>;
 
    // Arrow properties
    struct Arrow {
        OutputLocation location;                        // line numbers occupied by the arrow
        bool isForward;                                 // arrow points to a later vertex?
        ArrowId arrowId;                                // ID for this arrow
        size_t columnIdx = INVALID_INDEX;               // column of arrows where this arrow appears (after its been assigned)
 
        Arrow()
            : isForward(true) {}
 
        Arrow(const OutputLocation &location, const bool isForward, const ArrowId arrowId)
            : location(location), isForward(isForward), arrowId(arrowId) {}
 
        bool operator==(const Arrow &other) {
            return location == other.location && isForward == other.isForward && arrowId == other.arrowId;
        }
    };
    
    // One column of arrows. Maps line numbers of output to line numbers of edges.
    using Column = Sawyer::Container::IntervalMap<OutputLocation /*line number*/, Arrow>;
 
    // Columns of arrows
    using Columns = std::vector<Column>;
 
private:
    OutputLocation outputHull_;                         // entire output
    EndpointLocations endpointLocations_;               // logical location of each endpoint in the output
    Columns columns_;                                   // columns of arrows
    ArrowStyle arrowStyle_;                             // how to render arrows
    size_t minRenderColumns_ = 0;                       // minimum number of arrow columns to render
    size_t maxRenderColumns_ = UNLIMITED;               // maximum number of arrow columns to render
 
public:
    EdgeArrows() {
        arrowStyle_ = asciiL3();                        // maximum portability but slightly less clarity than unicodeL2
    }
 
    std::pair<size_t, size_t> minMaxRenderColumns() const;
    void minMaxRenderColumns(size_t minColumns, size_t maxColumns);
    bool columnIsRendered(size_t columnIdx) const;
 
    void computeLayout(const Graph&, const std::vector<EndpointId> &order);
 
    void computeCfgBlockLayout(const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&);
 
    void computeCfgEdgeLayout(const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&);
 
    static EndpointId toSourceEndpoint(size_t cfgEdgeOrVertexId);
    static EndpointId toTargetEndpoint(size_t cfgEdgeOrVertexId);
    static size_t fromEndpoint(EndpointId);
    static bool isSourceEndpoint(EndpointId);
    static bool isTargetEndpoint(EndpointId);
    static EndpointId otherEndpoint(EndpointId);
    // [Robb Matzke 2025-04-04]: Deprecated
    static EndpointId edgeToSourceEndpoint(size_t edgeId) ROSE_DEPRECATED("use toSourceEndpoint");
    static EndpointId edgeToTargetEndpoint(size_t edgeId) ROSE_DEPRECATED("use toTargetEndpoint");
    static size_t edgeFromEndpoint(EndpointId) ROSE_DEPRECATED("use fromEndpoint");
 
    bool exists(EndpointId) const;
 
    Sawyer::Optional<Arrow> findArrow(ArrowId) const;
 
    void reset();
 
    size_t nArrowColumns() const;
 
    size_t nRenderColumns() 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(EndpointId, OutputPart) const;
 
    size_t nSources(EndpointId) const;
 
    size_t nTargets(EndpointId) const;
 
    void debug(std::ostream&) const;
    void debugGraph(std::ostream&, const Graph&) const;
    void debugLines(std::ostream&, const std::vector<EndpointId>&) const;
private:
    // Append an endpoint to the output. This doesn't actually create any output, it just reserves space for it.
    void appendEndpoint(EndpointId);
 
    // Is the length of arrow A less than the length of arrow B?
    static bool ascendingLength(const Arrow &a, const Arrow &b);
 
};
class EdgeArrows {…};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif