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

author	Dan Winship <danw@gnome.org>
	Wed Feb 06 12:59:27 2008 -0500 (2008-02-06)
changeset 113	e408ff1d4a4d
parent 109	313b0a615c14
child 114	1d54922ff920
permissions	-rw-r--r--