X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=src%2Fparser_proc.y;h=e488c0e475ac0e6eea149f5fdcb6381ed210a175;hb=9bd48d16d68944f3a1e9366fe8c6f3c6d985bf56;hp=1cc466f16cb969b97c665479bae33d970f299516;hpb=7e4b0ccdd2123647b6fff8065c0abc61be3fb44d;p=m6w6%2Fext-psi diff --git a/src/parser_proc.y b/src/parser_proc.y index 1cc466f..e488c0e 100644 --- a/src/parser_proc.y +++ b/src/parser_proc.y @@ -30,6 +30,7 @@ void psi_error(int, const char *, int, const char *, ...); %left PLUS MINUS. %left SLASH ASTERISK. %fallback NAME TEMP FREE SET LET RETURN LIB STRING. +%fallback STRUCT UNION. file ::= blocks. @@ -60,6 +61,9 @@ block ::= decl_typedef(def). { if (def->type->strct) { P->structs = add_decl_struct(P->structs, def->type->strct); } + if (def->type->enm) { + P->enums = add_decl_enum(P->enums, def->type->enm); + } } block ::= constant(constant). { P->consts = add_constant(P->consts, constant); @@ -67,14 +71,75 @@ block ::= constant(constant). { block ::= decl_struct(strct). { P->structs = add_decl_struct(P->structs, strct); } +block ::= decl_enum(e). { + P->enums = add_decl_enum(P->enums, e); +} -struct_name(n) ::= STRUCT NAME(N). { +optional_name(n) ::= .{ + n = NULL; +} +optional_name(n) ::= NAME(N). { n = N; } +enum_name(n) ::= ENUM(E) optional_name(N). { + if (N) { + n = N; + free(E); + } else { + char digest[17]; + + PSI_TokenHash(E, digest); + n = PSI_TokenTranslit(PSI_TokenAppend(E, 1, digest), " ", "@"); + } +} + +%type decl_enum {decl_enum *} +%destructor decl_enum {free_decl_enum($$);} +decl_enum(e) ::= enum_name(N) LBRACE decl_enum_items(list) RBRACE. { + e = init_decl_enum(N->text, list); + e->token = N; +} + +%type decl_enum_items {decl_enum_items*} +%destructor decl_enum_items {free_decl_enum_items($$);} +decl_enum_items(l) ::= decl_enum_item(i). { + l = init_decl_enum_items(i); +} +decl_enum_items(l) ::= decl_enum_items(l_) COMMA decl_enum_item(i). { + l = add_decl_enum_item(l_, i); +} + +%type decl_enum_item {decl_enum_item*} +%destructor decl_enum_item {free_decl_enum_item($$);} +decl_enum_item(i) ::= NAME(N) EQUALS num_exp(num). { + i = init_decl_enum_item(N->text, num); + i->token = N; +} +decl_enum_item(i) ::= NAME(N). { + i = init_decl_enum_item(N->text, NULL); + i->token = N; +} + +struct_name(n) ::= STRUCT(S) optional_name(N). { + if (N) { + n = N; + free(S); + } else { + char digest[17]; + + PSI_TokenHash(S, digest); + n = PSI_TokenTranslit(PSI_TokenAppend(S, 1, digest), " ", "@"); + } +} +%type decl_struct_args_block {decl_args*} +%destructor decl_struct_args_block {free_decl_args($$);} +decl_struct_args_block(args_) ::= LBRACE struct_args(args) RBRACE. { + args_ = args; +} %type decl_struct_args {decl_args*} %destructor decl_struct_args {free_decl_args($$);} -decl_struct_args(args_) ::= LBRACE struct_args(args) RBRACE. { +decl_struct_args(args_) ::= decl_struct_args_block(args). { args_ = args; } decl_struct_args(args_) ::= EOS. { @@ -113,23 +178,72 @@ constant(constant) ::= CONST const_type(type) NSNAME(T) EQUALS impl_def_val(val) free(T); } -%type decl_typedef {decl_typedef*} -%destructor decl_typedef {free_decl_typedef($$);} -decl_typedef(def) ::= TYPEDEF decl_typedef_body(def_) EOS. { +%type decl_typedef {decl_arg*} +%destructor decl_typedef { + free_decl_arg($$); + if ($$->type->strct) { + free_decl_struct($$->type->strct); + } + if ($$->type->enm) { + free_decl_enum($$->type->enm); + } + if ($$->type->func) { + free_decl($$->type->func); + } +} +decl_typedef(def) ::= TYPEDEF(T) decl_typedef_body(def_) EOS. { def = def_; + def->token = T; } -%type decl_typedef_body {decl_typedef*} -%destructor decl_typedef_body {free_decl_typedef($$);} -decl_typedef_body(def) ::= decl_type(type) NAME(ALIAS). { - def = init_decl_typedef(ALIAS->text, type); - def->token = ALIAS; +%type decl_typedef_body_ex {decl_arg*} +%destructor decl_typedef_body_ex { + free_decl_arg($$); + if ($$->type->strct) { + free_decl_struct($$->type->strct); + } + if ($$->type->enm) { + free_decl_enum($$->type->enm); + } + if ($$->type->func) { + free_decl($$->type->func); + } } - -/* support opaque types */ -decl_typedef_body(def) ::= VOID(V) indirection(i) NAME(ALIAS). { - def = init_decl_typedef(ALIAS->text, init_decl_type(i?PSI_T_POINTER:V->type, V->text)); - def->token = ALIAS; - def->type->token = V; +decl_typedef_body_ex(def) ::= struct_name(N) struct_size(size_) decl_struct_args_block(args) decl_var(var). { + def = init_decl_arg(init_decl_type(PSI_T_STRUCT, N->text), var); + def->type->token = PSI_TokenCopy(N); + def->type->strct = init_decl_struct(N->text, args); + def->type->strct->token = N; + def->type->strct->size = size_; +} +decl_typedef_body_ex(def) ::= decl_enum(e) NAME(ALIAS). { + def = init_decl_arg(init_decl_type(PSI_T_ENUM, e->name), init_decl_var(ALIAS->text, 0, 0)); + def->var->token = ALIAS; + def->type->token = PSI_TokenCopy(e->token); + def->type->enm = e; +} +%type decl_typedef_body {decl_arg*} +%destructor decl_typedef_body { + free_decl_arg($$); + if ($$->type->strct) { + free_decl_struct($$->type->strct); + } + if ($$->type->enm) { + free_decl_enum($$->type->enm); + } + if ($$->type->func) { + free_decl($$->type->func); + } +} +decl_typedef_body(def) ::= decl_typedef_body_ex(def_). { + def = def_; +} +decl_typedef_body(def) ::= decl_func(func_) LPAREN decl_args(args) RPAREN. { + def = init_decl_arg(init_decl_type(PSI_T_FUNCTION, func_->var->name), copy_decl_var(func_->var)); + def->type->token = PSI_TokenCopy(func_->token); + def->type->func = init_decl(init_decl_abi("default"), func_, args); +} +decl_typedef_body(def) ::= decl_arg(arg). { + def = arg; } %type decl {decl*} @@ -150,7 +264,6 @@ decl_func(func) ::= VOID(T) NAME(N). { init_decl_var(N->text, 0, 0) ); func->type->token = T; - //free(T); free(N); } @@ -231,6 +344,9 @@ struct_args(args) ::= struct_args(args_) struct_arg(arg). { } %type struct_arg {decl_arg*} %destructor struct_arg {free_decl_arg($$);} +struct_arg(arg_) ::= decl_typedef_body_ex(def) EOS. { + arg_ = def; +} struct_arg(arg) ::= decl_arg(arg_) struct_layout(layout_) EOS. { arg_->layout = layout_; arg = arg_; @@ -332,6 +448,11 @@ decl_type(type_) ::= STRUCT(S) NAME(T). { type_->token = T; free(S); } +decl_type(type_) ::= ENUM(E) NAME(T). { + type_ = init_decl_type(E->type, T->text); + type_->token = T; + free(E); +} %token_class decl_type_token FLOAT DOUBLE INT8 UINT8 INT16 UINT16 INT32 UINT32 INT64 UINT64 NAME. %type decl_type {decl_type*} %destructor decl_type {free_decl_type($$);}