eolian: remove internal state struct (rely on external Eolian state)

diff --git a/src/lib/eolian/database_class_api.c b/src/lib/eolian/database_class_api.c
index da43d05..ae151f4 100644 (file)
--- a/src/lib/eolian/database_class_api.c
+++ b/src/lib/eolian/database_class_api.c
@@ -32,23 +32,21 @@ eolian_class_namespaces_get(const Eolian_Class *cl)
 }
 
 EAPI const Eolian_Class *
-eolian_class_get_by_name(const Eolian_Unit *unit EINA_UNUSED,
-                         const char *class_name)
+eolian_class_get_by_name(const Eolian_Unit *unit, const char *class_name)
 {
-   if (!_state) return NULL;
+   if (!unit) return NULL;
    Eina_Stringshare *shr = eina_stringshare_add(class_name);
-   Eolian_Class *cl = eina_hash_find(_state->unit.classes, shr);
+   Eolian_Class *cl = eina_hash_find(unit->state->unit.classes, shr);
    eina_stringshare_del(shr);
    return cl;
 }
 
 EAPI const Eolian_Class *
-eolian_class_get_by_file(const Eolian_Unit *unit EINA_UNUSED,
-                         const char *file_name)
+eolian_class_get_by_file(const Eolian_Unit *unit, const char *file_name)
 {
-   if (!_state) return NULL;
+   if (!unit) return NULL;
    Eina_Stringshare *shr = eina_stringshare_add(file_name);
-   Eolian_Class *cl = eina_hash_find(_state->classes_f, shr);
+   Eolian_Class *cl = eina_hash_find(unit->state->classes_f, shr);
    eina_stringshare_del(shr);
    return cl;
 }
@@ -61,9 +59,9 @@ eolian_class_type_get(const Eolian_Class *cl)
 }
 
 EAPI Eina_Iterator *
-eolian_all_classes_get(const Eolian_Unit *unit EINA_UNUSED)
+eolian_all_classes_get(const Eolian_Unit *unit)
 {
-   return (_state ? eina_hash_iterator_data_new(_state->unit.classes) : NULL);
+   return (unit ? eina_hash_iterator_data_new(unit->state->unit.classes) : NULL);
 }
 
 EAPI const Eolian_Documentation *

diff --git a/src/lib/eolian/database_type.c b/src/lib/eolian/database_type.c
index 347a6ba..5258709 100644 (file)
--- a/src/lib/eolian/database_type.c
+++ b/src/lib/eolian/database_type.c
@@ -41,30 +41,30 @@ database_typedecl_del(Eolian_Typedecl *tp)
 }
 
 void
