#s = pool.add_empty_repo
f = File.open('../../testsuite/data.libzypp/basic-exercises/exercise-20-packages.solv', 'r')
-s = pool.add_repo_solv(f, 'foo')
+s = pool.create_repo('foo');
+s.add_solv(f);
f = File.open('../../testsuite/data.libzypp/basic-exercises/exercise-20-system.solv', 'r')
-installed = pool.add_repo_solv(f, 'system')
+installed = pool.create_repo('system');
+installed.add_solv(f);
pool.each_repo do |repo|
puts repo.name
solv.each_to_remove do |i|
puts "to remove #{i}"
-end
\ No newline at end of file
+end
pool_free(Pool *pool)
{
int i;
- Repo *repo;
pool_freewhatprovides(pool);
pool_freeidhashes(pool);
- for (i = 0; i < pool->nrepos; i++)
- {
- repo = pool->repos[i];
- xfree(repo->idarraydata);
- xfree(repo->rpmdbid);
- xfree(repo);
- }
+ pool_freeallrepos(pool);
xfree(pool->id2arch);
xfree(pool->solvables);
- xfree(pool->repos);
xfree(pool->stringspace);
xfree(pool->strings);
xfree(pool->rels);
*/
Repo *
-pool_addrepo_empty(Pool *pool)
+repo_create(Pool *pool, const char *name)
{
Repo *repo;
repo = (Repo *)xcalloc(1, sizeof(*repo));
pool->repos = (Repo **)xrealloc(pool->repos, (pool->nrepos + 1) * sizeof(Repo *));
pool->repos[pool->nrepos++] = repo;
- repo->name = "empty";
+ repo->name = name ? strdup(name) : 0;
repo->pool = pool;
repo->start = pool->nsolvables;
repo->nsolvables = 0;
return repo;
}
+static void
+repo_freedata(Repo *repo)
+{
+ xfree(repo->idarraydata);
+ xfree(repo->rpmdbid);
+ xfree((char *)repo->name);
+ xfree(repo);
+}
+
/*
* add Id to repo
* olddeps = old array to extend
*/
void
-pool_freerepo(Pool *pool, Repo *repo)
+repo_free(Repo *repo)
{
+ Pool *pool = repo->pool;
int i, nsolvables;
pool_freewhatprovides(pool);
pool->repos[i]->start -= nsolvables; /* adapt start offset of remaining repos */
}
pool->nrepos = i;
+ repo_freedata(repo);
+}
- xfree(repo->idarraydata);
- xfree(repo->rpmdbid);
- xfree(repo);
+void
+pool_freeallrepos(Pool *pool)
+{
+ int i;
+ for (i = 0; i < pool->nrepos; i++)
+ repo_freedata(pool->repos[i]);
+ pool->repos = xfree(pool->repos);
+ pool->nrepos = 0;
}
Offset
Id *rpmdbid;
} Repo;
+extern Repo *repo_create(Pool *pool, const char *name);
+extern void repo_free(Repo *repo);
+
extern Offset repo_addid(Repo *repo, Offset olddeps, Id id);
extern Offset repo_addid_dep(Repo *repo, Offset olddeps, Id id, int isreq);
extern Offset repo_reserve_ids(Repo *repo, Offset olddeps, int num);
extern Offset repo_fix_legacy(Repo *repo, Offset provides, Offset supplements);
-extern Repo *pool_addrepo_empty(Pool *pool);
-extern void pool_freerepo(Pool *pool, Repo *repo);
+extern void pool_freeallrepos(Pool *pool);
static inline const char *repo_name(const Repo *repo)
{
* and add it to pool
*/
-Repo *
-pool_addrepo_solv(Pool *pool, FILE *fp, const char *reponame)
+void
+repo_add_solv(Repo *repo, FILE *fp)
{
+ Pool *pool = repo->pool;
int i, j, l;
unsigned int numid, numrel, numsolv, numsrcdata, numsolvdata;
int numsolvdatabits, type;
Reldep *ran;
SolvData *solvdata;
unsigned int size, size_str, size_idarray;
- Repo *repo;
Id *idarraydatap, *idarraydataend;
Offset ido;
unsigned int databits;
exit(1);
}
- /* create empty Repo */
- repo = pool_addrepo_empty(pool);
pool_freeidhashes(pool);
- repo->name = reponame;
-
numid = read_u32(fp);
numrel = read_u32(fp);
numsolv= read_u32(fp);
/*
* alloc buffers
*/
- /* alloc string buffer */
+
+ /* alloc string buffer */
strsp = (char *)xrealloc(pool->stringspace, pool->sstrings + sizeid + 1);
- /* alloc string offsets (Id -> Offset into string space) */
+ /* alloc string offsets (Id -> Offset into string space) */
str = (Offset *)xrealloc(pool->strings, (pool->nstrings + numid) * sizeof(Offset));
pool->stringspace = strsp;
/* point to _BEHIND_ already allocated string/Id space */
strsp += pool->sstrings;
- /* alloc id map for name and rel Ids */
+ /* alloc id map for name and rel Ids. this maps ids in the solv files
+ * to the ids in our pool */
idmap = (Id *)xcalloc(numid + numrel, sizeof(Id));
/*
}
/*
- * read (but dont store) repo data
+ * read (but dont store yet) repo data
*/
#if 0
fprintf(stderr, "too many data map bits\n");
exit(1);
}
+
+ /* make room for our idarrays */
if (size_idarray)
{
- size_idarray++; /* first entry is always zero */
- repo->idarraydata = (Id *)xmalloc(sizeof(Id) * size_idarray);
- repo->idarraysize = size_idarray;
- idarraydatap = repo->idarraydata;
- *idarraydatap++ = 0;
- idarraydataend = repo->idarraydata + size_idarray;
+ repo_reserve_ids(repo, 0, size_idarray);
+ idarraydatap = repo->idarraydata + repo->idarraysize;
+ repo->idarraysize += size_idarray;
+ idarraydataend = repo->idarraydata + repo->idarraysize;
+ repo->lastoff = 0;
}
else
{
- repo->idarraydata = 0;
- repo->idarraysize = 0;
idarraydatap = 0;
idarraydataend = 0;
}
- /* alloc solvables */
+ if (repo->start && repo->start + repo->nsolvables != pool->nsolvables)
+ abort();
+ if (!repo->start)
+ repo->start = pool->nsolvables;
+
+ /* alloc space for our solvables */
pool->solvables = (Solvable *)xrealloc(pool->solvables, (pool->nsolvables + numsolv) * sizeof(Solvable));
if (numsolv) /* clear newly allocated area */
memset(pool->solvables + pool->nsolvables, 0, numsolv * sizeof(Solvable));
- repo->start = pool->nsolvables;
- repo->nsolvables = numsolv;
/*
* read solvables
#if 0
printf("read solvables\n");
#endif
- for (i = 0, s = pool->solvables + repo->start; i < numsolv; i++, s++)
+ for (i = 0, s = pool->solvables + repo->start + repo->nsolvables; i < numsolv; i++, s++)
{
s->repo = repo;
databits = 0;
xfree(idmap);
xfree(solvdata);
+ repo->nsolvables += numsolv;
pool->nsolvables += numsolv;
-
- return repo;
}
// EOF
#include "pool.h"
#include "repo.h"
-extern Repo *pool_addrepo_solv(Pool *pool, FILE *fp, const char *name);
+extern void repo_add_solv(Repo *repo, FILE *fp);
#ifdef __cplusplus
}
main(int argc, char **argv)
{
Pool *pool = pool_create();
- Repo *repo = pool_addrepo_content(pool, stdin);
- pool_writerepo(pool, repo, stdout);
+ Repo *repo = repo_create(pool, "<stdin>");
+ repo_add_content(repo, stdin);
+ repo_write(repo, stdout);
pool_free(pool);
return 0;
}
}
}
pool = pool_create();
- repo = pool_addrepo_solv(pool, stdin, "");
+ repo = repo_create(pool, argc != 1 ? argv[1] : "<stdin>");
+ repo_add_solv(repo, stdin);
printf("repo contains %d solvables\n", repo->nsolvables);
for (i = repo->start; i < repo->start + repo->nsolvables; i++)
{
main(int argc, char **argv)
{
Pool *pool = pool_create();
- Repo *repo = pool_addrepo_helix(pool, stdin);
- pool_writerepo(pool, repo, stdout);
+ Repo *repo = repo_create(pool, "<stdin>");
+ repo_add_helix(repo, stdin);
+ repo_write(repo, stdout);
pool_free(pool);
exit(0);
}
perror(argv[1]);
exit(0);
}
- pool_addrepo_solv(pool, fp, "");
+ repo_add_solv(repo_create(pool, ""), fp);
fclose(fp);
}
if (!pool->nrepos)
}
while (pool->nrepos > 1)
{
- pool_freerepo (pool, pool->repos[1]);
+ repo_free(pool->repos[1]);
}
free (pool->repos[0]->idarraydata);
pool->repos[0]->idarraydata = new_id;
pool->repos[0]->idarraysize = new_id_size;
- pool_writerepo(pool, pool->repos[0], stdout);
+ repo_write(pool->repos[0], stdout);
pool_free(pool);
return 0;
main(int argc, char **argv)
{
Pool *pool = pool_create();
- Repo *repo = pool_addrepo_patchxml(pool, stdin);
- pool_writerepo(pool, repo, stdout);
+ Repo *repo = repo_create(pool, "<stdin>");
+ repo_add_patchxml(repo, stdin);
+ repo_write(repo, stdout);
pool_free(pool);
exit(0);
}
return olddeps;
}
-Repo *
-pool_addrepo_content(Pool *pool, FILE *fp)
+void
+repo_add_content(Repo *repo, FILE *fp)
{
+ Pool *pool = repo->pool;
char *line, *linep;
int aline;
- Repo *repo;
Solvable *s;
int pack;
struct parsedata pd;
- repo = pool_addrepo_empty(pool);
memset(&pd, 0, sizeof(pd));
line = xmalloc(1024);
aline = 1024;
if ((pack & PACK_BLOCK) == 0)
{
pool->solvables = realloc(pool->solvables, (pool->nsolvables + pack + PACK_BLOCK + 1) * sizeof(Solvable));
- memset(pool->solvables + repo->start + pack, 0, (PACK_BLOCK + 1) * sizeof(Solvable));
+ memset(pool->solvables + pool->nsolvables + pack, 0, (PACK_BLOCK + 1) * sizeof(Solvable));
}
- s = pool->solvables + repo->start + pack;
+ s = pool->solvables + pool->nsolvables + pack;
s->repo = repo;
s->name = str2id(pool, join(&pd, pd.kind, ":", value), 1);
pack++;
s->supplements = repo_fix_legacy(repo, s->provides, s->supplements);
pool->nsolvables += pack;
- repo->nsolvables = pack;
+ repo->nsolvables += pack;
if (pd.tmp)
free(pd.tmp);
free(line);
-
- return repo;
}
* for further information
*/
-Repo * pool_addrepo_content(Pool *pool, FILE *fp);
+void repo_add_content(Repo *repo, FILE *fp);
if ((pd->pack & PACK_BLOCK) == 0) /* alloc new block ? */
{
pool->solvables = (Solvable *)realloc(pool->solvables, (pool->nsolvables + pd->pack + PACK_BLOCK + 1) * sizeof(Solvable));
- pd->start = pool->solvables + pd->repo->start;
+ pd->start = pool->solvables + pool->nsolvables;
memset(pd->start + pd->pack, 0, (PACK_BLOCK + 1) * sizeof(Solvable));
}
*
*/
-Repo *
-pool_addrepo_helix(Pool *pool, FILE *fp)
+void
+repo_add_helix(Repo *repo, FILE *fp)
{
+ Pool *pool = repo->pool;
Parsedata pd;
char buf[BUFF_SIZE];
int i, l;
- Repo *repo;
struct stateswitch *sw;
- // create empty repo
- repo = pool_addrepo_empty(pool);
+ if (repo->start && repo->start + repo->nsolvables != pool->nsolvables)
+ abort();
+ if (!repo->start)
+ repo->start = pool->nsolvables;
- // prepare parsedata
+ /* prepare parsedata */
memset(&pd, 0, sizeof(pd));
for (i = 0, sw = stateswitches; sw->from != NUMSTATES; i++, sw++)
{
// adapt package count
pool->nsolvables += pd.pack;
- repo->nsolvables = pd.pack;
+ repo->nsolvables += pd.pack;
free(pd.content);
free(pd.evrspace);
-
- return repo;
}
#include "pool.h"
#include "repo.h"
-extern Repo *pool_addrepo_helix(Pool *pool, FILE *fp);
+extern void repo_add_helix(Repo *repo, FILE *fp);
#endif /* REPO_HELIX_H */
if ((pd->pack & PACK_BLOCK) == 0)
{
pool->solvables = realloc(pool->solvables, (pool->nsolvables + pd->pack + PACK_BLOCK + 1) * sizeof(Solvable));
- pd->start = pool->solvables + pd->repo->start;
+ pd->start = pool->solvables + pool->nsolvables;
memset(pd->start + pd->pack, 0, (PACK_BLOCK + 1) * sizeof(Solvable));
}
#if 0
#define BUFF_SIZE 8192
-Repo *
-pool_addrepo_patchxml(Pool *pool, FILE *fp)
+void
+repo_add_patchxml(Repo *repo, FILE *fp)
{
+ Pool *pool = repo->pool;
struct parsedata pd;
char buf[BUFF_SIZE];
int i, l;
- Repo *repo;
struct stateswitch *sw;
- repo = pool_addrepo_empty(pool);
+ if (repo->start && repo->start + repo->nsolvables != pool->nsolvables)
+ abort();
+ if (!repo->start)
+ repo->start = pool->nsolvables;
+
memset(&pd, 0, sizeof(pd));
for (i = 0, sw = stateswitches; sw->from != NUMSTATES; i++, sw++)
{
XML_ParserFree(parser);
pool->nsolvables += pd.pack;
- repo->nsolvables = pd.pack;
+ repo->nsolvables += pd.pack;
free(pd.content);
- return repo;
}
* for further information
*/
-extern Repo *pool_addrepo_patchxml(Pool *pool, FILE *fp);
+extern void repo_add_patchxml(Repo *repo, FILE *fp);
*
*/
-Repo *
-pool_addrepo_rpmdb(Pool *pool, Repo *ref)
+void
+repo_add_rpmdb(Repo *repo, Repo *ref)
{
+ Pool *pool = repo->pool;
unsigned char buf[16];
DB *db = 0;
DBC *dbc = 0;
int i;
int rpmheadsize;
RpmHead *rpmhead;
- Repo *repo;
Solvable *s;
Id id, *refhash;
unsigned int refmask, h;
int asolv;
- repo = pool_addrepo_empty(pool);
+ if (repo->start && repo->start + repo->nsolvables != pool->nsolvables)
+ abort();
+ if (!repo->start)
+ repo->start = pool->nsolvables;
if (ref && !(ref->nsolvables && ref->rpmdbid))
ref = 0;
}
dbidp = (unsigned char *)&dbid;
pool->solvables = xrealloc(pool->solvables, (pool->nsolvables + 256) * sizeof(Solvable));
- memset(pool->solvables + repo->start, 0, 256 * sizeof(Solvable));
+ memset(pool->solvables + pool->nsolvables, 0, 256 * sizeof(Solvable));
repo->rpmdbid = xcalloc(256, sizeof(unsigned int));
asolv = 256;
rpmheadsize = 0;
if (i >= asolv)
{
pool->solvables = xrealloc(pool->solvables, (pool->nsolvables + asolv + 256) * sizeof(Solvable));
- memset(pool->solvables + repo->start + asolv, 0, 256 * sizeof(Solvable));
+ memset(pool->solvables + pool->nsolvables + asolv, 0, 256 * sizeof(Solvable));
repo->rpmdbid = xrealloc(repo->rpmdbid, (asolv + 256) * sizeof(unsigned int));
memset(repo->rpmdbid + asolv, 0, 256 * sizeof(unsigned int));
asolv += 256;
}
- pool->solvables[repo->start + i].repo = repo;
+ pool->solvables[pool->nsolvables + i].repo = repo;
if (key.size != 4)
{
fprintf(stderr, "corrupt Packages database (key size)\n");
memcpy(rpmhead->data, (unsigned char *)data.data + 8, rpmhead->cnt * 16 + rpmhead->dcnt);
rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
repo->rpmdbid[i] = dbid;
- if (rpm2solv(pool, repo, pool->solvables + repo->start + i, rpmhead))
+ if (rpm2solv(pool, repo, pool->solvables + pool->nsolvables + i, rpmhead))
i++;
}
nrpmids = i;
rpmheadsize = 0;
rpmhead = 0;
- pool->solvables = xrealloc(pool->solvables, (pool->nsolvables + nrpmids) * sizeof(Solvable));
- memset(pool->solvables + repo->start, 0, nrpmids * sizeof(Solvable));
+ pool->solvables = xrealloc2(pool->solvables, (pool->nsolvables + nrpmids), sizeof(Solvable));
+ memset(pool->solvables + pool->nsolvables, 0, nrpmids * sizeof(Solvable));
repo->rpmdbid = calloc(nrpmids, sizeof(unsigned int));
refhash = 0;
refhash[h] = i + 1; /* make it non-zero */
}
}
- s = pool->solvables + repo->start;
+ s = pool->solvables + pool->nsolvables;
for (i = 0; i < nrpmids; i++, rp++, s++)
{
s->repo = repo;
if (rpmhead)
free(rpmhead);
pool->nsolvables += nrpmids;
- repo->nsolvables = nrpmids;
+ repo->nsolvables += nrpmids;
if (db)
db->close(db, 0);
- return repo;
}
* for further information
*/
-extern Repo *pool_addrepo_rpmdb(Pool *pool, Repo *ref);
+extern void repo_add_rpmdb(Repo *repo, Repo *ref);
#include <expat.h>
#include "pool.h"
+#include "util.h"
#include "repo_rpmmd.h"
l += strlen(r) + 1;
if (l > pd->acontent)
{
- pd->content = realloc(pd->content, l + 256);
+ pd->content = xrealloc(pd->content, l + 256);
pd->acontent = l + 256;
}
c = pd->content;
int l = strlen(k) + 1 + strlen(n) + 1;
if (l > pd->acontent)
{
- pd->content = realloc(pd->content, l + 256);
+ pd->content = xrealloc(pd->content, l + 256);
pd->acontent = l + 256;
}
sprintf(pd->content, "%s:%s", k, n);
#if 0
fprintf(stderr, "numpacks: %d\n", pd->numpacks);
#endif
- pool->solvables = realloc(pool->solvables, (pool->nsolvables + pd->numpacks) * sizeof(Solvable));
- pd->start = pool->solvables + pd->repo->start;
+ pool->solvables = xrealloc2(pool->solvables, (pool->nsolvables + pd->numpacks), sizeof(Solvable));
+ pd->start = pool->solvables + pool->nsolvables;
memset(pd->start, 0, pd->numpacks * sizeof(Solvable));
}
}
l = pd->lcontent + len + 1;
if (l > pd->acontent)
{
- pd->content = realloc(pd->content, l + 256);
+ pd->content = xrealloc(pd->content, l + 256);
pd->acontent = l + 256;
}
c = pd->content + pd->lcontent;
#define BUFF_SIZE 8192
-Repo *
-pool_addrepo_rpmmd(Pool *pool, FILE *fp)
+void
+repo_add_rpmmd(Repo *repo, FILE *fp)
{
+ Pool *pool = repo->pool;
struct parsedata pd;
char buf[BUFF_SIZE];
int i, l;
- Repo *repo;
struct stateswitch *sw;
- repo = pool_addrepo_empty(pool);
+ if (repo->start && repo->start + repo->nsolvables != pool->nsolvables)
+ abort();
+ if (!repo->start)
+ repo->start = pool->nsolvables;
+
memset(&pd, 0, sizeof(pd));
for (i = 0, sw = stateswitches; sw->from != NUMSTATES; i++, sw++)
{
XML_ParserFree(parser);
pool->nsolvables += pd.pack;
- repo->nsolvables = pd.pack;
+ repo->nsolvables += pd.pack;
free(pd.content);
- return repo;
}
* for further information
*/
-extern Repo *pool_addrepo_rpmmd(Pool *pool, FILE *fp);
+extern void repo_add_rpmmd(Repo *repo, FILE *fp);
Attrstore *attr;
-Repo *
-pool_addrepo_susetags(Pool *pool, FILE *fp, Id vendor, int with_attr)
+void
+repo_add_susetags(Repo *repo, FILE *fp, Id vendor, int with_attr)
{
+ Pool *pool = repo->pool;
char *line, *linep;
int aline;
- Repo *repo;
Solvable *s;
int intag = 0;
int cummulate = 0;
char *sp[5];
struct parsedata pd;
- repo = pool_addrepo_empty(pool);
+ if (repo->start && repo->start + repo->nsolvables != pool->nsolvables)
+ abort();
+ if (!repo->start)
+ repo->start = pool->nsolvables;
+
attr = new_store (pool);
memset(&pd, 0, sizeof(pd));
line = malloc(1024);
if ((pack & PACK_BLOCK) == 0)
{
pool->solvables = realloc(pool->solvables, (pool->nsolvables + pack + PACK_BLOCK + 1) * sizeof(Solvable));
- memset(pool->solvables + repo->start + pack, 0, (PACK_BLOCK + 1) * sizeof(Solvable));
+ memset(pool->solvables + pool->nsolvables + pack, 0, (PACK_BLOCK + 1) * sizeof(Solvable));
}
- s = pool->solvables + repo->start + pack;
+ s = pool->solvables + pool->nsolvables + pack;
s->repo = repo;
last_found_pack = pack;
pack++;
{
if (nn >= pack)
nn = 0;
- s = pool->solvables + repo->start + nn;
+ s = pool->solvables + pool->nsolvables + nn;
if (s->name == name && s->evr == evr && s->arch == arch)
break;
}
s->supplements = repo_fix_legacy(repo, s->provides, s->supplements);
pool->nsolvables += pack;
- repo->nsolvables = pack;
+ repo->nsolvables += pack;
if (pd.tmp)
free(pd.tmp);
free(line);
- return repo;
}
* for further information
*/
-extern Repo *pool_addrepo_susetags(Pool *pool, FILE *fp, Id vendor, int with_attr);
+extern void repo_add_susetags(Repo *repo, FILE *fp, Id vendor, int with_attr);
*/
void
-pool_writerepo(Pool *pool, Repo *repo, FILE *fp)
+repo_write(Repo *repo, FILE *fp)
{
+ Pool *pool = repo->pool;
int i, numsolvdata;
Solvable *s, *sstart;
NeedId *needid;
#include "pool.h"
#include "repo.h"
-extern void pool_writerepo(Pool *pool, Repo *repo, FILE *fp);
+extern void repo_write(Repo *repo, FILE *fp);
#endif
main(int argc, char **argv)
{
Pool *pool = pool_create();
- Repo *ref = NULL;
+ Repo *repo, *ref = 0;
FILE *fp;
if (argc != 1)
perror(argv[1]);
exit(0);
}
- ref = pool_addrepo_solv(refpool, fp, "rpmdb");
+ ref = repo_create(refpool, "ref");
+ repo_add_solv(ref, fp);
fclose(fp);
}
- Repo *repo = pool_addrepo_rpmdb(pool, ref);
+ repo = repo_create(pool, "installed");
+ repo_add_rpmdb(repo, ref);
if (ref)
{
if (ref->pool != pool)
pool_free(ref->pool);
else
- pool_freerepo(pool, ref);
- ref = NULL;
+ repo_free(ref);
+ ref = 0;
}
- pool_writerepo(pool, repo, stdout);
+ repo_write(repo, stdout);
pool_free(pool);
exit(0);
main(int argc, char **argv)
{
Pool *pool = pool_create();
- Repo *repo = pool_addrepo_rpmmd(pool, stdin);
- pool_writerepo(pool, repo, stdout);
+ Repo *repo = repo_create(pool, "<stdin>");
+ repo_add_rpmmd(repo, stdin);
+ repo_write(repo, stdout);
pool_free(pool);
exit(0);
}
argv++;
}
Pool *pool = pool_create();
- Repo *repo = pool_addrepo_susetags(pool, stdin, 0, with_attr);
- pool_writerepo(pool, repo, stdout);
+ Repo *repo = repo_create(pool, "<stdin>");
+ repo_add_susetags(repo, stdin, 0, with_attr);
+ repo_write(repo, stdout);
if (with_attr && attr)
{
FILE *fp = fopen ("test.attr", "w");