//FIXME on sinks should replace old connection!
Con *filter_connect_real(Filter *source, int out, Filter *sink, int in)
{
Con *con = malloc(sizeof(Con));
con->source = eina_array_data_get(source->out, out);
con->sink = eina_array_data_get(sink->in, in);
if (!source->node->con_trees_out)
source->node->con_trees_out = eina_array_new(1);
if (!sink->node->con_trees_in)
sink->node->con_trees_in = eina_array_new(1);
if (ea_count(source->node->con_trees_out)) {
printf("WARNING: have con_trees_out\n");
while (ea_count(source->node->con_trees_out))
ea_pop(source->node->con_trees_out);
}
if (ea_count(sink->node->con_trees_in)) {
printf("WARNING: have con_trees_in\n");
while (ea_count(sink->node->con_trees_in))
ea_pop(sink->node->con_trees_in);
}
eina_array_push(source->node->con_trees_out, con);
eina_array_push(sink->node->con_trees_in, con);
filter_hash_invalidate(source);
return con;
}
Evas_Module *
evas_module_engine_get(int render_method)
{
if ((render_method <= 0) ||
((unsigned int)render_method > eina_array_count_get(evas_engines)))
return NULL;
return eina_array_data_get(evas_engines, render_method - 1);
}
//FIXME on sinks should replace old connection!
Con *filter_connect(Filter *source, int out, Filter *sink, int in)
{
Con *con = malloc(sizeof(Con));
//no composition yet
assert(in == 0);
assert(out == 0);
assert(source->in);
assert(sink->out);
lime_config_reset(sink);
lime_config_reset(source);
con->source = eina_array_data_get(source->out, out);
con->sink = eina_array_data_get(sink->in, in);
if (!source->node_orig->con_trees_out)
source->node_orig->con_trees_out = eina_array_new(1);
if (!sink->node_orig->con_trees_in)
sink->node_orig->con_trees_in = eina_array_new(1);
if (!ea_count(source->node_orig->con_trees_out))
eina_array_push(source->node_orig->con_trees_out, con);
else {
while (ea_count(source->node_orig->con_trees_out))
con_del(ea_pop(source->node_orig->con_trees_out));
eina_array_push(source->node_orig->con_trees_out, con);
}
if (!ea_count(sink->node_orig->con_trees_in))
eina_array_push(sink->node_orig->con_trees_in, con);
else {
while (ea_count(sink->node_orig->con_trees_in))
con_del(ea_pop(sink->node_orig->con_trees_in));
eina_array_push(sink->node_orig->con_trees_in, con);
}
filter_hash_invalidate(source);
return con;
}
static void _activate_item(madshelf_state_t* state, Evas_Object* choicebox,
int item_num, bool is_alt)
{
_loc_t* _loc = (_loc_t*)state->loc;
char* filename = eina_array_data_get(_loc->files, item_num);
if(is_alt)
_open_file_context_menu(state, filename);
else
_activate_file(state, item_num);
}
static void _draw_item(const madshelf_state_t* state, Evas_Object* item,
int item_num)
{
item_clear(item);
_loc_t* _loc = (_loc_t*)state->loc;
char* filename = eina_array_data_get(_loc->files, item_num);
fileinfo_t* fileinfo = fileinfo_create(filename);
fileinfo_render(item, fileinfo, is_hidden(state, filename));
fileinfo_destroy(fileinfo);
}
END_TEST
START_TEST(eina_binshare_collision)
{
Eina_Array *ea;
char buffer[50];
int i;
srand(time(NULL));
eina_init();
ea = eina_array_new(256);
fail_if(!ea);
for (i = 0; i < 10000; ++i)
{
eina_convert_itoa(rand(), buffer);
eina_array_push(ea,
(void *)eina_binshare_add_length(buffer, strlen(buffer)));
if (rand() > RAND_MAX / 2)
{
const char *r = eina_binshare_add_length(buffer, strlen(buffer));
fail_if(r == NULL);
}
}
for (i = 0; i < 10000; ++i)
{
const char *r;
eina_convert_itoa(60000 - i, buffer);
eina_array_push(ea,
(void *)eina_binshare_add_length(buffer, strlen(buffer)));
r = eina_binshare_add_length(buffer, strlen(buffer));
fail_if(r == NULL);
r = eina_binshare_add_length(buffer, strlen(buffer));
fail_if(r == NULL);
}
for (i = 0; i < 200; ++i)
eina_binshare_del(eina_array_data_get(ea, i));
for (i = 0; i < 1000; ++i)
eina_binshare_del(eina_array_pop(ea));
eina_shutdown();
eina_array_free(ea);
}
static Eina_Bool
eina_array_iterator_next(Eina_Iterator_Array *it, void **data)
{
EINA_MAGIC_CHECK_ARRAY_ITERATOR(it, EINA_FALSE);
if (!(it->index < eina_array_count(it->array)))
return EINA_FALSE;
if (data)
*data = eina_array_data_get(it->array, it->index);
it->index++;
return EINA_TRUE;
}
static Eina_Bool
eina_array_accessor_get_at(Eina_Accessor_Array *it,
unsigned int idx,
void **data)
{
EINA_MAGIC_CHECK_ARRAY_ACCESSOR(it, EINA_FALSE);
if (!(idx < eina_array_count(it->array)))
return EINA_FALSE;
if (data)
*data = eina_array_data_get(it->array, idx);
return EINA_TRUE;
}
static void _activate_file(madshelf_state_t* state, int item_num)
{
_loc_t* _loc = (_loc_t*)state->loc;
char* filename = eina_array_data_get(_loc->files, item_num);
if(!ecore_file_exists(filename))
return;
if(ecore_file_is_dir(filename))
{
go_to_directory(state, filename);
return;
}
run_default_handler(state, filename);
}
static void _free(madshelf_state_t* state)
{
_loc_t* _loc = (_loc_t*)state->loc;
positions_update_unsubscribe(_loc->watcher);
if(_loc->dir)
{
Evas_Object* choicebox = evas_object_name_find(state->canvas, "contents");
if(choicebox)
{
int sel = choicebox_get_scroll_pos(choicebox);
if(sel == -1 || sel >= eina_array_count_get(_loc->files))
curdir_set(_loc->dir, NULL);
else
{
char* filename = eina_array_data_get(_loc->files, sel);
if(filename)
{
char* c = strdup(filename);
if(c)
{
char* base = basename(c);
curdir_set(_loc->dir, base);
free(c);
}
else
curdir_set(_loc->dir, NULL);
}
else
curdir_set(_loc->dir, NULL);
}
}
else
curdir_set(_loc->dir, NULL);
}
close_file_context_menu(state->canvas, false);
close_screen_context_menu(state->canvas);
_free_files(_loc->files);
free(_loc->dir);
free(_loc);
}
static void
_evas_render2_th_main_delete_objects_clean(Evas_Public_Data *e)
{
Evas_Object_Protected_Data *obj;
unsigned int i;
double t;
// cleanup deferred object deletion
t = get_time();
for (i = 0; i < e->delete_objects.count; ++i)
{
obj = eina_array_data_get(&e->delete_objects, i);
evas_object_free(obj->object, 1);
}
// OBJS_ARRAY_CLEAN(&e->delete_objects);
eina_array_clean(&e->delete_objects);
t = get_time() - t;
printf("T: object deletion: "); out_time(t);
}
static Eina_Value *
azy_value_deserialize_struct_json(cJSON *object)
{
Eina_Array *st_members, *st_values;
unsigned int offset = 0, z = 0;
Eina_Value *value_st = NULL;
Eina_Value_Struct_Member *members;
Eina_Value_Struct_Desc *st_desc;
const char *name;
cJSON *child;
st_desc = azy_value_util_struct_desc_new();
st_members = eina_array_new(1);
st_values = eina_array_new(1);
for (child = object->child; child; child = child->next)
{
Eina_Value_Struct_Member *m;
const Eina_Value_Type *type;
Eina_Value *v;
type = _azy_value_type_get(child);
if (!type) goto end;
name = child->string;
m = (Eina_Value_Struct_Member*)calloc(1, sizeof(Eina_Value_Struct_Member));
m->name = eina_stringshare_add(name);
offset = azy_value_util_type_offset(type, offset);
m->offset = offset;
offset += azy_value_util_type_size(type);
m->type = type;
eina_array_push(st_members, m);
v = azy_value_deserialize_json(child);
if (!v) goto end;
eina_array_push(st_values, v);
z++;
}
if (!z)
{
free(st_desc);
goto end;
}
members = (Eina_Value_Struct_Member*)malloc(eina_array_count(st_members) * sizeof(Eina_Value_Struct_Member));
for (z = 0; z < eina_array_count(st_members); z++)
{
Eina_Value_Struct_Member *m = (Eina_Value_Struct_Member*)eina_array_data_get(st_members, z);
members[z].name = m->name;
members[z].offset = m->offset;
members[z].type = m->type;
free(m);
}
//setup
st_desc->members = members;
st_desc->member_count = eina_array_count(st_members);
st_desc->size = offset;
value_st = eina_value_struct_new(st_desc);
//filling with data
for (z = 0; z < eina_array_count(st_values); z++)
{
Eina_Value *v = (Eina_Value*)eina_array_data_get(st_values, z);
eina_value_struct_value_set(value_st, members[z].name, v);
eina_value_free(v);
}
end:
eina_array_free(st_members);
eina_array_free(st_values);
return value_st;
}
char *
_nedje_text_escape(const char *text)
{
Eina_Strbuf *txt;
char *ret;
const char *text_end;
size_t text_len;
Eina_Array *arr;
const char *cur_tag = NULL;
if (!text) return NULL;
txt = eina_strbuf_new();
text_len = strlen(text);
arr = eina_array_new(3);
text_end = text + text_len;
while (text < text_end)
{
int advance;
if ((text[0] == '<') && text[1])
{
const char *tag, *popped;
Eina_Bool closing = EINA_FALSE;
if (text[1] == '/') //closing tag
{
closing = EINA_TRUE;
tag = _get_tag(text + 2);
}
else
tag = _get_tag(text + 1);
if (closing)
{
if (cur_tag && (tag != cur_tag))
{
/* tag mismatch: autoclose all failure tags
* not technically required by the spec,
* but it makes me feel better about myself
*/
do
{
popped = eina_array_pop(arr);
if (eina_array_count(arr))
cur_tag = eina_array_data_get(arr, eina_array_count(arr) - 1);
else
cur_tag = NULL;
eina_strbuf_append_printf(txt, "</%c>", popped[1]);
} while (cur_tag && (popped != tag));
advance = 4;
}
else if (cur_tag)
{
/* tag match: just pop */
popped = eina_array_pop(arr);
if (eina_array_count(arr))
cur_tag = eina_array_data_get(arr, eina_array_count(arr) - 1);
else
cur_tag = NULL;
eina_strbuf_append_printf(txt, "</%c>", popped[1]);
advance = 4;
}
else
{
/* no current tag: escape */
advance = _text_escape(txt, text);
}
}
else
{
if (tag)
{
cur_tag = tag;
eina_array_push(arr, tag);
eina_strbuf_append_printf(txt, "<%c>", tag[1]);
advance = 3;
}
else
advance = _text_escape(txt, text);
}
}
else if (text[0] == '&')
{
const char *s;
s = strchr(text, ';');
if (s)
s = evas_textblock_escape_string_range_get(text, s + 1);
if (s)
{
eina_strbuf_append_char(txt, text[0]);
advance = 1;
}
else
advance = _text_escape(txt, text);
}
else
advance = _text_escape(txt, text);
text += advance;
}
eina_array_free(arr);
ret = eina_strbuf_string_steal(txt);
eina_strbuf_free(txt);
return ret;
}
static void
on_send(void *data, Evas_Object *obj, void *event_info)
{
const char *text;
char *text2;
int len;
if (!number)
{
alert("No recipient indicated.<br>"
"Please specify one");
return;
}
text = elm_entry_entry_get(sms_entry);
if (!text)
{
alert("The message text is<br>"
"empty. Cannot send");
return;
}
text2 = elm_entry_markup_to_utf8(text);
if (!text2)
{
alert("Conversion from entry<br>"
"to UTF8 failed");
return;
}
len = strlen(text2);
if (len > 0)
{
if (text2[len - 1] == '\n') text2[len - 1] = 0;
}
printf("TO: <%s>\n", number);
printf("%s\n", text2);
// FIXME: no reply handler in efso to track message send
// FIXME: text input is utf8 - but encoding unspecified - efso probably
// should allow for encoding params or convert to a proper encoding
// (gsm, ucs2 etc.) for you.
if (data_message_sent_store(reply_to, number, text2))
{
#ifdef HAVE_EFSO
efso_gsm_sms_send_message(number, text2, NULL, NULL);
#elif HAVE_EOFONO
E_Ofono_Element *element;
Eina_Array *modems = NULL;
const char *path;
Eina_Bool powered = 0;
if (e_ofono_manager_get())
{
fputs("DBG: Trying to get modem from oFono\n", stderr);
if (e_ofono_manager_modems_get(&modems) && (modems) &&
(modems->count > 0))
{
path = eina_array_data_get(modems, 0);
fprintf(stderr, "DBG: Using oFono modem %s\n", path);
element = e_ofono_element_get(path, "org.ofono.Modem");
if (e_ofono_modem_powered_get(element, &powered))
{
if (powered)
{
element = e_ofono_element_get
(path, "org.ofono.SmsManager");
if (!e_ofono_sms_send_message
(element, number, text2, NULL, NULL))
{
alert("oFono error!<br>"
"Check log for more info.<br>"
"(message not sent)");
fputs
("ERROR: sms_send failed\n", stderr);
return;
}
}
else
{
alert("Modem powered off<br>"
"(message not sent)");
return;
}
}
else
{
alert("oFono error!<br>"
"Check log for more info.<br>"
"(message not sent)");
fputs("ERROR: modem_powered_get failed\n", stderr);
return;
}
}
}
else
{
alert("ofonod is not running!<br>"
"(message not sent)");
return;
}
#endif
}
else
{
alert("Cannot store sent message.<br>"
"FIXME: select msg to delete");
free(text2);
return;
}
free(text2);
on_write(NULL, NULL, NULL);
}
EAPI Eina_Bool
eina_array_remove(Eina_Array *array, Eina_Bool (*keep)(void *data,
void *gdata),
void *gdata)
{
void **tmp;
/* WARNING:
The algorithm does exit before using unitialized data. So compiler is
giving you a false positiv here too.
*/
void *data = NULL;
unsigned int total = 0;
unsigned int limit;
unsigned int i;
EINA_SAFETY_ON_NULL_RETURN_VAL(array, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(keep, EINA_FALSE);
EINA_MAGIC_CHECK_ARRAY(array);
if (array->total == 0)
return EINA_TRUE;
for (i = 0; i < array->count; ++i)
{
data = eina_array_data_get(array, i);
if (keep(data, gdata) == EINA_FALSE)
break;
}
limit = i;
if (i < array->count)
++i;
for (; i < array->count; ++i)
{
data = eina_array_data_get(array, i);
if (keep(data, gdata) == EINA_TRUE)
break;
}
/* Special case all objects that need to stay are at the beginning of the array. */
if (i == array->count)
{
array->count = limit;
if (array->count == 0)
{
free(array->data);
array->total = 0;
array->data = NULL;
}
return EINA_TRUE;
}
eina_error_set(0);
tmp = malloc(sizeof (void *) * array->total);
if (!tmp)
{
eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
return EINA_FALSE;
}
memcpy(tmp, array->data, limit * sizeof(void *));
total = limit;
if (i < array->count)
{
tmp[total] = data;
total++;
++i;
}
for (; i < array->count; ++i)
{
data = eina_array_data_get(array, i);
if (keep(data, gdata))
{
tmp[total] = data;
total++;
}
}
free(array->data);
/* If we do not keep any object in the array, we should have exited
earlier in test (i == array->count). */
assert(total != 0);
array->data = tmp;
array->count = total;
return EINA_TRUE;
}
/*
* (params[0] | (top of stack)) == filename
* params[1 | 0] == key
* params[2 | 1] == (cipher pass)
*/
static const Elixir_Loader_File *
_elixir_eet_request(int param, const char **params)
{
Elixir_Loader_File *result = NULL;
Elixir_Eet_Filename *top = NULL;
Elixir_Eet_Filename *lookup = NULL;
Eet_File *eet = NULL;
char *filename;
char *section = NULL;
char *compiled_key;
char *content = NULL;
char *compiled = NULL;
const char *key;
const char *cipher;
Eina_Bool free_compiled = EINA_FALSE;
Eina_Bool free_content = EINA_FALSE;
int content_length;
int compiled_length;
unsigned int i;
if (param < 1 || param > 3) return NULL;
cipher = NULL;
switch (param)
{
case 1:
if (stack && eina_array_count_get(stack) > 0)
{
top = eina_array_data_get(stack, eina_array_count_get(stack) - 1);
filename = top->filename;
key = params[0];
}
else
{
filename = (char*) params[0];
key = "elixir/main";
}
break;
case 2:
filename = (char*) params[0];
key = params[1];
break;
case 3:
filename = (char*) params[0];
key = params[1];
cipher = params[2];
break;
default:
return NULL;
}
filename = elixir_exe_canonicalize(filename);
if (!filename) return NULL;
section = strdup(key);
if (!section) goto on_error;
eet = eet_open(filename, EET_FILE_MODE_READ);
if (!eet) goto on_error;
/* Use a cache to prevent useless security check. */
lookup = eina_hash_find(cache, filename);
if (lookup && lookup->eet == eet)
{
eet_close(eet);
if (top != lookup)
{
eina_array_push(stack, lookup);
top = lookup;
}
eet = lookup->eet;
lru = eina_list_remove(lru, lookup);
}
else
{
/* Lookup is no longer valid, remove it from cache. */
if (lookup)
{
lru = eina_list_remove(lru, lookup);
eina_hash_del(cache, filename, lookup);
}
if (!_elixir_eet_security_check(eet)) goto on_error;
}
compiled_key = alloca(strlen(key) + 2);
snprintf(compiled_key, strlen(key) + 2, "%sx", key);
if (cipher)
{
free_content = EINA_TRUE;
content = eet_read_cipher(eet, key, &content_length, cipher);
if (!content) goto on_error;
compiled = eet_read_cipher(eet, compiled_key, &compiled_length, cipher);
}
else
{
content = (char*) eet_read_direct(eet, key, &content_length);
if (!content)
{
free_content = EINA_TRUE;
content = eet_read(eet, key, &content_length);
}
if (!content) goto on_error;
compiled = (char*) eet_read_direct(eet, compiled_key, &compiled_length);
if (!compiled)
{
free_compiled = EINA_TRUE;
compiled = eet_read(eet, compiled_key, &compiled_length);
}
}
if (memchr(content, '\0', content_length))
goto on_error;
if (compiled)
{
for (i = 0; i < sizeof (_jsx_header) / sizeof (_jsx_header[0]); ++i)
if (*(unsigned int*) compiled == _jsx_header[i])
break;
if (i == sizeof (_jsx_header) / sizeof (_jsx_header[0]))
if (free_compiled)
{
free(compiled);
free_compiled = EINA_FALSE;
compiled = NULL;
}
}
result = malloc(sizeof (Elixir_Loader_File));
if (!result) goto on_error;
result->content_length = content_length;
result->content = content;
result->free_content = free_content;
result->compiled_length = compiled_length;
result->compiled = compiled;
result->free_compiled = free_compiled;
/* Ref counting helper to find current open file. */
if (top)
{
top->reference++;
free(filename);
}
else
{
top = malloc(sizeof (Elixir_Eet_Filename) + strlen(filename));
if (!top) goto on_error;
top->reference = 1;
top->filename = filename;
top->eet = eet;
eina_array_push(stack, top);
eina_hash_add(cache, filename, top);
}
result->file = top;
result->section = section;
return result;
on_error:
if (result) free(result);
if (content && free_content) free(content);
if (compiled && free_compiled) free(compiled);
if (eet) eet_close(eet);
if (section) free(section);
free(filename);
return NULL;
}
