#include "razor.h"
static void
-parse_package(struct import_context *ctx, const char **atts, void *data)
+parse_package(struct razor_importer *importer, const char **atts, void *data)
{
const char *name = NULL, *version = NULL;
int i;
return;
}
- import_context_add_package(ctx, name, version);
+ razor_importer_begin_package(importer, name, version);
}
+enum {
+ RZR_REQUIRES, RZR_PROVIDES
+};
+
static void
-parse_property(struct import_context *ctx, const char **atts, void *data)
+parse_property(struct razor_importer *importer, const char **atts, void *data)
{
const char *name = NULL, *version = NULL;
int i;
return;
}
- import_context_add_property(ctx, data, name, version);
+ switch ((int) data) {
+ case RZR_REQUIRES:
+ razor_importer_add_requires(importer, name, version);
+ break;
+ case RZR_PROVIDES:
+ razor_importer_add_provides(importer, name, version);
+ break;
+ }
}
static void
start_element(void *data, const char *name, const char **atts)
{
- struct import_context *ctx = data;
+ struct razor_importer *importer = data;
if (strcmp(name, "package") == 0)
- parse_package(ctx, atts, NULL);
+ parse_package(importer, atts, NULL);
else if (strcmp(name, "requires") == 0)
- parse_property(ctx, atts, &ctx->requires);
+ parse_property(importer, atts, (void *) RZR_REQUIRES);
else if (strcmp(name, "provides") == 0)
- parse_property(ctx, atts, &ctx->provides);
+ parse_property(importer, atts, (void*) RZR_PROVIDES);
}
static void
end_element (void *data, const char *name)
{
- struct import_context *ctx = data;
+ struct razor_importer *importer = data;
if (strcmp(name, "package") == 0)
- import_context_finish_package(ctx);
+ razor_importer_finish_package(importer);
}
static int
-import_rzr_file(struct import_context *ctx, const char *filename)
+import_rzr_file(struct razor_importer *importer, const char *filename)
{
SHA_CTX sha1;
XML_Parser parser;
return -1;
parser = XML_ParserCreate(NULL);
- XML_SetUserData(parser, ctx);
+ XML_SetUserData(parser, importer);
XML_SetElementHandler(parser, start_element, end_element);
if (XML_Parse(parser, p, stat.st_size, 1) == XML_STATUS_ERROR) {
fprintf(stderr,
struct razor_set *
razor_import_rzr_files(int count, const char *files[])
{
- struct import_context ctx;
+ struct razor_importer *importer;
int i;
- razor_prepare_import(&ctx);
+ importer = razor_importer_new();
for (i = 0; i < count; i++) {
- if (import_rzr_file(&ctx, files[i]) < 0) {
+ if (import_rzr_file(importer, files[i]) < 0) {
fprintf(stderr, "failed to import %s\n", files[i]);
exit(-1);
}
}
- return razor_finish_import(&ctx);
+ return razor_importer_finish(importer);
}
/* Import a yum filelist as a razor package set. */
enum {
YUM_STATE_BEGIN,
- YUM_STATE_PACKAGE_NAME
+ YUM_STATE_PACKAGE_NAME,
+ YUM_STATE_REQUIRES,
+ YUM_STATE_PROVIDES
};
struct yum_context {
- struct import_context ctx;
+ struct razor_importer *importer;
struct import_property_context *current_property_context;
char *name;
int state;
if (strcmp(atts[i], "ver") == 0)
version = atts[i + 1];
}
- import_context_add_package(&ctx->ctx, ctx->name, version);
+ razor_importer_begin_package(ctx->importer, ctx->name, version);
} else if (strcmp(name, "rpm:requires") == 0) {
- ctx->current_property_context = &ctx->ctx.requires;
+ ctx->state = YUM_STATE_REQUIRES;
} else if (strcmp(name, "rpm:provides") == 0) {
- ctx->current_property_context = &ctx->ctx.provides;
+ ctx->state = YUM_STATE_PROVIDES;
} else if (strcmp(name, "rpm:entry") == 0 &&
- ctx->current_property_context != NULL) {
+ ctx->state != YUM_STATE_BEGIN) {
n = NULL;
version = NULL;
for (i = 0; atts[i]; i += 2) {
return;
}
- import_context_add_property(&ctx->ctx,
- ctx->current_property_context,
- n, version);
+ switch (ctx->state) {
+ case YUM_STATE_REQUIRES:
+ razor_importer_add_requires(ctx->importer, n, version);
+ break;
+ case YUM_STATE_PROVIDES:
+ razor_importer_add_provides(ctx->importer, n, version);
+ break;
+ }
+
}
}
if (strcmp(name, "package") == 0) {
free(ctx->name);
- import_context_finish_package(&ctx->ctx);
+ razor_importer_finish_package(ctx->importer);
} else if (strcmp(name, "name") == 0) {
- ctx->state = 0;
+ ctx->state = YUM_STATE_BEGIN;
} else if (strcmp(name, "rpm:requires") == 0) {
- ctx->current_property_context = NULL;
+ ctx->state = YUM_STATE_BEGIN;
} else if (strcmp(name, "rpm:provides") == 0) {
- ctx->current_property_context = NULL;
+ ctx->state = YUM_STATE_BEGIN;
}
}
char buf[4096];
int len;
- razor_prepare_import(&ctx.ctx);
+ ctx.importer = razor_importer_new();
parser = XML_ParserCreate(NULL);
XML_SetUserData(parser, &ctx);
XML_ParserFree(parser);
- return razor_finish_import(&ctx.ctx);
+ return razor_importer_finish(ctx.importer);
}
struct razor_set *
razor_set_create_from_rpmdb(void)
{
- struct import_context ctx;
+ struct razor_importer *importer;
rpmdbMatchIterator iter;
Header h;
int_32 type, count, i;
exit(1);
}
- razor_prepare_import(&ctx);
+ importer = razor_importer_new();
iter = rpmdbInitIterator(db, 0, NULL, 0);
while (h = rpmdbNextIterator(iter), h != NULL) {
(void **) &version, &count);
headerGetEntry(h, RPMTAG_RELEASE, &type,
(void **) &release, &count);
- import_context_add_package(&ctx, name, version);
-
+ razor_importer_begin_package(importer, name, version);
headerGetEntry(h, RPMTAG_REQUIRES, &type,
(void **) &properties, &count);
headerGetEntry(h, RPMTAG_REQUIREVERSION, &type,
(void **) &property_versions, &count);
for (i = 0; i < count; i++)
- import_context_add_property(&ctx,
- &ctx.requires,
+ razor_importer_add_requires(importer,
properties[i],
property_versions[i]);
headerGetEntry(h, RPMTAG_PROVIDEVERSION, &type,
(void **) &property_versions, &count);
for (i = 0; i < count; i++)
- import_context_add_property(&ctx,
- &ctx.provides,
+ razor_importer_add_provides(importer,
properties[i],
property_versions[i]);
- import_context_finish_package(&ctx);
+ razor_importer_finish_package(importer);
}
rpmdbClose(db);
- return razor_finish_import(&ctx);
+ return razor_importer_finish(importer);
}
#include "razor.h"
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+
+struct array {
+ void *data;
+ int size, alloc;
+};
+
+struct razor_set_section {
+ unsigned int type;
+ unsigned int offset;
+ unsigned int size;
+};
+
+struct razor_set_header {
+ unsigned int magic;
+ unsigned int version;
+ struct razor_set_section sections[0];
+};
+
+#define RAZOR_MAGIC 0x7a7a7a7a
+#define RAZOR_VERSION 1
+
+#define RAZOR_PACKAGES 0
+#define RAZOR_REQUIRES 1
+#define RAZOR_PROVIDES 2
+#define RAZOR_STRING_POOL 3
+#define RAZOR_PROPERTY_POOL 4
+
+struct razor_package {
+ unsigned long name;
+ unsigned long version;
+ unsigned long requires;
+ unsigned long provides;
+};
+
+struct razor_property {
+ unsigned long name;
+ unsigned long version;
+ unsigned long packages;
+};
+
+struct razor_set {
+ struct array buckets;
+ struct array string_pool;
+ struct array property_pool;
+ struct array packages;
+ struct array requires;
+ struct array provides;
+ struct razor_set_header *header;
+};
+
+struct import_property_context {
+ struct array *all;
+ struct array package;
+};
+
+struct razor_importer {
+ struct razor_set *set;
+ struct import_property_context requires;
+ struct import_property_context provides;
+ struct razor_package *package;
+ unsigned long *requires_map;
+ unsigned long *provides_map;
+};
+
static void
array_init(struct array *array)
{
return value;
}
-unsigned long
+static unsigned long
razor_set_tokenize(struct razor_set *set, const char *string)
{
unsigned long token;
}
void
-import_context_add_package(struct import_context *ctx,
- const char *name, const char *version)
+razor_importer_begin_package(struct razor_importer *importer,
+ const char *name, const char *version)
{
struct razor_package *p;
- p = array_add(&ctx->set->packages, sizeof *p);
- p->name = razor_set_tokenize(ctx->set, name);
- p->version = razor_set_tokenize(ctx->set, version);
+ p = array_add(&importer->set->packages, sizeof *p);
+ p->name = razor_set_tokenize(importer->set, name);
+ p->version = razor_set_tokenize(importer->set, version);
- ctx->package = p;
- array_init(&ctx->requires.package);
- array_init(&ctx->provides.package);
+ importer->package = p;
+ array_init(&importer->requires.package);
+ array_init(&importer->provides.package);
}
void
-import_context_finish_package(struct import_context *ctx)
+razor_importer_finish_package(struct razor_importer *importer)
{
struct razor_package *p;
- p = ctx->package;
- p->requires = add_to_property_pool(ctx->set, &ctx->requires.package);
- p->provides = add_to_property_pool(ctx->set, &ctx->provides.package);
+ p = importer->package;
+ p->requires = add_to_property_pool(importer->set,
+ &importer->requires.package);
+ p->provides = add_to_property_pool(importer->set,
+ &importer->provides.package);
- array_release(&ctx->requires.package);
- array_release(&ctx->provides.package);
+ array_release(&importer->requires.package);
+ array_release(&importer->provides.package);
}
-void
-import_context_add_property(struct import_context *ctx,
+static void
+razor_importer_add_property(struct razor_importer *importer,
struct import_property_context *pctx,
const char *name, const char *version)
{
unsigned long *r;
p = array_add(pctx->all, sizeof *p);
- p->name = razor_set_tokenize(ctx->set, name);
- p->version = razor_set_tokenize(ctx->set, version);
- p->packages = ctx->package -
- (struct razor_package *) ctx->set->packages.data;
+ p->name = razor_set_tokenize(importer->set, name);
+ p->version = razor_set_tokenize(importer->set, version);
+ p->packages = importer->package -
+ (struct razor_package *) importer->set->packages.data;
r = array_add(&pctx->package, sizeof *r);
*r = p - (struct razor_property *) pctx->all->data;
}
void
-razor_prepare_import(struct import_context *ctx)
+razor_importer_add_requires(struct razor_importer *importer,
+ const char *name, const char *version)
+{
+ razor_importer_add_property(importer,
+ &importer->requires, name, version);
+}
+
+void
+razor_importer_add_provides(struct razor_importer *importer,
+ const char *name, const char *version)
+{
+ razor_importer_add_property(importer,
+ &importer->provides, name, version);
+}
+
+struct razor_importer *
+razor_importer_new(void)
{
- memset(ctx, 0, sizeof *ctx);
- ctx->set = razor_set_create();
- ctx->requires.all = &ctx->set->requires;
- ctx->provides.all = &ctx->set->provides;
+ struct razor_importer *importer;
+
+ importer = zalloc(sizeof *importer);
+ importer->set = razor_set_create();
+ importer->requires.all = &importer->set->requires;
+ importer->provides.all = &importer->set->provides;
+
+ return importer;
}
typedef int (*compare_with_data_func_t)(const void *p1,
}
static void
-remap_package_links(struct import_context *ctx)
+remap_package_links(struct razor_importer *importer)
{
struct razor_package *p, *end;
unsigned long *pool, *r;
- pool = ctx->set->property_pool.data;
- end = ctx->set->packages.data + ctx->set->packages.size;
- for (p = ctx->set->packages.data; p < end; p++) {
+ pool = importer->set->property_pool.data;
+ end = importer->set->packages.data + importer->set->packages.size;
+ for (p = importer->set->packages.data; p < end; p++) {
for (r = &pool[p->requires]; ~*r; r++)
- *r = ctx->requires_map[*r];
+ *r = importer->requires_map[*r];
for (r = &pool[p->provides]; ~*r; r++)
- *r = ctx->provides_map[*r];
+ *r = importer->provides_map[*r];
}
}
static void
-remap_property_links(struct import_context *ctx, unsigned long *map)
+remap_property_links(struct razor_importer *importer, unsigned long *map)
{
struct razor_property *p, *end;
struct razor_package *rp;
unsigned long *pool, *r, *rmap;
int i, count;
- pool = ctx->set->property_pool.data;
- count = ctx->set->packages.size / sizeof(struct razor_package);
+ pool = importer->set->property_pool.data;
+ count = importer->set->packages.size / sizeof(struct razor_package);
rmap = malloc(count * sizeof *map);
- rp = ctx->set->packages.data;
+ rp = importer->set->packages.data;
for (i = 0; i < count; i++)
rmap[map[i]] = i;
* a flat pool. Right now, as property lists and package
* lists are mixed, we can't do that. */
- end = ctx->set->requires.data + ctx->set->requires.size;
- for (p = ctx->set->requires.data; p < end; p++)
+ end = importer->set->requires.data + importer->set->requires.size;
+ for (p = importer->set->requires.data; p < end; p++)
for (r = &pool[p->packages]; ~*r; r++)
*r = rmap[*r];
- end = ctx->set->provides.data + ctx->set->provides.size;
- for (p = ctx->set->provides.data; p < end; p++)
+ end = importer->set->provides.data + importer->set->provides.size;
+ for (p = importer->set->provides.data; p < end; p++)
for (r = &pool[p->packages]; ~*r; r++)
*r = rmap[*r];
}
struct razor_set *
-razor_finish_import(struct import_context *ctx)
+razor_importer_finish(struct razor_importer *importer)
{
+ struct razor_set *set;
unsigned long *map;
int count;
- ctx->requires_map = uniqueify_properties(ctx->set, ctx->requires.all);
- ctx->provides_map = uniqueify_properties(ctx->set, ctx->provides.all);
- remap_package_links(ctx);
- free(ctx->requires_map);
- free(ctx->provides_map);
+ importer->requires_map = uniqueify_properties(importer->set,
+ importer->requires.all);
+ importer->provides_map = uniqueify_properties(importer->set,
+ importer->provides.all);
+ remap_package_links(importer);
+ free(importer->requires_map);
+ free(importer->provides_map);
- count = ctx->set->packages.size / sizeof(struct razor_package);
- map = qsort_with_data(ctx->set->packages.data,
+ count = importer->set->packages.size / sizeof(struct razor_package);
+ map = qsort_with_data(importer->set->packages.data,
count,
sizeof(struct razor_package),
compare_packages,
- ctx->set);
- remap_property_links(ctx, map);
+ importer->set);
+ remap_property_links(importer, map);
free(map);
- return ctx->set;
+ set = importer->set;
+ free(importer);
+
+ return set;
}
void
#ifndef _RAZOR_H_
#define _RAZOR_H_
-#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+struct razor_importer;
-struct array {
- void *data;
- int size, alloc;
-};
-
-struct razor_set_section {
- unsigned int type;
- unsigned int offset;
- unsigned int size;
-};
-
-struct razor_set_header {
- unsigned int magic;
- unsigned int version;
- struct razor_set_section sections[0];
-};
-
-#define RAZOR_MAGIC 0x7a7a7a7a
-#define RAZOR_VERSION 1
-
-#define RAZOR_PACKAGES 0
-#define RAZOR_REQUIRES 1
-#define RAZOR_PROVIDES 2
-#define RAZOR_STRING_POOL 3
-#define RAZOR_PROPERTY_POOL 4
-
-struct razor_package {
- unsigned long name;
- unsigned long version;
- unsigned long requires;
- unsigned long provides;
-};
-
-struct razor_property {
- unsigned long name;
- unsigned long version;
- unsigned long packages;
-};
-
-struct razor_set {
- struct array buckets;
- struct array string_pool;
- struct array property_pool;
- struct array packages;
- struct array requires;
- struct array provides;
- struct razor_set_header *header;
-};
-
-struct import_property_context {
- struct array *all;
- struct array package;
-};
-
-struct import_context {
- struct razor_set *set;
- struct import_property_context requires;
- struct import_property_context provides;
- struct razor_package *package;
- unsigned long *requires_map;
- unsigned long *provides_map;
-};
-
-void import_context_add_package(struct import_context *ctx,
+struct razor_importer *razor_importer_new(void);
+void razor_importer_begin_package(struct razor_importer *importer,
const char *name, const char *version);
-void import_context_add_property(struct import_context *ctx,
- struct import_property_context *pctx,
+void razor_importer_add_requires(struct razor_importer *importer,
const char *name, const char *version);
-void import_context_finish_package(struct import_context *ctx);
-
-unsigned long razor_set_tokenize(struct razor_set *set, const char *string);
-void razor_prepare_import(struct import_context *ctx);
-struct razor_set *razor_finish_import(struct import_context *ctx);
+void razor_importer_add_provides(struct razor_importer *importer,
+ const char *name, const char *version);
+void razor_importer_finish_package(struct razor_importer *importer);
+struct razor_set *razor_importer_finish(struct razor_importer *importer);
struct razor_set *razor_import_rzr_files(int count, const char **files);
struct razor_set *razor_set_create_from_yum_filelist(int fd);
git://project.juiblex.co.uk / razor2.git/.git / commitdiff