-database_type_add(Eolian_Typedecl *def)
+database_type_add(Eolian *state, Eolian_Typedecl *def)
 {
-   eina_hash_set(_state->unit.aliases, def->full_name, def);
-   eina_hash_set(_state->aliases_f, def->base.file, eina_list_append
-                ((Eina_List*)eina_hash_find(_state->aliases_f, def->base.file),
+   eina_hash_set(state->unit.aliases, def->full_name, def);
+   eina_hash_set(state->aliases_f, def->base.file, eina_list_append
+                ((Eina_List*)eina_hash_find(state->aliases_f, def->base.file),
                 def));
    database_decl_add(def->full_name, EOLIAN_DECL_ALIAS, def->base.file, def);
 }
 
 void
-database_struct_add(Eolian_Typedecl *tp)
+database_struct_add(Eolian *state, Eolian_Typedecl *tp)
 {
-   eina_hash_set(_state->unit.structs, tp->full_name, tp);
-   eina_hash_set(_state->structs_f, tp->base.file, eina_list_append
-                ((Eina_List*)eina_hash_find(_state->structs_f, tp->base.file), tp));
+   eina_hash_set(state->unit.structs, tp->full_name, tp);
+   eina_hash_set(state->structs_f, tp->base.file, eina_list_append
+                ((Eina_List*)eina_hash_find(state->structs_f, tp->base.file), tp));
    database_decl_add(tp->full_name, EOLIAN_DECL_STRUCT, tp->base.file, tp);
 }
 
 void
-database_enum_add(Eolian_Typedecl *tp)
+database_enum_add(Eolian *state, Eolian_Typedecl *tp)
 {
-   eina_hash_set(_state->unit.enums, tp->full_name, tp);
-   eina_hash_set(_state->enums_f, tp->base.file, eina_list_append
-                ((Eina_List*)eina_hash_find(_state->enums_f, tp->base.file), tp));
+   eina_hash_set(state->unit.enums, tp->full_name, tp);
+   eina_hash_set(state->enums_f, tp->base.file, eina_list_append
+                ((Eina_List*)eina_hash_find(state->enums_f, tp->base.file), tp));
    database_decl_add(tp->full_name, EOLIAN_DECL_ENUM, tp->base.file, tp);
 }
 

diff --git a/src/lib/eolian/database_type_api.c b/src/lib/eolian/database_type_api.c
index 20ba88a..5edaed9 100644 (file)
--- a/src/lib/eolian/database_type_api.c
+++ b/src/lib/eolian/database_type_api.c
@@ -7,93 +7,87 @@
 #include "eo_lexer.h"
 
 EAPI const Eolian_Typedecl *
-eolian_typedecl_alias_get_by_name(const Eolian_Unit *unit EINA_UNUSED,
-                                  const char *name)
+eolian_typedecl_alias_get_by_name(const Eolian_Unit *unit, const char *name)
 {
-   if (!_state) return NULL;
+   if (!unit) return NULL;
    Eina_Stringshare *shr = eina_stringshare_add(name);
-   Eolian_Typedecl *tp = eina_hash_find(_state->unit.aliases, shr);
+   Eolian_Typedecl *tp = eina_hash_find(unit->state->unit.aliases, shr);
    eina_stringshare_del(shr);
    if (!tp) return NULL;
    return tp;
 }
 
 EAPI const Eolian_Typedecl *
-eolian_typedecl_struct_get_by_name(const Eolian_Unit *unit EINA_UNUSED,
-                                   const char *name)
+eolian_typedecl_struct_get_by_name(const Eolian_Unit *unit, const char *name)
 {
-   if (!_state) return NULL;
+   if (!unit) return NULL;
    Eina_Stringshare *shr = eina_stringshare_add(name);
-   Eolian_Typedecl *tp = eina_hash_find(_state->unit.structs, shr);
+   Eolian_Typedecl *tp = eina_hash_find(unit->state->unit.structs, shr);
    eina_stringshare_del(shr);
    if (!tp) return NULL;
    return tp;
 }
 
 EAPI const Eolian_Typedecl *
-eolian_typedecl_enum_get_by_name(const Eolian_Unit *unit EINA_UNUSED,
-                                 const char *name)
+eolian_typedecl_enum_get_by_name(const Eolian_Unit *unit, const char *name)
 {
-   if (!_state) return NULL;
+   if (!unit) return NULL;
    Eina_Stringshare *shr = eina_stringshare_add(name);
-   Eolian_Typedecl *tp = eina_hash_find(_state->unit.enums, shr);
+   Eolian_Typedecl *tp = eina_hash_find(unit->state->unit.enums, shr);
    eina_stringshare_del(shr);
    if (!tp) return NULL;
    return tp;
 }
 
 EAPI Eina_Iterator *
-eolian_typedecl_aliases_get_by_file(const Eolian_Unit *unit EINA_UNUSED,
-                                    const char *fname)
+eolian_typedecl_aliases_get_by_file(const Eolian_Unit *unit, const char *fname)
 {
-   if (!_state) return NULL;
+   if (!unit) return NULL;
    Eina_Stringshare *shr = eina_stringshare_add(fname);
-   Eina_List *l = eina_hash_find(_state->aliases_f, shr);
+   Eina_List *l = eina_hash_find(unit->state->aliases_f, shr);
    eina_stringshare_del(shr);
    if (!l) return NULL;
    return eina_list_iterator_new(l);
 }
 
 EAPI Eina_Iterator *
-eolian_typedecl_structs_get_by_file(const Eolian_Unit *unit EINA_UNUSED,
-                                    const char *fname)
+eolian_typedecl_structs_get_by_file(const Eolian_Unit *unit, const char *fname)
 {
-   if (!_state) return NULL;
+   if (!unit) return NULL;
    Eina_Stringshare *shr = eina_stringshare_add(fname);
-   Eina_List *l = eina_hash_find(_state->structs_f, shr);
+   Eina_List *l = eina_hash_find(unit->state->structs_f, shr);
    eina_stringshare_del(shr);
    if (!l) return NULL;
    return eina_list_iterator_new(l);
 }
 
 EAPI Eina_Iterator *
-eolian_typedecl_enums_get_by_file(const Eolian_Unit *unit EINA_UNUSED,
-                                  const char *fname)
+eolian_typedecl_enums_get_by_file(const Eolian_Unit *unit, const char *fname)
 {
-   if (!_state) return NULL;
+   if (!unit) return NULL;
    Eina_Stringshare *shr = eina_stringshare_add(fname);
-   Eina_List *l = eina_hash_find(_state->enums_f, shr);
+   Eina_List *l = eina_hash_find(unit->state->enums_f, shr);
    eina_stringshare_del(shr);
    if (!l) return NULL;
    return eina_list_iterator_new(l);
 }
 
 EAPI Eina_Iterator *
-eolian_typedecl_all_aliases_get(const Eolian_Unit *unit EINA_UNUSED)
+eolian_typedecl_all_aliases_get(const Eolian_Unit *unit)
 {
-   return (_state ? eina_hash_iterator_data_new(_state->unit.aliases) : NULL);
+   return (unit ? eina_hash_iterator_data_new(unit->state->unit.aliases) : NULL);
 }
 
 EAPI Eina_Iterator *
-eolian_typedecl_all_structs_get(const Eolian_Unit *unit EINA_UNUSED)
+eolian_typedecl_all_structs_get(const Eolian_Unit *unit)
 {
-   return (_state ? eina_hash_iterator_data_new(_state->unit.structs) : NULL);
+   return (unit ? eina_hash_iterator_data_new(unit->state->unit.structs) : NULL);
 }
 
 EAPI Eina_Iterator *
-eolian_typedecl_all_enums_get(const Eolian_Unit *unit EINA_UNUSED)
+eolian_typedecl_all_enums_get(const Eolian_Unit *unit)
 {
-   return (_state ? eina_hash_iterator_data_new(_state->unit.enums) : NULL);
+   return (unit ? eina_hash_iterator_data_new(unit->state->unit.enums) : NULL);
 }
 
 EAPI Eolian_Type_Type

diff --git a/src/lib/eolian/database_validate.c b/src/lib/eolian/database_validate.c
index 6ecafb5..e4cf4ca 100644 (file)
--- a/src/lib/eolian/database_validate.c
+++ b/src/lib/eolian/database_validate.c
@@ -513,7 +513,7 @@ _var_map_cb(const Eina_Hash *hash EINA_UNUSED, const void *key EINA_UNUSED,
 }
 
 Eina_Bool
-database_validate(const Eolian_Unit *src)
+database_validate(Eolian *state, const Eolian_Unit *src)
 {
    Eolian_Class *cl;
 
@@ -528,23 +528,23 @@ database_validate(const Eolian_Unit *src)
 
    Cb_Ret rt = { src, EINA_TRUE };
 
-   eina_hash_foreach(_state->unit.aliases, (Eina_Hash_Foreach)_typedecl_map_cb, &rt);
+   eina_hash_foreach(state->unit.aliases, (Eina_Hash_Foreach)_typedecl_map_cb, &rt);
    if (!rt.succ)
      return EINA_FALSE;
 
-   eina_hash_foreach(_state->unit.structs, (Eina_Hash_Foreach)_typedecl_map_cb, &rt);
+   eina_hash_foreach(state->unit.structs, (Eina_Hash_Foreach)_typedecl_map_cb, &rt);
    if (!rt.succ)
      return EINA_FALSE;
 
-   eina_hash_foreach(_state->unit.enums, (Eina_Hash_Foreach)_typedecl_map_cb, &rt);
+   eina_hash_foreach(state->unit.enums, (Eina_Hash_Foreach)_typedecl_map_cb, &rt);
    if (!rt.succ)
      return EINA_FALSE;
 
-   eina_hash_foreach(_state->unit.globals, (Eina_Hash_Foreach)_var_map_cb, &rt);
+   eina_hash_foreach(state->unit.globals, (Eina_Hash_Foreach)_var_map_cb, &rt);
    if (!rt.succ)
      return EINA_FALSE;
 
-   eina_hash_foreach(_state->unit.constants, (Eina_Hash_Foreach)_var_map_cb, &rt);
+   eina_hash_foreach(state->unit.constants, (Eina_Hash_Foreach)_var_map_cb, &rt);
    if (!rt.succ)
      return EINA_FALSE;
 

diff --git a/src/lib/eolian/database_var.c b/src/lib/eolian/database_var.c
index 0441d42..b14a99a 100644 (file)
--- a/src/lib/eolian/database_var.c
+++ b/src/lib/eolian/database_var.c
@@ -23,28 +23,28 @@ database_var_del(Eolian_Variable *var)
 }
 
 static void
-database_var_global_add(Eolian_Variable *var)
+database_var_global_add(Eolian *state, Eolian_Variable *var)
 {
-   eina_hash_set(_state->unit.globals, var->full_name, var);
-   eina_hash_set(_state->globals_f, var->base.file, eina_list_append
-                 ((Eina_List*)eina_hash_find(_state->globals_f, var->base.file), var));
+   eina_hash_set(state->unit.globals, var->full_name, var);
+   eina_hash_set(state->globals_f, var->base.file, eina_list_append
+                 ((Eina_List*)eina_hash_find(state->globals_f, var->base.file), var));
    database_decl_add(var->full_name, EOLIAN_DECL_VAR, var->base.file, var);
 }
 
 static void
-database_var_constant_add(Eolian_Variable *var)
+database_var_constant_add(Eolian *state, Eolian_Variable *var)
 {
-   eina_hash_set(_state->unit.constants, var->full_name, var);
-   eina_hash_set(_state->constants_f, var->base.file, eina_list_append
-                 ((Eina_List*)eina_hash_find(_state->constants_f, var->base.file), var));
+   eina_hash_set(state->unit.constants, var->full_name, var);
+   eina_hash_set(state->constants_f, var->base.file, eina_list_append
+                 ((Eina_List*)eina_hash_find(state->constants_f, var->base.file), var));
    database_decl_add(var->full_name, EOLIAN_DECL_VAR, var->base.file, var);
 }
 
 void
-database_var_add(Eolian_Variable *var)
+database_var_add(Eolian *state, Eolian_Variable *var)
 {
    if (var->type == EOLIAN_VAR_GLOBAL)
-     database_var_global_add(var);
+     database_var_global_add(state, var);
    else
-     database_var_constant_add(var);
+     database_var_constant_add(state, var);
 }

diff --git a/src/lib/eolian/database_var_api.c b/src/lib/eolian/database_var_api.c
index e8a58d3..a0d0e4e 100644 (file)
--- a/src/lib/eolian/database_var_api.c
+++ b/src/lib/eolian/database_var_api.c
@@ -6,61 +6,58 @@
 #include "eolian_database.h"
 
 EAPI const Eolian_Variable *
-eolian_variable_global_get_by_name(const Eolian_Unit *unit EINA_UNUSED,
-                                   const char *name)
+eolian_variable_global_get_by_name(const Eolian_Unit *unit, const char *name)
 {
-   if (!_state) return NULL;
+   if (!unit) return NULL;
    Eina_Stringshare *shr = eina_stringshare_add(name);
-   Eolian_Variable *v = eina_hash_find(_state->unit.globals, shr);
+   Eolian_Variable *v = eina_hash_find(unit->state->unit.globals, shr);
    eina_stringshare_del(shr);
    return v;
 }
 
 EAPI const Eolian_Variable *
-eolian_variable_constant_get_by_name(const Eolian_Unit *unit EINA_UNUSED,
-                                     const char *name)
+eolian_variable_constant_get_by_name(const Eolian_Unit *unit, const char *name)
 {
-   if (!_state) return NULL;
+   if (!unit) return NULL;
    Eina_Stringshare *shr = eina_stringshare_add(name);
-   Eolian_Variable *v = eina_hash_find(_state->unit.constants, shr);
+   Eolian_Variable *v = eina_hash_find(unit->state->unit.constants, shr);
    eina_stringshare_del(shr);
    return v;
 }
 
 EAPI Eina_Iterator *
-eolian_variable_globals_get_by_file(const Eolian_Unit *unit EINA_UNUSED,
-                                    const char *fname)
+eolian_variable_globals_get_by_file(const Eolian_Unit *unit, const char *fname)
 {
-   if (!_state) return NULL;
+   if (!unit) return NULL;
    Eina_Stringshare *shr = eina_stringshare_add(fname);
-   Eina_List *l = eina_hash_find(_state->globals_f, shr);
+   Eina_List *l = eina_hash_find(unit->state->globals_f, shr);
    eina_stringshare_del(shr);
    if (!l) return NULL;
    return eina_list_iterator_new(l);
 }
 
 EAPI Eina_Iterator *
-eolian_variable_constants_get_by_file(const Eolian_Unit *unit EINA_UNUSED,
+eolian_variable_constants_get_by_file(const Eolian_Unit *unit,
                                       const char *fname)
 {
-   if (!_state) return NULL;
+   if (!unit) return NULL;
    Eina_Stringshare *shr = eina_stringshare_add(fname);
-   Eina_List *l = eina_hash_find(_state->constants_f, shr);
+   Eina_List *l = eina_hash_find(unit->state->constants_f, shr);
    eina_stringshare_del(shr);
    if (!l) return NULL;
    return eina_list_iterator_new(l);
 }
 
 EAPI Eina_Iterator *
-eolian_variable_all_constants_get(const Eolian_Unit *unit EINA_UNUSED)
+eolian_variable_all_constants_get(const Eolian_Unit *unit)
 {
-   return (_state ? eina_hash_iterator_data_new(_state->unit.constants) : NULL);
+   return (unit ? eina_hash_iterator_data_new(unit->state->unit.constants) : NULL);
 }
 
 EAPI Eina_Iterator *
-eolian_variable_all_globals_get(const Eolian_Unit *unit EINA_UNUSED)
+eolian_variable_all_globals_get(const Eolian_Unit *unit)
 {
-   return (_state ? eina_hash_iterator_data_new(_state->unit.globals) : NULL);
+   return (unit ? eina_hash_iterator_data_new(unit->state->unit.globals) : NULL);
 }
 
 EAPI Eolian_Variable_Type

diff --git a/src/lib/eolian/eo_lexer.c b/src/lib/eolian/eo_lexer.c
index 7194250..9594d4a 100644 (file)
--- a/src/lib/eolian/eo_lexer.c
+++ b/src/lib/eolian/eo_lexer.c
@@ -261,7 +261,7 @@ enum Doc_Tokens {
 };
 
 static void
-doc_ref_class(const char *cname)
+doc_ref_class(Eo_Lexer *ls, const char *cname)
 {
    size_t clen = strlen(cname);
    char *buf = alloca(clen + 4);
@@ -275,7 +275,7 @@ doc_ref_class(const char *cname)
           *p = tolower(*p);
      }
    memcpy(buf + clen, ".eo", sizeof(".eo"));
-   const char *eop = eina_hash_find(_state->filenames_eo, buf);
+   const char *eop = eina_hash_find(ls->state->filenames_eo, buf);
    if (!eop)
      return;
    eina_hash_set(_defereos, buf, eop);
@@ -303,14 +303,14 @@ doc_ref(Eo_Lexer *ls)
    buf[rlen] = '\0';
 
    /* actual full class name */
-   doc_ref_class(buf);
+   doc_ref_class(ls, buf);
 
    /* method name at the end */
    char *end = strrchr(buf, '.');
    if (!end)
      return;
    *end = '\0';
-   doc_ref_class(buf);
+   doc_ref_class(ls, buf);
 
    /* .get or .set at the end, handle possible property */
    if (strcmp(end + 1, "get") && strcmp(end + 1, "set"))
@@ -319,7 +319,7 @@ doc_ref(Eo_Lexer *ls)
    if (!end)
      return;
    *end = '\0';
-   doc_ref_class(buf);
+   doc_ref_class(ls, buf);
 }
 
 static int
@@ -1014,7 +1014,7 @@ get_filename(Eo_Lexer *ls)
 }
 
 static void
-eo_lexer_set_input(Eo_Lexer *ls, const char *source)
+eo_lexer_set_input(Eo_Lexer *ls, Eolian *state, const char *source)
 {
    Eina_File *f = eina_file_open(source, EINA_FALSE);
    if (!f)
@@ -1023,6 +1023,7 @@ eo_lexer_set_input(Eo_Lexer *ls, const char *source)
         longjmp(ls->err_jmp, EINA_TRUE);
      }
    ls->lookahead.token = -1;
+   ls->state           = state;
    ls->buff            = eina_strbuf_new();
    ls->handle          = f;
    ls->stream          = eina_file_map_all(f, EINA_FILE_RANDOM);
@@ -1045,7 +1046,7 @@ eo_lexer_set_input(Eo_Lexer *ls, const char *source)
    next_char(ls);
 
    Eolian_Unit *ncunit = calloc(1, sizeof(Eolian_Unit));
-   database_unit_init(ncunit, ls->filename);
+   database_unit_init(state, ncunit, ls->filename);
    eina_hash_add(_units, ls->filename, ncunit);
 }
 
