enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 1 Projects Releases Wiki Activity

eolian: butts

This commit is contained in:
Daniel Kolesa 2015-05-12 16:15:29 +01:00
parent 2c48b3212a
commit ed58165b50
15 changed files with 50 additions and 279 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/bin/eolian/eo_generator.c
View File

@ -468,7 +468,7 @@ eo_bind_func_generate(const Eolian_Class *class, const Eolian_Function *funcid,
eina_strbuf_append_printf(params_init,
" if (%s) *%s = %s;",
pname, pname, val_str);
if (eolian_expression_type_get(dflt_value) == EOLIAN_EXPR_ENUM)
if (eolian_expression_type_get(dflt_value) == EOLIAN_EXPR_NAME)
{
Eina_Stringshare *string = eolian_expression_serialize(dflt_value);
eina_strbuf_append_printf(params_init, " /* %s */", string);
@ -586,7 +586,7 @@ eo_bind_func_generate(const Eolian_Class *class, const Eolian_Function *funcid,
eina_strbuf_append_printf(eo_func_decl, ", %s%s, %s",
ret_const ? "const " : "", rettype,
val_str?val_str:"0");
if (val_str && eolian_expression_type_get(default_ret_val) == EOLIAN_EXPR_ENUM)
if (val_str && eolian_expression_type_get(default_ret_val) == EOLIAN_EXPR_NAME)
{
Eina_Stringshare *string = eolian_expression_serialize(default_ret_val);
eina_strbuf_append_printf(eo_func_decl, " /* %s */", string);

6
src/bin/eolian/types_generator.c
View File

@ -91,8 +91,7 @@ _type_generate(const Eolian_Type *tp, Eina_Bool in_typedef, Eina_Bool full)
free(name);
break;
}
eina_strbuf_append_printf(buf, "struct%s%s {\n", name?" ":"", name?name:"");
free(name);
eina_strbuf_append_printf(buf, "typedef struct\n{\n");
Eina_Iterator *members = eolian_type_struct_fields_get(tp);
EINA_ITERATOR_FOREACH(members, member)
{
@ -106,7 +105,8 @@ _type_generate(const Eolian_Type *tp, Eina_Bool in_typedef, Eina_Bool full)
eina_strbuf_append(buf, "\n");
}
eina_iterator_free(members);
eina_strbuf_append(buf, "}");
eina_strbuf_append_printf(buf, "} %s", name);
free(name);
break;
}
case EOLIAN_TYPE_ENUM:

22
src/bindings/luajit/eolian.lua
View File

@ -61,8 +61,6 @@ ffi.cdef [[
EOLIAN_TYPE_UNKNOWN_TYPE,
EOLIAN_TYPE_VOID,
EOLIAN_TYPE_REGULAR,
EOLIAN_TYPE_REGULAR_STRUCT,
EOLIAN_TYPE_REGULAR_ENUM,
EOLIAN_TYPE_COMPLEX,
EOLIAN_TYPE_POINTER,
EOLIAN_TYPE_FUNCTION,
@ -88,7 +86,6 @@ ffi.cdef [[
EOLIAN_EXPR_NULL,
EOLIAN_EXPR_BOOL,
EOLIAN_EXPR_NAME,
EOLIAN_EXPR_ENUM,
EOLIAN_EXPR_UNARY,
EOLIAN_EXPR_BINARY
} Eolian_Expression_Type;
@ -431,16 +428,14 @@ M.type_type = {
UNKNOWN = 0,
VOID = 1,
REGULAR = 2,
REGULAR_STRUCT = 3,
REGULAR_ENUM = 4,
COMPLEX = 5,
POINTER = 6,
FUNCTION = 7,
STRUCT = 8,
STRUCT_OPAQUE = 9,
ENUM = 10,
ALIAS = 11,
CLASS = 12
COMPLEX = 3,
POINTER = 4,
FUNCTION = 5,
STRUCT = 6,
STRUCT_OPAQUE = 7,
ENUM = 8,
ALIAS = 9,
CLASS = 10
}
ffi.metatype("Eolian_Struct_Type_Field", {
@ -1059,7 +1054,6 @@ M.expression_type = {
NULL = 11,
BOOL = 12,
NAME = 13,
ENUM = 14,
UNARY = 15,
BINARY = 16
}

4
src/lib/ecore_con/ecore_con_base.eo
View File

@ -174,10 +174,10 @@ abstract Ecore.Con.Base (Eo.Base) {
}
/* FIXME: Should actually be a binbuf. */
type Ecore_Con_Event_Data_Received: struct {
struct Ecore_Con_Event_Data_Received {
data: void *; /*@ The data thet got sent. */
size: int; /*@ The length of the data sent. */
};
}
/* TODO
* Add events (to all of the ecore con stuff, e.g url).

3
src/lib/eolian/Eolian.h
View File

@ -191,8 +191,6 @@ typedef enum
EOLIAN_TYPE_UNKNOWN_TYPE,
EOLIAN_TYPE_VOID,
EOLIAN_TYPE_REGULAR,
EOLIAN_TYPE_REGULAR_STRUCT,
EOLIAN_TYPE_REGULAR_ENUM,
EOLIAN_TYPE_COMPLEX,
EOLIAN_TYPE_POINTER,
EOLIAN_TYPE_STRUCT,
@ -218,7 +216,6 @@ typedef enum
EOLIAN_EXPR_NULL,
EOLIAN_EXPR_BOOL,
EOLIAN_EXPR_NAME,
EOLIAN_EXPR_ENUM,
EOLIAN_EXPR_UNARY,
EOLIAN_EXPR_BINARY
} Eolian_Expression_Type;

52
src/lib/eolian/database_expr.c
View File

@ -508,24 +508,11 @@ eval_exp(const Eolian_Expression *expr, Eolian_Expression_Mask mask,
return expr_error(expr, "undefined variable");
etp = eolian_type_alias_get_by_name(fulln);
while (etp && etp->type == EOLIAN_TYPE_ALIAS)
{
etp = eolian_type_base_type_get(etp);
if (etp->type == EOLIAN_TYPE_ENUM)
break;
if (etp->type == EOLIAN_TYPE_REGULAR_ENUM)
break;
if (etp->type != EOLIAN_TYPE_REGULAR)
{
etp = NULL;
break;
}
etp = eolian_type_alias_get_by_name(etp->full_name);
}
if (etp && etp->type == EOLIAN_TYPE_REGULAR_ENUM)
etp = eolian_type_enum_get_by_name(etp->full_name);
while (etp && (etp->type == EOLIAN_TYPE_ALIAS
|| etp->type == EOLIAN_TYPE_REGULAR))
etp = eolian_type_base_type_get(etp);
if (!etp) etp = eolian_type_enum_get_by_name(fulln);
if (!etp || etp->type != EOLIAN_TYPE_ENUM)
{
free(fulln);
@ -545,37 +532,6 @@ eval_exp(const Eolian_Expression *expr, Eolian_Expression_Mask mask,
if (!exp)
return expr_error(expr, "undefined variable");
return eval_exp(exp, mask, out);
}
case EOLIAN_EXPR_ENUM:
{
const Eolian_Type *etp;
const Eolian_Expression *exp = NULL;
const Eolian_Enum_Type_Field *fl;
char *fulln = NULL, *memb = NULL;
if (!split_enum_name(expr->value.s, &fulln, &memb))
{
return expr_error(expr, "invalid enum");
}
etp = eolian_type_enum_get_by_name(fulln);
if (etp && etp->type == EOLIAN_TYPE_REGULAR_ENUM)
etp = eolian_type_enum_get_by_name(etp->full_name);
if (!etp)
{
free(fulln);
return expr_error(expr, "invalid enum");
}
fl = eolian_type_enum_field_get(etp, memb);
if (fl) exp = eolian_type_enum_field_value_get(fl);
free(fulln);
if (!exp)
return expr_error(expr, "invalid enum field");
return eval_exp(exp, mask, out);
}
case EOLIAN_EXPR_UNARY:

11
src/lib/eolian/database_expr_api.c
View File

@ -36,11 +36,17 @@ _eval_type(const Eolian_Expression *expr, const Eolian_Type *type)
}
case EOLIAN_TYPE_CLASS:
return database_expr_eval(expr, EOLIAN_MASK_NULL);
case EOLIAN_TYPE_ENUM:
return database_expr_eval(expr, EOLIAN_MASK_INT);
case EOLIAN_TYPE_REGULAR:
{
int kw = eo_lexer_keyword_str_to_id(type->name);
if (!kw || kw < KW_byte || kw >= KW_void)
return err;
{
const Eolian_Type *base = eolian_type_base_type_get(type);
if (base) return _eval_type(expr, base);
return err;
}
switch (kw)
{
case KW_byte:
@ -249,10 +255,7 @@ _expr_serialize(const Eolian_Expression *expr, Eina_Strbuf *buf, Eina_Bool outer
eina_strbuf_append(buf, expr->value.b ? "true" : "false");
break;
case EOLIAN_EXPR_NAME:
case EOLIAN_EXPR_ENUM:
{
if (expr->type == EOLIAN_EXPR_ENUM)
eina_strbuf_append(buf, "enum ");
eina_strbuf_append(buf, expr->value.s);
break;
}

19
src/lib/eolian/database_type.c
View File

@ -188,8 +188,6 @@ database_type_to_str(const Eolian_Type *tp, Eina_Strbuf *buf, const char *name)
}
if ((tp->type == EOLIAN_TYPE_REGULAR
|| tp->type == EOLIAN_TYPE_COMPLEX
|| tp->type == EOLIAN_TYPE_REGULAR_STRUCT
|| tp->type == EOLIAN_TYPE_REGULAR_ENUM
|| tp->type == EOLIAN_TYPE_VOID
|| tp->type == EOLIAN_TYPE_CLASS)
&& tp->is_const)
@ -198,20 +196,10 @@ database_type_to_str(const Eolian_Type *tp, Eina_Strbuf *buf, const char *name)
}
if (tp->type == EOLIAN_TYPE_REGULAR
|| tp->type == EOLIAN_TYPE_COMPLEX
|| tp->type == EOLIAN_TYPE_CLASS
|| tp->type == EOLIAN_TYPE_REGULAR_STRUCT
|| tp->type == EOLIAN_TYPE_REGULAR_ENUM)
|| tp->type == EOLIAN_TYPE_CLASS)
{
Eina_List *l;
const char *sp;
if (tp->type == EOLIAN_TYPE_REGULAR_STRUCT)
{
eina_strbuf_append(buf, "struct ");
}
else if (tp->type == EOLIAN_TYPE_REGULAR_ENUM)
{
eina_strbuf_append(buf, "enum ");
}
EINA_LIST_FOREACH(tp->namespaces, l, sp)
{
eina_strbuf_append(buf, sp);
@ -273,11 +261,8 @@ database_type_print(Eolian_Type *tp)
printf("%s", tp->full_name);
else if (tp->type == EOLIAN_TYPE_VOID)
printf("void");
else if (tp->type == EOLIAN_TYPE_REGULAR_STRUCT
|| tp->type == EOLIAN_TYPE_STRUCT_OPAQUE)
else if (tp->type == EOLIAN_TYPE_STRUCT_OPAQUE)
printf("struct %s", tp->full_name);
else if (tp->type == EOLIAN_TYPE_REGULAR_ENUM)
printf("enum %s", tp->full_name);
else if (tp->type == EOLIAN_TYPE_POINTER)
{
database_type_print(tp->base_type);

30
src/lib/eolian/database_validate.c
View File

@ -52,37 +52,11 @@ _validate_type(const Eolian_Type *tp)
if (id)
return eo_lexer_is_type_keyword(id);
/* user defined */
tpp = eolian_type_alias_get_by_name(tp->full_name);
tpp = eolian_type_base_type_get(tp);
if (!tpp)
{
char buf[256];
snprintf(buf, sizeof(buf), "undefined alias %s", tp->full_name);
_type_error(tp, buf);
return EINA_TRUE; /* for now only warn */
}
return _validate_type(tpp);
}
case EOLIAN_TYPE_REGULAR_STRUCT:
{
const Eolian_Type *tpp;
tpp = eolian_type_struct_get_by_name(tp->full_name);
if (!tpp)
{
char buf[256];
snprintf(buf, sizeof(buf), "undefined struct %s", tp->full_name);
_type_error(tp, buf);
return EINA_TRUE; /* for now only warn */
}
return _validate_type(tpp);
}
case EOLIAN_TYPE_REGULAR_ENUM:
{
const Eolian_Type *tpp;
tpp = eolian_type_enum_get_by_name(tp->full_name);
if (!tpp)
{
char buf[256];
snprintf(buf, sizeof(buf), "undefined enum %s", tp->full_name);
snprintf(buf, sizeof(buf), "undefined type %s", tp->full_name);
_type_error(tp, buf);
return EINA_TRUE; /* for now only warn */
}

103
src/lib/eolian/eo_parser.c
View File

@ -380,18 +380,11 @@ parse_expr_simple(Eo_Lexer *ls)
eo_lexer_get(ls);
break;
}
case KW_enum:
default:
{
Eina_Strbuf *buf = push_strbuf(ls);
Eolian_Expression_Type tp = EOLIAN_EXPR_NAME;
if (ls->t.kw == KW_enum)
{
eo_lexer_get(ls);
tp = EOLIAN_EXPR_ENUM;
}
expr = push_expr(ls);
expr->type = tp;
expr->type = EOLIAN_EXPR_NAME;
parse_name(ls, buf);
expr->value.s = eina_stringshare_add(eina_strbuf_string_get
(buf));
@ -453,7 +446,6 @@ parse_expr(Eo_Lexer *ls)
}
static Eolian_Type *parse_type_void(Eo_Lexer *ls);
static Eolian_Type *parse_type_named_void(Eo_Lexer *ls, Eina_Bool allow_named);
static Eolian_Type *
parse_type(Eo_Lexer *ls)
@ -470,21 +462,6 @@ parse_type(Eo_Lexer *ls)
return ret;
}
static Eolian_Type *
parse_type_named(Eo_Lexer *ls, Eina_Bool allow_named)
{
Eolian_Type *ret;
eo_lexer_context_push(ls);
ret = parse_type_named_void(ls, allow_named);
if (ret->type == EOLIAN_TYPE_VOID)
{
eo_lexer_context_restore(ls);
eo_lexer_syntax_error(ls, "non-void type expected");
}
eo_lexer_context_pop(ls);
return ret;
}
static void
_struct_field_free(Eolian_Struct_Type_Field *def)
{
@ -642,8 +619,8 @@ parse_enum(Eo_Lexer *ls, const char *name, Eina_Bool is_extern,
}
static void
parse_struct_attrs(Eo_Lexer *ls, Eina_Bool is_enum, Eina_Bool allow_named,
Eina_Bool *is_extern, const char **freefunc)
parse_struct_attrs(Eo_Lexer *ls, Eina_Bool is_enum, Eina_Bool *is_extern,
const char **freefunc)
{
Eina_Bool has_extern = EINA_FALSE, has_free = EINA_FALSE;
*freefunc = NULL;
@ -652,15 +629,6 @@ parse_struct_attrs(Eo_Lexer *ls, Eina_Bool is_enum, Eina_Bool allow_named,
{
case KW_at_extern:
CASE_LOCK(ls, extern, "@extern qualifier")
if (!allow_named)
{
if (is_enum)
eo_lexer_syntax_error(ls,
"only enum declarations can be extern");
else
eo_lexer_syntax_error(ls,
"only named structs can be extern");
}
eo_lexer_get(ls);
*is_extern = EINA_TRUE;
break;
@ -695,7 +663,7 @@ _append_dep(Eo_Lexer *ls, const char *fname, const char *name, int line, int col
}
static Eolian_Type *
parse_type_named_void(Eo_Lexer *ls, Eina_Bool allow_named)
parse_type_void(Eo_Lexer *ls)
{
Eolian_Type *def;
const char *ctype;
@ -760,57 +728,6 @@ parse_type_named_void(Eo_Lexer *ls, Eina_Bool allow_named)
check_match(ls, ')', '(', pline, pcolumn);
goto parse_ptr;
}
case KW_struct:
case KW_enum:
{
const char *freefunc;
Eina_Bool has_extern;
Eina_Bool is_enum = (ls->t.kw == KW_enum);
eo_lexer_get(ls);
parse_struct_attrs(ls, is_enum, allow_named, &has_extern, &freefunc);
if (freefunc && !allow_named)
check(ls, '{');
if (!is_enum && (ls->t.token == '{'))
{
if (has_extern)
eo_lexer_syntax_error(ls, "extern anonymous struct");
return parse_struct(ls, NULL, EINA_FALSE, line, col, freefunc);
}
buf = push_strbuf(ls);
eo_lexer_context_push(ls);
line = ls->line_number;
col = ls->column;
parse_name(ls, buf);
sname = push_str(ls, eina_strbuf_string_get(buf));
pop_strbuf(ls);
/* if we're extern and allow structs, gotta enforce it */
if (allow_named && (has_extern || freefunc))
check(ls, '{');
if (allow_named && ls->t.token == '{')
{
Eolian_Type *tp = (Eolian_Type*)eina_hash_find(_structs,
sname);
if (tp)
{
eo_lexer_context_restore(ls);
redef_error(ls, is_enum ? EOLIAN_TYPE_ENUM
: EOLIAN_TYPE_STRUCT, tp);
}
eo_lexer_context_pop(ls);
pop_str(ls);
if (is_enum)
return parse_enum(ls, sname, has_extern, line, col);
return parse_struct(ls, sname, has_extern, line, col, freefunc);
}
eo_lexer_context_pop(ls);
def = push_type(ls);
def->type = is_enum ? EOLIAN_TYPE_REGULAR_ENUM
: EOLIAN_TYPE_REGULAR_STRUCT;
FILL_BASE(def->base, ls, line, col);
pop_str(ls);
_fill_name(sname, &def->full_name, &def->name, &def->namespaces);
goto parse_ptr;
}
default:
break;
}
@ -901,12 +818,6 @@ parse_ptr:
return def;
}
static Eolian_Type *
parse_type_void(Eo_Lexer *ls)
{
return parse_type_named_void(ls, EINA_FALSE);
}
static Eolian_Type *
parse_typedef(Eo_Lexer *ls)
{
@ -915,7 +826,7 @@ parse_typedef(Eo_Lexer *ls)
const char *freefunc;
Eina_Strbuf *buf;
eo_lexer_get(ls);
parse_struct_attrs(ls, EINA_FALSE, EINA_TRUE, &has_extern, &freefunc);
parse_struct_attrs(ls, EINA_FALSE, &has_extern, &freefunc);
def->freefunc = freefunc;
pop_str(ls);
def->type = EOLIAN_TYPE_ALIAS;
@ -934,7 +845,7 @@ parse_typedef(Eo_Lexer *ls)
}
eo_lexer_context_pop(ls);
check_next(ls, ':');
def->base_type = parse_type_named(ls, EINA_TRUE);
def->base_type = parse_type(ls);
pop_type(ls);
check_next(ls, ';');
if (ls->t.token == TOK_COMMENT)
@ -1858,7 +1769,7 @@ parse_unit(Eo_Lexer *ls, Eina_Bool eot)
const char *freefunc;
Eina_Strbuf *buf;
eo_lexer_get(ls);
parse_struct_attrs(ls, is_enum, EINA_TRUE, &has_extern, &freefunc);
parse_struct_attrs(ls, is_enum, &has_extern, &freefunc);
buf = push_strbuf(ls);
eo_lexer_context_push(ls);
line = ls->line_number;

4
src/tests/eolian/data/enum.eo
View File

@ -6,7 +6,7 @@ enum Foo {
}
enum Bar {
foo = enum Foo.baz
foo = Foo.baz
}
enum Baz {
@ -15,7 +15,7 @@ enum Baz {
flag3 = 1 << 2
}
const Bah: int = enum Baz.flag1;
const Bah: int = Baz.flag1;
class Enum {
methods {

8
src/tests/eolian/data/free_func.eo
View File

@ -10,14 +10,6 @@ struct @free(test_free) Named2 {
type Typedef1: int;
type @free(def_free) Typedef2: int;
/* anon struct */
type Anon1: struct {
field: int;
};
type Anon2: struct @free(anon_free) {
field: int;
};
/* opaque */
struct Opaque1;
struct @free(opaque_free) Opaque2;

14
src/tests/eolian/data/struct.eo
View File

@ -4,21 +4,9 @@ struct Named {
}
struct Another {
field: struct Named;
field: Named;
}
/* named typedef'd */
type Foo: struct _Foo {
field: int;
another: float;
};
/* anonymous */
type Bar: struct {
a: Foo;
b: struct _Foo;
};
/* opaque struct */
struct Opaque;

24
src/tests/eolian/data/struct_ref.c
View File

@ -11,26 +11,16 @@ typedef Eo Struct;
#ifndef _STRUCT_EO_TYPES
#define _STRUCT_EO_TYPES
typedef struct _Foo Foo;
typedef struct {
Foo a;
struct _Foo b;
} Bar;
struct Named {
typedef struct
{
int field;
const char *something;
};
} Named;
struct Another {
struct Named field;
};
struct _Foo {
int field;
float another;
};
typedef struct
{
Named field;
} Another;
struct Opaque;

25
src/tests/eolian/eolian_parsing.c
View File

@ -721,20 +721,9 @@ START_TEST(eolian_struct)
fail_if(!(ftype = eolian_type_struct_field_type_get(field)));
fail_if(!(type_name = eolian_type_name_get(ftype)));
fail_if(strcmp(type_name, "Named"));
fail_if(eolian_type_type_get(ftype) != EOLIAN_TYPE_REGULAR_STRUCT);
/* typedef */
fail_if(!(atype = eolian_type_alias_get_by_name("Foo")));
fail_if(!(type = eolian_type_base_type_get(atype)));
fail_if(!(type_name = eolian_type_name_get(type)));
fail_if(eolian_type_type_get(type) != EOLIAN_TYPE_STRUCT);
fail_if(strcmp(type_name, "_Foo"));
/* typedef - anon */
fail_if(!(atype = eolian_type_alias_get_by_name("Bar")));
fail_if(!(type = eolian_type_base_type_get(atype)));
fail_if(!!(type_name = eolian_type_name_get(type)));
fail_if(eolian_type_type_get(type) != EOLIAN_TYPE_STRUCT);
fail_if(eolian_type_type_get(ftype) != EOLIAN_TYPE_REGULAR);
fail_if(eolian_type_type_get(eolian_type_base_type_get(ftype))
!= EOLIAN_TYPE_STRUCT);
/* opaque struct */
fail_if(!(type = eolian_type_struct_get_by_name("Opaque")));
@ -981,14 +970,6 @@ START_TEST(eolian_free_func)
fail_if(!(type = eolian_type_alias_get_by_name("Typedef2")));
fail_if(strcmp(eolian_type_free_func_get(type), "def_free"));
/* anon struct */
fail_if(!(type = eolian_type_alias_get_by_name("Anon1")));
fail_if(!(type = eolian_type_base_type_get(type)));
fail_if(eolian_type_free_func_get(type));
fail_if(!(type = eolian_type_alias_get_by_name("Anon2")));
fail_if(!(type = eolian_type_base_type_get(type)));
fail_if(strcmp(eolian_type_free_func_get(type), "anon_free"));
/* opaque struct */
fail_if(!(type = eolian_type_struct_get_by_name("Opaque1")));
fail_if(eolian_type_free_func_get(type));