sort * float_decl_plugin::mk_float_sort(unsigned ebits, unsigned sbits) {
parameter p1(ebits), p2(sbits);
parameter ps[2] = { p1, p2 };
sort_size sz;
sz = sort_size::mk_very_big(); // TODO: refine
return m_manager->mk_sort(symbol("FloatingPoint"), sort_info(m_family_id, FLOAT_SORT, sz, 2, ps));
}
virtual void set_manager(ast_manager * m, family_id id) {
SASSERT(m->is_format_manager());
decl_plugin::set_manager(m, id);
m_format_sort = m->mk_sort(symbol("format"), sort_info(id, FORMAT_SORT));
m->inc_ref(m_format_sort);
}
void ast_translation::mk_sort(sort * s, frame & fr) {
sort_info * si = s->get_info();
sort * new_s;
if (si == 0) {
// TODO: investigate: this branch is probably unreachable.
// It became unreachable after we started using mk_uninterpreted_sort for creating uninterpreted sorts,
// and mk_uninterpreted_sort actually creates a user_sort.
new_s = m_to_manager.mk_uninterpreted_sort(s->get_name());
SASSERT(m_result_stack.size() == fr.m_rpos);
}
else {
buffer<parameter> ps;
copy_params(s, fr.m_rpos, ps);
new_s = m_to_manager.mk_sort(s->get_name(), sort_info(si->get_family_id(),
si->get_decl_kind(),
si->get_num_elements(),
si->get_num_parameters(),
ps.c_ptr(),
s->private_parameters()));
}
m_result_stack.shrink(fr.m_rpos);
m_result_stack.push_back(new_s);
m_extra_children_stack.shrink(fr.m_cpos);
cache(s, new_s);
m_frame_stack.pop_back();
}
int baseprint(st_info *buf_head,char *data_name)
{
unsigned int i = 0,j = 0,check;
st_info *p1 = buf_head->next;
system("cls");
print_tips(" 浏览学生体检信息 ");
printf(menu_print);
if(p1 == NULL)
{
printf("\n\n\n Error!-----没有数据可以显示!请录入!按任意键返回");
fflush(stdin);
getch();
return 0;
}
while(p1)
{
++j;
p1 = p1->next;
}
p1 = buf_head->next;
while(p1!= NULL)
{
++i;
printf("\n");
printf(STINFO);
p1 = p1->next;
if(i % flag_page == 0 || i == j)
{
print_star();
if(i == j)
printf("\n**************************** 输出完毕 ***********************");
printf("\n 1.按身高升序 2.按体重升序 3.按肺活量升序 4.按学号升序");
printf("\n 5.按身高降序 6.按体重降序 7.按肺活量降序 8.按学号降序");
printf("\n **共%u页***************ESC键:返回菜单********字母键:翻页***********第%u页****\r",j/flag_page + 1,(i/flag_page + (( i==j )?1:0)));
fflush(stdin);
check = getch();
if(check <= 56 && check >= 49)
{
sort_info(buf_head,data_name,check - 48);
getch();
p1 = buf_head->next;
}
switch (check)
{
case 0:math_info(buf_head);break;
case 27:return 1;
default:if(i == j)
return 1;
break;
}
system("cls");
print_tips(" 浏览学生体检信息 ");
printf(menu_print);
}
}
getch();
return 1;
}
sort * datatype_decl_plugin::mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) {
try {
if (k != DATATYPE_SORT) {
throw invalid_datatype();
}
buffer<bool, false, 256> found;
unsigned num_types = read_int(num_parameters, parameters, 0, found);
if (num_types == 0) {
throw invalid_datatype();
}
unsigned tid = read_int(num_parameters, parameters, 1, found);
for (unsigned j = 0; j < num_types; j++) {
read_symbol(num_parameters, parameters, 2 + 2*j, found); // type name
unsigned o = read_int(num_parameters, parameters, 2 + 2*j + 1, found);
unsigned num_constructors = read_int(num_parameters, parameters, o, found);
if (num_constructors == 0) {
throw invalid_datatype();
}
for (unsigned s = 1; s <= num_constructors; s++) {
unsigned k_i = read_int(num_parameters, parameters, o + s, found);
read_symbol(num_parameters, parameters, k_i, found); // constructor name
read_symbol(num_parameters, parameters, k_i + 1, found); // recognizer name
unsigned num_accessors = read_int(num_parameters, parameters, k_i + 2, found);
unsigned first_accessor = k_i+3;
for (unsigned r = 0; r < num_accessors; r++) {
read_symbol(num_parameters, parameters, first_accessor + 2*r, found); // accessor name
parameter const & a_type = read(num_parameters, parameters, first_accessor + 2*r + 1, found); // accessort type
if (!a_type.is_int() && !a_type.is_ast()) {
throw invalid_datatype();
if (a_type.is_ast() && !is_sort(a_type.get_ast())) {
throw invalid_datatype();
}
}
}
}
}
// check if there is no garbage
if (found.size() != num_parameters || std::find(found.begin(), found.end(), false) != found.end()) {
throw invalid_datatype();
}
if (!is_well_founded(parameters)) {
m_manager->raise_exception("datatype is not well-founded");
return 0;
}
// compute datatype size
sort_size ts = get_datatype_size(parameters);
symbol const & tname = parameters[2+2*tid].get_symbol();
return m_manager->mk_sort(tname,
sort_info(m_family_id, k, ts, num_parameters, parameters, true));
}
catch (invalid_datatype) {
m_manager->raise_exception("invalid datatype");
return 0;
}
}
// --------- begin of function SERes::init1 ----------//
void SERes::init1()
{
deinit();
seed = m.get_time();
load_info();
sort_info();
build_index();
init_flag = 1;
}
inline sort * bv_decl_plugin::get_bv_sort(unsigned bv_size) {
if (bv_size < (1 << 12)) {
mk_bv_sort(bv_size);
return m_bv_sorts[bv_size];
}
parameter p(bv_size);
sort_size sz(sort_size::mk_very_big());
return m_manager->mk_sort(symbol("bv"), sort_info(m_family_id, BV_SORT, sz, 1, &p));
}
void proof_checker::hyp_decl_plugin::set_manager(ast_manager* m, family_id id) {
decl_plugin::set_manager(m,id);
m_cell = m->mk_sort(symbol("cell"), sort_info(id, CELL_SORT));
m_cons = m->mk_func_decl(symbol("cons"), m_cell, m_cell, m_cell, func_decl_info(id, OP_CONS));
m_atom = m->mk_func_decl(symbol("atom"), m->mk_bool_sort(), m_cell, func_decl_info(id, OP_ATOM));
m_nil = m->mk_const_decl(symbol("nil"), m_cell, func_decl_info(id, OP_NIL));
m->inc_ref(m_cell);
m->inc_ref(m_cons);
m->inc_ref(m_atom);
m->inc_ref(m_nil);
}
sort * fpa_decl_plugin::mk_float_sort(unsigned ebits, unsigned sbits) {
if (sbits < 2)
m_manager->raise_exception("minimum number of significand bits is 1");
if (ebits < 2)
m_manager->raise_exception("minimum number of exponent bits is 2");
parameter p1(ebits), p2(sbits);
parameter ps[2] = { p1, p2 };
sort_size sz;
sz = sort_size::mk_very_big(); // TODO: refine
return m_manager->mk_sort(symbol("FloatingPoint"), sort_info(m_family_id, FLOATING_POINT_SORT, sz, 2, ps));
}
void bv_decl_plugin::mk_bv_sort(unsigned bv_size) {
force_ptr_array_size(m_bv_sorts, bv_size + 1);
if (m_bv_sorts[bv_size] == 0) {
parameter p(bv_size);
sort_size sz;
if (sort_size::is_very_big_base2(bv_size)) {
sz = sort_size::mk_very_big();
}
else {
sz = sort_size(rational::power_of_two(bv_size));
}
m_bv_sorts[bv_size] = m_manager->mk_sort(symbol("bv"), sort_info(m_family_id, BV_SORT, sz, 1, &p));
m_manager->inc_ref(m_bv_sorts[bv_size]);
}
}
sort * float_decl_plugin::mk_rm_sort() {
return m_manager->mk_sort(symbol("RoundingMode"), sort_info(m_family_id, ROUNDING_MODE_SORT));
}
// retrieve a Sort by name
SortPtr PH::getSort (const string& s) {
map<string, SortPtr>::iterator f = sorts.find(s);
if (f == sorts.end())
throw sort_not_found() << sort_info(s);
return sorts[s];
}
