1.1 --- a/razor.c Mon Sep 03 23:13:19 2007 -0400
1.2 +++ b/razor.c Tue Sep 04 23:51:06 2007 -0400
1.3 @@ -40,34 +40,6 @@
1.4 return err;
1.5 }
1.6
1.7 -struct hashtable_header {
1.8 - unsigned int magic;
1.9 - unsigned int version;
1.10 - struct { unsigned int type, offset; } sections[0];
1.11 -};
1.12 -
1.13 -#define HASHTABLE_MAGIC 0x7a7a7a7a
1.14 -#define HASHTABLE_VERSION 1
1.15 -#define HASHTABLE_BUCKETS 1
1.16 -#define HASHTABLE_STRINGS 2
1.17 -#define HASHTABLE_PACKAGES 3
1.18 -
1.19 -struct package {
1.20 - unsigned long name;
1.21 - unsigned long version;
1.22 -};
1.23 -
1.24 -struct hashtable {
1.25 - unsigned long *buckets;
1.26 - int bucket_count, bucket_alloc;
1.27 - char *string_pool;
1.28 - int pool_size, pool_alloc;
1.29 - struct hashtable_header *header;
1.30 -
1.31 - struct package *packages;
1.32 - int package_count, package_alloc;
1.33 -};
1.34 -
1.35 static void *
1.36 zalloc(size_t size)
1.37 {
1.38 @@ -79,115 +51,143 @@
1.39 return p;
1.40 }
1.41
1.42 -struct hashtable *
1.43 -hashtable_create(void)
1.44 +struct razor_set_header {
1.45 + unsigned int magic;
1.46 + unsigned int version;
1.47 + struct { unsigned int type, offset; } sections[0];
1.48 +};
1.49 +
1.50 +#define RAZOR_MAGIC 0x7a7a7a7a
1.51 +#define RAZOR_VERSION 1
1.52 +#define RAZOR_BUCKETS 1
1.53 +#define RAZOR_STRINGS 2
1.54 +#define RAZOR_PACKAGES 3
1.55 +
1.56 +struct razor_package {
1.57 + unsigned long name;
1.58 + unsigned long version;
1.59 +};
1.60 +
1.61 +struct razor_set {
1.62 + unsigned long *buckets;
1.63 + int bucket_count, bucket_alloc;
1.64 + char *string_pool;
1.65 + int pool_size, pool_alloc;
1.66 + struct razor_set_header *header;
1.67 +
1.68 + struct razor_package *packages;
1.69 + int package_count, package_alloc;
1.70 +};
1.71 +
1.72 +struct razor_set *
1.73 +razor_set_create(void)
1.74 {
1.75 - struct hashtable *ht;
1.76 + struct razor_set *set;
1.77
1.78 - ht = zalloc(sizeof *ht);
1.79 - ht->buckets = zalloc(4096 * sizeof *ht->buckets);
1.80 - ht->bucket_count = 0;
1.81 - ht->bucket_alloc = 4096;
1.82 + set = zalloc(sizeof *set);
1.83 + set->buckets = zalloc(4096 * sizeof *set->buckets);
1.84 + set->bucket_count = 0;
1.85 + set->bucket_alloc = 4096;
1.86
1.87 - ht->string_pool = zalloc(4096);
1.88 - ht->pool_size = 1;
1.89 - ht->pool_alloc = 4096;
1.90 + set->string_pool = zalloc(4096);
1.91 + set->pool_size = 1;
1.92 + set->pool_alloc = 4096;
1.93
1.94 - ht->packages = zalloc(4096 * sizeof *ht->packages);
1.95 - ht->package_count = 0;
1.96 - ht->package_alloc = 4096;
1.97 + set->packages = zalloc(4096 * sizeof *set->packages);
1.98 + set->package_count = 0;
1.99 + set->package_alloc = 4096;
1.100
1.101 - return ht;
1.102 + return set;
1.103 }
1.104
1.105 -struct hashtable *
1.106 -hashtable_create_from_file(const char *filename)
1.107 +struct razor_set *
1.108 +razor_set_open(const char *filename)
1.109 {
1.110 - struct hashtable *ht;
1.111 + struct razor_set *set;
1.112 struct stat stat;
1.113 unsigned int size, offset;
1.114 int fd, i;
1.115
1.116 - ht = zalloc(sizeof *ht);
1.117 + set = zalloc(sizeof *set);
1.118 fd = open(filename, O_RDONLY);
1.119 if (fstat(fd, &stat) < 0)
1.120 return NULL;
1.121 - ht->header = mmap(NULL, stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
1.122 - if (ht->header == MAP_FAILED) {
1.123 - free(ht);
1.124 + set->header = mmap(NULL, stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
1.125 + if (set->header == MAP_FAILED) {
1.126 + free(set);
1.127 return NULL;
1.128 }
1.129
1.130 - for (i = 0; i < ht->header->sections[i].type; i++) {
1.131 - offset = ht->header->sections[i].offset;
1.132 - size = ht->header->sections[i + 1].offset - offset;
1.133 + for (i = 0; i < set->header->sections[i].type; i++) {
1.134 + offset = set->header->sections[i].offset;
1.135 + size = set->header->sections[i + 1].offset - offset;
1.136
1.137 - switch (ht->header->sections[i].type) {
1.138 - case HASHTABLE_BUCKETS:
1.139 - ht->buckets = (void *) ht->header + offset;
1.140 - ht->bucket_count = size / sizeof *ht->buckets;
1.141 - ht->bucket_alloc = ht->bucket_count;
1.142 + switch (set->header->sections[i].type) {
1.143 + case RAZOR_BUCKETS:
1.144 + set->buckets = (void *) set->header + offset;
1.145 + set->bucket_count = size / sizeof *set->buckets;
1.146 + set->bucket_alloc = set->bucket_count;
1.147 break;
1.148 - case HASHTABLE_STRINGS:
1.149 - ht->string_pool = (void *) ht->header + offset;
1.150 - ht->pool_size = size;
1.151 - ht->pool_alloc = size;
1.152 + case RAZOR_STRINGS:
1.153 + set->string_pool = (void *) set->header + offset;
1.154 + set->pool_size = size;
1.155 + set->pool_alloc = size;
1.156 break;
1.157 - case HASHTABLE_PACKAGES:
1.158 - ht->packages = (void *) ht->header + offset;
1.159 - ht->package_count = size / sizeof *ht->packages;
1.160 - ht->package_alloc = size / sizeof *ht->packages;
1.161 + case RAZOR_PACKAGES:
1.162 + set->packages = (void *) set->header + offset;
1.163 + set->package_count = size / sizeof *set->packages;
1.164 + set->package_alloc = size / sizeof *set->packages;
1.165 break;
1.166 }
1.167 }
1.168 close(fd);
1.169
1.170 - return ht;
1.171 + return set;
1.172 }
1.173
1.174 void
1.175 -hashtable_destroy(struct hashtable *ht)
1.176 +razor_set_destroy(struct razor_set *set)
1.177 {
1.178 unsigned int size;
1.179 int i;
1.180
1.181 - if (ht->header) {
1.182 - for (i = 0; ht->header->sections[i].type; i++)
1.183 + if (set->header) {
1.184 + for (i = 0; set->header->sections[i].type; i++)
1.185 ;
1.186 - size = ht->header->sections[i].type;
1.187 - munmap(ht->header, size);
1.188 + size = set->header->sections[i].type;
1.189 + munmap(set->header, size);
1.190 } else {
1.191 - free(ht->buckets);
1.192 - free(ht->string_pool);
1.193 + free(set->buckets);
1.194 + free(set->string_pool);
1.195 }
1.196
1.197 - free(ht);
1.198 + free(set);
1.199 }
1.200
1.201 static int
1.202 -hashtable_write(struct hashtable *ht, const char *filename)
1.203 +razor_set_write(struct razor_set *set, const char *filename)
1.204 {
1.205 char data[4096];
1.206 - struct hashtable_header *header = (struct hashtable_header *) data;
1.207 + struct razor_set_header *header = (struct razor_set_header *) data;
1.208 int fd, pool_size, package_size;
1.209
1.210 /* Align these to pages sizes */
1.211 - pool_size = (ht->pool_size + 4095) & ~4095;
1.212 + pool_size = (set->pool_size + 4095) & ~4095;
1.213 package_size =
1.214 - (ht->package_alloc * sizeof *ht->packages + 4095) & ~4095;
1.215 + (set->package_alloc * sizeof *set->packages + 4095) & ~4095;
1.216
1.217 memset(data, 0, sizeof data);
1.218 - header->magic = HASHTABLE_MAGIC;
1.219 - header->version = HASHTABLE_VERSION;
1.220 + header->magic = RAZOR_MAGIC;
1.221 + header->version = RAZOR_VERSION;
1.222
1.223 - header->sections[0].type = HASHTABLE_BUCKETS;
1.224 + header->sections[0].type = RAZOR_BUCKETS;
1.225 header->sections[0].offset = sizeof data;
1.226
1.227 - header->sections[1].type = HASHTABLE_STRINGS;
1.228 + header->sections[1].type = RAZOR_STRINGS;
1.229 header->sections[1].offset = header->sections[0].offset +
1.230 - ht->bucket_alloc * sizeof *ht->buckets;
1.231 + set->bucket_alloc * sizeof *set->buckets;
1.232
1.233 - header->sections[2].type = HASHTABLE_PACKAGES;
1.234 + header->sections[2].type = RAZOR_PACKAGES;
1.235 header->sections[2].offset = header->sections[1].offset + pool_size;
1.236
1.237 header->sections[3].type = 0;
1.238 @@ -198,9 +198,9 @@
1.239 return -1;
1.240
1.241 write_to_fd(fd, data, sizeof data);
1.242 - write_to_fd(fd, ht->buckets, ht->bucket_alloc * sizeof *ht->buckets);
1.243 - write_to_fd(fd, ht->string_pool, pool_size);
1.244 - write_to_fd(fd, ht->packages, package_size);
1.245 + write_to_fd(fd, set->buckets, set->bucket_alloc * sizeof *set->buckets);
1.246 + write_to_fd(fd, set->string_pool, pool_size);
1.247 + write_to_fd(fd, set->packages, package_size);
1.248
1.249 return 0;
1.250 }
1.251 @@ -218,23 +218,23 @@
1.252 }
1.253
1.254 unsigned long
1.255 -hashtable_lookup(struct hashtable *ht, const char *key)
1.256 +razor_set_lookup(struct razor_set *set, const char *key)
1.257 {
1.258 unsigned int start;
1.259 unsigned int mask;
1.260 unsigned long value;
1.261 int i;
1.262
1.263 - mask = ht->bucket_alloc - 1;
1.264 + mask = set->bucket_alloc - 1;
1.265 start = hash_string(key) & mask;
1.266 i = start;
1.267 do {
1.268 - value = ht->buckets[i];
1.269 + value = set->buckets[i];
1.270
1.271 if (value == 0)
1.272 return 0;
1.273
1.274 - if (strcmp(key, &ht->string_pool[value]) == 0)
1.275 + if (strcmp(key, &set->string_pool[value]) == 0)
1.276 return value;
1.277
1.278 i = (i + 1) & mask;
1.279 @@ -244,45 +244,45 @@
1.280 }
1.281
1.282 static unsigned long
1.283 -add_to_string_pool(struct hashtable *ht, const char *key)
1.284 +add_to_string_pool(struct razor_set *set, const char *key)
1.285 {
1.286 int len, alloc;
1.287 char *pool;
1.288 unsigned long value;
1.289
1.290 len = strlen(key) + 1;
1.291 - alloc = ht->pool_alloc;
1.292 - while (alloc < ht->pool_size + len)
1.293 + alloc = set->pool_alloc;
1.294 + while (alloc < set->pool_size + len)
1.295 alloc *= 2;
1.296 - if (ht->pool_alloc < alloc) {
1.297 - pool = realloc(ht->string_pool, alloc);
1.298 + if (set->pool_alloc < alloc) {
1.299 + pool = realloc(set->string_pool, alloc);
1.300 if (pool == NULL)
1.301 return 0;
1.302 - ht->string_pool = pool;
1.303 - ht->pool_alloc = alloc;
1.304 + set->string_pool = pool;
1.305 + set->pool_alloc = alloc;
1.306 }
1.307
1.308 - memcpy(ht->string_pool + ht->pool_size, key, len);
1.309 - value = ht->pool_size;
1.310 - ht->pool_size += len;
1.311 + memcpy(set->string_pool + set->pool_size, key, len);
1.312 + value = set->pool_size;
1.313 + set->pool_size += len;
1.314
1.315 return value;
1.316 }
1.317
1.318 static void
1.319 -do_insert(struct hashtable *ht, unsigned long value)
1.320 +do_insert(struct razor_set *set, unsigned long value)
1.321 {
1.322 unsigned int mask;
1.323 const char *key;
1.324 int i, start;
1.325
1.326 - key = &ht->string_pool[value];
1.327 - mask = ht->bucket_alloc - 1;
1.328 + key = &set->string_pool[value];
1.329 + mask = set->bucket_alloc - 1;
1.330 start = hash_string(key) & mask;
1.331 i = start;
1.332 do {
1.333 - if (ht->buckets[i] == 0) {
1.334 - ht->buckets[i] = value;
1.335 + if (set->buckets[i] == 0) {
1.336 + set->buckets[i] = value;
1.337 break;
1.338 }
1.339 i = (i + 1) & mask;
1.340 @@ -290,130 +290,98 @@
1.341 }
1.342
1.343 unsigned long
1.344 -hashtable_insert(struct hashtable *ht, const char *key)
1.345 +razor_set_insert(struct razor_set *set, const char *key)
1.346 {
1.347 unsigned long value, *buckets, *old_buckets;
1.348 int i, alloc, old_alloc;
1.349
1.350 - alloc = ht->bucket_alloc;
1.351 - while (alloc < 4 * ht->bucket_count)
1.352 + alloc = set->bucket_alloc;
1.353 + while (alloc < 4 * set->bucket_count)
1.354 alloc *= 2;
1.355
1.356 - if (alloc != ht->bucket_alloc) {
1.357 - buckets = zalloc(alloc * sizeof *ht->buckets);
1.358 + if (alloc != set->bucket_alloc) {
1.359 + buckets = zalloc(alloc * sizeof *set->buckets);
1.360 if (buckets == NULL)
1.361 return 0;
1.362 - old_buckets = ht->buckets;
1.363 - ht->buckets = buckets;
1.364 - old_alloc = ht->bucket_alloc;
1.365 - ht->bucket_alloc = alloc;
1.366 + old_buckets = set->buckets;
1.367 + set->buckets = buckets;
1.368 + old_alloc = set->bucket_alloc;
1.369 + set->bucket_alloc = alloc;
1.370
1.371 for (i = 0; i < old_alloc; i++) {
1.372 value = old_buckets[i];
1.373 if (value != 0)
1.374 - do_insert(ht, value);
1.375 + do_insert(set, value);
1.376 }
1.377 free(old_buckets);
1.378 }
1.379
1.380 - value = add_to_string_pool(ht, key);
1.381 - do_insert (ht, value);
1.382 - ht->bucket_count++;
1.383 + value = add_to_string_pool(set, key);
1.384 + do_insert (set, value);
1.385 + set->bucket_count++;
1.386
1.387 return value;
1.388 }
1.389
1.390 static unsigned long
1.391 -hashtable_add_package(struct hashtable *ht,
1.392 +razor_set_add_package(struct razor_set *set,
1.393 unsigned long name, unsigned long version)
1.394 {
1.395 - struct package *packages;
1.396 + struct razor_package *packages;
1.397 int alloc;
1.398
1.399 - alloc = ht->package_alloc;
1.400 - while (alloc < ht->package_count + 1)
1.401 + /* FIXME: make 0 an illegal pkgs number. */
1.402 + alloc = set->package_alloc;
1.403 + while (alloc < set->package_count + 1)
1.404 alloc *= 2;
1.405 - if (ht->package_alloc < alloc) {
1.406 - packages = realloc(ht->packages, alloc * sizeof ht->packages);
1.407 + if (set->package_alloc < alloc) {
1.408 + packages = realloc(set->packages, alloc * sizeof set->packages);
1.409 if (packages == NULL)
1.410 return 0;
1.411 - ht->packages = packages;
1.412 - ht->package_alloc = alloc;
1.413 + set->packages = packages;
1.414 + set->package_alloc = alloc;
1.415 }
1.416
1.417 - ht->packages[ht->package_count].name = name;
1.418 - ht->packages[ht->package_count].version = version;
1.419 - ht->package_count++;
1.420 + set->packages[set->package_count].name = name;
1.421 + set->packages[set->package_count].version = version;
1.422
1.423 - return 0;
1.424 -}
1.425 -
1.426 -
1.427 -struct razor_context {
1.428 - struct hashtable *global_ht;
1.429 -};
1.430 -
1.431 -struct razor_context *
1.432 -razor_context_create (void)
1.433 -{
1.434 - struct razor_context *ctx;
1.435 -
1.436 - ctx = malloc(sizeof *ctx);
1.437 - ctx->global_ht = hashtable_create();
1.438 -
1.439 - return ctx;
1.440 -}
1.441 -
1.442 -struct razor_context *
1.443 -razor_context_create_from_file (const char *filename)
1.444 -{
1.445 - struct razor_context *ctx;
1.446 -
1.447 - ctx = malloc(sizeof *ctx);
1.448 - ctx->global_ht = hashtable_create_from_file(filename);
1.449 -
1.450 - return ctx;
1.451 + return set->package_count++;
1.452 }
1.453
1.454 unsigned long
1.455 -razor_context_tokenize(struct razor_context *ctx, const char *string)
1.456 +razor_set_tokenize(struct razor_set *set, const char *string)
1.457 {
1.458 unsigned long token;
1.459
1.460 - token = hashtable_lookup(ctx->global_ht, string);
1.461 + token = razor_set_lookup(set, string);
1.462 if (token != 0)
1.463 return token;
1.464
1.465 - return hashtable_insert(ctx->global_ht, string);
1.466 + return razor_set_insert(set, string);
1.467 }
1.468
1.469 -static struct hashtable *qsort_ht;
1.470 +static struct razor_set *qsort_set;
1.471
1.472 static int
1.473 compare_packages(const void *p1, const void *p2)
1.474 {
1.475 - const struct package *pkg1 = p1, *pkg2 = p2;
1.476 + const struct razor_package *pkg1 = p1, *pkg2 = p2;
1.477
1.478 - return strcmp(&qsort_ht->string_pool[pkg1->name],
1.479 - &qsort_ht->string_pool[pkg2->name]);
1.480 + return strcmp(&qsort_set->string_pool[pkg1->name],
1.481 + &qsort_set->string_pool[pkg2->name]);
1.482 }
1.483
1.484 static void
1.485 -razor_context_sort(struct razor_context *ctx)
1.486 +razor_set_sort(struct razor_set *set)
1.487 {
1.488 - struct hashtable *ht = ctx->global_ht;
1.489 -
1.490 - qsort_ht = ht;
1.491 - qsort(ht->packages, ht->package_count, sizeof *ht->packages,
1.492 + qsort_set = set;
1.493 + qsort(set->packages, set->package_count, sizeof *set->packages,
1.494 compare_packages);
1.495 }
1.496
1.497 -struct razor_set {
1.498 - struct razor_context *ctx;
1.499 -};
1.500 -
1.501 struct parsing_context {
1.502 - struct razor_context *ctx;
1.503 + struct razor_set *set;
1.504 + int pkg_id;
1.505 };
1.506
1.507 static void
1.508 @@ -424,9 +392,9 @@
1.509
1.510 for (i = 0; atts[i]; i += 2) {
1.511 if (strcmp(atts[i], "name") == 0)
1.512 - name = razor_context_tokenize(ctx->ctx, atts[i + 1]);
1.513 + name = razor_set_tokenize(ctx->set, atts[i + 1]);
1.514 else if (strcmp(atts[i], "version") == 0)
1.515 - version = razor_context_tokenize(ctx->ctx, atts[i + 1]);
1.516 + version = razor_set_tokenize(ctx->set, atts[i + 1]);
1.517 }
1.518
1.519 if (name == 0 || version == 0) {
1.520 @@ -435,7 +403,9 @@
1.521 return;
1.522 }
1.523
1.524 - hashtable_add_package(ctx->ctx->global_ht, name, version);
1.525 + ctx->pkg_id = razor_set_add_package(ctx->set, name, version);
1.526 +
1.527 + return;
1.528 }
1.529
1.530 static void
1.531 @@ -448,12 +418,16 @@
1.532 parse_package(ctx, atts);
1.533
1.534 for (i = 0; atts[i]; i += 2)
1.535 - razor_context_tokenize(ctx->ctx, atts[i + 1]);
1.536 + razor_set_tokenize(ctx->set, atts[i + 1]);
1.537 }
1.538
1.539 static void
1.540 end_element (void *data, const char *name)
1.541 {
1.542 + struct parsing_context *ctx = data;
1.543 +
1.544 + if (strcmp(name, "package") == 0)
1.545 + ctx->pkg_id = 0;
1.546 }
1.547
1.548 static char *
1.549 @@ -476,11 +450,11 @@
1.550 }
1.551
1.552 static int
1.553 -razor_context_read_file(struct razor_context *ctx, const char *filename)
1.554 +razor_set_import(struct razor_set *set, const char *filename)
1.555 {
1.556 SHA_CTX sha1;
1.557 XML_Parser parser;
1.558 - struct parsing_context pctx;
1.559 + struct parsing_context ctx;
1.560 int fd;
1.561 void *p;
1.562 struct stat stat;
1.563 @@ -495,8 +469,8 @@
1.564 return -1;
1.565
1.566 parser = XML_ParserCreate(NULL);
1.567 - pctx.ctx = ctx;
1.568 - XML_SetUserData(parser, &pctx);
1.569 + ctx.set = set;
1.570 + XML_SetUserData(parser, &ctx);
1.571 XML_SetElementHandler(parser, start_element, end_element);
1.572 if (XML_Parse(parser, p, stat.st_size, 1) == XML_STATUS_ERROR) {
1.573 fprintf(stderr,
1.574 @@ -523,58 +497,42 @@
1.575 return 0;
1.576 }
1.577
1.578 -int
1.579 -razor_context_write(struct razor_context *ctx, const char *filename)
1.580 -{
1.581 - return hashtable_write(ctx->global_ht, filename);
1.582 -}
1.583 -
1.584 void
1.585 -razor_context_list_packages(struct razor_context *ctx)
1.586 +razor_set_list(struct razor_set *set)
1.587 {
1.588 int i;
1.589 - struct hashtable *ht = ctx->global_ht;
1.590 - struct package *p;
1.591 + struct razor_package *p;
1.592
1.593 - p = ht->packages;
1.594 - for (i = 0; i < ht->package_count && p->name; i++, p++) {
1.595 + p = set->packages;
1.596 + for (i = 0; i < set->package_count && p->name; i++, p++) {
1.597 printf("%s %s\n",
1.598 - &ht->string_pool[p->name],
1.599 - &ht->string_pool[p->version]);
1.600 + &set->string_pool[p->name],
1.601 + &set->string_pool[p->version]);
1.602 }
1.603 }
1.604
1.605 void
1.606 -razor_context_info(struct razor_context *ctx)
1.607 +razor_set_info(struct razor_set *set)
1.608 {
1.609 - struct hashtable *ht = ctx->global_ht;
1.610 unsigned int offset, size;
1.611 int i;
1.612
1.613 - for (i = 0; i < ht->header->sections[i].type; i++) {
1.614 - offset = ht->header->sections[i].offset;
1.615 - size = ht->header->sections[i + 1].offset - offset;
1.616 + for (i = 0; i < set->header->sections[i].type; i++) {
1.617 + offset = set->header->sections[i].offset;
1.618 + size = set->header->sections[i + 1].offset - offset;
1.619
1.620 - switch (ht->header->sections[i].type) {
1.621 - case HASHTABLE_BUCKETS:
1.622 + switch (set->header->sections[i].type) {
1.623 + case RAZOR_BUCKETS:
1.624 printf("bucket section:\t\t%dkb\n", size / 1024);
1.625 break;
1.626 - case HASHTABLE_STRINGS:
1.627 + case RAZOR_STRINGS:
1.628 printf("string pool:\t\t%dkb\n", size / 1024);
1.629 break;
1.630 - case HASHTABLE_PACKAGES:
1.631 + case RAZOR_PACKAGES:
1.632 printf("package section:\t%dkb\n", size / 1024);
1.633 break;
1.634 }
1.635 }
1.636 -
1.637 -}
1.638 -
1.639 -void
1.640 -razor_context_destroy(struct razor_context *ctx)
1.641 -{
1.642 - hashtable_destroy(ctx->global_ht);
1.643 - free(ctx);
1.644 }
1.645
1.646 static int
1.647 @@ -590,7 +548,7 @@
1.648 main(int argc, char *argv[])
1.649 {
1.650 int i;
1.651 - struct razor_context *ctx;
1.652 + struct razor_set *set;
1.653 struct stat statbuf;
1.654
1.655 if (argc < 2) {
1.656 @@ -601,41 +559,41 @@
1.657 exit(-1);
1.658 }
1.659
1.660 - ctx = razor_context_create();
1.661 + set = razor_set_create();
1.662
1.663 for (i = 2; i < argc; i++) {
1.664 - if (razor_context_read_file(ctx, argv[i]) < 0) {
1.665 + if (razor_set_import(set, argv[i]) < 0) {
1.666 fprintf(stderr, "failed to import %s\n",
1.667 argv[i]);
1.668 exit(-1);
1.669 }
1.670 }
1.671
1.672 - razor_context_sort(ctx);
1.673 + razor_set_sort(set);
1.674
1.675 printf("number of buckets: %d\n",
1.676 - ctx->global_ht->bucket_count);
1.677 + set->bucket_count);
1.678 printf("bucket allocation: %d\n",
1.679 - ctx->global_ht->bucket_alloc);
1.680 - printf("pool size: %d\n", ctx->global_ht->pool_size);
1.681 - printf("pool allocation: %d\n", ctx->global_ht->pool_alloc);
1.682 + set->bucket_alloc);
1.683 + printf("pool size: %d\n", set->pool_size);
1.684 + printf("pool allocation: %d\n", set->pool_alloc);
1.685
1.686 - razor_context_write(ctx, repo_filename);
1.687 + razor_set_write(set, repo_filename);
1.688
1.689 - razor_context_destroy(ctx);
1.690 + razor_set_destroy(set);
1.691 } else if (strcmp(argv[1], "lookup") == 0) {
1.692 - ctx = razor_context_create_from_file(repo_filename);
1.693 + set = razor_set_open(repo_filename);
1.694 printf("%s is %lu\n", argv[2],
1.695 - hashtable_lookup(ctx->global_ht, argv[2]));
1.696 - razor_context_destroy(ctx);
1.697 + razor_set_lookup(set, argv[2]));
1.698 + razor_set_destroy(set);
1.699 } else if (strcmp(argv[1], "list") == 0) {
1.700 - ctx = razor_context_create_from_file(repo_filename);
1.701 - razor_context_list_packages(ctx);
1.702 - razor_context_destroy(ctx);
1.703 + set = razor_set_open(repo_filename);
1.704 + razor_set_list(set);
1.705 + razor_set_destroy(set);
1.706 } else if (strcmp(argv[1], "info") == 0) {
1.707 - ctx = razor_context_create_from_file(repo_filename);
1.708 - razor_context_info(ctx);
1.709 - razor_context_destroy(ctx);
1.710 + set = razor_set_open(repo_filename);
1.711 + razor_set_info(set);
1.712 + razor_set_destroy(set);
1.713 } else {
1.714 usage();
1.715 }