func_decl * bv_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters, 
                                       unsigned num_args, expr * const * args, sort * range) {
    int bv_size;
    if (k == OP_INT2BV && get_int2bv_size(num_parameters, parameters, bv_size)) {
        // bv_size is filled in.
    }
    else if (k == OP_BV_NUM) {
        return mk_num_decl(num_parameters, parameters, num_args);
    }
    else if (k == OP_BIT0) {
        return m_bit0;
    }
    else if (k == OP_BIT1) {
        return m_bit1;
    }
    else if (k == OP_CARRY) {
        return m_carry;
    }
    else if (k == OP_XOR3) {
        return m_xor3;
    }
    else if (k == OP_MKBV) {
        return decl_plugin::mk_func_decl(k, num_parameters, parameters, num_args, args, range);
    }
    else if (num_args == 0 || !get_bv_size(args[0], bv_size)) {
        m_manager->raise_exception("operator is applied to arguments of the wrong sort");
        return 0;
    }
    func_decl * r = mk_func_decl(k, bv_size);
    if (r != 0) {
        return r;
    }
    return decl_plugin::mk_func_decl(k, num_parameters, parameters, num_args, args, range);
}
Пример #2
0
func_decl * bv_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
                                         unsigned num_args, expr * const * args, sort * range) {
    ast_manager& m = *m_manager;
    int bv_size;
    if (k == OP_INT2BV && get_int2bv_size(num_parameters, parameters, bv_size)) {
        // bv_size is filled in.
    }
    else if (k == OP_BV_NUM) {
        return mk_num_decl(num_parameters, parameters, num_args);
    }
    else if (k == OP_BIT0) {
        return m_bit0;
    }
    else if (k == OP_BIT1) {
        return m_bit1;
    }
    else if (k == OP_CARRY) {
        return m_carry;
    }
    else if (k == OP_XOR3) {
        return m_xor3;
    }
    else if (k == OP_MKBV) {
        return decl_plugin::mk_func_decl(k, num_parameters, parameters, num_args, args, range);
    }
    else if (num_args == 0 || !get_bv_size(args[0], bv_size)) {
        m.raise_exception("operator is applied to arguments of the wrong sort");
        return nullptr;
    }
    func_decl * r = mk_func_decl(k, bv_size);
    if (r != nullptr) {
        if (num_args != r->get_arity()) {
            if (r->get_info()->is_associative()) {
                sort * fs = r->get_domain(0);
                for (unsigned i = 0; i < num_args; ++i) {
                    if (m.get_sort(args[i]) != fs) {
                        m_manager->raise_exception("declared sorts do not match supplied sorts");
                        return nullptr;
                    }
                }
                return r;
            }
            else {
                m.raise_exception("declared arity mismatches supplied arity");
                return nullptr;
            }
        }
        for (unsigned i = 0; i < num_args; ++i) {
            if (m.get_sort(args[i]) != r->get_domain(i)) {
                std::ostringstream buffer;
                buffer << "Argument " << mk_pp(args[i], m) << " at position " << i << " does not match declaration " << mk_pp(r, m);
                m.raise_exception(buffer.str().c_str());
                return nullptr;
            }
        }
        return r;
    }
    return decl_plugin::mk_func_decl(k, num_parameters, parameters, num_args, args, range);
}
Пример #3
0
func_decl * bv_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
                                         unsigned arity, sort * const * domain, sort * range) {
    int bv_size;
    if (k == OP_INT2BV && get_int2bv_size(num_parameters, parameters, bv_size)) {
        // bv_size is filled in.
    }
    else if (k == OP_BV_NUM) {
        return mk_num_decl(num_parameters, parameters, arity);
    }
    else if (k == OP_BIT0) {
        return m_bit0;
    }
    else if (k == OP_BIT1) {
        return m_bit1;
    }
    else if (k == OP_CARRY) {
        return m_carry;
    }
    else if (k == OP_XOR3) {
        return m_xor3;
    }
    else if (k == OP_MKBV) {
        return mk_mkbv(arity, domain);
    }
    else if (arity == 0) {
        m_manager->raise_exception("no arguments supplied to bit-vector operator");
        return nullptr;
    }
    else if (!get_bv_size(domain[0], bv_size)) {
        m_manager->raise_exception("could not extract bit-vector size");
        return nullptr;
    }
    func_decl * r = mk_func_decl(k, bv_size);
    if (r != nullptr) {
        if (arity != r->get_arity()) {
            if (r->get_info()->is_associative())
                arity = r->get_arity();
            else {
                m_manager->raise_exception("declared arity mismatches supplied arity");
                return nullptr;
            }
        }
        for (unsigned i = 0; i < arity; ++i) {
            if (domain[i] != r->get_domain(i)) {
                m_manager->raise_exception("declared sorts do not match supplied sorts");
                return nullptr;
            }
        }
        return r;
    }
    int r_size;
    switch (k) {
    case OP_BIT2BOOL:
        return mk_bit2bool(bv_size, num_parameters, parameters, arity, domain);
    case OP_INT2BV:
        return mk_int2bv(bv_size, num_parameters, parameters, arity, domain);
    case OP_BV2INT:
        return mk_bv2int(bv_size, num_parameters, parameters, arity, domain);
    case OP_CONCAT:
        if (!get_concat_size(arity, domain, r_size))
            m_manager->raise_exception("invalid concat application");
        return m_manager->mk_func_decl(m_concat_sym, arity, domain, get_bv_sort(r_size),
                                       func_decl_info(m_family_id, k));
    case OP_SIGN_EXT:
        if (!get_extend_size(num_parameters, parameters, arity, domain, r_size))
            m_manager->raise_exception("invalid sign_extend application");
        return m_manager->mk_func_decl(m_sign_extend_sym, arity, domain, get_bv_sort(r_size),
                                       func_decl_info(m_family_id, k, num_parameters, parameters));
    case OP_ZERO_EXT:
        if (!get_extend_size(num_parameters, parameters, arity, domain, r_size))
            m_manager->raise_exception("invalid zero_extend application");
        return m_manager->mk_func_decl(m_zero_extend_sym, arity, domain, get_bv_sort(r_size),
                                       func_decl_info(m_family_id, k, num_parameters, parameters));
    case OP_EXTRACT:
        if (!get_extract_size(num_parameters, parameters, arity, domain, r_size))
            m_manager->raise_exception("invalid extract application");
        return m_manager->mk_func_decl(m_extract_sym, arity, domain, get_bv_sort(r_size),
                                       func_decl_info(m_family_id, k, num_parameters, parameters));
    case OP_ROTATE_LEFT:
        if (arity != 1)
            m_manager->raise_exception("rotate left expects one argument");
        return m_manager->mk_func_decl(m_rotate_left_sym, arity, domain, domain[0],
                                       func_decl_info(m_family_id, k, num_parameters, parameters));
    case OP_ROTATE_RIGHT:
        if (arity != 1)
            m_manager->raise_exception("rotate right expects one argument");
        return m_manager->mk_func_decl(m_rotate_right_sym, arity, domain, domain[0],
                                       func_decl_info(m_family_id, k, num_parameters, parameters));
    case OP_REPEAT:
        if (arity != 1)
            m_manager->raise_exception("repeat expects one argument");
        if (num_parameters != 1 || !parameters[0].is_int() || parameters[0].get_int() == 0)
            m_manager->raise_exception("repeat expects one nonzero integer parameter");
        if (!get_bv_size(domain[0], bv_size))
            m_manager->raise_exception("repeat expects an argument with bit-vector sort");
        return m_manager->mk_func_decl(m_repeat_sym, arity, domain, get_bv_sort(bv_size * parameters[0].get_int()),
                                       func_decl_info(m_family_id, k, num_parameters, parameters));
    default:
        return nullptr;
    }
}