Fix reserved identifier violation

See issue#104. We now prefix with "s_" instead of just "_".

diff --git a/ext/repo_pubkey.h b/ext/repo_pubkey.h
index dbc7f9c7835b0b4a88779e3d225374fc655bd51b..26cf0e1f5e76ce5aec5243adb1c013ac52eb92e2 100644 (file)
--- a/ext/repo_pubkey.h
+++ b/ext/repo_pubkey.h
@@ -19,7 +19,7 @@ extern int repo_add_keyring(Repo *repo, FILE *fp, int flags);
 extern int repo_add_keydir(Repo *repo, const char *keydir, const char *suffix, int flags);
 
 /* signature parsing */
-typedef struct _solvsig {
+typedef struct s_Solvsig {
   unsigned char *sigpkt;
   int sigpktl;
   Id htype;

diff --git a/src/bitmap.h b/src/bitmap.h
index 1e895904641aea590b8195e08f4cb9517f88b02d..6609678f7a3d6575c0364c2b9af70f9283de1b4d 100644 (file)
--- a/src/bitmap.h
+++ b/src/bitmap.h
@@ -19,7 +19,7 @@
 extern "C" {
 #endif
 
-typedef struct _Map {
+typedef struct s_Map {
   unsigned char *map;
   int size;
 } Map;

diff --git a/src/chksum.c b/src/chksum.c
index 935aea80690223f7037d854700c136ccd184b0c7..df46145c6ecbb00ca3b79b113bee892c4544005e 100644 (file)
--- a/src/chksum.c
+++ b/src/chksum.c
@@ -19,7 +19,7 @@
 #include "sha1.h"
 #include "sha2.h"
 
-struct _Chksum {
+struct s_Chksum {
   Id type;
   int done;
   unsigned char result[64];

diff --git a/src/chksum.h b/src/chksum.h
index 479923a476899206120221d597d45a5d0f3a25cf..65b775bcb412a12c8bd86622c82f852d076cfa51 100644 (file)
--- a/src/chksum.h
+++ b/src/chksum.h
@@ -14,8 +14,8 @@
 extern "C" {
 #endif
 
-struct _Chksum;
-typedef struct _Chksum Chksum;
+struct s_Chksum;
+typedef struct s_Chksum Chksum;
 
 Chksum *solv_chksum_create(Id type);
 Chksum *solv_chksum_create_clone(Chksum *chk);

diff --git a/src/dataiterator.h b/src/dataiterator.h
index 148c97354d5d017a6b536c53ade2175e9aeb6f87..0649258f2bb083ee88fd322feb1129f5ebfd5592 100644 (file)
--- a/src/dataiterator.h
+++ b/src/dataiterator.h
@@ -20,9 +20,9 @@
 extern "C" {
 #endif
 
-struct _Repo;
+struct s_Repo;
 
-typedef struct _KeyValue {
+typedef struct s_KeyValue {
   Id id;
   const char *str;
   unsigned int num;
@@ -31,7 +31,7 @@ typedef struct _KeyValue {
   int entry;   /* array entry, starts with 0 */
   int eof;     /* last entry reached */
 
-  struct _KeyValue *parent;
+  struct s_KeyValue *parent;
 } KeyValue;
 
 #define SOLV_KV_NUM64(kv) (((unsigned long long)((kv)->num2)) << 32 | (kv)->num)
@@ -72,7 +72,7 @@ typedef struct _KeyValue {
 /*
  * Datamatcher: match a string against a query
  */
-typedef struct _Datamatcher {
+typedef struct s_Datamatcher {
   int flags;           /* see matcher flags above */
   const char *match;   /* the query string */
   void *matchdata;     /* e.g. compiled regexp */
@@ -100,14 +100,14 @@ int  datamatcher_checkbasename(Datamatcher *ma, const char *str);
  *      dosomething(di.solvid, di.key, di.kv);
  *    dataiterator_free(&di);
  */
-typedef struct _Dataiterator
+typedef struct s_Dataiterator
 {
   int state;
   int flags;
 
   Pool *pool;
-  struct _Repo *repo;
-  struct _Repodata *data;
+  struct s_Repo *repo;
+  struct s_Repodata *data;
 
   /* data pointers */
   unsigned char *dp;
@@ -116,7 +116,7 @@ typedef struct _Dataiterator
   Id *keyp;
 
   /* the result */
-  struct _Repokey *key;
+  struct s_Repokey *key;
   KeyValue kv;
 
   /* our matcher */
@@ -165,9 +165,9 @@ typedef struct _Dataiterator
  * keyname: if non-null, limit search to this keyname
  * match:   if non-null, limit search to this match
  */
-int  dataiterator_init(Dataiterator *di, Pool *pool, struct _Repo *repo, Id p, Id keyname, const char *match, int flags);
+int  dataiterator_init(Dataiterator *di, Pool *pool, struct s_Repo *repo, Id p, Id keyname, const char *match, int flags);
 void dataiterator_init_clone(Dataiterator *di, Dataiterator *from);
-void dataiterator_set_search(Dataiterator *di, struct _Repo *repo, Id p);
+void dataiterator_set_search(Dataiterator *di, struct s_Repo *repo, Id p);
 void dataiterator_set_keyname(Dataiterator *di, Id keyname);
 int  dataiterator_set_match(Dataiterator *di, const char *match, int flags);
 
@@ -181,7 +181,7 @@ void dataiterator_skip_attribute(Dataiterator *di);
 void dataiterator_skip_solvable(Dataiterator *di);
 void dataiterator_skip_repo(Dataiterator *di);
 void dataiterator_jump_to_solvid(Dataiterator *di, Id solvid);
-void dataiterator_jump_to_repo(Dataiterator *di, struct _Repo *repo);
+void dataiterator_jump_to_repo(Dataiterator *di, struct s_Repo *repo);
 void dataiterator_entersub(Dataiterator *di);
 void dataiterator_clonepos(Dataiterator *di, Dataiterator *from);
 void dataiterator_seek(Dataiterator *di, int whence);

diff --git a/src/dirpool.h b/src/dirpool.h
index fe05cc6509cca4b373700b00e615391056d6891c..ca929548829cfe0b4caecee3be82636b139004a6 100644 (file)
--- a/src/dirpool.h
+++ b/src/dirpool.h
@@ -15,7 +15,7 @@
 extern "C" {
 #endif
 
-typedef struct _Dirpool {
+typedef struct s_Dirpool {
   Id *dirs;
   int ndirs;
   Id *dirtraverse;

diff --git a/src/order.c b/src/order.c
index c92c3328dc787212eb6764ad406e0c6cd184c8b3..c0cc07f440efb300f2fa8de5654381f64fe0fa75 100644 (file)
--- a/src/order.c
+++ b/src/order.c
@@ -23,14 +23,14 @@
 #include "repo.h"
 #include "util.h"
 
-struct _TransactionElement {
+struct s_TransactionElement {
   Id p;                /* solvable id */
   Id edges;    /* pointer into edges data */
   Id mark;
 };
 
-struct _TransactionOrderdata {
-  struct _TransactionElement *tes;
+struct s_TransactionOrderdata {
+  struct s_TransactionElement *tes;
   int ntes;
   Id *invedgedata;
   int ninvedgedata;
@@ -57,7 +57,7 @@ struct _TransactionOrderdata {
 void
 transaction_clone_orderdata(Transaction *trans, Transaction *srctrans)
 {
-  struct _TransactionOrderdata *od = srctrans->orderdata;
+  struct s_TransactionOrderdata *od = srctrans->orderdata;
   if (!od)
     return;
   trans->orderdata = solv_calloc(1, sizeof(*trans->orderdata));
@@ -77,7 +77,7 @@ transaction_free_orderdata(Transaction *trans)
 {
   if (trans->orderdata)
     {
-      struct _TransactionOrderdata *od = trans->orderdata;
+      struct s_TransactionOrderdata *od = trans->orderdata;
       od->tes = solv_free(od->tes);
       od->invedgedata = solv_free(od->invedgedata);
       if (od->cycles)
@@ -91,7 +91,7 @@ transaction_free_orderdata(Transaction *trans)
 
 struct orderdata {
   Transaction *trans;
-  struct _TransactionElement *tes;
+  struct s_TransactionElement *tes;
   int ntes;
   Id *edgedata;
   int nedgedata;
@@ -106,7 +106,7 @@ static int
 addteedge(struct orderdata *od, int from, int to, int type)
 {
   int i;
-  struct _TransactionElement *te;
+  struct s_TransactionElement *te;
 
   if (from == to)
     return 0;
@@ -154,7 +154,7 @@ addedge(struct orderdata *od, Id from, Id to, int type)
   Transaction *trans = od->trans;
   Pool *pool = trans->pool;
   Solvable *s;
-  struct _TransactionElement *te;
+  struct s_TransactionElement *te;
   int i;
 
   /* printf("addedge %d %d type %d\n", from, to, type); */
@@ -531,7 +531,7 @@ breakcycle(struct orderdata *od, Id *cycle)
   Pool *pool = od->trans->pool;
   Id ddegmin, ddegmax, ddeg;
   int k, l;
-  struct _TransactionElement *te;
+  struct s_TransactionElement *te;
 
   l = 0;
   ddegmin = ddegmax = 0;
@@ -604,7 +604,7 @@ dump_tes(struct orderdata *od)
   Pool *pool = od->trans->pool;
   int i, j;
   Queue obsq;
-  struct _TransactionElement *te, *te2;
+  struct s_TransactionElement *te, *te2;
 
   queue_init(&obsq);
   for (i = 1, te = od->tes + i; i < od->ntes; i++, te++)
@@ -632,7 +632,7 @@ dump_tes(struct orderdata *od)
 static void
 reachable(struct orderdata *od, Id i)
 {
-  struct _TransactionElement *te = od->tes + i;
+  struct s_TransactionElement *te = od->tes + i;
   int j, k;
 
   if (te->mark != 0)
@@ -660,7 +660,7 @@ addcycleedges(struct orderdata *od, Id *cycle, Queue *todo)
   Transaction *trans = od->trans;
   Pool *pool = trans->pool;
 #endif
-  struct _TransactionElement *te;
+  struct s_TransactionElement *te;
   int i, j, k, tail;
   int head;
 
@@ -780,7 +780,7 @@ transaction_order(Transaction *trans, int flags)
   Solvable *s;
   int i, j, k, numte, numedge;
   struct orderdata od;
-  struct _TransactionElement *te;
+  struct s_TransactionElement *te;
   Queue todo, obsq, samerepoq, uninstq;
   int cycstart, cycel;
   Id *cycle;
@@ -795,7 +795,7 @@ transaction_order(Transaction *trans, int flags)
   /* free old data if present */
   if (trans->orderdata)
     {
-      struct _TransactionOrderdata *od = trans->orderdata;
+      struct s_TransactionOrderdata *od = trans->orderdata;
       od->tes = solv_free(od->tes);
       od->invedgedata = solv_free(od->invedgedata);
       trans->orderdata = solv_free(trans->orderdata);
@@ -1069,7 +1069,7 @@ printf("do %s [%d]\n", pool_solvid2str(pool, te->p), temedianr[i]);
       s = pool->solvables + te->p;
       for (j = te->edges; od.invedgedata[j]; j++)
        {
-         struct _TransactionElement *te2 = od.tes + od.invedgedata[j];
+         struct s_TransactionElement *te2 = od.tes + od.invedgedata[j];
          assert(te2->mark > 0);
          if (--te2->mark == 0)
            {
@@ -1103,7 +1103,7 @@ printf("free %s [%d]\n", pool_solvid2str(pool, te2->p), temedianr[od.invedgedata
 
   if ((flags & (SOLVER_TRANSACTION_KEEP_ORDERDATA | SOLVER_TRANSACTION_KEEP_ORDERCYCLES)) != 0)
     {
-      struct _TransactionOrderdata *tod;
+      struct s_TransactionOrderdata *tod;
       trans->orderdata = tod = solv_calloc(1, sizeof(*trans->orderdata));
       if ((flags & SOLVER_TRANSACTION_KEEP_ORDERCYCLES) != 0)
        {
@@ -1137,8 +1137,8 @@ int
 transaction_order_add_choices(Transaction *trans, Id chosen, Queue *choices)
 {
   int i, j;
-  struct _TransactionOrderdata *od = trans->orderdata;
-  struct _TransactionElement *te;
+  struct s_TransactionOrderdata *od = trans->orderdata;
+  struct s_TransactionElement *te;
 
   if (!od)
      return choices->count;
@@ -1349,7 +1349,7 @@ transaction_check_order(Transaction *trans)
 void
 transaction_order_get_cycleids(Transaction *trans, Queue *q, int minseverity)
 {
-  struct _TransactionOrderdata *od = trans->orderdata;
+  struct s_TransactionOrderdata *od = trans->orderdata;
   Queue *cq;
   int i, cid, ncycles;
 
@@ -1377,7 +1377,7 @@ transaction_order_get_cycleids(Transaction *trans, Queue *q, int minseverity)
 int
 transaction_order_get_cycle(Transaction *trans, Id cid, Queue *q)
 {
-  struct _TransactionOrderdata *od = trans->orderdata;
+  struct s_TransactionOrderdata *od = trans->orderdata;
   Queue *cq;
   int cmin, cmax, severity;
   int ncycles;

diff --git a/src/pool.c b/src/pool.c
index 1db225616efd48457ded7c26e4cfa51002d820b2..383edb2abffd7803cd7714cf080c5b3cac1352cd 100644 (file)
--- a/src/pool.c
+++ b/src/pool.c
@@ -1602,7 +1602,7 @@ pool_setdebuglevel(Pool *pool, int level)
   pool->debugmask = mask;
 }
 
-void pool_setdebugcallback(Pool *pool, void (*debugcallback)(struct _Pool *, void *data, int type, const char *str), void *debugcallbackdata)
+void pool_setdebugcallback(Pool *pool, void (*debugcallback)(struct s_Pool *, void *data, int type, const char *str), void *debugcallbackdata)
 {
   pool->debugcallback = debugcallback;
   pool->debugcallbackdata = debugcallbackdata;
@@ -1613,20 +1613,20 @@ void pool_setdebugmask(Pool *pool, int mask)
   pool->debugmask = mask;
 }
 
-void pool_setloadcallback(Pool *pool, int (*cb)(struct _Pool *, struct _Repodata *, void *), void *loadcbdata)
+void pool_setloadcallback(Pool *pool, int (*cb)(struct s_Pool *, struct s_Repodata *, void *), void *loadcbdata)
 {
   pool->loadcallback = cb;
   pool->loadcallbackdata = loadcbdata;
 }
 
-void pool_setnamespacecallback(Pool *pool, Id (*cb)(struct _Pool *, void *, Id, Id), void *nscbdata)
+void pool_setnamespacecallback(Pool *pool, Id (*cb)(struct s_Pool *, void *, Id, Id), void *nscbdata)
 {
   pool->nscallback = cb;
   pool->nscallbackdata = nscbdata;
 }
 
 void
-pool_search(Pool *pool, Id p, Id key, const char *match, int flags, int (*callback)(void *cbdata, Solvable *s, struct _Repodata *data, struct _Repokey *key, struct _KeyValue *kv), void *cbdata)
+pool_search(Pool *pool, Id p, Id key, const char *match, int flags, int (*callback)(void *cbdata, Solvable *s, struct s_Repodata *data, struct s_Repokey *key, struct s_KeyValue *kv), void *cbdata)
 {
   if (p)
     {

diff --git a/src/pool.h b/src/pool.h
index 744977a1bda76cb0573e3200c60190e6fb290d08..37583a15ffd67bf20af04ef7db6ca506f064d5ad 100644 (file)
--- a/src/pool.h
+++ b/src/pool.h
@@ -36,13 +36,13 @@ extern "C" {
 
 /*----------------------------------------------- */
 
-struct _Repo;
-struct _Repodata;
-struct _Repokey;
-struct _KeyValue;
+struct s_Repo;
+struct s_Repodata;
+struct s_Repokey;
+struct s_KeyValue;
 
-typedef struct _Datapos {
-  struct _Repo *repo;
+typedef struct s_Datapos {
+  struct s_Repo *repo;
   Id solvid;
   Id repodataid;
   Id schema;
@@ -55,7 +55,7 @@ typedef struct _Datapos {
 /* how many strings to maintain (round robin) */
 #define POOL_TMPSPACEBUF 16
 
-struct _Pool_tmpspace {
+struct s_Pool_tmpspace {
   char *buf[POOL_TMPSPACEBUF];
   int   len[POOL_TMPSPACEBUF];
   int   n;
@@ -63,19 +63,19 @@ struct _Pool_tmpspace {
 
 #endif
 
-struct _Pool {
+struct s_Pool {
   void *appdata;               /* application private pointer */
 
-  struct _Stringpool ss;
+  struct s_Stringpool ss;
 
   Reldep *rels;                        /* table of rels: Id -> Reldep */
   int nrels;                   /* number of unique rels */
 
-  struct _Repo **repos;
+  struct s_Repo **repos;
   int nrepos;                  /* repos allocated */
   int urepos;                  /* repos in use */
 
-  struct _Repo *installed;     /* packages considered installed */
+  struct s_Repo *installed;    /* packages considered installed */
 
   Solvable *solvables;
   int nsolvables;              /* solvables allocated */
@@ -109,16 +109,16 @@ struct _Pool {
   Map *considered;
 
   /* callback for REL_NAMESPACE dependencies handled by the application  */
-  Id (*nscallback)(struct _Pool *, void *data, Id name, Id evr);
+  Id (*nscallback)(struct s_Pool *, void *data, Id name, Id evr);
   void *nscallbackdata;
 
   /* debug mask and callback */
   int  debugmask;
-  void (*debugcallback)(struct _Pool *, void *data, int type, const char *str);
+  void (*debugcallback)(struct s_Pool *, void *data, int type, const char *str);
   void *debugcallbackdata;
 
   /* load callback */
-  int (*loadcallback)(struct _Pool *, struct _Repodata *, void *);
+  int (*loadcallback)(struct s_Pool *, struct s_Repodata *, void *);
   void *loadcallbackdata;
 
   /* search position */
@@ -148,14 +148,14 @@ struct _Pool {
   int languagecacheother;
 
   /* our tmp space string space */
-  struct _Pool_tmpspace tmpspace;
+  struct s_Pool_tmpspace tmpspace;
 
   char *errstr;                        /* last error string */
   int errstra;                 /* allocated space for errstr */
 
   char *rootdir;
 
-  int (*custom_vendorcheck)(struct _Pool *, Solvable *, Solvable *);
+  int (*custom_vendorcheck)(struct s_Pool *, Solvable *, Solvable *);
 
   int addfileprovidesfiltered; /* 1: only use filtered file list for addfileprovides */
   int addedfileprovides;       /* true: application called addfileprovides */
@@ -246,13 +246,13 @@ extern int  pool_set_flag(Pool *pool, int flag, int value);
 extern int  pool_get_flag(Pool *pool, int flag);
 
 extern void pool_debug(Pool *pool, int type, const char *format, ...) __attribute__((format(printf, 3, 4)));
-extern void pool_setdebugcallback(Pool *pool, void (*debugcallback)(struct _Pool *, void *data, int type, const char *str), void *debugcallbackdata);
+extern void pool_setdebugcallback(Pool *pool, void (*debugcallback)(struct s_Pool *, void *data, int type, const char *str), void *debugcallbackdata);
 extern void pool_setdebugmask(Pool *pool, int mask);
-extern void pool_setloadcallback(Pool *pool, int (*cb)(struct _Pool *, struct _Repodata *, void *), void *loadcbdata);
-extern void pool_setnamespacecallback(Pool *pool, Id (*cb)(struct _Pool *, void *, Id, Id), void *nscbdata);
+extern void pool_setloadcallback(Pool *pool, int (*cb)(struct s_Pool *, struct s_Repodata *, void *), void *loadcbdata);
+extern void pool_setnamespacecallback(Pool *pool, Id (*cb)(struct s_Pool *, void *, Id, Id), void *nscbdata);
 extern void pool_flush_namespaceproviders(Pool *pool, Id ns, Id evr);
 
-extern void pool_set_custom_vendorcheck(Pool *pool, int (*vendorcheck)(struct _Pool *, Solvable *, Solvable *));
+extern void pool_set_custom_vendorcheck(Pool *pool, int (*vendorcheck)(struct s_Pool *, Solvable *, Solvable *));
 
 
 extern char *pool_alloctmpspace(Pool *pool, int len);
@@ -261,7 +261,7 @@ extern char *pool_tmpjoin(Pool *pool, const char *str1, const char *str2, const
 extern char *pool_tmpappend(Pool *pool, const char *str1, const char *str2, const char *str3);
 extern const char *pool_bin2hex(Pool *pool, const unsigned char *buf, int len);
 
-extern void pool_set_installed(Pool *pool, struct _Repo *repo);
+extern void pool_set_installed(Pool *pool, struct s_Repo *repo);
 
 extern int  pool_error(Pool *pool, int ret, const char *format, ...) __attribute__((format(printf, 3, 4)));
 extern char *pool_errstr(Pool *pool);
@@ -357,7 +357,7 @@ void pool_set_whatprovides(Pool *pool, Id id, Id providers);
  *   key   - search only this key
  *   match - key must match this string
  */
-void pool_search(Pool *pool, Id p, Id key, const char *match, int flags, int (*callback)(void *cbdata, Solvable *s, struct _Repodata *data, struct _Repokey *key, struct _KeyValue *kv), void *cbdata);
+void pool_search(Pool *pool, Id p, Id key, const char *match, int flags, int (*callback)(void *cbdata, Solvable *s, struct s_Repodata *data, struct s_Repokey *key, struct s_KeyValue *kv), void *cbdata);
 
 void pool_clear_pos(Pool *pool);
 
@@ -374,7 +374,7 @@ const char *pool_lookup_deltalocation(Pool *pool, Id entry, unsigned int *median
 
 #define DUCHANGES_ONLYADD      1
 
-typedef struct _DUChanges {
+typedef struct s_DUChanges {
   const char *path;
   long long kbytes;
   long long files;

diff --git a/src/poolid.h b/src/poolid.h
index 79a3ccdc78213d7b1c6b6d56103151a689a2961b..f832ff4b3002a17b37e01acc8c6346b299799257 100644 (file)
--- a/src/poolid.h
+++ b/src/poolid.h
@@ -24,7 +24,7 @@ extern "C" {
  * Ids with relation
  */
 
-typedef struct _Reldep {
+typedef struct s_Reldep {
   Id name;             /* "package" */
   Id evr;              /* "0:42-3" */
   int flags;           /* operation/relation, see REL_x in pool.h */

diff --git a/src/pooltypes.h b/src/pooltypes.h
index 64a3b8743465891a587a6893e1dfbdded7ceb4b6..e1f77b0ecc39d953d663f079720eaa0adb85b4d5 100644 (file)
--- a/src/pooltypes.h
+++ b/src/pooltypes.h
@@ -27,11 +27,11 @@
 #define SOLV_FLAG_PREFIX_POOL 4
 #define SOLV_FLAG_SIZE_BYTES  8
 
-struct _Stringpool;
-typedef struct _Stringpool Stringpool;
+struct s_Stringpool;
+typedef struct s_Stringpool Stringpool;
 
-struct _Pool;
-typedef struct _Pool Pool;
+struct s_Pool;
+typedef struct s_Pool Pool;
 
 /* identifier for string values */
 typedef int Id;                /* must be signed!, since negative Id is used in solver rules to denote negation */

diff --git a/src/problems.h b/src/problems.h
index 63319d6cbf09c686e2e7f03e0e9adaea184620bf..37021e1d5149029c9fc09ebe907d56d63a288de3 100644 (file)
--- a/src/problems.h
+++ b/src/problems.h
@@ -20,7 +20,7 @@ extern "C" {
 #endif
 
 
-struct _Solver;
+struct s_Solver;
 
 #define SOLVER_SOLUTION_JOB             (0)
 #define SOLVER_SOLUTION_DISTUPGRADE     (-1)
@@ -28,31 +28,31 @@ struct _Solver;
 #define SOLVER_SOLUTION_BEST            (-3)
 #define SOLVER_SOLUTION_POOLJOB         (-4)
 
-void solver_recordproblem(struct _Solver *solv, Id rid);
-void solver_fixproblem(struct _Solver *solv, Id rid);
-Id solver_autouninstall(struct _Solver *solv, int start);
-void solver_disableproblemset(struct _Solver *solv, int start);
+void solver_recordproblem(struct s_Solver *solv, Id rid);
+void solver_fixproblem(struct s_Solver *solv, Id rid);
+Id solver_autouninstall(struct s_Solver *solv, int start);
+void solver_disableproblemset(struct s_Solver *solv, int start);
 
-int solver_prepare_solutions(struct _Solver *solv);
+int solver_prepare_solutions(struct s_Solver *solv);
 
-unsigned int solver_problem_count(struct _Solver *solv);
-Id solver_next_problem(struct _Solver *solv, Id problem);
-unsigned int solver_solution_count(struct _Solver *solv, Id problem);
-Id solver_next_solution(struct _Solver *solv, Id problem, Id solution);
-unsigned int solver_solutionelement_count(struct _Solver *solv, Id problem, Id solution);
-Id solver_solutionelement_internalid(struct _Solver *solv, Id problem, Id solution);
-Id solver_solutionelement_extrajobflags(struct _Solver *solv, Id problem, Id solution);
-Id solver_next_solutionelement(struct _Solver *solv, Id problem, Id solution, Id element, Id *p, Id *rp);
+unsigned int solver_problem_count(struct s_Solver *solv);
+Id solver_next_problem(struct s_Solver *solv, Id problem);
+unsigned int solver_solution_count(struct s_Solver *solv, Id problem);
+Id solver_next_solution(struct s_Solver *solv, Id problem, Id solution);
+unsigned int solver_solutionelement_count(struct s_Solver *solv, Id problem, Id solution);
+Id solver_solutionelement_internalid(struct s_Solver *solv, Id problem, Id solution);
+Id solver_solutionelement_extrajobflags(struct s_Solver *solv, Id problem, Id solution);
+Id solver_next_solutionelement(struct s_Solver *solv, Id problem, Id solution, Id element, Id *p, Id *rp);
 
-void solver_take_solutionelement(struct _Solver *solv, Id p, Id rp, Id extrajobflags, Queue *job);
-void solver_take_solution(struct _Solver *solv, Id problem, Id solution, Queue *job);
+void solver_take_solutionelement(struct s_Solver *solv, Id p, Id rp, Id extrajobflags, Queue *job);
+void solver_take_solution(struct s_Solver *solv, Id problem, Id solution, Queue *job);
 
-Id solver_findproblemrule(struct _Solver *solv, Id problem);
-void solver_findallproblemrules(struct _Solver *solv, Id problem, Queue *rules);
+Id solver_findproblemrule(struct s_Solver *solv, Id problem);
+void solver_findallproblemrules(struct s_Solver *solv, Id problem, Queue *rules);
 
-extern const char *solver_problemruleinfo2str(struct _Solver *solv, SolverRuleinfo type, Id source, Id target, Id dep);
-extern const char *solver_problem2str(struct _Solver *solv, Id problem);
-extern const char *solver_solutionelement2str(struct _Solver *solv, Id p, Id rp);
+extern const char *solver_problemruleinfo2str(struct s_Solver *solv, SolverRuleinfo type, Id source, Id target, Id dep);
+extern const char *solver_problem2str(struct s_Solver *solv, Id problem);
+extern const char *solver_solutionelement2str(struct s_Solver *solv, Id p, Id rp);
 
 #ifdef __cplusplus
 }

diff --git a/src/queue.h b/src/queue.h
index 7e5603520e01eb98d5ace2f830e98c1f5f6f72fa..8b1ef08ff6448df05a53914c1bed1466a79c137b 100644 (file)
--- a/src/queue.h
+++ b/src/queue.h
@@ -19,7 +19,7 @@
 extern "C" {
 #endif
 
-typedef struct _Queue {
+typedef struct s_Queue {
   Id *elements;                /* pointer to elements */
   int count;           /* current number of elements in queue */
   Id *alloc;           /* this is whats actually allocated, elements > alloc if shifted */

diff --git a/src/repo.h b/src/repo.h
index 3016d00ada082bdaa27724df682723509e7af30c..4abfb0f8b626e7cc4fba24ffe0dce008e956c8d2 100644 (file)
--- a/src/repo.h
+++ b/src/repo.h
@@ -24,7 +24,7 @@
 extern "C" {
 #endif
 
-typedef struct _Repo {
+typedef struct s_Repo {
   const char *name;            /* name pointer */
   Id repoid;                   /* our id */
   void *appdata;               /* application private pointer */

diff --git a/src/repo_solv.c b/src/repo_solv.c
index 7249fcbd4ee0b3b42baf5a6e45835b225a2e3537..be339677a8432c614e9c27ea914bacef59acaeb5 100644 (file)
--- a/src/repo_solv.c
+++ b/src/repo_solv.c
@@ -478,7 +478,7 @@ repo_add_solv(Repo *repo, FILE *fp, int flags)
   int oldnstrings = pool->ss.nstrings;
   int oldnrels = pool->nrels;
 
-  struct _Stringpool *spool;
+  struct s_Stringpool *spool;
 
   Repodata *parent = 0;
   Repodata data;

diff --git a/src/repo_write.h b/src/repo_write.h
index 1dadad3b3a57b480bbcb7fa68902b75510197f69..34716705ef0e32a228bf41278bdfac78f9774531 100644 (file)
--- a/src/repo_write.h
+++ b/src/repo_write.h
@@ -22,7 +22,7 @@
 extern "C" {
 #endif
 
-typedef struct _Repowriter {
+typedef struct s_Repowriter {
   Repo *repo;
   int flags;
   int repodatastart;

diff --git a/src/repodata.c b/src/repodata.c
index dfc33b4570d101537c8d9970599870e56407a61f..4c57021e53d109dd042126fcda35c84f921e9c87 100644 (file)
--- a/src/repodata.c
+++ b/src/repodata.c
@@ -3692,7 +3692,7 @@ repodata_stub_loader(Repodata *data)
   Repo *repo = data->repo;
   Pool *pool = repo->pool;
   int r, i;
-  struct _Pool_tmpspace oldtmpspace;
+  struct s_Pool_tmpspace oldtmpspace;
   Datapos oldpos;
 
   if (!pool->loadcallback)

diff --git a/src/repodata.h b/src/repodata.h
index 81248852d8ebde35f2a36b33ed3ddf8cb184e073..f204e34f9bfbddbfb2fa56dec4de73510fcc7156 100644 (file)
--- a/src/repodata.h
+++ b/src/repodata.h
@@ -34,10 +34,10 @@ extern "C" {
 #define SIZEOF_SHA384  48
 #define SIZEOF_SHA512  64
 
-struct _Repo;
-struct _KeyValue;
+struct s_Repo;
+struct s_KeyValue;
 
-typedef struct _Repokey {
+typedef struct s_Repokey {
   Id name;
   Id type;                     /* REPOKEY_TYPE_xxx */
   unsigned int size;
@@ -66,13 +66,13 @@ struct dircache;
 #define REPODATA_FILELIST_FILTERED     1
 #define REPODATA_FILELIST_EXTENSION    2
 
-typedef struct _Repodata {
+typedef struct s_Repodata {
   Id repodataid;               /* our id */
-  struct _Repo *repo;          /* back pointer to repo */
+  struct s_Repo *repo;         /* back pointer to repo */
 
   int state;                   /* available, stub or error */
 
-  void (*loadcallback)(struct _Repodata *);
+  void (*loadcallback)(struct s_Repodata *);
 
   int start;                   /* start of solvables this repodata is valid for */
   int end;                     /* last solvable + 1 of this repodata */
@@ -148,7 +148,7 @@ typedef struct _Repodata {
 /*-----
  * management functions
  */
-void repodata_initdata(Repodata *data, struct _Repo *repo, int localpool);
+void repodata_initdata(Repodata *data, struct s_Repo *repo, int localpool);
 void repodata_freedata(Repodata *data);
 
 void repodata_free(Repodata *data);
@@ -207,13 +207,13 @@ repodata_has_keyname(Repodata *data, Id keyname)
 
 /* search key <keyname> (all keys, if keyname == 0) for Id <solvid>
  * Call <callback> for each match */
-void repodata_search(Repodata *data, Id solvid, Id keyname, int flags, int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, struct _KeyValue *kv), void *cbdata);
-void repodata_search_keyskip(Repodata *data, Id solvid, Id keyname, int flags, Id *keyskip, int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, struct _KeyValue *kv), void *cbdata);
-void repodata_search_arrayelement(Repodata *data, Id solvid, Id keyname, int flags, struct _KeyValue *kv, int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, struct _KeyValue *kv), void *cbdata);
+void repodata_search(Repodata *data, Id solvid, Id keyname, int flags, int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, struct s_KeyValue *kv), void *cbdata);
+void repodata_search_keyskip(Repodata *data, Id solvid, Id keyname, int flags, Id *keyskip, int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, struct s_KeyValue *kv), void *cbdata);
+void repodata_search_arrayelement(Repodata *data, Id solvid, Id keyname, int flags, struct s_KeyValue *kv, int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, struct s_KeyValue *kv), void *cbdata);
 
 /* Make sure the found KeyValue has the "str" field set. Return "str"
  * if valid, NULL if not possible */
-const char *repodata_stringify(Pool *pool, Repodata *data, Repokey *key, struct _KeyValue *kv, int flags);
+const char *repodata_stringify(Pool *pool, Repodata *data, Repokey *key, struct s_KeyValue *kv, int flags);
 
 /* filelist filter support */
 void repodata_set_filelisttype(Repodata *data, int filelisttype);
@@ -291,7 +291,7 @@ void repodata_add_fixarray(Repodata *data, Id solvid, Id keyname, Id ghandle);
 void repodata_add_flexarray(Repodata *data, Id solvid, Id keyname, Id ghandle);
 
 /* generic */
-void repodata_set_kv(Repodata *data, Id solvid, Id keyname, Id keytype, struct _KeyValue *kv);
+void repodata_set_kv(Repodata *data, Id solvid, Id keyname, Id keytype, struct s_KeyValue *kv);
 void repodata_unset(Repodata *data, Id solvid, Id keyname);
 void repodata_unset_uninternalized(Repodata *data, Id solvid, Id keyname);
 
@@ -324,8 +324,8 @@ void repodata_set_deltalocation(Repodata *data, Id handle, int medianr, const ch
 void repodata_set_sourcepkg(Repodata *data, Id solvid, const char *sourcepkg);
 
 /* uninternalized data lookup / search */
-Repokey *repodata_lookup_kv_uninternalized(Repodata *data, Id solvid, Id keyname, struct _KeyValue *kv);
-void repodata_search_uninternalized(Repodata *data, Id solvid, Id keyname, int flags, int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, struct _KeyValue *kv), void *cbdata);
+Repokey *repodata_lookup_kv_uninternalized(Repodata *data, Id solvid, Id keyname, struct s_KeyValue *kv);
+void repodata_search_uninternalized(Repodata *data, Id solvid, Id keyname, int flags, int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, struct s_KeyValue *kv), void *cbdata);
 
 /* stats */
 unsigned int repodata_memused(Repodata *data);

diff --git a/src/repopage.h b/src/repopage.h
index 739345ed6d74ed6b218c49d5b3812345daceac9e..b5f2eee90cbcd81060539043195bc67f8160a2cf 100644 (file)
--- a/src/repopage.h
+++ b/src/repopage.h
@@ -11,7 +11,7 @@
 #define REPOPAGE_BLOBBITS 15
 #define REPOPAGE_BLOBSIZE (1 << REPOPAGE_BLOBBITS)
 
-typedef struct _Attrblobpage
+typedef struct s_Attrblobpage
 {
   /* page_size == 0 means the page is not backed by some file storage.
      Otherwise it is L*2+(compressed ? 1 : 0), with L being the data
@@ -20,7 +20,7 @@ typedef struct _Attrblobpage
   unsigned int page_size;
 } Attrblobpage;
 
-typedef struct _Repopagestore {
+typedef struct s_Repopagestore {
   int pagefd;          /* file descriptor we're paging from */
   long file_offset;    /* pages in file start here */
 

diff --git a/src/rules.h b/src/rules.h
index db52199c67a0dcad716620e48ccfde55bfe7ed55..a3c01353f40dbc31d5cf77a1bf856e8c282d8f2a 100644 (file)
--- a/src/rules.h
+++ b/src/rules.h
@@ -35,7 +35,7 @@ extern "C" {
  * possible. Do not add new members unless there is no other way.
  */
 
-typedef struct _Rule {
+typedef struct s_Rule {
   Id p;                /* first literal in rule */
   Id d;                /* Id offset into 'list of providers terminated by 0' as used by whatprovides; pool->whatprovides + d */
                /* in case of binary rules, d == 0, w1 == p, w2 == other literal */
@@ -76,14 +76,14 @@ typedef enum {
 
 #define SOLVER_RULE_TYPEMASK    0xff00
 
-struct _Solver;
+struct s_Solver;
 
 /*-------------------------------------------------------------------
  * disable rule
  */
 
 static inline void
-solver_disablerule(struct _Solver *solv, Rule *r)
+solver_disablerule(struct s_Solver *solv, Rule *r)
 {
   if (r->d >= 0)
     r->d = -r->d - 1;
@@ -94,64 +94,64 @@ solver_disablerule(struct _Solver *solv, Rule *r)
  */
 
 static inline void
-solver_enablerule(struct _Solver *solv, Rule *r)
+solver_enablerule(struct s_Solver *solv, Rule *r)
 {
   if (r->d < 0)
     r->d = -r->d - 1;
 }
 
-extern Rule *solver_addrule(struct _Solver *solv, Id p, Id p2, Id d);
-extern void solver_unifyrules(struct _Solver *solv);
-extern int solver_rulecmp(struct _Solver *solv, Rule *r1, Rule *r2);
-extern void solver_shrinkrules(struct _Solver *solv, int nrules);
+extern Rule *solver_addrule(struct s_Solver *solv, Id p, Id p2, Id d);
+extern void solver_unifyrules(struct s_Solver *solv);
+extern int solver_rulecmp(struct s_Solver *solv, Rule *r1, Rule *r2);
+extern void solver_shrinkrules(struct s_Solver *solv, int nrules);
 
 /* pkg rules */
-extern void solver_addpkgrulesforsolvable(struct _Solver *solv, Solvable *s, Map *m);
-extern void solver_addpkgrulesforweak(struct _Solver *solv, Map *m);
-extern void solver_addpkgrulesforlinked(struct _Solver *solv, Map *m);
-extern void solver_addpkgrulesforupdaters(struct _Solver *solv, Solvable *s, Map *m, int allow_all);
+extern void solver_addpkgrulesforsolvable(struct s_Solver *solv, Solvable *s, Map *m);
+extern void solver_addpkgrulesforweak(struct s_Solver *solv, Map *m);
+extern void solver_addpkgrulesforlinked(struct s_Solver *solv, Map *m);
+extern void solver_addpkgrulesforupdaters(struct s_Solver *solv, Solvable *s, Map *m, int allow_all);
 
 /* update/feature rules */
-extern void solver_addfeaturerule(struct _Solver *solv, Solvable *s);
-extern void solver_addupdaterule(struct _Solver *solv, Solvable *s);
+extern void solver_addfeaturerule(struct s_Solver *solv, Solvable *s);
+extern void solver_addupdaterule(struct s_Solver *solv, Solvable *s);
 
 /* infarch rules */
-extern void solver_addinfarchrules(struct _Solver *solv, Map *addedmap);
+extern void solver_addinfarchrules(struct s_Solver *solv, Map *addedmap);
 
 /* dup rules */
-extern void solver_createdupmaps(struct _Solver *solv);
-extern void solver_freedupmaps(struct _Solver *solv);
-extern void solver_addduprules(struct _Solver *solv, Map *addedmap);
+extern void solver_createdupmaps(struct s_Solver *solv);
+extern void solver_freedupmaps(struct s_Solver *solv);
+extern void solver_addduprules(struct s_Solver *solv, Map *addedmap);
 
 /* choice rules */
-extern void solver_addchoicerules(struct _Solver *solv);
-extern void solver_disablechoicerules(struct _Solver *solv, Rule *r);
+extern void solver_addchoicerules(struct s_Solver *solv);
+extern void solver_disablechoicerules(struct s_Solver *solv, Rule *r);
 
 /* best rules */
-extern void solver_addbestrules(struct _Solver *solv, int havebestinstalljobs);
+extern void solver_addbestrules(struct s_Solver *solv, int havebestinstalljobs);
 
 /* yumobs rules */
-extern void solver_addyumobsrules(struct _Solver *solv);
+extern void solver_addyumobsrules(struct s_Solver *solv);
 
 /* policy rule disabling/reenabling */
-extern void solver_disablepolicyrules(struct _Solver *solv);
-extern void solver_reenablepolicyrules(struct _Solver *solv, int jobidx);
-extern void solver_reenablepolicyrules_cleandeps(struct _Solver *solv, Id pkg);
+extern void solver_disablepolicyrules(struct s_Solver *solv);
+extern void solver_reenablepolicyrules(struct s_Solver *solv, int jobidx);
+extern void solver_reenablepolicyrules_cleandeps(struct s_Solver *solv, Id pkg);
 
 /* rule info */
-extern int solver_allruleinfos(struct _Solver *solv, Id rid, Queue *rq);
-extern SolverRuleinfo solver_ruleinfo(struct _Solver *solv, Id rid, Id *fromp, Id *top, Id *depp);
-extern SolverRuleinfo solver_ruleclass(struct _Solver *solv, Id rid);
-extern void solver_ruleliterals(struct _Solver *solv, Id rid, Queue *q);
-extern int  solver_rule2jobidx(struct _Solver *solv, Id rid);
-extern Id   solver_rule2job(struct _Solver *solv, Id rid, Id *whatp);
-extern Id   solver_rule2solvable(struct _Solver *solv, Id rid);
-extern void solver_rule2rules(struct _Solver *solv, Id rid, Queue *q, int recursive);
-extern Id   solver_rule2pkgrule(struct _Solver *solv, Id rid);
+extern int solver_allruleinfos(struct s_Solver *solv, Id rid, Queue *rq);
+extern SolverRuleinfo solver_ruleinfo(struct s_Solver *solv, Id rid, Id *fromp, Id *top, Id *depp);
+extern SolverRuleinfo solver_ruleclass(struct s_Solver *solv, Id rid);
+extern void solver_ruleliterals(struct s_Solver *solv, Id rid, Queue *q);
+extern int  solver_rule2jobidx(struct s_Solver *solv, Id rid);
+extern Id   solver_rule2job(struct s_Solver *solv, Id rid, Id *whatp);
+extern Id   solver_rule2solvable(struct s_Solver *solv, Id rid);
+extern void solver_rule2rules(struct s_Solver *solv, Id rid, Queue *q, int recursive);
+extern Id   solver_rule2pkgrule(struct s_Solver *solv, Id rid);
 
 /* orphan handling */
-extern void solver_breakorphans(struct _Solver *solv);
-extern void solver_check_brokenorphanrules(struct _Solver *solv, Queue *dq);
+extern void solver_breakorphans(struct s_Solver *solv);
+extern void solver_check_brokenorphanrules(struct s_Solver *solv, Queue *dq);
 
 
 /* legacy */

diff --git a/src/sha2.h b/src/sha2.h
index 220af329b59de97c23de63180b49527ab1221bd5..53773600e90de7b30ca3935344f6b5e97933823a 100644 (file)
--- a/src/sha2.h
+++ b/src/sha2.h
@@ -51,12 +51,12 @@
  * uintXX_t (from inttypes.h), you may need to define things by hand
  * for your system:
  */
-typedef struct _SHA256_CTX {
+typedef struct s_SHA256_CTX {
        uint32_t        state[8];
        uint64_t        bitcount;
        uint32_t        buffer[SHA256_BLOCK_LENGTH/4];
 } SHA256_CTX;
-typedef struct _SHA512_CTX {
+typedef struct s_SHA512_CTX {
        uint64_t        state[8];
        uint64_t        bitcount[2];
        uint64_t        buffer[SHA512_BLOCK_LENGTH/8];

diff --git a/src/solvable.h b/src/solvable.h
index 49f0a413630b5fc1f314451f192cc22d8dd2ab3f..bf92a0003584253f222dcf540b9306c955cb9ef4 100644 (file)
--- a/src/solvable.h
+++ b/src/solvable.h
@@ -23,15 +23,15 @@
 extern "C" {
 #endif
 
-struct _Repo;
+struct s_Repo;
 
-typedef struct _Solvable {
+typedef struct s_Solvable {
   Id name;
   Id arch;
   Id evr;                      /* epoch:version-release */
   Id vendor;
 
-  struct _Repo *repo;          /* repo we belong to */
+  struct s_Repo *repo;         /* repo we belong to */
 
   /* dependencies are offsets into repo->idarraydata */
   Offset provides;             /* terminated with Id 0 */
@@ -90,7 +90,7 @@ int solvable_matchessolvable_int(Solvable *s, Id keyname, int marker, Id solvid,
 int solvable_is_irrelevant_patch(Solvable *s, Map *installedmap);
 int solvable_trivial_installable_map(Solvable *s, Map *installedmap, Map *conflictsmap, Map *multiversionmap);
 int solvable_trivial_installable_queue(Solvable *s, Queue *installed, Map *multiversionmap);
-int solvable_trivial_installable_repo(Solvable *s, struct _Repo *installed, Map *multiversionmap);
+int solvable_trivial_installable_repo(Solvable *s, struct s_Repo *installed, Map *multiversionmap);
 
 #ifdef __cplusplus
 }

diff --git a/src/solver.h b/src/solver.h
index ebb2232bb0a3e11aa415194e4616d7962494687a..4c85b4d5058235b0cb387af88934a485c0139e62 100644 (file)
--- a/src/solver.h
+++ b/src/solver.h
@@ -26,11 +26,11 @@
 extern "C" {
 #endif
 
-struct _Solver {
+struct s_Solver {
   Pool *pool;                          /* back pointer to pool */
   Queue job;                           /* copy of the job we're solving */
 
-  int (*solution_callback)(struct _Solver *solv, void *data);
+  int (*solution_callback)(struct s_Solver *solv, void *data);
   void *solution_callback_data;
 
   int pooljobcnt;                      /* number of pooljob entries in job queue */
@@ -211,7 +211,7 @@ struct _Solver {
 #endif /* LIBSOLV_INTERNAL */
 };
 
-typedef struct _Solver Solver;
+typedef struct s_Solver Solver;
 
 /*
  * queue commands

diff --git a/src/strpool.h b/src/strpool.h
index f96c5c18a38f01f823161e784b1e6e3775af5a4c..fd13bdb71bc0cd98cce86073f94297e0605f57b0 100644 (file)
--- a/src/strpool.h
+++ b/src/strpool.h
@@ -17,7 +17,7 @@ extern "C" {
 #define STRID_NULL  0
 #define STRID_EMPTY 1
 
-struct _Stringpool
+struct s_Stringpool
 {
   Offset *strings;            /* table of offsets into stringspace, indexed by Id: Id -> Offset */
   int nstrings;               /* number of ids in strings table */

diff --git a/src/transaction.h b/src/transaction.h
index 4690ced431a5ce0edf7c5deae4690c4b9bdefc7e..5b01354efd955a18e08a713a4aa0fce4dd9cce1c 100644 (file)
--- a/src/transaction.h
+++ b/src/transaction.h
@@ -21,12 +21,12 @@
 extern "C" {
 #endif
 
-struct _Pool;
-struct _DUChanges;
-struct _TransactionOrderdata;
+struct s_Pool;
+struct s_DUChanges;
+struct s_TransactionOrderdata;
 
-typedef struct _Transaction {
-  struct _Pool *pool;          /* back pointer to pool */
+typedef struct s_Transaction {
+  struct s_Pool *pool;         /* back pointer to pool */
 
   Queue steps;                 /* the transaction steps */
 
@@ -36,7 +36,7 @@ typedef struct _Transaction {
   Map transactsmap;
   Map multiversionmap;
 
-  struct _TransactionOrderdata *orderdata;
+  struct s_TransactionOrderdata *orderdata;
 #endif
 
 } Transaction;
@@ -92,8 +92,8 @@ typedef struct _Transaction {
 #define SOLVER_ORDERCYCLE_NORMAL               1
 #define SOLVER_ORDERCYCLE_CRITICAL             2
 
-extern Transaction *transaction_create(struct _Pool *pool);
-extern Transaction *transaction_create_decisionq(struct _Pool *pool, Queue *decisionq, Map *multiversionmap);
+extern Transaction *transaction_create(struct s_Pool *pool);
+extern Transaction *transaction_create_decisionq(struct s_Pool *pool, Queue *decisionq, Map *multiversionmap);
 extern Transaction *transaction_create_clone(Transaction *srctrans);
 extern void transaction_free(Transaction *trans);
 
@@ -116,7 +116,7 @@ extern void transaction_classify_pkgs(Transaction *trans, int mode, Id type, Id
 extern int transaction_installedresult(Transaction *trans, Queue *installedq);
 
 long long transaction_calc_installsizechange(Transaction *trans);
-void transaction_calc_duchanges(Transaction *trans, struct _DUChanges *mps, int nmps);
+void transaction_calc_duchanges(Transaction *trans, struct s_DUChanges *mps, int nmps);