@@ -1112,13 +1113,13 @@ eo_lexer_free(Eo_Lexer *ls)
 }
 
 Eo_Lexer *
-eo_lexer_new(const char *source)
+eo_lexer_new(Eolian *state, const char *source)
 {
    volatile Eo_Lexer *ls = calloc(1, sizeof(Eo_Lexer));
 
    if (!setjmp(((Eo_Lexer *)(ls))->err_jmp))
      {
-        eo_lexer_set_input((Eo_Lexer *) ls, source);
+        eo_lexer_set_input((Eo_Lexer *) ls, state, source);
         return (Eo_Lexer *) ls;
      }
    eo_lexer_free((Eo_Lexer *) ls);

diff --git a/src/lib/eolian/eo_lexer.h b/src/lib/eolian/eo_lexer.h
index b911ddb..e6f3249 100644 (file)
--- a/src/lib/eolian/eo_lexer.h
+++ b/src/lib/eolian/eo_lexer.h
@@ -166,6 +166,8 @@ typedef struct _Eo_Lexer
    /* points to the current line being lexed, used by error messages to
     * display the current line with a caret at the respective column */
    const char  *stream_line;
+   /* a pointer to the state this lexer belongs to */
+   Eolian      *state;
    /* this is jumped to when an error happens */
    jmp_buf      err_jmp;
 
@@ -187,7 +189,7 @@ typedef struct _Eo_Lexer
 
 int         eo_lexer_init           (void);
 int         eo_lexer_shutdown       (void);
-Eo_Lexer   *eo_lexer_new            (const char *source);
+Eo_Lexer   *eo_lexer_new            (Eolian *state, const char *source);
 void        eo_lexer_free           (Eo_Lexer *ls);
 /* gets a regular token, singlechar or one of TOK_something */
 int         eo_lexer_get            (Eo_Lexer *ls);

diff --git a/src/lib/eolian/eo_parser.c b/src/lib/eolian/eo_parser.c
index daf64cb..887bfd3 100644 (file)
--- a/src/lib/eolian/eo_parser.c
+++ b/src/lib/eolian/eo_parser.c
@@ -528,7 +528,7 @@ parse_struct(Eo_Lexer *ls, const char *name, Eina_Bool is_extern,
      }
    check_match(ls, '}', '{', bline, bcolumn);
    FILL_BASE(def->base, ls, line, column);
-   if (name) database_struct_add(def);
+   if (name) database_struct_add(ls->state, def);
    return def;
 }
 
