Rose/BinaryAnalysis/BasicTypes.h

#ifndef ROSE_BinaryAnalysis_BasicTypes_H
#define ROSE_BinaryAnalysis_BasicTypes_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <RoseFirst.h>
 
// #include's for subdirectories and sub-namespaces are at the end of this header.
#include <Rose/BinaryAnalysis/RegisterDescriptor.h>
#include <Rose/Exception.h>
#include <Sawyer/SharedPointer.h>
#include <memory>
 
namespace Rose {
namespace BinaryAnalysis {
 
// Document definitions, but not forwared declarations.
 
class AbstractLocation;
class AsmFunctionIndex;
class AstHasher;
class BestMapAddress;
class BinaryLoader;
using BinaryLoaderPtr = Sawyer::SharedPointer<BinaryLoader>; 
class BinaryLoaderElf;
using BinaryLoaderElfPtr = Sawyer::SharedPointer<BinaryLoaderElf>; 
class BinaryLoaderElfObj;
using BinaryLoaderElfObjPtr = Sawyer::SharedPointer<BinaryLoaderElfObj>; 
class BinaryLoaderPe;
using BinaryLoaderPePtr = Sawyer::SharedPointer<BinaryLoaderPe>; 
class BinaryToSource;
class CodeInserter;
class ConcreteLocation;
class DataFlow;
class Demangler;
class FeasiblePath;
class FunctionCall;
class FunctionSimilarity;
class HotPatch;
class LibraryIdentification;
class MagicNumber;
class MemoryMap;
using MemoryMapPtr = Sawyer::SharedPointer<MemoryMap>; 
class NoOperation;
class Reachability;
class ReadWriteSets;
using ReadWriteSetsPtr    = std::shared_ptr<ReadWriteSets>;  
using RegisterDescriptors = std::vector<RegisterDescriptor>; 
class RegisterDictionary;
using RegisterDictionaryPtr = Sawyer::SharedPointer<RegisterDictionary>; 
class RegisterNames;
class RegisterParts;
class SerialInput;
using SerialInputPtr = std::shared_ptr<SerialInput>; 
class SerialIo;
using SerialIoPtr = std::shared_ptr<SerialIo>; 
class SerialOutput;
using SerialOutputPtr = std::shared_ptr<SerialOutput>; 
namespace Serialization {
 
enum Format {
    BINARY,     
    TEXT,       
    XML,        
    FLATBUFFERS 
};
 
enum Savable {
    NO_OBJECT         = 0x00000000, 
    PARTITIONER       = 0x00000001, 
    AST               = 0x00000002, 
    END_OF_DATA       = 0x0000fffe, 
    ERROR             = 0x0000ffff, 
    USER_DEFINED      = 0x00010000, 
    USER_DEFINED_LAST = 0xffffffff  
};
 
class Exception: public Rose::Exception {
  public:
    explicit Exception(const std::string& s) : Rose::Exception(s) {}
    ~Exception() throw() {}
};
 
using ProgressCallback = std::function<void(size_t current, Sawyer::Optional<size_t> total, const std::string& phase)>;
 
class SerialFrame;
class FrameRecord;
 
namespace FlatBuffers {
class Serializer;
class Deserializer;
} // namespace FlatBuffers
 
} // namespace Serialization
class SmtlibSolver;
class SmtSolver;
using SmtSolverPtr = std::shared_ptr<SmtSolver>; 
class SourceLocations;
class SRecord;
class SymbolicExpresssionParser;
class SystemCall;
class TaintedFlow;
class VxworksTerminal;
using VxworksTerminalPtr = std::shared_ptr<VxworksTerminal>; 
class Z3Solver;
 
namespace PointerDetection {
class Analysis;
class PointerDescriptor;
class Settings;
} // namespace PointerDetection
 
namespace ReturnValueUsed {
class Analysis;
class CallSiteResults;
} // namespace ReturnValueUsed
 
namespace StackDelta {
class Analysis;
void initNamespace();
} // namespace StackDelta
 
namespace Strings {
class AnyCodePoint;
class BasicCharacterEncodingScheme;
class BasicLengthEncodingScheme;
class CharacterEncodingForm;
class CharacterEncodingScheme;
class CodePointPredicate;
class EncodedString;
class Exception;
class LengthEncodedString;
class LengthEncodingScheme;
class NoopCharacterEncodingForm;
class PrintableAscii;
class StringEncodingScheme;
class StringFinder;
class TerminatedString;
class Utf8CharacterEncodingForm;
class Utf16CharacterEncodingForm;
} // namespace Strings
 
namespace SymbolicExpression {
class Exception;
class ExprExprHashMap;
class Formatter;
class Interior;
using InteriorPtr = Sawyer::SharedPointer<Interior>; 
class Leaf;
using LeafPtr = Sawyer::SharedPointer<Leaf>; 
class Node;
using Ptr = Sawyer::SharedPointer<Node>; 
class Simplifier;
class Type;
class Visitor;
} // namespace SymbolicExpression
using SymbolicExpressionPtr = SymbolicExpression::Ptr;
 
} // namespace BinaryAnalysis
} // namespace Rose
 
#endif
 
// #include's for sub-namespaces and sub-directories
#include <Rose/BinaryAnalysis/Architecture/BasicTypes.h>
#include <Rose/BinaryAnalysis/CallingConvention/BasicTypes.h>
#include <Rose/BinaryAnalysis/Concolic/BasicTypes.h>
#include <Rose/BinaryAnalysis/Debugger/BasicTypes.h>
#include <Rose/BinaryAnalysis/Disassembler/BasicTypes.h>
#include <Rose/BinaryAnalysis/Dwarf/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
#include <Rose/BinaryAnalysis/ModelChecker/BasicTypes.h>
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
#include <Rose/BinaryAnalysis/Variables/BasicTypes.h>
 
#endif