# include <config.h>
#endif
-#if HAVE___ATTRIBUTE__
-#define __UNUSED__ __attribute__((unused))
-#else
-#define __UNUSED__
-#endif
-
#include <stdio.h>
#include <string.h>
#include <math.h>
# include <netinet/in.h>
#endif
-#if defined(_WIN32) && ! defined(__CEGCC__)
+#ifdef _WIN32
# include <winsock2.h>
#endif
typedef struct _Eet_Data_Stream Eet_Data_Stream;
typedef struct _Eet_Data_Descriptor_Hash Eet_Data_Descriptor_Hash;
typedef struct _Eet_Data_Encode_Hash_Info Eet_Data_Encode_Hash_Info;
+typedef struct _Eet_Free Eet_Free;
+typedef struct _Eet_Free_Context Eet_Free_Context;
/*---*/
struct _Eet_Data_Group_Type_Codec
{
- int (*get) (const Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Chunk *echnk, int type, int group_type, void *data_in, int level, void (*dumpfunc) (void *data, const char *str), void *dumpdata, char **p, int *size);
+ int (*get) (Eet_Free_Context *context, const Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Chunk *echnk, int type, int group_type, void *data_in, char **p, int *size);
void (*put) (Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Stream *ds, void *data_in);
};
Eet_Dictionary *ed;
};
+struct _Eet_Free
+{
+ int ref;
+ int len[256];
+ int num[256];
+ void **list[256];
+};
+
+struct _Eet_Free_Context
+{
+ Eet_Free freelist;
+ Eet_Free freelist_list;
+ Eet_Free freelist_hash;
+ Eet_Free freelist_str;
+ Eet_Free freelist_direct_str;
+};
+
/*---*/
static int eet_data_get_char(const Eet_Dictionary *ed, const void *src, const void *src_end, void *dest);
static void *eet_data_put_float(Eet_Dictionary *ed, const void *src, int *size_ret);
static int eet_data_get_double(const Eet_Dictionary *ed, const void *src, const void *src_end, void *dest);
static void *eet_data_put_double(Eet_Dictionary *ed, const void *src, int *size_ret);
+static int eet_data_get_f32p32(const Eet_Dictionary *ed, const void *src, const void *src_end, void *dest);
+static void *eet_data_put_f32p32(Eet_Dictionary *ed, const void *src, int *size_ret);
+static int eet_data_get_f16p16(const Eet_Dictionary *ed, const void *src, const void *src_end, void *dest);
+static void *eet_data_put_f16p16(Eet_Dictionary *ed, const void *src, int *size_ret);
+static int eet_data_get_f8p24(const Eet_Dictionary *ed, const void *src, const void *src_end, void *dest);
+static void *eet_data_put_f8p24(Eet_Dictionary *ed, const void *src, int *size_ret);
static inline int eet_data_get_string(const Eet_Dictionary *ed, const void *src, const void *src_end, void *dest);
static void *eet_data_put_string(Eet_Dictionary *ed, const void *src, int *size_ret);
static int eet_data_get_istring(const Eet_Dictionary *ed, const void *src, const void *src_end, void *dest);
static void *eet_data_put_istring(Eet_Dictionary *ed, const void *src, int *size_ret);
+static int eet_data_get_null(const Eet_Dictionary *ed, const void *src, const void *src_end, void *dest);
+static void *eet_data_put_null(Eet_Dictionary *ed, const void *src, int *size_ret);
static int eet_data_get_type(const Eet_Dictionary *ed, int type, const void *src, const void *src_end, void *dest);
static void *eet_data_put_type(Eet_Dictionary *ed, int type, const void *src, int *size_ret);
-static int eet_data_get_unknown(const Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Chunk *echnk, int type, int group_type, void *data_in, int level, void (*dumpfunc) (void *data, const char *str), void *dumpdata, char **p, int *size);
+static Eet_Node *eet_data_node_simple_type(int type, const char *name, void *dd);
+
+static int eet_data_get_unknown(Eet_Free_Context *context, const Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Chunk *echnk, int type, int group_type, void *data_in, char **p, int *size);
static void eet_data_put_unknown(Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Stream *ds, void *data_in);
static void eet_data_put_array(Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Stream *ds, void *data_in);
-static int eet_data_get_array(const Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Chunk *echnk, int type, int group_type, void *data, int level, void (*dumpfunc) (void *data, const char *str), void *dumpdata, char **p, int *size);
-static int eet_data_get_list(const Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Chunk *echnk, int type, int group_type, void *data_in, int level, void (*dumpfunc) (void *data, const char *str), void *dumpdata, char **p, int *size);
+static int eet_data_get_array(Eet_Free_Context *context, const Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Chunk *echnk, int type, int group_type, void *data, char **p, int *size);
+static int eet_data_get_list(Eet_Free_Context *context, const Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Chunk *echnk, int type, int group_type, void *data_in, char **p, int *size);
static void eet_data_put_list(Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Stream *ds, void *data_in);
static void eet_data_put_hash(Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Stream *ds, void *data_in);
-static int eet_data_get_hash(const Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Chunk *echnk, int type, int group_type, void *data, int level, void (*dumpfunc) (void *data, const char *str), void *dumpdata, char **p, int *size);
+static int eet_data_get_hash(Eet_Free_Context *context, const Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Chunk *echnk, int type, int group_type, void *data, char **p, int *size);
static void eet_data_chunk_get(const Eet_Dictionary *ed, Eet_Data_Chunk *chnk, const void *src, int size);
static Eet_Data_Chunk *eet_data_chunk_new(void *data, int size, const char *name, int type, int group_type);
static int eet_data_descriptor_encode_hash_cb(void *hash, const char *key, void *hdata, void *fdata);
static void *_eet_data_descriptor_encode(Eet_Dictionary *ed, Eet_Data_Descriptor *edd, const void *data_in, int *size_ret);
-static void *_eet_data_descriptor_decode(const Eet_Dictionary *ed,
+static void *_eet_data_descriptor_decode(Eet_Free_Context *context,
+ const Eet_Dictionary *ed,
Eet_Data_Descriptor *edd,
const void *data_in,
- int size_in,
- int level,
- void (*dumpfunc) (void *data, const char *str),
- void *dumpdata);
+ int size_in);
/*---*/
{sizeof(int), "uint", eet_data_get_int, eet_data_put_int },
{sizeof(long long), "ulong_long", eet_data_get_long_long, eet_data_put_long_long},
{sizeof(char *), "string", eet_data_get_string, eet_data_put_string },
- {sizeof(char *), "inlined", eet_data_get_istring, eet_data_put_istring }
+ {sizeof(char *), "inlined", eet_data_get_istring, eet_data_put_istring },
+ {sizeof(void *), "NULL", eet_data_get_null, eet_data_put_null },
+ {sizeof(Eina_F32p32),"f32p32", eet_data_get_f32p32, eet_data_put_f32p32 },
+ {sizeof(Eina_F16p16),"f16p16", eet_data_get_f16p16, eet_data_put_f16p16 },
+ {sizeof(Eina_F8p24),"f8p24", eet_data_get_f8p24, eet_data_put_f8p24 }
};
static const Eet_Data_Group_Type_Codec eet_group_codec[] =
{ eet_data_get_hash, eet_data_put_hash }
};
-static int words_bigendian = -1;
+static int _eet_data_words_bigendian = -1;
/*---*/
((((short)(x) & 0x00ff ) << 8) |\
(((short)(x) & 0xff00 ) >> 8))
+#ifdef CONV8
+# undef CONV8
+#endif
+#ifdef CONV16
+# undef CONV16
+#endif
+#ifdef CONV32
+# undef CONV32
+#endif
+#ifdef CONV64
+# undef CONV64
+#endif
+
#define CONV8(x)
-#define CONV16(x) {if (words_bigendian) SWAP16(x);}
-#define CONV32(x) {if (words_bigendian) SWAP32(x);}
-#define CONV64(x) {if (words_bigendian) SWAP64(x);}
+#define CONV16(x) {if (_eet_data_words_bigendian) SWAP16(x);}
+#define CONV32(x) {if (_eet_data_words_bigendian) SWAP32(x);}
+#define CONV64(x) {if (_eet_data_words_bigendian) SWAP64(x);}
#define IS_SIMPLE_TYPE(Type) (Type > EET_T_UNKNOW && Type < EET_T_LAST)
+#define IS_POINTER_TYPE(Type) (Type >= EET_T_STRING && Type <= EET_T_NULL)
+
+#define EET_I_STRING 1 << 4
+#define EET_I_INLINED_STRING 2 << 4
+#define EET_I_NULL 3 << 4
/*---*/
{
if (ed)
{
- int index;
+ int idx;
- if (eet_data_get_int(ed, src, src_end, &index) < 0) return -1;
+ if (eet_data_get_int(ed, src, src_end, &idx) < 0) return -1;
- return eet_dictionary_string_get_hash(ed, index);
+ return eet_dictionary_string_get_hash(ed, idx);
}
return -1;
if (ed)
{
const char *str;
- int index;
+ int idx;
- if (eet_data_get_int(ed, src, src_end, &index) < 0) return -1;
+ if (eet_data_get_int(ed, src, src_end, &idx) < 0) return -1;
- str = eet_dictionary_string_get_char(ed, index);
+ str = eet_dictionary_string_get_char(ed, idx);
if (str == NULL)
return -1;
*d = (char *) str;
- return eet_dictionary_string_get_size(ed, index);
+ return eet_dictionary_string_get_size(ed, idx);
}
s = (char *)src;
if (ed)
{
const char *str;
- int index;
+ int idx;
str = *((const char **) src);
if (!str) return NULL;
- index = eet_dictionary_string_add(ed, str);
- if (index == -1) return NULL;
+ idx = eet_dictionary_string_add(ed, str);
+ if (idx == -1) return NULL;
- return eet_data_put_int(ed, &index, size_ret);
+ return eet_data_put_int(ed, &idx, size_ret);
}
s = (char *)(*((char **)src));
return eet_data_put_string(NULL, src, size_ret);
}
+/* ALWAYS NULL TYPE */
+static int
+eet_data_get_null(const Eet_Dictionary *ed __UNUSED__, const void *src __UNUSED__, const void *src_end __UNUSED__, void *dst)
+{
+ char **d;
+
+ d = (char**) dst;
+
+ *d = NULL;
+ return 1;
+}
+
+static void *
+eet_data_put_null(Eet_Dictionary *ed __UNUSED__, const void *src __UNUSED__, int *size_ret)
+{
+ *size_ret = 0;
+ return NULL;
+}
+
/**
* Fast lookups of simple doubles/floats.
*
eet_data_get_float(const Eet_Dictionary *ed, const void *src, const void *src_end, void *dst)
{
float *d;
- int index;
+ int idx;
d = (float *) dst;
if (!ed)
return len + 1;
}
- if (eet_data_get_int(ed, src, src_end, &index) < 0) return -1;
+ if (eet_data_get_int(ed, src, src_end, &idx) < 0) return -1;
- if (!eet_dictionary_string_get_float(ed, index, d))
+ if (!eet_dictionary_string_get_float(ed, idx, d))
return -1;
return 1;
}
eet_data_put_float(Eet_Dictionary *ed, const void *src, int *size_ret)
{
char buf[128];
- int index;
+ int idx;
eina_convert_dtoa((double)(*(float *)src), buf);
return d;
}
- index = eet_dictionary_string_add(ed, buf);
- if (index == -1) return NULL;
+ idx = eet_dictionary_string_add(ed, buf);
+ if (idx == -1) return NULL;
- return eet_data_put_int(ed, &index, size_ret);
+ return eet_data_put_int(ed, &idx, size_ret);
}
/* DOUBLE TYPE */
eet_data_get_double(const Eet_Dictionary *ed, const void *src, const void *src_end, void *dst)
{
double *d;
- int index;
+ int idx;
d = (double *) dst;
return len + 1;
}
- if (eet_data_get_int(ed, src, src_end, &index) < 0) return -1;
+ if (eet_data_get_int(ed, src, src_end, &idx) < 0) return -1;
- if (!eet_dictionary_string_get_double(ed, index, d))
+ if (!eet_dictionary_string_get_double(ed, idx, d))
return -1;
return 1;
}
eet_data_put_double(Eet_Dictionary *ed, const void *src, int *size_ret)
{
char buf[128];
- int index;
+ int idx;
eina_convert_dtoa((double)(*(double *)src), buf);
return d;
}
- index = eet_dictionary_string_add(ed, buf);
- if (index == -1) return NULL;
+ idx = eet_dictionary_string_add(ed, buf);
+ if (idx == -1) return NULL;
+
+ return eet_data_put_int(ed, &idx, size_ret);
+}
+
+static int
+eet_data_get_f32p32(const Eet_Dictionary *ed, const void *src, const void *src_end, void *dst)
+{
+ Eina_F32p32 *fp;
+ int idx;
+
+ fp = (Eina_F32p32*) dst;
+
+ if (!ed) return -1;
+
+ if (eet_data_get_int(ed, src, src_end, &idx) < 0) return -1;
+
+ if (!eet_dictionary_string_get_fp(ed, idx, fp))
+ return -1;
+ return 1;
+}
+
+static void *
+eet_data_put_f32p32(Eet_Dictionary *ed, const void *src, int *size_ret)
+{
+ char buf[128];
+ int idx;
+
+ if (!ed) return NULL;
+
+ eina_convert_fptoa((Eina_F32p32)(*(Eina_F32p32 *)src), buf);
+
+ idx = eet_dictionary_string_add(ed, buf);
+ if (idx == -1) return NULL;
+
+ return eet_data_put_int(ed, &idx, size_ret);
+}
+
+static int
+eet_data_get_f16p16(const Eet_Dictionary *ed, const void *src, const void *src_end, void *dst)
+{
+ Eina_F32p32 tmp;
+ Eina_F16p16 *fp;
+
+ fp = (Eina_F16p16*) dst;
+
+ if (eet_data_get_f32p32(ed, src, src_end, &tmp) < 0) return -1;
+
+ *fp = eina_f32p32_to_f16p16(tmp);
+ return 1;
+}
+
+static void *
+eet_data_put_f16p16(Eet_Dictionary *ed, const void *src, int *size_ret)
+{
+ Eina_F32p32 tmp;
+
+ tmp = eina_f16p16_to_f32p32((Eina_F16p16)(*(Eina_F16p16 *)src));
+ return eet_data_put_f32p32(ed, &tmp, size_ret);
+}
+
+static int
+eet_data_get_f8p24(const Eet_Dictionary *ed, const void *src, const void *src_end, void *dst)
+{
+ Eina_F32p32 tmp;
+ Eina_F8p24 *fp;
+
+ fp = (Eina_F8p24*) dst;
+
+ if (eet_data_get_f32p32(ed, src, src_end, &tmp) < 0) return -1;
+
+ *fp = eina_f32p32_to_f8p24(tmp);
+ return 1;
+}
+
+static void *
+eet_data_put_f8p24(Eet_Dictionary *ed, const void *src, int *size_ret)
+{
+ Eina_F32p32 tmp;
- return eet_data_put_int(ed, &index, size_ret);
+ tmp = eina_f8p24_to_f32p32((Eina_F8p24)(*(Eina_F8p24 *)src));
+ return eet_data_put_f32p32(ed, &tmp, size_ret);
}
static inline int
return ret;
}
+static inline Eina_Bool
+eet_data_type_match(int type1, int type2)
+{
+ if (type1 == type2) return EINA_TRUE;
+
+ /* Note: All floating point type are equivalent and could be read
+ without problem by any other floating point getter. */
+ switch (type1)
+ {
+ case EET_T_FLOAT:
+ case EET_T_DOUBLE:
+ case EET_T_F32P32:
+ case EET_T_F16P16:
+ case EET_T_F8P24:
+ switch (type2)
+ {
+ case EET_T_FLOAT:
+ case EET_T_DOUBLE:
+ case EET_T_F32P32:
+ case EET_T_F16P16:
+ case EET_T_F8P24:
+ return EINA_TRUE;
+ default:
+ break;
+ }
+ break;
+ default:
+ break;
+ }
+
+ return EINA_FALSE;
+}
+
/* chunk format...
*
* char[4] = "CHnK"; // untyped data ... or
if (!src) return;
if (size <= 8) return;
-
if (!chnk) return;
s = src;
if (s[2] == 'K')
{
if ((s[0] != 'C') || (s[1] != 'H') || (s[2] != 'K'))
+ return;
+
+ chnk->type = (unsigned char)(s[3]);
+ if (chnk->type >= EET_I_LIMIT)
{
- return;
+ chnk->group_type = ((chnk->type - EET_I_LIMIT) & 0xF) + EET_G_UNKNOWN;
+ switch ((chnk->type - EET_I_LIMIT) & 0xF0)
+ {
+#define EET_UNMATCH_TYPE(Type) \
+ case EET_I_##Type: chnk->type = EET_T_##Type; break;
+
+ EET_UNMATCH_TYPE(STRING);
+ EET_UNMATCH_TYPE(INLINED_STRING);
+ EET_UNMATCH_TYPE(NULL);
+ default:
+ return;
+ }
}
- chnk->type = (unsigned char)(s[3]);
- if (chnk->type > EET_T_LAST)
+ else if (chnk->type > EET_T_LAST)
{
chnk->group_type = chnk->type;
chnk->type = EET_T_UNKNOW;
else
{
if ((s[0] != 'C') || (s[1] != 'H') || (s[2] != 'n') || (s[3] != 'K'))
- {
- return;
- }
+ return;
}
ret1 = eet_data_get_type(ed, EET_T_INT, (s + 4), (s + size), &(chnk->size));
- if (ret1 <= 0)
- {
- return;
- }
- if ((chnk->size < 0) || ((chnk->size + 8) > size))
- {
- return;
- }
+
+ if (ret1 <= 0) return;
+ if ((chnk->size < 0) || ((chnk->size + 8) > size)) return;
ret2 = eet_data_get_type(ed, EET_T_STRING, (s + 8), (s + size), &(chnk->name));
- if (ret2 <= 0)
- {
- return;
- }
+
+ if (ret2 <= 0) return;
chnk->len = ret2;
chnk = calloc(1, sizeof(Eet_Data_Chunk));
if (!chnk) return NULL;
+ /* Note: Another security, so older eet library could read file
+ saved with fixed point value. */
+ if (type == EET_T_F32P32
+ || type == EET_T_F16P16
+ || type == EET_T_F8P24)
+ type = EET_T_DOUBLE;
+
chnk->name = strdup(name);
chnk->len = strlen(name) + 1;
chnk->size = size;
}
static inline void
+eet_data_stream_flush(Eet_Data_Stream *ds)
+{
+ free(ds);
+}
+
+static inline void
eet_data_stream_write(Eet_Data_Stream *ds, const void *data, int size)
{
char *p;
int string_ret = 0;
unsigned char buf[4] = "CHK";
- if (!chnk->data) return;
+ /* disable this check - it will allow empty chunks to be written. this is
+ * right for corner-cases when y have a struct with empty fields (empty
+ * strings or empty list ptrs etc.) */
+ /* if (!chnk->data && chnk->type != EET_T_NULL) return; */
/* chunk head */
/* eet_data_stream_write(ds, "CHnK", 4);*/
- if (chnk->type != EET_T_UNKNOW) buf[3] = chnk->type;
+ if (chnk->type != EET_T_UNKNOW)
+ {
+ if (chnk->group_type != EET_G_UNKNOWN)
+ {
+ int type = EET_I_LIMIT + chnk->group_type - EET_G_UNKNOWN;
+
+ switch (chnk->type)
+ {
+ /* Only make sense with pointer type. */
+#define EET_MATCH_TYPE(Type) \
+ case EET_T_##Type: type += EET_I_##Type; break;
+
+ EET_MATCH_TYPE(STRING);
+ EET_MATCH_TYPE(INLINED_STRING);
+ EET_MATCH_TYPE(NULL);
+ default:
+ return ;
+ }
+
+ buf[3] = type;
+ }
+ else
+ buf[3] = chnk->type;
+ }
else buf[3] = chnk->group_type;
string = eet_data_put_string(ed, &chnk->name, &string_ret);
eet_data_stream_write(ds, string, string_ret);
/* write payload */
- eet_data_stream_write(ds, chnk->data, chnk->size);
+ if (chnk->data)
+ eet_data_stream_write(ds, chnk->data, chnk->size);
free(string);
on_error:
free((char *)str);
}
+static Eina_Hash *
+_eet_eina_hash_add_alloc(Eina_Hash *hash, const char *key, void *data)
+{
+ if (!hash) hash = eina_hash_string_small_new(NULL);
+ if (!hash) return NULL;
+
+ eina_hash_add(hash, key, data);
+ return hash;
+}
+
+static Eina_Hash *
+_eet_eina_hash_direct_add_alloc(Eina_Hash *hash, const char *key, void *data)
+{
+ if (!hash) hash = eina_hash_string_small_new(NULL);
+ if (!hash) return NULL;
+
+ eina_hash_direct_add(hash, key, data);
+ return hash;
+}
+
+static char *
+_eet_str_direct_alloc(const char *str)
+{
+ return (char *)str;
+}
+
+static void
+_eet_str_direct_free(__UNUSED__ const char *str)
+{
+}
+
+static void
+_eet_eina_hash_foreach(void *hash, Eina_Hash_Foreach cb, void *fdata)
+{
+ if (hash) eina_hash_foreach(hash, cb, fdata);
+}
+
+static void
+_eet_eina_hash_free(void *hash)
+{
+ if (hash) eina_hash_free(hash);
+}
+
/*---*/
+EAPI Eina_Bool
+eet_eina_stream_data_descriptor_class_set(Eet_Data_Descriptor_Class *eddc, const char *name, int size)
+{
+ if (!eddc || !name) return EINA_FALSE;
-EAPI Eet_Data_Descriptor *
-eet_data_descriptor_new(const char *name,
- int size,
- void *(*func_list_next) (void *l),
- void *(*func_list_append) (void *l, void *d),
- void *(*func_list_data) (void *l),
- void *(*func_list_free) (void *l),
- void (*func_hash_foreach) (void *h, int (*func) (void *h, const char *k, void *dt, void *fdt), void *fdt),
- void *(*func_hash_add) (void *h, const char *k, void *d),
- void (*func_hash_free) (void *h))
+ eddc->name = name;
+ eddc->size = size;
+ eddc->version = 1;
+
+ eddc->func.mem_alloc = _eet_mem_alloc;
+ eddc->func.mem_free = _eet_mem_free;
+ eddc->func.str_alloc = (char *(*)(const char *))eina_stringshare_add;
+ eddc->func.str_free = eina_stringshare_del;
+ eddc->func.list_next = (void *(*)(void *))eina_list_next;
+ eddc->func.list_append = (void *(*)(void *, void *))eina_list_append;
+ eddc->func.list_data = (void *(*)(void *))eina_list_data_get;
+ eddc->func.list_free = (void *(*)(void *))eina_list_free;
+ eddc->func.hash_foreach = (void (*)(void *, int (*)(void *, const char *, void *, void *), void *))_eet_eina_hash_foreach;
+ eddc->func.hash_add = (void* (*)(void *, const char *, void *)) _eet_eina_hash_add_alloc;
+ eddc->func.hash_free = (void (*)(void *))_eet_eina_hash_free;
+
+ return EINA_TRUE;
+}
+
+EAPI Eina_Bool
+eet_eina_file_data_descriptor_class_set(Eet_Data_Descriptor_Class *eddc, const char *name, int size)
{
- Eet_Data_Descriptor *edd;
+ if (!eet_eina_stream_data_descriptor_class_set(eddc, name, size))
+ return EINA_FALSE;
- if (!name) return NULL;
- edd = calloc(1, sizeof(Eet_Data_Descriptor));
- if (!edd) return NULL;
+ eddc->version = 2;
- edd->name = name;
- edd->ed = NULL;
- edd->size = size;
- edd->func.mem_alloc = _eet_mem_alloc;
- edd->func.mem_free = _eet_mem_free;
- edd->func.str_alloc = _eet_str_alloc;
- edd->func.str_direct_alloc = NULL;
- edd->func.str_direct_free = NULL;
- edd->func.str_free = _eet_str_free;
- edd->func.list_next = func_list_next;
- edd->func.list_append = func_list_append;
- edd->func.list_data = func_list_data;
- edd->func.list_free = func_list_free;
- edd->func.hash_foreach = func_hash_foreach;
- edd->func.hash_add = func_hash_add;
- edd->func.hash_free = func_hash_free;
- return edd;
+ eddc->func.hash_add = (void* (*)(void *, const char *, void *)) _eet_eina_hash_direct_add_alloc;
+ eddc->func.str_direct_alloc = _eet_str_direct_alloc;
+ eddc->func.str_direct_free = _eet_str_direct_free;
+
+ return EINA_TRUE;
}
-/* new replcement */
-EAPI Eet_Data_Descriptor *
-eet_data_descriptor2_new(Eet_Data_Descriptor_Class *eddc)
+static Eet_Data_Descriptor *
+_eet_data_descriptor_new(const Eet_Data_Descriptor_Class *eddc, int version)
{
Eet_Data_Descriptor *edd;
if (!eddc) return NULL;
- if (eddc->version < 1) return NULL;
- edd = calloc(1, sizeof(Eet_Data_Descriptor));
+ if (eddc->version < version) return NULL;
+
+ edd = calloc(1, sizeof (Eet_Data_Descriptor));
if (!edd) return NULL;
edd->name = eddc->name;
edd->func.hash_add = eddc->func.hash_add;
edd->func.hash_free = eddc->func.hash_free;
+ if (version > 1)
+ {
+ edd->func.str_direct_alloc = eddc->func.str_direct_alloc;
+ edd->func.str_direct_free = eddc->func.str_direct_free;
+ }
+
return edd;
}
EAPI Eet_Data_Descriptor *
-eet_data_descriptor3_new(Eet_Data_Descriptor_Class *eddc)
+eet_data_descriptor_new(const char *name,
+ int size,
+ void *(*func_list_next) (void *l),
+ void *(*func_list_append) (void *l, void *d),
+ void *(*func_list_data) (void *l),
+ void *(*func_list_free) (void *l),
+ void (*func_hash_foreach) (void *h, int (*func) (void *h, const char *k, void *dt, void *fdt), void *fdt),
+ void *(*func_hash_add) (void *h, const char *k, void *d),
+ void (*func_hash_free) (void *h))
{
- Eet_Data_Descriptor *edd;
+ Eet_Data_Descriptor_Class eddc;
- if (!eddc) return NULL;
- if (eddc->version < 2) return NULL;
- edd = calloc(1, sizeof(Eet_Data_Descriptor));
- if (!edd) return NULL;
+ if (!name) return NULL;
- edd->name = eddc->name;
- edd->ed = NULL;
- edd->size = eddc->size;
- edd->func.mem_alloc = _eet_mem_alloc;
- edd->func.mem_free = _eet_mem_free;
- edd->func.str_alloc = _eet_str_alloc;
- edd->func.str_free = _eet_str_free;
- if (eddc->func.mem_alloc)
- edd->func.mem_alloc = eddc->func.mem_alloc;
- if (eddc->func.mem_free)
- edd->func.mem_free = eddc->func.mem_free;
- if (eddc->func.str_alloc)
- edd->func.str_alloc = eddc->func.str_alloc;
- if (eddc->func.str_free)
- edd->func.str_free = eddc->func.str_free;
- edd->func.list_next = eddc->func.list_next;
- edd->func.list_append = eddc->func.list_append;
- edd->func.list_data = eddc->func.list_data;
- edd->func.list_free = eddc->func.list_free;
- edd->func.hash_foreach = eddc->func.hash_foreach;
- edd->func.hash_add = eddc->func.hash_add;
- edd->func.hash_free = eddc->func.hash_free;
- edd->func.str_direct_alloc = eddc->func.str_direct_alloc;
- edd->func.str_direct_free = eddc->func.str_direct_free;
+ memset(&eddc, 0, sizeof (Eet_Data_Descriptor_Class));
- return edd;
+ eddc.name = name;
+ eddc.size = size;
+ eddc.version = 0;
+
+ eddc.func.list_next = func_list_next;
+ eddc.func.list_append = func_list_append;
+ eddc.func.list_data = func_list_data;
+ eddc.func.list_free = func_list_free;
+ eddc.func.hash_foreach = func_hash_foreach;
+ eddc.func.hash_add = func_hash_add;
+ eddc.func.hash_free = func_hash_free;
+
+ return _eet_data_descriptor_new(&eddc, 0);
+}
+
+EAPI Eet_Data_Descriptor *
+eet_data_descriptor2_new(const Eet_Data_Descriptor_Class *eddc)
+{
+ return _eet_data_descriptor_new(eddc, 1);
+}
+
+EAPI Eet_Data_Descriptor *
+eet_data_descriptor3_new(const Eet_Data_Descriptor_Class *eddc)
+{
+ return _eet_data_descriptor_new(eddc, 2);
+}
+
+EAPI Eet_Data_Descriptor *
+eet_data_descriptor_stream_new(const Eet_Data_Descriptor_Class *eddc)
+{
+ return _eet_data_descriptor_new(eddc, 1);
+}
+
+EAPI Eet_Data_Descriptor *
+eet_data_descriptor_file_new(const Eet_Data_Descriptor_Class *eddc)
+{
+ return _eet_data_descriptor_new(eddc, 2);
}
EAPI void
eet_data_descriptor_free(Eet_Data_Descriptor *edd)
{
+ if (!edd) return ;
_eet_descriptor_hash_free(edd);
if (edd->elements.set) free(edd->elements.set);
free(edd);
int offset,
int count,
/* int counter_offset, */
- const char *counter_name /* Useless should go on a major release */,
+ const char *counter_name /* FIXME: Useless should go on a major release */,
Eet_Data_Descriptor *subtype)
{
Eet_Data_Element *ede;
- /* int l1, l2, p1, p2, i;
- char *ps;*/
+ Eet_Data_Element *tmp;
- /* FIXME: Fail safely when realloc fail. */
edd->elements.num++;
- edd->elements.set = realloc(edd->elements.set, edd->elements.num * sizeof(Eet_Data_Element));
- if (!edd->elements.set) return;
+ tmp = realloc(edd->elements.set, edd->elements.num * sizeof(Eet_Data_Element));
+ if (!tmp) return ;
+ edd->elements.set = tmp;
ede = &(edd->elements.set[edd->elements.num - 1]);
ede->name = name;
ede->directory_name_ptr = NULL;
*/
if (group_type > EET_G_UNKNOWN
&& group_type < EET_G_LAST
- && type > EET_T_UNKNOW && type < EET_T_STRING
+ && ((type > EET_T_UNKNOW && type < EET_T_STRING)
+ || (type > EET_T_NULL && type < EET_T_LAST))
&& subtype == NULL)
{
subtype = calloc(1, sizeof (Eet_Data_Descriptor));
}
EAPI void *
-eet_data_read(Eet_File *ef, Eet_Data_Descriptor *edd, const char *name)
+eet_data_read_cipher(Eet_File *ef, Eet_Data_Descriptor *edd, const char *name, const char *cipher_key)
{
const Eet_Dictionary *ed = NULL;
- const void *data;
+ const void *data = NULL;
void *data_dec;
- int size;
+ Eet_Free_Context context;
int required_free = 0;
+ int size;
ed = eet_dictionary_get(ef);
- data = eet_read_direct(ef, name, &size);
+ if (!cipher_key)
+ data = eet_read_direct(ef, name, &size);
if (!data)
{
required_free = 1;
- data = eet_read(ef, name, &size);
+ data = eet_read_cipher(ef, name, &size, cipher_key);
if (!data) return NULL;
}
- data_dec = _eet_data_descriptor_decode(ed, edd, data, size, 0, NULL, NULL);
+ memset(&context, 0, sizeof (context));
+ data_dec = _eet_data_descriptor_decode(&context, ed, edd, data, size);
if (required_free)
free((void*)data);
return data_dec;
}
-EAPI int
-eet_data_write(Eet_File *ef, Eet_Data_Descriptor *edd, const char *name, const void *data, int compress)
+EAPI Eet_Node *
+eet_data_node_read_cipher(Eet_File *ef, const char *name, const char *cipher_key)
{
- Eet_Dictionary *ed;
- void *data_enc;
- int size;
- int val;
+ const Eet_Dictionary *ed = NULL;
+ const void *data = NULL;
+ Eet_Node *result;
+ Eet_Free_Context context;
+ int required_free = 0;
+ int size;
ed = eet_dictionary_get(ef);
- data_enc = _eet_data_descriptor_encode(ed, edd, data, &size);
- if (!data_enc) return 0;
- val = eet_write(ef, name, data_enc, size, compress);
- free(data_enc);
- return val;
+ if (!cipher_key)
+ data = eet_read_direct(ef, name, &size);
+ if (!data)
+ {
+ required_free = 1;
+ data = eet_read_cipher(ef, name, &size, cipher_key);
+ if (!data) return NULL;
+ }
+
+ memset(&context, 0, sizeof (context));
+ result = _eet_data_descriptor_decode(&context, ed, NULL, data, size);
+ if (required_free)
+ free((void*)data);
+
+ return result;
}
-typedef struct _Eet_Free Eet_Free;
-struct _Eet_Free
+EAPI void *
+eet_data_read(Eet_File *ef, Eet_Data_Descriptor *edd, const char *name)
{
- int ref;
- int len[256];
- int num[256];
- void **list[256];
-};
+ return eet_data_read_cipher(ef, edd, name, NULL);
+}
+
+EAPI int
+eet_data_write_cipher(Eet_File *ef, Eet_Data_Descriptor *edd, const char *name, const char *cipher_key, const void *data, int compress)
+{
+ Eet_Dictionary *ed;
+ void *data_enc;
+ int size;
+ int val;
+
+ ed = eet_dictionary_get(ef);
+
+ data_enc = _eet_data_descriptor_encode(ed, edd, data, &size);
+ if (!data_enc) return 0;
+ val = eet_write_cipher(ef, name, data_enc, size, compress, cipher_key);
+ free(data_enc);
+ return val;
+}
+
+EAPI int
+eet_data_write(Eet_File *ef, Eet_Data_Descriptor *edd, const char *name, const void *data, int compress)
+{
+ return eet_data_write_cipher(ef, edd, name, NULL, data, compress);
+}
static int
_eet_free_hash(void *data)
ef->ref--;
}
-static Eet_Free freelist = { 0, { 0 }, { 0 }, { NULL } };
-
-#define _eet_freelist_add(Data) _eet_free_add(&freelist, Data);
-#define _eet_freelist_reset() _eet_free_reset(&freelist);
-#define _eet_freelist_ref() _eet_free_ref(&freelist);
-#define _eet_freelist_unref() _eet_free_unref(&freelist);
+#define _eet_freelist_add(Ctx, Data) _eet_free_add(&Ctx->freelist, Data);
+#define _eet_freelist_reset(Ctx) _eet_free_reset(&Ctx->freelist);
+#define _eet_freelist_ref(Ctx) _eet_free_ref(&Ctx->freelist);
+#define _eet_freelist_unref(Ctx) _eet_free_unref(&Ctx->freelist);
static void
-_eet_freelist_free(Eet_Data_Descriptor *edd)
+_eet_freelist_free(Eet_Free_Context *context, Eet_Data_Descriptor *edd)
{
int j;
int i;
- if (freelist.ref > 0) return;
+ if (context->freelist.ref > 0) return;
for (j = 0; j < 256; ++j)
- for (i = 0; i < freelist.num[j]; ++i)
+ for (i = 0; i < context->freelist.num[j]; ++i)
{
if (edd)
- edd->func.mem_free(freelist.list[j][i]);
+ edd->func.mem_free(context->freelist.list[j][i]);
else
- free(freelist.list[j][i]);
+ free(context->freelist.list[j][i]);
}
- _eet_free_reset(&freelist);
+ _eet_free_reset(&context->freelist);
}
-static Eet_Free freelist_list = { 0, { 0 }, { 0 }, { NULL } };
-
-#define _eet_freelist_list_add(Data) _eet_free_add(&freelist_list, Data);
-#define _eet_freelist_list_reset() _eet_free_reset(&freelist_list);
-#define _eet_freelist_list_ref() _eet_free_ref(&freelist_list);
-#define _eet_freelist_list_unref() _eet_free_unref(&freelist_list);
+#define _eet_freelist_list_add(Ctx, Data) _eet_free_add(&Ctx->freelist_list, Data);
+#define _eet_freelist_list_reset(Ctx) _eet_free_reset(&Ctx->freelist_list);
+#define _eet_freelist_list_ref(Ctx) _eet_free_ref(&Ctx->freelist_list);
+#define _eet_freelist_list_unref(Ctx) _eet_free_unref(&Ctx->freelist_list);
static void
-_eet_freelist_list_free(Eet_Data_Descriptor *edd)
+_eet_freelist_list_free(Eet_Free_Context *context, Eet_Data_Descriptor *edd)
{
int j;
int i;
- if (freelist_list.ref > 0) return;
+ if (context->freelist_list.ref > 0) return;
for (j = 0; j < 256; ++j)
- for (i = 0; i < freelist_list.num[j]; ++i)
+ for (i = 0; i < context->freelist_list.num[j]; ++i)
{
if (edd)
- edd->func.list_free(*((void**)(freelist_list.list[j][i])));
+ edd->func.list_free(*((void**)(context->freelist_list.list[j][i])));
}
- _eet_free_reset(&freelist_list);
+ _eet_free_reset(&context->freelist_list);
}
-static Eet_Free freelist_str = { 0, { 0 }, { 0 }, { NULL } };
-
-#define _eet_freelist_str_add(Data) _eet_free_add(&freelist_str, Data);
-#define _eet_freelist_str_reset() _eet_free_reset(&freelist_str);
-#define _eet_freelist_str_ref() _eet_free_ref(&freelist_str);
-#define _eet_freelist_str_unref() _eet_free_unref(&freelist_str);
+#define _eet_freelist_str_add(Ctx, Data) _eet_free_add(&Ctx->freelist_str, Data);
+#define _eet_freelist_str_reset(Ctx) _eet_free_reset(&Ctx->freelist_str);
+#define _eet_freelist_str_ref(Ctx) _eet_free_ref(&Ctx->freelist_str);
+#define _eet_freelist_str_unref(Ctx) _eet_free_unref(&Ctx->freelist_str);
static void
-_eet_freelist_str_free(Eet_Data_Descriptor *edd)
+_eet_freelist_str_free(Eet_Free_Context *context, Eet_Data_Descriptor *edd)
{
int j;
int i;
- if (freelist_str.ref > 0) return;
+ if (context->freelist_str.ref > 0) return;
for (j = 0; j < 256; ++j)
- for (i = 0; i < freelist_str.num[j]; ++i)
+ for (i = 0; i < context->freelist_str.num[j]; ++i)
{
if (edd)
- edd->func.str_free(freelist_str.list[j][i]);
+ edd->func.str_free(context->freelist_str.list[j][i]);
else
- free(freelist_str.list[j][i]);
+ free(context->freelist_str.list[j][i]);
}
- _eet_free_reset(&freelist_str);
+ _eet_free_reset(&context->freelist_str);
}
-static Eet_Free freelist_direct_str = { 0, { 0 }, { 0 }, { NULL } };
+#define _eet_freelist_direct_str_add(Ctx, Data) _eet_free_add(&Ctx->freelist_direct_str, Data);
+#define _eet_freelist_direct_str_reset(Ctx) _eet_free_reset(&Ctx->freelist_direct_str);
+#define _eet_freelist_direct_str_ref(Ctx) _eet_free_ref(&Ctx->freelist_direct_str);
+#define _eet_freelist_direct_str_unref(Ctx) _eet_free_unref(&Ctx->freelist_direct_str);
-#define _eet_freelist_direct_str_add(Data) _eet_free_add(&freelist_direct_str, Data);
-#define _eet_freelist_direct_str_reset() _eet_free_reset(&freelist_direct_str);
-#define _eet_freelist_direct_str_ref() _eet_free_ref(&freelist_direct_str);
-#define _eet_freelist_direct_str_unref() _eet_free_unref(&freelist_direct_str);
+static void
+_eet_freelist_direct_str_free(Eet_Free_Context *context, Eet_Data_Descriptor *edd)
+{
+ int j;
+ int i;
+
+ if (context->freelist_direct_str.ref > 0) return;
+ for (j = 0; j < 256; ++j)
+ for (i = 0; i < context->freelist_direct_str.num[j]; ++i)
+ {
+ if (edd)
+ edd->func.str_direct_free(context->freelist_direct_str.list[j][i]);
+ else
+ free(context->freelist_direct_str.list[j][i]);
+ }
+ _eet_free_reset(&context->freelist_direct_str);
+}
+
+#define _eet_freelist_hash_add(Ctx, Data) _eet_free_add(&Ctx->freelist_hash, Data);
+#define _eet_freelist_hash_reset(Ctx) _eet_free_reset(&Ctx->freelist_hash);
+#define _eet_freelist_hash_ref(Ctx) _eet_free_ref(&Ctx->freelist_hash);
+#define _eet_freelist_hash_unref(Ctx) _eet_free_unref(&Ctx->freelist_hash);
static void
-_eet_freelist_direct_str_free(Eet_Data_Descriptor *edd)
+_eet_freelist_hash_free(Eet_Free_Context *context, Eet_Data_Descriptor *edd)
{
int j;
int i;
- if (freelist_str.ref > 0) return;
+ if (context->freelist_hash.ref > 0) return;
for (j = 0; j < 256; ++j)
- for (i = 0; i < freelist_str.num[j]; ++i)
+ for (i = 0; i < context->freelist_hash.num[j]; ++i)
{
if (edd)
- edd->func.str_direct_free(freelist_str.list[j][i]);
+ edd->func.hash_free(context->freelist_hash.list[j][i]);
else
- free(freelist_str.list[j][i]);
+ free(context->freelist_hash.list[j][i]);
}
- _eet_free_reset(&freelist_str);
+ _eet_free_reset(&context->freelist_hash);
+}
+
+static void
+_eet_freelist_all_ref(Eet_Free_Context *freelist_context)
+{
+ _eet_freelist_ref(freelist_context);
+ _eet_freelist_str_ref(freelist_context);
+ _eet_freelist_list_ref(freelist_context);
+ _eet_freelist_hash_ref(freelist_context);
+ _eet_freelist_direct_str_ref(freelist_context);
+}
+
+static void
+_eet_freelist_all_unref(Eet_Free_Context *freelist_context)
+{
+ _eet_freelist_unref(freelist_context);
+ _eet_freelist_str_unref(freelist_context);
+ _eet_freelist_list_unref(freelist_context);
+ _eet_freelist_hash_unref(freelist_context);
+ _eet_freelist_direct_str_unref(freelist_context);
}
static int
-eet_data_descriptor_encode_hash_cb(void *hash __UNUSED__, const char *key, void *hdata, void *fdata)
+eet_data_descriptor_encode_hash_cb(void *hash __UNUSED__, const char *cipher_key, void *hdata, void *fdata)
{
Eet_Dictionary *ed;
Eet_Data_Encode_Hash_Info *edehi;
/* Store key */
data = eet_data_put_type(ed,
EET_T_STRING,
- &key,
+ &cipher_key,
&size);
if (data)
{
data = NULL;
}
- EET_ASSERT(!IS_SIMPLE_TYPE(ede->type), return 1);
+ EET_ASSERT(!((ede->type > EET_T_UNKNOW) && (ede->type < EET_T_STRING)), return );
/* Store data */
- if (ede->subtype)
- data = _eet_data_descriptor_encode(ed,
- ede->subtype,
- hdata,
- &size);
- if (data)
- {
- echnk = eet_data_chunk_new(data, size, ede->name, ede->type, ede->group_type);
- eet_data_chunk_put(ed, echnk, ds);
- eet_data_chunk_free(echnk);
- free(data);
- data = NULL;
- }
- return 1;
-}
-
-static char *
-_eet_data_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 (ede->type >= EET_T_STRING)
+ eet_data_put_unknown(ed, NULL, ede, ds, &hdata);
+ else
{
- if (*strp == '\"')
- {
- *sp = '\\';
- sp++;
- }
- else if (*strp == '\\')
+ if (ede->subtype)
+ data = _eet_data_descriptor_encode(ed,
+ ede->subtype,
+ hdata,
+ &size);
+ if (data)
{
- *sp = '\\';
- sp++;
+ echnk = eet_data_chunk_new(data, size, ede->name, ede->type, ede->group_type);
+ eet_data_chunk_put(ed, echnk, ds);
+ eet_data_chunk_free(echnk);
+ free(data);
+ data = NULL;
}
- *sp = *strp;
}
- *sp = 0;
- return s;
-}
-
-static void
-_eet_data_dump_string_escape(void *dumpdata, void dumpfunc(void *data, const char *str), const char *str)
-{
- char *s;
- s = _eet_data_string_escape(str);
- if (s)
- {
- dumpfunc(dumpdata, s);
- free(s);
- }
+ return 1;
}
static char *
{
/* skip */
}
+ else if ((p[0] == '\\') && (*len > 1) && (p[1] == 'n'))
+ {
+ /* skip */
+ }
+ else if ((p[0] == 'n') && (p > src) && (p[-1] == '\\'))
+ {
+ TOK_ADD('\n');
+ }
else
TOK_ADD(p[0]);
}
return NULL;
}
-typedef struct _Node Node;
-
-struct _Node
-{
- int type;
- int count;
- char *name;
- char *key;
- Node *values;
- Node *prev;
- Node *next;
- Node *parent;
- union {
- char c;
- short s;
- int i;
- long long l;
- float f;
- double d;
- unsigned char uc;
- unsigned short us;
- unsigned int ui;
- unsigned long long ul;
- char *str;
- } data;
-};
-
static void
-_eet_data_dump_free(Node *node)
+eet_data_encode(Eet_Dictionary *ed, Eet_Data_Stream *ds, void *data, const char *name, int size, int type, int group_type)
{
- Node *n, *n2;
+ Eet_Data_Chunk *echnk;
- switch (node->type)
- {
- case EET_G_UNKNOWN:
- case EET_G_ARRAY:
- case EET_G_VAR_ARRAY:
- case EET_G_LIST:
- case EET_G_HASH:
- if (node->key) free(node->key);
- for (n = node->values; n;)
- {
- n2 = n;
- n = n->next;
- _eet_data_dump_free(n2);
- }
- 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:
- case EET_T_ULONG_LONG:
- break;
- case EET_T_INLINED_STRING:
- case EET_T_STRING:
- if (node->data.str) free(node->data.str);
- break;
- default:
- break;
- }
- free(node);
+ if (!data) type = EET_T_NULL;
+
+ if (group_type != EET_G_UNKNOWN)
+ if (type >= EET_T_LAST)
+ type = EET_T_UNKNOW;
+
+ echnk = eet_data_chunk_new(data, size, name, type, group_type);
+ eet_data_chunk_put(ed, echnk, ds);
+ eet_data_chunk_free(echnk);
+ free(data);
}
static void *
-_eet_data_dump_encode(Eet_Dictionary *ed,
- Node *node,
+_eet_data_dump_encode(int parent_type,
+ Eet_Dictionary *ed,
+ Eet_Node *node,
int *size_ret)
{
- Eet_Data_Chunk *chnk = NULL, *echnk = NULL;
+ Eet_Data_Chunk *chnk = NULL;
Eet_Data_Stream *ds;
void *cdata, *data;
int csize, size;
- Node *n;
+ int count;
+ int child_type;
+ Eet_Node *n;
- if (words_bigendian == -1)
+ if (_eet_data_words_bigendian == -1)
{
unsigned long int v;
v = htonl(0x12345678);
- if (v == 0x12345678) words_bigendian = 1;
- else words_bigendian = 0;
+ if (v == 0x12345678) _eet_data_words_bigendian = 1;
+ else _eet_data_words_bigendian = 0;
}
+ if (node == NULL) return NULL;
+
ds = eet_data_stream_new();
if (!ds) return NULL;
case EET_G_UNKNOWN:
for (n = node->values; n; n = n->next)
{
- data = _eet_data_dump_encode(ed, n, &size);
+ data = _eet_data_dump_encode(node->type, ed, n, &size);
if (data)
{
eet_data_stream_write(ds, data, size);
break;
case EET_G_ARRAY:
case EET_G_VAR_ARRAY:
+ for (child_type = EET_T_NULL, n = node->values; n; n = n->next)
+ {
+ if (n->type != EET_T_NULL)
+ {
+ child_type = n->type;
+ break;
+ }
+ }
+
data = eet_data_put_type(ed,
EET_T_INT,
&node->count,
&size);
- if (data)
- {
- echnk = eet_data_chunk_new(data, size, node->name, node->type, node->type);
- eet_data_chunk_put(ed, echnk, ds);
- eet_data_chunk_free(echnk);
- free(data);
- }
+ eet_data_encode(ed, ds, data, node->name, size, child_type, node->type);
+
+ count = node->count;
+
for (n = node->values; n; n = n->next)
{
- data = _eet_data_dump_encode(ed, n, &size);
- if (data)
+ int pos = ds->pos;
+
+ switch (n->type)
{
- echnk = eet_data_chunk_new(data, size, node->name, node->type, node->type);
- eet_data_chunk_put(ed, echnk, ds);
- eet_data_chunk_free(echnk);
- free(data);
+ case EET_T_STRING:
+ case EET_T_INLINED_STRING:
+ data = eet_data_put_type(ed, n->type, &(n->data.value.str), &size);
+ if (data) eet_data_encode(ed, ds, data, node->name, size, n->type, node->type);
+ break;
+ case EET_T_NULL:
+ continue;
+ default:
+ data = _eet_data_dump_encode(n->type, ed, n, &size);
+ eet_data_encode(ed, ds, data, node->name, size, n->type, node->type);
+ break;
}
+ if (ds->pos != pos) count--;
+ }
+
+ for (; count; count--)
+ {
+ eet_data_encode(ed, ds, NULL, node->name, 0, EET_T_NULL, node->type);
}
/* Array is somekind of special case, so we should embed it inside another chunk. */
eet_data_stream_free(ds);
return cdata;
+ break;
case EET_G_LIST:
for (n = node->values; n; n = n->next)
{
- data = _eet_data_dump_encode(ed, n, &size);
- if (data)
+ switch (n->type)
{
- eet_data_stream_write(ds, data, size);
- free(data);
+ case EET_T_STRING:
+ case EET_T_INLINED_STRING:
+ data = eet_data_put_type(ed, n->type, &(n->data.value.str), &size);
+ if (data) eet_data_encode(ed, ds, data, node->name, size, n->type, node->type);
+ break;
+ case EET_T_NULL:
+ continue;
+ default:
+ data = _eet_data_dump_encode(node->type, ed, n, &size);
+ eet_data_encode(ed, ds, data, node->name, size, n->type, node->type);
}
}
+
+ /* List is another somekind of special case, every chunk is embed inside a list chunk. */
+ *size_ret = ds->pos;
+ cdata = ds->data;
+
+ ds->data = NULL;
+ ds->size = 0;
+ eet_data_stream_free(ds);
+
+ return cdata;
break;
case EET_G_HASH:
if (node->key)
EET_T_STRING,
&node->key,
&size);
- if (data)
- {
- echnk = eet_data_chunk_new(data, size, node->name, node->type, node->type);
- eet_data_chunk_put(ed, echnk, ds);
- eet_data_chunk_free(echnk);
- free(data);
- }
+ eet_data_encode(ed, ds, data, node->name, size, node->type, node->type);
}
+ else
+ /* A Hash without key will not decode correctly. */
+ return NULL;
+
for (n = node->values; n; n = n->next)
{
- data = _eet_data_dump_encode(ed, n, &size);
- if (data)
+ switch (n->type)
{
- echnk = eet_data_chunk_new(data, size, node->name, node->type, node->type);
- eet_data_chunk_put(ed, echnk, ds);
- eet_data_chunk_free(echnk);
- free(data);
+ case EET_T_STRING:
+ case EET_T_INLINED_STRING:
+ data = eet_data_put_type(ed, n->type, &(n->data.value.str), &size);
+ if (data) eet_data_encode(ed, ds, data, node->name, size, n->type, node->type);
+ break;
+ case EET_T_NULL:
+ continue;
+ default:
+ data = _eet_data_dump_encode(node->type, ed, n, &size);
+ eet_data_encode(ed, ds, data, node->name, size, n->type, node->type);
}
}
*size_ret = ds->pos;
cdata = ds->data;
- ds->data = NULL;
- ds->size = 0;
- eet_data_stream_free(ds);
+ eet_data_stream_flush(ds);
return cdata;
- case EET_T_CHAR:
- data = eet_data_put_type(ed, node->type, &(node->data.c), &size);
- if (data)
- {
- eet_data_stream_write(ds, data, size);
- free(data);
- }
- break;
- case EET_T_SHORT:
- data = eet_data_put_type(ed, node->type, &(node->data.s), &size);
- if (data)
- {
- eet_data_stream_write(ds, data, size);
- free(data);
- }
- break;
- case EET_T_INT:
- data = eet_data_put_type(ed, node->type, &(node->data.i), &size);
- if (data)
- {
- eet_data_stream_write(ds, data, size);
- free(data);
- }
- break;
- case EET_T_LONG_LONG:
- data = eet_data_put_type(ed, node->type, &(node->data.l), &size);
- if (data)
- {
- eet_data_stream_write(ds, data, size);
- free(data);
- }
- break;
- case EET_T_FLOAT:
- data = eet_data_put_type(ed, node->type, &(node->data.f), &size);
- if (data)
- {
- eet_data_stream_write(ds, data, size);
- free(data);
- }
- break;
- case EET_T_DOUBLE:
- data = eet_data_put_type(ed, node->type, &(node->data.d), &size);
- if (data)
- {
- eet_data_stream_write(ds, data, size);
- free(data);
- }
- break;
- case EET_T_UCHAR:
- data = eet_data_put_type(ed, node->type, &(node->data.uc), &size);
- if (data)
- {
- eet_data_stream_write(ds, data, size);
- free(data);
- }
- break;
- case EET_T_USHORT:
- data = eet_data_put_type(ed, node->type, &(node->data.us), &size);
- if (data)
- {
- eet_data_stream_write(ds, data, size);
- free(data);
- }
- break;
- case EET_T_UINT:
- data = eet_data_put_type(ed, node->type, &(node->data.ui), &size);
- if (data)
- {
- eet_data_stream_write(ds, data, size);
- free(data);
- }
- break;
- case EET_T_ULONG_LONG:
- data = eet_data_put_type(ed, node->type, &(node->data.ul), &size);
- if (data)
- {
- eet_data_stream_write(ds, data, size);
- free(data);
- }
- break;
- case EET_T_INLINED_STRING:
- data = eet_data_put_type(ed, node->type, &(node->data.str), &size);
- if (data)
- {
- eet_data_stream_write(ds, data, size);
- free(data);
- }
- break;
- case EET_T_STRING:
- data = eet_data_put_type(ed, node->type, &(node->data.str), &size);
- if (data)
- {
- eet_data_stream_write(ds, data, size);
- free(data);
- }
+ case EET_T_NULL:
+ break;
+
+#define EET_DATA_NODE_ENCODE(Eet_Type, Type) \
+ case Eet_Type: \
+ data = eet_data_put_type(ed, node->type, &(node->data.value.Type), &size); \
+ if (data) \
+ { \
+ eet_data_encode(ed, ds, data, node->name, size, node->type, parent_type); \
+ cdata = ds->data; \
+ *size_ret = ds->pos; \
+ eet_data_stream_flush(ds); \
+ return cdata; \
+ } \
break;
+
+ EET_DATA_NODE_ENCODE(EET_T_CHAR, c);
+ EET_DATA_NODE_ENCODE(EET_T_SHORT, s);
+ EET_DATA_NODE_ENCODE(EET_T_INT, i);
+ EET_DATA_NODE_ENCODE(EET_T_LONG_LONG, l);
+ EET_DATA_NODE_ENCODE(EET_T_FLOAT, f);
+ EET_DATA_NODE_ENCODE(EET_T_DOUBLE, d);
+ EET_DATA_NODE_ENCODE(EET_T_UCHAR, uc);
+ EET_DATA_NODE_ENCODE(EET_T_USHORT, us);
+ EET_DATA_NODE_ENCODE(EET_T_UINT, ui);
+ EET_DATA_NODE_ENCODE(EET_T_ULONG_LONG, ul);
+ EET_DATA_NODE_ENCODE(EET_T_INLINED_STRING, str);
+ EET_DATA_NODE_ENCODE(EET_T_STRING, str);
default:
break;
}
chnk = eet_data_chunk_new(ds->data, ds->pos, node->name, EET_T_UNKNOW, node->type);
else
chnk = eet_data_chunk_new(ds->data, ds->pos, node->name, node->type, EET_G_UNKNOWN);
- ds->data = NULL;
- ds->size = 0;
- eet_data_stream_free(ds);
+ eet_data_stream_flush(ds);
ds = eet_data_stream_new();
eet_data_chunk_put(ed, chnk, ds);
cdata = ds->data;
csize = ds->pos;
- ds->data = NULL;
- ds->size = 0;
- eet_data_stream_free(ds);
+ eet_data_stream_flush(ds);
*size_ret = csize;
free(chnk->data);
int size)
{
void *cdata = NULL;
- const char *p;
+ const char *p = NULL;
#define M_NONE 0
#define M_STRUCT 1
#define M_ 2
int left, jump;
- Node *node_base = NULL;
- Node *node = NULL;
- Node *n, *nn;
+ Eet_Node *node_base = NULL;
+ Eet_Node *node = NULL;
+ Eet_Node *n = NULL, *nn = NULL;
/* FIXME; handle parse errors */
#define TOK_GET(t) \
if (!strcmp(tok4, "{"))
{
/* we have 'group NAM TYP {' */
- n = calloc(1, sizeof(Node));
+ n = eet_node_new();
if (n)
{
n->parent = node;
{
node_base = n;
}
- if (!node)
- {
- node = n;
- }
- else
+ if (node)
{
/* append node */
if (!node->values)
if (!nn->next)
{
nn->next = n;
- n->prev = nn;
break;
}
}
}
}
- n->name = strdup(tok2);
+ n->name = eina_stringshare_add(tok2);
if (!strcmp(tok3, "struct")) n->type = EET_G_UNKNOWN;
else if (!strcmp(tok3, "array")) n->type = EET_G_ARRAY;
else if (!strcmp(tok3, "var_array")) n->type = EET_G_VAR_ARRAY;
else if (!strcmp(tok3, "hash")) n->type = EET_G_HASH;
else
{
- printf("ERROR: group type '%s' invalid.\n", tok3);
+ ERR("ERROR: group type '%s' invalid.", tok3);
}
node = n;
}
/* we have 'value NAME TYP XXX' */
if (node_base)
{
- n = calloc(1, sizeof(Node));
+ n = eet_node_new();
if (n)
{
n->parent = node;
if (!nn->next)
{
nn->next = n;
- n->prev = nn;
break;
}
}
}
- n->name = strdup(tok2);
+ n->name = eina_stringshare_add(tok2);
if (!strcmp(tok3, "char:"))
{
n->type = EET_T_CHAR;
- sscanf(tok4, "%hhi", &(n->data.c));
+ sscanf(tok4, "%hhi", &(n->data.value.c));
}
else if (!strcmp(tok3, "short:"))
{
n->type = EET_T_SHORT;
- sscanf(tok4, "%hi", &(n->data.s));
+ sscanf(tok4, "%hi", &(n->data.value.s));
}
else if (!strcmp(tok3, "int:"))
{
n->type = EET_T_INT;
- sscanf(tok4, "%i", &(n->data.i));
+ sscanf(tok4, "%i", &(n->data.value.i));
}
else if (!strcmp(tok3, "long_long:"))
{
n->type = EET_T_LONG_LONG;
- sscanf(tok4, "%lli", &(n->data.l));
+ sscanf(tok4, "%lli", &(n->data.value.l));
}
else if (!strcmp(tok3, "float:"))
{
n->type = EET_T_FLOAT;
- sscanf(tok4, "%f", &(n->data.f));
+ sscanf(tok4, "%f", &(n->data.value.f));
}
else if (!strcmp(tok3, "double:"))
{
n->type = EET_T_DOUBLE;
- sscanf(tok4, "%lf", &(n->data.d));
+ sscanf(tok4, "%lf", &(n->data.value.d));
}
else if (!strcmp(tok3, "uchar:"))
{
n->type = EET_T_UCHAR;
- sscanf(tok4, "%hhu", &(n->data.uc));
+ sscanf(tok4, "%hhu", &(n->data.value.uc));
}
else if (!strcmp(tok3, "ushort:"))
{
n->type = EET_T_USHORT;
- sscanf(tok4, "%hu", &(n->data.us));
+ sscanf(tok4, "%hu", &(n->data.value.us));
}
else if (!strcmp(tok3, "uint:"))
{
n->type = EET_T_UINT;
- sscanf(tok4, "%u", &(n->data.ui));
+ sscanf(tok4, "%u", &(n->data.value.ui));
}
else if (!strcmp(tok3, "ulong_long:"))
{
n->type = EET_T_ULONG_LONG;
- sscanf(tok4, "%llu", &(n->data.ul));
+ sscanf(tok4, "%llu", &(n->data.value.ul));
}
else if (!strcmp(tok3, "string:"))
{
n->type = EET_T_STRING;
- n->data.str = strdup(tok4);
+ n->data.value.str = eina_stringshare_add(tok4);
}
else if (!strcmp(tok3, "inlined:"))
{
n->type = EET_T_INLINED_STRING;
- n->data.str = strdup(tok4);
+ n->data.value.str = eina_stringshare_add(tok4);
+ }
+ else if (!strcmp(tok3, "null"))
+ {
+ n->type = EET_T_NULL;
+ n->data.value.str = NULL;
}
else
{
- printf("ERROR: value type '%s' invalid.\n", tok4);
+ ERR("ERROR: value type '%s' invalid.", tok4);
}
}
}
/* we have 'key NAME' */
if (node)
{
- node->key = strdup(tok2);
+ node->key = eina_stringshare_add(tok2);
}
free(tok2);
}
if (node_base)
{
- cdata = _eet_data_dump_encode(ed, node_base, size_ret);
- _eet_data_dump_free(node_base);
+ cdata = _eet_data_dump_encode(EET_G_UNKNOWN, ed, node_base, size_ret);
+ eet_node_del(node_base);
}
return cdata;
}
}
static void *
-_eet_data_descriptor_decode(const Eet_Dictionary *ed,
+_eet_data_descriptor_decode(Eet_Free_Context *context,
+ const Eet_Dictionary *ed,
Eet_Data_Descriptor *edd,
const void *data_in,
- int size_in,
- int level,
- void (*dumpfunc) (void *data, const char *str),
- void *dumpdata)
+ int size_in)
{
+ Eet_Node *result = NULL;
void *data = NULL;
- char *p, *buf, tbuf[256];
- int size, i, dump;
+ char *p;
+ int size, i;
Eet_Data_Chunk chnk;
- if (words_bigendian == -1)
+ if (_eet_data_words_bigendian == -1)
{
unsigned long int v;
v = htonl(0x12345678);
- if (v == 0x12345678) words_bigendian = 1;
- else words_bigendian = 0;
+ if (v == 0x12345678) _eet_data_words_bigendian = 1;
+ else _eet_data_words_bigendian = 0;
}
if (edd)
edd->ed = ed;
}
}
- _eet_freelist_ref();
- _eet_freelist_str_ref();
- _eet_freelist_list_ref();
- if (data) _eet_freelist_add(data);
- dump = 0;
+ _eet_freelist_all_ref(context);
+ if (data) _eet_freelist_add(context, data);
memset(&chnk, 0, sizeof(Eet_Data_Chunk));
eet_data_chunk_get(ed, &chnk, data_in, size_in);
if (!chnk.name) goto error;
{
if (!edd->elements.hash.buckets) _eet_descriptor_hash_new(edd);
}
- if (dumpfunc)
+ else
{
- dump = 1;
- if (chnk.type == EET_T_UNKNOW)
+ switch (chnk.group_type)
{
- buf = tbuf;
-
- for (i = 0; i < level; i++) dumpfunc(dumpdata, " ");
- dumpfunc(dumpdata, "group \"");
- _eet_data_dump_string_escape(dumpdata, dumpfunc, chnk.name);
- dumpfunc(dumpdata, "\" ");
- switch (chnk.group_type)
- {
- case EET_G_UNKNOWN:
- dumpfunc(dumpdata, "struct");
- break;
- case EET_G_ARRAY:
- dumpfunc(dumpdata, "array");
- break;
- case EET_G_VAR_ARRAY:
- dumpfunc(dumpdata, "var_array");
- break;
- case EET_G_LIST:
- dumpfunc(dumpdata, "list");
- break;
- case EET_G_HASH:
- dumpfunc(dumpdata, "hash");
- break;
- default:
- dumpfunc(dumpdata, "???");
- break;
- }
- dumpfunc(dumpdata, " {\n");
+ case EET_G_UNKNOWN:
+ switch (chnk.type)
+ {
+ case EET_T_STRING:
+ return eet_node_string_new(chnk.name, chnk.data);
+ case EET_T_INLINED_STRING:
+ return eet_node_inlined_string_new(chnk.name, chnk.data);
+ case EET_T_NULL:
+ return eet_node_null_new(chnk.name);
+ default:
+ result = eet_node_struct_new(chnk.name, NULL);
+ }
+ break;
+ case EET_G_VAR_ARRAY:
+ return eet_node_var_array_new(chnk.name, NULL);
+ case EET_G_LIST:
+ goto error;
+ case EET_G_HASH:
+ goto error;
+ case EET_G_ARRAY:
+ goto error;
+ default:
+ goto error;
}
}
while (size > 0)
{
Eet_Data_Chunk echnk;
- Eet_Data_Element *ede;
+ Eet_Data_Element *ede = NULL;
+ Eet_Node *child = NULL;
+ int group_type = EET_G_UNKNOWN, type = EET_T_UNKNOW;
+ int ret = 0;
/* get next data chunk */
memset(&echnk, 0, sizeof(Eet_Data_Chunk));
eet_data_chunk_get(ed, &echnk, p, size);
if (!echnk.name) goto error;
/* FIXME: don't REPLY on edd - work without */
- if ((edd) && (!dumpfunc))
+ if (edd)
{
ede = _eet_descriptor_hash_find(edd, echnk.name, echnk.hash);
if (ede)
{
- int group_type = EET_G_UNKNOWN, type = EET_T_UNKNOW;
- int ret = 0;
-
group_type = ede->group_type;
type = ede->type;
if ((echnk.type == 0) && (echnk.group_type == 0))
else
{
if (IS_SIMPLE_TYPE(echnk.type) &&
- (echnk.type == ede->type))
- type = echnk.type;
+ eet_data_type_match(echnk.type, ede->type))
+ /* Needed when converting on the fly from FP to Float */
+ type = ede->type;
else if ((echnk.group_type > EET_G_UNKNOWN) &&
(echnk.group_type < EET_G_LAST) &&
(echnk.group_type == ede->group_type))
group_type = echnk.group_type;
}
- /* hashes doesnt fit well with the table */
- ret = eet_group_codec[group_type - 100].get(ed, edd, ede, &echnk, type, group_type, ((char *)data) + ede->offset, level, dumpfunc, dumpdata, &p, &size);
- if (ret <= 0) goto error;
}
}
- /*...... dump func */
- else if (dumpfunc)
+ /*...... dump to node */
+ else
+ {
+ type = echnk.type;
+ group_type = echnk.group_type;
+ }
+
+ if (!edd && group_type == EET_G_UNKNOWN && IS_SIMPLE_TYPE(type))
{
unsigned char dd[128];
- int group_type = EET_G_UNKNOWN, type = EET_T_UNKNOW;
-
- if ((echnk.type > EET_T_UNKNOW) &&
- (echnk.type < EET_T_LAST))
- type = echnk.type;
- else if ((echnk.group_type > EET_G_UNKNOWN) &&
- (echnk.group_type < EET_G_LAST))
- group_type = echnk.group_type;
- if (group_type == EET_G_UNKNOWN)
- {
- int ret;
- void *data_ret;
- if (IS_SIMPLE_TYPE(type))
- {
- ret = eet_data_get_type(ed,
- type,
- echnk.data,
- ((char *)echnk.data) + echnk.size,
- dd);
- for (i = 0; i < level; i++) dumpfunc(dumpdata, " ");
- dumpfunc(dumpdata, " value \"");
- _eet_data_dump_string_escape(dumpdata, dumpfunc, echnk.name);
- dumpfunc(dumpdata, "\" ");
- switch (type)
- {
- case EET_T_CHAR:
- dumpfunc(dumpdata, "char: ");
- snprintf(tbuf, sizeof(tbuf), "%hhi", *((char *)dd));
- dumpfunc(dumpdata, tbuf); break;
- case EET_T_SHORT:
- dumpfunc(dumpdata, "short: ");
- snprintf(tbuf, sizeof(tbuf), "%hi", *((short *)dd));
- dumpfunc(dumpdata, tbuf); break;
- case EET_T_INT:
- dumpfunc(dumpdata, "int: ");
- snprintf(tbuf, sizeof(tbuf), "%i", *((int *)dd));
- dumpfunc(dumpdata, tbuf); break;
- case EET_T_LONG_LONG:
- dumpfunc(dumpdata, "long_long: ");
- snprintf(tbuf, sizeof(tbuf), "%lli", *((long long *)dd));
- dumpfunc(dumpdata, tbuf); break;
- case EET_T_FLOAT:
- dumpfunc(dumpdata, "float: ");
- snprintf(tbuf, sizeof(tbuf), "%1.25f", *((float *)dd));
- dumpfunc(dumpdata, tbuf); break;
- case EET_T_DOUBLE:
- dumpfunc(dumpdata, "double: ");
- snprintf(tbuf, sizeof(tbuf), "%1.25f", *((double *)dd));
- dumpfunc(dumpdata, tbuf); break;
- case EET_T_UCHAR:
- dumpfunc(dumpdata, "uchar: ");
- snprintf(tbuf, sizeof(tbuf), "%hhu", *((unsigned char *)dd));
- dumpfunc(dumpdata, tbuf); break;
- case EET_T_USHORT:
- dumpfunc(dumpdata, "ushort: ");
- snprintf(tbuf, sizeof(tbuf), "%i", *((unsigned short *)dd));
- dumpfunc(dumpdata, tbuf); break;
- case EET_T_UINT:
- dumpfunc(dumpdata, "uint: ");
- snprintf(tbuf, sizeof(tbuf), "%u", *((unsigned int *)dd));
- dumpfunc(dumpdata, tbuf); break;
- case EET_T_ULONG_LONG:
- dumpfunc(dumpdata, "ulong_long: ");
- snprintf(tbuf, sizeof(tbuf), "%llu", *((unsigned long long *)dd));
- dumpfunc(dumpdata, tbuf); break;
- case EET_T_INLINED_STRING:
- {
- char *s;
+ ret = eet_data_get_type(ed,
+ type,
+ echnk.data,
+ ((char *)echnk.data) + echnk.size,
+ dd);
+ if (ret <= 0) goto error;
- s = *((char **)dd);
- if (s)
- {
- dumpfunc(dumpdata, "inlined: \"");
- _eet_data_dump_string_escape(dumpdata, dumpfunc, s);
- dumpfunc(dumpdata, "\"");
- }
- }
- break;
- case EET_T_STRING:
- {
- char *s;
+ child = eet_data_node_simple_type(type, echnk.name, dd);
- s = *((char **)dd);
- if (s)
- {
- dumpfunc(dumpdata, "string: \"");
- _eet_data_dump_string_escape(dumpdata, dumpfunc, s);
- dumpfunc(dumpdata, "\"");
- }
- }
- break;
- default:
- dumpfunc(dumpdata, "???: ???"); break;
- break;
- }
- dumpfunc(dumpdata, ";\n");
- }
- else
- {
- data_ret = _eet_data_descriptor_decode(ed,
- NULL,
- echnk.data,
- echnk.size,
- level + 1,
- dumpfunc,
- dumpdata);
- if (!data_ret) goto error;
- }
- }
- else
- {
- for (i = 0; i < level; i++) dumpfunc(dumpdata, " ");
- dumpfunc(dumpdata, " group \"");
- _eet_data_dump_string_escape(dumpdata, dumpfunc, echnk.name);
- dumpfunc(dumpdata, "\" ");
- switch (echnk.group_type)
- {
- case EET_G_UNKNOWN:
- dumpfunc(dumpdata, "struct");break;
- case EET_G_ARRAY:
- dumpfunc(dumpdata, "array");break;
- case EET_G_VAR_ARRAY:
- dumpfunc(dumpdata, "var_array");break;
- case EET_G_LIST:
- dumpfunc(dumpdata, "list");break;
- case EET_G_HASH:
- dumpfunc(dumpdata, "hash");break;
- default:
- dumpfunc(dumpdata, "???");break;
- break;
- }
- dumpfunc(dumpdata, " {\n");
- switch (group_type)
- {
- case EET_G_ARRAY:
- case EET_G_VAR_ARRAY:
- {
- int count;
- int ret;
- int i;
-
- EET_ASSERT(!IS_SIMPLE_TYPE(type), goto error);
-
- ret = eet_data_get_type(ed,
- EET_T_INT,
- echnk.data,
- ((char *)echnk.data) + echnk.size,
- &count);
- if (ret <= 0) goto error;
-
- for (i = 0; i < level; i++) dumpfunc(dumpdata, " ");
- dumpfunc(dumpdata, " count ");
- snprintf(tbuf, sizeof(tbuf), "%i", count);
- dumpfunc(dumpdata, tbuf);
- dumpfunc(dumpdata, ";\n");
-
- /* get all array elements */
- for (i = 0; i < count; i++)
- {
- void *data_ret = NULL;
-
- /* Advance to next chunk */
- NEXT_CHUNK(p, size, echnk, ed);
- memset(&echnk, 0, sizeof(Eet_Data_Chunk));
-
- eet_data_chunk_get(ed, &echnk, p, size);
- if (!echnk.name) goto error;
- /* get the data */
- data_ret = _eet_data_descriptor_decode(ed,
- NULL,
- echnk.data,
- echnk.size,
- level + 2,
- dumpfunc,
- dumpdata);
- if (!data_ret) goto error;
- }
- }
- break;
- case EET_G_LIST:
- {
- void *data_ret = NULL;
-
- EET_ASSERT(!IS_SIMPLE_TYPE(type), goto error);
-
- data_ret = _eet_data_descriptor_decode(ed,
- NULL,
- echnk.data,
- echnk.size,
- level + 2,
- dumpfunc,
- dumpdata);
- if (!data_ret) goto error;
- }
- break;
- case EET_G_HASH:
- {
- int ret;
- char *key = NULL;
- void *data_ret = NULL;
-
- /* Read key */
- ret = eet_data_get_type(ed,
- EET_T_STRING,
- echnk.data,
- ((char *)echnk.data) + echnk.size,
- &key);
- if (ret <= 0) goto error;
-
- /* Advance to next chunk */
- NEXT_CHUNK(p, size, echnk, ed);
- memset(&echnk, 0, sizeof(Eet_Data_Chunk));
-
- /* Read value */
- eet_data_chunk_get(ed, &echnk, p, size);
- if (!echnk.name) goto error;
-
- EET_ASSERT(!IS_SIMPLE_TYPE(type), goto error);
-
- {
- char *s;
-
- s = key;
- if (s)
- {
- for (i = 0; i < level; i++) dumpfunc(dumpdata, " ");
- dumpfunc(dumpdata, " key \"");
- _eet_data_dump_string_escape(dumpdata, dumpfunc, s);
- dumpfunc(dumpdata, "\";\n");
- }
- data_ret = _eet_data_descriptor_decode(ed,
- NULL,
- echnk.data,
- echnk.size,
- level + 2,
- dumpfunc,
- dumpdata);
- }
- if (!data_ret)
- {
- goto error;
- }
- }
- break;
- default:
- break;
- }
- if (dumpfunc)
- {
- for (i = 0; i < level; i++) dumpfunc(dumpdata, " ");
- dumpfunc(dumpdata, " }\n");
- }
- }
+ eet_node_struct_append(result, echnk.name, child);
+ }
+ else
+ {
+ ret = eet_group_codec[group_type - 100].get(context,
+ ed, edd, ede, &echnk,
+ type, group_type, ede ? (void*) (((char *)data) + ede->offset) : (void**) &result,
+ &p, &size);
+
+ if (ret <= 0) goto error;
}
+
/* advance to next chunk */
NEXT_CHUNK(p, size, echnk, ed);
}
- _eet_freelist_unref();
- _eet_freelist_str_unref();
- _eet_freelist_list_unref();
- if (dumpfunc)
+ _eet_freelist_all_unref(context);
+ if (!edd)
{
- _eet_freelist_str_free(edd);
- _eet_freelist_direct_str_free(edd);
- _eet_freelist_list_free(edd);
- _eet_freelist_free(edd);
+ _eet_freelist_str_free(context, edd);
+ _eet_freelist_direct_str_free(context, edd);
+ _eet_freelist_list_free(context, edd);
+ _eet_freelist_hash_free(context, edd);
+ _eet_freelist_free(context, edd);
}
else
{
- _eet_freelist_reset();
- _eet_freelist_str_reset();
- _eet_freelist_list_reset();
- _eet_freelist_direct_str_reset();
- }
- if (dumpfunc)
- {
- if (dump)
- {
- if (chnk.type == EET_T_UNKNOW)
- {
- for (i = 0; i < level; i++) dumpfunc(dumpdata, " ");
- dumpfunc(dumpdata, "}\n");
- }
- }
- return (void *)1;
+ _eet_freelist_reset(context);
+ _eet_freelist_str_reset(context);
+ _eet_freelist_list_reset(context);
+ _eet_freelist_hash_reset(context);
+ _eet_freelist_direct_str_reset(context);
}
+
+ if (!edd)
+ return result;
+
return data;
error:
- _eet_freelist_unref();
- _eet_freelist_str_unref();
- _eet_freelist_list_unref();
- _eet_freelist_str_free(edd);
- _eet_freelist_direct_str_free(edd);
- _eet_freelist_list_free(edd);
- _eet_freelist_free(edd);
- if (dumpfunc)
- {
- if (dump)
- {
- if (chnk.type == EET_T_UNKNOW)
- {
- for (i = 0; i < level; i++) dumpfunc(dumpdata, " ");
- dumpfunc(dumpdata, "}\n");
- }
- }
- }
+ eet_node_del(result);
+
+ _eet_freelist_all_unref(context);
+ _eet_freelist_str_free(context, edd);
+ _eet_freelist_direct_str_free(context, edd);
+ _eet_freelist_list_free(context, edd);
+ _eet_freelist_hash_free(context, edd);
+ _eet_freelist_free(context, edd);
+
+ /* FIXME: Warn that something goes wrong here. */
return NULL;
}
static int
-eet_data_get_list(const Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Chunk *echnk,
- int type __UNUSED__, int group_type __UNUSED__, void *data,
- int level, void (*dumpfunc) (void *data, const char *str), void *dumpdata,
- char **p __UNUSED__, int *size __UNUSED__)
+eet_data_get_list(Eet_Free_Context *context, const Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Chunk *echnk,
+ int type, int group_type __UNUSED__, void *data,
+ char **p, int *size)
{
+ Eet_Data_Descriptor *subtype = NULL;
void *list = NULL;
void **ptr;
void *data_ret;
EET_ASSERT(!((type > EET_T_UNKNOW) && (type < EET_T_STRING)), return 0);
+ if (edd)
+ {
+ subtype = ede->subtype;
+
+ if (type != ede->type)
+ return 0;
+ }
+
ptr = (void **)data;
list = *ptr;
data_ret = NULL;
- if (ede->type >= EET_T_STRING)
+ if (IS_POINTER_TYPE(type))
{
int ret;
- ret = eet_data_get_unknown(ed, edd, ede, echnk, ede->type, EET_G_UNKNOWN,
- &data_ret, level, dumpfunc, dumpdata, p, size);
+ ret = eet_data_get_unknown(context, ed, edd, ede, echnk, type, EET_G_UNKNOWN,
+ &data_ret, p, size);
if (!ret) return 0;
}
else
{
- data_ret = _eet_data_descriptor_decode(ed, ede->subtype, echnk->data, echnk->size, level + 2, dumpfunc, dumpdata);
+ data_ret = _eet_data_descriptor_decode(context, ed, subtype,
+ echnk->data, echnk->size);
if (!data_ret) return 0;
}
- list = edd->func.list_append(list, data_ret);
- *ptr = list;
- _eet_freelist_list_add(ptr);
+ if (edd)
+ {
+ list = edd->func.list_append(list, data_ret);
+ *ptr = list;
+ _eet_freelist_list_add(context, ptr);
+ }
+ else
+ {
+ eet_node_list_append(*((Eet_Node**) data), echnk->name, data_ret);
+ }
return 1;
}
static int
-eet_data_get_hash(const Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Chunk *echnk,
+eet_data_get_hash(Eet_Free_Context *context, const Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Chunk *echnk,
int type, int group_type __UNUSED__, void *data,
- int level, void (*dumpfunc) (void *data, const char *str), void *dumpdata,
char **p, int *size)
{
void **ptr;
void *data_ret = NULL;
int ret = 0;
- EET_ASSERT(!IS_SIMPLE_TYPE(type), return 0);
+ EET_ASSERT(!((type > EET_T_UNKNOW) && (type < EET_T_STRING)), return 0);
ptr = (void **)data;
hash = *ptr;
eet_data_chunk_get(ed, echnk, *p, *size);
if (!echnk->name) goto on_error;
- data_ret = _eet_data_descriptor_decode(ed,
- ede->subtype,
- echnk->data,
- echnk->size,
- level + 2,
- dumpfunc,
- dumpdata);
- if (!data_ret) goto on_error;
-
- hash = edd->func.hash_add(hash, key, data_ret);
- *ptr = hash;
- _eet_freelist_list_add(ptr);
+ if (IS_POINTER_TYPE(echnk->type))
+ {
+ ret = eet_data_get_unknown(context, ed, edd, ede, echnk, echnk->type, EET_G_UNKNOWN,
+ &data_ret, p, size);
+ if (!ret) goto on_error;
+ }
+ else
+ {
+ data_ret = _eet_data_descriptor_decode(context,
+ ed,
+ ede ? ede->subtype : NULL,
+ echnk->data,
+ echnk->size);
+ if (!data_ret) goto on_error;
+ }
+
+ if (edd)
+ {
+ hash = edd->func.hash_add(hash, key, data_ret);
+ *ptr = hash;
+ _eet_freelist_hash_add(context, hash);
+ }
+ else
+ {
+ eet_node_hash_add(*((Eet_Node **) data), echnk->name, key, data_ret);
+ }
+
return 1;
on_error:
* each chunk is pointless.
*/
static int
-eet_data_get_array(const Eet_Dictionary *ed, Eet_Data_Descriptor *edd __UNUSED__,
+eet_data_get_array(Eet_Free_Context *context, const Eet_Dictionary *ed, Eet_Data_Descriptor *edd,
Eet_Data_Element *ede, Eet_Data_Chunk *echnk,
int type, int group_type, void *data,
- int level, void (*dumpfunc) (void *data, const char *str), void *dumpdata,
char **p, int *size)
{
+ Eina_List *childs = NULL;
+ const char *name;
+ Eet_Node *tmp;
void *ptr;
int count;
int ret;
+ int subsize = 0;
int i;
- EET_ASSERT(!IS_SIMPLE_TYPE(type), return 0);
+ EET_ASSERT(!((type > EET_T_UNKNOW) && (type < EET_T_STRING)), return 0);
ptr = data;
/* read the number of elements */
((char *)echnk->data) + echnk->size,
&count);
if (ret <= 0) return ret;
- if (group_type == EET_G_VAR_ARRAY)
+
+ name = echnk->name;
+
+ if (ede)
{
- /* store the number of elements
- * on the counter offset */
- *(int *)(((char *)data) + ede->count - ede->offset) = count;
- /* allocate space for the array of elements */
- *(void **)ptr = calloc(count, ede->subtype->size);
+ if (IS_POINTER_TYPE(type))
+ subsize = eet_basic_codec[ede->type].size;
+ else
+ subsize = ede->subtype->size;
+
+ if (group_type == EET_G_VAR_ARRAY)
+ {
+ /* store the number of elements
+ * on the counter offset */
+ *(int *)(((char *)data) + ede->count - ede->offset) = count;
+ /* allocate space for the array of elements */
+ *(void **)ptr = edd->func.mem_alloc(count * subsize);
+
+ if (!*(void **)ptr) return 0;
- if (!*(void **)ptr) return 0;
+ memset(*(void **)ptr, 0, count * subsize);
- _eet_freelist_add(*(void **)ptr);
+ _eet_freelist_add(context, *(void **)ptr);
+ }
}
/* get all array elements */
for (i = 0; i < count; i++)
{
- void *dst;
+ void *dst = NULL;
void *data_ret = NULL;
/* Advance to next chunk */
memset(echnk, 0, sizeof(Eet_Data_Chunk));
eet_data_chunk_get(ed, echnk, *p, *size);
- if (!echnk->name) return 0;
+ if (!echnk->name || strcmp(echnk->name, name) != 0) goto on_error;
/* get the data */
+ if (echnk->group_type != group_type
+ || (echnk->type != type && echnk->type != EET_T_NULL))
+ goto on_error;
+
+ if (ede)
+ if (ede->group_type != echnk->group_type
+ || (echnk->type != ede->type && echnk->type != EET_T_NULL))
+ goto on_error;
+
/* get the destination pointer */
+ if (ede)
+ {
+ if (group_type == EET_G_ARRAY)
+ dst = (char *)ptr + (subsize * i);
+ else
+ dst = *(char **)ptr + (subsize * i);
+ }
+
+ if (IS_POINTER_TYPE(echnk->type))
+ {
+ ret = eet_data_get_unknown(context, ed, edd, ede, echnk, echnk->type, EET_G_UNKNOWN,
+ &data_ret, p, size);
+ if (!ret) goto on_error;
+ if (dst) memcpy(dst, &data_ret, subsize);
+ if (!edd) childs = eina_list_append(childs, data_ret);
+ }
+ else
+ {
+ data_ret = _eet_data_descriptor_decode(context, ed, ede ? ede->subtype : NULL,
+ echnk->data, echnk->size);
+ if (!data_ret) goto on_error;
+ if (dst)
+ {
+ memcpy(dst, data_ret, subsize);
+ _eet_freelist_add(context, data_ret);
+ }
+ if (!edd) childs = eina_list_append(childs, data_ret);
+ }
+ }
+
+ if (!edd)
+ {
+ Eet_Node *parent = *((Eet_Node **) data);
+ Eet_Node *array;
+
if (group_type == EET_G_ARRAY)
- dst = (char *)ptr + (ede->subtype->size * i);
+ array = eet_node_array_new(name, count, childs);
else
- dst = *(char **)ptr + (ede->subtype->size * i);
- data_ret = _eet_data_descriptor_decode(ed,
- ede->subtype,
- echnk->data,
- echnk->size,
- level + 2,
- dumpfunc,
- dumpdata);
- if (!data_ret) return 0;
- memcpy(dst, data_ret, ede->subtype->size);
- free(data_ret);
+ array = eet_node_var_array_new(name, childs);
+
+ if (!array) goto on_error;
+
+ eet_node_struct_append(parent, name, array);
}
+
return 1;
+
+ on_error:
+ EINA_LIST_FREE(childs, tmp)
+ eet_node_del(tmp);
+
+ return 0;
+}
+
+static Eet_Node *
+eet_data_node_simple_type(int type, const char *name, void *dd)
+{
+#ifdef EET_T_TYPE
+# undef EET_T_TYPE
+#endif
+
+#define EET_T_TYPE(Eet_Type, Eet_Node_Type, Type) \
+ case Eet_Type: \
+ return eet_node_##Eet_Node_Type##_new(name, *((Type *) dd)); \
+
+ switch (type)
+ {
+ EET_T_TYPE(EET_T_CHAR, char, char);
+ EET_T_TYPE(EET_T_SHORT, short, short);
+ EET_T_TYPE(EET_T_INT, int, int);
+ EET_T_TYPE(EET_T_LONG_LONG, long_long, long long);
+ EET_T_TYPE(EET_T_FLOAT, float, float);
+ EET_T_TYPE(EET_T_DOUBLE, double, double);
+ EET_T_TYPE(EET_T_UCHAR, unsigned_char, unsigned char);
+ EET_T_TYPE(EET_T_USHORT, unsigned_short, unsigned short);
+ EET_T_TYPE(EET_T_UINT, unsigned_int, unsigned int);
+ EET_T_TYPE(EET_T_ULONG_LONG, unsigned_long_long, unsigned long long);
+ EET_T_TYPE(EET_T_STRING, string, char*);
+ EET_T_TYPE(EET_T_INLINED_STRING, inlined_string, char*);
+ case EET_T_NULL:
+ return eet_node_null_new(name);
+ default:
+ ERR("Unknow type passed to eet_data_node_simple_type");
+ return NULL;
+ }
}
static int
-eet_data_get_unknown(const Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Chunk *echnk,
+eet_data_get_unknown(Eet_Free_Context *context, const Eet_Dictionary *ed, Eet_Data_Descriptor *edd, Eet_Data_Element *ede, Eet_Data_Chunk *echnk,
int type, int group_type __UNUSED__, void *data,
- int level, void (*dumpfunc) (void *data, const char *str), void *dumpdata,
char **p __UNUSED__, int *size __UNUSED__)
{
int ret;
if (IS_SIMPLE_TYPE(type))
{
- ret = eet_data_get_type(ed, type, echnk->data, ((char *)echnk->data) + echnk->size, ((char *)data));
+ unsigned char dd[128];
+
+ ret = eet_data_get_type(ed, type, echnk->data, ((char *)echnk->data) + echnk->size, edd ? (char*) data : (char*) dd);
if (ret <= 0) return ret;
- if (type == EET_T_STRING)
+ if (!edd)
{
- char **str;
+ Eet_Node **parent = data;
+ Eet_Node *node;
- str = (char **)(((char *)data));
- if (*str)
+ node = eet_data_node_simple_type(type, echnk->name, dd);
+
+ if (*parent) eet_node_struct_append(*parent, echnk->name, node);
+ else *parent = node;
+ }
+ else
+ {
+ if (type == EET_T_STRING)
{
- if ((ed == NULL) || (edd->func.str_direct_alloc == NULL))
+ char **str;
+
+ str = (char **)(((char *)data));
+ if (*str)
{
- *str = edd->func.str_alloc(*str);
- _eet_freelist_str_add(*str);
+ if ((ed == NULL) || (edd->func.str_direct_alloc == NULL))
+ {
+ *str = edd->func.str_alloc(*str);
+ _eet_freelist_str_add(context, *str);
+ }
+ else
+ {
+ *str = edd->func.str_direct_alloc(*str);
+ _eet_freelist_direct_str_add(context, *str);
+ }
}
- else
+ }
+ else if (edd && type == EET_T_INLINED_STRING)
+ {
+ char **str;
+
+ str = (char **)(((char *)data));
+ if (*str)
{
- *str = edd->func.str_direct_alloc(*str);
- _eet_freelist_direct_str_add(*str);
+ *str = edd->func.str_alloc(*str);
+ _eet_freelist_str_add(context, *str);
}
}
}
- else if (type == EET_T_INLINED_STRING)
+ }
+ else
+ {
+ Eet_Data_Descriptor *subtype;
+
+ subtype = ede ? ede->subtype : NULL;
+
+ if (subtype || !edd)
{
- char **str;
+ Eet_Node **parent = data;
+ void **ptr;
- str = (char **)(((char *)data));
- if (*str)
+ data_ret = _eet_data_descriptor_decode(context, ed, subtype, echnk->data, echnk->size);
+ if (!data_ret) return 0;
+
+ if (edd)
{
- *str = edd->func.str_alloc(*str);
- _eet_freelist_str_add(*str);
+ ptr = (void **)(((char *)data));
+ *ptr = (void *)data_ret;
}
- }
- }
- else if (ede->subtype)
- {
- void **ptr;
-
- data_ret = _eet_data_descriptor_decode(ed, ede->subtype, echnk->data, echnk->size, level + 1, dumpfunc, dumpdata);
- if (!data_ret) return 0;
+ else
+ {
+ Eet_Node *node = data_ret;
- ptr = (void **)(((char *)data));
- *ptr = (void *)data_ret;
+ if (*parent)
+ {
+ node = eet_node_struct_child_new(echnk->name, node);
+ eet_node_struct_append(*parent, echnk->name, node);
+ }
+ else *parent = node;
+ }
+ }
}
return 1;
}
static void
-eet_data_encode(Eet_Dictionary *ed, Eet_Data_Stream *ds, void *data, const char *name, int size, int type, int group_type)
-{
- Eet_Data_Chunk *echnk;
-
- echnk = eet_data_chunk_new(data, size, name, type, group_type);
- eet_data_chunk_put(ed, echnk, ds);
- eet_data_chunk_free(echnk);
- free(data);
-}
-
-static void
eet_data_put_array(Eet_Dictionary *ed, Eet_Data_Descriptor *edd __UNUSED__, Eet_Data_Element *ede, Eet_Data_Stream *ds, void *data_in)
{
void *data;
- int size;
- int j;
int offset = 0;
+ int subsize;
int count;
+ int size;
+ int j;
- EET_ASSERT(!IS_SIMPLE_TYPE(ede->type), return );
+ EET_ASSERT(!((ede->type > EET_T_UNKNOW) && (ede->type < EET_T_STRING)), return );
if (ede->group_type == EET_G_ARRAY)
count = ede->counter_offset;
data = eet_data_put_type(ed, EET_T_INT, &count, &size);
if (data) eet_data_encode(ed, ds, data, ede->name, size, ede->type, ede->group_type);
+ if (IS_POINTER_TYPE(ede->type))
+ subsize = eet_basic_codec[ede->type].size;
+ else
+ subsize = ede->subtype->size;
+
for (j = 0; j < count; j++)
{
void *d;
+ int pos = ds->pos;
if (ede->group_type == EET_G_ARRAY)
d = (void *)(((char *)data_in) + offset);
else
d = *(((char **)data_in)) + offset;
- data = _eet_data_descriptor_encode(ed, ede->subtype, d, &size);
- offset += ede->subtype->size;
- if (data) eet_data_encode(ed, ds, data, ede->name, size, ede->type, ede->group_type);
+ if (IS_POINTER_TYPE(ede->type))
+ {
+ if (*(char**) d)
+ eet_data_put_unknown(ed, NULL, ede, ds, d);
+ }
+ else
+ {
+ data = _eet_data_descriptor_encode(ed, ede->subtype, d, &size);
+ if (data) eet_data_encode(ed, ds, data, ede->name, size, ede->type, ede->group_type);
+ }
+
+ if (pos == ds->pos)
+ {
+ /* Add a NULL element just to have the correct array layout. */
+ eet_data_encode(ed, ds, NULL, ede->name, 0, EET_T_NULL, ede->group_type);
+ }
+
+ offset += subsize;
}
}
void *l;
int size;
- EET_ASSERT(!((ede->type > EET_T_UNKNOW) && (ede->type < EET_T_STRING)), return );
+ EET_ASSERT(!(((ede->type > EET_T_UNKNOW) && (ede->type < EET_T_STRING))
+ || ((ede->type > EET_T_NULL) && (ede->type < EET_T_LAST))),
+ return );
l = *((void **)(((char *)data_in)));
for (; l; l = edd->func.list_next(l))
{
- if (ede->type >= EET_T_STRING)
+ if (IS_POINTER_TYPE(ede->type))
{
- const char *str = edd->func.list_data(l);
+ const void *str = edd->func.list_data(l);
eet_data_put_unknown(ed, NULL, ede, ds, &str);
}
else
}
EAPI int
-eet_data_dump(Eet_File *ef,
- const char *name,
- void (*dumpfunc) (void *data, const char *str),
- void *dumpdata)
+eet_data_dump_cipher(Eet_File *ef,
+ const char *name, const char *cipher_key,
+ void (*dumpfunc) (void *data, const char *str),
+ void *dumpdata)
{
const Eet_Dictionary *ed = NULL;
- const void *data;
- int ret = 0;
+ const void *data = NULL;
+ Eet_Node *result;
+ Eet_Free_Context context;
int required_free = 0;
int size;
ed = eet_dictionary_get(ef);
- data = eet_read_direct(ef, name, &size);
+ if (!cipher_key)
+ data = eet_read_direct(ef, name, &size);
if (!data)
{
required_free = 1;
- data = eet_read(ef, name, &size);
+ data = eet_read_cipher(ef, name, &size, cipher_key);
if (!data) return 0;
}
- if (_eet_data_descriptor_decode(ed, NULL, data, size, 0,
- dumpfunc, dumpdata))
- ret = 1;
+ memset(&context, 0, sizeof (context));
+ result = _eet_data_descriptor_decode(&context, ed, NULL, data, size);
+
+ eet_node_dump(result, 0, dumpfunc, dumpdata);
+
+ eet_node_del(result);
if (required_free)
free((void*)data);
- return ret;
+ return result ? 1 : 0;
+}
+
+EAPI int
+eet_data_dump(Eet_File *ef,
+ const char *name,
+ void (*dumpfunc) (void *data, const char *str),
+ void *dumpdata)
+{
+ return eet_data_dump_cipher(ef, name, NULL, dumpfunc, dumpdata);
}
EAPI int
+eet_data_text_dump_cipher(const void *data_in,
+ const char *cipher_key, int size_in,
+ void (*dumpfunc) (void *data, const char *str),
+ void *dumpdata)
+{
+ void *ret = NULL;
+ Eet_Node *result;
+ Eet_Free_Context context;
+ unsigned int ret_len = 0;
+
+ if (!data_in) return 0;
+
+ if (cipher_key)
+ {
+ if (eet_decipher(data_in, size_in, cipher_key,
+ strlen(cipher_key), &ret, &ret_len))
+ {
+ if (ret) free(ret);
+ return 0;
+ }
+ }
+ else
+ {
+ ret = (void*) data_in;
+ ret_len = size_in;
+ }
+
+ memset(&context, 0, sizeof (context));
+ result = _eet_data_descriptor_decode(&context, NULL, NULL, ret, ret_len);
+
+ eet_node_dump(result, 0, dumpfunc, dumpdata);
+
+ eet_node_del(result);
+ if (cipher_key) free(ret);
+
+ return result ? 1 : 0;
+}
+
+EAPI int
eet_data_text_dump(const void *data_in,
int size_in,
void (*dumpfunc) (void *data, const char *str),
void *dumpdata)
{
- if (_eet_data_descriptor_decode(NULL, NULL, data_in, size_in, 0,
- dumpfunc, dumpdata))
- return 1;
- return 0;
+ return eet_data_text_dump_cipher(data_in, NULL, size_in, dumpfunc, dumpdata);
+}
+
+EAPI void *
+eet_data_text_undump_cipher(const char *text,
+ const char *cipher_key,
+ int textlen,
+ int *size_ret)
+{
+ void *ret = NULL;
+
+ ret = _eet_data_dump_parse(NULL, size_ret, text, textlen);
+ if (ret && cipher_key)
+ {
+ void *ciphered = NULL;
+ unsigned int ciphered_len;
+
+ if (eet_cipher(ret, *size_ret, cipher_key,
+ strlen(cipher_key), &ciphered, &ciphered_len))
+ {
+ if (ciphered) free(ciphered);
+ size_ret = 0;
+ free(ret);
+ return NULL;
+ }
+ free(ret);
+ *size_ret = ciphered_len;
+ ret = ciphered;
+ }
+ return ret;
}
EAPI void *
int textlen,
int *size_ret)
{
- return _eet_data_dump_parse(NULL, size_ret, text, textlen);
+ return eet_data_text_undump_cipher(text, NULL, textlen, size_ret);
}
EAPI int
-eet_data_undump(Eet_File *ef,
- const char *name,
- const char *text,
- int textlen,
- int compress)
+eet_data_undump_cipher(Eet_File *ef,
+ const char *name,
+ const char *cipher_key,
+ const char *text,
+ int textlen,
+ int compress)
{
Eet_Dictionary *ed;
void *data_enc;
data_enc = _eet_data_dump_parse(ed, &size, text, textlen);
if (!data_enc) return 0;
- val = eet_write(ef, name, data_enc, size, compress);
+ val = eet_write_cipher(ef, name, data_enc, size, compress, cipher_key);
free(data_enc);
return val;
}
+EAPI int
+eet_data_undump(Eet_File *ef,
+ const char *name,
+ const char *text,
+ int textlen,
+ int compress)
+{
+ return eet_data_undump_cipher(ef, name, NULL, text, textlen, compress);
+}
+
+EAPI void *
+eet_data_descriptor_decode_cipher(Eet_Data_Descriptor *edd,
+ const void *data_in,
+ const char *cipher_key,
+ int size_in)
+{
+ void *deciphered = (void*) data_in;
+ void *ret;
+ Eet_Free_Context context;
+ unsigned int deciphered_len = size_in;
+
+ if (cipher_key && data_in)
+ {
+ if (eet_decipher(data_in, size_in, cipher_key,
+ strlen(cipher_key), &deciphered, &deciphered_len))
+ {
+ if (deciphered) free(deciphered);
+ return NULL;
+ }
+ }
+
+ memset(&context, 0, sizeof (context));
+ ret = _eet_data_descriptor_decode(&context, NULL, edd, deciphered, deciphered_len);
+
+ if (data_in != deciphered) free(deciphered);
+
+ return ret;
+}
+
EAPI void *
eet_data_descriptor_decode(Eet_Data_Descriptor *edd,
const void *data_in,
int size_in)
{
- return _eet_data_descriptor_decode(NULL, edd, data_in, size_in, 0,
- NULL, NULL);
+ return eet_data_descriptor_decode_cipher(edd, data_in, NULL, size_in);
+}
+
+EAPI Eet_Node *
+eet_data_node_decode_cipher(const void *data_in, const char *cipher_key, int size_in)
+{
+ void *deciphered = (void*) data_in;
+ Eet_Node *ret;
+ Eet_Free_Context context;
+ unsigned int deciphered_len = size_in;
+
+ if (cipher_key && data_in)
+ {
+ if (eet_decipher(data_in, size_in, cipher_key,
+ strlen(cipher_key), &deciphered, &deciphered_len))
+ {
+ if (deciphered) free(deciphered);
+ return NULL;
+ }
+ }
+
+ memset(&context, 0, sizeof (context));
+ ret = _eet_data_descriptor_decode(&context, NULL, NULL, deciphered, deciphered_len);
+
+ if (data_in != deciphered) free(deciphered);
+
+ return ret;
}
static void *
int csize;
int i;
- if (words_bigendian == -1)
+ if (_eet_data_words_bigendian == -1)
{
unsigned long int v;
v = htonl(0x12345678);
- if (v == 0x12345678) words_bigendian = 1;
- else words_bigendian = 0;
+ if (v == 0x12345678) _eet_data_words_bigendian = 1;
+ else _eet_data_words_bigendian = 0;
}
ds = eet_data_stream_new();
return cdata;
}
+EAPI int
+eet_data_node_write_cipher(Eet_File *ef, const char *name, const char *cipher_key, Eet_Node *node, int compress)
+{
+ Eet_Dictionary *ed;
+ void *data_enc;
+ int size;
+ int val;
+
+ ed = eet_dictionary_get(ef);
+
+ data_enc = _eet_data_dump_encode(EET_G_UNKNOWN, ed, node, &size);
+ if (!data_enc) return 0;
+ val = eet_write_cipher(ef, name, data_enc, size, compress, cipher_key);
+ free(data_enc);
+ return val;
+}
+
+EAPI void *
+eet_data_node_encode_cipher(Eet_Node *node,
+ const char *cipher_key,
+ int *size_ret)
+{
+ void *ret = NULL;
+ void *ciphered = NULL;
+ unsigned int ciphered_len = 0;
+ int size;
+
+ ret = _eet_data_dump_encode(EET_G_UNKNOWN, NULL, node, &size);
+ if (cipher_key && ret)
+ {
+ if (eet_cipher(ret, size, cipher_key,
+ strlen(cipher_key), &ciphered, &ciphered_len))
+ {
+ if (ciphered) free(ciphered);
+ if (size_ret) *size_ret = 0;
+ free(ret);
+ return NULL;
+ }
+ free(ret);
+ size = (int) ciphered_len;
+ ret = ciphered;
+ }
+
+ if (size_ret) *size_ret = size;
+ return ret;
+}
+
+EAPI void *
+eet_data_descriptor_encode_cipher(Eet_Data_Descriptor *edd,
+ const void *data_in,
+ const char *cipher_key,
+ int *size_ret)
+{
+ void *ret = NULL;
+ void *ciphered = NULL;
+ unsigned int ciphered_len = 0;
+ int size;
+
+ ret = _eet_data_descriptor_encode(NULL, edd, data_in, &size);
+ if (cipher_key && ret)
+ {
+ if (eet_cipher(ret, size, cipher_key,
+ strlen(cipher_key), &ciphered, &ciphered_len))
+ {
+ if (ciphered) free(ciphered);
+ if (size_ret) *size_ret = 0;
+ free(ret);
+ return NULL;
+ }
+ free(ret);
+ size = ciphered_len;
+ ret = ciphered;
+ }
+
+ if (size_ret) *size_ret = size;
+ return ret;
+}
+
EAPI void *
eet_data_descriptor_encode(Eet_Data_Descriptor *edd,
const void *data_in,
int *size_ret)
{
- return _eet_data_descriptor_encode(NULL, edd, data_in, size_ret);
+ return eet_data_descriptor_encode_cipher(edd, data_in, NULL, size_ret);
}
projects / framework / uifw / eet.git / blobdiff