Debian Codegraph @

lib/base/string.c

raw
1 /*
2 * Copyright (c) 2010 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
4 * All rights reserved.
5 *
6 * Portions Copyright (c) 2010 Apple Inc. All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 *
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * 3. Neither the name of the Institute nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35
36 #include "baselocl.h"
37 #include <string.h>
38
39 static void
40 string_dealloc(void *ptr)
41 {
42 heim_string_t s = ptr;
43 heim_string_free_f_t *deallocp;
44 heim_string_free_f_t dealloc;
45
46 if (*(const char *)ptr != '\0')
47 return;
48
49 /* Possible string ref */
50 deallocp = _heim_get_isaextra(s, 0);
51 dealloc = *deallocp;
52 if (dealloc != NULL) {
53 char **strp = _heim_get_isaextra(s, 1);
54 dealloc(*strp);
55 }
56 }
57
58 static int
59 string_cmp(void *a, void *b)
60 {
61 if (*(char *)a == '\0') {
62 char **strp = _heim_get_isaextra(a, 1);
63
64 if (*strp != NULL)
65 a = *strp; /* a is a string ref */
66 }
67 if (*(char *)b == '\0') {
68 char **strp = _heim_get_isaextra(b, 1);
69
70 if (*strp != NULL)
71 b = *strp; /* b is a string ref */
72 }
73 return strcmp(a, b);
74 }
75
76 static unsigned long
77 string_hash(void *ptr)
78 {
79 const char *s = ptr;
80 unsigned long n;
81
82 for (n = 0; *s; ++s)
83 n += *s;
84 return n;
85 }
86
87 struct heim_type_data _heim_string_object = {
88 HEIM_TID_STRING,
89 "string-object",
90 NULL,
91 string_dealloc,
92 NULL,
93 string_cmp,
94 string_hash,
95 NULL
96 };
97
98 /**
99 * Create a string object
100 *
101 * @param string the string to create, must be an utf8 string
102 *
103 * @return string object
104 */
105
106 heim_string_t
107 heim_string_create(const char *string)
108 {
109 return heim_string_create_with_bytes(string, strlen(string));
110 }
111
112 /**
113 * Create a string object without copying the source.
114 *
115 * @param string the string to referenced, must be UTF-8
116 * @param dealloc the function to use to release the referece to the string
117 *
118 * @return string object
119 */
120
121 heim_string_t
122 heim_string_ref_create(const char *string, heim_string_free_f_t dealloc)
123 {
124 heim_string_t s;
125 heim_string_free_f_t *deallocp;
126
127 s = _heim_alloc_object(&_heim_string_object, 1);
128 if (s) {
129 const char **strp;
130
131 ((char *)s)[0] = '\0';
132 deallocp = _heim_get_isaextra(s, 0);
133 *deallocp = dealloc;
134 strp = _heim_get_isaextra(s, 1);
135 *strp = string;
136 }
137 return s;
138 }
139
140 /**
141 * Create a string object
142 *
143 * @param string the string to create, must be an utf8 string
144 * @param len the length of the string
145 *
146 * @return string object
147 */
148
149 heim_string_t
150 heim_string_create_with_bytes(const void *data, size_t len)
151 {
152 heim_string_t s;
153
154 s = _heim_alloc_object(&_heim_string_object, len + 1);
155 if (s) {
156 memcpy(s, data, len);
157 ((char *)s)[len] = '\0';
158 }
159 return s;
160 }
161
162 /**
163 * Create a string object using a format string
164 *
165 * @param fmt format string
166 * @param ...
167 *
168 * @return string object
169 */
170
171 heim_string_t
172 heim_string_create_with_format(const char *fmt, ...)
173 {
174 heim_string_t s;
175 char *str = NULL;
176 va_list ap;
177 int ret;
178
179 va_start(ap, fmt);
180 ret = vasprintf(&str, fmt, ap);
181 va_end(ap);
182 if (ret < 0 || str == NULL)
183 return NULL;
184
185 s = heim_string_ref_create(str, string_dealloc);
186 if (s == NULL)
187 free(str);
188 return s;
189 }
190
191 /**
192 * Return the type ID of string objects
193 *
194 * @return type id of string objects
195 */
196
197 heim_tid_t
198 heim_string_get_type_id(void)
199 {
200 return HEIM_TID_STRING;
201 }
202
203 /**
204 * Get the string value of the content.
205 *
206 * @param string the string object to get the value from
207 *
208 * @return a utf8 string
209 */
210
211 const char *
212 heim_string_get_utf8(heim_string_t string)
213 {
214 if (*(const char *)string == '\0') {
215 const char **strp;
216
217 /* String ref */
218 strp = _heim_get_isaextra(string, 1);
219 if (*strp != NULL)
220 return *strp;
221 }
222 return (const char *)string;
223 }
224
225 /*
226 *
227 */
228
229 static void
230 init_string(void *ptr)
231 {
232 heim_dict_t *dict = ptr;
233 *dict = heim_dict_create(101);
234 heim_assert(*dict != NULL, "__heim_string_constant");
235 }
236
237 heim_string_t
238 __heim_string_constant(const char *_str)
239 {
240 static HEIMDAL_MUTEX mutex = HEIMDAL_MUTEX_INITIALIZER;
241 static heim_base_once_t once;
242 static heim_dict_t dict = NULL;
243 heim_string_t s, s2;
244
245 heim_base_once_f(&once, &dict, init_string);
246 s = heim_string_create(_str);
247
248 HEIMDAL_MUTEX_lock(&mutex);
249 s2 = heim_dict_get_value(dict, s);
250 if (s2) {
251 heim_release(s);
252 s = s2;
253 } else {
254 _heim_make_permanent(s);
255 heim_dict_set_value(dict, s, s);
256 }
257 HEIMDAL_MUTEX_unlock(&mutex);
258
259 return s;
260 }