LinuxExecutor.h

#ifndef ROSE_BinaryAnalysis_Concolic_LinuxExecutor_H
#define ROSE_BinaryAnalysis_Concolic_LinuxExecutor_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_CONCOLIC_TESTING
#include <Rose/BinaryAnalysis/Concolic/BasicTypes.h>

#include <boost/serialization/export.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/base_object.hpp>
#include <Rose/BinaryAnalysis/Concolic/ConcreteExecutor.h>
#include <Sawyer/Optional.h>
#include <Sawyer/SharedPointer.h>
#include <string>

namespace Rose {
namespace BinaryAnalysis {
namespace Concolic {

class LinuxExecutor: public ConcreteExecutor {
public:
    typedef Sawyer::SharedPointer<LinuxExecutor> Ptr;

    typedef Sawyer::Optional<unsigned long> Persona;

    class Result: public ConcreteExecutorResult {
    protected:
        int         exitStatus_;   
        std::string exitKind_;     
        std::string capturedOut_;  
        std::string capturedErr_;  
    private:
        friend class boost::serialization::access;

        template<class S>
        void serialize(S &s, const unsigned /*version*/) {
            s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(ConcreteExecutorResult);
            s & BOOST_SERIALIZATION_NVP(exitStatus_);
            s & BOOST_SERIALIZATION_NVP(exitKind_);
            s & BOOST_SERIALIZATION_NVP(capturedOut_);
            s & BOOST_SERIALIZATION_NVP(capturedErr_);
        }

    public:
        Result(double rank, int exitStatus);

        Result() {} // required for boost serialization

        int exitStatus() const { return exitStatus_; }
        void exitStatus(int x);
        std::string out() const             { return capturedOut_; }
        void out(const std::string& output) { capturedOut_ = output; }

        std::string err() const             { return capturedErr_; }
        void err(const std::string& output) { capturedErr_ = output; }
        std::string exitKind() const            { return exitKind_; }
        /* @} */
    };

protected:
    bool useAddressRandomization_;                      // enable/disable address space randomization in the OS

protected:
    explicit LinuxExecutor(const DatabasePtr&);

public:
    ~LinuxExecutor();

    static Ptr instance(const DatabasePtr&);

    bool useAddressRandomization() const { return useAddressRandomization_; }
    void useAddressRandomization(bool b) { useAddressRandomization_ = b; }
    virtual
    ConcreteExecutorResult* execute(const TestCasePtr&) override;
};

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

#endif
#endif