cleanup vrp

[libfirm] / ir / lpp / lpp.c

diff --git a/ir/lpp/lpp.c b/ir/lpp/lpp.c
index cfb7cc8..9ac76f4 100644 (file)
--- a/ir/lpp/lpp.c
+++ b/ir/lpp/lpp.c
@@ -32,6 +32,7 @@
 #include "hashptr.h"
 #include "debug.h"
 #include "set.h"
+#include "debug.h"
 
 #include "sp_matrix.h"
 #include "mps.h"
@@ -40,19 +41,19 @@
 #include "lpp_solvers.h"
 #include "lpp_net.h"
 
-#define HASH_NAME_T(n) HASH_STR((n)->name, strlen((n)->name))
+#define HASH_NAME_T(n) hash_str((n)->name)
 
-static firm_dbg_module_t *dbg = NULL;
+DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
 
 static inline char *obst_xstrdup(struct obstack *obst, const char *str)
 {
-       return obstack_copy0(obst, str, strlen(str));
+       return (char*)obstack_copy0(obst, str, strlen(str));
 }
 
 static int cmp_name_t(const void *x, const void *y, size_t size)
 {
-       const lpp_name_t *n = x;
-       const lpp_name_t *m = y;
+       const lpp_name_t *n = (const lpp_name_t*)x;
+       const lpp_name_t *m = (const lpp_name_t*)y;
        (void)size;
        return strcmp(n->name, m->name);
 }
