X-Git-Url: https://git.m6w6.name/?p=m6w6%2Fext-psi;a=blobdiff_plain;f=src%2Fcontext.c;h=ee79c8f07e752f25d938c1af103c88d6e8a79635;hp=e499c5f0d24052c0f5a32475f0f0878d2a0b1fc2;hb=c2dc24a4967dd767fc4a240f93ca0de4600a8c62;hpb=3f3b862aeb06ebe0e61d8fcc21df0fe88e397688 diff --git a/src/context.c b/src/context.c index e499c5f..ee79c8f 100644 --- a/src/context.c +++ b/src/context.c @@ -1,72 +1,205 @@ -#include -#include -#include -#include -#include - #ifdef HAVE_CONFIG_H # include "config.h" #endif +#include "php.h" + +#include +#ifdef HAVE_SYS_TYPES_H +# include +#endif +#ifdef HAVE_SYS_STAT_H +# include +#endif +#ifdef STDC_HEADERS +# include +# include +#else +# ifdef HAVE_STDLIB_H +# include +# endif +#endif +#ifdef HAVE_STRING_H +# if !defined STDC_HEADERS && defined HAVE_MEMORY_H +# include +# endif +# include +#endif +#ifdef HAVE_STRINGS_H +# include +#endif +#ifdef HAVE_INTTYPES_H +# include +#endif +#ifdef HAVE_STDINT_H +# include +#endif +#ifdef HAVE_UNISTD_H +# include +#endif + +#ifdef HAVE_ERRNO_H +# include +#endif +#ifdef HAVE_GLOB_H +# include +#endif +#ifdef HAVE_NETINET_IN_H +# include +#endif +#ifdef HAVE_ARPA_NAMESER_H +# include +#endif +#ifdef HAVE_NETDB_H +# include +#endif +#ifdef HAVE_RESOLV_H +# include +#endif +#ifdef HAVE_SYS_SELECT_H +# include +#endif +#ifdef HAVE_SYS_SOCKET_H +# include +#endif +#ifdef HAVE_SYS_TIME_H +# include +#endif +#ifdef HAVE_SYS_TIMES_H +# include +#endif +#ifdef HAVE_SYS_UIO_H +# include +#endif +#ifdef HAVE_SYS_UTSNAME_H +# include +#endif +#ifdef HAVE_TIME_H +# include +#endif +#ifdef HAVE_SYSLOG_H +# include +#endif +#ifdef HAVE_WCHAR_H +# include +#endif + +#ifdef HAVE_DIRENT_H +# include +# define NAMLEN(dirent) strlen ((dirent)->d_name) +#else +# define dirent direct +# define NAMLEN(dirent) ((dirent)->d_namlen) +# ifdef HAVE_SYS_NDIR_H +# include +# endif +# ifdef HAVE_SYS_DIR_H +# include +# endif +# ifdef HAVE_NDIR_H +# include +# endif +#endif + +#include +#include +#include + #include "php.h" #include "php_scandir.h" #include "php_psi.h" -#include "context.h" -#include "parser.h" -#define psi_predef_count(of) ((sizeof(psi_predef ##of## s)/sizeof(psi_predef ##of))-1) -typedef struct psi_predef_type { +#include "libjit.h" +#include "libffi.h" + +static struct psi_std_type { + token_t type_tag; + const char *type_name; +} psi_std_types[] = { + {PSI_T_FLOAT, "float"}, + {PSI_T_DOUBLE, "double"}, + {PSI_T_INT8, "int8_t"}, + {PSI_T_INT16, "int16_t"}, + {PSI_T_INT32, "int32_t"}, + {PSI_T_INT64, "int64_t"}, + {PSI_T_UINT8, "uint8_t"}, + {PSI_T_UINT16, "uint16_t"}, + {PSI_T_UINT32, "uint32_t"}, + {PSI_T_UINT64, "uint64_t"}, + {0} +}; + +static struct psi_predef_type { token_t type_tag; const char *type_name; const char *alias; -} psi_predef_type; -static const psi_predef_type psi_predef_types[] = { - PHP_PSI_TYPES{0} +} psi_predef_types[] = { + PSI_TYPES + {0} }; -#define psi_predef_type_count() psi_predef_count(_type) -typedef struct psi_predef_const { +static struct psi_predef_const { token_t type_tag; const char *type_name; - const char *name; + const char *var_name; const char *val_text; token_t val_type_tag; -} psi_predef_const; -static const psi_predef_const psi_predef_consts[] = { - PHP_PSI_CONSTS{0} +} psi_predef_consts[] = { + PSI_CONSTS + {0} +}; + +PSI_MACROS + +int psi_glob(const char *pattern, int flags, + int (*errfunc) (const char *epath, int eerrno), + glob_t *pglob) { + size_t offs = flags & GLOB_DOOFFS ? pglob->gl_offs : 0; + int rv = glob(pattern, flags, errfunc, pglob); + if (pglob->gl_pathv) { + while (offs--) { + pglob->gl_pathv[offs] = NULL; + } + } + return rv; +} + +static struct psi_func_redir { + const char *name; + void (*func)(void); +} psi_func_redirs[] = { + {"glob", (void (*)(void)) psi_glob}, + PSI_REDIRS + {0} }; -#define psi_predef_const_count() psi_predef_count(_const) -typedef struct psi_predef_struct_member { +static struct psi_predef_decl { token_t type_tag; const char *type_name; - const char *name; - size_t off; - size_t len; + const char *var_name; size_t pointer_level; size_t array_size; -} psi_predef_struct_member; -#define PSI_PREDEF_STRUCT_MEMBERS 32 -typedef struct psi_predef_struct { - const char *name; - size_t size; - psi_predef_struct_member members[PSI_PREDEF_STRUCT_MEMBERS]; -} psi_predef_struct; -static const psi_predef_struct psi_predef_structs[] = { - PHP_PSI_STRUCTS{0} +} psi_predef_decls[] = { + PSI_DECLS + {0} +}; +static struct psi_predef_decl psi_predef_vararg_decls[] = { + PSI_VA_DECLS + {0} }; -#define psi_predef_struct_count() psi_predef_count(_struct) - -PHP_PSI_MACROS -typedef struct psi_predef_func { - const char *name; - void (*func)(void); -} psi_predef_func; -static psi_predef_func psi_predef_funcs[] = { - PHP_PSI_FUNCS{0} +static struct psi_predef_struct { + token_t type_tag; + const char *type_name; + const char *var_name; + size_t offset; + size_t size; + size_t pointer_level; + size_t array_size; +} psi_predef_structs[] = { + PSI_STRUCTS + {0} }; -#define psi_predef_func_count() psi_predef_count(_func) static int validate_lib(PSI_Data *data, void **dlopened) { char lib[MAXPATHLEN]; @@ -79,13 +212,13 @@ static int validate_lib(PSI_Data *data, void **dlopened) { } else if (!strchr(ptr, '/')) { len = snprintf(lib, MAXPATHLEN, "lib%s.%s", ptr, PHP_PSI_SHLIB_SUFFIX); if (MAXPATHLEN == len) { - data->error(PSI_WARNING, "Library name too long: '%s'", ptr); + data->error(NULL, PSI_WARNING, "Library name too long: '%s'", ptr); } lib[len] = 0; ptr = lib; } if (!(*dlopened = dlopen(ptr, RTLD_LAZY|RTLD_LOCAL))) { - data->error(PSI_WARNING, "Could not open library '%s': %s.", + data->error(NULL, PSI_WARNING, "Could not open library '%s': %s.", data->psi.file.ln, dlerror()); return 0; } @@ -94,16 +227,26 @@ static int validate_lib(PSI_Data *data, void **dlopened) { static inline int locate_decl_type_alias(decl_typedefs *defs, decl_type *type) { size_t i; + struct psi_std_type *stdtyp; if (type->real) { return 1; } for (i = 0; i < defs->count; ++i) { - if (!strcmp(defs->list[i]->alias, type->name)) { - type->real = defs->list[i]->type; + decl_typedef *def = defs->list[i]; + + if (def->type->type != type->type && !strcmp(def->alias, type->name)) { + type->real = def->type; return 1; } } + for (stdtyp = &psi_std_types[0]; stdtyp->type_tag; ++stdtyp) { + if (!strcmp(type->name, stdtyp->type_name)) { + type->type = stdtyp->type_tag; + return 1; + } + } + return 0; } static inline int locate_decl_type_struct(decl_structs *structs, decl_type *type) { @@ -127,7 +270,10 @@ static inline int validate_decl_type(PSI_Data *data, decl_type *type) { if (!data->defs || !locate_decl_type_alias(data->defs, type)) { return 0; } - return validate_decl_type(data, type->real); + if (type->real) { + return validate_decl_type(data, type->real); + } + return 1; case PSI_T_STRUCT: if (!data->structs || !locate_decl_type_struct(data->structs, type)) { return 0; @@ -138,8 +284,9 @@ static inline int validate_decl_type(PSI_Data *data, decl_type *type) { } static inline int validate_decl_typedef(PSI_Data *data, decl_typedef *def) { if (!validate_decl_type(data, def->type)) { - data->error(PSI_WARNING, "Type '%s' cannot be aliased to '%s'", - def->type->name, def->alias); + data->error(def->token, PSI_WARNING, + "Type '%s' cannot be aliased to %s'%s'", + def->type->name, def->type->type == PSI_T_STRUCT?"struct ":"",def->alias); return 0; } /* FIXME: check def->alias */ @@ -153,8 +300,9 @@ static inline int validate_constant(PSI_Data *data, constant *c) { static inline int validate_decl_arg(PSI_Data *data, decl_arg *arg) { if (!validate_decl_type(data, arg->type)) { - data->error(PSI_WARNING, "Cannot use '%s' as type for '%s'", - arg->type->name, arg->var->name); + data->error(arg->type->token, PSI_WARNING, + "Cannot use '%s'(%d) as type for decl var '%s'", + arg->type->name, arg->type->type, arg->var->name); return 0; } return 1; @@ -208,6 +356,7 @@ static const char * const abi_ccs[] = { "default", /* \ */ "extern", /* > - all the same */ "cdecl", /* / */ + "mscdecl", "stdcall", "fastcall", }; @@ -219,36 +368,33 @@ static inline int validate_decl_abi(PSI_Data *data, decl_abi *abi) { return 1; } } - data->error(PSI_WARNING, "Invalid calling convention: '%s'", abi->convention); return 0; } static inline int validate_decl_func(PSI_Data *data, void *dl, decl *decl, decl_arg *func) { + struct psi_func_redir *redir; + if (!strcmp(func->var->name, "dlsym")) { - data->error(PSI_WARNING, "Cannot dlsym dlsym (sic!)"); + data->error(func->token, PSI_WARNING, "Cannot dlsym dlsym (sic!)"); return 0; } if (!validate_decl_arg(data, func)) { return 0; } + for (redir = &psi_func_redirs[0]; redir->name; ++redir) { + if (!strcmp(func->var->name, redir->name)) { + decl->call.sym = redir->func; + } + } + if (!decl->call.sym) { #ifndef RTLD_NEXT # define RTLD_NEXT ((void *) -1l) #endif - decl->dlptr = dlsym(dl ?: RTLD_NEXT, func->var->name); - if (!decl->dlptr) { - size_t i; - - for (i = 0; i < psi_predef_func_count(); ++i) { - psi_predef_func *pre = &psi_predef_funcs[i]; - - if (!strcmp(func->var->name, pre->name)) { - decl->dlptr = pre->func; - break; - } - } - if (!decl->dlptr) { - data->error(PSI_WARNING, "Failed to locate symbol '%s': %s", + decl->call.sym = dlsym(dl ?: RTLD_NEXT, func->var->name); + if (!decl->call.sym) { + data->error(func->token, PSI_WARNING, + "Failed to locate symbol '%s': %s", func->var->name, dlerror()); } } @@ -257,6 +403,8 @@ static inline int validate_decl_func(PSI_Data *data, void *dl, decl *decl, decl_ static inline int validate_decl(PSI_Data *data, void *dl, decl *decl) { if (!validate_decl_abi(data, decl->abi)) { + data->error(decl->abi->token, PSI_WARNING, + "Invalid calling convention: '%s'", decl->abi->token->text); return 0; } if (!validate_decl_func(data, dl, decl, decl->func)) { @@ -273,26 +421,87 @@ static inline int validate_decl(PSI_Data *data, void *dl, decl *decl) { } return 1; } - -static inline decl_arg *locate_struct_member(decl_struct *s, decl_var *var) { +static inline decl_arg *locate_decl_var_arg(decl_var *var, decl_args *args, decl_arg *func) { size_t i; - ZEND_ASSERT(s); - for (i = 0; i < s->args->count; ++i) { - decl_arg *darg = s->args->args[i]; + for (i = 0; i < args->count; ++i) { + decl_arg *arg = args->args[i]; - if (!strcmp(var->name, darg->var->name)) { - return var->arg = darg; + if (!strcmp(var->name, arg->var->name)) { + ZEND_ASSERT(!var->arg || var->arg == arg); + return var->arg = arg; } } + if (func && !strcmp(var->name, func->var->name)) { + return var->arg = func; + } + + return NULL; +} +static inline decl_arg *locate_struct_member(decl_struct *s, decl_var *var) { + if (s->args) { + return locate_decl_var_arg(var, s->args, NULL); + } return NULL; } -static inline int validate_set_value(PSI_Data *data, set_value *set, decl_arg *ref) { +static inline constant *locate_num_exp_constant(num_exp *exp, constants *consts) { size_t i; - decl_type *ref_type = real_decl_type(ref->type); - decl_var *set_var = set->vars->vars[0]; + for (i = 0; i < consts->count; ++i) { + constant *cnst = consts->list[i]; + + if (!strcmp(cnst->name, exp->u.numb)) { + free(exp->u.numb); + return exp->u.cnst = cnst; + } + } + + return NULL; +} +static inline int validate_num_exp(PSI_Data *data, decl_args *dargs, decl_arg *func, num_exp *exp) { + if (exp->operand) { + switch (exp->operator) { + case PSI_T_PLUS: + exp->calculator = psi_calc_add; + break; + case PSI_T_MINUS: + exp->calculator = psi_calc_sub; + break; + case PSI_T_ASTERISK: + exp->calculator = psi_calc_mul; + break; + case PSI_T_SLASH: + exp->calculator = psi_calc_div; + break; + EMPTY_SWITCH_DEFAULT_CASE(); + } + if (!validate_num_exp(data, dargs, func, exp->operand)) { + return 0; + } + } + switch (exp->t) { + case PSI_T_NAME: + if (!locate_decl_var_arg(exp->u.dvar, dargs, func)) { + data->error(exp->token, PSI_WARNING, "Unknown variable '%s' in numeric expression", + exp->u.dvar->name); + return 0; + } + return 1; + case PSI_T_NSNAME: + if (!locate_num_exp_constant(exp, data->consts)) { + data->error(exp->token, PSI_WARNING, "Unknown constant '%s' in numeric expression", + exp->u.numb); + return 0; + } + return 1; + case PSI_T_NUMBER: + return 1; + default: + return 0; + } +} +static inline int validate_set_value_handler(set_value *set) { switch (set->func->type) { case PSI_T_TO_BOOL: set->func->handler = psi_to_bool; @@ -309,39 +518,135 @@ static inline int validate_set_value(PSI_Data *data, set_value *set, decl_arg *r case PSI_T_TO_ARRAY: set->func->handler = psi_to_array; break; - EMPTY_SWITCH_DEFAULT_CASE(); + case PSI_T_TO_OBJECT: + set->func->handler = psi_to_object; + break; + case PSI_T_VOID: + set->func->handler = psi_to_void; + break; + case PSI_T_ELLIPSIS: + if (set->outer.set && set->outer.set->func->type == PSI_T_TO_ARRAY) { + set->func->handler = psi_to_recursive; + break; + } + /* no break */ + default: + return 0; } + return 1; +} +static inline void decl_var_arg_v(decl_args *args, va_list argp) { + int argc; + decl_arg **argv; - if (strcmp(set_var->name, ref->var->name)) { - return 0; + memset(args, 0, sizeof(*args)); + + while ((argc = va_arg(argp, int))) { + argv = va_arg(argp, decl_arg **); + while (argc--) { + add_decl_arg(args, *argv++); + } } +} +static inline int validate_set_value_ex(PSI_Data *data, set_value *set, decl_arg *ref, decl_args *ref_list) { + size_t i; + decl_type *ref_type; + decl_var *set_var = set->vars->vars[0]; - if (set->count && (set->func->type != PSI_T_TO_ARRAY || ref_type->type != PSI_T_STRUCT)) { - data->error(E_WARNING, "Inner `set` statement casts only work with to_array() casts on structs"); + if (!validate_set_value_handler(set)) { + data->error(set->func->token, PSI_WARNING, "Invalid cast '%s' in `set` statement", set->func->name); return 0; } - for (i = 0; i < set->count; ++i) { - decl_var *sub_var = set->inner[i]->vars->vars[0]; - decl_arg *sub_ref = locate_struct_member(ref_type->strct, sub_var); + + for (i = 0; i < set->vars->count; ++i) { + decl_var *svar = set->vars->vars[i]; + if (!svar->arg && !locate_decl_var_arg(svar, ref_list, NULL)) { + data->error(svar->token, PSI_WARNING, "Unknown variable '%s' in `set` statement", svar->name); + return 0; + } + } + + if (!ref) { + ref = set_var->arg; + } + ref_type = real_decl_type(ref->type); + + if (set->count) { + int is_to_array = (set->func->type == PSI_T_TO_ARRAY); + int is_pointer_to_struct = (ref_type->type == PSI_T_STRUCT && ref->var->pointer_level); + + if (!is_to_array && !is_pointer_to_struct) { + data->error(set->func->token, E_WARNING, "Inner `set` statement casts only work with " + "to_array() casts on structs or pointers: %s(%s...", set->func->name, set->vars->vars[0]->name); + return 0; + } + } + if (set->num) { + if (!validate_num_exp(data, ref_list, ref, set->num)) { + return 0; + } + } + + if (ref_type->type == PSI_T_STRUCT) { + /* to_array(struct, to_...) */ + for (i = 0; i < set->count; ++i) { + decl_var *sub_var = set->inner[i]->vars->vars[0]; + decl_arg *sub_ref = locate_struct_member(ref_type->strct, sub_var); + + if (sub_ref) { + if (!validate_set_value_ex(data, set->inner[i], sub_ref, ref_type->strct->args)) { + return 0; + } + } + } + } else if (set->count == 1) { + /* to_array(ptr, to_string(*ptr)) */ + decl_var *sub_var = set->inner[0]->vars->vars[0]; + decl_arg *sub_ref = locate_decl_var_arg(sub_var, ref_list, ref); if (sub_ref) { - if (!validate_set_value(data, set->inner[i], sub_ref)) { + if (strcmp(sub_var->name, set_var->name)) { + data->error(sub_var->token, E_WARNING, "Inner `set` statement casts on pointers must reference the same variable"); + return 0; + } + if (!validate_set_value_ex(data, set->inner[0], sub_ref, ref_list)) { return 0; } } + } else if (set->count > 1) { + data->error(set->func->token, E_WARNING, "Inner `set` statement casts on pointers may only occur once"); + return 0; } return 1; } +static inline int validate_set_value(PSI_Data *data, set_value *set, ...) { + va_list argp; + decl_args args = {0}; + int check; + + va_start(argp, set); + decl_var_arg_v(&args, argp); + va_end(argp); + + check = validate_set_value_ex(data, set, NULL, &args); + if (args.args) { + free(args.args); + } + return check; +} static inline decl *locate_impl_decl(decls *decls, return_stmt *ret) { - size_t i; + if (decls) { + size_t i; - for (i = 0; i < decls->count; ++i) { - if (!strcmp(decls->list[i]->func->var->name, ret->set->vars->vars[0]->name)) { - ret->decl = decls->list[i]->func; - return decls->list[i]; + for (i = 0; i < decls->count; ++i) { + if (!strcmp(decls->list[i]->func->var->name, ret->set->vars->vars[0]->name)) { + ret->decl = decls->list[i]->func; + return decls->list[i]; + } } } + return NULL; } static inline int validate_impl_ret_stmt(PSI_Data *data, impl *impl) { @@ -351,11 +656,13 @@ static inline int validate_impl_ret_stmt(PSI_Data *data, impl *impl) { /* and which type cast to apply */ if (impl->stmts->ret.count != 1) { if (impl->stmts->ret.count > 1) { - data->error(PSI_WARNING, "Too many `return` statements for implmentation %s;" + data->error(impl->stmts->ret.list[1]->token, PSI_WARNING, + "Too many `return` statements for implmentation %s;" " found %zu, exactly one is needed", impl->func->name, impl->stmts->ret.count); } else { - data->error(PSI_WARNING, "Missing `return` statement for implementation %s", + data->error(impl->func->token, PSI_WARNING, + "Missing `return` statement for implementation %s", impl->func->name); } return 0; @@ -364,19 +671,94 @@ static inline int validate_impl_ret_stmt(PSI_Data *data, impl *impl) { ret = impl->stmts->ret.list[0]; if (!(impl->decl = locate_impl_decl(data->decls, ret))) { - data->error(PSI_WARNING, "Missing declaration for implementation %s", - impl->func->name); + data->error(ret->token, PSI_WARNING, + "Missing declaration '%s' for `return` statment for implementation %s", + ret->set->vars->vars[0]->name, impl->func->name); return 0; } - if (!validate_set_value(data, ret->set, ret->decl)) { + + if (!validate_set_value(data, ret->set, 1, &ret->decl, impl->decl->args ? (int) impl->decl->args->count : 0, impl->decl->args ? impl->decl->args->args : NULL, 0)) { return 0; } + impl->decl->impl = impl; + return 1; } + static inline int validate_impl_let_stmts(PSI_Data *data, impl *impl) { size_t i, j; /* we can have multiple let stmts */ + + /* check that we have a decl arg for every let stmt */ + for (i = 0; i < impl->stmts->let.count; ++i) { + let_stmt *let = impl->stmts->let.list[i]; + decl_var *let_var; + int check = 0; + + if (let->val && let->val->kind == PSI_LET_TMP) { + let_var = let->val->data.var; + } else { + let_var = let->var; + } + + if (!locate_decl_var_arg(let_var, impl->decl->args, impl->decl->func)) { + data->error(let_var->token, PSI_WARNING, "Unknown variable '%s' in `let` statement" + " of implementation '%s'", let_var->name, impl->func->name); + return 0; + } + + switch (let->val->kind) { + case PSI_LET_NULL: + break; + case PSI_LET_TMP: + /* e.g. let bar = &strval($bar); // decl_arg(char **bar) */ + /* e.g. let foo = *bar; */ + let->var->pointer_level = let->val->data.var->pointer_level; + let->var->arg = init_decl_arg( + init_decl_type( + real_decl_type(let->val->data.var->arg->type)->type, + real_decl_type(let->val->data.var->arg->type)->name), + init_decl_var( + let->var->name, + let->var->pointer_level, + let->var->array_size)); + break; + case PSI_LET_NUMEXP: + if (!validate_num_exp(data, impl->decl->args, impl->decl->func, let->val->data.num)) { + return 0; + } + break; + case PSI_LET_CALLOC: + if (!validate_num_exp(data, impl->decl->args, impl->decl->func, let->val->data.alloc->nmemb)) { + return 0; + } + if (!validate_num_exp(data, impl->decl->args, impl->decl->func, let->val->data.alloc->size)) { + return 0; + } + break; + case PSI_LET_FUNC: + if (impl->func->args) { + for (j = 0; j < impl->func->args->count; ++j) { + impl_arg *iarg = impl->func->args->args[j]; + + if (!strcmp(let->val->data.func->var->name, iarg->var->name)) { + let->val->data.func->arg = iarg; + check = 1; + break; + } + } + } + if (!check) { + data->error(let->var->token, PSI_WARNING, "Unknown value '$%s' of `let` statement" + " for variable '%s' of implementation '%s'", + let->val->data.func->var->name, let->var->name, impl->func->name); + return 0; + } + break; + } + } + /* check that we have a let stmt for every decl arg */ if (impl->decl->args) for (i = 0; i < impl->decl->args->count; ++i) { decl_arg *darg = impl->decl->args->args[i]; @@ -392,43 +774,15 @@ static inline int validate_impl_let_stmts(PSI_Data *data, impl *impl) { } } if (!check) { - data->error(PSI_WARNING, "Missing `let` statement for arg '%s %.*s%s'" + data->error(impl->func->token, PSI_WARNING, + "Missing `let` statement for arg '%s %.*s%s'" " of declaration '%s' for implementation '%s'", darg->type->name, (int) darg->var->pointer_level, "*****", darg->var->name, impl->decl->func->var->name, impl->func->name); return 0; } } - /* check that the let_value references a known variable or NULL */ - for (i = 0; i < impl->stmts->let.count; ++i) { - let_stmt *let = impl->stmts->let.list[i]; - int check = 0; - - if (let->val && let->val->func && let->val->func->alloc) { - if (!validate_decl_type(data, let->val->func->alloc->type)) { - data->error(PSI_WARNING, "Cannot use '%s' as type for calloc in `let` statement", - let->val->func->alloc->type->name); - return 0; - } - } - if (let->val && let->val->var) { - if (impl->func->args) for (j = 0; j < impl->func->args->count; ++j) { - impl_arg *iarg = impl->func->args->args[j]; - if (!strcmp(let->val->var->name, iarg->var->name)) { - let->arg = iarg; - check = 1; - break; - } - } - if (!check) { - data->error(PSI_WARNING, "Unknown value '$%s' of `let` statement" - " for variable '%s' of implementation '%s'", - let->val->var->name, let->var->name, impl->func->name); - return 0; - } - } - } return 1; } static inline int validate_impl_set_stmts(PSI_Data *data, impl *impl) { @@ -449,7 +803,7 @@ static inline int validate_impl_set_stmts(PSI_Data *data, impl *impl) { } } if (!check) { - data->error(PSI_WARNING, "Unknown variable '$%s' of `set` statement" + data->error(set->var->token, PSI_WARNING, "Unknown variable '$%s' of `set` statement" " of implementation '%s'", set->var->name, impl->func->name); return 0; @@ -459,21 +813,40 @@ static inline int validate_impl_set_stmts(PSI_Data *data, impl *impl) { decl_var *set_var = set->val->vars->vars[j]; check = 0; - if (impl->decl->args) for (k = 0; k < impl->decl->args->count; ++k) { - decl_arg *set_arg = impl->decl->args->args[k]; + if (impl->decl->args) { + for (k = 0; k < impl->decl->args->count; ++k) { + decl_arg *set_arg = impl->decl->args->args[k]; - if (!strcmp(set_var->name, set_arg->var->name)) { - check = 1; - if (!validate_set_value(data, set->val, set_arg)) { - return 0; + if (!strcmp(set_var->name, set_arg->var->name)) { + check = 1; + set_var->arg = set_arg; + if (!validate_set_value(data, set->val, 1, &set_arg, 1, &impl->decl->func, impl->decl->args->count, impl->decl->args->args, 0)) { + return 0; + } + break; + } + } + } + if (!check) { + for (k = 0; k < impl->stmts->let.count; ++k) { + let_stmt *let = impl->stmts->let.list[k]; + + /* check temp vars */ + if (let->val && let->val->kind == PSI_LET_TMP) { + if (!strcmp(set_var->name, let->var->name)) { + check = 1; + set_var->arg = let->var->arg; + if (!validate_set_value(data, set->val, 1, &set_var->arg, 1, &impl->decl->func, impl->decl->args->count, impl->decl->args->args, 0)) { + return 0; + } + break; + } } - set_var->arg = set_arg; - break; } } if (!check) { - data->error(PSI_WARNING, "Unknown value '%s' of `set` statement" + data->error(set_var->token, PSI_WARNING, "Unknown value '%s' of `set` statement" " for variable '$%s' of implementation '%s'", set_var->name, set->arg->var->name, impl->func->name); return 0; @@ -483,14 +856,17 @@ static inline int validate_impl_set_stmts(PSI_Data *data, impl *impl) { return 1; } static inline decl *locate_free_decl(decls *decls, free_call *f) { - size_t i; + if (decls) { + size_t i; - for (i = 0; i < decls->count; ++i) { - if (!strcmp(decls->list[i]->func->var->name, f->func)) { - f->decl = decls->list[i]; - return decls->list[i]; + for (i = 0; i < decls->count; ++i) { + if (!strcmp(decls->list[i]->func->var->name, f->func)) { + f->decl = decls->list[i]; + return decls->list[i]; + } } } + return NULL; } static inline int validate_impl_free_stmts(PSI_Data *data, impl *impl) { @@ -504,12 +880,15 @@ static inline int validate_impl_free_stmts(PSI_Data *data, impl *impl) { /* first find the decl of the free func */ if (!locate_free_decl(data->decls, free_call)) { - data->error(PSI_WARNING, "Unknown function '%s' in `free` statement" - " of implementation '%s'", free_call->func, impl->func->name); + data->error(free_call->token, PSI_WARNING, + "Missing declaration '%s' in `free` statement" + " of implementation '%s'", + free_call->func, impl->func->name); return 0; } if (!impl->decl->args) { - data->error(PSI_WARNING, "Declaration '%s' of implementation '%s'" + data->error(free_call->token, PSI_WARNING, + "Declaration '%s' of implementation '%s'" " does not have any arguments to free", impl->decl->func->var->name, impl->func->name); } @@ -530,7 +909,8 @@ static inline int validate_impl_free_stmts(PSI_Data *data, impl *impl) { } if (!check) { - data->error(PSI_WARNING, "Unknown variable '%s' of `free` statement" + data->error(free_var->token, PSI_WARNING, + "Unknown variable '%s' of `free` statement" " of implementation '%s'", free_var->name, impl->func->name); return 0; @@ -542,7 +922,8 @@ static inline int validate_impl_free_stmts(PSI_Data *data, impl *impl) { } static inline int validate_impl_stmts(PSI_Data *data, impl *impl) { if (!impl->stmts) { - data->error(PSI_WARNING, "Missing body for implementation %s!", + data->error(impl->func->token, PSI_WARNING, + "Missing body for implementation %s!", impl->func->name); return 0; } @@ -566,8 +947,12 @@ static inline int validate_impl_stmts(PSI_Data *data, impl *impl) { PSI_Context *PSI_ContextInit(PSI_Context *C, PSI_ContextOps *ops, PSI_ContextErrorFunc error) { - size_t i, j; + size_t i; PSI_Data T; + struct psi_predef_type *predef_type; + struct psi_predef_const *predef_const; + struct psi_predef_struct *predef_struct; + struct psi_predef_decl *predef_decl; if (!C) { C = malloc(sizeof(*C)); @@ -576,55 +961,92 @@ PSI_Context *PSI_ContextInit(PSI_Context *C, PSI_ContextOps *ops, PSI_ContextErr C->error = error; C->ops = ops; - ops->init(C); + + if (ops->init) { + ops->init(C); + } + + ZEND_ASSERT(ops->call != NULL); + ZEND_ASSERT(ops->compile != NULL); /* build up predefs in a temporary PSI_Data for validation */ memset(&T, 0, sizeof(T)); T.error = error; - for (i = 0; i < psi_predef_type_count(); ++i) { - const psi_predef_type *pre = &psi_predef_types[i]; - decl_type *type = init_decl_type(pre->type_tag, pre->type_name); - decl_typedef *def = init_decl_typedef(pre->alias, type); + for (predef_type = &psi_predef_types[0]; predef_type->type_tag; ++predef_type) { + decl_type *type = init_decl_type(predef_type->type_tag, predef_type->type_name); + decl_typedef *def = init_decl_typedef(predef_type->alias, type); T.defs = add_decl_typedef(T.defs, def); } - for (i = 0; i < psi_predef_const_count(); ++i) { - const psi_predef_const *pre = &psi_predef_consts[i]; - impl_def_val *val = init_impl_def_val(pre->val_type_tag, pre->val_text); - const_type *type = init_const_type(pre->type_tag, pre->type_name); - constant *constant = init_constant(type, pre->name, val); + for (predef_const = &psi_predef_consts[0]; predef_const->type_tag; ++predef_const) { + impl_def_val *val = init_impl_def_val(predef_const->val_type_tag, predef_const->val_text); + const_type *type = init_const_type(predef_const->type_tag, predef_const->type_name); + constant *constant = init_constant(type, predef_const->var_name, val); T.consts = add_constant(T.consts, constant); } - for (i = 0; i < psi_predef_struct_count(); ++i) { - const psi_predef_struct *pre = &psi_predef_structs[i]; + for (predef_struct = &psi_predef_structs[0]; predef_struct->type_tag; ++predef_struct) { + struct psi_predef_struct *member; decl_args *dargs = init_decl_args(NULL); - decl_struct *dstruct; + decl_struct *dstruct = init_decl_struct(predef_struct->var_name, dargs); - for (j = 0; j < PSI_PREDEF_STRUCT_MEMBERS; ++j) { - const psi_predef_struct_member *member = &pre->members[j]; + dstruct->size = predef_struct->size; + for (member = &predef_struct[1]; member->type_tag; ++member) { decl_type *type; decl_var *dvar; decl_arg *darg; - if (!member->name) { - break; - } - type = init_decl_type(member->type_tag, member->type_name); - dvar = init_decl_var(member->name, member->pointer_level, member->array_size); + dvar = init_decl_var(member->var_name, member->pointer_level, member->array_size); darg = init_decl_arg(type, dvar); - darg->layout = init_decl_struct_layout(member->off, member->len); + darg->layout = init_decl_struct_layout(member->offset, member->size); dargs = add_decl_arg(dargs, darg); } - dstruct = init_decl_struct(pre->name, dargs); - dstruct->size = pre->size; T.structs = add_decl_struct(T.structs, dstruct); + predef_struct = member; + } + for (predef_decl = &psi_predef_decls[0]; predef_decl->type_tag; ++predef_decl) { + struct psi_predef_decl *farg; + decl_type *ftype = init_decl_type(predef_decl->type_tag, predef_decl->type_name); + decl_var *fname = init_decl_var(predef_decl->var_name, predef_decl->pointer_level, predef_decl->array_size); + decl_arg *func = init_decl_arg(ftype, fname); + decl_args *args = init_decl_args(NULL); + decl *decl = init_decl(init_decl_abi("default"), func, args); + + for (farg = &predef_decl[1]; farg->type_tag; ++farg) { + decl_type *arg_type = init_decl_type(farg->type_tag, farg->type_name); + decl_var *arg_var = init_decl_var(farg->var_name, farg->pointer_level, farg->array_size); + decl_arg *darg = init_decl_arg(arg_type, arg_var); + args = add_decl_arg(args, darg); + } + + T.decls = add_decl(T.decls, decl); + predef_decl = farg; + } + + for (predef_decl = &psi_predef_vararg_decls[0]; predef_decl->type_tag; ++predef_decl) { + struct psi_predef_decl *farg; + decl_type *ftype = init_decl_type(predef_decl->type_tag, predef_decl->type_name); + decl_var *fname = init_decl_var(predef_decl->var_name, predef_decl->pointer_level, predef_decl->array_size); + decl_arg *func = init_decl_arg(ftype, fname); + decl_args *args = init_decl_args(NULL); + decl *decl = init_decl(init_decl_abi("default"), func, args); + + for (farg = &predef_decl[1]; farg->type_tag; ++farg) { + decl_type *arg_type = init_decl_type(farg->type_tag, farg->type_name); + decl_var *arg_var = init_decl_var(farg->var_name, farg->pointer_level, farg->array_size); + decl_arg *darg = init_decl_arg(arg_type, arg_var); + args = add_decl_arg(args, darg); + } + args->varargs = 1; + + T.decls = add_decl(T.decls, decl); + predef_decl = farg; } - for (i = 0; i < psi_predef_type_count(); ++i) { + for (i = 0; i < T.defs->count; ++i) { decl_typedef *def = T.defs->list[i]; if (validate_decl_typedef(&T, def)) { @@ -632,7 +1054,7 @@ PSI_Context *PSI_ContextInit(PSI_Context *C, PSI_ContextOps *ops, PSI_ContextErr } } - for (i = 0; i < psi_predef_const_count(); ++i) { + for (i = 0; i < T.consts->count; ++i) { constant *constant = T.consts->list[i]; if (validate_constant(&T, constant)) { @@ -640,7 +1062,7 @@ PSI_Context *PSI_ContextInit(PSI_Context *C, PSI_ContextOps *ops, PSI_ContextErr } } - for (i = 0; i < psi_predef_struct_count(); ++i) { + for (i = 0; i < T.structs->count; ++i) { decl_struct *dstruct = T.structs->list[i]; if (validate_decl_struct(&T, dstruct)) { @@ -648,6 +1070,14 @@ PSI_Context *PSI_ContextInit(PSI_Context *C, PSI_ContextOps *ops, PSI_ContextErr } } + for (i = 0; i < T.decls->count; ++i) { + decl *decl = T.decls->list[i]; + + if (validate_decl(&T, NULL, decl)) { + C->decls = add_decl(C->decls, decl); + } + } + C->count = 1; C->data = malloc(sizeof(*C->data)); PSI_DataExchange(C->data, &T); @@ -730,7 +1160,7 @@ static int psi_select_dirent(const struct dirent *entry) void PSI_ContextBuild(PSI_Context *C, const char *paths) { - int i, n; + int i, n, flags = psi_check_env("PSI_DEBUG") ? PSI_PARSER_DEBUG : 0; char *sep = NULL, *cpy = strdup(paths), *ptr = cpy; struct dirent **entries = NULL; @@ -750,18 +1180,22 @@ void PSI_ContextBuild(PSI_Context *C, const char *paths) PSI_Parser P; if (MAXPATHLEN <= slprintf(psi, MAXPATHLEN, "%s/%s", ptr, entries[i]->d_name)) { - C->error(PSI_WARNING, "Path to PSI file too long: %s/%s", + C->error(NULL, PSI_WARNING, "Path to PSI file too long: %s/%s", ptr, entries[i]->d_name); } - if (!PSI_ParserInit(&P, psi, C->error, 0)) { - C->error(PSI_WARNING, "Failed to init PSI parser (%s): %s", + if (!PSI_ParserInit(&P, psi, C->error, flags)) { + C->error(NULL, PSI_WARNING, "Failed to init PSI parser (%s): %s", psi, strerror(errno)); continue; } - while (-1 != PSI_ParserScan(&P)) { + while (0 < PSI_ParserScan(&P)) { PSI_ParserParse(&P, PSI_TokenAlloc(&P)); - }; + if (P.num == PSI_T_EOF) { + break; + } + } + PSI_ParserParse(&P, NULL); PSI_ContextValidate(C, &P); PSI_ParserDtor(&P); @@ -780,7 +1214,7 @@ void PSI_ContextBuild(PSI_Context *C, const char *paths) if (PSI_ContextCompile(C) && SUCCESS != zend_register_functions(NULL, C->closures, NULL, MODULE_PERSISTENT)) { - C->error(PSI_WARNING, "Failed to register functions!"); + C->error(NULL, PSI_WARNING, "Failed to register functions!"); } free(cpy); @@ -818,30 +1252,315 @@ zend_function_entry *PSI_ContextCompile(PSI_Context *C) } } - return C->closures = C->ops->compile(C); } -void PSI_ContextCall(PSI_Context *C, impl_val *ret_val, decl *decl, impl_val **args) +void PSI_ContextCall(PSI_Context *C, decl_callinfo *decl_call, impl_vararg *va) { - C->ops->call(C, ret_val, decl, args); + C->ops->call(C, decl_call, va); +} + +static inline void dump_decl_type(int fd, decl_type *t) { + const char *pre; + + switch (t->type) { + case PSI_T_STRUCT: + pre = "struct "; + break; + default: + pre = ""; + } + dprintf(fd, "%s%s", pre, t->name); +} +static inline void dump_decl_var(int fd, decl_var *v) { + dprintf(fd, "%.*s%s", v->pointer_level-!!v->array_size, "**********", v->name); + if (v->array_size) { + dprintf(fd, "[%u]", v->array_size); + } +} +static inline void dump_decl_arg(int fd, decl_arg *a) { + dump_decl_type(fd, a->type); + dprintf(fd, " "); + dump_decl_var(fd, a->var); +} +static inline void dump_level(int fd, unsigned level) { + dprintf(fd, "%.*s", level, "\t\t\t\t\t\t\t\t\t"); +} +static inline void dump_num_exp(int fd, num_exp *exp) { + while (exp) { + switch (exp->t) { + case PSI_T_NUMBER: + dprintf(fd, "%s", exp->u.numb); + break; + case PSI_T_NSNAME: + dprintf(fd, "%s", exp->u.cnst->name); + break; + case PSI_T_NAME: + dump_decl_var(fd, exp->u.dvar); + break; + EMPTY_SWITCH_DEFAULT_CASE(); + } + if (exp->operand) { + char op; + + switch (exp->operator) { + case PSI_T_PLUS: op = '+'; break; + case PSI_T_MINUS: op = '-'; break; + case PSI_T_ASTERISK:op = '*'; break; + case PSI_T_SLASH: op = '/'; break; + EMPTY_SWITCH_DEFAULT_CASE(); + } + dprintf(fd, " %c ", op); + } + exp = exp->operand; + } +} + +static inline void dump_impl_set_value(int fd, set_value *set, unsigned level) { + size_t i, j; + + if (level > 1) { + /* only if not directly after `set ...` */ + dump_level(fd, level); + } + + if (set->func->type == PSI_T_ELLIPSIS) { + dprintf(fd, "%s(", set->outer.set->func->name); + } else { + dprintf(fd, "%s(", set->func->name); + } + + for (i = 0; i < set->vars->count; ++i) { + decl_var *svar = set->vars->vars[i]; + if (i) { + dprintf(fd, ", "); + } + dump_decl_var(fd, svar); + } + + if (set->func->type == PSI_T_ELLIPSIS) { + dprintf(fd, ", ..."); + } + if (set->num) { + dprintf(fd, ", "); + dump_num_exp(fd, set->num); + } + if (set->inner) { + dprintf(fd, ",\n"); + for (i = 0; i < set->count; ++i) { + dump_impl_set_value(fd, set->inner[i], level+1); + } + /* only if inner stmts, i.e. with new lines, were dumped */ + dump_level(fd, level); + } + if (level > 1) { + dprintf(fd, "),\n"); + } else { + dprintf(fd, ");\n"); + } +} +void PSI_ContextDump(PSI_Context *C, int fd) +{ + size_t i, j, k, l; + +#ifdef HAVE_LIBJIT + if (C->ops == PSI_Libjit()) { + dprintf(fd, "// psi.engine=jit\n"); + } +#endif +#ifdef HAVE_LIBFFI + if (C->ops == PSI_Libffi()) { + dprintf(fd, "// psi.engine=ffi\n"); + } +#endif + dprintf(fd, "\n"); + + if (C->defs) { + for (i = 0; i < C->defs->count; ++i) { + decl_typedef *tdef = C->defs->list[i]; + + dprintf(fd, "typedef "); + dump_decl_type(fd, tdef->type); + dprintf(fd, " %s;\n", tdef->alias); + } + dprintf(fd, "\n"); + } + + if (C->structs) { + for (i = 0; i < C->structs->count; ++i) { + decl_struct *strct = C->structs->list[i]; + + dprintf(fd, "struct %s::(%zu) {\n", strct->name, strct->size); + if (strct->args) for (j = 0; j < strct->args->count; ++j) { + decl_arg *sarg = strct->args->args[j]; + + dprintf(fd, "\t"); + dump_decl_arg(fd, sarg); + dprintf(fd, "::(%zu, %zu);\n", sarg->layout->pos, sarg->layout->len); + } + dprintf(fd, "}\n"); + } + dprintf(fd, "\n"); + } + if (C->consts) { + for (i = 0; i < C->consts->count; ++i) { + constant *cnst = C->consts->list[i]; + + dprintf(fd, "const %s %s = ", cnst->type->name, cnst->name); + if (cnst->val->type == PSI_T_QUOTED_STRING) { + dprintf(fd, "\"%s\";\n", cnst->val->text); + } else { + dprintf(fd, "%s;\n", cnst->val->text); + } + } + dprintf(fd, "\n"); + } + if (C->decls) { + for (i = 0; i < C->decls->count; ++i) { + decl *decl = C->decls->list[i]; + + dprintf(fd, "%s ", decl->abi->convention); + dump_decl_arg(fd, decl->func); + dprintf(fd, "("); + if (decl->args) { + for (j = 0; j < decl->args->count; ++j) { + if (j) { + dprintf(fd, ", "); + } + dump_decl_arg(fd, decl->args->args[j]); + } + if (decl->args->varargs) { + dprintf(fd, ", ..."); + } + } + dprintf(fd, ");\n"); + } + dprintf(fd, "\n"); + } + if (C->impls) { + for (i = 0; i < C->impls->count; ++i) { + impl *impl = C->impls->list[i]; + + dprintf(fd, "function %s(", impl->func->name); + if (impl->func->args) { + for (j = 0; j < impl->func->args->count; ++j) { + impl_arg *iarg = impl->func->args->args[j]; + + dprintf(fd, "%s%s %s$%s", + j ? ", " : "", + iarg->type->name, + iarg->var->reference ? "&" : "", + iarg->var->name); + if (iarg->def) { + dprintf(fd, " = %s", iarg->def->text); + } + } + if (impl->func->args->vararg.name) { + impl_arg *vararg = impl->func->args->vararg.name; + + dprintf(fd, ", %s %s...$%s", + vararg->type->name, + vararg->var->reference ? "&" : "", + vararg->var->name); + } + } + dprintf(fd, ") : %s%s {\n", + impl->func->return_reference ? "&":"", + impl->func->return_type->name); + if (impl->stmts) { + for (j = 0; j < impl->stmts->let.count; ++j) { + let_stmt *let = impl->stmts->let.list[j]; + + dprintf(fd, "\tlet %s", let->var->name); + if (let->val) { + dprintf(fd, " = %s", let->val->flags.one.is_reference ? "&" : ""); + switch (let->val->kind) { + case PSI_LET_NULL: + dprintf(fd, "NULL"); + break; + case PSI_LET_TMP: + dump_decl_var(fd, let->val->data.var); + break; + case PSI_LET_CALLOC: + dprintf(fd, "calloc("); + dump_num_exp(fd, let->val->data.alloc->nmemb); + dprintf(fd, ", "); + dump_num_exp(fd, let->val->data.alloc->size); + dprintf(fd, ")"); + break; + case PSI_LET_FUNC: + dprintf(fd, "%s($%s)", let->val->data.func->name, + let->val->data.func->var->name); + break; + + EMPTY_SWITCH_DEFAULT_CASE(); + } + dprintf(fd, ";\n"); + } + } + for (j = 0; j < impl->stmts->ret.count; ++j) { + return_stmt *ret = impl->stmts->ret.list[j]; + + dprintf(fd, "\treturn "); + dump_impl_set_value(fd, ret->set, 1); + } + for (j = 0; j < impl->stmts->set.count; ++j) { + set_stmt *set = impl->stmts->set.list[j]; + + dprintf(fd, "\tset $%s = ", set->var->name); + dump_impl_set_value(fd, set->val, 1); + } + for (j = 0; j < impl->stmts->fre.count; ++j) { + free_stmt *fre = impl->stmts->fre.list[j]; + + dprintf(fd, "\tfree "); + for (k = 0; k < fre->calls->count; ++k) { + free_call *call = fre->calls->list[k]; + + if (k) { + dprintf(fd, ", "); + } + dprintf(fd, "%s(", call->func); + for (l = 0; l < call->vars->count; ++l) { + decl_var *fvar = call->vars->vars[l]; + + dump_decl_var(fd, fvar); + } + dprintf(fd, ");\n"); + } + } + } + dprintf(fd, "}\n"); + } + dprintf(fd, "\n"); + } } void PSI_ContextDtor(PSI_Context *C) { size_t i; + zend_function_entry *zfe; - C->ops->dtor(C); + if (C->ops->dtor) { + C->ops->dtor(C); + } free_decl_libs(&C->psi.libs); - for (i = 0; i < C->count; ++i) { - PSI_DataDtor(&C->data[i]); + if (C->data) { + for (i = 0; i < C->count; ++i) { + PSI_DataDtor(&C->data[i]); + } + free(C->data); } - free(C->data); - free(C->closures); + if (C->closures) { + for (zfe = C->closures; zfe->fname; ++zfe) { + free((void *) zfe->arg_info); + } + free(C->closures); + } if (C->consts) { if (C->consts->list) {