From 9d48e256dcc80006dfa3fb06f4b3debb64665db0 Mon Sep 17 00:00:00 2001 From: Daniel Kolesa Date: Wed, 18 Jun 2014 16:27:29 +0100 Subject: [PATCH] eolian: remove the ugly old type extractor, instead build the inlist during parsing --- src/lib/eolian/eo_definitions.c | 8 +- src/lib/eolian/eo_definitions.h | 7 +- src/lib/eolian/eo_parser.c | 237 +++++++++++++--------------------------- 3 files changed, 86 insertions(+), 166 deletions(-) diff --git a/src/lib/eolian/eo_definitions.c b/src/lib/eolian/eo_definitions.c index 76b728a..c791c44 100644 --- a/src/lib/eolian/eo_definitions.c +++ b/src/lib/eolian/eo_definitions.c @@ -2,11 +2,11 @@ #include #include "eo_definitions.h" +#include "eolian_database.h" static void eo_definitions_ret_free(Eo_Ret_Def *ret) { - if (ret->type) eina_stringshare_del(ret->type); if (ret->comment) eina_stringshare_del(ret->comment); if (ret->dflt_ret_val) eina_stringshare_del(ret->dflt_ret_val); free(ret); @@ -15,7 +15,6 @@ eo_definitions_ret_free(Eo_Ret_Def *ret) static void eo_definitions_param_free(Eo_Param_Def *param) { - if (param->type) eina_stringshare_del(param->type); if (param->name) eina_stringshare_del(param->name); if (param->comment) eina_stringshare_del(param->comment); free(param); @@ -117,8 +116,6 @@ eo_definitions_type_def_free(Eo_Type_Def *type) { if (type->alias) eina_stringshare_del(type->alias); - if (type->type) - eina_stringshare_del(type->type); free(type); } @@ -212,4 +209,7 @@ eo_definitions_temps_free(Eo_Lexer_Temps *tmp) if (tmp->impl) eo_definitions_impl_def_free(tmp->impl); + + if (tmp->type) + database_type_del(tmp->type); } diff --git a/src/lib/eolian/eo_definitions.h b/src/lib/eolian/eo_definitions.h index 90c2849..2a24c73 100644 --- a/src/lib/eolian/eo_definitions.h +++ b/src/lib/eolian/eo_definitions.h @@ -8,7 +8,7 @@ typedef struct _eo_ret_def { - const char *type; + Eolian_Type type; const char *comment; const char *dflt_ret_val; Eina_Bool warn_unused:1; @@ -27,7 +27,7 @@ typedef enum _param_way typedef struct _eo_param_def { Param_Way way; - const char *type; + Eolian_Type type; const char *name; const char *comment; Eina_Bool nonull:1; @@ -127,7 +127,7 @@ typedef struct _eo_class_def typedef struct _eo_type_def { const char *alias; - const char *type; + Eolian_Type type; } Eo_Type_Def; /* TEMPS */ @@ -148,6 +148,7 @@ typedef struct _Eo_Lexer_Temps Eina_List *str_items; Eo_Event_Def *event; Eo_Implement_Def *impl; + Eolian_Type type; } Eo_Lexer_Temps; void eo_definitions_class_def_free(Eo_Class_Def *kls); diff --git a/src/lib/eolian/eo_parser.c b/src/lib/eolian/eo_parser.c index 043d6e1..611554b 100644 --- a/src/lib/eolian/eo_parser.c +++ b/src/lib/eolian/eo_parser.c @@ -128,21 +128,22 @@ parse_name_list(Eo_Lexer *ls) return ls->tmp.str_items; } -static void -parse_type(Eo_Lexer *ls, Eina_Strbuf *buf) +static Eina_Inlist * +parse_type(Eo_Lexer *ls, Eina_Inlist *types, Eina_Strbuf *sbuf) { Eina_Bool has_struct = EINA_FALSE, need_space = EINA_FALSE; + Eina_Bool is_own = EINA_FALSE; + Eina_Strbuf *buf = sbuf ? sbuf : push_strbuf(ls); if (ls->t.kw == KW_at_own) { - eina_strbuf_append(buf, "@own"); + if (sbuf) eina_strbuf_append(buf, "@own "); + is_own = EINA_TRUE; eo_lexer_get(ls); - need_space = EINA_TRUE; } if (ls->t.kw == KW_const) { - if (need_space) eina_strbuf_append_char(buf, ' '); eina_strbuf_append(buf, "const"); eo_lexer_get(ls); need_space = EINA_TRUE; @@ -205,30 +206,37 @@ parse_type(Eo_Lexer *ls, Eina_Strbuf *buf) } } + if (!sbuf) + { + types = database_type_append(types, eina_strbuf_string_get(buf), is_own); + ls->tmp.type = types; + pop_strbuf(ls); + } + if (ls->t.token == '<') { int line = ls->line_number; - eina_strbuf_append(buf, " <"); + if (sbuf) eina_strbuf_append(buf, " <"); eo_lexer_get(ls); - parse_type(ls, buf); + types = parse_type(ls, types, sbuf); check_match(ls, '>', '<', line); - eina_strbuf_append_char(buf, '>'); + if (sbuf) eina_strbuf_append_char(buf, '>'); } + + return types; } static void parse_typedef(Eo_Lexer *ls) { - Eina_Strbuf *buf = push_strbuf(ls); ls->tmp.type_def = calloc(1, sizeof(Eo_Type_Def)); eo_lexer_get(ls); check(ls, TOK_VALUE); ls->tmp.type_def->alias = eina_stringshare_add(ls->t.value); eo_lexer_get(ls); test_next(ls, ':'); - parse_type(ls, buf); - ls->tmp.type_def->type = eina_stringshare_add(eina_strbuf_string_get(buf)); - pop_strbuf(ls); + ls->tmp.type_def->type = parse_type(ls, NULL, NULL); + ls->tmp.type = NULL; check_next(ls, ';'); } @@ -236,12 +244,10 @@ static void parse_return(Eo_Lexer *ls) { Eo_Ret_Def *ret = calloc(1, sizeof(Eo_Ret_Def)); - Eina_Strbuf *buf = push_strbuf(ls); ls->tmp.ret_def = ret; eo_lexer_get(ls); - parse_type(ls, buf); - ret->type = eina_stringshare_add(eina_strbuf_string_get(buf)); - pop_strbuf(ls); + ret->type = parse_type(ls, NULL, NULL); + ls->tmp.type = NULL; if (ls->t.token == '(') { int line = ls->line_number; @@ -268,7 +274,6 @@ static void parse_param(Eo_Lexer *ls, Eina_Bool allow_inout) { Eo_Param_Def *par = calloc(1, sizeof(Eo_Param_Def)); - Eina_Strbuf *buf = NULL; ls->tmp.param = par; if (allow_inout) { @@ -290,10 +295,8 @@ parse_param(Eo_Lexer *ls, Eina_Bool allow_inout) else par->way = PARAM_IN; } - buf = push_strbuf(ls); - parse_type(ls, buf); - par->type = eina_stringshare_add(eina_strbuf_string_get(buf)); - pop_strbuf(ls); + par->type = parse_type(ls, NULL, NULL); + ls->tmp.type = NULL; check(ls, TOK_VALUE); par->name = eina_stringshare_add(ls->t.value); eo_lexer_get(ls); @@ -748,7 +751,7 @@ parse_event(Eo_Lexer *ls) int line = ls->line_number; eo_lexer_get(ls); buf = push_strbuf(ls); - parse_type(ls, buf); + parse_type(ls, NULL, buf); ev->type = eina_stringshare_add(eina_strbuf_string_get(buf)); pop_strbuf(ls); check_match(ls, ')', '(', line); @@ -1024,6 +1027,23 @@ parse_chunk(Eo_Lexer *ls) static char *_accessor_type_str[ACCESSOR_TYPE_LAST] = { "setter", "getter" }; static char * _param_way_str[ PARAM_WAY_LAST] = { "IN", "OUT", "INOUT" }; +static void +_print_type(FILE *f, Eolian_Type tp) +{ + const char *type; + Eina_Bool own; + Eolian_Type ntp = eolian_type_information_get(tp, &type, &own); + if (own) + fputs("@own ", f); + fputs(type, f); + if (ntp) + { + fputc('<', f); + _print_type(f, ntp); + fputc('>', f); + } +} + void eo_parser_dump(Eo_Lexer *ls) { @@ -1059,13 +1079,17 @@ eo_parser_dump(Eo_Lexer *ls) { printf(" constructors: %s\n", meth->name); if (meth->ret) - printf(" return: %s (%s)\n", meth->ret->type, meth->ret->comment); + { + printf(" return: "); + _print_type(stdout, meth->ret->type); + printf(" (%s)\n", meth->ret->comment); + } printf(" legacy : %s\n", meth->legacy); EINA_LIST_FOREACH(meth->params, m, param) { - printf(" param: %s %s : %s (%s)\n", - _param_way_str[param->way], param->name, - param->type, param->comment); + printf(" param: %s %s : ", _param_way_str[param->way], param->name); + _print_type(stdout, param->type); + printf(" (%s)\n", param->comment); } } @@ -1074,20 +1098,22 @@ eo_parser_dump(Eo_Lexer *ls) printf(" property: %s\n", prop->name); EINA_LIST_FOREACH(prop->keys, m, param) { - printf(" key: %s : %s (%s)\n", - param->name, param->type, param->comment); + printf(" key: %s : ", param->name); + _print_type(stdout, param->type); + printf(" (%s)\n", param->comment); } EINA_LIST_FOREACH(prop->values, m, param) { - printf(" value: %s : %s (%s)\n", - param->name, param->type, param->comment); + printf(" value: %s : ", param->name); + _print_type(stdout, param->type); + printf(" (%s)\n", param->comment); } EINA_LIST_FOREACH(prop->accessors, m, accessor) { - printf(" accessor: %s : %s (%s)\n", - (accessor->ret?accessor->ret->type:""), - _accessor_type_str[accessor->type], - accessor->comment); + printf(" accessor: "); + if (accessor->ret) + _print_type(stdout, accessor->ret->type); + printf(" : %s (%s)\n", _accessor_type_str[accessor->type], accessor->comment); printf(" legacy : %s\n", accessor->legacy); } } @@ -1096,129 +1122,28 @@ eo_parser_dump(Eo_Lexer *ls) { printf(" method: %s\n", meth->name); if (meth->ret) - printf(" return: %s (%s)\n", meth->ret->type, meth->ret->comment); + { + printf(" return: "); + _print_type(stdout, meth->ret->type); + printf(" (%s)\n", meth->ret->comment); + } printf(" legacy : %s\n", meth->legacy); printf(" obj_const : %s\n", meth->obj_const?"true":"false"); EINA_LIST_FOREACH(meth->params, m, param) { - printf(" param: %s %s : %s (%s)\n", - _param_way_str[param->way], param->name, - param->type, param->comment); + printf(" param: %s %s : ", _param_way_str[param->way], param->name); + _print_type(stdout, param->type); + printf(" (%s)\n", param->comment); } } } EINA_LIST_FOREACH(ls->typedefs, k, type) { - printf("Typedef: %s (%s)\n", type->alias, type->type); - } -} - -static Eina_Inlist * -_types_extract(const char *buf, int len) -{ - const char *save_buf = buf; - Eolian_Type types = NULL; - long depth = 0; - char *tmp_type = malloc(2 * len + 1); - - while (len > 0) - { - char *d = tmp_type; - Eina_Bool end_type = EINA_FALSE; - Eina_Bool is_own = EINA_FALSE; - char c; - Eina_Bool in_spaces = EINA_TRUE, in_stars = EINA_FALSE; - while (len > 0 && !end_type) - { - switch (c = *buf++) - { - /* @own */ - case '@': - { - if (!strncmp(buf, "own ", 4)) - { - is_own = EINA_TRUE; - buf += 4; len -= 4; - } - break; - } - /* if '*', we have to add a space. We set in_spaces to true in - * case spaces are between stars, to be sure we remove them. - */ - case '*': - { - if (!in_stars && !in_spaces) - { - *d++ = ' '; - in_stars = EINA_TRUE; - in_spaces = EINA_TRUE; - } - *d++ = c; - break; - } - /* Only the first space is inserted. */ - case ' ': - { - if (!in_spaces) *d++ = c; - in_spaces = EINA_TRUE; - break; - } - case '<': - { - if (depth < 0) - { - ERR("%s: Cannot reopen < after >", save_buf); - goto error; - } - depth++; - end_type = EINA_TRUE; - break; - } - case '>': - { - if (depth == 0) - { - ERR("%s: Too much >", save_buf); - goto error; - } - if (depth > 0 && d == tmp_type) - { - ERR("%s: empty type inside <>", save_buf); - goto error; - } - if (depth > 0) depth *= -1; - depth++; - end_type = EINA_TRUE; - break; - } - default: - { - *d++ = c; - in_spaces = EINA_FALSE; - in_stars = EINA_FALSE; - } - } - len--; - } - if (d != tmp_type) - { - *d = '\0'; - types = database_type_append(types, tmp_type, is_own); - } - } - if (depth) - { - ERR("%s: < and > are not well used.", save_buf); - goto error; + printf("Typedef: %s ", type->alias); + _print_type(stdout, type->type); + printf("\n"); } - goto success; -error: - database_type_del(types); - types = NULL; -success: - free(tmp_type); - return types; } Eina_Bool @@ -1296,8 +1221,7 @@ eo_parser_database_fill(const char *filename) database_function_data_set(foo_id, EOLIAN_LEGACY, meth->legacy); EINA_LIST_FOREACH(meth->params, m, param) { - Eolian_Type type = _types_extract(param->type, strlen(param->type)); - database_method_parameter_add(foo_id, (Eolian_Parameter_Dir)param->way, type, param->name, param->comment); + database_method_parameter_add(foo_id, (Eolian_Parameter_Dir)param->way, param->type, param->name, param->comment); } } @@ -1307,16 +1231,14 @@ eo_parser_database_fill(const char *filename) database_function_scope_set(foo_id, prop->scope); EINA_LIST_FOREACH(prop->keys, m, param) { - Eolian_Type type = _types_extract(param->type, strlen(param->type)); Eolian_Function_Parameter p = database_property_key_add( - foo_id, type, param->name, param->comment); + foo_id, param->type, param->name, param->comment); database_parameter_nonull_set(p, param->nonull); } EINA_LIST_FOREACH(prop->values, m, param) { - Eolian_Type type = _types_extract(param->type, strlen(param->type)); Eolian_Function_Parameter p = database_property_value_add( - foo_id, type, param->name, param->comment); + foo_id, param->type, param->name, param->comment); database_parameter_nonull_set(p, param->nonull); } EINA_LIST_FOREACH(prop->accessors, m, accessor) @@ -1326,8 +1248,7 @@ eo_parser_database_fill(const char *filename) { Eolian_Function_Type ftype = accessor->type == SETTER?EOLIAN_PROP_SET:EOLIAN_PROP_GET; - Eolian_Type types = _types_extract(accessor->ret->type, strlen(accessor->ret->type)); - database_function_return_type_set(foo_id, ftype, types); + database_function_return_type_set(foo_id, ftype, accessor->ret->type); database_function_return_comment_set(foo_id, ftype, accessor->ret->comment); database_function_return_flag_set_as_warn_unused(foo_id, @@ -1371,8 +1292,7 @@ eo_parser_database_fill(const char *filename) database_class_function_add(class, foo_id); if (meth->ret) { - Eolian_Type types = _types_extract(meth->ret->type, strlen(meth->ret->type)); - database_function_return_type_set(foo_id, EOLIAN_METHOD, types); + database_function_return_type_set(foo_id, EOLIAN_METHOD, meth->ret->type); database_function_return_comment_set(foo_id, EOLIAN_METHOD, meth->ret->comment); database_function_return_flag_set_as_warn_unused(foo_id, EOLIAN_METHOD, meth->ret->warn_unused); @@ -1384,9 +1304,8 @@ eo_parser_database_fill(const char *filename) database_function_object_set_as_const(foo_id, meth->obj_const); EINA_LIST_FOREACH(meth->params, m, param) { - Eolian_Type type = _types_extract(param->type, strlen(param->type)); Eolian_Function_Parameter p = database_method_parameter_add(foo_id, - (Eolian_Parameter_Dir)param->way, type, param->name, param->comment); + (Eolian_Parameter_Dir)param->way, param->type, param->name, param->comment); database_parameter_nonull_set(p, param->nonull); } } @@ -1444,7 +1363,7 @@ eo_parser_database_fill(const char *filename) EINA_LIST_FOREACH(ls->typedefs, k, type_def) { - database_type_add(type_def->alias, _types_extract(type_def->type, strlen(type_def->type))); + database_type_add(type_def->alias, type_def->type); } ret = EINA_TRUE; -- 2.7.4