VMFace.h

Go to the documentation of this file.

/*
    This file is part of cpp-ethereum.
 
    cpp-ethereum is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    cpp-ethereum is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
 
#include "ExtVMFace.h"
#include <libdevcore/Exceptions.h>
#include <memory>
 
namespace dev
{
namespace eth
{
 
struct VMException: Exception {};
#define ETH_SIMPLE_EXCEPTION_VM(X) struct X: VMException { const char* what() const noexcept override { return #X; } }
ETH_SIMPLE_EXCEPTION_VM(BadInstruction);
ETH_SIMPLE_EXCEPTION_VM(BadJumpDestination);
ETH_SIMPLE_EXCEPTION_VM(OutOfGas);
ETH_SIMPLE_EXCEPTION_VM(OutOfStack);
ETH_SIMPLE_EXCEPTION_VM(StackUnderflow);
ETH_SIMPLE_EXCEPTION_VM(DisallowedStateChange);
ETH_SIMPLE_EXCEPTION_VM(BufferOverrun);
 
struct InternalVMError : Exception {};
 
using errinfo_evmcStatusCode = boost::error_info<struct tag_evmcStatusCode, evmc_status_code>;
 
struct RevertInstruction: VMException
{
    explicit RevertInstruction(owning_bytes_ref&& _output) : m_output(std::move(_output)) {}
    RevertInstruction(RevertInstruction const&) = delete;
    RevertInstruction(RevertInstruction&&) = default;
    RevertInstruction& operator=(RevertInstruction const&) = delete;
    RevertInstruction& operator=(RevertInstruction&&) = default;
 
    char const* what() const noexcept override { return "Revert instruction"; }
 
    owning_bytes_ref&& output() { return std::move(m_output); }
 
private:
    owning_bytes_ref m_output;
};
 
 
class VMFace
{
public:
    VMFace() = default;
    virtual ~VMFace() = default;
    VMFace(VMFace const&) = delete;
    VMFace& operator=(VMFace const&) = delete;
 
    virtual owning_bytes_ref exec(u256& io_gas, ExtVMFace& _ext, OnOpFunc const& _onOp) = 0;
};
 
 
// Convert from a 256-bit integer stack/memory entry into a 160-bit Address hash.
// Currently we just pull out the right (low-order in BE) 160-bits.
inline Address asAddress(u256 _item)
{
    return right160(h256(_item));
}
 
inline u256 fromAddress(Address _a)
{
    return (u160)_a;
}
 
}
}