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