diff options
Diffstat (limited to '')
-rw-r--r-- | libraries/eet/src/lib/eet_node.c | 797 |
1 files changed, 0 insertions, 797 deletions
diff --git a/libraries/eet/src/lib/eet_node.c b/libraries/eet/src/lib/eet_node.c deleted file mode 100644 index 11d7cc0..0000000 --- a/libraries/eet/src/lib/eet_node.c +++ /dev/null | |||
@@ -1,797 +0,0 @@ | |||
1 | #ifdef HAVE_CONFIG_H | ||
2 | # include <config.h> | ||
3 | #endif /* ifdef HAVE_CONFIG_H */ | ||
4 | |||
5 | #include <string.h> | ||
6 | #include <stdio.h> | ||
7 | |||
8 | #ifdef HAVE_EVIL | ||
9 | # include <Evil.h> | ||
10 | #endif /* ifdef HAVE_EVIL */ | ||
11 | |||
12 | #include <Eina.h> | ||
13 | |||
14 | #include "Eet.h" | ||
15 | #include "Eet_private.h" | ||
16 | |||
17 | static Eina_Mempool *_eet_node_mp = NULL; | ||
18 | |||
19 | Eet_Node * | ||
20 | eet_node_new(void) | ||
21 | { | ||
22 | Eet_Node *result; | ||
23 | |||
24 | result = eina_mempool_malloc(_eet_node_mp, sizeof (Eet_Node)); | ||
25 | if (!result) | ||
26 | return NULL; | ||
27 | |||
28 | memset(result, 0, sizeof (Eet_Node)); | ||
29 | return result; | ||
30 | } | ||
31 | |||
32 | void | ||
33 | eet_node_free(Eet_Node *node) | ||
34 | { | ||
35 | eina_mempool_free(_eet_node_mp, node); | ||
36 | } | ||
37 | |||
38 | static Eet_Node * | ||
39 | _eet_node_new(const char *name, | ||
40 | int type) | ||
41 | { | ||
42 | Eet_Node *n; | ||
43 | |||
44 | n = eet_node_new(); | ||
45 | if (!n) | ||
46 | return NULL; | ||
47 | |||
48 | n->type = type; | ||
49 | n->name = eina_stringshare_add(name); | ||
50 | |||
51 | return n; | ||
52 | } | ||
53 | |||
54 | static void | ||
55 | _eet_node_append(Eet_Node *n, | ||
56 | Eina_List *nodes) | ||
57 | { | ||
58 | Eet_Node *value; | ||
59 | Eina_List *l; | ||
60 | |||
61 | EINA_LIST_REVERSE_FOREACH(nodes, l, value) | ||
62 | { | ||
63 | value->next = n->values; | ||
64 | n->values = value; | ||
65 | } | ||
66 | } | ||
67 | |||
68 | #define EET_NODE_NEW(Eet_type, Name, Value, Type) \ | ||
69 | EAPI Eet_Node * \ | ||
70 | eet_node_ ## Name ## _new(const char *name, Type Value) \ | ||
71 | { \ | ||
72 | Eet_Node *n; \ | ||
73 | \ | ||
74 | n = _eet_node_new(name, Eet_type); \ | ||
75 | if (!n) { return NULL; } \ | ||
76 | \ | ||
77 | n->data.value.Value = Value; \ | ||
78 | \ | ||
79 | return n; \ | ||
80 | } | ||
81 | |||
82 | #define EET_NODE_STR_NEW(Eet_type, Name, Value, Type) \ | ||
83 | EAPI Eet_Node * \ | ||
84 | eet_node_ ## Name ## _new(const char *name, Type Value) \ | ||
85 | { \ | ||
86 | Eet_Node *n; \ | ||
87 | \ | ||
88 | n = _eet_node_new(name, Eet_type); \ | ||
89 | if (!n) { return NULL; } \ | ||
90 | \ | ||
91 | n->data.value.Value = eina_stringshare_add(Value); \ | ||
92 | \ | ||
93 | return n; \ | ||
94 | } | ||
95 | |||
96 | EET_NODE_NEW(EET_T_CHAR, char, c, char) | ||
97 | EET_NODE_NEW(EET_T_SHORT, short, s, short) | ||
98 | EET_NODE_NEW(EET_T_INT, int, i, int) | ||
99 | EET_NODE_NEW(EET_T_LONG_LONG, long_long, l, long long) | ||
100 | EET_NODE_NEW(EET_T_FLOAT, float, f, float) | ||
101 | EET_NODE_NEW(EET_T_DOUBLE, double, d, double) | ||
102 | EET_NODE_NEW(EET_T_UCHAR, unsigned_char, uc, unsigned char) | ||
103 | EET_NODE_NEW(EET_T_USHORT, unsigned_short, us, unsigned short) | ||
104 | EET_NODE_NEW(EET_T_UINT, unsigned_int, ui, unsigned int) | ||
105 | EET_NODE_NEW(EET_T_ULONG_LONG, unsigned_long_long, ul, unsigned long long) | ||
106 | EET_NODE_STR_NEW(EET_T_STRING, string, str, const char *) | ||
107 | EET_NODE_STR_NEW(EET_T_INLINED_STRING, inlined_string, str, const char *) | ||
108 | |||
109 | Eet_Node * | ||
110 | eet_node_null_new(const char *name) | ||
111 | { | ||
112 | Eet_Node *n; | ||
113 | |||
114 | n = _eet_node_new(name, EET_T_NULL); | ||
115 | if (!n) | ||
116 | return NULL; | ||
117 | |||
118 | n->data.value.str = NULL; | ||
119 | |||
120 | return n; | ||
121 | } | ||
122 | |||
123 | Eet_Node * | ||
124 | eet_node_list_new(const char *name, | ||
125 | Eina_List *nodes) | ||
126 | { | ||
127 | Eet_Node *n; | ||
128 | |||
129 | n = _eet_node_new(name, EET_G_LIST); | ||
130 | if (!n) | ||
131 | return NULL; | ||
132 | |||
133 | _eet_node_append(n, nodes); | ||
134 | |||
135 | return n; | ||
136 | } | ||
137 | |||
138 | Eet_Node * | ||
139 | eet_node_array_new(const char *name, | ||
140 | int count, | ||
141 | Eina_List *nodes) | ||
142 | { | ||
143 | Eet_Node *n; | ||
144 | |||
145 | n = _eet_node_new(name, EET_G_ARRAY); | ||
146 | if (!n) | ||
147 | return NULL; | ||
148 | |||
149 | n->count = count; | ||
150 | |||
151 | _eet_node_append(n, nodes); | ||
152 | |||
153 | return n; | ||
154 | } | ||
155 | |||
156 | Eet_Node * | ||
157 | eet_node_var_array_new(const char *name, | ||
158 | Eina_List *nodes) | ||
159 | { | ||
160 | Eet_Node *n; | ||
161 | |||
162 | n = _eet_node_new(name, EET_G_VAR_ARRAY); | ||
163 | if (!n) | ||
164 | return NULL; | ||
165 | |||
166 | n->count = eina_list_count(nodes); | ||
167 | |||
168 | _eet_node_append(n, nodes); | ||
169 | |||
170 | return n; | ||
171 | } | ||
172 | |||
173 | Eet_Node * | ||
174 | eet_node_hash_new(const char *name, | ||
175 | const char *key, | ||
176 | Eet_Node *node) | ||
177 | { | ||
178 | Eina_List *nodes; | ||
179 | Eet_Node *n; | ||
180 | |||
181 | if (!node) | ||
182 | return NULL; | ||
183 | |||
184 | n = _eet_node_new(name, EET_G_HASH); | ||
185 | if (!n) | ||
186 | return NULL; | ||
187 | |||
188 | n->key = eina_stringshare_add(key); | ||
189 | nodes = eina_list_append(NULL, node); | ||
190 | |||
191 | _eet_node_append(n, nodes); | ||
192 | |||
193 | return n; | ||
194 | } | ||
195 | |||
196 | Eet_Node * | ||
197 | eet_node_struct_new(const char *name, | ||
198 | Eina_List *nodes) | ||
199 | { | ||
200 | Eet_Node *n; | ||
201 | |||
202 | n = _eet_node_new(name, EET_G_UNKNOWN); | ||
203 | if (!n) | ||
204 | return NULL; | ||
205 | |||
206 | _eet_node_append(n, nodes); | ||
207 | |||
208 | return n; | ||
209 | } | ||
210 | |||
211 | Eet_Node * | ||
212 | eet_node_struct_child_new(const char *parent, | ||
213 | Eet_Node *child) | ||
214 | { | ||
215 | Eet_Node *n; | ||
216 | |||
217 | if (!child) return NULL; | ||
218 | |||
219 | if (child->type != EET_G_UNKNOWN) | ||
220 | return child; | ||
221 | |||
222 | n = _eet_node_new(parent, EET_G_UNKNOWN); | ||
223 | if (!n) | ||
224 | return NULL; | ||
225 | |||
226 | _eet_node_append(n, eina_list_prepend(NULL, child)); | ||
227 | |||
228 | return n; | ||
229 | } | ||
230 | |||
231 | Eet_Node * | ||
232 | eet_node_children_get(Eet_Node *node) | ||
233 | { | ||
234 | if (!node) return NULL; | ||
235 | return node->values; | ||
236 | } | ||
237 | |||
238 | Eet_Node * | ||
239 | eet_node_next_get(Eet_Node *node) | ||
240 | { | ||
241 | if (!node) return NULL; | ||
242 | return node->next; | ||
243 | } | ||
244 | |||
245 | Eet_Node * | ||
246 | eet_node_parent_get(Eet_Node *node) | ||
247 | { | ||
248 | if (!node) return NULL; | ||
249 | return node->parent; | ||
250 | } | ||
251 | |||
252 | void | ||
253 | eet_node_list_append(Eet_Node *parent, | ||
254 | const char *name, | ||
255 | Eet_Node *child) | ||
256 | { | ||
257 | const char *tmp; | ||
258 | Eet_Node *nn; | ||
259 | |||
260 | if ((!parent) || (!child)) return; | ||
261 | tmp = eina_stringshare_add(name); | ||
262 | |||
263 | for (nn = parent->values; nn; nn = nn->next) | ||
264 | if (nn->name == tmp && nn->type == EET_G_LIST) | ||
265 | { | ||
266 | Eet_Node *n; | ||
267 | |||
268 | if (!nn->values) | ||
269 | nn->values = child; | ||
270 | else | ||
271 | { | ||
272 | for (n = nn->values; n->next; n = n->next) | ||
273 | ; | ||
274 | n->next = child; | ||
275 | } | ||
276 | |||
277 | child->next = NULL; | ||
278 | |||
279 | eina_stringshare_del(tmp); | ||
280 | |||
281 | return; | ||
282 | } | ||
283 | |||
284 | /* No list found, so create it. */ | ||
285 | nn = eet_node_list_new(tmp, eina_list_append(NULL, child)); | ||
286 | |||
287 | /* And add it to the parent. */ | ||
288 | nn->next = parent->values; | ||
289 | parent->values = nn; | ||
290 | |||
291 | eina_stringshare_del(tmp); | ||
292 | } | ||
293 | |||
294 | void | ||
295 | eet_node_struct_append(Eet_Node *parent, | ||
296 | const char *name, | ||
297 | Eet_Node *child) | ||
298 | { | ||
299 | const char *tmp; | ||
300 | Eet_Node *prev; | ||
301 | Eet_Node *nn; | ||
302 | |||
303 | if ((!parent) || (!child)) return; | ||
304 | if (parent->type != EET_G_UNKNOWN) | ||
305 | { | ||
306 | ERR("[%s] is not a structure. Will not insert [%s] in it", | ||
307 | parent->name, | ||
308 | name); | ||
309 | eet_node_del(child); | ||
310 | return; | ||
311 | } | ||
312 | |||
313 | tmp = eina_stringshare_add(name); | ||
314 | |||
315 | for (prev = NULL, nn = parent->values; nn; prev = nn, nn = nn->next) | ||
316 | if (nn->name == tmp && nn->type == child->type) | ||
317 | { | ||
318 | if (prev) | ||
319 | prev->next = nn->next; | ||
320 | else | ||
321 | parent->values = nn->next; | ||
322 | |||
323 | nn->next = NULL; | ||
324 | eet_node_del(nn); | ||
325 | |||
326 | break; | ||
327 | } | ||
328 | |||
329 | if (prev) | ||
330 | { | ||
331 | prev->next = child; | ||
332 | child->next = NULL; | ||
333 | } | ||
334 | else | ||
335 | { | ||
336 | child->next = NULL; | ||
337 | parent->values = child; | ||
338 | } | ||
339 | |||
340 | eina_stringshare_del(tmp); | ||
341 | } | ||
342 | |||
343 | void | ||
344 | eet_node_hash_add(Eet_Node *parent, | ||
345 | const char *name, | ||
346 | const char *key, | ||
347 | Eet_Node *child) | ||
348 | { | ||
349 | Eet_Node *nn; | ||
350 | |||
351 | if ((!parent) || (!child)) return; | ||
352 | |||
353 | /* No list found, so create it. */ | ||
354 | nn = eet_node_hash_new(name, key, child); | ||
355 | |||
356 | /* And add it to the parent. */ | ||
357 | nn->next = parent->values; | ||
358 | parent->values = nn; | ||
359 | } | ||
360 | |||
361 | int | ||
362 | eet_node_type_get(Eet_Node *node) | ||
363 | { | ||
364 | if (!node) return EET_T_UNKNOW; | ||
365 | return node->type; | ||
366 | } | ||
367 | |||
368 | Eet_Node_Data * | ||
369 | eet_node_value_get(Eet_Node *node) | ||
370 | { | ||
371 | if (!node) return NULL; | ||
372 | return &node->data; | ||
373 | } | ||
374 | |||
375 | const char * | ||
376 | eet_node_name_get(Eet_Node *node) | ||
377 | { | ||
378 | if (!node) return NULL; | ||
379 | return node->name; | ||
380 | } | ||
381 | |||
382 | void | ||
383 | eet_node_del(Eet_Node *n) | ||
384 | { | ||
385 | Eet_Node *nn; | ||
386 | Eet_Node *tmp; | ||
387 | |||
388 | if (!n) | ||
389 | return; | ||
390 | |||
391 | switch (n->type) | ||
392 | { | ||
393 | case EET_G_HASH: | ||
394 | eina_stringshare_del(n->key); | ||
395 | |||
396 | case EET_G_UNKNOWN: | ||
397 | case EET_G_VAR_ARRAY: | ||
398 | case EET_G_ARRAY: | ||
399 | case EET_G_LIST: | ||
400 | for (nn = n->values; nn; ) | ||
401 | { | ||
402 | tmp = nn; | ||
403 | nn = nn->next; | ||
404 | eet_node_del(tmp); | ||
405 | } | ||
406 | break; | ||
407 | |||
408 | case EET_T_STRING: | ||
409 | case EET_T_INLINED_STRING: | ||
410 | eina_stringshare_del(n->data.value.str); | ||
411 | break; | ||
412 | |||
413 | case EET_T_CHAR: | ||
414 | case EET_T_SHORT: | ||
415 | case EET_T_INT: | ||
416 | case EET_T_LONG_LONG: | ||
417 | case EET_T_FLOAT: | ||
418 | case EET_T_DOUBLE: | ||
419 | case EET_T_UCHAR: | ||
420 | case EET_T_USHORT: | ||
421 | case EET_T_UINT: | ||
422 | break; | ||
423 | } | ||
424 | |||
425 | eina_stringshare_del(n->name); | ||
426 | eet_node_free(n); | ||
427 | } | ||
428 | |||
429 | static const char *eet_node_dump_g_name[6] = { | ||
430 | "struct", | ||
431 | "array", | ||
432 | "var_array", | ||
433 | "list", | ||
434 | "hash", | ||
435 | "???" | ||
436 | }; | ||
437 | |||
438 | static const char *eet_node_dump_t_name[14][2] = { | ||
439 | { "???: ", "???" }, | ||
440 | { "char: ", "%hhi" }, | ||
441 | { "short: ", "%hi" }, | ||
442 | { "int: ", "%i" }, | ||
443 | { "long_long: ", "%lli" }, | ||
444 | { "float: ", "%1.25f" }, | ||
445 | { "double: ", "%1.25f" }, | ||
446 | { "uchar: ", "%hhu" }, | ||
447 | { "ushort: ", "%i" }, | ||
448 | { "uint: ", "%u" }, | ||
449 | { "ulong_long: ", "%llu" }, | ||
450 | { "null", "" } | ||
451 | }; | ||
452 | |||
453 | static void | ||
454 | eet_node_dump_level(int level, | ||
455 | Eet_Dump_Callback dumpfunc, | ||
456 | void *dumpdata) | ||
457 | { | ||
458 | int i; | ||
459 | |||
460 | for (i = 0; i < level; i++) dumpfunc(dumpdata, " "); | ||
461 | } | ||
462 | |||
463 | static char * | ||
464 | eet_node_string_escape(const char *str) | ||
465 | { | ||
466 | char *s, *sp; | ||
467 | const char *strp; | ||
468 | int sz = 0; | ||
469 | |||
470 | for (strp = str; *strp; strp++) | ||
471 | { | ||
472 | if (*strp == '\"') | ||
473 | sz += 2; | ||
474 | else if (*strp == '\\') | ||
475 | sz += 2; | ||
476 | else if (*strp == '\n') | ||
477 | sz += 2; | ||
478 | else | ||
479 | sz += 1; | ||
480 | } | ||
481 | s = malloc(sz + 1); | ||
482 | if (!s) | ||
483 | return NULL; | ||
484 | |||
485 | for (strp = str, sp = s; *strp; strp++, sp++) | ||
486 | { | ||
487 | if (*strp == '\"' | ||
488 | || *strp == '\\' | ||
489 | || *strp == '\n') | ||
490 | { | ||
491 | *sp = '\\'; | ||
492 | sp++; | ||
493 | } | ||
494 | |||
495 | if (*strp == '\n') | ||
496 | *sp = 'n'; | ||
497 | else | ||
498 | *sp = *strp; | ||
499 | } | ||
500 | *sp = 0; | ||
501 | return s; | ||
502 | } | ||
503 | |||
504 | static void | ||
505 | eet_node_dump_string_escape(void *dumpdata, | ||
506 | Eet_Dump_Callback dumpfunc, | ||
507 | const char *str) | ||
508 | { | ||
509 | char *s; | ||
510 | |||
511 | s = eet_node_string_escape(str); | ||
512 | if (!s) | ||
513 | return; | ||
514 | |||
515 | dumpfunc(dumpdata, s); | ||
516 | free(s); | ||
517 | } | ||
518 | |||
519 | static void | ||
520 | eet_node_dump_simple_type(Eet_Node *n, | ||
521 | int level, | ||
522 | Eet_Dump_Callback dumpfunc, | ||
523 | void *dumpdata) | ||
524 | { | ||
525 | const char *type_name = NULL; | ||
526 | char tbuf[256]; | ||
527 | |||
528 | eet_node_dump_level(level, dumpfunc, dumpdata); | ||
529 | dumpfunc(dumpdata, "value \""); | ||
530 | eet_node_dump_string_escape(dumpdata, dumpfunc, n->name); | ||
531 | dumpfunc(dumpdata, "\" "); | ||
532 | |||
533 | #ifdef EET_T_TYPE | ||
534 | # undef EET_T_TYPE | ||
535 | #endif /* ifdef EET_T_TYPE */ | ||
536 | |||
537 | #define EET_T_TYPE(Eet_Type, Type) \ | ||
538 | case Eet_Type: \ | ||
539 | { \ | ||
540 | dumpfunc(dumpdata, eet_node_dump_t_name[Eet_Type][0]); \ | ||
541 | snprintf(tbuf, \ | ||
542 | sizeof (tbuf), \ | ||
543 | eet_node_dump_t_name[Eet_Type][1], \ | ||
544 | n->data.value.Type); \ | ||
545 | dumpfunc(dumpdata, tbuf); \ | ||
546 | break; \ | ||
547 | } | ||
548 | |||
549 | switch (n->type) | ||
550 | { | ||
551 | EET_T_TYPE(EET_T_CHAR, c); | ||
552 | EET_T_TYPE(EET_T_SHORT, s); | ||
553 | EET_T_TYPE(EET_T_INT, i); | ||
554 | EET_T_TYPE(EET_T_LONG_LONG, l); | ||
555 | EET_T_TYPE(EET_T_FLOAT, f); | ||
556 | EET_T_TYPE(EET_T_DOUBLE, d); | ||
557 | EET_T_TYPE(EET_T_UCHAR, uc); | ||
558 | EET_T_TYPE(EET_T_USHORT, us); | ||
559 | EET_T_TYPE(EET_T_UINT, ui); | ||
560 | EET_T_TYPE(EET_T_ULONG_LONG, ul); | ||
561 | |||
562 | case EET_T_INLINED_STRING: | ||
563 | type_name = "inlined: \""; | ||
564 | |||
565 | case EET_T_STRING: | ||
566 | if (!type_name) | ||
567 | type_name = "string: \""; | ||
568 | |||
569 | dumpfunc(dumpdata, type_name); | ||
570 | eet_node_dump_string_escape(dumpdata, dumpfunc, n->data.value.str); | ||
571 | dumpfunc(dumpdata, "\""); | ||
572 | break; | ||
573 | |||
574 | case EET_T_NULL: | ||
575 | dumpfunc(dumpdata, "null"); | ||
576 | break; | ||
577 | |||
578 | default: | ||
579 | dumpfunc(dumpdata, "???: ???"); | ||
580 | break; | ||
581 | } | ||
582 | |||
583 | dumpfunc(dumpdata, ";\n"); | ||
584 | } | ||
585 | |||
586 | static void | ||
587 | eet_node_dump_group_start(int level, | ||
588 | Eet_Dump_Callback dumpfunc, | ||
589 | void *dumpdata, | ||
590 | int group_type, | ||
591 | const char *name) | ||
592 | { | ||
593 | int chnk_type; | ||
594 | |||
595 | chnk_type = (group_type >= EET_G_UNKNOWN && group_type <= EET_G_HASH) ? | ||
596 | group_type : EET_G_LAST; | ||
597 | |||
598 | eet_node_dump_level(level, dumpfunc, dumpdata); | ||
599 | dumpfunc(dumpdata, "group \""); | ||
600 | eet_node_dump_string_escape(dumpdata, dumpfunc, name); | ||
601 | dumpfunc(dumpdata, "\" "); | ||
602 | |||
603 | dumpfunc(dumpdata, eet_node_dump_g_name[chnk_type - EET_G_UNKNOWN]); | ||
604 | dumpfunc(dumpdata, " {\n"); | ||
605 | } | ||
606 | |||
607 | static void | ||
608 | eet_node_dump_group_end(int level, | ||
609 | Eet_Dump_Callback dumpfunc, | ||
610 | void *dumpdata) | ||
611 | { | ||
612 | eet_node_dump_level(level, dumpfunc, dumpdata); | ||
613 | dumpfunc(dumpdata, "}\n"); | ||
614 | } | ||
615 | |||
616 | void | ||
617 | eet_node_dump(Eet_Node *n, | ||
618 | int dumplevel, | ||
619 | Eet_Dump_Callback dumpfunc, | ||
620 | void *dumpdata) | ||
621 | { | ||
622 | Eet_Node *it; | ||
623 | |||
624 | if (!n) | ||
625 | return; | ||
626 | |||
627 | switch (n->type) | ||
628 | { | ||
629 | case EET_G_VAR_ARRAY: | ||
630 | case EET_G_ARRAY: | ||
631 | case EET_G_UNKNOWN: | ||
632 | case EET_G_HASH: | ||
633 | case EET_G_LIST: | ||
634 | eet_node_dump_group_start(dumplevel, | ||
635 | dumpfunc, | ||
636 | dumpdata, | ||
637 | n->type, | ||
638 | n->name); | ||
639 | |||
640 | if (n->type == EET_G_VAR_ARRAY | ||
641 | || n->type == EET_G_ARRAY) | ||
642 | { | ||
643 | char tbuf[256]; | ||
644 | |||
645 | eet_node_dump_level(dumplevel, dumpfunc, dumpdata); | ||
646 | dumpfunc(dumpdata, " count "); | ||
647 | eina_convert_itoa(n->count, tbuf); | ||
648 | dumpfunc(dumpdata, tbuf); | ||
649 | dumpfunc(dumpdata, ";\n"); | ||
650 | } | ||
651 | else if (n->type == EET_G_HASH) | ||
652 | { | ||
653 | eet_node_dump_level(dumplevel, dumpfunc, dumpdata); | ||
654 | dumpfunc(dumpdata, " key \""); | ||
655 | eet_node_dump_string_escape(dumpdata, dumpfunc, n->key); | ||
656 | dumpfunc(dumpdata, "\";\n"); | ||
657 | } | ||
658 | |||
659 | for (it = n->values; it; it = it->next) | ||
660 | eet_node_dump(it, dumplevel + 2, dumpfunc, dumpdata); | ||
661 | |||
662 | eet_node_dump_group_end(dumplevel, dumpfunc, dumpdata); | ||
663 | break; | ||
664 | |||
665 | case EET_T_STRING: | ||
666 | case EET_T_INLINED_STRING: | ||
667 | case EET_T_CHAR: | ||
668 | case EET_T_SHORT: | ||
669 | case EET_T_INT: | ||
670 | case EET_T_LONG_LONG: | ||
671 | case EET_T_FLOAT: | ||
672 | case EET_T_DOUBLE: | ||
673 | case EET_T_UCHAR: | ||
674 | case EET_T_USHORT: | ||
675 | case EET_T_UINT: | ||
676 | case EET_T_ULONG_LONG: | ||
677 | eet_node_dump_simple_type(n, dumplevel, dumpfunc, dumpdata); | ||
678 | break; | ||
679 | } | ||
680 | } | ||
681 | |||
682 | void * | ||
683 | eet_node_walk(void *parent, | ||
684 | const char *name, | ||
685 | Eet_Node *root, | ||
686 | Eet_Node_Walk *cb, | ||
687 | void *user_data) | ||
688 | { | ||
689 | Eet_Node *it; | ||
690 | void *me = NULL; | ||
691 | int i; | ||
692 | |||
693 | if (!root) | ||
694 | { | ||
695 | if (parent) | ||
696 | cb->struct_add(parent, name, NULL, user_data); | ||
697 | |||
698 | return NULL; | ||
699 | } | ||
700 | |||
701 | switch (root->type) | ||
702 | { | ||
703 | case EET_G_UNKNOWN: | ||
704 | me = cb->struct_alloc(root->name, user_data); | ||
705 | |||
706 | for (it = root->values; it; it = it->next) | ||
707 | eet_node_walk(me, it->name, it, cb, user_data); | ||
708 | |||
709 | break; | ||
710 | |||
711 | case EET_G_VAR_ARRAY: | ||
712 | case EET_G_ARRAY: | ||
713 | me = cb->array(root->type == EET_G_VAR_ARRAY ? EINA_TRUE : EINA_FALSE, | ||
714 | root->name, root->count, user_data); | ||
715 | |||
716 | for (i = 0, it = root->values; it; it = it->next) | ||
717 | cb->insert(me, i++, eet_node_walk(NULL, | ||
718 | NULL, | ||
719 | it, | ||
720 | cb, | ||
721 | user_data), user_data); | ||
722 | |||
723 | break; | ||
724 | |||
725 | case EET_G_LIST: | ||
726 | me = cb->list(root->name, user_data); | ||
727 | |||
728 | for (it = root->values; it; it = it->next) | ||
729 | cb->append(me, eet_node_walk(NULL, | ||
730 | NULL, | ||
731 | it, | ||
732 | cb, | ||
733 | user_data), user_data); | ||
734 | |||
735 | break; | ||
736 | |||
737 | case EET_G_HASH: | ||
738 | if (!parent) | ||
739 | return NULL; | ||
740 | |||
741 | return cb->hash(parent, root->name, root->key, | ||
742 | eet_node_walk(NULL, | ||
743 | NULL, | ||
744 | root->values, | ||
745 | cb, | ||
746 | user_data), user_data); | ||
747 | |||
748 | case EET_T_STRING: | ||
749 | case EET_T_INLINED_STRING: | ||
750 | case EET_T_CHAR: | ||
751 | case EET_T_SHORT: | ||
752 | case EET_T_INT: | ||
753 | case EET_T_LONG_LONG: | ||
754 | case EET_T_FLOAT: | ||
755 | case EET_T_DOUBLE: | ||
756 | case EET_T_UCHAR: | ||
757 | case EET_T_USHORT: | ||
758 | case EET_T_UINT: | ||
759 | case EET_T_ULONG_LONG: | ||
760 | me = cb->simple(root->type, &root->data, user_data); | ||
761 | break; | ||
762 | } | ||
763 | |||
764 | if (parent) | ||
765 | cb->struct_add(parent, name, me, user_data); | ||
766 | |||
767 | return me; | ||
768 | } | ||
769 | |||
770 | int | ||
771 | eet_node_init(void) | ||
772 | { | ||
773 | const char *choice; | ||
774 | const char *tmp; | ||
775 | |||
776 | #ifdef EINA_DEFAULT_MEMPOOL | ||
777 | choice = "pass_through"; | ||
778 | #else | ||
779 | choice = "chained_mempool"; | ||
780 | #endif | ||
781 | tmp = getenv("EINA_MEMPOOL"); | ||
782 | if (tmp && tmp[0]) | ||
783 | choice = tmp; | ||
784 | |||
785 | _eet_node_mp = | ||
786 | eina_mempool_add(choice, "eet-node-alloc", NULL, sizeof(Eet_Node), 1024); | ||
787 | |||
788 | return _eet_node_mp ? 1 : 0; | ||
789 | } | ||
790 | |||
791 | void | ||
792 | eet_node_shutdown(void) | ||
793 | { | ||
794 | eina_mempool_del(_eet_node_mp); | ||
795 | _eet_node_mp = NULL; | ||
796 | } | ||
797 | |||