dl_interface::dl_interface(datalog::context& ctx) : 
    m_ctx(ctx), 
    m_pdr_rules(ctx), 
    m_old_rules(ctx),
    m_context(0) {
    m_context = alloc(pdr::context, ctx.get_fparams(), ctx.get_params(), ctx.get_manager());
}

dl_interface::dl_interface(datalog::context& ctx) :
    engine_base(ctx.get_manager(), "pdr"),
    m_ctx(ctx),
    m_pdr_rules(ctx),
    m_old_rules(ctx),
    m_context(0),
    m_refs(ctx.get_manager()) {
    m_context = alloc(pdr::context, ctx.get_fparams(), ctx.get_params(), ctx.get_manager());
}

 void set_state(void* state) {
     SASSERT(!m_state);
     m_state = state;
     symbol name("datalog_relation");
     ast_manager& m = m_context.get_manager();
     if (!m.has_plugin(name)) {
         m.register_plugin(name, alloc(datalog::dl_decl_plugin));
     }
     datalog::rel_context_base* rel = m_context.get_rel_context();
     if (rel) {
         datalog::relation_manager& r = rel->get_rmanager();
         r.register_plugin(alloc(datalog::external_relation_plugin, *this, r));
     }
 }

static void display_statistics(
    std::ostream& out,
    datalog::context& ctx,
    datalog::rule_set& orig_rules,
    datalog::instruction_block& code,
    datalog::execution_context& ex_ctx,
    bool verbose
    ) 
{
    g_piece_timer.stop();
    unsigned t_other = static_cast<int>(g_piece_timer.get_seconds()*1000);
    g_overall_time.stop();

    code.process_all_costs();
    {
        params_ref p;
        p.set_bool("output_profile", true);
        p.set_uint("profile_milliseconds_threshold", 100);
        ctx.updt_params(p);

        out << "--------------\n";
        out << "original rules\n";
        orig_rules.display(out);

        out << "---------------\n";
        out << "generated rules\n";
        ctx.display_rules(out);

        out << "--------------\n";
        out << "instructions  \n";
        code.display(*ctx.get_rel_context(), out);

        out << "--------------\n";
        out << "big relations \n";
        ex_ctx.report_big_relations(1000, out);
    }
    out << "--------------\n";
    out << "relation sizes\n";
    ctx.get_rel_context()->get_rmanager().display_relation_sizes(out);

    if (verbose) {
        out << "--------------\n";
        out << "rules\n";
        ctx.display_rules(out);
    }

    out << "Time: " << static_cast<int>(g_overall_time.get_seconds()*1000) << "ms\n";
    out << "Parsing: " << t_parsing << "ms, other: " << t_other << "ms\n";
}

 std::string get_last_status() {
     datalog::execution_result status = m_context.get_status();
     switch(status) {
     case datalog::INPUT_ERROR:
         return "input error";
     case datalog::OK:
         return "ok";
     case datalog::TIMEOUT:
         return "timeout";
     case datalog::APPROX:
         return "approximated";
     default:
         UNREACHABLE();
         return "unknown";
     }
 }

 virtual void reduce(func_decl* f, unsigned num_args, expr * const* args, expr_ref& result) {
     expr* r = 0;
     if (m_reduce_app) {
         m_reduce_app(m_state, f, num_args, args, &r);
         result = r;
         m_trail.push_back(f);
         for (unsigned i = 0; i < num_args; ++i) {
             m_trail.push_back(args[i]);
         }
         m_trail.push_back(r);
     }
     // allow fallthrough.
     if (r == 0) {
         ast_manager& m = m_context.get_manager();
         result = m.mk_app(f, num_args, args);
     }
 }

 void updt_params(params_ref const& p) {
     m_context.updt_params(p);
 }

 void collect_param_descrs(param_descrs & p) {
     m_context.collect_params(p);
 }

 void add_cover(int level, func_decl* pred, expr* predicate) {
     m_context.add_cover(level, pred, predicate);
 }

 expr_ref get_cover_delta(int level, func_decl* pred) {
     return m_context.get_cover_delta(level, pred);
 }

 unsigned get_num_levels(func_decl* pred) {
     return m_context.get_num_levels(pred);
 }

 std::string to_string(unsigned num_queries, expr* const* queries) {
     std::stringstream str;
     m_context.display_smt2(num_queries, queries, str);
     return str.str();
 }

 void add_table_fact(func_decl* r, unsigned num_args, unsigned args[]) {
     m_context.add_table_fact(r, num_args, args);
 }

 void update_rule(expr* rule, symbol const& name) {
     m_context.update_rule(rule, name);
 }

 void add_rule(expr* rule, symbol const& name) {
     m_context.add_rule(rule, name);
 }