bool sat_path_enumeratort::next(patht &path) { scratch_programt program(symbol_table); program.append(fixed); program.append(fixed); // Let's make sure that we get a path we have not seen before. for(std::list<distinguish_valuest>::iterator it=accelerated_paths.begin(); it!=accelerated_paths.end(); ++it) { exprt new_path=false_exprt(); for(distinguish_valuest::iterator jt=it->begin(); jt!=it->end(); ++jt) { exprt distinguisher=jt->first; bool taken=jt->second; if(taken) { not_exprt negated(distinguisher); distinguisher.swap(negated); } or_exprt disjunct(new_path, distinguisher); new_path.swap(disjunct); } program.assume(new_path); } program.add_instruction(ASSERT)->guard=false_exprt(); try { if(program.check_sat()) { #ifdef DEBUG std::cout << "Found a path" << std::endl; #endif build_path(program, path); record_path(program); return true; } } catch(std::string s) { std::cout << "Error in fitting polynomial SAT check: " << s << std::endl; } catch(const char *s) { std::cout << "Error in fitting polynomial SAT check: " << s << std::endl; } return false; }
bool disjunctive_polynomial_accelerationt::fit_polynomial( exprt &var, polynomialt &polynomial, patht &path) { // These are the variables that var depends on with respect to the body. std::vector<expr_listt> parameters; std::set<std::pair<expr_listt, exprt> > coefficients; expr_listt exprs; scratch_programt program(symbol_table); expr_sett influence; cone_of_influence(var, influence); #ifdef DEBUG std::cout << "Fitting a polynomial for " << expr2c(var, ns) << ", which depends on:" << std::endl; for (expr_sett::iterator it = influence.begin(); it != influence.end(); ++it) { std::cout << expr2c(*it, ns) << std::endl; } #endif for (expr_sett::iterator it = influence.begin(); it != influence.end(); ++it) { if (it->id() == ID_index || it->id() == ID_dereference) { // Hack: don't accelerate anything that depends on an array // yet... return false; } exprs.clear(); exprs.push_back(*it); parameters.push_back(exprs); exprs.push_back(loop_counter); parameters.push_back(exprs); } // N exprs.clear(); exprs.push_back(loop_counter); parameters.push_back(exprs); // N^2 exprs.push_back(loop_counter); parameters.push_back(exprs); // Constant exprs.clear(); parameters.push_back(exprs); for (std::vector<expr_listt>::iterator it = parameters.begin(); it != parameters.end(); ++it) { symbolt coeff = utils.fresh_symbol("polynomial::coeff", signed_poly_type()); coefficients.insert(make_pair(*it, coeff.symbol_expr())); // XXX HACK HACK HACK // I'm just constraining these coefficients to prevent overflows messing things // up later... Should really do this properly somehow. program.assume(binary_relation_exprt(from_integer(-(1 << 10), signed_poly_type()), "<", coeff.symbol_expr())); program.assume(binary_relation_exprt(coeff.symbol_expr(), "<", from_integer(1 << 10, signed_poly_type()))); } // Build a set of values for all the parameters that allow us to fit a // unique polynomial. std::map<exprt, exprt> ivals1; std::map<exprt, exprt> ivals2; std::map<exprt, exprt> ivals3; for (expr_sett::iterator it = influence.begin(); it != influence.end(); ++it) { symbolt ival1 = utils.fresh_symbol("polynomial::init", it->type()); symbolt ival2 = utils.fresh_symbol("polynomial::init", it->type()); symbolt ival3 = utils.fresh_symbol("polynomial::init", it->type()); program.assume(binary_relation_exprt(ival1.symbol_expr(), "<", ival2.symbol_expr())); program.assume(binary_relation_exprt(ival2.symbol_expr(), "<", ival3.symbol_expr())); #if 0 if (it->type() == signedbv_typet()) { program.assume(binary_relation_exprt(ival1.symbol_expr(), ">", from_integer(-100, it->type()))); } program.assume(binary_relation_exprt(ival1.symbol_expr(), "<", from_integer(100, it->type()))); if (it->type() == signedbv_typet()) { program.assume(binary_relation_exprt(ival2.symbol_expr(), ">", from_integer(-100, it->type()))); } program.assume(binary_relation_exprt(ival2.symbol_expr(), "<", from_integer(100, it->type()))); if (it->type() == signedbv_typet()) { program.assume(binary_relation_exprt(ival3.symbol_expr(), ">", from_integer(-100, it->type()))); } program.assume(binary_relation_exprt(ival3.symbol_expr(), "<", from_integer(100, it->type()))); #endif ivals1[*it] = ival1.symbol_expr(); ivals2[*it] = ival2.symbol_expr(); ivals3[*it] = ival3.symbol_expr(); //ivals1[*it] = from_integer(1, it->type()); } std::map<exprt, exprt> values; for (expr_sett::iterator it = influence.begin(); it != influence.end(); ++it) { values[*it] = ivals1[*it]; } // Start building the program. Begin by decl'ing each of the // master distinguishers. for (std::list<exprt>::iterator it = distinguishers.begin(); it != distinguishers.end(); ++it) { program.add_instruction(DECL)->code = code_declt(*it); } // Now assume our polynomial fits at each of our sample points. assert_for_values(program, values, coefficients, 1, fixed, var); for (int n = 0; n <= 1; n++) { for (expr_sett::iterator it = influence.begin(); it != influence.end(); ++it) { values[*it] = ivals2[*it]; assert_for_values(program, values, coefficients, n, fixed, var); values[*it] = ivals3[*it]; assert_for_values(program, values, coefficients, n, fixed, var); values[*it] = ivals1[*it]; } } for (expr_sett::iterator it = influence.begin(); it != influence.end(); ++it) { values[*it] = ivals3[*it]; } assert_for_values(program, values, coefficients, 0, fixed, var); assert_for_values(program, values, coefficients, 1, fixed, var); assert_for_values(program, values, coefficients, 2, fixed, var); // Let's make sure that we get a path we have not seen before. for (std::list<distinguish_valuest>::iterator it = accelerated_paths.begin(); it != accelerated_paths.end(); ++it) { exprt new_path = false_exprt(); for (distinguish_valuest::iterator jt = it->begin(); jt != it->end(); ++jt) { exprt distinguisher = jt->first; bool taken = jt->second; if (taken) { not_exprt negated(distinguisher); distinguisher.swap(negated); } or_exprt disjunct(new_path, distinguisher); new_path.swap(disjunct); } program.assume(new_path); } utils.ensure_no_overflows(program); // Now do an ASSERT(false) to grab a counterexample program.add_instruction(ASSERT)->guard = false_exprt(); // If the path is satisfiable, we've fitted a polynomial. Extract the // relevant coefficients and return the expression. try { if (program.check_sat()) { #ifdef DEBUG std::cout << "Found a polynomial" << std::endl; #endif utils.extract_polynomial(program, coefficients, polynomial); build_path(program, path); record_path(program); return true; } } catch (std::string s) { std::cout << "Error in fitting polynomial SAT check: " << s << std::endl; } catch (const char *s) { std::cout << "Error in fitting polynomial SAT check: " << s << std::endl; } return false; }
/* * a server was selected in the tree widget. * * put up some server info. */ static void server_browse_entry_selected(GqBrowserNode *be, int error_context, GQTreeWidget *ctree, GQTreeWidgetNode *node, GqTab *tab) { GtkWidget *pane2_scrwin, *pane2_vbox, *label, *e; GtkWidget *table; char *server_name; int row = 0; char buf[128]; LDAP *ld; GqBrowserNodeServer *entry; g_assert(GQ_IS_BROWSER_NODE_SERVER(be)); entry = GQ_BROWSER_NODE_SERVER(be); ld = open_connection(error_context, entry->server); if (!ld) return; server_name = entry->server->name; /* dn_by_node(node); */ record_path(tab, GQ_BROWSER_NODE(entry), ctree, node); pane2_scrwin = GQ_TAB_BROWSE(tab)->pane2_scrwin; pane2_vbox = GQ_TAB_BROWSE(tab)->pane2_vbox; /* gtk_widget_destroy(pane2_vbox); */ /* remove the viewport of the scrolled window. This should _really_ destroy the widgets below it. The pane2_scrwin is a GtkBin Object and thus has only one child, use this to obtain the viewport */ gtk_container_remove(GTK_CONTAINER(pane2_scrwin), GTK_BIN(pane2_scrwin)->child); pane2_vbox = gtk_vbox_new(FALSE, 2); GQ_TAB_BROWSE(tab)->pane2_vbox = pane2_vbox; gtk_widget_show(pane2_vbox); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(pane2_scrwin), pane2_vbox); table = gtk_table_new(5, 2, FALSE); gtk_container_border_width(GTK_CONTAINER(table), 5); gtk_widget_show(table); gtk_box_pack_start(GTK_BOX(pane2_vbox), table, FALSE, FALSE, 5); /* Nickname */ label = gtk_label_new(_("Nickname")); gtk_widget_show(label); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_SHRINK, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); e = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(e), server_name); gtk_widget_set_sensitive(e, FALSE); gtk_widget_show(e); gtk_table_attach(GTK_TABLE(table), e, 1, 2, row, row+1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); row++; /* Host name */ label = gtk_label_new(_("Hostname")); gtk_widget_show(label); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_SHRINK, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); e = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(e), entry->server->ldaphost); gtk_widget_set_sensitive(e, FALSE); gtk_widget_show(e); gtk_table_attach(GTK_TABLE(table), e, 1, 2, row, row+1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); row++; /* Port */ label = gtk_label_new(_("Port")); gtk_widget_show(label); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_SHRINK, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); g_snprintf(buf, sizeof(buf), "%d", entry->server->ldapport); e = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(e), buf); gtk_widget_set_sensitive(e, FALSE); gtk_widget_show(e); gtk_table_attach(GTK_TABLE(table), e, 1, 2, row, row+1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); row++; /* Connection caching */ label = gtk_label_new(_("Connection caching")); gtk_widget_show(label); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_SHRINK, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); g_snprintf(buf, sizeof(buf), "%s", entry->server->cacheconn ? _("on") : _("off")); e = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(e), buf); gtk_widget_set_sensitive(e, FALSE); gtk_widget_show(e); gtk_table_attach(GTK_TABLE(table), e, 1, 2, row, row+1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); row++; /* TLS */ label = gtk_label_new(_("TLS")); gtk_widget_show(label); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_SHRINK, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); g_snprintf(buf, sizeof(buf), "%s", entry->server->enabletls ? _("on") : _("off")); e = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(e), buf); gtk_widget_set_sensitive(e, FALSE); gtk_widget_show(e); gtk_table_attach(GTK_TABLE(table), e, 1, 2, row, row+1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); row++; #if HAVE_LDAP_CLIENT_CACHE label = gtk_label_new(_("Client-side caching")); gtk_widget_show(label); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_SHRINK, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); g_snprintf(buf, sizeof(buf), "%s", (entry->server->local_cache_timeout >= 0) ? _("on") : _("off")); e = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(e), buf); gtk_widget_set_sensitive(e, FALSE); gtk_widget_show(e); gtk_table_attach(GTK_TABLE(table), e, 1, 2, row, row+1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); row++; #endif /* Connections so far */ label = gtk_label_new(_("Connections so far")); gtk_widget_show(label); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_SHRINK, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); g_snprintf(buf, sizeof(buf), "%d", entry->server->incarnation); e = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(e), buf); gtk_widget_set_sensitive(e, FALSE); gtk_widget_show(e); gtk_table_attach(GTK_TABLE(table), e, 1, 2, row, row+1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); row++; if (ld) { int intdata; int rc; /* void *optdata; */ char *rootDSEattr[] = { "vendorName", _("Vendor Name"), /* RFC 3045 */ "vendorVersion", _("Vendor Version"), /* RFC 3045 */ "altServer", _("Alternative Server(s)"), /* RFC 2251 */ "supportedLDAPVersion", _("Supported LDAP Version"), /* RFC 2251 */ "supportedSASLMechanisms", _("Supported SASL Mechanisms"), /* RFC 2251 */ NULL }; LDAPMessage *res, *ee; BerElement *berptr; char *attr; char **vals; int i, msg; rc = ldap_get_option(ld, LDAP_OPT_PROTOCOL_VERSION, &intdata); /* LDAP protocol version */ label = gtk_label_new(_("LDAP protocol version")); gtk_widget_show(label); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_SHRINK, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); g_snprintf(buf, sizeof(buf), "%d", intdata); e = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(e), buf); gtk_widget_set_sensitive(e, FALSE); gtk_widget_show(e); gtk_table_attach(GTK_TABLE(table), e, 1, 2, row, row+1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); row++; /* read some Information from the root DSE */ for (i = 0 ; rootDSEattr[i] && ld != NULL ; i += 2) { char *attrs[2] = { rootDSEattr[i], NULL }; msg = ldap_search_ext_s(ld, "", LDAP_SCOPE_BASE, /* scope */ "(objectClass=*)", /* filter */ attrs, /* attrs */ 0, /* attrsonly */ NULL, /* serverctrls */ NULL, /* clientctrls */ NULL, /* timeout */ LDAP_NO_LIMIT, /* sizelimit */ &res); if(msg == LDAP_NOT_SUPPORTED) { msg = ldap_search_s(ld, "", LDAP_SCOPE_BASE, "(objectClass=*)", attrs, 0, &res); } if(msg != LDAP_SUCCESS) { if (msg == LDAP_SERVER_DOWN) { close_connection(entry->server, FALSE); ld = open_connection(error_context, entry->server); } statusbar_msg("%s", ldap_err2string(msg)); } else { if(res == NULL) continue; ee = ldap_first_entry(ld, res); if (ee == NULL) { ldap_msgfree(res); continue; } attr = ldap_first_attribute(ld, res, &berptr); if (attr == NULL) { ldap_msgfree(res); #ifndef HAVE_OPENLDAP_12 if(berptr) ber_free(berptr, 0); #endif continue; } vals = ldap_get_values(ld, res, attr); if (vals) { int j; for (j = 0 ; vals[j] ; j++) ; label = gtk_label_new(rootDSEattr[i + 1]); gtk_widget_show(label); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+j, GTK_SHRINK, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); for (j = 0 ; vals[j] ; j++) { g_snprintf(buf, sizeof(buf), "%s", vals[j]); e = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(e), buf); gtk_widget_set_sensitive(e, FALSE); gtk_widget_show(e); gtk_table_attach(GTK_TABLE(table), e, 1, 2, row, row+1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); row++; } ldap_value_free(vals); } ldap_memfree(attr); #ifndef HAVE_OPENLDAP_12 if(berptr) ber_free(berptr, 0); #endif ldap_msgfree(res); } } close_connection(entry->server, FALSE); } /* gtk_box_pack_start(GTK_BOX(pane2_vbox), label, FALSE, FALSE, 0); */ }