diff options
author | David Walter Seikel | 2013-01-13 17:29:19 +1000 |
---|---|---|
committer | David Walter Seikel | 2013-01-13 17:29:19 +1000 |
commit | 07274513e984f0b5544586c74508ccd16e7dcafa (patch) | |
tree | b32ff2a9136fbc1a4a6a0ed1e4d79cde0f5f16d9 /libraries/eet/src/lib/eet_dictionary.c | |
parent | Added Irrlicht 1.8, but without all the Windows binaries. (diff) | |
download | SledjHamr-07274513e984f0b5544586c74508ccd16e7dcafa.zip SledjHamr-07274513e984f0b5544586c74508ccd16e7dcafa.tar.gz SledjHamr-07274513e984f0b5544586c74508ccd16e7dcafa.tar.bz2 SledjHamr-07274513e984f0b5544586c74508ccd16e7dcafa.tar.xz |
Remove EFL, since it's been released now.
Diffstat (limited to '')
-rw-r--r-- | libraries/eet/src/lib/eet_dictionary.c | 444 |
1 files changed, 0 insertions, 444 deletions
diff --git a/libraries/eet/src/lib/eet_dictionary.c b/libraries/eet/src/lib/eet_dictionary.c deleted file mode 100644 index c79239b..0000000 --- a/libraries/eet/src/lib/eet_dictionary.c +++ /dev/null | |||
@@ -1,444 +0,0 @@ | |||
1 | #ifdef HAVE_CONFIG_H | ||
2 | # include <config.h> | ||
3 | #endif /* ifdef HAVE_CONFIG_H */ | ||
4 | |||
5 | #include <stdio.h> | ||
6 | #include <string.h> | ||
7 | #include <math.h> | ||
8 | |||
9 | #include <Eina.h> | ||
10 | |||
11 | #include "Eet.h" | ||
12 | #include "Eet_private.h" | ||
13 | |||
14 | Eet_Dictionary * | ||
15 | eet_dictionary_add(void) | ||
16 | { | ||
17 | Eet_Dictionary *new; | ||
18 | |||
19 | new = eet_dictionary_calloc(1); | ||
20 | if (!new) | ||
21 | return NULL; | ||
22 | |||
23 | memset(new->hash, -1, sizeof (int) * 256); | ||
24 | |||
25 | return new; | ||
26 | } | ||
27 | |||
28 | void | ||
29 | eet_dictionary_free(Eet_Dictionary *ed) | ||
30 | { | ||
31 | int i; | ||
32 | |||
33 | if (!ed) return; | ||
34 | |||
35 | for (i = 0; i < ed->count; ++i) | ||
36 | if (ed->all[i].allocated) | ||
37 | eina_stringshare_del(ed->all[i].str); | ||
38 | |||
39 | if (ed->all) | ||
40 | free(ed->all); | ||
41 | |||
42 | if (ed->converts) eina_hash_free(ed->converts); | ||
43 | |||
44 | eet_dictionary_mp_free(ed); | ||
45 | } | ||
46 | |||
47 | static int | ||
48 | _eet_dictionary_lookup(Eet_Dictionary *ed, | ||
49 | const char *string, | ||
50 | int len, | ||
51 | int hash) | ||
52 | { | ||
53 | Eina_Bool found = EINA_FALSE; | ||
54 | int prev = -1; | ||
55 | int current; | ||
56 | |||
57 | current = ed->hash[hash]; | ||
58 | |||
59 | while (current != -1) | ||
60 | { | ||
61 | if (ed->all[current].len == len) | ||
62 | { | ||
63 | if (ed->all[current].str && | ||
64 | (ed->all[current].str == string || strcmp(ed->all[current].str, string) == 0)) | ||
65 | { | ||
66 | found = EINA_TRUE; | ||
67 | break; | ||
68 | } | ||
69 | } | ||
70 | |||
71 | prev = current; | ||
72 | current = ed->all[current].next; | ||
73 | } | ||
74 | |||
75 | if (current == -1 && found) | ||
76 | return prev; | ||
77 | |||
78 | return current; | ||
79 | } | ||
80 | |||
81 | int | ||
82 | eet_dictionary_string_add(Eet_Dictionary *ed, | ||
83 | const char *string) | ||
84 | { | ||
85 | Eet_String *current; | ||
86 | const char *str; | ||
87 | int hash; | ||
88 | int idx; | ||
89 | int len; | ||
90 | |||
91 | if (!ed) | ||
92 | return -1; | ||
93 | |||
94 | hash = _eet_hash_gen(string, 8); | ||
95 | len = strlen(string) + 1; | ||
96 | |||
97 | idx = _eet_dictionary_lookup(ed, string, len, hash); | ||
98 | |||
99 | if (idx != -1) | ||
100 | { | ||
101 | if (ed->all[idx].str && (ed->all[idx].str == string || strcmp(ed->all[idx].str, string) == 0)) | ||
102 | return idx; | ||
103 | } | ||
104 | |||
105 | if (ed->total == ed->count) | ||
106 | { | ||
107 | Eet_String *new; | ||
108 | int total; | ||
109 | |||
110 | total = ed->total + 8; | ||
111 | |||
112 | new = realloc(ed->all, total * sizeof(Eet_String)); | ||
113 | if (!new) | ||
114 | return -1; | ||
115 | |||
116 | ed->all = new; | ||
117 | ed->total = total; | ||
118 | } | ||
119 | |||
120 | str = eina_stringshare_add(string); | ||
121 | if (!str) | ||
122 | return -1; | ||
123 | |||
124 | current = ed->all + ed->count; | ||
125 | |||
126 | current->allocated = EINA_TRUE; | ||
127 | |||
128 | current->hash = hash; | ||
129 | |||
130 | current->str = str; | ||
131 | current->len = len; | ||
132 | |||
133 | if (idx == -1) | ||
134 | { | ||
135 | current->next = ed->hash[hash]; | ||
136 | current->prev = -1; | ||
137 | ed->hash[hash] = ed->count; | ||
138 | } | ||
139 | else | ||
140 | { | ||
141 | current->next = idx; | ||
142 | current->prev = ed->all[idx].prev; | ||
143 | |||
144 | if (current->next != -1) | ||
145 | ed->all[current->next].prev = ed->count; | ||
146 | |||
147 | if (current->prev != -1) | ||
148 | ed->all[current->prev].next = ed->count; | ||
149 | else | ||
150 | ed->hash[hash] = ed->count; | ||
151 | } | ||
152 | |||
153 | return ed->count++; | ||
154 | } | ||
155 | |||
156 | int | ||
157 | eet_dictionary_string_get_size(const Eet_Dictionary *ed, | ||
158 | int idx) | ||
159 | { | ||
160 | if (!ed) | ||
161 | return 0; | ||
162 | |||
163 | if (idx < 0) | ||
164 | return 0; | ||
165 | |||
166 | if (idx < ed->count) | ||
167 | return ed->all[idx].len; | ||
168 | |||
169 | return 0; | ||
170 | } | ||
171 | |||
172 | EAPI int | ||
173 | eet_dictionary_count(const Eet_Dictionary *ed) | ||
174 | { | ||
175 | return ed->count; | ||
176 | } | ||
177 | |||
178 | int | ||
179 | eet_dictionary_string_get_hash(const Eet_Dictionary *ed, | ||
180 | int idx) | ||
181 | { | ||
182 | if (!ed) | ||
183 | return -1; | ||
184 | |||
185 | if (idx < 0) | ||
186 | return -1; | ||
187 | |||
188 | if (idx < ed->count) | ||
189 | return ed->all[idx].hash; | ||
190 | |||
191 | return -1; | ||
192 | } | ||
193 | |||
194 | const char * | ||
195 | eet_dictionary_string_get_char(const Eet_Dictionary *ed, | ||
196 | int idx) | ||
197 | { | ||
198 | if (!ed) | ||
199 | return NULL; | ||
200 | |||
201 | if (idx < 0) | ||
202 | return NULL; | ||
203 | |||
204 | if (idx < ed->count) | ||
205 | { | ||
206 | #ifdef _WIN32 | ||
207 | /* Windows file system could change the mmaped file when replacing a file. So we need to copy all string in memory to avoid bugs. */ | ||
208 | if (!ed->all[idx].allocated) | ||
209 | { | ||
210 | ed->all[idx].str = eina_stringshare_add(ed->all[idx].str); | ||
211 | ed->all[idx].allocated = EINA_TRUE; | ||
212 | } | ||
213 | #endif /* ifdef _WIN32 */ | ||
214 | return ed->all[idx].str; | ||
215 | } | ||
216 | |||
217 | return NULL; | ||
218 | } | ||
219 | |||
220 | static inline Eina_Bool | ||
221 | _eet_dictionary_string_get_me_cache(const char *s, | ||
222 | int len, | ||
223 | int *mantisse, | ||
224 | int *exponent) | ||
225 | { | ||
226 | if ((len == 6) && (s[0] == '0') && (s[1] == 'x') && (s[3] == 'p')) | ||
227 | { | ||
228 | *mantisse = (s[2] >= 'a') ? (s[2] - 'a' + 10) : (s[2] - '0'); | ||
229 | *exponent = (s[5] - '0'); | ||
230 | |||
231 | return EINA_TRUE; | ||
232 | } | ||
233 | |||
234 | return EINA_FALSE; | ||
235 | } | ||
236 | |||
237 | static inline Eina_Bool | ||
238 | _eet_dictionary_string_get_float_cache(const char *s, | ||
239 | int len, | ||
240 | float *result) | ||
241 | { | ||
242 | int mantisse; | ||
243 | int exponent; | ||
244 | |||
245 | if (_eet_dictionary_string_get_me_cache(s, len, &mantisse, &exponent)) | ||
246 | { | ||
247 | if (s[4] == '+') | ||
248 | *result = (float)(mantisse << exponent); | ||
249 | else | ||
250 | *result = (float)mantisse / (float)(1 << exponent); | ||
251 | |||
252 | return EINA_TRUE; | ||
253 | } | ||
254 | |||
255 | return EINA_FALSE; | ||
256 | } | ||
257 | |||
258 | static inline Eina_Bool | ||
259 | _eet_dictionary_string_get_double_cache(const char *s, | ||
260 | int len, | ||
261 | double *result) | ||
262 | { | ||
263 | int mantisse; | ||
264 | int exponent; | ||
265 | |||
266 | if (_eet_dictionary_string_get_me_cache(s, len, &mantisse, &exponent)) | ||
267 | { | ||
268 | if (s[4] == '+') | ||
269 | *result = (double)(mantisse << exponent); | ||
270 | else | ||
271 | *result = (double)mantisse / (float)(1 << exponent); | ||
272 | |||
273 | return EINA_TRUE; | ||
274 | } | ||
275 | |||
276 | return EINA_FALSE; | ||
277 | } | ||
278 | |||
279 | static inline Eina_Bool | ||
280 | _eet_dictionary_test(const Eet_Dictionary *ed, | ||
281 | int idx, | ||
282 | void *result) | ||
283 | { | ||
284 | if (!result) | ||
285 | return EINA_FALSE; | ||
286 | |||
287 | if (!ed) | ||
288 | return EINA_FALSE; | ||
289 | |||
290 | if (idx < 0) | ||
291 | return EINA_FALSE; | ||
292 | |||
293 | if (!(idx < ed->count)) | ||
294 | return EINA_FALSE; | ||
295 | |||
296 | return EINA_TRUE; | ||
297 | } | ||
298 | |||
299 | static Eet_Convert * | ||
300 | eet_dictionary_convert_get(const Eet_Dictionary *ed, | ||
301 | int idx, | ||
302 | const char **str) | ||
303 | { | ||
304 | Eet_Convert *result; | ||
305 | |||
306 | *str = ed->all[idx].str; | ||
307 | |||
308 | if (!ed->converts) | ||
309 | { | ||
310 | ((Eet_Dictionary *)ed)->converts = eina_hash_int32_new(free); | ||
311 | |||
312 | goto add_convert; | ||
313 | } | ||
314 | |||
315 | result = eina_hash_find(ed->converts, &idx); | ||
316 | if (result) return result; | ||
317 | |||
318 | add_convert: | ||
319 | result = calloc(1, sizeof (Eet_Convert)); | ||
320 | |||
321 | eina_hash_add(ed->converts, &idx, result); | ||
322 | return result; | ||
323 | } | ||
324 | |||
325 | Eina_Bool | ||
326 | eet_dictionary_string_get_float(const Eet_Dictionary *ed, | ||
327 | int idx, | ||
328 | float *result) | ||
329 | { | ||
330 | Eet_Convert *convert; | ||
331 | const char *str; | ||
332 | |||
333 | if (!_eet_dictionary_test(ed, idx, result)) | ||
334 | return EINA_FALSE; | ||
335 | |||
336 | convert = eet_dictionary_convert_get(ed, idx, &str); | ||
337 | if (!convert) return EINA_FALSE; | ||
338 | |||
339 | if (!(convert->type & EET_D_FLOAT)) | ||
340 | { | ||
341 | if (!_eet_dictionary_string_get_float_cache(str, ed->all[idx].len, | ||
342 | &convert->f)) | ||
343 | { | ||
344 | long long mantisse = 0; | ||
345 | long exponent = 0; | ||
346 | |||
347 | if (eina_convert_atod(str, ed->all[idx].len, &mantisse, | ||
348 | &exponent) == EINA_FALSE) | ||
349 | return EINA_FALSE; | ||
350 | |||
351 | convert->f = ldexpf((float)mantisse, exponent); | ||
352 | } | ||
353 | |||
354 | convert->type |= EET_D_FLOAT; | ||
355 | } | ||
356 | |||
357 | *result = convert->f; | ||
358 | return EINA_TRUE; | ||
359 | } | ||
360 | |||
361 | Eina_Bool | ||
362 | eet_dictionary_string_get_double(const Eet_Dictionary *ed, | ||
363 | int idx, | ||
364 | double *result) | ||
365 | { | ||
366 | Eet_Convert *convert; | ||
367 | const char *str; | ||
368 | |||
369 | if (!_eet_dictionary_test(ed, idx, result)) | ||
370 | return EINA_FALSE; | ||
371 | |||
372 | convert = eet_dictionary_convert_get(ed, idx, &str); | ||
373 | if (!convert) return EINA_FALSE; | ||
374 | |||
375 | if (!(convert->type & EET_D_DOUBLE)) | ||
376 | { | ||
377 | if (!_eet_dictionary_string_get_double_cache(str, ed->all[idx].len, | ||
378 | &convert->d)) | ||
379 | { | ||
380 | long long mantisse = 0; | ||
381 | long exponent = 0; | ||
382 | |||
383 | if (eina_convert_atod(str, ed->all[idx].len, &mantisse, | ||
384 | &exponent) == EINA_FALSE) | ||
385 | return EINA_FALSE; | ||
386 | |||
387 | convert->d = ldexp((double)mantisse, exponent); | ||
388 | } | ||
389 | |||
390 | convert->type |= EET_D_DOUBLE; | ||
391 | } | ||
392 | |||
393 | *result = convert->d; | ||
394 | return EINA_TRUE; | ||
395 | } | ||
396 | |||
397 | Eina_Bool | ||
398 | eet_dictionary_string_get_fp(const Eet_Dictionary *ed, | ||
399 | int idx, | ||
400 | Eina_F32p32 *result) | ||
401 | { | ||
402 | Eet_Convert *convert; | ||
403 | const char *str; | ||
404 | |||
405 | if (!_eet_dictionary_test(ed, idx, result)) | ||
406 | return EINA_FALSE; | ||
407 | |||
408 | convert = eet_dictionary_convert_get(ed, idx, &str); | ||
409 | if (!convert) return EINA_FALSE; | ||
410 | |||
411 | if (!(convert->type & EET_D_FIXED_POINT)) | ||
412 | { | ||
413 | Eina_F32p32 fp; | ||
414 | |||
415 | if (!eina_convert_atofp(str, ed->all[idx].len, &fp)) | ||
416 | return EINA_FALSE; | ||
417 | |||
418 | convert->fp = fp; | ||
419 | convert->type |= EET_D_FIXED_POINT; | ||
420 | } | ||
421 | |||
422 | *result = convert->fp; | ||
423 | return EINA_TRUE; | ||
424 | } | ||
425 | |||
426 | EAPI int | ||
427 | eet_dictionary_string_check(Eet_Dictionary *ed, | ||
428 | const char *string) | ||
429 | { | ||
430 | int i; | ||
431 | |||
432 | if ((!ed) || (!string)) | ||
433 | return 0; | ||
434 | |||
435 | if ((ed->start <= string) && (string < ed->end)) | ||
436 | return 1; | ||
437 | |||
438 | for (i = 0; i < ed->count; ++i) | ||
439 | if ((ed->all[i].allocated) && ed->all[i].str == string) | ||
440 | return 1; | ||
441 | |||
442 | return 0; | ||
443 | } | ||
444 | |||