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); */
}
