Class for smt2 asts and functions for creating ASTs

This is to represent the structure of the smt2 instance generated by
smt2_conv.
This will allow separation between the structure and the printing of
these instances.
The structure is not used in this commit but will ultimately be used by
convert_expr.

Author: romainbrenguier

src/solvers/smt2/smt2_ast.cpp

@@ -0,0 +1,90 @@
+/*******************************************************************\
+
+Module: SMT2 solver
+
+Author: Romain Brenguier, [email protected]
+
+\*******************************************************************/
+
+#include <util/make_unique.h>
+#include "smt2_ast.h"
+
+std::unique_ptr<smt2_ast_symbolt> smt2_ast_symbolt::make(std::string symbol)
+{
+  return util_make_unique<smt2_ast_symbolt>(std::move(symbol));
+}
+
+void print(std::shared_ptr<smt2_astt> ast, std::ostream &stream)
+{
+  smt2_astt::visitort print_visitor;
+  print_visitor.data = [&stream](const std::unique_ptr<smt2_ast_leaft> &data){
+    data->print(stream);
+  };
+  print_visitor.first_child = [&stream](){
+    stream << "(";
+  };
+  print_visitor.next_sibling = [&stream](){
+    stream << " ";
+  };
+  print_visitor.parent = [&stream](){
+    stream << ")";
+  };
+
+  smt2_astt::dfs(ast, print_visitor);
+}
+
+std::shared_ptr<smt2_astt> detail::make_tree(
+  std::string &&symbol)
+{
+  return smt2_astt::make_leaf(smt2_ast_symbolt::make(std::move(symbol)));
+}
+
+std::shared_ptr<smt2_astt> detail::make_tree(
+  std::unique_ptr<smt2_ast_leaft> leaf)
+{
+  return smt2_astt::make_leaf(std::move(leaf));
+}
+
+std::shared_ptr<treet<smt2_ast_leaft>> detail::make_tree(
+  std::shared_ptr<smt2_astt> tree)
+{
+  return tree;
+}
+
+std::unique_ptr<smt2_ast_leaft> smt2_ast_intt::make(mp_integer value)
+{
+  return util_make_unique<smt2_ast_intt>(value);
+}
+
+std::shared_ptr<treet<smt2_ast_leaft>> smt2_ast_index(
+  std::shared_ptr<treet<smt2_ast_leaft>> array,
+  std::shared_ptr<treet<smt2_ast_leaft>> index)
+{
+  return smt2_ast_node(std::move(array), ".", std::move(index));
+}
+
+std::shared_ptr<treet<smt2_ast_leaft>> smt2_not(
+  std::shared_ptr<treet<smt2_ast_leaft>> ast)
+{
+  return smt2_ast_node("not", std::move(ast));
+}
+
+std::shared_ptr<treet<smt2_ast_leaft>> smt2_zero_extend(
+  const mp_integer &width)
+{
+  return smt2_ast_node("_", "zero_extend", smt2_ast_intt::make(width));
+}
+
+std::shared_ptr<treet<smt2_ast_leaft>> smt2_extract(
+  const mp_integer &width, const mp_integer &offset)
+{
+  return smt2_ast_node(
+    "_", "extract", smt2_ast_intt::make(width), smt2_ast_intt::make(offset));
+}
+
+std::shared_ptr<smt2_astt> smt2_bv(
+  const mp_integer &index, const mp_integer &width)
+{
+  const std::string bv = "bv" + integer2string(index);
+  return smt2_ast_node("_", bv, smt2_ast_leaf(width));
+}

src/solvers/smt2/smt2_ast.h

