expr_cast.h

Go to the documentation of this file.

/*******************************************************************\
 
Module:
 
Author: Nathan Phillips <Nathan.Phillips@diffblue.com>
 
\*******************************************************************/
 
#ifndef CPROVER_UTIL_EXPR_CAST_H
#define CPROVER_UTIL_EXPR_CAST_H
 
 
#include <typeinfo>
#include <type_traits>
#include <functional>
 
#include "invariant.h"
#include "expr.h"
 
template<typename T> inline bool can_cast_expr(const exprt &base);
 
template <typename T>
inline bool can_cast_type(const typet &base);
 
inline void validate_expr(const exprt &) {}
 
namespace detail // NOLINT
{
 
template<typename Ret, typename T>
struct expr_try_dynamic_cast_return_typet final
{
  static_assert(
    !std::is_reference<Ret>::value,
    "Ret must not be a reference, i.e. expr_try_dynamic_cast<const thingt> "
    "rather than expr_try_dynamic_cast<const thing &>");
 
  typedef
    typename std::conditional<
      std::is_const<T>::value,
      typename std::add_const<Ret>::type,
      Ret>::type *
    type;
};
struct expr_try_dynamic_cast_return_typet final {…};
 
} // namespace detail
namespace detail // NOLINT {…}
 
template <typename T, typename TExpr>
auto expr_try_dynamic_cast(TExpr &base)
  -> typename detail::expr_try_dynamic_cast_return_typet<T, TExpr>::type
{
  typedef
    typename detail::expr_try_dynamic_cast_return_typet<T, TExpr>::type
    returnt;
  static_assert(
    std::is_base_of<exprt, typename std::decay<TExpr>::type>::value,
    "Tried to expr_try_dynamic_cast from something that wasn't an exprt");
  static_assert(
    std::is_base_of<exprt, T>::value,
    "The template argument T must be derived from exprt.");
  if(!can_cast_expr<typename std::remove_const<T>::type>(base))
    return nullptr;
  const auto ret=static_cast<returnt>(&base);
  validate_expr(*ret);
  return ret;
}
auto expr_try_dynamic_cast(TExpr &base) {…}
 
template <typename T, typename TExpr>
std::optional<T> expr_try_dynamic_cast(TExpr &&base)
{
  static_assert(
    std::is_rvalue_reference<decltype(base)>::value,
    "This template overload must only match where base is an rvalue.");
  static_assert(
    std::is_base_of<exprt, typename std::decay<TExpr>::type>::value,
    "Tried to expr_try_dynamic_cast from something that wasn't an exprt.");
  static_assert(
    std::is_base_of<exprt, T>::value,
    "The template argument T must be derived from exprt.");
  static_assert(!std::is_const<TExpr>::value, "Attempted to move from const.");
  if(!can_cast_expr<T>(base))
    return {};
  std::optional<T> ret{static_cast<T &&>(base)};
  validate_expr(*ret);
  return ret;
}
std::optional<T> expr_try_dynamic_cast(TExpr &&base) {…}
 
template <typename T, typename TType>
auto type_try_dynamic_cast(TType &base) ->
  typename detail::expr_try_dynamic_cast_return_typet<T, TType>::type
{
  typedef
    typename detail::expr_try_dynamic_cast_return_typet<T, TType>::type returnt;
  static_assert(
    std::is_base_of<typet, typename std::decay<TType>::type>::value,
    "Tried to type_try_dynamic_cast from something that wasn't an typet");
  static_assert(
    std::is_base_of<typet, T>::value,
    "The template argument T must be derived from typet.");
  if(!can_cast_type<typename std::remove_const<T>::type>(base))
    return nullptr;
  TType::check(base);
  return static_cast<returnt>(&base);
}
auto type_try_dynamic_cast(TType &base) -> {…}
 
template <typename T, typename TType>
std::optional<T> type_try_dynamic_cast(TType &&base)
{
  static_assert(
    std::is_rvalue_reference<decltype(base)>::value,
    "This template overload must only match where base is an rvalue.");
  static_assert(
    std::is_base_of<typet, typename std::decay<TType>::type>::value,
    "Tried to type_try_dynamic_cast from something that wasn't an typet.");
  static_assert(
    std::is_base_of<typet, T>::value,
    "The template argument T must be derived from typet.");
  static_assert(!std::is_const<TType>::value, "Attempted to move from const.");
  if(!can_cast_type<T>(base))
    return {};
  TType::check(base);
  std::optional<T> ret{static_cast<T &&>(base)};
  return ret;
}
std::optional<T> type_try_dynamic_cast(TType &&base) {…}
 
namespace detail // NOLINT
{
 
template<typename Ret, typename T>
struct expr_dynamic_cast_return_typet final
{
  static_assert(
    !std::is_reference<Ret>::value,
    "Ret must not be a reference, i.e. expr_dynamic_cast<const thingt> rather "
    "than expr_dynamic_cast<const thing &>");
 
  typedef
    typename std::conditional<
      std::is_const<T>::value,
      typename std::add_const<Ret>::type,
      Ret>::type &
    type;
};
struct expr_dynamic_cast_return_typet final {…};
 
} // namespace detail
 
template<typename T, typename TExpr>
auto expr_dynamic_cast(TExpr &base)
  -> typename detail::expr_dynamic_cast_return_typet<T, TExpr>::type
{
  const auto ret=expr_try_dynamic_cast<T>(base);
  if(ret==nullptr)
    throw std::bad_cast();
  return *ret;
}
auto expr_dynamic_cast(TExpr &base) {…}
 
template<typename T, typename TExpr>
auto expr_checked_cast(TExpr &base)
  -> typename detail::expr_dynamic_cast_return_typet<T, TExpr>::type
{
  PRECONDITION(can_cast_expr<T>(base));
  return expr_dynamic_cast<T>(base);
}
auto expr_checked_cast(TExpr &base) {…}
 
template <typename T, typename TType>
auto type_checked_cast(TType &base) ->
  typename detail::expr_dynamic_cast_return_typet<T, TType>::type
{
  auto result = type_try_dynamic_cast<T>(base);
  CHECK_RETURN(result != nullptr);
  return *result;
}
auto type_checked_cast(TType &base) -> {…}
 
inline void validate_operands(
  const exprt &value,
  exprt::operandst::size_type number,
  const char *message,
  bool allow_more=false)
{
  DATA_INVARIANT(
    allow_more
      ? value.operands().size()>=number
      : value.operands().size()==number,
    message);
}
inline void validate_operands( {…}
 
#endif  // CPROVER_UTIL_EXPR_CAST_H