Declaration.h

#ifndef ROSE_BinaryAnalysis_CallingConvention_Declaration_H
#define ROSE_BinaryAnalysis_CallingConvention_Declaration_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/CallingConvention/BasicTypes.h>
 
#include <Rose/BinaryAnalysis/ConcreteLocation.h>
 
#include <Sawyer/Result.h>
#include <Sawyer/SharedObject.h>
 
#include <string>
#include <vector>
 
class SgAsmType;
 
namespace Rose {
namespace BinaryAnalysis {
namespace CallingConvention {
 
class Declaration: public Sawyer::SharedObject {
public:
    using Ptr = DeclarationPtr;
 
private:
    std::string name_;                                  // optional declaration name
    std::string comment_;                               // optional declaration comment
    std::string sourceCode_;                            // string from which this declaration was parsed
    DefinitionPtr callingConvention_;                   // required calling convention definition
    SgAsmType *returnType_ = nullptr;                   // type of the function return value
    std::vector<std::pair<SgAsmType*, std::string>> arguments_; // types (and names) of the arguments
    std::vector<std::vector<ConcreteLocation>> argumentLocations_; // computed argument locations based on calling convention
    std::vector<ConcreteLocation> returnLocations_;     // location of return value(s)
 
public:
    ~Declaration();
protected:
    explicit Declaration(const DefinitionPtr&);
public:
    static Ptr instance(const DefinitionPtr&, const std::string&);
 
public:
    const std::string& name() const;
    void name(const std::string&);
    const std::string& comment() const;
    void comment(const std::string&);
    const std::string& toString() const;
 
    DefinitionPtr callingConvention() const;
 
    SgAsmType* returnType() const;
 
    size_t nArguments() const;
 
    SgAsmType* argumentType(size_t index) const;
 
    const std::string& argumentName(size_t index) const;
 
    const std::vector<std::pair<SgAsmType*, std::string>>& arguments() const;
 
public:
    Sawyer::Result<std::vector<ConcreteLocation>, std::string> argumentLocation(size_t index) const;
    Sawyer::Result<std::vector<ConcreteLocation>, std::string> argumentLocation(const std::string &argName) const;
    Sawyer::Result<std::vector<ConcreteLocation>, std::string> returnLocation() const;
 
private:
    // Compute locations for all arguments or throw an exception
    void computeArgumentLocations();
    void computeReturnLocations();
};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif