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