Unparser/Settings.h

// Basic types for binary unparsing.
#ifndef ROSE_BinaryAnalysis_Unparser_Settings_H
#define ROSE_BinaryAnalysis_Unparser_Settings_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/Color.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics.h>
#include <Rose/BinaryAnalysis/Unparser/EdgeArrows.h>
#include <Sawyer/CommandLine.h>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Unparser {
 
struct Style {
    Sawyer::Optional<Color::HSV> foreground;            
    Sawyer::Optional<Color::HSV> background;            
    Style() {}
 
    Style(const Sawyer::Optional<Color::HSV> &fg, const Sawyer::Optional<Color::HSV> &bg = Sawyer::Nothing())
        : foreground(fg), background(bg) {}
 
    std::string ansiStyle() const;
};
 
struct Settings {
    virtual ~Settings() {}
 
    Color::Colorization colorization;                   
    struct {
        struct {
            Style style;
        } line;                                         
        struct {
            Style style;
        } trailing;                                     
    } comment;
 
    struct {
        Style separatorStyle;                           
        Style titleStyle;                               
        bool showingSourceLocation;                     
        bool showingReasons;                            
        bool showingDemangled;                          
        struct {
            bool showing;                               
        } cg;                                           
        struct {
            bool showing;                               
            bool concrete;                              
        } stackDelta;                                   
        struct {
            bool showing;                               
        } callconv;                                     
        struct {
            bool showing;                               
        } noop;                                         
        struct {
            bool showing;                               
        } mayReturn;                                    
    } function;                                         
    struct {
        bool showingSourceLocation;                     
        struct {
            bool showingPredecessors;                   
            bool showingSuccessors;                     
            bool showingSharing;                        
            bool showingArrows;                         
            Style arrowStyle;                           
            bool showingNormalFallThroughEdges;         
            bool showingCallReturnFallThroughEdges;     
        } cfg;                                          
        struct {
            bool showingReachability;                   
        } reach;                                        
        bool showingPostBlock;                          
    } bblock;                                           
    struct {
        bool showingSourceLocation;                     
    } dblock;
 
    struct {
        struct {
            bool showing;                               
            bool useLabels;                             
            size_t fieldWidth;                          
            Style style;                                
        } address;                                      
        struct {
            bool showing;                               
            size_t perLine;                             
            size_t fieldWidth;                          
            Style style;                                
        } bytes;                                        
        struct {
            bool showing;                               
            size_t fieldWidth;                          
            Style style;                                
        } stackDelta;                                   
        struct {
            bool showing;                               
            size_t fieldWidth;                          
            Style style;                                
        } frameDelta;                                   
        struct {
            size_t fieldWidth;                          
            std::string semanticFailureMarker;          
            Style semanticFailureStyle;                 
            Style style;                                
        } mnemonic;                                     
        struct {
            std::string separator;                      
            size_t fieldWidth;                          
            bool showingWidth;                          
            Style style;                                
        } operands;                                     
        struct {
            bool showing;                               
            bool usingDescription;                      
            std::string pre;                            
            std::string post;                           
            size_t fieldWidth;                          
            // Style style;                             // see `comment.trailing.style` above
        } comment;                                      
        struct {
            bool showing;                               
            InstructionSemantics::BaseSemantics::Formatter formatter; 
            bool tracing;                               
            Style style;                                
        } semantics;
    } insn;                                             
    struct {
        EdgeArrows::ArrowStylePreset style;             
    } arrow;                                            
    std::string linePrefix;
 
    Settings();
    static Settings full();
    static Settings minimal();
};
 
// Forward declarations.
class Base;
class State;
typedef Sawyer::SharedPointer<Base> BasePtr;
 
Sawyer::CommandLine::SwitchGroup commandLineSwitches(Settings &settings);
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif