Add string-specific memory pool
[git] / vcs-svn / string_pool.c
1 /*
2  * Licensed under a two-clause BSD-style license.
3  * See LICENSE for details.
4  */
5
6 #include "git-compat-util.h"
7 #include "trp.h"
8 #include "obj_pool.h"
9 #include "string_pool.h"
10
11 static struct trp_root tree = { ~0 };
12
13 struct node {
14         uint32_t offset;
15         struct trp_node children;
16 };
17
18 /* Two memory pools: one for struct node, and another for strings */
19 obj_pool_gen(node, struct node, 4096)
20 obj_pool_gen(string, char, 4096)
21
22 static char *node_value(struct node *node)
23 {
24         return node ? string_pointer(node->offset) : NULL;
25 }
26
27 static int node_cmp(struct node *a, struct node *b)
28 {
29         return strcmp(node_value(a), node_value(b));
30 }
31
32 /* Build a Treap from the node structure (a trp_node w/ offset) */
33 trp_gen(static, tree_, struct node, children, node, node_cmp);
34
35 const char *pool_fetch(uint32_t entry)
36 {
37         return node_value(node_pointer(entry));
38 }
39
40 uint32_t pool_intern(const char *key)
41 {
42         /* Canonicalize key */
43         struct node *match = NULL, *node;
44         uint32_t key_len;
45         if (key == NULL)
46                 return ~0;
47         key_len = strlen(key) + 1;
48         node = node_pointer(node_alloc(1));
49         node->offset = string_alloc(key_len);
50         strcpy(node_value(node), key);
51         match = tree_search(&tree, node);
52         if (!match) {
53                 tree_insert(&tree, node);
54         } else {
55                 node_free(1);
56                 string_free(key_len);
57                 node = match;
58         }
59         return node_offset(node);
60 }
61
62 uint32_t pool_tok_r(char *str, const char *delim, char **saveptr)
63 {
64         char *token = strtok_r(str, delim, saveptr);
65         return token ? pool_intern(token) : ~0;
66 }
67
68 void pool_print_seq(uint32_t len, uint32_t *seq, char delim, FILE *stream)
69 {
70         uint32_t i;
71         for (i = 0; i < len && ~seq[i]; i++) {
72                 fputs(pool_fetch(seq[i]), stream);
73                 if (i < len - 1 && ~seq[i + 1])
74                         fputc(delim, stream);
75         }
76 }
77
78 uint32_t pool_tok_seq(uint32_t sz, uint32_t *seq, const char *delim, char *str)
79 {
80         char *context = NULL;
81         uint32_t token = ~0;
82         uint32_t length;
83
84         if (sz == 0)
85                 return ~0;
86         if (str)
87                 token = pool_tok_r(str, delim, &context);
88         for (length = 0; length < sz; length++) {
89                 seq[length] = token;
90                 if (token == ~0)
91                         return length;
92                 token = pool_tok_r(NULL, delim, &context);
93         }
94         seq[sz - 1] = ~0;
95         return sz;
96 }
97
98 void pool_reset(void)
99 {
100         node_reset();
101         string_reset();
102 }