Пример #1
0
TypeNode exportTypeInternal(TypeNode n, NodeManager* from, NodeManager* to, ExprManagerMapCollection& vmap) {
  Debug("export") << "type: " << n << " " << n.getId() << std::endl;
  if(theory::kindToTheoryId(n.getKind()) == theory::THEORY_DATATYPES) {
    throw ExportUnsupportedException
      ("export of types belonging to theory of DATATYPES kinds unsupported");
  }
  if(n.getMetaKind() == kind::metakind::PARAMETERIZED &&
     n.getKind() != kind::SORT_TYPE) {
    throw ExportUnsupportedException
      ("export of PARAMETERIZED-kinded types (other than SORT_KIND) not supported");
  }
  if(n.getKind() == kind::TYPE_CONSTANT) {
    return to->mkTypeConst(n.getConst<TypeConstant>());
  } else if(n.getKind() == kind::BITVECTOR_TYPE) {
    return to->mkBitVectorType(n.getConst<BitVectorSize>());
  } else if(n.getKind() == kind::SUBRANGE_TYPE) {
    return to->mkSubrangeType(n.getSubrangeBounds());
  }
  Type from_t = from->toType(n);
  Type& to_t = vmap.d_typeMap[from_t];
  if(! to_t.isNull()) {
    Debug("export") << "+ mapped `" << from_t << "' to `" << to_t << "'" << std::endl;
    return *Type::getTypeNode(to_t);
  }
  NodeBuilder<> children(to, n.getKind());
  if(n.getKind() == kind::SORT_TYPE) {
    Debug("export") << "type: operator: " << n.getOperator() << std::endl;
    // make a new sort tag in target node manager
    Node sortTag = NodeBuilder<0>(to, kind::SORT_TAG);
    children << sortTag;
  }
  for(TypeNode::iterator i = n.begin(), i_end = n.end(); i != i_end; ++i) {
    Debug("export") << "type: child: " << *i << std::endl;
    children << exportTypeInternal(*i, from, to, vmap);
  }
  TypeNode out = children.constructTypeNode();// FIXME thread safety
  to_t = to->toType(out);
  return out;
}/* exportTypeInternal() */
Пример #2
0
TypeNode NodeManager::mkSort(TypeNode constructor,
                             const std::vector<TypeNode>& children,
                             uint32_t flags) {
    Assert(constructor.getKind() == kind::SORT_TYPE &&
           constructor.getNumChildren() == 0,
           "expected a sort constructor");
    Assert(children.size() > 0, "expected non-zero # of children");
    Assert( hasAttribute(constructor.d_nv, expr::SortArityAttr()) &&
            hasAttribute(constructor.d_nv, expr::VarNameAttr()),
            "expected a sort constructor" );
    std::string name = getAttribute(constructor.d_nv, expr::VarNameAttr());
    Assert(getAttribute(constructor.d_nv, expr::SortArityAttr()) == children.size(),
           "arity mismatch in application of sort constructor");
    NodeBuilder<> nb(this, kind::SORT_TYPE);
    Node sortTag = Node(constructor.d_nv->d_children[0]);
    nb << sortTag;
    nb.append(children);
    TypeNode type = nb.constructTypeNode();
    setAttribute(type, expr::VarNameAttr(), name);
    for(std::vector<NodeManagerListener*>::iterator i = d_listeners.begin(); i != d_listeners.end(); ++i) {
        (*i)->nmNotifyInstantiateSortConstructor(constructor, type, flags);
    }
    return type;
}