{
Eet_Dictionary *new;
- new = calloc(1, sizeof (Eet_Dictionary));
+ new = eet_dictionary_calloc(1);
if (!new)
- return NULL;
+ return NULL;
memset(new->hash, -1, sizeof (int) * 256);
+ eina_lock_new(&new->mutex);
return new;
-} /* eet_dictionary_add */
+}
void
eet_dictionary_free(Eet_Dictionary *ed)
{
- if (ed)
- {
- int i;
+ int i;
- for (i = 0; i < ed->count; ++i)
- if (ed->all[i].str)
- free(ed->all[i].str);
+ if (!ed) return;
- if (ed->all)
- free(ed->all);
+ eina_lock_free(&ed->mutex);
- free(ed);
- }
-} /* eet_dictionary_free */
+ for (i = 0; i < ed->count; ++i)
+ if (ed->all[i].allocated)
+ eina_stringshare_del(ed->all[i].str);
+
+ if (ed->all)
+ free(ed->all);
+
+ if (ed->converts) eina_hash_free(ed->converts);
+
+ eet_dictionary_mp_free(ed);
+}
static int
_eet_dictionary_lookup(Eet_Dictionary *ed,
const char *string,
- int len,
+ int len,
int hash)
{
Eina_Bool found = EINA_FALSE;
while (current != -1)
{
- if (ed->all[current].len == len)
- {
- if (ed->all[current].str)
- if (strcmp(ed->all[current].str, string) == 0)
- {
- found = EINA_TRUE;
- break;
- }
-
- if (ed->all[current].mmap)
- if (strcmp(ed->all[current].mmap, string) == 0)
- {
- found = EINA_TRUE;
- break;
- }
- }
+ if (ed->all[current].len == len)
+ {
+ if (ed->all[current].str &&
+ ((ed->all[current].str == string) ||
+ (!strcmp(ed->all[current].str, string))))
+ {
+ found = EINA_TRUE;
+ break;
+ }
+ }
prev = current;
current = ed->all[current].next;
}
- if (current == -1 && found)
- return prev;
+ if ((current == -1) && found)
+ return prev;
return current;
-} /* _eet_dictionary_lookup */
+}
int
eet_dictionary_string_add(Eet_Dictionary *ed,
const char *string)
{
Eet_String *current;
- char *str;
+ const char *str;
int hash;
int idx;
int len;
+ int cnt;
if (!ed)
- return -1;
+ return -1;
hash = _eet_hash_gen(string, 8);
len = strlen(string) + 1;
+ eina_lock_take(&ed->mutex);
+
idx = _eet_dictionary_lookup(ed, string, len, hash);
if (idx != -1)
{
- if (ed->all[idx].str)
- if (strcmp(ed->all[idx].str, string) == 0)
- return idx;
-
- if (ed->all[idx].mmap)
- if (strcmp(ed->all[idx].mmap, string) == 0)
+ if (ed->all[idx].str &&
+ ((ed->all[idx].str == string) ||
+ (!strcmp(ed->all[idx].str, string))))
+ {
+ eina_lock_release(&ed->mutex);
return idx;
+ }
}
if (ed->total == ed->count)
total = ed->total + 8;
- new = realloc(ed->all, sizeof (Eet_String) * total);
- if (!new)
- return -1;
+ new = realloc(ed->all, total * sizeof(Eet_String));
+ if (!new) goto on_error;
ed->all = new;
ed->total = total;
}
- str = strdup(string);
- if (!str)
- return -1;
+ str = eina_stringshare_add(string);
+ if (!str) goto on_error;
current = ed->all + ed->count;
- current->type = EET_D_NOT_CONVERTED;
+ current->allocated = EINA_TRUE;
current->hash = hash;
current->str = str;
current->len = len;
- current->mmap = NULL;
if (idx == -1)
{
current->prev = ed->all[idx].prev;
if (current->next != -1)
- ed->all[current->next].prev = ed->count;
+ ed->all[current->next].prev = ed->count;
if (current->prev != -1)
- ed->all[current->prev].next = ed->count;
+ ed->all[current->prev].next = ed->count;
else
- ed->hash[hash] = ed->count;
+ ed->hash[hash] = ed->count;
}
- return ed->count++;
-} /* eet_dictionary_string_add */
+ cnt = ed->count++;
+ eina_lock_release(&ed->mutex);
+ return cnt;
+
+ on_error:
+ eina_lock_release(&ed->mutex);
+ return -1;
+}
int
eet_dictionary_string_get_size(const Eet_Dictionary *ed,
int idx)
{
- if (!ed)
- return 0;
+ int length = 0;
+
+ if (!ed) goto done;
+
+ if (idx < 0) goto done;
- if (idx < 0)
- return 0;
+ eina_lock_take((Eina_Lock*) &ed->mutex);
if (idx < ed->count)
- return ed->all[idx].len;
+ length = ed->all[idx].len;
- return 0;
-} /* eet_dictionary_string_get_size */
+ eina_lock_release((Eina_Lock*) &ed->mutex);
+
+ done:
+ return length;
+}
+
+EAPI int
+eet_dictionary_count(const Eet_Dictionary *ed)
+{
+ return ed->count;
+}
int
eet_dictionary_string_get_hash(const Eet_Dictionary *ed,
int idx)
{
- if (!ed)
- return -1;
+ int hash = -1;
+
+ if (!ed) goto done;
- if (idx < 0)
- return -1;
+ if (idx < 0) goto done;
+
+ eina_lock_take((Eina_Lock*) &ed->mutex);
if (idx < ed->count)
- return ed->all[idx].hash;
+ hash = ed->all[idx].hash;
- return -1;
-} /* eet_dictionary_string_get_hash */
+ eina_lock_release((Eina_Lock*) &ed->mutex);
+
+ done:
+ return hash;
+}
const char *
eet_dictionary_string_get_char(const Eet_Dictionary *ed,
int idx)
{
- if (!ed)
- return NULL;
+ const char *s = NULL;
+
+ if (!ed) goto done;
- if (idx < 0)
- return NULL;
+ if (idx < 0) goto done;
+
+ eina_lock_take((Eina_Lock*) &ed->mutex);
if (idx < ed->count)
{
#ifdef _WIN32
/* Windows file system could change the mmaped file when replacing a file. So we need to copy all string in memory to avoid bugs. */
- if (!ed->all[idx].str)
+ if (!ed->all[idx].allocated)
{
- ed->all[idx].str = strdup(ed->all[idx].mmap);
- ed->all[idx].mmap = NULL;
+ ed->all[idx].str = eina_stringshare_add(ed->all[idx].str);
+ ed->all[idx].allocated = EINA_TRUE;
}
-
-#else /* ifdef _WIN32 */
- if (ed->all[idx].mmap)
- return ed->all[idx].mmap;
-
#endif /* ifdef _WIN32 */
- return ed->all[idx].str;
+ s = ed->all[idx].str;
}
- return NULL;
-} /* eet_dictionary_string_get_char */
+ eina_lock_release((Eina_Lock*) &ed->mutex);
+
+ done:
+ return s;
+}
static inline Eina_Bool
_eet_dictionary_string_get_me_cache(const char *s,
}
return EINA_FALSE;
-} /* _eet_dictionary_string_get_me_cache */
+}
static inline Eina_Bool
_eet_dictionary_string_get_float_cache(const char *s,
if (_eet_dictionary_string_get_me_cache(s, len, &mantisse, &exponent))
{
if (s[4] == '+')
- *result = (float)(mantisse << exponent);
+ *result = (float)(mantisse << exponent);
else
- *result = (float)mantisse / (float)(1 << exponent);
+ *result = (float)mantisse / (float)(1 << exponent);
return EINA_TRUE;
}
return EINA_FALSE;
-} /* _eet_dictionary_string_get_float_cache */
+}
static inline Eina_Bool
_eet_dictionary_string_get_double_cache(const char *s,
if (_eet_dictionary_string_get_me_cache(s, len, &mantisse, &exponent))
{
if (s[4] == '+')
- *result = (double)(mantisse << exponent);
+ *result = (double)(mantisse << exponent);
else
- *result = (double)mantisse / (float)(1 << exponent);
+ *result = (double)mantisse / (float)(1 << exponent);
return EINA_TRUE;
}
return EINA_FALSE;
-} /* _eet_dictionary_string_get_double_cache */
+}
static inline Eina_Bool
_eet_dictionary_test(const Eet_Dictionary *ed,
int idx,
void *result)
{
- if (!result)
- return EINA_FALSE;
+ Eina_Bool limit = EINA_FALSE;
- if (!ed)
- return EINA_FALSE;
+ if (!result) goto done;
- if (idx < 0)
- return EINA_FALSE;
+ if (!ed) goto done;
- if (!(idx < ed->count))
- return EINA_FALSE;
+ if (idx < 0) goto done;
- return EINA_TRUE;
-} /* _eet_dictionary_test */
+ eina_lock_take((Eina_Lock*) &ed->mutex);
+
+ if (!(idx < ed->count)) goto unlock_done;
+
+ limit = EINA_TRUE;
+
+ unlock_done:
+ eina_lock_release((Eina_Lock*) &ed->mutex);
+
+ done:
+ return limit;
+}
+
+static Eet_Convert *
+eet_dictionary_convert_get(const Eet_Dictionary *ed,
+ int idx,
+ const char **str)
+{
+ Eet_Convert *result;
+
+ eina_lock_take((Eina_Lock*) &ed->mutex);
+
+ *str = ed->all[idx].str;
+
+ if (!ed->converts)
+ {
+ ((Eet_Dictionary *)ed)->converts = eina_hash_int32_new(free);
+
+ goto add_convert;
+ }
+
+ result = eina_hash_find(ed->converts, &idx);
+ if (result) goto done;
+
+ add_convert:
+ result = calloc(1, sizeof (Eet_Convert));
+
+ eina_hash_add(ed->converts, &idx, result);
+
+ done:
+ eina_lock_release((Eina_Lock*) &ed->mutex);
+
+ return result;
+}
Eina_Bool
eet_dictionary_string_get_float(const Eet_Dictionary *ed,
int idx,
float *result)
{
- if (!_eet_dictionary_test(ed, idx, result))
- return EINA_FALSE;
+ Eet_Convert *convert;
+ const char *str;
- if (!(ed->all[idx].type & EET_D_FLOAT))
- {
- const char *str;
+ if (!_eet_dictionary_test(ed, idx, result))
+ return EINA_FALSE;
- str = ed->all[idx].str ? ed->all[idx].str : ed->all[idx].mmap;
+ convert = eet_dictionary_convert_get(ed, idx, &str);
+ if (!convert) return EINA_FALSE;
+ if (!(convert->type & EET_D_FLOAT))
+ {
+ eina_lock_take((Eina_Lock*) &ed->mutex);
if (!_eet_dictionary_string_get_float_cache(str, ed->all[idx].len,
- &ed->all[idx].f))
+ &convert->f))
{
long long mantisse = 0;
long exponent = 0;
if (eina_convert_atod(str, ed->all[idx].len, &mantisse,
&exponent) == EINA_FALSE)
- return EINA_FALSE;
+ {
+ eina_lock_release((Eina_Lock*) &ed->mutex);
+ return EINA_FALSE;
+ }
- ed->all[idx].f = ldexpf((float)mantisse, exponent);
+ convert->f = ldexpf((float)mantisse, exponent);
}
+ eina_lock_release((Eina_Lock*) &ed->mutex);
- ed->all[idx].type |= EET_D_FLOAT;
+ convert->type |= EET_D_FLOAT;
}
- *result = ed->all[idx].f;
+ *result = convert->f;
return EINA_TRUE;
-} /* eet_dictionary_string_get_float */
+}
Eina_Bool
eet_dictionary_string_get_double(const Eet_Dictionary *ed,
int idx,
double *result)
{
+ Eet_Convert *convert;
+ const char *str;
+
if (!_eet_dictionary_test(ed, idx, result))
- return EINA_FALSE;
+ return EINA_FALSE;
- if (!(ed->all[idx].type & EET_D_DOUBLE))
- {
- const char *str;
+ convert = eet_dictionary_convert_get(ed, idx, &str);
+ if (!convert) return EINA_FALSE;
- str = ed->all[idx].str ? ed->all[idx].str : ed->all[idx].mmap;
+ if (!(convert->type & EET_D_DOUBLE))
+ {
+ eina_lock_take((Eina_Lock*) &ed->mutex);
if (!_eet_dictionary_string_get_double_cache(str, ed->all[idx].len,
- &ed->all[idx].d))
+ &convert->d))
{
long long mantisse = 0;
long exponent = 0;
if (eina_convert_atod(str, ed->all[idx].len, &mantisse,
&exponent) == EINA_FALSE)
- return EINA_FALSE;
+ {
+ eina_lock_release((Eina_Lock*) &ed->mutex);
+ return EINA_FALSE;
+ }
- ed->all[idx].d = ldexp((double)mantisse, exponent);
+ convert->d = ldexp((double)mantisse, exponent);
}
+ eina_lock_release((Eina_Lock*) &ed->mutex);
- ed->all[idx].type |= EET_D_DOUBLE;
+ convert->type |= EET_D_DOUBLE;
}
- *result = ed->all[idx].d;
+ *result = convert->d;
return EINA_TRUE;
-} /* eet_dictionary_string_get_double */
+}
Eina_Bool
eet_dictionary_string_get_fp(const Eet_Dictionary *ed,
int idx,
Eina_F32p32 *result)
{
+ Eet_Convert *convert;
+ const char *str;
+
if (!_eet_dictionary_test(ed, idx, result))
- return EINA_FALSE;
+ return EINA_FALSE;
+
+ convert = eet_dictionary_convert_get(ed, idx, &str);
+ if (!convert) return EINA_FALSE;
- if (!(ed->all[idx].type & EET_D_FIXED_POINT))
+ if (!(convert->type & EET_D_FIXED_POINT))
{
- const char *str;
Eina_F32p32 fp;
- str = ed->all[idx].str ? ed->all[idx].str : ed->all[idx].mmap;
-
+ eina_lock_take((Eina_Lock*) &ed->mutex);
if (!eina_convert_atofp(str, ed->all[idx].len, &fp))
- return EINA_FALSE;
+ {
+ eina_lock_release((Eina_Lock*) &ed->mutex);
+ return EINA_FALSE;
+ }
+ eina_lock_release((Eina_Lock*) &ed->mutex);
- ed->all[idx].fp = fp;
- ed->all[idx].type |= EET_D_FIXED_POINT;
+ convert->fp = fp;
+ convert->type |= EET_D_FIXED_POINT;
}
- *result = ed->all[idx].fp;
+ *result = convert->fp;
return EINA_TRUE;
-} /* eet_dictionary_string_get_fp */
+}
EAPI int
eet_dictionary_string_check(Eet_Dictionary *ed,
const char *string)
{
+ int res = 0;
int i;
if ((!ed) || (!string))
- return 0;
+ return 0;
+
+ eina_lock_take(&ed->mutex);
if ((ed->start <= string) && (string < ed->end))
- return 1;
+ res = 1;
- for (i = 0; i < ed->count; ++i)
- if (ed->all[i].str == string)
- return 1;
+ if (!res)
+ {
+ for (i = 0; i < ed->count; ++i)
+ if ((ed->all[i].allocated) && ed->all[i].str == string)
+ {
+ res = 1;
+ break;
+ }
+ }
+
+ eina_lock_release(&ed->mutex);
- return 0;
-} /* eet_dictionary_string_check */
+ return res;
+}
projects / framework / uifw / eet.git / blobdiff