@@ -0,0 +1,270 @@
+/*******************************************************************\
+
+Module: SMT2 solver
+
+Author: Romain Brenguier, [email protected]
+
+\*******************************************************************/
+
+/// \file Abstract Syntax Tree for SMT2
+
+#ifndef CPROVER_SOLVERS_SMT2_SMT2_AST_H
+#define CPROVER_SOLVERS_SMT2_SMT2_AST_H
+
+#include <memory>
+#include <util/mp_arith.h>
+#include <vector>
+#include <util/invariant.h>
+#include <util/arith_tools.h>
+
+/// Left-child right-sibling tree
+/// https://en.wikipedia.org/wiki/Left-child_right-sibling_binary_tree
+template<typename datat>
+class treet
+{
+public:
+  static std::shared_ptr<treet<datat>> make_node(
+    std::vector<std::shared_ptr<treet<datat>>> &&children)
+  {
+    auto result = std::make_shared<treet<datat>>();
+    if(children.empty())
+      return result;
+    children.back()->parent = result;
+    for(std::size_t i = children.size() - 1; i != 0; --i)
+      children[i - 1]->next_sibling = std::move(children[i]);
+    result->first_child = std::move(children[0]);
+    return result;
+  }
+
+  static std::shared_ptr<treet<datat>> make_leaf(
+    std::unique_ptr<datat> leaf)
+  {
+    auto result = std::make_shared<treet<datat>>();
+    result->data = std::move(leaf);
+    return result;
+  }
+
+  /// Make \p child a child of \p tree. \p child is modified so that parent
+  /// points to tree. \p child should not have parent before this function is
+  /// called.
+  static void add_child(
+    std::shared_ptr<treet<datat>> tree,
+    std::shared_ptr<treet<datat>> child)
+  {
+    PRECONDITION(tree != nullptr);
+    PRECONDITION(child->parent.lock() == nullptr);
+    child->parent = tree;
+    if(tree->first_child == nullptr)
+    {
+      tree->first_child = child;
+      return;
+    }
+    auto last_visited_child = tree->first_child;
+    while(last_visited_child->next_sibling != nullptr)
+      last_visited_child = last_visited_child->next_sibling;
+    last_visited_child->next_sibling = child;
+  }
+
+  /// Type of visitor used for dfs
+  ///
+  /// A visitor has to provide functions \c first_child, \c next_sibling,
+  ///   \c parent, and \c data which are invoked at the relevant points of the
+  ///   exploration.
+  struct visitort
+  {
+    std::function<void(const std::unique_ptr<datat> &)> data;
+    std::function<void(void)> first_child;
+    std::function<void(void)> next_sibling;
+    std::function<void(void)> parent;
+  };
+
+  /// This is not recursive in order to avoid stack overflow
+  /// \param ast: pointer to the root node of a tree
+  /// \param v: visitor
+  static void dfs(std::shared_ptr<treet<datat>> ast, visitort v)
+  {
+    PRECONDITION(ast->parent.lock() == nullptr);
+    while(true)
+    {
+      if(ast->data != nullptr)
+        v.data(ast->data);
+      if(ast->first_child != nullptr)
+      {
+        v.first_child();
+        ast = ast->first_child;
+      }
+      else
+      {
+        while(ast->next_sibling == nullptr)
+        {
+          ast = ast->parent.lock();
+          if(ast == nullptr)
+            return;
+          v.parent();
+        }
+
+        v.next_sibling();
+        ast = ast->next_sibling;
+      }
+    }
+  }
+
+private:
+  std::unique_ptr<datat> data = nullptr;
+  /// Null if the node has no children
+  std::shared_ptr<treet<datat>> first_child = nullptr;
+  /// Null if the node is the last sibling
+  std::shared_ptr<treet<datat>> next_sibling = nullptr;
+  /// Set if the node has no next sibling, and it is not the root
+  std::weak_ptr<treet<datat>> parent = {};
+};
+
+class smt2_ast_leaft
+{
+public:
+  virtual void print(std::ostream &stream) const = 0;
+};
+
+class smt2_ast_symbolt : public smt2_ast_leaft
+{
+public:
+  smt2_ast_symbolt(std::string symbol) : symbol(std::move(symbol)) {}
+
+  void print(std::ostream &stream) const override
+  {
+    stream << symbol;
+  }
+
+  static std::unique_ptr<smt2_ast_symbolt> make(std::string symbol);
+
+private:
+  std::string symbol;
+};
+
+class smt2_ast_intt : public smt2_ast_leaft
+{
+public:
+  smt2_ast_intt(mp_integer value) : value(std::move(value)) {}
+
+  void print(std::ostream &stream) const override
+  {
+    stream << value;
+  }
+
+  static std::unique_ptr<smt2_ast_leaft> make(mp_integer value);
+
+  template<typename T, typename std::enable_if<std::is_integral<T>::value>::type>
+  static std::unique_ptr<smt2_ast_leaft> make(T value)
+  {
+    return make(numeric_cast_v<mp_integer>(value));
+  }
+
+private:
+  mp_integer value;
+};
+
+using smt2_astt = treet<smt2_ast_leaft>;
+
+void print(std::shared_ptr<smt2_astt> ast, std::ostream &stream);
+
+namespace detail
+{
+  std::shared_ptr<smt2_astt> make_tree(std::shared_ptr<smt2_astt> ast);
+
+  std::shared_ptr<smt2_astt> make_tree(std::string &&symbol);
+
+  std::shared_ptr<smt2_astt> make_tree(std::unique_ptr<smt2_ast_leaft> leaf);
+
+  inline void fill_vector(std::vector<std::shared_ptr<smt2_astt>> &out) {}
+
+/// Add a sequence of ASTs or strings
+  template <typename FirstType, typename... Args>
+  void fill_vector(
+    std::vector<std::shared_ptr<smt2_astt>> &out,
+    FirstType first,
+    Args &&... args)
+  {
+    out.push_back(make_tree(std::move(first)));
+    fill_vector(out, std::forward<Args>(args)...);
+  }
+}
+
+/// Make a node with no data and with children given by \p args.
+template <typename... Args>
+std::shared_ptr<smt2_astt> smt2_ast_node(Args &&... args)
+{
+  std::vector<std::shared_ptr<smt2_astt>> vector;
+  detail::fill_vector(vector, std::forward<Args>(args)...);
+  return smt2_astt::make_node(std::move(vector));
+}
+
+inline
+std::shared_ptr<smt2_astt> smt2_ast_symbol_leaf(std::string s)
+{
+  return smt2_astt::make_leaf(smt2_ast_symbolt::make(s));
+}
+
+inline
+std::shared_ptr<smt2_astt> smt2_ast_leaf(mp_integer i)
+{
+  return smt2_astt::make_leaf(smt2_ast_intt::make(i));
+}
+
+template<typename conditiont, typename true_caset, typename false_caset>
+std::shared_ptr<smt2_astt> smt2_ite(
+  conditiont condition, true_caset true_case, false_caset false_case)
+{
+  return smt2_ast_node(
+    "ite", std::move(condition), std::move(true_case), std::move(false_case));
+}
+
+template<typename leftt, typename rightt>
+std::shared_ptr<treet<smt2_ast_leaft>> smt2_eq(leftt left, rightt right)
+{
+  return smt2_ast_node("=", std::move(left), std::move(right));
+}
+
+std::shared_ptr<treet<smt2_ast_leaft>> smt2_not(
+  std::shared_ptr<treet<smt2_ast_leaft>> ast);
+
+smt2_astt smt2_eq(smt2_astt left, smt2_astt right);
+
+inline
+std::shared_ptr<smt2_astt> smt2_let(
+  std::vector<std::pair<std::shared_ptr<smt2_astt>, std::shared_ptr<smt2_astt>>>
+    symbol_value_pairs,
+  std::shared_ptr<smt2_astt> expr)
+{
+  std::vector<std::shared_ptr<smt2_astt>> bindings;
+  for(const auto &pair : symbol_value_pairs)
+  {
+    bindings.push_back(
+      smt2_ast_node(std::move(pair.first), std::move(pair.second)));
+  }
+  return smt2_ast_node(
+    "let", smt2_astt::make_node(std::move(bindings)), std::move(expr));
+}
+
+template<typename opt>
+std::shared_ptr<smt2_astt> smt2_sign_extend(opt op)
+{
+  return smt2_ast_node("_", "sign_extend", std::move(op));
+}
+
+std::shared_ptr<smt2_astt> smt2_zero_extend(
+  const mp_integer &width);
+
+std::shared_ptr<smt2_astt> smt2_extract(
+  const mp_integer &width, const mp_integer &offset);
+
+std::shared_ptr<smt2_astt> smt2_bv(
+  const mp_integer &index, const mp_integer &width);
+
+template <typename arrayt, typename indext>
+std::shared_ptr<treet<smt2_ast_leaft>> smt2_ast_index(
+  arrayt array, indext index)
+{
+  return smt2_ast_node(std::move(array), ".", std::move(index));
+}
+
+#endif // CPROVER_SOLVERS_SMT2_SMT2_AST_H