/**
* @brief Saves Etk's config to disk
* @return Returns ETK_TRUE on a successful save, ETK_FALSE otherwise.
*/
Etk_Bool etk_config_save(void)
{
Eet_File *ef;
char buf[PATH_MAX];
char *home;
Etk_Bool ret;
home = getenv("HOME");
if (!home)
return 0;
snprintf(buf, sizeof(buf), "%s/.e/etk/config.eet", home);
ef = eet_open(buf, EET_FILE_MODE_WRITE);
if (!ef)
return 0;
ret = eet_data_write(ef, _etk_config_ver_edd, "config/version",
_etk_config->version, 1);
if (!ret)
ETK_WARNING("Problem saving config!");
ret = eet_data_write(ef, _etk_config_gen_edd, "config/general",
_etk_config->general, 1);
if (!ret)
ETK_WARNING("Problem saving config/stickies!");
eet_close(ef);
return ret;
}
int
ex_config_write(Extrackt *ex)
{
Eet_File *ef;
char buf[PATH_MAX];
char *home;
int ret;
Eina_List *l;
home = getenv("HOME");
if(!home)
return 0;
snprintf(buf, sizeof(buf), "%s/.e/extrackt/config.eet", home);
ef = eet_open(buf, EET_FILE_MODE_WRITE);
if(!ef)
return 0;
ret = eet_data_write(ef, _ex_config_version_edd, "config/version", ex->config.version, 1);
if(!ret)
DEBUG(_("Problem saving config!"));
ret = eet_data_write(ef, _ex_config_cd_edd, "config/cd", ex->config.cd, 1);
if(!ret)
DEBUG(_("Problem saving config!"));
ret = eet_data_write(ef, _ex_config_cddb_edd, "config/cddb", ex->config.cddb, 1);
if(!ret)
DEBUG(_("Problem saving config!"));
for(l = ex->config.rippers; l; l = l->next)
{
Ex_Config_Exe *ripper;
char *buf;
int size;
ripper = l->data;
size = strlen("config/rippers/") + strlen(ripper->name) + 1;
buf = E_NEW(size, char);
snprintf(buf, size, "config/rippers/%s", ripper->name);
ret = eet_data_write(ef, _ex_config_exe_edd, buf, ripper, 1);
if(!ret)
DEBUG(_("Problem saving config!"));
}
ret = eet_data_write(ef, _ex_config_encode_edd, "config/encode", ex->config.encode, 1);
if(!ret)
DEBUG(_("Problem saving config!"));
eet_close(ef);
return ret;
}
static Eina_Bool
_ephoto_on_config_save(void *data)
{
Ephoto *ephoto = data;
Eet_File *ef;
char buf[4096], buf2[4096];
snprintf(buf, sizeof(buf), "%s/.config/ephoto/ephoto.cfg", getenv("HOME"));
snprintf(buf2, sizeof(buf2), "%s.tmp", buf);
ef = eet_open(buf2, EET_FILE_MODE_WRITE);
if (!ef) goto save_end;
eet_data_write(ef, edd, "config", ephoto->config, 1);
if (eet_close(ef)) goto save_end;
if (!ecore_file_mv(buf2, buf)) goto save_end;
INF("Config saved");
save_end:
ecore_file_unlink(buf2);
if (save_timer)
{
ecore_timer_del(save_timer);
save_timer = NULL;
}
return ECORE_CALLBACK_CANCEL;
}
void
config_flush(void)
{
Eet_File *cf;
char path[PATH_MAX];
if (!config)
return;
snprintf(path, sizeof(path), "%s/%s", efreet_config_home_get(), "jesus.eet");
cf = eet_open(path, EET_FILE_MODE_WRITE);
if (!cf)
{
printf("Failed to open config file");
}
if (!eet_data_write(cf, edd, CONFIG_KEY, config, 0))
{
printf("Failed to write config file");
}
eet_close(cf);
}
void Config::saveStateCache()
{
Eet_File *ef;
std::string file = Utils::getCacheFile("iostates.cache");
std::string tmp = file + "_tmp";
ConfigStateCache *cache;
cache = new ConfigStateCache;
cache->version = CONFIG_STATES_CACHE_VERSION;
cache->states = cache_states;
ef = eet_open(tmp.c_str(), EET_FILE_MODE_WRITE);
if (!ef)
{
cWarning() << "Could not open iostates.cache for write !";
delete cache;
return;
}
Eina_Bool ret = eet_data_write(ef, edd_cache, "calaos/states/cache", cache, EINA_TRUE);
eet_close(ef);
delete cache;
if (ret)
{
ecore_file_unlink(file.c_str());
ecore_file_mv(tmp.c_str(), file.c_str());
}
cInfo() << "State cache file written successfully (" << file << ")";
}
static Eina_Bool
config_save(Eet_Data_Descriptor *descriptor, const char *filename, const char *section, const void *data)
{
Eet_File *ef;
FILE *f;
char buffer[PATH_MAX];
int i;
/* human readable version */
snprintf(buffer, PATH_MAX, "%s.%s", filename, section);
f = fopen(buffer, "w");
if (!f) {
fprintf(stderr, "Not able to open human readable config file.\n");
goto on_error;
}
/* save the configuration */
snprintf(buffer, PATH_MAX, "%s.eet", filename);
ef = eet_open(buffer, EET_FILE_MODE_READ_WRITE);
if (!ef) {
fprintf(stderr, "Not able to open config file for read write mode.\n");
goto on_error;
}
if (!eet_data_write(ef, descriptor, section, data, 1)) {
fprintf(stderr, "Can't write data inside the config file.\n");
goto on_write_error;
}
if (!eet_data_dump(ef, section, invert_fputs, f)) {
fprintf(stderr, "Can't dump section `%s`.\n");
goto on_write_error;
}
eet_close(ef);
sleep(2);
fclose(f);
return EINA_TRUE;
on_write_error:
eet_close(ef);
snprintf(buffer, PATH_MAX, "%s.eet", filename);
unlink(buffer);
on_error:
if (f)
{
fclose(f);
snprintf(buffer, PATH_MAX, "%s.%s", filename, section);
unlink(buffer);
}
return EINA_FALSE;
}
int
source_fontmap_save(Eet_File *ef, Eina_List *font_list)
{
Edje_Font_List fl;
fl.list = font_list;
return eet_data_write(ef, _font_list_edd, "edje_source_fontmap", &fl,
compress_mode);
}
/* Write the input method configuration to the file */
EAPI int
e_intl_input_method_config_write(Eet_File *imc_file, E_Input_Method_Config *imc)
{
int ok = 0;
if (imc_file)
{
ok = eet_data_write(imc_file, _e_intl_input_method_config_edd, "imc", imc, 0);
}
return ok;
}
/**
* @brief Save the connection associated to an essid in the configuration file
* @param file the configuration file
* @param c the connection
* @return Returns 1 if success, else 0
*/
int _exalt_eet_wireless_conn_save(const char*file, Exalt_Connection* c)
{
Eet_Data_Descriptor* edd;
Eet_File* f;
int res;
edd = exalt_conn_edd_new();
f = eet_open(file, EET_FILE_MODE_READ_WRITE);
if(!f)
f = eet_open(file, EET_FILE_MODE_WRITE);
res=eet_data_write(f, edd,exalt_conn_get_essid(c), c, 0);
EXALT_ASSERT(res!=0);
eet_close(f);
eet_data_descriptor_free(edd);
return res;
}
/**
* @brief Save a Exalt_Eth_Save structure in the configuration file
* @param file the configuration file
* @param s the Exalt_Eth_Save strucuture
* @param udi the hal udi of the interface
* @return Returns 1 if success, else 0
*/
int _exalt_eet_eth_save(const char* file, Exalt_Eth_Save* s, const char* udi)
{
Eet_Data_Descriptor *edd;
Eet_File* f;
int res;
edd = _exalt_eth_save_edd_new();
f = eet_open(file, EET_FILE_MODE_READ_WRITE);
if(!f)
f = eet_open(file, EET_FILE_MODE_WRITE);
res=eet_data_write(f, edd,udi, s, 0);
EXALT_ASSERT(res!=0);
eet_close(f);
eet_data_descriptor_free(edd);
return res;
}
static Eina_Bool
_my_conf_save(const My_Conf_Type *my_conf,
const char *filename)
{
char tmp[PATH_MAX];
Eet_File *ef;
Eina_Bool ret;
unsigned int i, len;
struct stat st;
len = eina_strlcpy(tmp, filename, sizeof(tmp));
if (len + 12 >= (int)sizeof(tmp))
{
fprintf(stderr, "ERROR: file name is too big: %s\n", filename);
return EINA_FALSE;
}
i = 0;
do
{
snprintf(tmp + len, 12, ".%u", i);
i++;
}
while (stat(tmp, &st) == 0);
ef = eet_open(tmp, EET_FILE_MODE_WRITE);
if (!ef)
{
fprintf(stderr, "ERROR: could not open '%s' for write\n", tmp);
return EINA_FALSE;
}
ret = eet_data_write
(ef, _my_conf_descriptor, MY_CONF_FILE_ENTRY, my_conf, EINA_TRUE);
eet_close(ef);
if (ret)
{
unlink(filename);
rename(tmp, filename);
}
return ret;
} /* _my_conf_save */
void
ems_config_save(void)
{
Eet_File *file;
FILE *fp;
file = eet_open(ems_config_tmp_filename_get(),
EET_FILE_MODE_READ_WRITE);
eet_data_write(file, conf_edd, "config", ems_config, EINA_FALSE);
printf("save to : %s\n", ems_config_filename_get());
fp = fopen(ems_config_filename_get(), "w");
if (!fp)
goto error;
eet_data_dump(file, "config", _dump_cb, fp);
fclose(fp);
error:
eet_close(file);
}
void write_histogram_to_file(char * output_file, Eina_Hash *map_histo)
{
Eet_File *ef;
histogram_cache_t *cache_histo;
printf("Writing cache map with %i entries\n"
, eina_hash_population(map_histo));
unlink(output_file);
cache_histo = malloc(sizeof(histogram_cache_t));
cache_histo->map_histo = map_histo;
ef = eet_open(output_file, EET_FILE_MODE_WRITE);
eet_data_write(ef, _histogram_cache_descriptor
, CACHE_FILE_ENTRY, cache_histo, EINA_TRUE);
eet_close(ef);
free(cache_histo);
}
/*
* @brief save the list of interfaces
* @param l the list
* @param file the configuration file
*/
void waiting_iface_save(const Boot_Process_List* l, const char* file)
{
Eet_Data_Descriptor* edd;
Eet_File* f;
EXALT_ASSERT_RETURN_VOID(l!=NULL);
EXALT_ASSERT_RETURN_VOID(file!=NULL);
edd = waiting_iface_edd_new();
f = eet_open(file, EET_FILE_MODE_READ_WRITE);
if(!f)
{
f = eet_open(file, EET_FILE_MODE_WRITE);
}
eet_data_write(f, edd,"boot process interface list", l, 0);
eet_close(f);
eet_data_descriptor_free(edd);
}
Eina_Bool
session_save(Session *session, const char *filename)
{
Eet_File *ef;
Eina_Bool ret;
if (filename) session->__eet_filename = eina_stringshare_add(filename);
else if (session->__eet_filename) filename = session->__eet_filename;
else return EINA_FALSE;
ef = eet_open(filename, EET_FILE_MODE_READ_WRITE);
if (!ef)
{
fprintf(stderr, "ERROR: could not open '%s' for write\n", filename);
return EINA_FALSE;
}
ret = !!eet_data_write(ef, _session_descriptor, SESSION_ENTRY, session, EINA_TRUE);
eet_close(ef);
return ret;
}
Eina_Bool
fav_save(Fav *fav, const char *filename)
{
Eet_File *ef;
Eina_Bool ret;
if (filename) fav->__eet_filename = eina_stringshare_add(filename);
else if (fav->__eet_filename) filename = fav->__eet_filename;
else return EINA_FALSE;
ef = eet_open(filename, EET_FILE_MODE_READ_WRITE);
if (!ef)
{
fprintf(stderr, "ERROR: could not open '%s' for write\n", filename);
return EINA_FALSE;
}
ret = !!eet_data_write(ef, _fav_descriptor, FAV_ENTRY, fav, EINA_TRUE);
eet_close(ef);
return ret;
}
Eina_Bool
config_save(Config *config, const char *filename)
{
Eet_File *ef;
Eina_Bool ret;
if (filename) config->__eet_filename = eina_stringshare_add(filename);
else if (config->__eet_filename) filename = config->__eet_filename;
else return EINA_FALSE;
ef = eet_open(filename, EET_FILE_MODE_READ_WRITE);
if (!ef)
{
fprintf(stderr, "ERROR: could not open '%s' for write\n", filename);
return EINA_FALSE;
}
ret = !!eet_data_write(ef, _config_descriptor, CONFIG_ENTRY, config, EINA_TRUE);
eet_close(ef);
return ret;
}
static void _eli_highscore_write(const char * game)
{
Eli_Highscore hiscore;
Eet_File * file;
hiscore.entries = eli_highscore_get(game);
if (!hiscore.entries) return;
if (ecore_file_exists(eet_file_name)) {
file = eet_open(eet_file_name, EET_FILE_MODE_READ_WRITE);
if (!file) fprintf(stderr, "Could not open file %s!\n", eet_file_name);
}
else {
file = eet_open(eet_file_name, EET_FILE_MODE_WRITE);
if (!file) fprintf(stderr, "Could not create file %s\n!",
eet_file_name);
}
if (file) {
eet_data_write(file, edd_hiscore, game, &hiscore, 1);
eet_close(file);
}
}
int
main(int argc, char **argv)
{
Edje_Part_Collection_Directory_Entry *ce;
Old_Edje_File *oef;
Edje_File *nef;
Eina_Iterator *it;
Eet_File *ef;
setlocale(LC_NUMERIC, "C");
ecore_app_no_system_modules();
if (!eina_init())
return -1;
_edje_cc_log_dom = eina_log_domain_register
("edje_convert", EDJE_CC_DEFAULT_LOG_COLOR);
if (_edje_cc_log_dom < 0)
{
EINA_LOG_ERR("Enable to create a log domain.");
exit(-1);
}
eet_init();
progname = argv[0];
if (argc > 2 || argc < 2 || !strcmp(argv[1], "-h"))
{
main_help();
return 0;
}
_edje_edd_old_init();
_edje_edd_init();
ef = eet_open(argv[1], EET_FILE_MODE_READ_WRITE);
if (!ef)
{
EINA_LOG_ERR("Unable to open `%s'.", argv[1]);
return -1;
}
oef = eet_data_read(ef, _edje_edd_old_edje_file, "edje_file");
if (!oef)
{
EINA_LOG_ERR("Unable to get edje_file section from old file format, are you sure it's an old file ?");
return -1;
}
nef = _edje_file_convert(ef, oef);
_edje_file_set(nef);
/* convert old structure to new one */
it = eina_hash_iterator_data_new(nef->collection);
EINA_ITERATOR_FOREACH(it, ce)
{
Old_Edje_Part_Collection *opc;
Edje_Part_Collection *npc;
char buf[1024];
int bytes = 0;
snprintf(buf, sizeof (buf), "collections/%i", ce->id);
opc = eet_data_read(ef, _edje_edd_old_edje_part_collection, buf);
if (!opc)
{
EINA_LOG_ERR("Unable to find collection `%s'[%i] in `%s'.", ce->entry, ce->id, argv[1]);
return -1;
}
npc = _edje_collection_convert(ef, ce, opc);
snprintf(buf, sizeof (buf), "edje/collections/%i", ce->id);
bytes = eet_data_write(ef, _edje_edd_edje_part_collection, buf, npc, 1);
if (bytes <= 0)
{
EINA_LOG_ERR("Unable to save `%s' in section `%s' of `%s'.", ce->entry, buf, argv[1]);
return -1;
}
}
static int
cache_add(const char *path, const char *file_id, int priority EINA_UNUSED, int *changed)
{
Efreet_Desktop *desk;
char *ext;
INF("FOUND: %s", path);
if (file_id) INF(" (id): %s", file_id);
ext = strrchr(path, '.');
if (!ext || (strcmp(ext, ".desktop") && strcmp(ext, ".directory"))) return 1;
desk = efreet_desktop_new(path);
if (desk) INF(" OK");
else INF(" FAIL");
if (!desk) return 1;
if (!desk->eet)
{
/* This file isn't in cache */
*changed = 1;
INF(" NEW");
}
else if (ecore_file_mod_time(desk->orig_path) != desk->load_time)
{
efreet_desktop_free(desk);
*changed = 1;
desk = efreet_desktop_uncached_new(path);
if (desk) INF(" CHANGED");
else INF(" NO UNCACHED");
}
if (!desk) return 1;
if (file_id && old_file_ids && !eina_hash_find(old_file_ids->hash, file_id))
{
*changed = 1;
INF(" NOT IN UTILS");
}
if (!eina_hash_find(paths, desk->orig_path))
{
if (!eet_data_write(ef, edd, desk->orig_path, desk, 0))
return 0;
eina_hash_add(paths, desk->orig_path, (void *)1);
}
/* TODO: We should check priority, and not just hope we search in right order */
/* TODO: We need to find out if prioritized file id has changed because of
* changed search order. */
if (!desk->hidden && desk->type == EFREET_DESKTOP_TYPE_APPLICATION &&
file_id && !eina_hash_find(file_ids, file_id))
{
Eina_List *l;
char *data;
Efreet_Cache_Array_String *array;
#define ADD_LIST(list, hash) \
EINA_LIST_FOREACH((list), l, data) \
{ \
array = eina_hash_find((hash), data); \
if (!array) \
array = NEW(Efreet_Cache_Array_String, 1); \
array->array = realloc(array->array, sizeof (char *) * (array->array_count + 1)); \
array->array[array->array_count++] = desk->orig_path; \
eina_hash_set((hash), data, array); \
}
#define ADD_ELEM(elem, hash) \
if ((elem)) \
{ \
data = (elem); \
array = eina_hash_find((hash), data); \
if (!array) \
array = NEW(Efreet_Cache_Array_String, 1); \
array->array = realloc(array->array, sizeof (char *) * (array->array_count + 1)); \
array->array[array->array_count++] = desk->orig_path; \
eina_hash_set((hash), data, array); \
}
ADD_LIST(desk->mime_types, mime_types);
ADD_LIST(desk->categories, categories);
ADD_ELEM(desk->startup_wm_class, startup_wm_class);
ADD_ELEM(desk->name, name);
ADD_ELEM(desk->generic_name, generic_name);
ADD_ELEM(desk->comment, comment);
ADD_ELEM(desk->exec, exec);
eina_hash_add(file_ids, file_id, desk->orig_path);
eina_hash_add(desktops, desk->orig_path, desk);
}
else
efreet_desktop_free(desk);
return 1;
}
int
main(int argc, char **argv)
{
/* TODO:
* - Add file monitor on files, so that we catch changes on files
* during whilst this program runs.
* - Maybe linger for a while to reduce number of cache re-creates.
*/
Efreet_Cache_Hash hash;
Efreet_Cache_Version version;
Eina_List *dirs = NULL;
Eina_List *systemdirs = NULL;
Eina_List *extra_dirs = NULL;
Eina_List *l = NULL;
Eina_Inarray *stack = NULL;
int priority = 0;
char *dir = NULL;
char *path;
int lockfd = -1, tmpfd;
int changed = 0;
int i;
char file[PATH_MAX] = { '\0' };
char util_file[PATH_MAX] = { '\0' };
mode_t um;
if (!eina_init()) goto eina_error;
_efreet_desktop_cache_log_dom =
eina_log_domain_register("efreet_desktop_cache", EFREET_DEFAULT_LOG_COLOR);
if (_efreet_desktop_cache_log_dom < 0)
{
EINA_LOG_ERR("Efreet: Could not create a log domain for efreet_desktop_cache.");
return -1;
}
for (i = 1; i < argc; i++)
{
if (!strcmp(argv[i], "-v"))
eina_log_domain_level_set("efreet_desktop_cache", EINA_LOG_LEVEL_DBG);
else if ((!strcmp(argv[i], "-h")) ||
(!strcmp(argv[i], "-help")) ||
(!strcmp(argv[i], "--h")) ||
(!strcmp(argv[i], "--help")))
{
printf("Options:\n");
printf(" -v Verbose mode\n");
printf(" -d dir1 dir2 Extra dirs\n");
exit(0);
}
else if (!strcmp(argv[i], "-d"))
{
while ((i < (argc - 1)) && (argv[(i + 1)][0] != '-'))
extra_dirs = eina_list_append(extra_dirs, argv[++i]);
}
}
extra_dirs = eina_list_sort(extra_dirs, -1, EINA_COMPARE_CB(strcmp));
#ifdef HAVE_SYS_RESOURCE_H
setpriority(PRIO_PROCESS, 0, 19);
#elif _WIN32
SetPriorityClass(GetCurrentProcess(), IDLE_PRIORITY_CLASS);
#endif
/* init external subsystems */
if (!eet_init()) goto eet_error;
if (!ecore_init()) goto ecore_error;
efreet_cache_update = 0;
/* finish efreet init */
if (!efreet_init()) goto efreet_error;
/* create homedir */
snprintf(file, sizeof(file), "%s/efreet", efreet_cache_home_get());
if (!ecore_file_exists(file))
{
if (!ecore_file_mkpath(file)) goto efreet_error;
efreet_setowner(file);
}
/* lock process, so that we only run one copy of this program */
lockfd = cache_lock_file();
if (lockfd == -1) goto efreet_error;
edd = efreet_desktop_edd();
if (!edd) goto edd_error;
/* read user dirs from old cache */
ef = eet_open(efreet_desktop_util_cache_file(), EET_FILE_MODE_READ);
if (ef)
{
old_file_ids = eet_data_read(ef, efreet_hash_string_edd(), "file_id");
eet_close(ef);
}
/* create cache */
snprintf(file, sizeof(file), "%s.XXXXXX", efreet_desktop_cache_file());
/* set secure umask for temporary files */
um = umask(0077);
tmpfd = mkstemp(file);
umask(um);
if (tmpfd < 0) goto error;
close(tmpfd);
ef = eet_open(file, EET_FILE_MODE_READ_WRITE);
if (!ef) goto error;
snprintf(util_file, sizeof(util_file), "%s.XXXXXX", efreet_desktop_util_cache_file());
/* set secure umask for temporary files */
um = umask(0077);
tmpfd = mkstemp(util_file);
umask(um);
if (tmpfd < 0) goto error;
close(tmpfd);
util_ef = eet_open(util_file, EET_FILE_MODE_READ_WRITE);
if (!util_ef) goto error;
/* write cache version */
version.major = EFREET_DESKTOP_UTILS_CACHE_MAJOR;
version.minor = EFREET_DESKTOP_UTILS_CACHE_MINOR;
eet_data_write(util_ef, efreet_version_edd(), EFREET_CACHE_VERSION, &version, 1);
version.major = EFREET_DESKTOP_CACHE_MAJOR;
version.minor = EFREET_DESKTOP_CACHE_MINOR;
eet_data_write(ef, efreet_version_edd(), EFREET_CACHE_VERSION, &version, 1);
desktops = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_desktop_free));
file_ids = eina_hash_string_superfast_new(NULL);
paths = eina_hash_string_superfast_new(NULL);
mime_types = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_array_string_free));
categories = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_array_string_free));
startup_wm_class = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_array_string_free));
name = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_array_string_free));
generic_name = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_array_string_free));
comment = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_array_string_free));
exec = eina_hash_string_superfast_new(EINA_FREE_CB(efreet_cache_array_string_free));
dirs = efreet_default_dirs_get(efreet_data_home_get(), efreet_data_dirs_get(),
"applications");
if (!dirs) goto error;
stack = eina_inarray_new(sizeof(struct stat), 16);
if (!stack) goto error;
EINA_LIST_FREE(dirs, path)
{
char file_id[PATH_MAX] = { '\0' };
eina_inarray_flush(stack);
if (!cache_scan(stack, path, file_id, priority++, 1, &changed))
goto error;
systemdirs = eina_list_append(systemdirs, path);
}
EINA_ITERATOR_FOREACH(it, sce)
if (ce->id == sce->id)
{
memcpy(&ce->count, &sce->count, sizeof (ce->count));
break;
}
if (!sce)
error_and_abort(ef, "Collection %s (%i) can't find an correct alias.\n", ce->entry, ce->id);
eina_iterator_free(it);
eina_hash_direct_add(edje_file->collection, ce->entry, ce);
}
}
bytes = eet_data_write(ef, edd_edje_file, "edje/file", edje_file, 1);
if (bytes <= 0)
error_and_abort(ef, "Unable to write \"edje_file\" entry to \"%s\" \n",
file_out);
}
if (verbose)
{
printf("%s: Wrote %9i bytes (%4iKb) for \"edje_file\" header\n",
progname, bytes, (bytes + 512) / 1024);
}
return bytes;
}
static int
int
source_append(Eet_File *ef)
{
return eet_data_write(ef, _srcfile_list_edd, "edje_sources", &srcfiles,
compress_mode);
}
END_TEST
START_TEST(eet_test_file_fp)
{
char *file;
Eet_Data_Descriptor_Class eddc;
Eet_Data_Descriptor *edd_5FP;
Eet_Data_Descriptor *edd_5DBL;
Eet_File *ef;
Eet_5FP origin;
Eet_5DBL *convert;
Eet_5FP *build;
int tmpfd;
file = strdup("/tmp/eet_suite_testXXXXXX");
eet_init();
EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_5FP);
edd_5FP = eet_data_descriptor_file_new(&eddc);
EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "fp32", fp32, EET_T_F32P32);
EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "fp16", fp16, EET_T_F16P16);
EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "fp8", fp8, EET_T_F8P24);
EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "f1", f1, EET_T_F32P32);
EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "f0", f0, EET_T_F32P32);
eet_eina_file_data_descriptor_class_set(&eddc, sizeof (eddc), "Eet_5FP", sizeof (Eet_5DBL));
edd_5DBL = eet_data_descriptor_file_new(&eddc);
EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "fp32", fp32, EET_T_DOUBLE);
EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "fp16", fp16, EET_T_DOUBLE);
EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "fp8", fp8, EET_T_FLOAT);
EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "f1", f1, EET_T_DOUBLE);
EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "f0", f0, EET_T_DOUBLE);
origin.fp32 = eina_f32p32_double_from(1.125);
origin.fp16 = eina_f16p16_int_from(2000);
origin.fp8 = eina_f8p24_int_from(125);
origin.f1 = eina_f32p32_int_from(1);
origin.f0 = 0;
fail_if(-1 == (tmpfd = mkstemp(file)));
fail_if(!!close(tmpfd));
ef = eet_open(file, EET_FILE_MODE_READ_WRITE);
fail_if(!ef);
fail_if(!eet_data_write(ef, edd_5FP, EET_TEST_FILE_KEY1, &origin, 1));
build = eet_data_read(ef, edd_5FP, EET_TEST_FILE_KEY1);
fail_if(!build);
convert = eet_data_read(ef, edd_5DBL, EET_TEST_FILE_KEY1);
fail_if(!convert);
fail_if(build->fp32 != eina_f32p32_double_from(1.125));
fail_if(build->fp16 != eina_f16p16_int_from(2000));
fail_if(build->fp8 != eina_f8p24_int_from(125));
fail_if(build->f1 != eina_f32p32_int_from(1));
fail_if(build->f0 != 0);
fail_if(convert->fp32 != 1.125);
fail_if(convert->fp16 != 2000);
fail_if(convert->fp8 != 125);
fail_if(convert->f1 != 1);
fail_if(convert->f0 != 0);
eet_close(ef);
fail_if(unlink(file) != 0);
eet_shutdown();
}
END_TEST
START_TEST(eet_test_file_data_dump)
{
Eet_Data_Descriptor *edd;
Eet_Test_Ex_Type *result;
Eet_Data_Descriptor_Class eddc;
Eet_Test_Ex_Type etbt;
Eet_File *ef;
char *string1;
char *file;
int test;
int tmpfd;
file = strdup("/tmp/eet_suite_testXXXXXX");
eet_init();
eet_test_ex_set(&etbt, 0);
etbt.list = eina_list_prepend(etbt.list, eet_test_ex_set(NULL, 1));
etbt.list = eina_list_prepend(etbt.list, eet_test_ex_set(NULL, 1));
etbt.hash = eina_hash_string_superfast_new(NULL);
eina_hash_add(etbt.hash, EET_TEST_KEY1, eet_test_ex_set(NULL, 2));
eina_hash_add(etbt.hash, EET_TEST_KEY2, eet_test_ex_set(NULL, 2));
etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
etbt.ihash = eina_hash_string_superfast_new(NULL);
eina_hash_add(etbt.ihash, EET_TEST_KEY1, &i7);
eina_hash_add(etbt.ihash, EET_TEST_KEY2, &i7);
etbt.slist = eina_list_prepend(NULL, "test");
etbt.shash = eina_hash_string_superfast_new(NULL);
eina_hash_add(etbt.shash, EET_TEST_KEY1, "test");
memset(&etbt.charray, 0, sizeof(etbt.charray));
etbt.charray[0] = "test";
eet_eina_file_data_descriptor_class_set(&eddc, sizeof (eddc),
"Eet_Test_Ex_Type",
sizeof(Eet_Test_Ex_Type));
edd = eet_data_descriptor_file_new(&eddc);
fail_if(!edd);
eet_build_ex_descriptor(edd, EINA_FALSE);
fail_if(-1 == (tmpfd = mkstemp(file)));
fail_if(!!close(tmpfd));
/* Save the encoded data in a file. */
ef = eet_open(file, EET_FILE_MODE_WRITE);
fail_if(!ef);
fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 0));
eet_close(ef);
/* Use dump/undump in the middle */
ef = eet_open(file, EET_FILE_MODE_READ_WRITE);
fail_if(!ef);
string1 = NULL;
fail_if(eet_data_dump(ef, EET_TEST_FILE_KEY1, append_string, &string1) != 1);
fail_if(eet_delete(ef, EET_TEST_FILE_KEY1) == 0);
fail_if(!eet_data_undump(ef, EET_TEST_FILE_KEY1, string1, strlen(string1), 1));
eet_close(ef);
/* Test the correctness of the reinsertion. */
ef = eet_open(file, EET_FILE_MODE_READ);
fail_if(!ef);
result = eet_data_read(ef, edd, EET_TEST_FILE_KEY1);
fail_if(!result);
eet_close(ef);
/* Test the resulting data. */
fail_if(eet_test_ex_check(result, 0, EINA_TRUE) != 0);
fail_if(eet_test_ex_check(eina_list_data_get(result->list), 1, EINA_TRUE) != 0);
fail_if(eina_list_data_get(result->ilist) == NULL);
fail_if(*((int *)eina_list_data_get(result->ilist)) != 42);
fail_if(eina_list_data_get(result->slist) == NULL);
fail_if(strcmp(eina_list_data_get(result->slist), "test") != 0);
fail_if(eina_hash_find(result->shash, EET_TEST_KEY1) == NULL);
fail_if(strcmp(eina_hash_find(result->shash, EET_TEST_KEY1), "test") != 0);
fail_if(strcmp(result->charray[0], "test") != 0);
test = 0;
_dump_call = EINA_TRUE;
if (result->hash)
eina_hash_foreach(result->hash, func, &test);
_dump_call = EINA_FALSE;
fail_if(test != 0);
if (result->ihash)
eina_hash_foreach(result->ihash, func7, &test);
fail_if(test != 0);
fail_if(unlink(file) != 0);
eet_shutdown();
}
END_TEST
START_TEST(eet_test_file_data)
{
Eet_Data_Descriptor *edd;
Eet_Test_Ex_Type *result;
Eet_Dictionary *ed;
Eet_File *ef;
char **list;
char *file;
Eet_Data_Descriptor_Class eddc;
Eet_Test_Ex_Type etbt;
int size;
int test;
int tmpfd;
file = strdup("/tmp/eet_suite_testXXXXXX");
eet_init();
eet_test_ex_set(&etbt, 0);
etbt.list = eina_list_prepend(etbt.list, eet_test_ex_set(NULL, 1));
etbt.list = eina_list_prepend(etbt.list, eet_test_ex_set(NULL, 1));
etbt.hash = eina_hash_string_superfast_new(NULL);
eina_hash_add(etbt.hash, EET_TEST_KEY1, eet_test_ex_set(NULL, 2));
etbt.hash = eina_hash_string_superfast_new(NULL);
eina_hash_add(etbt.hash, EET_TEST_KEY2, eet_test_ex_set(NULL, 2));
etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
etbt.ihash = eina_hash_string_superfast_new(NULL);
eina_hash_add(etbt.ihash, EET_TEST_KEY1, &i7);
etbt.ihash = eina_hash_string_superfast_new(NULL);
eina_hash_add(etbt.ihash, EET_TEST_KEY2, &i7);
etbt.slist = eina_list_prepend(NULL, "test");
etbt.shash = eina_hash_string_superfast_new(NULL);
eina_hash_add(etbt.shash, EET_TEST_KEY1, "test");
memset(&etbt.charray, 0, sizeof(etbt.charray));
etbt.charray[0] = "test";
eet_test_setup_eddc(&eddc);
eddc.name = "Eet_Test_Ex_Type";
eddc.size = sizeof(Eet_Test_Ex_Type);
edd = eet_data_descriptor_file_new(&eddc);
fail_if(!edd);
eet_build_ex_descriptor(edd, EINA_FALSE);
fail_if(-1 == (tmpfd = mkstemp(file)));
fail_if(!!close(tmpfd));
/* Insert an error in etbt. */
etbt.i = 0;
/* Save the encoded data in a file. */
ef = eet_open(file, EET_FILE_MODE_READ_WRITE);
fail_if(!ef);
fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 0));
result = eet_data_read(ef, edd, EET_TEST_FILE_KEY1);
fail_if(!result);
fail_if(eet_mode_get(ef) != EET_FILE_MODE_READ_WRITE);
/* Test string space. */
ed = eet_dictionary_get(ef);
fail_if(!eet_dictionary_string_check(ed, result->str));
fail_if(eet_dictionary_string_check(ed, result->istr));
eet_close(ef);
/* Attempt to replace etbt by the correct one. */
etbt.i = EET_TEST_INT;
ef = eet_open(file, EET_FILE_MODE_READ_WRITE);
fail_if(!ef);
fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 0));
result = eet_data_read(ef, edd, EET_TEST_FILE_KEY1);
fail_if(!result);
/* Test the resulting data. */
fail_if(eet_test_ex_check(result, 0, EINA_FALSE) != 0);
eet_close(ef);
/* Read back the data. */
ef = eet_open(file, EET_FILE_MODE_READ_WRITE);
fail_if(!ef);
fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY2, &etbt, 0));
result = eet_data_read(ef, edd, EET_TEST_FILE_KEY1);
fail_if(!result);
/* Test string space. */
ed = eet_dictionary_get(ef);
fail_if(!ed);
fail_if(!eet_dictionary_string_check(ed, result->str));
fail_if(eet_dictionary_string_check(ed, result->istr));
/* Test the resulting data. */
fail_if(eet_test_ex_check(result, 0, EINA_FALSE) != 0);
fail_if(eet_test_ex_check(eina_list_data_get(result->list), 1, EINA_FALSE) != 0);
fail_if(eina_list_data_get(result->ilist) == NULL);
fail_if(*((int *)eina_list_data_get(result->ilist)) != 42);
fail_if(eina_list_data_get(result->slist) == NULL);
fail_if(strcmp(eina_list_data_get(result->slist), "test") != 0);
fail_if(eina_hash_find(result->shash, EET_TEST_KEY1) == NULL);
fail_if(strcmp(eina_hash_find(result->shash, EET_TEST_KEY1), "test") != 0);
fail_if(strcmp(result->charray[0], "test") != 0);
test = 0;
if (result->hash)
eina_hash_foreach(result->hash, func, &test);
fail_if(test != 0);
if (result->ihash)
eina_hash_foreach(result->ihash, func7, &test);
fail_if(test != 0);
list = eet_list(ef, "keys/*", &size);
fail_if(eet_num_entries(ef) != 2);
fail_if(size != 2);
fail_if(!(strcmp(list[0],
EET_TEST_FILE_KEY1) == 0 &&
strcmp(list[1], EET_TEST_FILE_KEY2) == 0)
&& !(strcmp(list[0],
EET_TEST_FILE_KEY2) == 0 &&
strcmp(list[1], EET_TEST_FILE_KEY1) == 0));
free(list);
fail_if(eet_delete(ef, NULL) != 0);
fail_if(eet_delete(NULL, EET_TEST_FILE_KEY1) != 0);
fail_if(eet_delete(ef, EET_TEST_FILE_KEY1) == 0);
list = eet_list(ef, "keys/*", &size);
fail_if(size != 1);
fail_if(eet_num_entries(ef) != 1);
/* Test some more wrong case */
fail_if(eet_data_read(ef, edd, "plop") != NULL);
fail_if(eet_data_read(ef, edd, EET_TEST_FILE_KEY1) != NULL);
/* Reinsert and reread data */
fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 0));
fail_if(eet_data_read(ef, edd, EET_TEST_FILE_KEY1) == NULL);
fail_if(eet_read_direct(ef, EET_TEST_FILE_KEY1, &size) == NULL);
eet_close(ef);
fail_if(unlink(file) != 0);
eet_shutdown();
}
