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;            
    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;                           
        } cfg;                                          
        struct {
            bool showingReachability;                   
        } reach;                                        
    } 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 {
            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;                          
        } 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