bool MSConnectivityScore::check_assignment(NNGraph &G, unsigned int node_handle,
Assignment const &assignment,
EdgeSet &picked) const {
MSConnectivityRestraint::ExperimentalTree::Node const *node =
tree_.get_node(node_handle);
MSConnectivityRestraint::ExperimentalTree::Node::Label const &lb =
node->get_label();
Vector<Tuples> new_tuples;
Ints empty_vector;
for (unsigned int i = 0; i < lb.size(); ++i) {
int prot_count = lb[i].second;
unsigned int id = lb[i].first;
while (new_tuples.size() < id)
new_tuples.push_back(Tuples(empty_vector, 0));
if (prot_count > 0) {
if (!assignment[id].empty()) {
Ints const &configuration = assignment[id].get_tuple();
if (prot_count > int(configuration.size())) {
IMP_THROW("Experimental tree is inconsistent",
IMP::ValueException);
}
new_tuples.push_back(Tuples(configuration, prot_count));
} else {
IMP_THROW("Experimental tree is inconsistent",
IMP::ValueException);
}
} else
new_tuples.push_back(Tuples(empty_vector, 0));
}
while (new_tuples.size() <
restraint_.particle_matrix_.get_number_of_classes())
new_tuples.push_back(Tuples(empty_vector, 0));
Assignment new_assignment(new_tuples);
if (new_assignment.empty()) return false;
do {
NNGraph ng = build_subgraph_from_assignment(G, new_assignment);
if (is_connected(ng)) {
EdgeSet n_picked;
bool good = true;
for (unsigned int i = 0; i < node->get_number_of_children(); ++i) {
unsigned int child_handle = node->get_child(i);
if (!check_assignment(ng, child_handle, new_assignment, n_picked)) {
good = false;
break;
}
}
if (good) {
add_edges_to_set(ng, n_picked);
picked.insert(n_picked.begin(), n_picked.end());
return true;
}
}
} while (new_assignment.next());
return false;
}
void check_return(expression e)
{
type ret = current_return_type();
if (type_void(ret))
{
if (pedantic || !type_void(e->type))
warning("`return' with a value, in function returning void");
}
else
{
check_assignment(ret, default_conversion_for_assignment(e), e, "return", NULL, NULL, 0);
/* XXX: Missing warning about returning address of local var */
}
}
bool MSConnectivityScore::perform_search(NNGraph &G, EdgeSet &picked) const {
unsigned int root_handle = tree_.get_root();
MSConnectivityRestraint::ExperimentalTree::Node const *node =
tree_.get_node(root_handle);
MSConnectivityRestraint::ExperimentalTree::Node::Label const &lb =
node->get_label();
Vector<Tuples> tuples;
Ints empty_vector;
for (unsigned int i = 0; i < lb.size(); ++i) {
int prot_count = lb[i].second;
unsigned int id = lb[i].first;
while (tuples.size() < id) tuples.push_back(Tuples(empty_vector, 0));
if (prot_count > 0) {
tuples.push_back(
Tuples(restraint_.particle_matrix_.get_all_proteins_in_class(id),
prot_count));
} else
tuples.push_back(Tuples(empty_vector, 0));
}
while (tuples.size() < restraint_.particle_matrix_.get_number_of_classes())
tuples.push_back(Tuples(empty_vector, 0));
Assignment assignment(tuples);
if (assignment.empty()) return false;
do {
NNGraph ng = build_subgraph_from_assignment(G, assignment);
if (is_connected(ng)) {
EdgeSet n_picked;
bool good = true;
for (unsigned int i = 0; i < node->get_number_of_children(); ++i) {
unsigned int child_handle = node->get_child(i);
if (!check_assignment(ng, child_handle, assignment, n_picked)) {
good = false;
break;
}
}
if (good) {
add_edges_to_set(ng, n_picked);
picked.insert(n_picked.begin(), n_picked.end());
return true;
}
}
} while (assignment.next());
return false;
}
int check_statement(ast::abstract::Statement* statement) {
assert(statement != nullptr);
switch(*statement) {
case ast::ReturnNode:
return check_return(dynamic_cast<ast::Return*>(statement));
break;
case ast::BranchNode:
return check_branch(dynamic_cast<ast::Branch*>(statement));
break;
case ast::AssignmentNode:
return check_assignment(dynamic_cast<ast::Assignment*>(statement));
break;
case ast::WhileNode:
return check_while(dynamic_cast<ast::While*>(statement));
break;
case ast::VoidContextNode:
return check_void_context(dynamic_cast<ast::VoidContext*>(statement));
break;
}
assert(false);
return EXIT_SUCCESS;
}
bool check_inst(struct instruction *i, struct type *ret, struct symtable *syms)
{
switch(i->kind)
{
case funcall:
{
struct type *res;
return check_funcall(i->instr.funcall, syms, &res);
}
case assignment:
return check_assignment(i->instr.assignment, syms);
case ifthenelse:
{
struct ifthenelse* e = i->instr.ifthenelse;
char *t1 = check_expr(e->cond, syms);
if (!t1)
return false;
if(strcmp(t1, TYPE_BOOLEAN) == 0)
{
for(unsigned int i =0; i < e->instructions.size; ++i)
{
if (!check_inst(list_nth(e->instructions, i), ret, syms))
{
return false;
}
}
for(unsigned int i =0; i < e->elseblock.size; ++i)
{
if(!check_inst(list_nth(e->elseblock,i), ret, syms))
{
return false;
}
}
return true;
}
error(e->cond->pos, "condition should be a boolean");
return false;
}
case switchcase:
{
char *t1 = check_expr(i->instr.switchcase->cond, syms);
if(!t1)
return false;
for(unsigned int l = 0; l < i->instr.switchcase->caseblocklist.size; ++l)
{
for( unsigned int j = 0; j < i->instr.switchcase->caseblocklist.data[l]->exprlist.size; ++j)
{
char *t2 =
check_expr(i->instr.switchcase->caseblocklist.data[l]->exprlist.data[j],
syms);
if(!t2)
return false;
if (!equal_types(t1, t2, syms))
{
error(i->instr.switchcase->cond->pos,
"different types between switch and case\n");
return false;
}
}
for(int unsigned k = 0;
k < i->instr.switchcase->caseblocklist.data[l]->instructions.size; ++k)
{
if(!check_inst(i->instr.switchcase->caseblocklist.data[l]->instructions.data[k], ret, syms))
return false;
}
}
for(unsigned int l = 0; l < i->instr.switchcase->otherwiseblock.size; ++l)
{
if(!check_inst(i->instr.switchcase->otherwiseblock.data[l], ret, syms))
return false;
}
return true;
break;
}
case dowhile:
{
struct dowhile* e = i->instr.dowhile;
char *t = check_expr(e->cond, syms);
if(strcmp(t, TYPE_BOOLEAN) == 0)
{
for(unsigned int i = 0; i < e->instructions.size; ++i)
{
if(!check_inst(list_nth(e->instructions,i), ret, syms))
return false;
}
return true;
}
error(e->cond->pos, "condition should be a boolean");
return false;
}
break;
case whiledo:
{
struct whiledo* e = i->instr.whiledo;
if(strcmp(check_expr(e->cond, syms), TYPE_BOOLEAN) == 0)
{
for(unsigned int i = 0; i < e->instructions.size; ++i)
if(!check_inst(list_nth(e->instructions,i), ret, syms))
return false;
return true;
}
error(e->cond->pos, "condition should be a boolean");
return false;
}
break;
case forloop:
{
struct forloop* e = i->instr.forloop;
char *upto_type = check_expr(e->upto, syms);
if(upto_type && check_assignment(e->assignment, syms))
{
if (strcmp(upto_type, TYPE_INT) != 0)
{
error(e->upto->pos, "expected int expression");
return false;
}
else if (strcmp(e->assignment->e1->type, TYPE_INT) != 0)
{
error(e->assignment->e1->pos, "expected int expression");
return false;
}
else if (strcmp(e->assignment->e2->type, TYPE_INT) != 0)
{
error(e->assignment->e2->pos, "expected int expression");
return false;
}
else
{
for(unsigned int i = 0; i < e->instructions.size; ++i)
if(!check_inst(list_nth(e->instructions, i), ret, syms))
return false;
return true;
}
}
return false;
}
break;
case returnstmt:
{
if (!ret)
{
error(i->instr.returnstmt->expr->pos,
"algorithm is a procedure, no return statement expected");
return false;
}
char *t = check_expr(i->instr.returnstmt->expr, syms);
if (!t)
return false;
if(equal_types(t, ret->name, syms))
return true;
error(i->instr.returnstmt->expr->pos, "expected type %s, not %s", ret->name, t);
return false;
}
}
return false;
}
void visitAssignment(Assignment * p)
{
p->m_attribute.m_scope = m_st->get_scope();
p->visit_children(this);
check_assignment(p);
}
int check_types_in_expr(ast_node root) {
symhashtable_t *hash = NULL;
symnode_t *node = NULL;
ast_node anode = NULL;
switch (root->node_type) {
case OP_ASSIGN_N:
//check_binary(root);
check_assignment(root);
break;
case OP_PLUS_N:
check_binary(root);
break;
case OP_MINUS_N:
check_binary(root);
break;
case OP_NEG_N:
check_unary(root);
break;
case OP_TIMES_N:
check_binary(root);
break;
case OP_DIVIDE_N:
check_binary(root);
break;
case OP_EQUALS_N:
check_binary(root);
break;
case OP_INCREMENT_N:
check_unary(root);
break;
case OP_DECREMENT_N:
check_unary(root);
break;
case OP_MODULUS_N:
check_binary(root);
break;
case OP_LESS_THAN_N:
check_binary(root);
break;
case OP_LESS_EQUAL_N:
check_binary(root);
break;
case OP_GREATER_THAN_N:
check_binary(root);
break;
case OP_GREATER_EQUAL_N:
check_binary(root);
break;
case OP_NOT_EQUAL_N:
check_binary(root);
break;
case OP_AND_N:
check_binary(root);
break;
case OP_OR_N:
check_binary(root);
break;
case OP_NOT_N:
check_unary(root);
break;
case RETURN_N:
check_unary(root);
break;
default:
// printf("at default of switch\n");
break;
}
/* Recurse on each child of the subtree root, with a depth one
greater than the root's depth. */
ast_node child;
for (child = root->left_child; child != NULL; child = child->right_sibling)
check_types_in_expr(child);
return 0;
}