X-Git-Url: https://git.m6w6.name/?p=m6w6%2Fext-psi;a=blobdiff_plain;f=src%2Fparser.h;h=daf99dc8eda359cc02e2a1d0fba8ae75bbee7ced;hp=d5ff8967b4ae2d343bfee026e9e1d7748896179a;hb=6a459a08a40a2c243b0211ceb0cb263d29302627;hpb=4ecafb11128dc652013564387ab33b8b9110f039 diff --git a/src/parser.h b/src/parser.h index d5ff896..daf99dc 100644 --- a/src/parser.h +++ b/src/parser.h @@ -17,13 +17,12 @@ typedef int token_t; -/* in php_psi.h */ size_t psi_t_alignment(token_t); size_t psi_t_size(token_t); typedef struct PSI_Token { token_t type; - unsigned size, *line; + unsigned size, line; char *text, *file; char buf[1]; } PSI_Token; @@ -43,6 +42,9 @@ typedef union impl_val { uint64_t u64; float fval; double dval; +#ifdef HAVE_LONG_DOUBLE + long double ldval; +#endif union { zend_bool bval; zend_long lval; @@ -58,6 +60,7 @@ typedef struct decl_type { token_t type; struct decl_type *real; struct decl_struct *strct; + struct decl_enum *enm; } decl_type; static inline decl_type *init_decl_type(token_t type, const char *name) { @@ -67,40 +70,6 @@ static inline decl_type *init_decl_type(token_t type, const char *name) { return t; } -static inline decl_type *init_decl_type_ex(token_t type, int argc, ...) { - va_list argv; - char *ptr, *arg; - unsigned i; - size_t len, pos = 0, all = 0; - decl_type *t = calloc(1, sizeof(*t)); - - va_start(argv, argc); - for (i = 0; i < argc; ++i) { - arg = va_arg(argv, char *); - len = va_arg(argv, size_t); - - if (len) { - if (all) { - pos = all; - ptr = realloc(ptr, 1 + (all += len)); - } else { - ptr = malloc(1 + (all = len)); - } - memcpy(ptr + pos, arg, len); - } - } - va_end(argv); - - if (!all) { - ptr = calloc(1, 1); - } else { - ptr[all] = 0; - } - t->type = type; - t->name = ptr; - return t; -} - static inline decl_type *real_decl_type(decl_type *type) { while (type->real) { type = type->real; @@ -372,6 +341,7 @@ static inline void free_decls(decls *decls) { free(decls); } + typedef struct decl_struct { PSI_Token *token; char *name; @@ -648,6 +618,7 @@ typedef struct num_exp { char *numb; constant *cnst; decl_var *dvar; + struct decl_enum_item *enm; } u; token_t operator; int (*calculator)(int t1, impl_val *v1, int t2, impl_val *v2, impl_val *res); @@ -669,6 +640,36 @@ static inline num_exp *init_num_exp(token_t t, void *num) { return exp; } +static inline PSI_Token *PSI_TokenCopy(PSI_Token *src); +static inline num_exp *copy_num_exp(num_exp *exp) { + decl_var *dvar; + num_exp *num = calloc(1, sizeof(*num)); + + memcpy(num, exp, sizeof(*num)); + + if (num->token) { + num->token = PSI_TokenCopy(num->token); + } + if (num->operand) { + num->operand = copy_num_exp(num->operand); + } + switch (num->t) { + case PSI_T_NUMBER: + case PSI_T_NSNAME: + num->u.numb = strdup(num->u.numb); + break; + case PSI_T_NAME: + dvar = init_decl_var(num->u.dvar->name, num->u.dvar->pointer_level, num->u.dvar->array_size); + dvar->arg = num->u.dvar->arg; + if (num->u.dvar->token) { + dvar->token = PSI_TokenCopy(num->u.dvar->token); + } + num->u.dvar = dvar; + break; + } + return num; +} + static inline void free_num_exp(num_exp *exp) { if (exp->token) { free(exp->token); @@ -682,6 +683,8 @@ static inline void free_num_exp(num_exp *exp) { case PSI_T_NAME: free_decl_var(exp->u.dvar); break; + case PSI_T_ENUM: + break; EMPTY_SWITCH_DEFAULT_CASE(); } if (exp->operand) { @@ -690,6 +693,122 @@ static inline void free_num_exp(num_exp *exp) { free(exp); } +typedef struct decl_enum_item { + PSI_Token *token; + char *name; + num_exp *num; + num_exp inc; + struct decl_enum_item *prev; +} decl_enum_item; + +static inline decl_enum_item *init_decl_enum_item(const char *name, num_exp *num) { + decl_enum_item *i = calloc(1, sizeof(*i)); + + i->name = strdup(name); + i->num = num; + return i; +} + +static inline void free_decl_enum_item(decl_enum_item *i) { + if (i->token) { + free(i->token); + } + if (i->num && i->num != &i->inc) { + free_num_exp(i->num); + } + free(i->name); + free(i); +} + +typedef struct decl_enum_items { + decl_enum_item **list; + size_t count; +} decl_enum_items; + +static inline decl_enum_items *init_decl_enum_items(decl_enum_item *i) { + decl_enum_items *l = calloc(1, sizeof(*l)); + + if (i) { + l->count = 1; + l->list = calloc(1, sizeof(*l->list)); + l->list[0] = i; + } + return l; +} + +static inline decl_enum_items *add_decl_enum_item(decl_enum_items *l, decl_enum_item *i) { + l->list = realloc(l->list, sizeof(*l->list) * (l->count + 1)); + l->list[l->count] = i; + if (l->count) { + i->prev = l->list[l->count - 1]; + } + ++l->count; + return l; +} + +static inline void free_decl_enum_items(decl_enum_items *l) { + if (l->list) { + size_t j; + + for (j = 0; j < l->count; ++j) { + free_decl_enum_item(l->list[j]); + } + free(l->list); + } + free(l); +} + +typedef struct decl_enum { + PSI_Token *token; + char *name; + decl_enum_items *items; +} decl_enum; + +static inline decl_enum *init_decl_enum(const char *name, decl_enum_items *l) { + decl_enum *e = calloc(1, sizeof(*e)); + + e->name = strdup(name); + e->items = l; + return e; +} + +static inline void free_decl_enum(decl_enum *e) { + if (e->token) { + free(e->token); + } + if (e->items) { + free_decl_enum_items(e->items); + } + free(e->name); + free(e); +} + +typedef struct decl_enums { + decl_enum **list; + size_t count; +} decl_enums; + +static inline decl_enums* add_decl_enum(decl_enums *es, decl_enum *e) { + if (!es) { + es = calloc(1, sizeof(*es)); + } + es->list = realloc(es->list, ++es->count * sizeof(*es->list)); + es->list[es->count-1] = e; + return es; +} + +static inline void free_decl_enums(decl_enums *es) { + if (es->list) { + size_t j; + + for (j = 0; j < es->count; ++j) { + free_decl_enum(es->list[j]); + } + } + free(es->list); + free(es); +} + typedef struct let_calloc { num_exp *nmemb; num_exp *size; @@ -1213,7 +1332,7 @@ static inline impl_val *enref_impl_val(void *ptr, decl_var *var) { var->name, var->pointer_level, var->arg->var->pointer_level, var->array_size, var->arg->var->array_size); #endif - if (!var->pointer_level && real_decl_type(var->arg->type)->type != PSI_T_STRUCT) { + if (!var->pointer_level ){//&& real_decl_type(var->arg->type)->type != PSI_T_STRUCT) { return ptr; } @@ -1247,6 +1366,7 @@ typedef void (*psi_error_cb)(PSI_Token *token, int type, const char *msg, ...); constants *consts; \ decl_typedefs *defs; \ decl_structs *structs; \ + decl_enums *enums; \ decls *decls; \ impls *impls; \ union { \ @@ -1277,6 +1397,9 @@ static inline void PSI_DataDtor(PSI_Data *data) { if (data->structs) { free_decl_structs(data->structs); } + if (data->enums) { + free_decl_enums(data->enums); + } if (data->decls) { free_decls(data->decls); } @@ -1296,7 +1419,7 @@ typedef struct PSI_Parser { } PSI_Parser; static inline size_t PSI_TokenAllocSize(size_t token_len, size_t fname_len) { - return sizeof(PSI_Token) + token_len + fname_len + sizeof(unsigned) + 2; + return sizeof(PSI_Token) + token_len + fname_len + 2; } static inline PSI_Token *PSI_TokenAlloc(PSI_Parser *P) { @@ -1317,11 +1440,10 @@ static inline PSI_Token *PSI_TokenAlloc(PSI_Parser *P) { T->size = token_len; T->text = &T->buf[0]; T->file = &T->buf[token_len + 1]; - T->line = (void *) &T->buf[fname_len + token_len + 2]; + T->line = P->line; memcpy(T->text, P->tok, token_len); memcpy(T->file, P->psi.file.fn, fname_len); - memcpy(T->line, &P->line, sizeof(unsigned)); return T; } @@ -1348,12 +1470,14 @@ static inline PSI_Token *PSI_TokenCat(unsigned argc, ...) { PSI_Token *arg = va_arg(argv, PSI_Token *); if (T) { - size_t fname_len = strlen(T->file); + size_t token_len = T->size, fname_len = strlen(T->file); - T = realloc(T, PSI_TokenAllocSize(T->size + arg->size, fname_len)); - memmove(&T->buf[T->size + 1], T->file, fname_len + 1); - memcpy(T->file - 1, arg->text, arg->size + 1); + T = realloc(T, PSI_TokenAllocSize(T->size += arg->size + 1, fname_len)); + T->text = &T->buf[0]; T->file = &T->buf[T->size + 1]; + T->buf[token_len] = ' '; + memmove(&T->buf[T->size + 1], &T->buf[token_len + 1], fname_len + 1); + memcpy(&T->buf[token_len + 1], arg->text, arg->size + 1); } else { T = PSI_TokenCopy(arg); T->type = PSI_T_NAME;