void Hungarian::print_status()
{
fprintf(stderr,"cost:\n");
print_cost();
fprintf(stderr,"assignment:\n");
print_assignment();
}
void fill(int spot)
{
if (spot == 15)
{
print_assignment();
exit(0);
}
for (int v = 0; v < n; v++)
{
if (used[v])
continue;
used[v] = true;
bool badChoice = false;
for (int t = 0; (t < nTri) && (badChoice == false); t++)
{
bool skipThisTriple = false;
bool vInThisTriple = false;
for (int k = 0; k < 3; k++)
{
int now = triples[t][k];
if (! used[now])
{
skipThisTriple = true;
}
if (v == now)
vInThisTriple = true;
}
if (!skipThisTriple && vInThisTriple)
{
int totalDist = 0;
for (int k = 0; k < 3; k++)
{
int dist = now - triples[t][(k-1)%3];
if (dist >= n/2)
dist = n - dist;
std::cout << "Dist between " << now << " and " << triples[t][(k-1)%3]
<< " is " << dist << std::endl;
totalDist += dist;
}
if (totalDist == 15) // Note that for long cycles, totalDist = 15.
badChoice = true;
}
}
if (! badChoice)
{
assignment[spot] = v;
fill(spot+1);
}
used[v] = false;
}
}
std::ostream& node(const ast::abstract::Node& node) {
switch(node) {
case ast::ExternNode:
print_extern(dynamic_cast<const ast::Extern&>(node));
break;
case ast::FuncNode:
print_func(dynamic_cast<const ast::Func&>(node));
break;
case ast::VariableNode:
print_variable(dynamic_cast<const ast::Variable&>(node));
break;
case ast::ConstantNode:
print_constant(dynamic_cast<const ast::Constant&>(node));
break;
case ast::CastNode:
print_cast(dynamic_cast<const ast::Cast&>(node));
break;
case ast::UnOpNode:
print_un_op(dynamic_cast<const ast::UnOp&>(node));
break;
case ast::BinOpNode:
print_bin_op(dynamic_cast<const ast::BinOp&>(node));
break;
case ast::CallNode:
print_call(dynamic_cast<const ast::Call&>(node));
break;
case ast::ReturnNode:
print_return(dynamic_cast<const ast::Return&>(node));
break;
case ast::BranchNode:
print_branch(dynamic_cast<const ast::Branch&>(node));
break;
case ast::AssignmentNode:
print_assignment(dynamic_cast<const ast::Assignment&>(node));
break;
case ast::WhileNode:
print_while(dynamic_cast<const ast::While&>(node));
break;
case ast::VoidContextNode:
print_void_context(dynamic_cast<const ast::VoidContext&>(node));
break;
default:
stream << "[Unknown Node] ??";
}
return stream;
}
/*template <class T_t, class G_t>*/
static int tree_dec_safety (tree_dec_lospre_t/*T_t*/ &T, cfg_lospre_t/*G_t*/ &G, const iCode *ic)
{
if(tree_dec_safety_nodes(T, find_root(T), G))
return(-1);
wassert(T[find_root(T)].assignments.begin() != T[find_root(T)].assignments.end());
const assignment_lospre &winner = *(T[find_root(T)].assignments.begin());
implement_safety(winner, G);
#ifdef DEBUG_LOSPRE
std::cout << "Winner (safety): ";
print_assignment(winner, G);
#endif
T[find_root(T)].assignments.clear();
return (0);
}
void print_instruction(struct instruction *i, int indent)
{
switch (i->kind)
{
case assignment:
print_indent(indent);
print_assignment(i->instr.assignment);
printf(";\n");
break;
case whiledo:
print_indent(indent);
printf("while (");
print_expression(i->instr.whiledo->cond);
printf(")\n");
print_indent(indent);
printf("{\n");
print_instructions(i->instr.whiledo->instructions, indent + INDENT_WIDTH);
print_indent(indent);
printf("}\n");
break;
case dowhile:
print_indent(indent);
printf("do\n");
print_indent(indent);
printf("{\n");
print_instructions(i->instr.dowhile->instructions, indent + INDENT_WIDTH);
print_indent(indent);
printf("} while (");
print_expression(i->instr.dowhile->cond);
printf(");\n");
break;
case forloop:
print_indent(indent);
printf("for (");
print_assignment(i->instr.forloop->assignment);
printf("; ");
print_expression(i->instr.forloop->assignment->e1);
if (i->instr.forloop->decreasing)
printf(" >= ");
else
printf(" <= ");
print_expression(i->instr.forloop->upto);
if (i->instr.forloop->decreasing)
printf("; --(");
else
printf("; ++(");
print_expression(i->instr.forloop->assignment->e1);
printf("))\n");
print_indent(indent);
printf("{\n");
print_instructions(i->instr.forloop->instructions, indent + INDENT_WIDTH);
print_indent(indent);
printf("}\n");
break;
case funcall:
print_funcall(i->instr.funcall, indent);
break;
case ifthenelse:
print_indent(indent);
printf("if (");
print_expression(i->instr.ifthenelse->cond);
printf(")\n");
print_indent(indent);
printf("{\n");
print_instructions(i->instr.ifthenelse->instructions, indent + INDENT_WIDTH);
print_indent(indent);
printf("}\n");
if (i->instr.ifthenelse->elseblock.size > 0)
{
print_indent(indent);
printf("else\n");
print_indent(indent);
printf("{\n");
print_instructions(i->instr.ifthenelse->elseblock, indent + INDENT_WIDTH);
print_indent(indent);
printf("}\n");
}
break;
case returnstmt:
print_indent(indent);
printf("return ");
if (i->instr.returnstmt->expr)
print_expression(i->instr.returnstmt->expr);
printf(";\n");
break;
default:
printf("instruction not handled yet\n");
case switchcase:
print_indent(indent);
printf("switch (");
print_expression(i->instr.switchcase->cond);
printf(")\n");
print_indent(indent);
printf("{\n");
print_caselist(i->instr.switchcase->caseblocklist, indent+ INDENT_WIDTH);
if(i->instr.switchcase->otherwiseblock.size > 0)
{
print_indent(indent + INDENT_WIDTH);
printf("default:\n");
print_instructions(i->instr.switchcase->otherwiseblock, indent + 2 * INDENT_WIDTH);
print_indent(indent + 2 * INDENT_WIDTH);
printf("break;\n");
}
print_indent(indent);
printf("}\n");
break;
}
}
struct trans_object *unfolding_transition(struct trans_object *t, int num, AssignmentPTR a, struct rpar_object **rpars)
{
struct trans_object *result;
struct rpar_object *rpar, *rpar_curr;
char *string_num;
bool Already_defined;
result = (struct trans_object *) Emalloc(sizeof(struct trans_object));
string_num = (char *) Ecalloc(TAG_SIZE, sizeof(char));
sprintf(string_num, "_%d", num);
result->tag = Estrdup(t->tag);
result->tag = NewStringCat(result->tag, string_num);
result->fire_rate.ff = t->fire_rate.ff;
result->fire_rate.fp = t->fire_rate.fp;
if(t->rpar!=NULL)
result->rpar= t->rpar;
else{
Already_defined = FALSE;
rpar = (struct rpar_object *) malloc(RPAOBJ_SIZE);
rpar->tag = EmptyString();
rpar->tag = NewStringCat("Rate_",t->tag);
for (rpar_curr = *rpars; rpar_curr != NULL && Already_defined == FALSE; rpar_curr = rpar_curr->next)
if(strcmp(rpar_curr->tag, rpar->tag)==0){
result->rpar= rpar_curr;
Already_defined = TRUE;
}
if(Already_defined == FALSE){
rpar->layer = NewLayerList(WHOLENET,NULL);
rpar->value = t->fire_rate.ff;
rpar->center.x = t->center.x +20;
rpar->center.y = t->center.y +20;
rpar->next = *rpars;
*rpars=rpar;
result->rpar= rpar;
}
}
result->enabl= t->enabl;
result->kind= t->kind;
result->mark_dep = t->mark_dep;
result->center.x = t->center.x;
result->center.y = t->center.y;
result->tagpos.x = t->tagpos.x;
result->tagpos.y = t->tagpos.y;
result->colpos.x = t->colpos.x;
result->colpos.y = t->colpos.y;
result->ratepos.x = t->ratepos.x;
result->ratepos.y = t->ratepos.y;
result->orient = t->orient;
result->arcs = NULL;
result->color = NULL;
result->lisp = NULL;
result->layer = NewLayerList(WHOLENET,NULL);
result->next = NULL;
fprintf(gTr_Ind_fp, "Transition %s : %s\n", result->tag, print_assignment(a));
return(result);
}
static list expandtransition(struct trans_object *trans_el, struct net_object *net, struct net_object *unf_net)
{
struct trans_object *unf_trans;
bool Found;
struct lisp_object *lisp;
struct arc_object *arc, *new_arc, *prev_arc;
guard_exprPTR g;
arcPTR *parsedArcs;
operandPTR op;
list arcs, l=NULL, curr=NULL;
int i, j, noarc, otd, vtd;
multisetPTR p_MS;
AssignmentPTR gamma;
status state;
char *new_var;
init_list(&gListParsedArcs);
init_list(&YACCParsedVarList);
#if DEBUG_UNFOLD
printf("Expand transition %s\n\n", trans_el->tag);
#endif
new_var = FreeVarName();
for (arc = trans_el->arcs, noarc = 0; arc != NULL; arc = arc->next, noarc++);
parsedArcs = (arcPTR *) Ecalloc( noarc , sizeof(arcPTR));
init_list(&YACCParsedVarList);
i = 0;
for( arc = trans_el->arcs; arc != NULL; arc = arc->next){
init_list(&l);
if((find_key(gListDomain, (generic_ptr) (arc->place)->tag , CmpDomainName, &l))==OK)
{
YACCparsedDomain = ((DomainObjPTR) DATA(l));
Found = FALSE;
if ( arc->color != NULL ) {
for ( lisp = net->lisps; lisp != NULL; lisp = lisp->next){
if(lisp->type=='f' && (strcmp(arc->color, lisp->tag)==0)) {
parsedArcs[i++]= ParseArc(lisp->text);
Found = TRUE;
}
}
if(Found == FALSE){
parsedArcs[i++]= ParseArc(arc->color);
Found = TRUE;
}
}
else if(Found == FALSE && arc->lisp != NULL)
parsedArcs[i++]= ParseArc(arc->lisp->text);
else
parsedArcs[i++]= ParseNoColoredArc(arc, new_var);
}
else
Error(UNDEF_DOM_ERR, "DefTransitions", (arc->place)->tag);
}
g = ParseGuard(trans_el, net);
create_assignment(&gamma, YACCParsedVarList);
otd = atoi(opt_list[OPT_ORIZ_TRANS_DISPLACEMENT].arg_val);
vtd = atoi(opt_list[OPT_VERT_TRANS_DISPLACEMENT].arg_val);
l = NULL;
j = 0;
init_list(&l);
for(state = first_assignment(gamma) ; state != ERROR ; j++) {
#if DEBUG_UNFOLD
printf("Assignment %s\n%",print_assignment(gamma));
#endif
if(eval_guard_expr(g, gamma) == TRUE){
unf_trans = unfolding_transition(trans_el, j, gamma, &(unf_net->rpars));
unf_trans->center.x += j*otd;
unf_trans->center.y += j*vtd;
head_insert(&l, (generic_ptr) unf_trans);
i = 0;
for( arc = trans_el->arcs; arc != NULL; arc = arc->next)
{
#if DEBUG_UNFOLD
printf("Arc %s \n", PrintArcExpression(parsedArcs[i]));
#endif
eval_arc(parsedArcs[i], gamma, &p_MS);
arcs = expand_arc(arc, p_MS, parsedArcs[i++]->domain->create_place, unf_net);
// destroy_multiset(p_MS);
curr = NULL;
while ( (curr = list_iterator(arcs, curr)) != NULL )
{
new_arc = (struct arc_object *) DATA(curr);
if(unf_trans->arcs == NULL)
unf_trans->arcs = new_arc;
else
prev_arc->next = new_arc;
prev_arc = new_arc;
}
// destroy(&arcs, NULL);
}
}
state = next_assignment(gamma);
}
return(l);
}
