static Eina_Bool _e_fm_ipc_cb_file_mon_list_idler(void *data);
static Eina_Bool _e_fm_ipc_cb_fop_trash_idler(void *data);
-static char *_e_str_list_remove(Eina_List **list, char *str);
+static char *_e_str_list_remove(Eina_List **list, const char *str, int len);
static void _e_fm_ipc_reorder(const char *file, const char *dst, const char *relative, int after);
static void _e_fm_ipc_dir_del(E_Dir *ed);
_e_fm_ipc_monitor_start_try(E_Fm_Task *task)
{
E_Dir *ed, *ped = NULL;
+ Eina_Iterator *it;
- DIR *dir;
Eina_List *l;
/* look for any previous dir entries monitoring this dir */
}
/* open the dir to list */
- dir = opendir(task->src);
- if (!dir)
+ it = eina_file_direct_ls(task->src);
+ if (!it)
{
char buf[PATH_MAX + 4096];
}
else
{
+ Eina_File_Direct_Info *info;
Eina_List *files = NULL;
- struct dirent *dp;
- int dot_order = 0;
- char buf[4096];
- FILE *f;
+ char *dot_order = NULL;
/* create a new dir entry */
ed = calloc(1, sizeof(E_Dir));
_e_dirs = eina_list_append(_e_dirs, ed);
/* read everything except a .order, . and .. */
- while ((dp = readdir(dir)))
+ EINA_ITERATOR_FOREACH(it, info)
{
- if ((!strcmp(dp->d_name, ".")) || (!strcmp(dp->d_name, "..")))
- continue;
- if (!strcmp(dp->d_name, ".order"))
+ if (!strcmp(info->path + info->name_start, ".order"))
{
- dot_order = 1;
+ dot_order = strdup(info->path);
continue;
}
- files = eina_list_append(files, strdup(dp->d_name));
+ files = eina_list_append(files, eina_stringshare_add(info->path + info->name_start));
}
- closedir(dir);
+ eina_iterator_free(it);
+
/* if there was a .order - we need to parse it */
if (dot_order)
{
- snprintf(buf, sizeof(buf), "%s/.order", task->src);
- f = fopen(buf, "r");
- if (f)
- {
- Eina_List *f2 = NULL;
- int len;
- char *s;
-
- /* inset files in order if the existed in file
- * list before */
- while (fgets(buf, sizeof(buf), f))
- {
- len = strlen(buf);
- if (len > 0) buf[len - 1] = 0;
- s = _e_str_list_remove(&files, buf);
- if (s) f2 = eina_list_append(f2, s);
- }
- fclose(f);
- /* append whats left */
- files = eina_list_merge(f2, files);
- }
+ Eina_File *f;
+
+ f = eina_file_open(dot_order, EINA_FALSE);
+ if (f)
+ {
+ Eina_List *f2 = NULL;
+ char *map;
+
+ /* This piece of code should really become generic and work like an iterator.
+ * I plan to add this feature in eina, but that would be for next generation of E,
+ * not E17.
+ */
+ map = eina_file_map_all(f, EINA_FILE_SEQUENTIAL);
+ if (map)
+ {
+ const char *current = map;
+ const char *found;
+ size_t length = eina_file_size_get(f);
+
+ /* inset files in order if the existed in file
+ * list before */
+ while ((found = memchr(current, '\n', length)))
+ {
+ if (found - current > 1)
+ {
+ char *s = _e_str_list_remove(&files, current, found - current - 1);
+ if (s) f2 = eina_list_append(f2, s);
+ }
+ length -= found - current - 1;
+ current = found + 1;
+ }
+
+ if (found == NULL && length > 0)
+ {
+ char *s = _e_str_list_remove(&files, current, length);
+ if (s) f2 = eina_list_append(f2, s);
+ }
+
+ /* append whats left */
+ files = eina_list_merge(f2, files);
+
+ eina_file_map_free(f, map);
+ }
+
+ eina_file_close(f);
+ }
}
ed->fq = files;
/* FIXME: if .order file- load it, sort all items int it
* .order file stuff here - but not today
*/
/* note that we had a .order at all */
- ed->dot_order = dot_order;
+ ed->dot_order = dot_order ? EINA_TRUE : EINA_FALSE;
if (dot_order)
{
/* if we did - tell the E about this FIRST - it will
* decide what to do if it first sees a .order or not */
- if (!strcmp(task->src, "/"))
- snprintf(buf, sizeof(buf), "/.order");
- else
- snprintf(buf, sizeof(buf), "%s/.order", task->src);
if (eina_list_count(files) == 1)
- _e_fm_ipc_file_add(ed, buf, 2);
+ _e_fm_ipc_file_add(ed, dot_order, 2);
else
- _e_fm_ipc_file_add(ed, buf, 1);
+ _e_fm_ipc_file_add(ed, dot_order, 1);
}
/* send empty file - indicate empty dir */
if (!files) _e_fm_ipc_file_add(ed, "", 2);
/* and in an idler - list files, statting them etc. */
ed->idler = ecore_idler_add(_e_fm_ipc_cb_file_mon_list_idler, ed);
ed->sync_num = DEF_SYNC_NUM;
+
+ free(dot_order);
}
}
snprintf(buf, sizeof(buf), "%s/%s", ed->dir, file);
_e_fm_ipc_file_add(ed, buf, 1);
}
- free(file);
+ eina_stringshare_del(file);
ed->fq = eina_list_remove_list(ed->fq, ed->fq);
n++;
if (n == ed->sync_num)
}
static char *
-_e_str_list_remove(Eina_List **list, char *str)
+_e_str_list_remove(Eina_List **list, const char *str, int len)
{
Eina_List *l;
char *s;
EINA_LIST_FOREACH(*list, l, s)
- if (!strcmp(s, str))
+ if (!strncmp(s, str, len))
{
*list = eina_list_remove_list(*list, l);
return s;
free(m);
}
EINA_LIST_FREE(ed->fq, data)
- free(data);
+ eina_stringshare_del(data);
free(ed);
}
static Eina_List *node = NULL;
E_Fm_Op_Task *task = NULL;
char buf[PATH_MAX];
- static struct dirent *de = NULL;
- static DIR *dir = NULL;
+ static Eina_Iterator *dir = NULL;
E_Fm_Op_Task *ntask = NULL;
if (!node) node = _e_fm_op_scan_queue;
{
/* If it's a dir, then look through it and add a task for each. */
- dir = opendir(task->src.name);
+ dir = eina_file_direct_ls(task->src.name);
if (!dir)
_E_FM_OP_ERROR_SEND_SCAN(task, E_FM_OP_ERROR,
"Cannot open directory '%s': %s.",
}
else if (dir && !task->started)
{
- de = readdir(dir);
+ Eina_File_Direct_Info *info;
- if (!de)
+ if (!eina_iterator_next(dir, (void**) &info))
{
ntask = _e_fm_op_task_new();
ntask->type = E_FM_OP_COPY_STAT_INFO;
eina_list_append(_e_fm_op_scan_queue, ntask);
task->started = 1;
- closedir(dir);
+ eina_iterator_free(dir);
dir = NULL;
node = NULL;
return ECORE_CALLBACK_RENEW;
}
- if ((!strcmp(de->d_name, ".") || (!strcmp(de->d_name, ".."))))
- return ECORE_CALLBACK_RENEW;
-
ntask = _e_fm_op_task_new();
ntask->type = task->type;
- snprintf(buf, sizeof(buf), "%s/%s", task->src.name, de->d_name);
- ntask->src.name = eina_stringshare_add(buf);
+ ntask->src.name = eina_stringshare_add(info->path);
if (task->dst.name)
{
- snprintf(buf, sizeof(buf), "%s/%s", task->dst.name, de->d_name);
+ snprintf(buf, sizeof(buf), "%s/%s", task->dst.name, info->path + info->name_start);
ntask->dst.name = eina_stringshare_add(buf);
}
else
int iw, ih;
Eina_List *dirs;
char *curdir;
- DIR *dir;
+ Eina_Iterator *dir;
Ecore_Idler *idler;
int scans;
int con_num, zone_num, desk_x, desk_y;
static Eina_Bool
_idler(void *data)
{
- struct dirent *dp;
- char buf[PATH_MAX];
+ Eina_File_Direct_Info *st;
Info *info = data;
if (!info->dir)
info->idler = NULL;
return ECORE_CALLBACK_CANCEL;
}
- dp = readdir(info->dir);
- if (!dp)
+ if (!eina_iterator_next(info->dir, (void**) &st))
{
free(info->curdir);
info->curdir = NULL;
- closedir(info->dir);
+ eina_iterator_free(info->dir);
info->dir = NULL;
info->idler = NULL;
_scan(info);
return ECORE_CALLBACK_CANCEL;
}
- if ((!strcmp(dp->d_name, ".")) || (!strcmp(dp->d_name, "..")))
+ if ((st->path[st->name_start]) == '.')
return ECORE_CALLBACK_RENEW;
- if (dp->d_name[0] == '.')
- return ECORE_CALLBACK_RENEW;
- snprintf(buf, sizeof(buf), "%s/%s", info->curdir, dp->d_name);
- if (ecore_file_is_dir(buf))
+ if (st->type == EINA_FILE_DIR)
{
- info->dirs = eina_list_append(info->dirs, strdup(buf));
+ info->dirs = eina_list_append(info->dirs, strdup(st->path));
return ECORE_CALLBACK_RENEW;
}
info->scans++;
- _pan_file_add(info->span, buf, 0, 0);
+ _pan_file_add(info->span, st->path, 0, 0);
e_util_wakeup();
return ECORE_CALLBACK_RENEW;
if (info->curdir) free(info->curdir);
info->curdir = info->dirs->data;
info->dirs = eina_list_remove_list(info->dirs, info->dirs);
- if (!info->dir) info->dir = opendir(info->curdir);
+ if (!info->dir) info->dir = eina_file_stat_ls(info->curdir);
info->idler = ecore_idler_add(_idler, info);
}
}
if (!info) return;
e_object_del(E_OBJECT(info->win));
- if (info->dir) closedir(info->dir);
+ if (info->dir) eina_iterator_free(info->dir);
free(info->bg_file);
free(info->curdir);
EINA_LIST_FREE(info->dirs, s)
/* check if input matches plugin trigger */
if (input)
{
- int len_trigger = 0;
+ size_t len_trigger = 0;
EINA_LIST_FOREACH (s->plugins, l, p)
{
if (!p->config->trigger) continue;
- int len = strlen(p->config->trigger);
+ size_t len = strlen(p->config->trigger);
if (len_trigger && len != len_trigger)
continue;
/* skip non-toplevel plugins when input < min_query */
if ((!p->config->top_level) &&
- (p->config->min_query > len_inp))
+ ((size_t) p->config->min_query > len_inp))
goto next;
}
/* call free on all items provided by plugin instance '_p' */
#define EVRY_PLUGIN_ITEMS_FREE(_p) { \
- Evry_Item *it; \
- EINA_LIST_FREE(EVRY_PLUGIN(_p)->items, it) \
- evry->item_free(it); }
+ Evry_Item *_it; \
+ EINA_LIST_FREE(EVRY_PLUGIN(_p)->items, _it) \
+ evry->item_free(_it); }
/* append '_item' to list of items provided by plugin instance '_p' */
#define EVRY_PLUGIN_ITEM_APPEND(_p, _item) \
(_input && (strlen(_input) >= EVRY_PLUGIN(_p)->config->min_query)))
#define EVRY_PLUGIN_ITEMS_CLEAR(_p) { \
- Evry_Item *it; \
- EINA_LIST_FREE(EVRY_PLUGIN(_p)->items, it) \
- if (it) it->fuzzy_match = 0; }
+ Evry_Item *_it; \
+ EINA_LIST_FREE(EVRY_PLUGIN(_p)->items, _it) \
+ if (_it) _it->fuzzy_match = 0; }
#define EVRY_PLUGIN_HAS_ITEMS(_p) !!(EVRY_PLUGIN(_p)->items)
_module = E_NEW(Evry_Module, 1); \
_module->init = &_init; \
_module->shutdown = &_shutdown; \
- Eina_List *l = e_datastore_get("evry_modules"); \
- l = eina_list_append(l, _module); \
- e_datastore_set("evry_modules", l); \
+ Eina_List *_l = e_datastore_get("evry_modules"); \
+ _l = eina_list_append(_l, _module); \
+ e_datastore_set("evry_modules", _l); \
if ((_evry = e_datastore_get("evry_api"))) \
_module->active = _init(_evry); \
}
{ \
if (_module->active) _module->shutdown(); \
_module->active = EINA_FALSE; \
- Eina_List *l = e_datastore_get("evry_modules"); \
- l = eina_list_remove(l, _module); \
- if (l) e_datastore_set("evry_modules", l); \
+ Eina_List *_l = e_datastore_get("evry_modules"); \
+ _l = eina_list_remove(_l, _module); \
+ if (_l) e_datastore_set("evry_modules", _l); \
else e_datastore_del("evry_modules"); \
E_FREE(_module); \
}
static Ecore_Idler *exe_scan_idler = NULL;
static E_Config_DD *exelist_exe_edd = NULL;
static E_Config_DD *exelist_edd = NULL;
-static DIR *exe_dir = NULL;
+static Eina_Iterator *exe_dir = NULL;
static Eina_List *exe_list = NULL;
static Eina_List *exe_list2 = NULL;
static Eina_List *apps_cache = NULL;
{
GET_PLUGIN(p, plugin);
Eina_List *l;
- Evry_Item *it;
+ Evry_Item *eit;
History_Types *ht;
unsigned int len = (input ? strlen(input) : 0);
double max = 0.0;
}
}
- EINA_LIST_FOREACH (plugin->items, l, it)
+ EINA_LIST_FOREACH (plugin->items, l, eit)
{
- evry->history_item_usage_set(it, input, NULL);
- if (input && (it->usage > max) && !strncmp(input, it->label, len))
- max = it->usage;
+ evry->history_item_usage_set(eit, input, NULL);
+ if (input && (eit->usage > max) && !strncmp(input, eit->label, len))
+ max = eit->usage;
}
EVRY_ITEM(p->command)->usage = (max * 2.0);
if (exe_dir)
{
- closedir(exe_dir);
+ eina_iterator_free(exe_dir);
exe_dir = NULL;
}
EINA_LIST_FREE (exe_path, str)
static Eina_Bool
_scan_idler(void *data __UNUSED__)
{
- struct stat st;
- struct dirent *dp;
char *dir;
- char buf[4096];
/* no more path items left - stop scanning */
if (!exe_path)
{
Eina_List *l, *l2;
- E_Exe_List *el;
- E_Exe *ee;
int different = 0;
/* FIXME: check wheter they match or not */
if ((l) || (l2)) different = 1;
if (exe_list2)
{
- while (exe_list)
- {
- free(eina_list_data_get(exe_list));
- exe_list = eina_list_remove_list(exe_list, exe_list);
- }
+ void *tmp;
+
+ EINA_LIST_FREE(exe_list, tmp)
+ free(tmp);
exe_list = exe_list2;
exe_list2 = NULL;
}
if (different)
{
+ const char *s;
+ E_Exe_List *el;
+ E_Exe *ee;
+
el = calloc(1, sizeof(E_Exe_List));
- if (el)
+ if (!el) return ECORE_CALLBACK_CANCEL;
+
+ el->list = NULL;
+
+ EINA_LIST_FOREACH(exe_list, l, s)
{
- el->list = NULL;
- for (l = exe_list; l; l = l->next)
- {
- ee = malloc(sizeof(E_Exe));
- if (ee)
- {
- ee->path = eina_stringshare_add(l->data);
- el->list = eina_list_append(el->list, ee);
- }
- }
- e_config_domain_save("exebuf_exelist_cache", exelist_edd, el);
- while (el->list)
- {
- ee = eina_list_data_get(el->list);
- eina_stringshare_del(ee->path);
- free(ee);
- el->list = eina_list_remove_list(el->list, el->list);
- }
- free(el);
+ ee = malloc(sizeof(E_Exe));
+ if (!ee) continue ;
+
+ ee->path = eina_stringshare_add(s);
+ el->list = eina_list_append(el->list, ee);
+ }
+
+ e_config_domain_save("exebuf_exelist_cache", exelist_edd, el);
+
+ EINA_LIST_FREE(el->list, ee)
+ {
+ eina_stringshare_del(ee->path);
+ free(ee);
}
+ free(el);
}
exe_scan_idler = NULL;
return ECORE_CALLBACK_CANCEL;
if (!exe_dir)
{
dir = exe_path->data;
- exe_dir = opendir(dir);
+ exe_dir = eina_file_direct_ls(dir);
}
/* if we have an opened dir - scan the next item */
if (exe_dir)
{
- dir = exe_path->data;
+ Eina_File_Direct_Info *info;
- dp = readdir(exe_dir);
- if (dp)
+ if (eina_iterator_next(exe_dir, (void**) &info))
{
- if ((strcmp(dp->d_name, ".")) && (strcmp(dp->d_name, "..")))
+ Eina_Stat st;
+
+ if (eina_file_statat(eina_iterator_container_get(exe_dir), info, &st) &&
+ (!S_ISDIR(st.mode)) &&
+ (!access(info->path, X_OK)))
{
- snprintf(buf, sizeof(buf), "%s/%s", dir, dp->d_name);
- if ((stat(buf, &st) == 0) &&
- ((!S_ISDIR(st.st_mode)) &&
- (!access(buf, X_OK))))
- {
- if (!exe_list)
- exe_list = eina_list_append(exe_list, strdup(dp->d_name));
- else
- exe_list2 = eina_list_append(exe_list2, strdup(dp->d_name));
- }
+ if (!exe_list)
+ exe_list = eina_list_append(exe_list, strdup(info->path + info->name_start));
+ else
+ exe_list2 = eina_list_append(exe_list2, strdup(info->path + info->name_start));
}
}
else
* of the path list so we advance and next loop we will pick up
* the next item, or if null- abort
*/
- closedir(exe_dir);
+ dir = exe_path->data;
+ free(dir);
+
+ eina_iterator_free(exe_dir);
exe_dir = NULL;
- free(eina_list_data_get(exe_path));
+
exe_path = eina_list_remove_list(exe_path, exe_path);
}
}
projects / platform / upstream / enlightenment.git / commitdiff