+ struct psi_func_redir *redir;
+
+ if (!strcmp(func->var->name, "dlsym")) {
+ data->error(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->call.sym = dlsym(dl ?: RTLD_NEXT, func->var->name);
+ if (!decl->call.sym) {
+ data->error(PSI_WARNING, "Failed to locate symbol '%s': %s",
+ func->var->name, dlerror());
+ }
+ }
+ return 1;
+}
+
+static inline int validate_decl(PSI_Data *data, void *dl, decl *decl) {
+ if (!validate_decl_abi(data, decl->abi)) {
+ return 0;
+ }
+ if (!validate_decl_func(data, dl, decl, decl->func)) {
+ return 0;
+ }
+ if (decl->args) {
+ size_t i;
+
+ for (i = 0; i < decl->args->count; ++i) {
+ if (!validate_decl_arg(data, decl->args->args[i])) {
+ return 0;
+ }
+ }
+ }
+ return 1;
+}
+static inline decl_arg *locate_decl_var_arg(decl_var *var, decl_args *args) {
+ size_t i;
+
+ for (i = 0; i < args->count; ++i) {
+ decl_arg *arg = args->args[i];
+
+ if (!strcmp(var->name, arg->var->name)) {
+ ZEND_ASSERT(!var->arg || var->arg == arg);
+ return var->arg = arg;
+ }
+ }
+
+ 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);
+ }
+
+ return NULL;
+}
+static inline int validate_set_value(PSI_Data *data, set_value *set, decl_arg *ref, decl_args *ref_list) {
+ size_t i;
+ decl_type *ref_type = real_decl_type(ref->type);
+ decl_var *set_var = set->vars->vars[0];
+
+ switch (set->func->type) {
+ case PSI_T_TO_BOOL:
+ set->func->handler = psi_to_bool;
+ break;
+ case PSI_T_TO_INT:
+ set->func->handler = psi_to_int;
+ break;
+ case PSI_T_TO_FLOAT:
+ set->func->handler = psi_to_double;
+ break;
+ case PSI_T_TO_STRING:
+ set->func->handler = psi_to_string;
+ break;
+ case PSI_T_TO_ARRAY:
+ set->func->handler = psi_to_array;
+ break;
+ case PSI_T_TO_OBJECT:
+ set->func->handler = psi_to_object;
+ break;
+ case PSI_T_VOID:
+ set->func->handler = psi_to_void;
+ break;
+ EMPTY_SWITCH_DEFAULT_CASE();
+ }
+
+ for (i = 1; i < set->vars->count; ++i) {
+ if (!locate_decl_var_arg(set->vars->vars[i], ref_list)) {
+ return 0;
+ }
+ }
+ set_var->arg = ref;
+
+ 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(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 (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);
+
+ set->inner[i]->outer.set = set;
+ if (sub_ref) {
+ if (!validate_set_value(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);
+
+ set->inner[0]->outer.set = set;
+ if (sub_ref) {
+ if (strcmp(sub_var->name, set_var->name)) {
+ data->error(E_WARNING, "Inner `set` statement casts on pointers must reference the same variable");
+ return 0;
+ }
+ if (!validate_set_value(data, set->inner[0], sub_ref, ref_list)) {
+ return 0;
+ }
+ }
+ } else if (set->count > 1) {
+ data->error(E_WARNING, "Inner `set` statement casts on pointers may only occur once");
+ return 0;
+ }
+
+ return 1;
+}
+static inline decl *locate_impl_decl(decls *decls, return_stmt *ret) {
+ 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];
+ }
+ }
+ }
+
+ return NULL;
+}
+static inline int validate_impl_ret_stmt(PSI_Data *data, impl *impl) {
+ return_stmt *ret;
+
+ /* we must have exactly one ret stmt delcaring the native func to call */
+ /* 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;"
+ " found %zu, exactly one is needed",
+ impl->func->name, impl->stmts->ret.count);
+ } else {
+ data->error(PSI_WARNING, "Missing `return` statement for implementation %s",
+ impl->func->name);
+ }
+ return 0;
+ }
+
+ 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);
+ return 0;
+ }
+
+ if (!validate_set_value(data, ret->set, ret->decl, impl->decl->args)) {
+ return 0;
+ }
+
+ impl->decl->impl = impl;
+
+ return 1;
+}
+static inline constant *locate_num_exp_constant(num_exp *exp, constants *consts) {
+ size_t i;
+
+ 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, impl *impl, num_exp *exp) {
+ switch (exp->t) {
+ case PSI_T_NAME:
+ if (!locate_decl_var_arg(exp->u.dvar, impl->decl->args)) {
+ data->error(PSI_WARNING, "Unknown variable '%s' in numeric expression"
+ " of implementation '%s'", exp->u.dvar->name, impl->func->name);
+ return 0;
+ }
+ return 1;
+ case PSI_T_NSNAME:
+ if (!locate_num_exp_constant(exp, data->consts)) {
+ data->error(PSI_WARNING, "Unknown constant '%s' in numeric expression"
+ " of implementation '%s'", exp->u.numb, impl->func->name);
+ return 0;
+ }
+ return 1;
+ case PSI_T_NUMBER:
+ return 1;
+ default:
+ return 0;
+ }
+}
+static inline int validate_impl_let_stmts(PSI_Data *data, impl *impl) {