razor: razor.c@07a5bf8e7e6e (annotated)

krh@15	1	#define _GNU_SOURCE
krh@15	2
krh@0	3	#include <stdlib.h>
krh@19	4	#include <stddef.h>
danw@108	5	#include <stdint.h>
krh@0	6	#include <stdio.h>
krh@0	7	#include <string.h>
krh@0	8	#include <sys/types.h>
krh@0	9	#include <sys/stat.h>
krh@0	10	#include <sys/mman.h>
krh@0	11	#include <unistd.h>
krh@0	12	#include <fcntl.h>
krh@15	13	#include <errno.h>
krh@35	14	#include <ctype.h>
krh@54	15	#include <fnmatch.h>
krh@0	16
krh@27	17	#include "razor.h"
krh@91	18	#include "razor-internal.h"
krh@6	19
krh@30	20	struct array {
krh@30	21	void *data;
krh@30	22	int size, alloc;
krh@30	23	};
krh@30	24
krh@30	25	struct razor_set_section {
danw@108	26	uint32_t type;
danw@108	27	uint32_t offset;
danw@108	28	uint32_t size;
krh@30	29	};
krh@30	30
krh@30	31	struct razor_set_header {
danw@108	32	uint32_t magic;
danw@108	33	uint32_t version;
krh@30	34	struct razor_set_section sections[0];
krh@30	35	};
krh@30	36
krh@30	37	#define RAZOR_MAGIC 0x7a7a7a7a
krh@30	38	#define RAZOR_VERSION 1
krh@30	39
krh@61	40	#define RAZOR_ENTRY_LAST 0x80000000ul
krh@61	41	#define RAZOR_IMMEDIATE 0x80000000ul
krh@61	42	#define RAZOR_ENTRY_MASK 0x00fffffful
krh@61	43
krh@66	44	#define RAZOR_STRING_POOL 0
krh@66	45	#define RAZOR_PACKAGES 1
krh@66	46	#define RAZOR_PROPERTIES 2
krh@66	47	#define RAZOR_FILES 3
krh@66	48	#define RAZOR_PACKAGE_POOL 4
krh@66	49	#define RAZOR_PROPERTY_POOL 5
krh@66	50	#define RAZOR_FILE_POOL 6
krh@30	51
krh@30	52	struct razor_package {
danw@108	53	uint32_t name;
danw@108	54	uint32_t version;
danw@108	55	uint32_t properties;
danw@108	56	uint32_t files;
krh@30	57	};
krh@30	58
krh@30	59	struct razor_property {
danw@108	60	uint32_t name;
danw@109	61	uint32_t relation;
danw@108	62	uint32_t version;
danw@108	63	uint32_t packages;
krh@30	64	};
krh@30	65
krh@48	66	struct razor_entry {
danw@108	67	uint32_t name;
danw@108	68	uint32_t start;
danw@108	69	uint32_t packages;
krh@48	70	};
krh@48	71
krh@30	72	struct razor_set {
krh@30	73	struct array string_pool;
krh@30	74	struct array packages;
krh@66	75	struct array properties;
krh@56	76	struct array files;
krh@56	77	struct array package_pool;
krh@66	78	struct array property_pool;
krh@56	79	struct array file_pool;
krh@30	80	struct razor_set_header *header;
krh@30	81	};
krh@30	82
krh@52	83	struct import_entry {
danw@108	84	uint32_t package;
krh@52	85	char *name;
krh@52	86	};
krh@52	87
krh@52	88	struct import_directory {
danw@108	89	uint32_t name, count;
krh@52	90	struct array files;
krh@52	91	struct array packages;
krh@52	92	struct import_directory *last;
krh@52	93	};
krh@52	94
krh@78	95	struct hashtable {
krh@78	96	struct array buckets;
krh@78	97	struct array *pool;
krh@78	98	};
krh@78	99
krh@30	100	struct razor_importer {
krh@30	101	struct razor_set *set;
krh@78	102	struct hashtable table;
krh@30	103	struct razor_package *package;
krh@66	104	struct array properties;
krh@48	105	struct array files;
krh@30	106	};
krh@30	107
krh@13	108	static void
krh@13	109	array_init(struct array *array)
krh@13	110	{
krh@13	111	memset(array, 0, sizeof *array);
krh@13	112	}
krh@13	113
krh@13	114	static void
krh@13	115	array_release(struct array *array)
krh@13	116	{
krh@13	117	free(array->data);
krh@13	118	}
krh@13	119
krh@6	120	static void *
krh@6	121	array_add(struct array *array, int size)
krh@6	122	{
krh@6	123	int alloc;
krh@6	124	void data, p;
krh@6	125
krh@6	126	if (array->alloc > 0)
krh@6	127	alloc = array->alloc;
krh@6	128	else
krh@10	129	alloc = 16;
krh@6	130
krh@6	131	while (alloc < array->size + size)
krh@6	132	alloc *= 2;
krh@6	133
krh@6	134	if (array->alloc < alloc) {
krh@6	135	data = realloc(array->data, alloc);
krh@6	136	if (data == NULL)
krh@6	137	return 0;
krh@6	138	array->data = data;
krh@6	139	array->alloc = alloc;
krh@6	140	}
krh@6	141
krh@6	142	p = array->data + array->size;
krh@6	143	array->size += size;
krh@6	144
krh@6	145	return p;
krh@6	146	}
krh@6	147
krh@0	148	static void *
krh@0	149	zalloc(size_t size)
krh@0	150	{
krh@0	151	void *p;
krh@0	152
krh@0	153	p = malloc(size);
krh@0	154	memset(p, 0, size);
krh@0	155
krh@0	156	return p;
krh@0	157	}
krh@0	158
krh@19	159	struct razor_set_section razor_sections[] = {
krh@56	160	{ RAZOR_STRING_POOL, offsetof(struct razor_set, string_pool) },
krh@19	161	{ RAZOR_PACKAGES, offsetof(struct razor_set, packages) },
krh@66	162	{ RAZOR_PROPERTIES, offsetof(struct razor_set, properties) },
krh@56	163	{ RAZOR_FILES, offsetof(struct razor_set, files) },
krh@39	164	{ RAZOR_PACKAGE_POOL, offsetof(struct razor_set, package_pool) },
krh@66	165	{ RAZOR_PROPERTY_POOL, offsetof(struct razor_set, property_pool) },
krh@56	166	{ RAZOR_FILE_POOL, offsetof(struct razor_set, file_pool) },
krh@19	167	};
krh@19	168
krh@4	169	struct razor_set *
krh@4	170	razor_set_create(void)
krh@0	171	{
krh@18	172	return zalloc(sizeof(struct razor_set));
krh@0	173	}
krh@0	174
krh@4	175	struct razor_set *
krh@4	176	razor_set_open(const char *filename)
krh@0	177	{
krh@4	178	struct razor_set *set;
krh@19	179	struct razor_set_section *s;
krh@0	180	struct stat stat;
krh@19	181	struct array *array;
krh@19	182	int fd;
krh@0	183
krh@4	184	set = zalloc(sizeof *set);
krh@0	185	fd = open(filename, O_RDONLY);
krh@0	186	if (fstat(fd, &stat) < 0)
krh@0	187	return NULL;
krh@4	188	set->header = mmap(NULL, stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
krh@4	189	if (set->header == MAP_FAILED) {
krh@4	190	free(set);
krh@0	191	return NULL;
krh@0	192	}
krh@0	193
krh@19	194	for (s = set->header->sections; ~s->type; s++) {
krh@19	195	if (s->type >= ARRAY_SIZE(razor_sections))
krh@19	196	continue;
krh@19	197	if (s->type != razor_sections[s->type].type)
krh@19	198	continue;
krh@19	199	array = (void *) set + razor_sections[s->type].offset;
krh@19	200	array->data = (void *) set->header + s->offset;
krh@19	201	array->size = s->size;
krh@19	202	array->alloc = s->size;
krh@0	203	}
krh@0	204	close(fd);
krh@0	205
krh@4	206	return set;
krh@0	207	}
krh@0	208
krh@0	209	void
krh@4	210	razor_set_destroy(struct razor_set *set)
krh@0	211	{
krh@0	212	unsigned int size;
krh@19	213	struct array *a;
krh@0	214	int i;
krh@0	215
krh@4	216	if (set->header) {
krh@4	217	for (i = 0; set->header->sections[i].type; i++)
krh@0	218	;
krh@4	219	size = set->header->sections[i].type;
krh@4	220	munmap(set->header, size);
krh@0	221	} else {
krh@19	222	for (i = 0; i < ARRAY_SIZE(razor_sections); i++) {
krh@19	223	a = (void *) set + razor_sections[i].offset;
krh@19	224	free(a->data);
krh@19	225	}
krh@0	226	}
krh@0	227
krh@4	228	free(set);
krh@0	229	}
krh@0	230
krh@43	231	int
krh@4	232	razor_set_write(struct razor_set set, const char filename)
krh@0	233	{
krh@0	234	char data[4096];
krh@4	235	struct razor_set_header header = (struct razor_set_header ) data;
krh@19	236	struct array *a;
danw@108	237	uint32_t offset;
krh@17	238	int i, fd;
krh@0	239
krh@0	240	memset(data, 0, sizeof data);
krh@4	241	header->magic = RAZOR_MAGIC;
krh@4	242	header->version = RAZOR_VERSION;
krh@17	243	offset = sizeof data;
krh@0	244
krh@19	245	for (i = 0; i < ARRAY_SIZE(razor_sections); i++) {
krh@19	246	if (razor_sections[i].type != i)
krh@19	247	continue;
krh@19	248	a = (void *) set + razor_sections[i].offset;
krh@19	249	header->sections[i].type = i;
krh@17	250	header->sections[i].offset = offset;
krh@19	251	header->sections[i].size = a->size;
krh@91	252	offset += ALIGN(a->size, 4096);
krh@17	253	}
krh@0	254
krh@19	255	header->sections[i].type = ~0;
krh@17	256	header->sections[i].offset = 0;
krh@17	257	header->sections[i].size = 0;
krh@10	258
krh@0	259	fd = open(filename, O_CREAT \| O_WRONLY \| O_TRUNC, 0666);
krh@0	260	if (fd < 0)
krh@0	261	return -1;
krh@0	262
krh@91	263	razor_write(fd, data, sizeof data);
krh@19	264	for (i = 0; i < ARRAY_SIZE(razor_sections); i++) {
krh@19	265	if (razor_sections[i].type != i)
krh@19	266	continue;
krh@19	267	a = (void *) set + razor_sections[i].offset;
krh@91	268	razor_write(fd, a->data, ALIGN(a->size, 4096));
krh@19	269	}
krh@17	270
krh@17	271	close(fd);
krh@0	272
krh@0	273	return 0;
krh@0	274	}
krh@0	275
krh@0	276	static unsigned int
krh@0	277	hash_string(const char *key)
krh@0	278	{
krh@0	279	const char *p;
krh@0	280	unsigned int hash = 0;
krh@0	281
krh@0	282	for (p = key; *p; p++)
krh@9	283	hash = (hash * 617) ^ *p;
krh@0	284
krh@0	285	return hash;
krh@0	286	}
krh@0	287
danw@108	288	static uint32_t
krh@78	289	hashtable_lookup(struct hashtable table, const char key)
krh@0	290	{
krh@6	291	unsigned int mask, start, i;
danw@108	292	uint32_t *b;
krh@6	293	char *pool;
krh@0	294
krh@78	295	pool = table->pool->data;
krh@78	296	mask = table->buckets.alloc - 1;
danw@108	297	start = hash_string(key) * sizeof(uint32_t);
krh@0	298
krh@78	299	for (i = 0; i < table->buckets.alloc; i += sizeof *b) {
krh@78	300	b = table->buckets.data + ((start + i) & mask);
krh@6	301
krh@6	302	if (*b == 0)
krh@0	303	return 0;
krh@0	304
krh@6	305	if (strcmp(key, &pool[*b]) == 0)
krh@6	306	return *b;
krh@6	307	}
krh@0	308
krh@0	309	return 0;
krh@0	310	}
krh@0	311
danw@108	312	static uint32_t
krh@78	313	add_to_string_pool(struct hashtable table, const char key)
krh@0	314	{
krh@6	315	int len;
krh@6	316	char *p;
krh@0	317
krh@0	318	len = strlen(key) + 1;
krh@78	319	p = array_add(table->pool, len);
krh@6	320	memcpy(p, key, len);
krh@0	321
krh@78	322	return p - (char *) table->pool->data;
krh@0	323	}
krh@0	324
danw@108	325	static uint32_t
krh@39	326	add_to_property_pool(struct array pool, struct array properties)
krh@10	327	{
danw@108	328	uint32_t *p;
krh@92	329
krh@92	330	if (properties->size == 0)
krh@92	331	return ~0;
krh@92	332	else if (properties->size == sizeof *p)
danw@108	333	return (uint32_t ) properties->data \| RAZOR_IMMEDIATE;
krh@10	334
krh@39	335	p = array_add(pool, properties->size);
krh@10	336	memcpy(p, properties->data, properties->size);
krh@64	337	p[properties->size / sizeof *p - 1] \|= RAZOR_IMMEDIATE;
krh@10	338
danw@108	339	return p - (uint32_t *) pool->data;
krh@10	340	}
krh@10	341
krh@0	342	static void
danw@108	343	do_insert(struct hashtable *table, uint32_t value)
krh@0	344	{
krh@6	345	unsigned int mask, start, i;
danw@108	346	uint32_t *b;
krh@0	347	const char *key;
krh@0	348
krh@78	349	key = (char *) table->pool->data + value;
krh@78	350	mask = table->buckets.alloc - 1;
danw@108	351	start = hash_string(key) * sizeof(uint32_t);
krh@6	352
krh@78	353	for (i = 0; i < table->buckets.alloc; i += sizeof *b) {
krh@78	354	b = table->buckets.data + ((start + i) & mask);
krh@6	355	if (*b == 0) {
krh@6	356	*b = value;
krh@0	357	break;
krh@0	358	}
krh@6	359	}
krh@0	360	}
krh@0	361
danw@108	362	static uint32_t
krh@78	363	hashtable_insert(struct hashtable table, const char key)
krh@0	364	{
danw@108	365	uint32_t value, buckets, b, *end;
krh@6	366	int alloc;
krh@0	367
krh@78	368	alloc = table->buckets.alloc;
krh@78	369	array_add(&table->buckets, 4 * sizeof *buckets);
krh@78	370	if (alloc != table->buckets.alloc) {
krh@78	371	end = table->buckets.data + alloc;
krh@78	372	memset(end, 0, table->buckets.alloc - alloc);
krh@78	373	for (b = table->buckets.data; b < end; b++) {
krh@6	374	value = *b;
krh@6	375	if (value != 0) {
krh@6	376	*b = 0;
krh@78	377	do_insert(table, value);
krh@6	378	}
krh@0	379	}
krh@0	380	}
krh@0	381
krh@78	382	value = add_to_string_pool(table, key);
krh@78	383	do_insert (table, value);
krh@0	384
krh@0	385	return value;
krh@0	386	}
krh@0	387
krh@78	388	static void
krh@78	389	hashtable_init(struct hashtable table, struct array pool)
krh@78	390	{
krh@78	391	array_init(&table->buckets);
krh@78	392	table->pool = pool;
krh@78	393	}
krh@78	394
krh@78	395	static void
krh@78	396	hashtable_release(struct hashtable *table)
krh@78	397	{
krh@78	398	array_release(&table->buckets);
krh@78	399	}
krh@78	400
danw@108	401	static uint32_t
krh@79	402	hashtable_tokenize(struct hashtable table, const char string)
krh@0	403	{
danw@108	404	uint32_t token;
krh@0	405
krh@13	406	if (string == NULL)
krh@78	407	string = "";
krh@13	408
krh@79	409	token = hashtable_lookup(table, string);
krh@0	410	if (token != 0)
krh@0	411	return token;
krh@0	412
krh@79	413	return hashtable_insert(table, string);
krh@79	414	}
krh@79	415
krh@27	416	void
krh@30	417	razor_importer_begin_package(struct razor_importer *importer,
krh@30	418	const char name, const char version)
krh@13	419	{
krh@25	420	struct razor_package *p;
krh@13	421
krh@30	422	p = array_add(&importer->set->packages, sizeof *p);
krh@95	423	p->name = hashtable_tokenize(&importer->table, name);
krh@95	424	p->version = hashtable_tokenize(&importer->table, version);
krh@13	425
krh@30	426	importer->package = p;
krh@66	427	array_init(&importer->properties);
krh@13	428	}
krh@13	429
krh@13	430	void
krh@30	431	razor_importer_finish_package(struct razor_importer *importer)
krh@13	432	{
krh@25	433	struct razor_package *p;
krh@13	434
krh@30	435	p = importer->package;
krh@66	436	p->properties = add_to_property_pool(&importer->set->property_pool,
krh@66	437	&importer->properties);
krh@13	438
krh@66	439	array_release(&importer->properties);
krh@13	440	}
krh@13	441
krh@66	442	void
krh@30	443	razor_importer_add_property(struct razor_importer *importer,
danw@109	444	const char *name,
danw@109	445	enum razor_version_relation relation,
danw@109	446	const char *version,
krh@66	447	enum razor_property_type type)
krh@13	448	{
krh@25	449	struct razor_property *p;
danw@108	450	uint32_t *r;
krh@13	451
krh@66	452	p = array_add(&importer->set->properties, sizeof *p);
krh@95	453	p->name = hashtable_tokenize(&importer->table, name) \| (type << 30);
danw@109	454	p->relation = relation;
krh@95	455	p->version = hashtable_tokenize(&importer->table, version);
krh@30	456	p->packages = importer->package -
krh@30	457	(struct razor_package *) importer->set->packages.data;
krh@13	458
krh@66	459	r = array_add(&importer->properties, sizeof *r);
krh@66	460	r = p - (struct razor_property ) importer->set->properties.data;
krh@30	461	}
krh@30	462
krh@46	463	void
krh@46	464	razor_importer_add_file(struct razor_importer importer, const char name)
krh@46	465	{
krh@52	466	struct import_entry *e;
krh@48	467
krh@52	468	e = array_add(&importer->files, sizeof *e);
krh@52	469
krh@52	470	e->package = importer->package -
krh@52	471	(struct razor_package *) importer->set->packages.data;
krh@52	472	e->name = strdup(name);
krh@46	473	}
krh@46	474
krh@30	475	struct razor_importer *
krh@30	476	razor_importer_new(void)
krh@30	477	{
krh@30	478	struct razor_importer *importer;
krh@30	479
krh@30	480	importer = zalloc(sizeof *importer);
krh@30	481	importer->set = razor_set_create();
krh@78	482	hashtable_init(&importer->table, &importer->set->string_pool);
krh@30	483
krh@30	484	return importer;
krh@9	485	}
krh@9	486
krh@75	487	/* Destroy an importer without creating the set. */
krh@75	488	void
krh@75	489	razor_importer_destroy(struct razor_importer *importer)
krh@75	490	{
krh@75	491	/* FIXME: write this */
krh@75	492	}
krh@75	493
krh@75	494
krh@22	495	typedef int (compare_with_data_func_t)(const void p1,
krh@22	496	const void *p,
krh@22	497	void *data);
krh@22	498
krh@25	499	struct qsort_context {
krh@25	500	size_t size;
krh@25	501	compare_with_data_func_t compare;
krh@25	502	void *data;
krh@25	503	};
krh@25	504
krh@22	505	static void
krh@22	506	qsort_swap(void p1, void p2, size_t size)
krh@22	507	{
krh@22	508	char buffer[size];
krh@22	509
krh@22	510	memcpy(buffer, p1, size);
krh@22	511	memcpy(p1, p2, size);
krh@22	512	memcpy(p2, buffer, size);
krh@22	513	}
krh@22	514
krh@25	515	static void
danw@108	516	__qsort_with_data(void base, size_t nelem, uint32_t map,
krh@25	517	struct qsort_context *ctx)
krh@22	518	{
krh@22	519	void p, start, end, pivot;
danw@108	520	uint32_t mp, mstart, *mend, tmp;
krh@22	521	int left, right, result;
krh@25	522	size_t size = ctx->size;
krh@22	523
krh@22	524	p = base;
krh@22	525	start = base;
krh@22	526	end = base + nelem * size;
krh@25	527	mp = map;
krh@25	528	mstart = map;
krh@25	529	mend = map + nelem;
krh@22	530	pivot = base + (random() % nelem) * size;
krh@25	531
krh@22	532	while (p < end) {
krh@25	533	result = ctx->compare(p, pivot, ctx->data);
krh@22	534	if (result < 0) {
krh@22	535	qsort_swap(p, start, size);
krh@25	536	tmp = *mp;
krh@25	537	mp = mstart;
krh@25	538	*mstart = tmp;
krh@22	539	if (start == pivot)
krh@22	540	pivot = p;
krh@22	541	start += size;
krh@25	542	mstart++;
krh@22	543	p += size;
krh@29	544	mp++;
krh@22	545	} else if (result == 0) {
krh@22	546	p += size;
krh@25	547	mp++;
krh@22	548	} else {
krh@22	549	end -= size;
krh@25	550	mend--;
krh@22	551	qsort_swap(p, end, size);
krh@25	552	tmp = *mp;
krh@29	553	mp = mend;
krh@29	554	*mend = tmp;
krh@22	555	if (end == pivot)
krh@22	556	pivot = p;
krh@22	557	}
krh@22	558	}
krh@22	559
krh@22	560	left = (start - base) / size;
krh@22	561	right = (base + nelem * size - end) / size;
krh@22	562	if (left > 1)
krh@25	563	__qsort_with_data(base, left, map, ctx);
krh@22	564	if (right > 1)
krh@25	565	__qsort_with_data(end, right, mend, ctx);
krh@25	566	}
krh@25	567
danw@108	568	uint32_t *
krh@25	569	qsort_with_data(void *base, size_t nelem, size_t size,
krh@25	570	compare_with_data_func_t compare, void *data)
krh@25	571	{
krh@25	572	struct qsort_context ctx;
danw@108	573	uint32_t *map;
krh@25	574	int i;
krh@25	575
krh@75	576	if (nelem == 0)
krh@75	577	return NULL;
krh@75	578
krh@25	579	ctx.size = size;
krh@25	580	ctx.compare = compare;
krh@25	581	ctx.data = data;
krh@25	582
danw@108	583	map = malloc(nelem * sizeof (uint32_t));
krh@25	584	for (i = 0; i < nelem; i++)
krh@25	585	map[i] = i;
krh@25	586
krh@25	587	__qsort_with_data(base, nelem, map, &ctx);
krh@25	588
krh@25	589	return map;
krh@22	590	}
krh@9	591
krh@9	592	static int
krh@35	593	versioncmp(const char s1, const char s2)
krh@35	594	{
krh@35	595	const char p1, p2;
krh@35	596	long n1, n2;
krh@35	597	int res;
krh@35	598
krh@35	599	n1 = strtol(s1, (char **) &p1, 0);
krh@35	600	n2 = strtol(s2, (char **) &p2, 0);
krh@35	601
krh@35	602	/* Epoch; if one but not the other has an epoch set, default
krh@35	603	* the epoch-less version to 0. */
krh@35	604	res = (p1 == ':') - (p2 == ':');
krh@35	605	if (res < 0) {
krh@35	606	n1 = 0;
krh@35	607	p1 = s1;
krh@35	608	p2++;
krh@35	609	} else if (res > 0) {
krh@35	610	p1++;
krh@35	611	n2 = 0;
krh@35	612	p2 = s2;
krh@35	613	}
krh@35	614
krh@35	615	if (n1 != n2)
krh@35	616	return n1 - n2;
krh@35	617	while (p1 && p2) {
krh@35	618	if (p1 != p2)
krh@35	619	return p1 - p2;
krh@35	620	p1++;
krh@35	621	p2++;
krh@35	622	if (isdigit(p1) && isdigit(p2))
krh@35	623	return versioncmp(p1, p2);
krh@35	624	}
krh@35	625
krh@35	626	return p1 - p2;
krh@35	627	}
krh@35	628
krh@35	629	static int
krh@22	630	compare_packages(const void p1, const void p2, void *data)
krh@9	631	{
krh@25	632	const struct razor_package pkg1 = p1, pkg2 = p2;
krh@22	633	struct razor_set *set = data;
krh@22	634	char *pool = set->string_pool.data;
krh@9	635
krh@23	636	if (pkg1->name == pkg2->name)
krh@35	637	return versioncmp(&pool[pkg1->version], &pool[pkg2->version]);
krh@23	638	else
krh@23	639	return strcmp(&pool[pkg1->name], &pool[pkg2->name]);
krh@9	640	}
krh@9	641
krh@9	642	static int
krh@22	643	compare_properties(const void p1, const void p2, void *data)
krh@9	644	{
krh@25	645	const struct razor_property prop1 = p1, prop2 = p2;
krh@22	646	struct razor_set *set = data;
krh@22	647	char *pool = set->string_pool.data;
krh@9	648
danw@109	649	if (prop1->name == prop2->name) {
danw@109	650	if (prop1->relation == prop2->relation)
danw@109	651	return versioncmp(&pool[prop1->version],
danw@109	652	&pool[prop2->version]);
danw@109	653	else
danw@109	654	return prop1->relation - prop2->relation;
danw@109	655	} else if ((prop1->name & RAZOR_ENTRY_MASK) == (prop2->name & RAZOR_ENTRY_MASK))
krh@66	656	return (prop1->name >> 30) - (prop2->name >> 30);
krh@12	657	else
krh@66	658	return strcmp(&pool[prop1->name & RAZOR_ENTRY_MASK],
krh@66	659	&pool[prop2->name & RAZOR_ENTRY_MASK]);
krh@9	660	}
krh@9	661
danw@108	662	static uint32_t *
krh@66	663	uniqueify_properties(struct razor_set *set)
krh@9	664	{
krh@25	665	struct razor_property rp, up, *rp_end;
krh@18	666	struct array pkgs, p;
danw@108	667	uint32_t map, rmap, *r;
krh@18	668	int i, count, unique;
krh@9	669
krh@66	670	count = set->properties.size / sizeof(struct razor_property);
krh@66	671	map = qsort_with_data(set->properties.data,
krh@25	672	count,
krh@25	673	sizeof(struct razor_property),
krh@25	674	compare_properties,
krh@25	675	set);
krh@9	676
krh@66	677	rp_end = set->properties.data + set->properties.size;
krh@25	678	rmap = malloc(count * sizeof *map);
krh@25	679	pkgs = zalloc(count * sizeof *pkgs);
krh@66	680	for (rp = set->properties.data, up = rp, i = 0; rp < rp_end; rp++, i++) {
danw@109	681	if (rp->name != up->name \|\| rp->relation != up->relation \|\|
danw@109	682	rp->version != up->version) {
krh@25	683	up++;
krh@25	684	up->name = rp->name;
danw@109	685	up->relation = rp->relation;
krh@25	686	up->version = rp->version;
krh@10	687	}
krh@25	688
krh@66	689	unique = up - (struct razor_property *) set->properties.data;
krh@25	690	rmap[map[i]] = unique;
krh@25	691	r = array_add(&pkgs[unique], sizeof *r);
krh@25	692	*r = rp->packages;
krh@10	693	}
krh@25	694	free(map);
krh@9	695
krh@25	696	up++;
krh@66	697	set->properties.size = (void *) up - set->properties.data;
krh@25	698	rp_end = up;
krh@66	699	for (rp = set->properties.data, p = pkgs; rp < rp_end; rp++, p++) {
krh@61	700	if (p->size / sizeof *r == 1) {
krh@61	701	r = p->data;
krh@61	702	rp->packages = *r \| RAZOR_IMMEDIATE;
krh@61	703	} else {
krh@61	704	rp->packages =
krh@61	705	add_to_property_pool(&set->package_pool, p);
krh@61	706	}
krh@25	707	array_release(p);
krh@18	708	}
krh@18	709
krh@18	710	free(pkgs);
krh@18	711
krh@25	712	return rmap;
krh@10	713	}
krh@10	714
krh@10	715	static void
danw@108	716	remap_links(struct array links, uint32_t map)
krh@10	717	{
danw@108	718	uint32_t p, end;
krh@10	719
krh@39	720	end = links->data + links->size;
krh@39	721	for (p = links->data; p < end; p++)
krh@64	722	p = map[p & RAZOR_ENTRY_MASK] \| (*p & ~RAZOR_ENTRY_MASK);
krh@9	723	}
krh@9	724
krh@48	725	static int
krh@48	726	compare_filenames(const void p1, const void p2, void *data)
krh@48	727	{
krh@52	728	const struct import_entry *e1 = p1;
krh@52	729	const struct import_entry *e2 = p2;
krh@48	730
krh@52	731	return strcmp(e1->name, e2->name);
krh@48	732	}
krh@48	733
krh@48	734	static void
krh@52	735	count_entries(struct import_directory *d)
krh@48	736	{
krh@52	737	struct import_directory p, end;
krh@48	738
krh@48	739	p = d->files.data;
krh@48	740	end = d->files.data + d->files.size;
krh@48	741	d->count = 0;
krh@48	742	while (p < end) {
krh@48	743	count_entries(p);
krh@48	744	d->count += p->count + 1;
krh@48	745	p++;
krh@48	746	}
krh@48	747	}
krh@48	748
krh@48	749	static void
krh@52	750	serialize_files(struct razor_set *set,
krh@52	751	struct import_directory d, struct array array)
krh@48	752	{
krh@52	753	struct import_directory p, end;
krh@56	754	struct razor_entry *e = NULL;
danw@108	755	uint32_t s, *r;
krh@48	756
krh@48	757	p = d->files.data;
krh@48	758	end = d->files.data + d->files.size;
krh@48	759	s = array->size / sizeof e + d->files.size / sizeof p;
krh@48	760	while (p < end) {
krh@48	761	e = array_add(array, sizeof *e);
krh@48	762	e->name = p->name;
krh@56	763	e->start = p->count > 0 ? s : 0;
krh@48	764	s += p->count;
krh@60	765
krh@64	766	if (p->packages.size == 0) {
krh@92	767	e->packages = ~0;
krh@64	768	} else if (p->packages.size / sizeof *r == 1) {
krh@60	769	r = p->packages.data;
krh@60	770	e->packages = *r \| RAZOR_IMMEDIATE;
krh@60	771	} else {
krh@60	772	e->packages = add_to_property_pool(&set->package_pool,
krh@60	773	&p->packages);
krh@60	774	}
krh@52	775	array_release(&p->packages);
krh@48	776	p++;
krh@48	777	}
krh@56	778	if (e != NULL)
krh@56	779	e->name \|= RAZOR_ENTRY_LAST;
krh@48	780
krh@48	781	p = d->files.data;
krh@48	782	end = d->files.data + d->files.size;
krh@48	783	while (p < end) {
krh@52	784	serialize_files(set, p, array);
krh@48	785	p++;
krh@48	786	}
krh@48	787	}
krh@48	788
krh@48	789	static void
danw@108	790	remap_property_package_links(struct array properties, uint32_t rmap)
krh@61	791	{
krh@61	792	struct razor_property p, end;
krh@61	793
krh@61	794	end = properties->data + properties->size;
krh@61	795	for (p = properties->data; p < end; p++)
krh@61	796	if (p->packages & RAZOR_IMMEDIATE)
krh@61	797	p->packages = rmap[p->packages & RAZOR_ENTRY_MASK] \|
krh@61	798	RAZOR_IMMEDIATE;
krh@61	799	}
krh@61	800
krh@61	801	static void
krh@48	802	build_file_tree(struct razor_importer *importer)
krh@48	803	{
krh@48	804	int count, i, length;
krh@52	805	struct import_entry *filenames;
krh@52	806	char f, end;
danw@108	807	uint32_t name, *r;
krh@48	808	char dirname[256];
krh@52	809	struct import_directory *d, root;
krh@48	810	struct razor_entry *e;
krh@48	811
krh@52	812	count = importer->files.size / sizeof (struct import_entry);
krh@48	813	qsort_with_data(importer->files.data,
krh@48	814	count,
krh@52	815	sizeof (struct import_entry),
krh@48	816	compare_filenames,
krh@48	817	NULL);
krh@48	818
krh@95	819	root.name = hashtable_tokenize(&importer->table, "");
krh@48	820	array_init(&root.files);
krh@52	821	array_init(&root.packages);
krh@48	822	root.last = NULL;
krh@48	823
krh@48	824	filenames = importer->files.data;
krh@48	825	for (i = 0; i < count; i++) {
krh@52	826	f = filenames[i].name;
krh@48	827	if (*f != '/')
krh@48	828	continue;
krh@57	829	f++;
krh@48	830
krh@48	831	d = &root;
krh@48	832	while (*f) {
krh@57	833	end = strchr(f, '/');
krh@48	834	if (end == NULL)
krh@48	835	end = f + strlen(f);
krh@57	836	length = end - f;
krh@57	837	memcpy(dirname, f, length);
krh@48	838	dirname[length] ='\0';
krh@95	839	name = hashtable_tokenize(&importer->table, dirname);
krh@48	840	if (d->last == NULL \|\| d->last->name != name) {
krh@48	841	d->last = array_add(&d->files, sizeof *d);
krh@48	842	d->last->name = name;
krh@48	843	d->last->last = NULL;
krh@48	844	array_init(&d->last->files);
krh@52	845	array_init(&d->last->packages);
krh@48	846	}
krh@48	847	d = d->last;
krh@57	848	f = end + 1;
krh@57	849	if (*end == '\0')
krh@57	850	break;
krh@48	851	}
krh@48	852
krh@52	853	r = array_add(&d->packages, sizeof *r);
krh@52	854	*r = filenames[i].package;
krh@52	855	free(filenames[i].name);
krh@48	856	}
krh@48	857
krh@48	858	count_entries(&root);
krh@56	859	array_init(&importer->set->files);
krh@48	860
krh@56	861	e = array_add(&importer->set->files, sizeof *e);
krh@56	862	e->name = root.name \| RAZOR_ENTRY_LAST;
krh@48	863	e->start = 1;
krh@92	864	e->packages = ~0;
krh@48	865
krh@56	866	serialize_files(importer->set, &root, &importer->set->files);
krh@48	867
krh@48	868	array_release(&importer->files);
krh@48	869	}
krh@48	870
krh@56	871	static void
danw@108	872	build_package_file_lists(struct razor_set set, uint32_t rmap)
krh@54	873	{
krh@56	874	struct razor_package p, packages;
krh@56	875	struct array *pkgs;
krh@54	876	struct razor_entry e, end;
danw@108	877	uint32_t r, q;
krh@56	878	int i, count;
krh@54	879
krh@56	880	count = set->packages.size / sizeof *p;
krh@56	881	pkgs = zalloc(count * sizeof *pkgs);
krh@54	882
krh@56	883	end = set->files.data + set->files.size;
krh@92	884	for (e = set->files.data; e < end; e++) {
krh@92	885	if (e->packages == ~0) {
krh@92	886	continue;
krh@92	887	} else if (e->packages & RAZOR_IMMEDIATE) {
krh@60	888	e->packages = rmap[e->packages & RAZOR_ENTRY_MASK] \|
krh@60	889	RAZOR_IMMEDIATE;
krh@60	890	r = &e->packages;
krh@60	891	} else {
danw@108	892	r = (uint32_t *) set->package_pool.data + e->packages;
krh@60	893	}
krh@60	894
krh@64	895	while (1) {
krh@60	896	q = array_add(&pkgs[r & RAZOR_ENTRY_MASK], sizeof q);
krh@56	897	q = e - (struct razor_entry ) set->files.data;
krh@60	898	if (*r++ & RAZOR_IMMEDIATE)
krh@60	899	break;
krh@54	900	}
krh@54	901	}
krh@54	902
krh@56	903	packages = set->packages.data;
krh@56	904	for (i = 0; i < count; i++) {
krh@56	905	packages[i].files =
krh@56	906	add_to_property_pool(&set->file_pool, &pkgs[i]);
krh@56	907	array_release(&pkgs[i]);
krh@48	908	}
krh@56	909	free(pkgs);
krh@52	910	}
krh@52	911
krh@27	912	struct razor_set *
krh@30	913	razor_importer_finish(struct razor_importer *importer)
krh@9	914	{
krh@30	915	struct razor_set *set;
danw@108	916	uint32_t map, rmap;
krh@39	917	int i, count;
krh@18	918
krh@66	919	map = uniqueify_properties(importer->set);
krh@66	920	remap_links(&importer->set->property_pool, map);
krh@39	921	free(map);
krh@25	922
krh@30	923	count = importer->set->packages.size / sizeof(struct razor_package);
krh@30	924	map = qsort_with_data(importer->set->packages.data,
krh@25	925	count,
krh@25	926	sizeof(struct razor_package),
krh@25	927	compare_packages,
krh@30	928	importer->set);
krh@39	929
krh@39	930	rmap = malloc(count * sizeof *rmap);
krh@39	931	for (i = 0; i < count; i++)
krh@39	932	rmap[map[i]] = i;
krh@25	933	free(map);
krh@13	934
krh@48	935	build_file_tree(importer);
krh@52	936	remap_links(&importer->set->package_pool, rmap);
krh@60	937	build_package_file_lists(importer->set, rmap);
krh@66	938	remap_property_package_links(&importer->set->properties, rmap);
krh@52	939	free(rmap);
krh@48	940
krh@30	941	set = importer->set;
krh@78	942	hashtable_release(&importer->table);
krh@30	943	free(importer);
krh@30	944
krh@30	945	return set;
krh@9	946	}
krh@9	947
krh@92	948	struct razor_package_iterator {
krh@92	949	struct razor_set *set;
krh@92	950	struct razor_package package, end;
danw@108	951	uint32_t *index;
krh@101	952	int last;
krh@92	953	};
krh@92	954
krh@92	955	struct razor_package_iterator *
krh@101	956	razor_package_iterator_create_with_index(struct razor_set *set,
danw@108	957	uint32_t *index)
krh@3	958	{
krh@92	959	struct razor_package_iterator *pi;
krh@92	960
krh@92	961	pi = zalloc(sizeof *pi);
krh@92	962	pi->set = set;
krh@101	963	pi->end = set->packages.data + set->packages.size;
krh@92	964	pi->package = set->packages.data;
krh@101	965	pi->index = index;
krh@92	966
krh@92	967	return pi;
krh@92	968	}
krh@92	969
krh@101	970	struct razor_package_iterator *
krh@101	971	razor_package_iterator_create(struct razor_set *set)
krh@101	972	{
krh@101	973	return razor_package_iterator_create_with_index(set, NULL);
krh@101	974	}
krh@101	975
krh@101	976	struct razor_package_iterator *
krh@101	977	razor_package_iterator_create_for_property(struct razor_set *set,
krh@101	978	struct razor_property *property)
krh@101	979	{
danw@108	980	uint32_t *index;
krh@101	981
krh@101	982	if (property->packages & RAZOR_IMMEDIATE)
krh@101	983	index = &property->packages;
krh@101	984	else
danw@108	985	index = (uint32_t *)
krh@101	986	set->package_pool.data + property->packages;
krh@101	987
krh@101	988	return razor_package_iterator_create_with_index(set, index);
krh@101	989	}
krh@101	990
krh@92	991	int
krh@92	992	razor_package_iterator_next(struct razor_package_iterator *pi,
krh@92	993	struct razor_package **package,
krh@92	994	const char name, const char version)
krh@92	995	{
krh@6	996	char *pool;
krh@101	997	int valid;
krh@101	998	struct razor_package p, packages;
krh@3	999
krh@101	1000	if (pi->index) {
krh@101	1001	packages = pi->set->packages.data;
krh@101	1002	p = &packages[*pi->index & RAZOR_ENTRY_MASK];
krh@101	1003	valid = !pi->last;
krh@101	1004	pi->last = (*pi->index++ & RAZOR_IMMEDIATE) != 0;
krh@101	1005	} else {
krh@101	1006	p = pi->package++;
krh@101	1007	valid = p < pi->end;
krh@101	1008	}
krh@92	1009
krh@101	1010	if (valid) {
krh@101	1011	pool = pi->set->string_pool.data;
krh@101	1012	*package = p;
krh@101	1013	*name = &pool[p->name & RAZOR_ENTRY_MASK];
krh@101	1014	*version = &pool[p->version];
krh@101	1015	} else {
krh@101	1016	*package = NULL;
krh@101	1017	}
krh@101	1018
krh@101	1019	return valid;
krh@92	1020	}
krh@92	1021
krh@92	1022	void
krh@92	1023	razor_package_iterator_destroy(struct razor_package_iterator *pi)
krh@92	1024	{
krh@92	1025	free(pi);
krh@3	1026	}
krh@3	1027
krh@10	1028	struct razor_package *
krh@10	1029	razor_set_get_package(struct razor_set set, const char package)
krh@10	1030	{
krh@97	1031	struct razor_package_iterator *pi;
krh@97	1032	struct razor_package *p;
krh@97	1033	const char name, version;
krh@97	1034
krh@97	1035	pi = razor_package_iterator_create(set);
krh@97	1036	while (razor_package_iterator_next(pi, &p, &name, &version)) {
krh@97	1037	if (strcmp(package, name) == 0)
krh@97	1038	break;
krh@97	1039	}
krh@97	1040	razor_package_iterator_destroy(pi);
krh@97	1041
krh@97	1042	return p;
krh@10	1043	}
krh@10	1044
krh@92	1045	struct razor_property_iterator {
krh@92	1046	struct razor_set *set;
krh@92	1047	struct razor_property property, end;
danw@108	1048	uint32_t *index;
krh@92	1049	int last;
krh@92	1050	};
krh@92	1051
krh@92	1052	struct razor_property_iterator *
krh@92	1053	razor_property_iterator_create(struct razor_set *set,
krh@92	1054	struct razor_package *package)
krh@92	1055	{
krh@92	1056	struct razor_property_iterator *pi;
krh@92	1057
krh@92	1058	pi = zalloc(sizeof *pi);
krh@92	1059	pi->set = set;
krh@92	1060	pi->end = set->properties.data + set->properties.size;
krh@101	1061	pi->property = set->properties.data;
krh@98	1062
krh@98	1063	if (package)
danw@108	1064	pi->index = (uint32_t *)
krh@92	1065	set->property_pool.data + package->properties;
krh@92	1066
krh@92	1067	return pi;
krh@92	1068	}
krh@92	1069
krh@92	1070	int
krh@92	1071	razor_property_iterator_next(struct razor_property_iterator *pi,
krh@92	1072	struct razor_property **property,
danw@109	1073	const char **name,
danw@109	1074	enum razor_version_relation *relation,
danw@109	1075	const char **version,
krh@92	1076	enum razor_property_type *type)
krh@92	1077	{
krh@92	1078	char *pool;
krh@92	1079	int valid;
krh@92	1080	struct razor_property p, properties;
krh@92	1081
krh@92	1082	if (pi->index) {
krh@92	1083	properties = pi->set->properties.data;
krh@92	1084	p = &properties[*pi->index & RAZOR_ENTRY_MASK];
krh@92	1085	valid = !pi->last;
krh@92	1086	pi->last = (*pi->index++ & RAZOR_IMMEDIATE) != 0;
krh@92	1087	} else {
krh@92	1088	p = pi->property++;
krh@92	1089	valid = p < pi->end;
krh@92	1090	}
krh@92	1091
krh@96	1092	if (valid) {
krh@96	1093	pool = pi->set->string_pool.data;
krh@96	1094	*property = p;
krh@96	1095	*name = &pool[p->name & RAZOR_ENTRY_MASK];
danw@109	1096	*relation = p->relation;
krh@96	1097	*version = &pool[p->version];
krh@96	1098	*type = p->name >> 30;
krh@96	1099	} else {
krh@96	1100	*property = NULL;
krh@96	1101	}
krh@92	1102
krh@92	1103	return valid;
krh@92	1104	}
krh@92	1105
krh@66	1106	void
krh@92	1107	razor_property_iterator_destroy(struct razor_property_iterator *pi)
krh@8	1108	{
krh@92	1109	free(pi);
krh@10	1110	}
krh@10	1111
krh@56	1112	static struct razor_entry *
krh@56	1113	find_entry(struct razor_set set, struct razor_entry dir, const char *pattern)
krh@56	1114	{
krh@56	1115	struct razor_entry *e;
krh@56	1116	const char n, pool = set->string_pool.data;
krh@56	1117	int len;
krh@56	1118
krh@56	1119	e = (struct razor_entry *) set->files.data + dir->start;
krh@56	1120	do {
krh@56	1121	n = pool + (e->name & RAZOR_ENTRY_MASK);
krh@56	1122	if (strcmp(pattern + 1, n) == 0)
krh@56	1123	return e;
krh@57	1124	len = strlen(n);
krh@56	1125	if (e->start != 0 && strncmp(pattern + 1, n, len) == 0 &&
krh@56	1126	pattern[len + 1] == '/') {
krh@56	1127	return find_entry(set, e, pattern + len + 1);
krh@56	1128	}
krh@56	1129	} while (((e++)->name & RAZOR_ENTRY_LAST) == 0);
krh@56	1130
krh@56	1131	return NULL;
krh@56	1132	}
krh@56	1133
krh@56	1134	static void
krh@56	1135	list_dir(struct razor_set set, struct razor_entry dir,
krh@56	1136	const char prefix, const char pattern)
krh@56	1137	{
krh@56	1138	struct razor_entry *e;
krh@56	1139	const char n, pool = set->string_pool.data;
krh@56	1140
krh@56	1141	e = (struct razor_entry *) set->files.data + dir->start;
krh@56	1142	do {
krh@56	1143	n = pool + (e->name & RAZOR_ENTRY_MASK);
krh@56	1144	if (pattern && pattern[0] && fnmatch(pattern, n, 0) != 0)
krh@56	1145	continue;
krh@56	1146	printf("%s/%s%s\n", prefix, n, e->start > 0 ? "/" : "");
krh@56	1147	} while (((e++)->name & RAZOR_ENTRY_LAST) == 0);
krh@56	1148	}
krh@56	1149
krh@56	1150	void
krh@56	1151	razor_set_list_files(struct razor_set set, const char pattern)
krh@56	1152	{
krh@56	1153	struct razor_entry *e;
krh@56	1154	char buffer[512], p, base;
krh@56	1155
krh@56	1156	if (pattern == NULL)
krh@56	1157	pattern = "/";
krh@56	1158
krh@56	1159	strcpy(buffer, pattern);
krh@56	1160	e = find_entry(set, set->files.data, buffer);
krh@56	1161	if (e && e->start > 0) {
krh@56	1162	base = NULL;
krh@56	1163	} else {
krh@56	1164	p = strrchr(buffer, '/');
krh@56	1165	if (p) {
krh@56	1166	*p = '\0';
krh@56	1167	base = p + 1;
krh@56	1168	} else {
krh@56	1169	base = NULL;
krh@56	1170	}
krh@56	1171	}
krh@56	1172	e = find_entry(set, set->files.data, buffer);
krh@56	1173	if (e->start != 0)
krh@56	1174	list_dir(set, e, buffer, base);
krh@56	1175	}
krh@56	1176
krh@102	1177	struct razor_package_iterator *
krh@102	1178	razor_package_iterator_create_for_file(struct razor_set *set,
krh@102	1179	const char *filename)
krh@56	1180	{
krh@102	1181	struct razor_entry *entry;
danw@108	1182	uint32_t *index;
krh@56	1183
krh@102	1184	entry = find_entry(set, set->files.data, filename);
krh@102	1185	if (entry == NULL)
krh@102	1186	return NULL;
krh@56	1187
krh@102	1188	if (entry->packages & RAZOR_IMMEDIATE)
krh@102	1189	index = &entry->packages;
krh@60	1190	else
danw@108	1191	index = (uint32_t *)
krh@102	1192	set->package_pool.data + entry->packages;
krh@60	1193
krh@102	1194	return razor_package_iterator_create_with_index(set, index);
krh@56	1195	}
krh@56	1196
danw@108	1197	static uint32_t *
danw@108	1198	list_package_files(struct razor_set set, uint32_t r,
danw@108	1199	struct razor_entry *dir, uint32_t end,
krh@56	1200	char *prefix)
krh@56	1201	{
krh@56	1202	struct razor_entry e, f, *entries;
danw@108	1203	uint32_t next, file;
krh@56	1204	char *pool;
krh@56	1205	int len;
krh@56	1206
krh@56	1207	entries = (struct razor_entry *) set->files.data;
krh@56	1208	pool = set->string_pool.data;
krh@56	1209
krh@56	1210	e = entries + dir->start;
krh@56	1211	do {
krh@83	1212	if (entries + (*r & RAZOR_ENTRY_MASK) == e) {
krh@56	1213	printf("%s/%s\n", prefix,
krh@56	1214	pool + (e->name & RAZOR_ENTRY_MASK));
krh@83	1215	if (*r & RAZOR_ENTRY_LAST)
krh@83	1216	return NULL;
krh@56	1217	r++;
krh@83	1218	if ((*r & RAZOR_ENTRY_MASK) >= end)
krh@83	1219	return r;
krh@56	1220	}
krh@83	1221	} while (!((e++)->name & RAZOR_ENTRY_LAST));
krh@56	1222
krh@56	1223	e = entries + dir->start;
krh@56	1224	do {
krh@56	1225	if (e->start == 0)
krh@56	1226	continue;
krh@56	1227
krh@56	1228	if (e->name & RAZOR_ENTRY_LAST)
krh@56	1229	next = end;
krh@56	1230	else {
krh@56	1231	f = e + 1;
krh@56	1232	while (f->start == 0 && !(f->name & RAZOR_ENTRY_LAST))
krh@56	1233	f++;
krh@56	1234	if (f->start == 0)
krh@56	1235	next = end;
krh@56	1236	else
krh@56	1237	next = f->start;
krh@56	1238	}
krh@56	1239
krh@83	1240	file = *r & RAZOR_ENTRY_MASK;
krh@83	1241	if (e->start <= file && file < next) {
krh@56	1242	len = strlen(prefix);
krh@56	1243	prefix[len] = '/';
krh@56	1244	strcpy(prefix + len + 1,
krh@56	1245	pool + (e->name & RAZOR_ENTRY_MASK));
krh@56	1246	r = list_package_files(set, r, e, next, prefix);
krh@56	1247	prefix[len] = '\0';
krh@56	1248	}
krh@83	1249	} while (!((e++)->name & RAZOR_ENTRY_LAST) && r != NULL);
krh@56	1250
krh@56	1251	return r;
krh@56	1252	}
krh@56	1253
krh@56	1254	void
krh@56	1255	razor_set_list_package_files(struct razor_set set, const char name)
krh@56	1256	{
krh@56	1257	struct razor_package *package;
danw@108	1258	uint32_t *r, end;
krh@56	1259	char buffer[512];
krh@56	1260
krh@56	1261	package = razor_set_get_package(set, name);
krh@56	1262
danw@108	1263	r = (uint32_t *) set->file_pool.data + package->files;
krh@56	1264	end = set->files.size / sizeof (struct razor_entry);
krh@56	1265	buffer[0] = '\0';
krh@56	1266	list_package_files(set, r, set->files.data, end, buffer);
krh@56	1267	}
krh@56	1268
krh@43	1269	static void
krh@21	1270	razor_set_validate(struct razor_set set, struct array unsatisfied)
krh@21	1271	{
krh@66	1272	struct razor_property r, p, *end;
danw@108	1273	uint32_t *u;
krh@21	1274	char *pool;
krh@21	1275
krh@66	1276	end = set->properties.data + set->properties.size;
krh@21	1277	pool = set->string_pool.data;
krh@21	1278
krh@66	1279	for (r = set->properties.data, p = r; r < end; r++) {
krh@66	1280	if (r->name >> 30 != RAZOR_PROPERTY_REQUIRES)
krh@66	1281	continue;
krh@66	1282
krh@66	1283	if ((r->name & RAZOR_ENTRY_MASK) != (p->name & RAZOR_ENTRY_MASK)) {
krh@66	1284	p = r;
krh@66	1285	while (p < end && p->name == r->name)
krh@66	1286	p++;
krh@66	1287	}
krh@37	1288
krh@35	1289	/* If there is more than one version of a provides,
krh@35	1290	* seek to the end for the highest version. */
krh@66	1291	/* FIXME: This doesn't work if we have a series of
krh@66	1292	* requires a = 1, provides a = 1, requires a = 2,
krh@66	1293	* provides a = 2, as the kernel and kernel-devel
krh@66	1294	* does.*/
krh@66	1295	while (p + 1 < end && p->name == (p + 1)->name)
krh@35	1296	p++;
krh@37	1297
krh@37	1298	/* FIXME: We need to track property flags (<, <=, =
krh@37	1299	* etc) to properly determine if a requires is
krh@37	1300	* satisfied. The current code doesn't track that the
krh@37	1301	* requires a = 1 isn't satisfied by a = 2 provides. */
krh@37	1302
krh@66	1303	if (p == end \|\|
krh@66	1304	(p->name >> 30) != RAZOR_PROPERTY_PROVIDES \|\|
krh@66	1305	(r->name & RAZOR_ENTRY_MASK) != (p->name & RAZOR_ENTRY_MASK) \|\|
krh@35	1306	versioncmp(&pool[r->version], &pool[p->version]) > 0) {
krh@35	1307	/* FIXME: We ignore file requires for now. */
krh@66	1308	if (pool[r->name & RAZOR_ENTRY_MASK] == '/')
krh@35	1309	continue;
krh@21	1310	u = array_add(unsatisfied, sizeof *u);
krh@66	1311	u = r - (struct razor_property ) set->properties.data;
krh@21	1312	}
krh@21	1313	}
krh@21	1314	}
krh@21	1315
krh@21	1316	void
krh@21	1317	razor_set_list_unsatisfied(struct razor_set *set)
krh@21	1318	{
krh@21	1319	struct array unsatisfied;
krh@66	1320	struct razor_property properties, r;
danw@108	1321	uint32_t u, end;
krh@21	1322	char *pool;
krh@21	1323
krh@21	1324	array_init(&unsatisfied);
krh@21	1325	razor_set_validate(set, &unsatisfied);
krh@21	1326
krh@21	1327	end = unsatisfied.data + unsatisfied.size;
krh@66	1328	properties = set->properties.data;
krh@21	1329	pool = set->string_pool.data;
krh@21	1330
krh@21	1331	for (u = unsatisfied.data; u < end; u++) {
krh@66	1332	r = properties + *u;
krh@66	1333	if (pool[r->version] == '\0')
krh@66	1334	printf("%ss not satisfied\n",
krh@66	1335	&pool[r->name & RAZOR_ENTRY_MASK]);
krh@66	1336	else
krh@66	1337	printf("%s-%s not satisfied\n",
krh@66	1338	&pool[r->name & RAZOR_ENTRY_MASK],
krh@66	1339	&pool[r->version]);
krh@21	1340	}
krh@21	1341
krh@21	1342	array_release(&unsatisfied);
krh@21	1343	}
krh@21	1344
krh@41	1345	#define UPSTREAM_SOURCE 0x80000000ul
krh@41	1346	#define INDEX_MASK 0x00fffffful
krh@41	1347
krh@41	1348	struct source {
krh@41	1349	struct razor_set *set;
danw@108	1350	uint32_t *property_map;
krh@41	1351	};
krh@41	1352
krh@79	1353	struct razor_merger {
krh@79	1354	struct razor_set *set;
krh@79	1355	struct hashtable table;
krh@79	1356	struct source source1;
krh@79	1357	struct source source2;
krh@79	1358	};
krh@79	1359
krh@79	1360	static struct razor_merger *
krh@79	1361	razor_merger_create(struct razor_set set1, struct razor_set set2)
krh@41	1362	{
krh@79	1363	struct razor_merger *merger;
krh@41	1364	int count;
krh@41	1365	size_t size;
krh@41	1366
krh@79	1367	merger = zalloc(sizeof *merger);
krh@79	1368	merger->set = razor_set_create();
krh@79	1369	hashtable_init(&merger->table, &merger->set->string_pool);
krh@41	1370
krh@79	1371	count = set1->properties.size / sizeof (struct razor_property);
krh@79	1372	size = count * sizeof merger->source1.property_map[0];
krh@79	1373	merger->source1.property_map = zalloc(size);
krh@79	1374	merger->source1.set = set1;
krh@79	1375
krh@79	1376	count = set2->properties.size / sizeof (struct razor_property);
krh@79	1377	size = count * sizeof merger->source2.property_map[0];
krh@79	1378	merger->source2.property_map = zalloc(size);
krh@79	1379	merger->source2.set = set2;
krh@79	1380
krh@79	1381	return merger;
krh@41	1382	}
krh@41	1383
krh@33	1384	static void
krh@79	1385	add_package(struct razor_merger *merger,
krh@41	1386	struct razor_package package, struct source source,
danw@108	1387	uint32_t flags)
krh@33	1388	{
krh@33	1389	char *pool;
danw@108	1390	uint32_t *r;
krh@41	1391	struct razor_package *p;
krh@33	1392
krh@41	1393	pool = source->set->string_pool.data;
krh@79	1394	p = array_add(&merger->set->packages, sizeof *p);
krh@79	1395	p->name = hashtable_tokenize(&merger->table, &pool[package->name]);
krh@41	1396	p->name \|= flags;
krh@79	1397	p->version = hashtable_tokenize(&merger->table,
krh@79	1398	&pool[package->version]);
krh@66	1399	p->properties = package->properties;
krh@33	1400
krh@66	1401	if (package->properties & RAZOR_IMMEDIATE)
krh@66	1402	r = &package->properties;
krh@64	1403	else
danw@108	1404	r = (uint32_t *)
krh@66	1405	source->set->property_pool.data + package->properties;
krh@64	1406	while (1) {
krh@66	1407	source->property_map[*r & RAZOR_ENTRY_MASK] = 1;
krh@64	1408	if (*r++ & RAZOR_IMMEDIATE)
krh@64	1409	break;
krh@64	1410	}
krh@41	1411	}
krh@41	1412
krh@41	1413
krh@41	1414	/* Build the new package list sorted by merging the two package lists.
krh@79	1415	* Build new string pool as we go. */
krh@41	1416	static void
krh@79	1417	merge_packages(struct razor_merger merger, struct array packages)
krh@41	1418	{
krh@41	1419	struct razor_package upstream_packages, p, s, send;
krh@79	1420	struct source source1, source2;
krh@41	1421	char spool, upool;
danw@108	1422	uint32_t u, uend;
krh@41	1423	int cmp;
krh@41	1424
krh@79	1425	source1 = &merger->source1;
krh@79	1426	source2 = &merger->source2;
krh@41	1427	upstream_packages = source2->set->packages.data;
krh@41	1428
krh@41	1429	u = packages->data;
krh@41	1430	uend = packages->data + packages->size;
krh@41	1431	upool = source2->set->string_pool.data;
krh@41	1432
krh@41	1433	s = source1->set->packages.data;
krh@41	1434	send = source1->set->packages.data + source1->set->packages.size;
krh@41	1435	spool = source1->set->string_pool.data;
krh@41	1436
krh@41	1437	while (s < send) {
krh@41	1438	p = upstream_packages + *u;
krh@41	1439
krh@41	1440	if (u < uend)
krh@41	1441	cmp = strcmp(&spool[s->name], &upool[p->name]);
krh@41	1442	if (u >= uend \|\| cmp < 0) {
krh@79	1443	add_package(merger, s, source1, 0);
krh@41	1444	s++;
krh@41	1445	} else if (cmp == 0) {
krh@79	1446	add_package(merger, p, source2, UPSTREAM_SOURCE);
krh@41	1447	s++;
krh@41	1448	u++;
krh@41	1449	} else {
krh@79	1450	add_package(merger, p, source2, UPSTREAM_SOURCE);
krh@41	1451	u++;
krh@41	1452	}
krh@41	1453	}
krh@41	1454	}
krh@41	1455
danw@108	1456	static uint32_t
krh@79	1457	add_property(struct razor_merger *merger,
danw@109	1458	const char *name, enum razor_version_relation relation,
danw@109	1459	const char *version, int type)
krh@41	1460	{
krh@41	1461	struct razor_property *p;
krh@41	1462
krh@79	1463	p = array_add(&merger->set->properties, sizeof *p);
krh@79	1464	p->name = hashtable_tokenize(&merger->table, name) \| (type << 30);
danw@109	1465	p->relation = relation;
krh@79	1466	p->version = hashtable_tokenize(&merger->table, version);
krh@41	1467
krh@79	1468	return p - (struct razor_property *) merger->set->properties.data;
krh@41	1469	}
krh@41	1470
krh@41	1471	static void
krh@79	1472	merge_properties(struct razor_merger *merger)
krh@41	1473	{
krh@41	1474	struct razor_property p1, p2;
krh@79	1475	struct razor_set set1, set2;
danw@108	1476	uint32_t map1, map2;
krh@41	1477	int i, j, cmp, count1, count2;
krh@41	1478	char pool1, pool2;
krh@41	1479
krh@79	1480	set1 = merger->source1.set;
krh@79	1481	set2 = merger->source2.set;
krh@79	1482	map1 = merger->source1.property_map;
krh@79	1483	map2 = merger->source2.property_map;
krh@79	1484
krh@41	1485	i = 0;
krh@41	1486	j = 0;
krh@41	1487	pool1 = set1->string_pool.data;
krh@41	1488	pool2 = set2->string_pool.data;
krh@41	1489
krh@66	1490	count1 = set1->properties.size / sizeof *p1;
krh@66	1491	count2 = set2->properties.size / sizeof *p2;
krh@41	1492	while (i < count1 \|\| j < count2) {
krh@41	1493	if (i < count1 && map1[i] == 0) {
krh@41	1494	i++;
krh@41	1495	continue;
krh@41	1496	}
krh@41	1497	if (j < count2 && map2[j] == 0) {
krh@41	1498	j++;
krh@41	1499	continue;
krh@41	1500	}
krh@66	1501	p1 = (struct razor_property *) set1->properties.data + i;
krh@66	1502	p2 = (struct razor_property *) set2->properties.data + j;
krh@41	1503	if (i < count1 && j < count2)
krh@66	1504	cmp = strcmp(&pool1[p1->name & RAZOR_ENTRY_MASK],
krh@66	1505	&pool2[p2->name & RAZOR_ENTRY_MASK]);
krh@41	1506	else if (i < count1)
krh@41	1507	cmp = -1;
krh@41	1508	else
krh@41	1509	cmp = 1;
krh@41	1510	if (cmp == 0)
danw@109	1511	cmp = p1->relation - p2->relation;
danw@109	1512	if (cmp == 0)
krh@41	1513	cmp = versioncmp(&pool1[p1->version],
krh@41	1514	&pool2[p2->version]);
krh@41	1515	if (cmp < 0) {
krh@79	1516	map1[i++] = add_property(merger,
krh@66	1517	&pool1[p1->name & RAZOR_ENTRY_MASK],
danw@109	1518	p1->relation,
krh@69	1519	&pool1[p1->version],
krh@69	1520	(p1->name >> 30));
krh@41	1521	} else if (cmp > 0) {
krh@79	1522	map2[j++] = add_property(merger,
krh@66	1523	&pool2[p2->name & RAZOR_ENTRY_MASK],
danw@109	1524	p2->relation,
krh@69	1525	&pool2[p2->version],
krh@69	1526	(p2->name >> 30));
krh@41	1527	} else {
krh@79	1528	map1[i++] = map2[j++] = add_property(merger,
krh@66	1529	&pool1[p1->name & RAZOR_ENTRY_MASK],
danw@109	1530	p1->relation,
krh@69	1531	&pool1[p1->version],
krh@69	1532	(p1->name >> 30));
krh@41	1533	}
krh@41	1534	}
krh@41	1535	}
krh@41	1536
danw@108	1537	static uint32_t
danw@108	1538	emit_properties(struct array *source_pool, uint32_t index,
danw@108	1539	uint32_t map, struct array pool)
krh@41	1540	{
danw@108	1541	uint32_t r, p, q;
krh@41	1542
krh@41	1543	r = pool->size / sizeof *q;
danw@108	1544	p = (uint32_t *) source_pool->data + index;
krh@64	1545	while (1) {
krh@41	1546	q = array_add(pool, sizeof *q);
krh@64	1547	q = map[p & RAZOR_ENTRY_MASK] \| (*p & ~RAZOR_ENTRY_MASK);
krh@64	1548	if (*p++ & RAZOR_ENTRY_LAST)
krh@64	1549	break;
krh@33	1550	}
krh@33	1551
krh@41	1552	return r;
krh@41	1553	}
krh@41	1554
krh@41	1555	/* Rebuild property->packages maps. We can't just remap these, as a
krh@41	1556	* property may have lost or gained a number of packages. Allocate an
krh@41	1557	* array per property and loop through the packages and add them to
krh@41	1558	* the arrays for their properties. */
krh@41	1559	static void
krh@41	1560	rebuild_package_lists(struct razor_set *set)
krh@41	1561	{
krh@66	1562	struct array pkgs, a;
krh@41	1563	struct razor_package pkg, pkg_end;
krh@41	1564	struct razor_property prop, prop_end;
danw@108	1565	uint32_t r, q, *pool;
krh@66	1566	int count;
krh@41	1567
krh@66	1568	count = set->properties.size / sizeof (struct razor_property);
krh@66	1569	pkgs = zalloc(count * sizeof *pkgs);
krh@41	1570	pkg_end = set->packages.data + set->packages.size;
krh@66	1571	pool = set->property_pool.data;
krh@41	1572
krh@41	1573	for (pkg = set->packages.data; pkg < pkg_end; pkg++) {
krh@66	1574	for (r = &pool[pkg->properties]; ; r++) {
krh@66	1575	q = array_add(&pkgs[r & RAZOR_ENTRY_MASK], sizeof q);
krh@41	1576	q = pkg - (struct razor_package ) set->packages.data;
krh@64	1577	if (*r & RAZOR_IMMEDIATE)
krh@64	1578	break;
krh@41	1579	}
krh@33	1580	}
krh@33	1581
krh@66	1582	prop_end = set->properties.data + set->properties.size;
krh@66	1583	a = pkgs;
krh@66	1584	for (prop = set->properties.data; prop < prop_end; prop++, a++) {
krh@61	1585	if (a->size / sizeof *r == 1) {
krh@61	1586	r = a->data;
krh@61	1587	prop->packages = *r \| RAZOR_IMMEDIATE;
krh@61	1588	} else {
krh@61	1589	prop->packages =
krh@66	1590	add_to_property_pool(&set->property_pool, a);
krh@61	1591	}
krh@41	1592	array_release(a);
krh@41	1593	}
krh@66	1594	free(pkgs);
krh@33	1595	}
krh@33	1596
krh@79	1597	struct razor_set *
krh@79	1598	razor_merger_finish(struct razor_merger *merger)
krh@79	1599	{
krh@79	1600	struct razor_set *result;
krh@79	1601
krh@79	1602	result = merger->set;
krh@79	1603	hashtable_release(&merger->table);
krh@79	1604	free(merger);
krh@79	1605
krh@79	1606	return result;
krh@79	1607	}
krh@79	1608
krh@33	1609	/* Add packages from 'upstream' to 'set'. The packages to add are
krh@33	1610	* specified by the 'packages' array, which is a sorted list of
krh@33	1611	* package indexes. Returns a newly allocated package set. Does not
krh@41	1612	* enforce validity of the resulting package set.
krh@41	1613	*
krh@41	1614	* This looks more complicated than it is. An easy way to merge two
krh@41	1615	* package sets would be to just use a razor_importer, but that
krh@41	1616	* requires resorting, and is thus O(n log n). We can do this in a
krh@41	1617	* linear sweep, but it gets a little more complicated.
krh@41	1618	*/
krh@33	1619	struct razor_set *
krh@33	1620	razor_set_add(struct razor_set set, struct razor_set upstream,
krh@33	1621	struct array *packages)
krh@33	1622	{
krh@79	1623	struct razor_merger *merger;
krh@41	1624	struct razor_package p, pend;
krh@33	1625
krh@79	1626	merger = razor_merger_create(set, upstream);
krh@33	1627
krh@79	1628	merge_packages(merger, packages);
krh@41	1629
krh@41	1630	/* As we built the package list, we filled out a bitvector of
krh@41	1631	* the properties that are referenced by the packages in the
krh@41	1632	* new set. Now we do a parallel loop through the properties
krh@41	1633	* and emit those marked in the bit vector to the new set. In
krh@41	1634	* the process, we update the bit vector to actually map from
krh@41	1635	* indices in the old property list to indices in the new
krh@41	1636	* property list for both sets. */
krh@41	1637
krh@79	1638	merge_properties(merger);
krh@41	1639
krh@41	1640	/* Now we loop through the packages again and emit the
krh@41	1641	* property lists, remapped to point to the new properties. */
krh@41	1642
krh@79	1643	pend = merger->set->packages.data + merger->set->packages.size;
krh@79	1644	for (p = merger->set->packages.data; p < pend; p++) {
krh@41	1645	struct source *src;
krh@41	1646
krh@41	1647	if (p->name & UPSTREAM_SOURCE)
krh@79	1648	src = &merger->source2;
krh@41	1649	else
krh@79	1650	src = &merger->source1;
krh@41	1651
krh@66	1652	p->properties = emit_properties(&src->set->property_pool,
krh@66	1653	p->properties,
krh@66	1654	src->property_map,
krh@79	1655	&merger->set->property_pool);
krh@41	1656	p->name &= INDEX_MASK;
krh@33	1657	}
krh@33	1658
krh@79	1659	rebuild_package_lists(merger->set);
krh@41	1660
krh@79	1661	return razor_merger_finish(merger);
krh@33	1662	}
krh@33	1663
krh@37	1664	void
krh@37	1665	razor_set_satisfy(struct razor_set set, struct array unsatisfied,
krh@37	1666	struct razor_set upstream, struct array list)
krh@37	1667	{
krh@37	1668	struct razor_property requires, r;
krh@37	1669	struct razor_property p, pend;
danw@108	1670	uint32_t u, end, pkg, package_pool;
krh@37	1671	char pool, upool;
krh@37	1672
krh@37	1673	end = unsatisfied->data + unsatisfied->size;
krh@66	1674	requires = set->properties.data;
krh@37	1675	pool = set->string_pool.data;
krh@37	1676
krh@66	1677	p = upstream->properties.data;
krh@66	1678	pend = upstream->properties.data + upstream->properties.size;
krh@37	1679	upool = upstream->string_pool.data;
krh@39	1680	package_pool = upstream->package_pool.data;
krh@37	1681
krh@37	1682	for (u = unsatisfied->data; u < end; u++) {
krh@37	1683	r = requires + *u;
krh@37	1684
krh@66	1685	while (p < pend &&
krh@66	1686	strcmp(&pool[r->name & RAZOR_ENTRY_MASK],
krh@66	1687	&upool[p->name & RAZOR_ENTRY_MASK]) > 0 &&
krh@66	1688	(p->name >> 30) != RAZOR_PROPERTY_PROVIDES)
krh@37	1689	p++;
krh@37	1690	/* If there is more than one version of a provides,
krh@37	1691	* seek to the end for the highest version. */
krh@37	1692	while (p + 1 < pend && p->name == (p + 1)->name)
krh@37	1693	p++;
krh@37	1694
krh@37	1695	if (p == pend \|\|
krh@66	1696	strcmp(&pool[r->name & RAZOR_ENTRY_MASK],
krh@66	1697	&upool[p->name & RAZOR_ENTRY_MASK]) != 0 \|\|
krh@37	1698	versioncmp(&pool[r->version], &upool[p->version]) > 0) {
krh@37	1699	/* Do we need to track unsatisfiable requires
krh@37	1700	* as we go, or should we just do a
krh@37	1701	* razor_set_validate() at the end? */
krh@37	1702	} else {
krh@37	1703	pkg = array_add(list, sizeof *pkg);
krh@37	1704	/* We just pull in the first package that provides */
krh@61	1705	if (p->packages & RAZOR_IMMEDIATE)
krh@61	1706	*pkg = p->packages & RAZOR_ENTRY_MASK;
krh@61	1707	else
krh@61	1708	*pkg = package_pool[p->packages];
krh@37	1709	}
krh@37	1710	}
krh@37	1711	}
krh@37	1712
krh@38	1713	static void
krh@38	1714	find_packages(struct razor_set *set,
krh@105	1715	int count, const char *package_names, struct array list)
krh@38	1716	{
krh@105	1717	struct razor_package_iterator *pi;
krh@105	1718	struct razor_package p, packages;
krh@105	1719	const char name, version;
danw@108	1720	uint32_t *r;
krh@38	1721	int i;
krh@38	1722
krh@105	1723	packages = (struct razor_package *) set->packages.data;
krh@105	1724	pi = razor_package_iterator_create(set);
krh@105	1725
krh@105	1726	while (razor_package_iterator_next(pi, &p, &name, &version)) {
krh@105	1727	for (i = 0; i < count; i++) {
krh@105	1728	if (strcmp(name, package_names[i]) == 0) {
krh@105	1729	r = array_add(list, sizeof *r);
krh@105	1730	*r = p - packages;
krh@105	1731	break;
krh@105	1732	}
krh@105	1733	}
krh@38	1734	}
krh@105	1735
krh@105	1736	razor_package_iterator_destroy(pi);
krh@38	1737	}
krh@38	1738
krh@38	1739	static void
krh@38	1740	find_all_packages(struct razor_set *set,
krh@38	1741	struct razor_set upstream, struct array list)
krh@38	1742	{
krh@38	1743	struct razor_package p, u, pend, uend;
danw@108	1744	uint32_t *r;
krh@38	1745	char pool, upool;
krh@38	1746
krh@38	1747	pend = set->packages.data + set->packages.size;
krh@38	1748	pool = set->string_pool.data;
krh@38	1749	u = upstream->packages.data;
krh@38	1750	uend = upstream->packages.data + upstream->packages.size;
krh@38	1751	upool = upstream->string_pool.data;
krh@38	1752
krh@38	1753	for (p = set->packages.data; p < pend; p++) {
krh@38	1754	while (u < uend && strcmp(&pool[p->name], &upool[u->name]) > 0)
krh@38	1755	u++;
krh@38	1756	if (strcmp(&pool[p->name], &upool[u->name]) == 0) {
krh@38	1757	r = array_add(list, sizeof *r);
krh@38	1758	r = u - (struct razor_package ) upstream->packages.data;
krh@38	1759	}
krh@38	1760	}
krh@38	1761	}
krh@38	1762
krh@33	1763	struct razor_set *
krh@33	1764	razor_set_update(struct razor_set set, struct razor_set upstream,
krh@33	1765	int count, const char **packages)
krh@33	1766	{
krh@37	1767	struct razor_set *new;
krh@43	1768	struct razor_package *upackages;
krh@37	1769	struct array list, unsatisfied;
krh@37	1770	char *pool;
danw@108	1771	uint32_t u, end;
krh@38	1772	int total = 0;
krh@33	1773
krh@33	1774	array_init(&list);
krh@38	1775	if (count > 0)
krh@38	1776	find_packages(upstream, count, packages, &list);
krh@38	1777	else
krh@38	1778	find_all_packages(set, upstream, &list);
krh@33	1779
krh@37	1780	end = list.data + list.size;
krh@37	1781	upackages = upstream->packages.data;
krh@37	1782	pool = upstream->string_pool.data;
krh@38	1783	total += list.size / sizeof *u;
krh@37	1784
krh@37	1785	while (list.size > 0) {
krh@37	1786	new = razor_set_add(set, upstream, &list);
krh@37	1787	array_release(&list);
krh@37	1788	razor_set_destroy(set);
krh@37	1789	set = new;
krh@37	1790
krh@37	1791	array_init(&unsatisfied);
krh@37	1792	razor_set_validate(new, &unsatisfied);
krh@37	1793	array_init(&list);
krh@37	1794	razor_set_satisfy(new, &unsatisfied, upstream, &list);
krh@37	1795	array_release(&unsatisfied);
krh@37	1796
krh@37	1797	end = list.data + list.size;
krh@37	1798	upackages = upstream->packages.data;
krh@37	1799	pool = upstream->string_pool.data;
krh@38	1800	total += list.size / sizeof *u;
krh@37	1801	}
krh@37	1802
krh@37	1803	array_release(&list);
krh@37	1804
krh@37	1805	return set;
krh@33	1806	}
krh@33	1807
krh@44	1808	/* The diff order matters. We should sort the packages so that a
krh@44	1809	* REMOVE of a package comes before the INSTALL, and so that all
krh@44	1810	* requires for a package have been installed before the package.
krh@44	1811	**/
krh@44	1812
krh@44	1813	void
krh@44	1814	razor_set_diff(struct razor_set set, struct razor_set upstream,
krh@44	1815	razor_package_callback_t callback, void *data)
krh@44	1816	{
krh@103	1817	struct razor_package_iterator pi1, pi2;
krh@103	1818	struct razor_package p1, p2;
krh@103	1819	const char name1, name2, version1, version2;
krh@106	1820	int res;
krh@44	1821
krh@103	1822	pi1 = razor_package_iterator_create(set);
krh@103	1823	pi2 = razor_package_iterator_create(upstream);
krh@44	1824
krh@103	1825	razor_package_iterator_next(pi1, &p1, &name1, &version1);
krh@103	1826	razor_package_iterator_next(pi2, &p2, &name2, &version2);
krh@44	1827
krh@103	1828	while (p1 \|\| p2) {
krh@103	1829	if (p1 && p2) {
krh@103	1830	res = strcmp(name1, name2);
krh@44	1831	if (res == 0)
krh@103	1832	res = versioncmp(version1, version2);
krh@106	1833	} else {
krh@106	1834	res = 0;
krh@44	1835	}
krh@44	1836
krh@103	1837	if (p2 == NULL \|\| res < 0)
krh@103	1838	callback(name1, version1, NULL, data);
krh@103	1839	else if (p1 == NULL \|\| res > 0)
krh@103	1840	callback(name2, NULL, version2, data);
krh@103	1841
krh@103	1842	if (p1 != NULL && res <= 0)
krh@103	1843	razor_package_iterator_next(pi1, &p1,
krh@103	1844	&name1, &version1);
krh@103	1845	if (p2 != NULL && res >= 0)
krh@103	1846	razor_package_iterator_next(pi2, &p2,
krh@103	1847	&name2, &version2);
krh@44	1848	}
krh@103	1849
krh@103	1850	razor_package_iterator_destroy(pi1);
krh@103	1851	razor_package_iterator_destroy(pi2);
krh@44	1852	}

author	Dan Winship <danw@gnome.org>
	Tue Feb 05 12:02:53 2008 -0500 (2008-02-05)
changeset 110	07a5bf8e7e6e
parent 108	340d92912f49
child 113	e408ff1d4a4d
permissions	-rw-r--r--