@@ -640,7 +640,7 @@ parse_enum(Eo_Lexer *ls, const char *name, Eina_Bool is_extern,
      }
    check_match(ls, '}', '{', bline, bcolumn);
    FILL_BASE(def->base, ls, line, column);
-   if (name) database_enum_add(def);
+   if (name) database_enum_add(ls->state, def);
    return def;
 }
 
@@ -683,7 +683,7 @@ _parse_dep(Eo_Lexer *ls, const char *fname, const char *name)
    if (eina_hash_find(_parsingeos, fname))
      return NULL;
    Eolian_Class *cl = NULL;
-   if (!eo_parser_database_fill(fname, EINA_FALSE, &cl) || !cl)
+   if (!eo_parser_database_fill(ls->state, fname, EINA_FALSE, &cl) || !cl)
      {
         char buf[PATH_MAX];
         eo_lexer_context_restore(ls);
@@ -822,7 +822,7 @@ parse_type_void(Eo_Lexer *ls)
              fnm = database_class_to_filename(nm);
              if (!compare_class_file(bnm, fnm))
                {
-                  const char *fname = eina_hash_find(_state->filenames_eo, fnm);
+                  const char *fname = eina_hash_find(ls->state->filenames_eo, fnm);
                   eina_stringshare_del(bnm);
                   free(fnm);
                   if (fname)
@@ -1530,7 +1530,7 @@ parse_part(Eo_Lexer *ls)
    if (!compare_class_file(bnm, fnm))
      {
         Eolian_Class *dep = NULL;
-        const char *fname = eina_hash_find(_state->filenames_eo, fnm);
+        const char *fname = eina_hash_find(ls->state->filenames_eo, fnm);
         eina_stringshare_del(bnm);
         free(fnm);
         if (fname)
@@ -2038,7 +2038,7 @@ _inherit_dep(Eo_Lexer *ls, Eina_Strbuf *buf, Eina_Bool check_inherit,
         eo_lexer_syntax_error(ls, ebuf);
         return; /* unreachable (longjmp above), make static analysis shut up */
      }
-   fname = eina_hash_find(_state->filenames_eo, fnm);
+   fname = eina_hash_find(ls->state->filenames_eo, fnm);
    free(fnm);
    if (!fname)
      {
@@ -2177,11 +2177,11 @@ parse_unit(Eo_Lexer *ls, Eina_Bool eot)
            check(ls, TOK_VALUE);
            eina_strbuf_append(buf, ls->t.value.s);
            eina_strbuf_append(buf, ".eot");
-           if (!(found = eina_hash_find(_state->filenames_eot, eina_strbuf_string_get(buf))))
+           if (!(found = eina_hash_find(ls->state->filenames_eot, eina_strbuf_string_get(buf))))
              {
                 size_t buflen = eina_strbuf_length_get(buf);
                 eina_strbuf_remove(buf, buflen - 1, buflen);
-                if (!(found = eina_hash_find(_state->filenames_eo, eina_strbuf_string_get(buf))))
+                if (!(found = eina_hash_find(ls->state->filenames_eo, eina_strbuf_string_get(buf))))
                   {
                      pop_strbuf(ls);
                      snprintf(errbuf, sizeof(errbuf),
@@ -2197,20 +2197,20 @@ parse_unit(Eo_Lexer *ls, Eina_Bool eot)
         }
       case KW_type:
         {
-           database_type_add(parse_typedef(ls));
+           database_type_add(ls->state, parse_typedef(ls));
            pop_typedecl(ls);
            break;
         }
       case KW_function:
         {
-           database_type_add(parse_function_pointer(ls));
+           database_type_add(ls->state, parse_function_pointer(ls));
            pop_typedecl(ls);
            break;
         }
       case KW_const:
       case KW_var:
         {
-           database_var_add(parse_variable(ls, ls->t.kw == KW_var));
+           database_var_add(ls->state, parse_variable(ls, ls->t.kw == KW_var));
            eolian_object_ref(&ls->tmp.var->base);
            ls->tmp.var = NULL;
            break;
@@ -2253,7 +2253,7 @@ parse_unit(Eo_Lexer *ls, Eina_Bool eot)
                 eo_lexer_get(ls);
                 FILL_DOC(ls, def, doc);
                 FILL_BASE(def->base, ls, line, col);
-                database_struct_add(def);
+                database_struct_add(ls->state, def);
                 pop_typedecl(ls);
                 break;
              }
@@ -2497,7 +2497,7 @@ end:
 }
 
 Eina_Bool
-eo_parser_database_fill(const char *filename, Eina_Bool eot, Eolian_Class **fcl)
+eo_parser_database_fill(Eolian *state, const char *filename, Eina_Bool eot, Eolian_Class **fcl)
 {
    Eolian_Class *cl = eina_hash_find(_parsedeos, filename);
    if (cl)
@@ -2508,7 +2508,7 @@ eo_parser_database_fill(const char *filename, Eina_Bool eot, Eolian_Class **fcl)
 
    eina_hash_set(_parsingeos, filename, (void *)EINA_TRUE);
 
-   Eo_Lexer *ls = eo_lexer_new(filename);
+   Eo_Lexer *ls = eo_lexer_new(state, filename);
    if (!ls)
      {
         _eolian_log("unable to create lexer for file '%s'", filename);
@@ -2537,8 +2537,8 @@ eo_parser_database_fill(const char *filename, Eina_Bool eot, Eolian_Class **fcl)
    if (!_db_fill_ctors(cl))
      goto error;
 
-   eina_hash_set(_state->unit.classes, cl->full_name, cl);
-   eina_hash_set(_state->classes_f, cl->base.file, cl);
+   eina_hash_set(ls->state->unit.classes, cl->full_name, cl);
+   eina_hash_set(ls->state->classes_f, cl->base.file, cl);
    eolian_object_ref(&cl->base);
 
    if (fcl) *fcl = cl;

diff --git a/src/lib/eolian/eo_parser.h b/src/lib/eolian/eo_parser.h
index 7179107..8196c5b 100644 (file)
--- a/src/lib/eolian/eo_parser.h
+++ b/src/lib/eolian/eo_parser.h
@@ -3,6 +3,6 @@
 
 #include "eo_lexer.h"
 
-Eina_Bool eo_parser_database_fill(const char *filename, Eina_Bool eot, Eolian_Class **cl);
+Eina_Bool eo_parser_database_fill(Eolian *state, const char *filename, Eina_Bool eot, Eolian_Class **cl);
 
 #endif /* __EO_PARSER_H__ */
\ No newline at end of file

diff --git a/src/lib/eolian/eolian_database.c b/src/lib/eolian/eolian_database.c
index 6db5c05..7f7c5a2 100644 (file)
--- a/src/lib/eolian/eolian_database.c
+++ b/src/lib/eolian/eolian_database.c
@@ -19,8 +19,6 @@ Eina_Hash *_defereos = NULL;
 
 static Eolian_Unit *_cunit = NULL;
 
-Eolian *_state = NULL;
-
 static int _database_init_count = 0;
 
 static void
@@ -40,7 +38,6 @@ database_init()
    _parsingeos = eina_hash_string_small_new(NULL);
    _defereos   = eina_hash_string_small_new(NULL);
    _units      = eina_hash_stringshared_new(EINA_FREE_CB(database_unit_del));
-   _state = eolian_new();
    return ++_database_init_count;
 }
 
@@ -56,7 +53,6 @@ database_shutdown()
 
    if (_database_init_count == 0)
      {
-        eolian_free(_state); _state = NULL;
         eina_hash_free(_decls     ); _decls      = NULL;
         eina_hash_free(_declsf    ); _declsf     = NULL;
         eina_hash_free(_parsedeos ); _parsedeos  = NULL;
@@ -562,8 +558,10 @@ eolian_doc_token_ref_get(const Eolian_Unit *unit, const Eolian_Doc_Token *tok,
 }
 
 void
-database_unit_init(Eolian_Unit *unit, Eina_Stringshare *fname)
+database_unit_init(Eolian *state, Eolian_Unit *unit, Eina_Stringshare *fname)
 {
+   unit->state = state;
+
    if (fname)
      {
         Eolian_Unit *ocunit = _cunit;
@@ -605,7 +603,7 @@ eolian_new(void)
    if (!state)
      return NULL;
 
-   database_unit_init(&state->unit, NULL);
+   database_unit_init(state, &state->unit, NULL);
 
    state->filenames_eo  = eina_hash_string_small_new(free);
    state->filenames_eot = eina_hash_string_small_new(free);
@@ -651,17 +649,18 @@ join_path(const char *path, const char *file)
 static void
 _scan_cb(const char *name, const char *path, void *data EINA_UNUSED)
 {
+   Eolian *state = data;
    Eina_Bool is_eo = eina_str_has_suffix(name, EO_SUFFIX);
    if (!is_eo && !eina_str_has_suffix(name, EOT_SUFFIX)) return;
-   eina_hash_add(is_eo ? _state->filenames_eo : _state->filenames_eot,
+   eina_hash_add(is_eo ? state->filenames_eo : state->filenames_eot,
                  eina_stringshare_add(name), join_path(path, name));
 }
 
 EAPI Eina_Bool
-eolian_directory_scan(Eolian *state EINA_UNUSED, const char *dir)
+eolian_directory_scan(Eolian *state, const char *dir)
 {
-   if (!dir) return EINA_FALSE;
-   eina_file_dir_list(dir, EINA_TRUE, _scan_cb, NULL);
+   if (!dir || !state) return EINA_FALSE;
+   eina_file_dir_list(dir, EINA_TRUE, _scan_cb, state);
    return EINA_TRUE;
 }
 
@@ -695,7 +694,7 @@ database_class_to_filename(const char *cname)
 }
 
 static Eina_Bool
-_eolian_file_parse_nodep(const char *filepath)
+_eolian_file_parse_nodep(Eolian *state, const char *filepath)
 {
    Eina_Bool is_eo;
    const char *eopath;
@@ -707,18 +706,18 @@ _eolian_file_parse_nodep(const char *filepath)
         _eolian_log("file '%s' doesn't have a correct extension", filepath);
         return EINA_FALSE;
      }
-   if (!(eopath = eina_hash_find(is_eo ? _state->filenames_eo : _state->filenames_eot, filepath)))
+   if (!(eopath = eina_hash_find(is_eo ? state->filenames_eo : state->filenames_eot, filepath)))
      {
         char *vpath = eina_file_path_sanitize(filepath);
-        Eina_Bool ret = eo_parser_database_fill(vpath, !is_eo, NULL);
+        Eina_Bool ret = eo_parser_database_fill(state, vpath, !is_eo, NULL);
         free(vpath);
         return ret;
      }
-   return eo_parser_database_fill(eopath, !is_eo, NULL);
+   return eo_parser_database_fill(state, eopath, !is_eo, NULL);
 }
 
 static Eina_Bool
-_parse_deferred()
+_parse_deferred(Eolian *state)
 {
    Eina_Hash *defer = _defereos;
    if (!defer || !eina_hash_population(defer))
@@ -729,7 +728,7 @@ _parse_deferred()
    const char *dep;
    EINA_ITERATOR_FOREACH(itr, dep)
      {
-        if (!_eolian_file_parse_nodep(dep))
+        if (!_eolian_file_parse_nodep(state, dep))
           {
              eina_iterator_free(itr);
              eina_hash_free_buckets(_defereos);
@@ -740,98 +739,102 @@ _parse_deferred()
    eina_iterator_free(itr);
    eina_hash_free(defer);
    /* in case more deps were queued in, parse them */
-   return _parse_deferred();
+   return _parse_deferred(state);
 }
 
-static Eolian_Unit unit_tmp;
-
 EAPI const Eolian_Unit *
-eolian_file_parse(Eolian *state EINA_UNUSED, const char *filepath)
+eolian_file_parse(Eolian *state, const char *filepath)
 {
-   if (!_eolian_file_parse_nodep(filepath))
+   if (!_eolian_file_parse_nodep(state, filepath))
      return NULL;
-   if (!_parse_deferred())
+   if (!_parse_deferred(state))
      return NULL;
    /* FIXME: pass unit properly */
-   if (!database_validate(NULL))
+   if (!database_validate(state, &state->unit))
      return NULL;
-   return &unit_tmp;
+   return &state->unit;
 }
 
+typedef struct _Parse_Data
+{
+   Eolian *state;
+   Eina_Bool ret;
+} Parse_Data;
+
 static Eina_Bool _tfile_parse(const Eina_Hash *hash EINA_UNUSED, const void *key EINA_UNUSED, void *data, void *fdata)
 {
-   Eina_Bool *ret = fdata;
-   if (*ret) *ret = eo_parser_database_fill(data, EINA_TRUE, NULL);
-   if (*ret) *ret = _parse_deferred();
-   return *ret;
+   Parse_Data *pd = fdata;
+   if (pd->ret) pd->ret = eo_parser_database_fill(pd->state, data, EINA_TRUE, NULL);
+   if (pd->ret) pd->ret = _parse_deferred(pd->state);
+   return pd->ret;
 }
 
 EAPI Eina_Bool
-eolian_all_eot_files_parse(Eolian *state EINA_UNUSED)
+eolian_all_eot_files_parse(Eolian *state)
 {
-   Eina_Bool ret = EINA_TRUE;
+   Parse_Data pd = { state, EINA_TRUE };
 
    if (_database_init_count <= 0)
      return EINA_FALSE;
 
-   eina_hash_foreach(_state->filenames_eot, _tfile_parse, &ret);
+   eina_hash_foreach(state->filenames_eot, _tfile_parse, &pd);
 
    /* FIXME: pass unit properly */
-   if (ret && !database_validate(NULL))
+   if (pd.ret && !database_validate(state, &state->unit))
      return EINA_FALSE;
 
-   return ret;
+   return pd.ret;
 }
 
 static Eina_Bool _file_parse(const Eina_Hash *hash EINA_UNUSED, const void *key EINA_UNUSED, void *data, void *fdata)
 {
-   Eina_Bool *ret = fdata;
-   if (*ret) *ret = eo_parser_database_fill(data, EINA_FALSE, NULL);
-   if (*ret) *ret = _parse_deferred();
-   return *ret;
+   Parse_Data *pd = fdata;
+   if (pd->ret) pd->ret = eo_parser_database_fill(pd->state, data, EINA_FALSE, NULL);
+   if (pd->ret) pd->ret = _parse_deferred(pd->state);
+   return pd->ret;
 }
 
 EAPI Eina_Bool
-eolian_all_eo_files_parse(Eolian *state EINA_UNUSED)
+eolian_all_eo_files_parse(Eolian *state)
 {
-   Eina_Bool ret = EINA_TRUE;
+   Parse_Data pd = { state, EINA_TRUE };
 
    if (_database_init_count <= 0)
      return EINA_FALSE;
 
-   eina_hash_foreach(_state->filenames_eo, _file_parse, &ret);
+   eina_hash_foreach(state->filenames_eo, _file_parse, &pd);
 
    /* FIXME: pass unit properly */
-   if (ret && !database_validate(NULL))
+   if (pd.ret && !database_validate(state, &state->unit))
      return EINA_FALSE;
 
-   return ret;
+   return pd.ret;
 }
 
 EAPI Eina_Iterator *
-eolian_all_eot_files_get(Eolian *state EINA_UNUSED)
+eolian_all_eot_files_get(Eolian *state)
 {
-   if (!_state) return NULL;
-   return eina_hash_iterator_key_new(_state->filenames_eot);
+   if (!state) return NULL;
+   return eina_hash_iterator_key_new(state->filenames_eot);
 }
 
 EAPI Eina_Iterator *
-eolian_all_eo_files_get(Eolian *state EINA_UNUSED)
+eolian_all_eo_files_get(Eolian *state)
 {
-   if (!_state) return NULL;
-   return eina_hash_iterator_key_new(_state->filenames_eo);
+   if (!state) return NULL;
+   return eina_hash_iterator_key_new(state->filenames_eo);
 }
 
 EAPI Eina_Iterator *
-eolian_all_eot_file_paths_get(Eolian *state EINA_UNUSED)
+eolian_all_eot_file_paths_get(Eolian *state)
 {
-   if (!_state) return NULL;
-   return eina_hash_iterator_data_new(_state->filenames_eot);
+   if (!state) return NULL;
+   return eina_hash_iterator_data_new(state->filenames_eot);
 }
 
 EAPI Eina_Iterator *
-eolian_all_eo_file_paths_get(Eolian *state EINA_UNUSED)
+eolian_all_eo_file_paths_get(Eolian *state)
 {
-   if (!_state) return NULL;
-   return eina_hash_iterator_data_new(_state->filenames_eo);
+   if (!state) return NULL;
+   return eina_hash_iterator_data_new(state->filenames_eo);
 }

diff --git a/src/lib/eolian/eolian_database.h b/src/lib/eolian/eolian_database.h
index 529681d..c59e6e6 100644 (file)
--- a/src/lib/eolian/eolian_database.h
+++ b/src/lib/eolian/eolian_database.h
@@ -44,11 +44,9 @@ extern Eina_Hash *_parsingeos;
 /* for deferred dependency parsing */
 extern Eina_Hash *_defereos;
 
-/* TODO: remove */
-extern Eolian *_state;
-
 struct _Eolian_Unit
 {
+   Eolian        *state;
    Eolian_Unit   *parent;
    Eina_Hash     *children;
    Eina_Hash     *classes;
@@ -326,21 +324,21 @@ int database_init(void);
 int database_shutdown(void);
 
 char *database_class_to_filename(const char *cname);
-Eina_Bool database_validate(const Eolian_Unit *src);
+Eina_Bool database_validate(Eolian *state, const Eolian_Unit *src);
 
 void database_decl_add(Eina_Stringshare *name, Eolian_Declaration_Type type,
                        Eina_Stringshare *file, void *ptr);
 
 void database_doc_del(Eolian_Documentation *doc);
 
-void database_unit_init(Eolian_Unit *unit, Eina_Stringshare *fname);
+void database_unit_init(Eolian *state, Eolian_Unit *unit, Eina_Stringshare *fname);
 void database_unit_del(Eolian_Unit *unit);
 
 /* types */
 
-void database_type_add(Eolian_Typedecl *def);
-void database_struct_add(Eolian_Typedecl *tp);
-void database_enum_add(Eolian_Typedecl *tp);
+void database_type_add(Eolian *state, Eolian_Typedecl *def);
+void database_struct_add(Eolian *state, Eolian_Typedecl *tp);
+void database_enum_add(Eolian *state, Eolian_Typedecl *tp);
 void database_type_del(Eolian_Type *tp);
 void database_typedecl_del(Eolian_Typedecl *tp);
 
@@ -358,7 +356,7 @@ void database_expr_print(Eolian_Expression *expr);
 /* variables */
 
 void database_var_del(Eolian_Variable *var);
-void database_var_add(Eolian_Variable *var);
+void database_var_add(Eolian *state, Eolian_Variable *var);
 
 /* classes */
 void database_class_del(Eolian_Class *cl);