2009-08-23 02:36:43 -07:00
|
|
|
/*
|
|
|
|
* vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include <config.h>
|
|
|
|
#endif
|
|
|
|
|
2009-04-16 05:42:03 -07:00
|
|
|
#include <stdio.h>
|
2009-08-23 02:36:43 -07:00
|
|
|
|
2009-04-16 05:42:03 -07:00
|
|
|
#include <Eina.h>
|
|
|
|
|
|
|
|
#include "Eet.h"
|
|
|
|
#include "Eet_private.h"
|
|
|
|
|
|
|
|
static Eet_Node *
|
|
|
|
_eet_node_new(const char *name, int type)
|
|
|
|
{
|
|
|
|
Eet_Node *n;
|
|
|
|
|
|
|
|
n = calloc(1, sizeof (Eet_Node));
|
|
|
|
if (!n) return NULL;
|
|
|
|
|
|
|
|
n->type = type;
|
|
|
|
n->name = eina_stringshare_add(name);
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eet_node_append(Eet_Node *n, Eina_List *nodes)
|
|
|
|
{
|
|
|
|
Eet_Node *value;
|
|
|
|
Eina_List *l;
|
|
|
|
|
|
|
|
EINA_LIST_REVERSE_FOREACH(nodes, l, value)
|
|
|
|
{
|
|
|
|
value->next = n->values;
|
|
|
|
n->values = value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#define EET_NODE_NEW(Eet_type, Name, Value, Type) \
|
|
|
|
EAPI Eet_Node * \
|
|
|
|
eet_node_##Name##_new(const char *name, Type Value) \
|
|
|
|
{ \
|
|
|
|
Eet_Node *n; \
|
|
|
|
\
|
|
|
|
n = _eet_node_new(name, Eet_type); \
|
|
|
|
if (!n) return NULL; \
|
|
|
|
\
|
|
|
|
n->data.Value = Value; \
|
|
|
|
\
|
|
|
|
return n; \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define EET_NODE_STR_NEW(Eet_type, Name, Value, Type) \
|
|
|
|
EAPI Eet_Node * \
|
|
|
|
eet_node_##Name##_new(const char *name, Type Value) \
|
|
|
|
{ \
|
|
|
|
Eet_Node *n; \
|
|
|
|
\
|
|
|
|
n = _eet_node_new(name, Eet_type); \
|
|
|
|
if (!n) return NULL; \
|
|
|
|
\
|
|
|
|
n->data.Value = eina_stringshare_add(Value); \
|
|
|
|
\
|
|
|
|
return n; \
|
|
|
|
}
|
|
|
|
|
2009-06-24 05:56:16 -07:00
|
|
|
EET_NODE_NEW(EET_T_CHAR, char, c, char)
|
|
|
|
EET_NODE_NEW(EET_T_SHORT, short, s, short)
|
|
|
|
EET_NODE_NEW(EET_T_INT, int, i, int)
|
|
|
|
EET_NODE_NEW(EET_T_LONG_LONG, long_long, l, long long)
|
|
|
|
EET_NODE_NEW(EET_T_FLOAT, float, f, float)
|
|
|
|
EET_NODE_NEW(EET_T_DOUBLE, double, d, double)
|
|
|
|
EET_NODE_NEW(EET_T_UCHAR, unsigned_char, uc, unsigned char)
|
|
|
|
EET_NODE_NEW(EET_T_USHORT, unsigned_short, us, unsigned short)
|
|
|
|
EET_NODE_NEW(EET_T_UINT, unsigned_int, ui, unsigned int)
|
|
|
|
EET_NODE_NEW(EET_T_ULONG_LONG, unsigned_long_long, ul, unsigned long long)
|
|
|
|
EET_NODE_STR_NEW(EET_T_STRING, string, str, const char *)
|
|
|
|
EET_NODE_STR_NEW(EET_T_INLINED_STRING, inlined_string, str, const char *)
|
2009-04-16 05:42:03 -07:00
|
|
|
|
|
|
|
Eet_Node *
|
|
|
|
eet_node_null_new(const char *name)
|
|
|
|
{
|
|
|
|
Eet_Node *n;
|
|
|
|
|
|
|
|
n = _eet_node_new(name, EET_T_NULL);
|
|
|
|
if (!n) return NULL;
|
|
|
|
|
|
|
|
n->data.str = NULL;
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
Eet_Node *
|
|
|
|
eet_node_list_new(const char *name, Eina_List *nodes)
|
|
|
|
{
|
|
|
|
Eet_Node *n;
|
|
|
|
|
|
|
|
n = _eet_node_new(name, EET_G_LIST);
|
|
|
|
if (!n) return NULL;
|
|
|
|
|
|
|
|
_eet_node_append(n, nodes);
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
Eet_Node *
|
|
|
|
eet_node_array_new(const char *name, int count, Eina_List *nodes)
|
|
|
|
{
|
|
|
|
Eet_Node *n;
|
|
|
|
|
|
|
|
n = _eet_node_new(name, EET_G_ARRAY);
|
|
|
|
if (!n) return NULL;
|
|
|
|
|
|
|
|
n->count = count;
|
|
|
|
|
|
|
|
_eet_node_append(n, nodes);
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
Eet_Node *
|
2009-06-02 09:24:28 -07:00
|
|
|
eet_node_var_array_new(const char *name, Eina_List *nodes)
|
2009-04-16 05:42:03 -07:00
|
|
|
{
|
|
|
|
Eet_Node *n;
|
|
|
|
|
|
|
|
n = _eet_node_new(name, EET_G_VAR_ARRAY);
|
|
|
|
if (!n) return NULL;
|
|
|
|
|
2009-06-02 09:24:28 -07:00
|
|
|
n->count = eina_list_count(nodes);
|
2009-04-16 05:42:03 -07:00
|
|
|
|
|
|
|
_eet_node_append(n, nodes);
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
Eet_Node *
|
2009-06-02 09:24:28 -07:00
|
|
|
eet_node_hash_new(const char *name, const char *key, Eet_Node *node)
|
2009-04-16 05:42:03 -07:00
|
|
|
{
|
2009-06-02 09:24:28 -07:00
|
|
|
Eina_List *nodes;
|
2009-04-16 05:42:03 -07:00
|
|
|
Eet_Node *n;
|
|
|
|
|
2009-06-02 09:24:28 -07:00
|
|
|
if (!node) return NULL;
|
|
|
|
|
2009-04-16 05:42:03 -07:00
|
|
|
n = _eet_node_new(name, EET_G_HASH);
|
|
|
|
if (!n) return NULL;
|
|
|
|
|
|
|
|
n->key = eina_stringshare_add(key);
|
2009-06-02 09:24:28 -07:00
|
|
|
nodes = eina_list_append(NULL, node);
|
2009-04-16 05:42:03 -07:00
|
|
|
|
|
|
|
_eet_node_append(n, nodes);
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
Eet_Node *
|
|
|
|
eet_node_struct_new(const char *name, Eina_List *nodes)
|
|
|
|
{
|
|
|
|
Eet_Node *n;
|
|
|
|
|
|
|
|
n = _eet_node_new(name, EET_G_UNKNOWN);
|
|
|
|
if (!n) return NULL;
|
|
|
|
|
|
|
|
_eet_node_append(n, nodes);
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2009-06-15 09:48:31 -07:00
|
|
|
Eet_Node *
|
|
|
|
eet_node_struct_child_new(const char *parent, Eet_Node *child)
|
|
|
|
{
|
|
|
|
Eet_Node *n;
|
|
|
|
|
|
|
|
if (child->type != EET_G_UNKNOWN)
|
|
|
|
return child;
|
|
|
|
|
|
|
|
n = _eet_node_new(parent, EET_G_UNKNOWN);
|
|
|
|
if (!n) return NULL;
|
|
|
|
|
|
|
|
_eet_node_append(n, eina_list_prepend(NULL, child));
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2009-04-16 05:42:03 -07:00
|
|
|
void
|
|
|
|
eet_node_del(Eet_Node *n)
|
|
|
|
{
|
|
|
|
Eet_Node *nn;
|
|
|
|
Eet_Node *tmp;
|
|
|
|
|
|
|
|
switch (n->type)
|
|
|
|
{
|
|
|
|
case EET_G_HASH:
|
|
|
|
eina_stringshare_del(n->key);
|
|
|
|
case EET_G_UNKNOWN:
|
|
|
|
case EET_G_VAR_ARRAY:
|
|
|
|
case EET_G_ARRAY:
|
|
|
|
case EET_G_LIST:
|
|
|
|
for (nn = n->values; nn; )
|
|
|
|
{
|
|
|
|
tmp = nn;
|
|
|
|
nn = nn->next;
|
|
|
|
eet_node_del(tmp);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case EET_T_STRING:
|
|
|
|
case EET_T_INLINED_STRING:
|
|
|
|
eina_stringshare_del(n->data.str);
|
|
|
|
break;
|
|
|
|
case EET_T_CHAR:
|
|
|
|
case EET_T_SHORT:
|
|
|
|
case EET_T_INT:
|
|
|
|
case EET_T_LONG_LONG:
|
|
|
|
case EET_T_FLOAT:
|
|
|
|
case EET_T_DOUBLE:
|
|
|
|
case EET_T_UCHAR:
|
|
|
|
case EET_T_USHORT:
|
|
|
|
case EET_T_UINT:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
eina_stringshare_del(n->name);
|
|
|
|
free(n);
|
|
|
|
}
|
2009-06-02 09:24:28 -07:00
|
|
|
|
|
|
|
|
|
|
|
static const char *eet_node_dump_g_name[6] = {
|
|
|
|
"struct",
|
|
|
|
"array",
|
|
|
|
"var_array",
|
|
|
|
"list",
|
|
|
|
"hash",
|
|
|
|
"???"
|
|
|
|
};
|
|
|
|
|
|
|
|
static const char *eet_node_dump_t_name[14][2] = {
|
|
|
|
{ "???: ", "???" },
|
|
|
|
{ "char: ", "%hhi" },
|
|
|
|
{ "short: ", "%hi" },
|
|
|
|
{ "int: ", "%i" },
|
|
|
|
{ "long_long: ", "%lli" },
|
|
|
|
{ "float: ", "%1.25f" },
|
|
|
|
{ "double: ", "%1.25f" },
|
|
|
|
{ "uchar: ", "%hhu" },
|
|
|
|
{ "ushort: ", "%i" },
|
|
|
|
{ "uint: ", "%u" },
|
|
|
|
{ "ulong_long: ", "%llu" },
|
|
|
|
{ "null", "" }
|
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
|
|
|
eet_node_dump_level(int level, void (*dumpfunc) (void *data, const char *str), void *dumpdata)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < level; i++) dumpfunc(dumpdata, " ");
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
eet_node_string_escape(const char *str)
|
|
|
|
{
|
|
|
|
char *s, *sp;
|
|
|
|
const char *strp;
|
|
|
|
int sz = 0;
|
|
|
|
|
|
|
|
for (strp = str; *strp; strp++)
|
|
|
|
{
|
|
|
|
if (*strp == '\"') sz += 2;
|
|
|
|
else if (*strp == '\\') sz += 2;
|
|
|
|
else sz += 1;
|
|
|
|
}
|
|
|
|
s = malloc(sz + 1);
|
|
|
|
if (!s) return NULL;
|
|
|
|
for (strp = str, sp = s; *strp; strp++, sp++)
|
|
|
|
{
|
|
|
|
if (*strp == '\"')
|
|
|
|
{
|
|
|
|
*sp = '\\';
|
|
|
|
sp++;
|
|
|
|
}
|
|
|
|
else if (*strp == '\\')
|
|
|
|
{
|
|
|
|
*sp = '\\';
|
|
|
|
sp++;
|
|
|
|
}
|
|
|
|
*sp = *strp;
|
|
|
|
}
|
|
|
|
*sp = 0;
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
eet_node_dump_string_escape(void *dumpdata, void dumpfunc(void *data, const char *str), const char *str)
|
|
|
|
{
|
|
|
|
char *s;
|
|
|
|
|
|
|
|
s = eet_node_string_escape(str);
|
|
|
|
if (!s) return ;
|
|
|
|
|
|
|
|
dumpfunc(dumpdata, s);
|
|
|
|
free(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
eet_node_dump_simple_type(Eet_Node *n, int level,
|
|
|
|
void (*dumpfunc) (void *data, const char *str), void *dumpdata)
|
|
|
|
{
|
|
|
|
const char *type_name = NULL;
|
|
|
|
char tbuf[256];
|
|
|
|
|
|
|
|
eet_node_dump_level(level, dumpfunc, dumpdata);
|
|
|
|
dumpfunc(dumpdata, " value \"");
|
|
|
|
eet_node_dump_string_escape(dumpdata, dumpfunc, n->name);
|
|
|
|
dumpfunc(dumpdata, "\" ");
|
|
|
|
|
2009-11-02 00:41:43 -08:00
|
|
|
#ifdef EET_T_TYPE
|
|
|
|
# undef EET_T_TYPE
|
|
|
|
#endif
|
|
|
|
|
2009-06-02 09:24:28 -07:00
|
|
|
#define EET_T_TYPE(Eet_Type, Type) \
|
|
|
|
case Eet_Type: \
|
|
|
|
{ \
|
|
|
|
dumpfunc(dumpdata, eet_node_dump_t_name[Eet_Type][0]); \
|
|
|
|
snprintf(tbuf, sizeof (tbuf), eet_node_dump_t_name[Eet_Type][1], n->data.Type); \
|
|
|
|
dumpfunc(dumpdata, tbuf); \
|
|
|
|
break; \
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (n->type)
|
|
|
|
{
|
|
|
|
EET_T_TYPE(EET_T_CHAR, c);
|
|
|
|
EET_T_TYPE(EET_T_SHORT, s);
|
|
|
|
EET_T_TYPE(EET_T_INT, i);
|
|
|
|
EET_T_TYPE(EET_T_LONG_LONG, l);
|
|
|
|
EET_T_TYPE(EET_T_FLOAT, f);
|
|
|
|
EET_T_TYPE(EET_T_DOUBLE, d);
|
|
|
|
EET_T_TYPE(EET_T_UCHAR, uc);
|
|
|
|
EET_T_TYPE(EET_T_USHORT, us);
|
|
|
|
EET_T_TYPE(EET_T_UINT, ui);
|
|
|
|
EET_T_TYPE(EET_T_ULONG_LONG, ul);
|
|
|
|
case EET_T_INLINED_STRING:
|
|
|
|
type_name = "inlined: \"";
|
|
|
|
case EET_T_STRING:
|
|
|
|
if (!type_name) type_name = "string: \"";
|
|
|
|
|
|
|
|
dumpfunc(dumpdata, type_name);
|
|
|
|
eet_node_dump_string_escape(dumpdata, dumpfunc, n->data.str);
|
|
|
|
dumpfunc(dumpdata, "\"");
|
|
|
|
break;
|
|
|
|
case EET_T_NULL:
|
|
|
|
dumpfunc(dumpdata, "null");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dumpfunc(dumpdata, "???: ???");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
dumpfunc(dumpdata, ";\n");
|
|
|
|
}
|
|
|
|
|
2009-12-21 07:46:56 -08:00
|
|
|
static void
|
|
|
|
eet_node_dump_group_start(int level, void (*dumpfunc) (void *data, const char *str), void *dumpdata,
|
|
|
|
int group_type, const char *name)
|
|
|
|
{
|
|
|
|
int chnk_type;
|
|
|
|
|
|
|
|
chnk_type = (group_type >= EET_G_UNKNOWN && group_type <= EET_G_HASH) ?
|
|
|
|
group_type : EET_G_LAST;
|
|
|
|
|
|
|
|
eet_node_dump_level(level, dumpfunc, dumpdata);
|
|
|
|
dumpfunc(dumpdata, "group \"");
|
|
|
|
eet_node_dump_string_escape(dumpdata, dumpfunc, name);
|
|
|
|
dumpfunc(dumpdata, "\" ");
|
|
|
|
|
|
|
|
dumpfunc(dumpdata, eet_node_dump_g_name[chnk_type - EET_G_UNKNOWN]);
|
|
|
|
dumpfunc(dumpdata, " {\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
eet_node_dump_group_end(int level, void (*dumpfunc) (void *data, const char *str), void *dumpdata)
|
|
|
|
{
|
|
|
|
eet_node_dump_level(level, dumpfunc, dumpdata);
|
|
|
|
dumpfunc(dumpdata, " }\n");
|
|
|
|
}
|
|
|
|
|
2009-06-02 09:24:28 -07:00
|
|
|
void
|
|
|
|
eet_node_dump(Eet_Node *n, int dumplevel, void (*dumpfunc) (void *data, const char *str), void *dumpdata)
|
|
|
|
{
|
|
|
|
switch (n->type)
|
|
|
|
{
|
|
|
|
case EET_G_HASH:
|
|
|
|
case EET_G_UNKNOWN:
|
|
|
|
case EET_G_VAR_ARRAY:
|
|
|
|
case EET_G_ARRAY:
|
|
|
|
case EET_G_LIST:
|
2009-12-21 07:46:56 -08:00
|
|
|
eet_node_dump_group_start(dumplevel, dumpfunc, dumpdata, n->type, n->name);
|
|
|
|
/* FIXME: Handle content of group. */
|
|
|
|
eet_node_dump_group_end(dumplevel, dumpfunc, dumpdata);
|
2009-06-02 09:24:28 -07:00
|
|
|
break;
|
|
|
|
case EET_T_STRING:
|
|
|
|
case EET_T_INLINED_STRING:
|
|
|
|
case EET_T_CHAR:
|
|
|
|
case EET_T_SHORT:
|
|
|
|
case EET_T_INT:
|
|
|
|
case EET_T_LONG_LONG:
|
|
|
|
case EET_T_FLOAT:
|
|
|
|
case EET_T_DOUBLE:
|
|
|
|
case EET_T_UCHAR:
|
|
|
|
case EET_T_USHORT:
|
|
|
|
case EET_T_UINT:
|
|
|
|
eet_node_dump_simple_type(n, dumplevel, dumpfunc, dumpdata);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|