X-Git-Url: https://git.m6w6.name/?p=m6w6%2Fext-psi;a=blobdiff_plain;f=src%2Fparser.h;h=30388ad7d3e7bea7a2ea4255b4fcf9b2dffd0552;hp=0f5671d38ebf7782f3b42ae68120df801182487a;hb=8b652242a4ef920f2ab82bfb822596de25bc5a63;hpb=9bd48d16d68944f3a1e9366fe8c6f3c6d985bf56 diff --git a/src/parser.h b/src/parser.h index 0f5671d..30388ad 100644 --- a/src/parser.h +++ b/src/parser.h @@ -7,6 +7,7 @@ #include #include +#include /* fcall */ #include "parser_proc.h" @@ -29,6 +30,11 @@ typedef struct PSI_Token { static inline PSI_Token *PSI_TokenCopy(PSI_Token *src); +typedef struct zend_fcall { + zend_fcall_info fci; + zend_fcall_info_cache fcc; +} zend_fcall; + typedef union impl_val { char cval; int8_t i8; @@ -51,6 +57,7 @@ typedef union impl_val { zend_bool bval; zend_long lval; zend_string *str; + zend_fcall *cb; } zend; void *ptr; uint8_t _dbg[sizeof(void *)]; @@ -62,6 +69,7 @@ typedef struct decl_type { token_t type; struct decl_type *real; struct decl_struct *strct; + struct decl_union *unn; struct decl_enum *enm; struct decl *func; } decl_type; @@ -166,6 +174,9 @@ static inline decl_arg *init_decl_arg(decl_type *type, decl_var *var) { } static inline void free_decl_arg(decl_arg *arg) { + if (arg->token && arg->token != arg->var->token) { + free(arg->token); + } free_decl_type(arg->type); free_decl_var(arg->var); if (arg->layout) { @@ -286,6 +297,10 @@ typedef struct decl_callinfo { size_t argc; void **args; void **rval; + struct { + void *data; + void (*dtor)(void *data); + } closure; } decl_callinfo; typedef struct decl { @@ -343,6 +358,7 @@ typedef struct decl_struct { char *name; decl_args *args; size_t size; + size_t align; struct { void *type; void (*dtor)(void *type); @@ -394,6 +410,56 @@ static inline void free_decl_structs(decl_structs *ss) { free(ss); } +typedef struct decl_union { + PSI_Token *token; + char *name; + decl_args *args; + size_t size; + size_t align; +} decl_union; + +static inline decl_union *init_decl_union(const char *name, decl_args *args) { + decl_union *u = calloc(1, sizeof(*u)); + u->name = strdup(name); + u->args = args; + return u; +} + +static inline void free_decl_union(decl_union *u) { + if (u->token) { + free(u->token); + } + if (u->args) { + free_decl_args(u->args); + } + free(u->name); + free(u); +} + +typedef struct decl_unions { + decl_union **list; + size_t count; +} decl_unions; + +static inline decl_unions *add_decl_union(decl_unions *uu, decl_union *u) { + if (!uu) { + uu = calloc(1, sizeof(*uu)); + } + uu->list = realloc(uu->list, ++uu->count * sizeof(*uu->list)); + uu->list[uu->count-1] = u; + return uu; +} + +static inline void free_decl_unions(decl_unions *uu) { + size_t i; + + for (i = 0; i < uu->count; ++i) { + free_decl_union(uu->list[i]); + } + free(uu->list); + free(uu); +} + typedef struct impl_type { char *name; token_t type; @@ -425,6 +491,17 @@ static inline impl_var *init_impl_var(const char *name, int is_reference) { return var; } +static inline impl_var *copy_impl_var(impl_var *var) { + impl_var *cpy = malloc(sizeof(*cpy)); + + memcpy(cpy, var, sizeof(*cpy)); + cpy->name = strdup(cpy->name); + if (cpy->token) { + cpy->token = PSI_TokenCopy(cpy->token); + } + return cpy; +} + static inline void free_impl_var(impl_var *var) { if (var->token) { free(var->token); @@ -822,11 +899,33 @@ static inline void free_let_calloc(let_calloc *alloc) { free(alloc); } +typedef struct let_callback { + struct let_func *func; + struct set_values *args; +} let_callback; + +static inline void free_let_func(struct let_func *func); +static inline void free_set_values(struct set_values *vals); +static inline let_callback *init_let_callback(struct let_func *func, struct set_values *args) { + let_callback *cb = calloc(1, sizeof(*cb)); + + cb->func = func; + cb->args = args; + return cb; +} + +static inline void free_let_callback(let_callback *cb) { + free_let_func(cb->func); + free_set_values(cb->args); + free(cb); +} + typedef struct let_func { token_t type; char *name; impl_var *var; impl_arg *arg; + impl_val *(*handler)(impl_val *tmp, decl_type *type, void *val, void **to_free); } let_func; static inline let_func *init_let_func(token_t type, const char *name, impl_var *var) { @@ -849,12 +948,14 @@ typedef struct let_val { PSI_LET_NULL, PSI_LET_NUMEXP, PSI_LET_CALLOC, + PSI_LET_CALLBACK, PSI_LET_FUNC, PSI_LET_TMP, } kind; union { num_exp *num; let_calloc *alloc; + let_callback *callback; let_func *func; decl_var *var; } data; @@ -877,6 +978,9 @@ static inline let_val *init_let_val(enum let_val_kind kind, void *data) { case PSI_LET_CALLOC: let->data.alloc = data; break; + case PSI_LET_CALLBACK: + let->data.callback = data; + break; case PSI_LET_FUNC: let->data.func = data; break; @@ -898,6 +1002,9 @@ static inline void free_let_val(let_val *let) { case PSI_LET_CALLOC: free_let_calloc(let->data.alloc); break; + case PSI_LET_CALLBACK: + free_let_callback(let->data.callback); + break; case PSI_LET_FUNC: free_let_func(let->data.func); break; @@ -966,10 +1073,15 @@ typedef struct set_value { struct set_value *set; impl_val *val; } outer; - struct set_value **inner; - size_t count; + struct set_values *inner; } set_value; +typedef struct set_values { + set_value **vals; + size_t count; +} set_values; + + static inline set_value *init_set_value(set_func *func, decl_vars *vars) { set_value *val = calloc(1, sizeof(*val)); val->func = func; @@ -977,8 +1089,8 @@ static inline set_value *init_set_value(set_func *func, decl_vars *vars) { return val; } static inline set_value *add_inner_set_value(set_value *val, set_value *inner) { - val->inner = realloc(val->inner, ++val->count * sizeof(*val->inner)); - val->inner[val->count-1] = inner; + val->inner->vals = realloc(val->inner->vals, ++val->inner->count * sizeof(*val->inner->vals)); + val->inner->vals[val->inner->count-1] = inner; inner->outer.set = val; return val; } @@ -992,10 +1104,10 @@ static inline void free_set_value(set_value *val) { } if (val->inner && (!val->outer.set || val->outer.set->inner != val->inner)) { size_t i; - for (i = 0; i < val->count; ++i) { - free_set_value(val->inner[i]); + for (i = 0; i < val->inner->count; ++i) { + free_set_value(val->inner->vals[i]); } - free(val->inner); + free(val->inner->vals); } if (val->num) { free_num_exp(val->num); @@ -1003,6 +1115,29 @@ static inline void free_set_value(set_value *val) { free(val); } +static inline set_values *init_set_values(set_value *val) { + set_values *vals = calloc(1, sizeof(*vals)); + if (val) { + vals->count = 1; + vals->vals = calloc(1, sizeof(val)); + vals->vals[0] = val; + } + return vals; +} + +static inline set_values *add_set_value(set_values *vals, set_value *val) { + vals->vals = realloc(vals->vals, ++vals->count * sizeof(val)); + vals->vals[vals->count-1] = val; + return vals; +} + +static inline void free_set_values(set_values *vals) { + if (vals->vals) { + free(vals->vals); + } + free(vals); +} + typedef struct set_stmt { impl_var *var; set_value *val; @@ -1354,13 +1489,14 @@ static inline impl_val *struct_member_ref(decl_arg *set_arg, impl_val *struct_pt #define PSI_ERROR 16 #define PSI_WARNING 32 -typedef void (*psi_error_cb)(PSI_Token *token, int type, const char *msg, ...); +typedef void (*psi_error_cb)(void *context, PSI_Token *token, int type, const char *msg, ...); #define PSI_DATA(D) ((PSI_Data *) (D)) #define PSI_DATA_MEMBERS \ constants *consts; \ decl_typedefs *defs; \ decl_structs *structs; \ + decl_unions *unions; \ decl_enums *enums; \ decls *decls; \ impls *impls; \ @@ -1368,7 +1504,9 @@ typedef void (*psi_error_cb)(PSI_Token *token, int type, const char *msg, ...); decl_file file; \ decl_libs libs; \ } psi; \ - psi_error_cb error + psi_error_cb error; \ + unsigned errors; \ + unsigned flags typedef struct PSI_Data { PSI_DATA_MEMBERS; } PSI_Data; @@ -1392,6 +1530,9 @@ static inline void PSI_DataDtor(PSI_Data *data) { if (data->structs) { free_decl_structs(data->structs); } + if (data->unions) { + free_decl_unions(data->unions); + } if (data->enums) { free_decl_enums(data->enums); } @@ -1409,7 +1550,7 @@ typedef struct PSI_Parser { FILE *fp; token_t num; void *proc; - unsigned flags, errors, line, col; + unsigned line, col; char *cur, *tok, *lim, *eof, *ctx, *mrk, buf[BSIZE]; } PSI_Parser; @@ -1541,6 +1682,7 @@ static inline uint64_t PSI_TokenHash(PSI_Token *t, char *digest_buf) { } #define PSI_PARSER_DEBUG 0x1 +#define PSI_PARSER_SILENT 0x2 PSI_Parser *PSI_ParserInit(PSI_Parser *P, const char *filename, psi_error_cb error, unsigned flags); void PSI_ParserSyntaxError(PSI_Parser *P, const char *fn, size_t ln, const char *msg, ...);