@@ -79,7 +80,7 @@ lpp_t *lpp_new_userdef(const char *name, lpp_opt_t opt_type,
        lpp_t *lpp;
        int   idx;
 
-       dbg = firm_dbg_register("lpp");
+       DEBUG_ONLY(dbg = firm_dbg_register("lpp");)
        lpp = XMALLOCZ(lpp_t);
        obstack_init(&lpp->obst);
 
@@ -139,7 +140,7 @@ static int name2nr(set *where, const char *name)
 {
        lpp_name_t find, *found;
        find.name = name;
-       found = set_find(where, &find, sizeof(find), HASH_NAME_T(&find));
+       found = set_find(lpp_name_t, where, &find, sizeof(find), HASH_NAME_T(&find));
        return (found ? found->nr : -1);
 }
 
@@ -155,7 +156,7 @@ static int var_nr(const lpp_t *lpp, const char *name)
 
 static inline char *get_next_name(lpp_t *lpp)
 {
-       char *res = obstack_alloc(&lpp->obst, 12);
+       char *res = OALLOCN(&lpp->obst, char, 12);
        snprintf(res, 12, "_%u", lpp->next_name_number++);
        return res;
 }
@@ -175,7 +176,7 @@ int lpp_add_cst(lpp_t *lpp, const char *cst_name, lpp_cst_t cst_type, double rhs
                n.name = get_next_name(lpp);
 
        n.nr  = -1;
-       inner = set_insert(lpp->cst2nr, &n, sizeof(n), HASH_NAME_T(&n));
+       inner = set_insert(lpp_name_t, lpp->cst2nr, &n, sizeof(n), HASH_NAME_T(&n));
        assert(inner);
 
        if (inner->nr == -1) {
@@ -205,7 +206,7 @@ int lpp_add_cst_uniq(lpp_t *lpp, const char *cst_name, lpp_cst_t cst_type, doubl
 
                n.name = cst_name;
                n.nr   = -1;
-               assert(!set_find(lpp->cst2nr, &n, sizeof(n), HASH_NAME_T(&n)) &&
+               assert(!set_find(lpp_name_t, lpp->cst2nr, &n, sizeof(n), HASH_NAME_T(&n)) &&
                    "constraint already exists");
        }
        return lpp_add_cst(lpp, cst_name, cst_type, rhs);
@@ -250,12 +251,12 @@ int lpp_add_var(lpp_t *lpp, const char *var_name, lpp_var_t var_type, double obj
                n.name = get_next_name(lpp);
 
        n.nr  = -1;
-       inner = set_insert(lpp->var2nr, &n, sizeof(n), HASH_NAME_T(&n));
+       inner = set_insert(lpp_name_t, lpp->var2nr, &n, sizeof(n), HASH_NAME_T(&n));
        assert(inner);
 
        if (inner->nr == -1) {
                inner->nr            = lpp->var_next;
-               inner->value_kind    = 0;
+               inner->value_kind    = lpp_none;
                inner->value         = 0;
                inner->type.var_type = var_type;
 
@@ -411,21 +412,35 @@ void lpp_dump_plain(lpp_t *lpp, FILE *f)
 {
        int i;
 
+       fprintf(f, lpp->opt_type == lpp_minimize ? "Minimize\n" : "Maximize\n");
        for(i = 0; i < lpp->cst_next; ++i) {
-               const matrix_elem_t *elm;
                lpp_name_t *cst = lpp->csts[i];
 
+
                fprintf(f, "%16s: ", cst->name);
                matrix_foreach_in_row(lpp->m, cst->nr, elm) {
                        lpp_name_t *var = lpp->vars[elm->col];
                        /* TODO Perhaps better a define LPP_COL_RHS */
                        if(elm->col > 0)
-                               fprintf(f, "%+4.1f*%-16s ", elm->val, var->name);
+                               fprintf(f, "%+4.1f %-16s ", elm->val, var->name);
+               }
+
+               if (i == 0) {
+                       fprintf(f, "\nSubject To\n");
+                       continue;
                }
 
                fprintf(f, "%3s %+4.1f\n",
                                lpp_cst_op_to_str(cst->type.cst_type), matrix_get(lpp->m, cst->nr, 0));
        }
+
+       fprintf(f, "Binary\n");
+       for(i = 0; i < lpp->var_next; ++i) {
+               lpp_name_t *var = lpp->vars[i];
+               if (var->type.var_type == lpp_binary)
+                       fprintf(f, "%16s\n", var->name);
+       }
+       fprintf(f, "End\n");
 }
 
 /**
@@ -447,7 +462,7 @@ void lpp_serialize(lpp_comm_t *comm, const lpp_t *lpp, int with_names)
        lpp_writel(comm, lpp->set_bound);
        lpp_writed(comm, lpp->bound);
        lpp_writed(comm, lpp->time_limit_secs);
-       lpp_writed(comm, lpp->emphasis);
+       lpp_writel(comm, lpp->emphasis);
 
        for(i = 0; i < lpp->cst_next; ++i) {
                lpp_name_t *name = lpp->csts[i];
@@ -469,20 +484,16 @@ void lpp_serialize(lpp_comm_t *comm, const lpp_t *lpp, int with_names)
                        lpp_writes(comm, name->name);
        }
 
-       {
-               const matrix_elem_t *elm;
-               n = 0;
-
-               matrix_foreach(lpp->m, elm)
-                       n++;
+       n = 0;
+       matrix_foreach(lpp->m, elm)
+               n++;
 
-               assert(n == matrix_get_entries(lpp->m));
-               lpp_writel(comm, n);
-               matrix_foreach(lpp->m, elm) {
-                       lpp_writel(comm, elm->row);
-                       lpp_writel(comm, elm->col);
-                       lpp_writed(comm, elm->val);
-               }
+       assert(n == matrix_get_entries(lpp->m));
+       lpp_writel(comm, n);
+       matrix_foreach(lpp->m, elm) {
+               lpp_writel(comm, elm->row);
+               lpp_writel(comm, elm->col);
+               lpp_writed(comm, elm->val);
        }
 }
 
@@ -502,14 +513,14 @@ lpp_t *lpp_deserialize(lpp_comm_t *comm)
        with_names    = lpp_readl(comm);
        lpp->cst_next = lpp_readl(comm);
        lpp->var_next = lpp_readl(comm);
-       lpp->opt_type = lpp_readl(comm);
+       lpp->opt_type = (lpp_opt_t)lpp_readl(comm);
        lpp->name     = lpp_reads(comm);
 
        /* read options */
        lpp->set_bound       = lpp_readl(comm);
        lpp->bound           = lpp_readd(comm);
        lpp->time_limit_secs = lpp_readd(comm);
-       lpp->emphasis        = lpp_readd(comm);
+       lpp->emphasis        = (lpp_emphasis_t)lpp_readl(comm);
 
        lpp->cst_size = lpp->cst_next;
        lpp->var_size = lpp->var_next;
@@ -525,8 +536,8 @@ lpp_t *lpp_deserialize(lpp_comm_t *comm)
                lpp_name_t name, *res;
 
                name.nr            = lpp_readl(comm);
-               name.value_kind    = lpp_readl(comm);
-               name.type.cst_type = lpp_readl(comm);
+               name.value_kind    = (lpp_value_kind_t)lpp_readl(comm);
+               name.type.cst_type = (lpp_cst_t)lpp_readl(comm);
 
                if(with_names) {
                        name.name = lpp_reads(comm);
@@ -536,7 +547,7 @@ lpp_t *lpp_deserialize(lpp_comm_t *comm)
                        name.name = buf;
                }
 
-               res = set_insert(lpp->cst2nr, &name, sizeof(name), HASH_NAME_T(&name));
+               res = set_insert(lpp_name_t, lpp->cst2nr, &name, sizeof(name), HASH_NAME_T(&name));
                lpp->csts[name.nr] = res;
        }
 
@@ -544,8 +555,8 @@ lpp_t *lpp_deserialize(lpp_comm_t *comm)
                lpp_name_t name, *res;
 
                name.nr            = lpp_readl(comm);
-               name.value_kind    = lpp_readl(comm);
-               name.type.var_type = lpp_readl(comm);
+               name.value_kind    = (lpp_value_kind_t)lpp_readl(comm);
+               name.type.var_type = (lpp_var_t)lpp_readl(comm);
 
                if(with_names) {
                        name.name = lpp_reads(comm);
@@ -555,7 +566,7 @@ lpp_t *lpp_deserialize(lpp_comm_t *comm)
                        name.name = buf;
                }
 
-               res = set_insert(lpp->var2nr, &name, sizeof(name), HASH_NAME_T(&name));
+               res = set_insert(lpp_name_t, lpp->var2nr, &name, sizeof(name), HASH_NAME_T(&name));
                lpp->vars[name.nr] = res;
        }
 
@@ -618,7 +629,7 @@ void lpp_serialize_stats(lpp_comm_t *comm, const lpp_t *lpp)
 
 void lpp_deserialize_stats(lpp_comm_t *comm, lpp_t *lpp)
 {
-       lpp->sol_state  = lpp_readl(comm);
+       lpp->sol_state  = (lpp_sol_state_t)lpp_readl(comm);
        lpp->iterations = lpp_readl(comm);
        lpp->sol_time   = lpp_readd(comm);
        lpp->objval     = lpp_readd(comm);