struct member fixes

[m6w6/ext-psi] / src / module.c

diff --git a/src/module.c b/src/module.c
index 152c949dabedd873dc9076a62ea96ea2aa54536b..5a44593af95a64401236d4a4766171ccd1e913ca 100644 (file)
--- a/src/module.c
+++ b/src/module.c
@@ -23,6 +23,8 @@
 # define PSI_ENGINE "ffi"
 #endif
 
+#include <ndbm.h>
+
 ZEND_DECLARE_MODULE_GLOBALS(psi);
 
 PHP_INI_BEGIN()
@@ -106,6 +108,15 @@ size_t psi_t_align(token_t t, size_t s)
        return ((s - 1) | (a - 1)) + 1;
 }
 
+size_t psi_offset_padding(size_t diff, size_t alignment)
+{
+       if (diff && diff <= ((diff - 1) | (alignment -1)) + 1) {
+               diff = 0;
+       }
+
+       return diff;
+}
+
 int psi_internal_type(impl_type *type)
 {
        switch (type->type) {
@@ -144,6 +155,7 @@ zend_internal_arg_info *psi_internal_arginfo(impl *impl)
                zend_internal_arg_info *ai = &aip[impl->func->args->count];
 
                ai->name = vararg->var->name;
+               ai->allow_null = 1;
                ai->type_hint = psi_internal_type(vararg->type);
                if (vararg->var->reference) {
                        ai->pass_by_reference = 1;
@@ -160,9 +172,9 @@ zend_internal_arg_info *psi_internal_arginfo(impl *impl)
                if (iarg->var->reference) {
                        ai->pass_by_reference = 1;
                }
-               if (iarg->var->reference || (iarg->def && iarg->def->type == PSI_T_NULL)) {
+               //if (iarg->var->reference || (iarg->def && iarg->def->type == PSI_T_NULL)) {
                        ai->allow_null = 1;
-               }
+               //}
        }
 
        return aip;
@@ -349,6 +361,7 @@ void psi_from_zval(impl_val *mem, decl_arg *spec, zval *zv, void **tmp)
        case PSI_T_DOUBLE:
                mem->dval = zval_get_double(zv);
                break;
+       case PSI_T_VOID:
        case PSI_T_INT8:
        case PSI_T_UINT8:
                if (spec->var->pointer_level) {
@@ -608,7 +621,7 @@ static inline void *psi_do_calloc(let_calloc *alloc)
        return mem;
 }
 
-static inline ZEND_RESULT_CODE psi_let_val(token_t let_func, impl_arg *iarg, impl_val *arg_val, decl_struct *strct, void **to_free)
+static inline impl_val *psi_let_val(token_t let_func, impl_arg *iarg, impl_val *arg_val, decl_struct *strct, void **to_free)
 {
        switch (let_func) {
        case PSI_T_BOOLVAL:
@@ -636,7 +649,7 @@ static inline ZEND_RESULT_CODE psi_let_val(token_t let_func, impl_arg *iarg, imp
        case PSI_T_STRVAL:
                if (iarg->type->type == PSI_T_STRING) {
                        if (iarg->val.zend.str) {
-                               arg_val->ptr = estrdup(iarg->val.zend.str->val);
+                               arg_val->ptr = estrndup(iarg->val.zend.str->val, iarg->val.zend.str->len);
                                *to_free = arg_val->ptr;
                        } else {
                                arg_val->ptr = "";
@@ -650,7 +663,7 @@ static inline ZEND_RESULT_CODE psi_let_val(token_t let_func, impl_arg *iarg, imp
                if (PSI_T_PATHVAL == let_func) {
                        if (SUCCESS != php_check_open_basedir(arg_val->ptr)) {
                                efree(arg_val->ptr);
-                               return FAILURE;
+                               return NULL;
                        }
                }
                break;
@@ -669,8 +682,8 @@ static inline ZEND_RESULT_CODE psi_let_val(token_t let_func, impl_arg *iarg, imp
                break;
        case PSI_T_ARRVAL:
                if (iarg->type->type == PSI_T_ARRAY) {
-                       arg_val->ptr = psi_array_to_struct(strct, HASH_OF(iarg->_zv));
-                       *to_free = arg_val->ptr;
+                       arg_val = psi_array_to_struct(strct, HASH_OF(iarg->_zv));
+                       *to_free = arg_val;
                }
                break;
        case PSI_T_OBJVAL:
@@ -678,7 +691,7 @@ static inline ZEND_RESULT_CODE psi_let_val(token_t let_func, impl_arg *iarg, imp
                        psi_object *obj;
 
                        if (!instanceof_function(Z_OBJCE_P(iarg->_zv), psi_class_entry)) {
-                               return FAILURE;
+                               return NULL;
                        }
 
                        obj = PSI_OBJ(iarg->_zv, NULL);
@@ -687,7 +700,7 @@ static inline ZEND_RESULT_CODE psi_let_val(token_t let_func, impl_arg *iarg, imp
                break;
        EMPTY_SWITCH_DEFAULT_CASE();
        }
-       return SUCCESS;
+       return arg_val;
 }
 
 static inline void *psi_do_let(let_stmt *let)
@@ -723,7 +736,7 @@ static inline void *psi_do_let(let_stmt *let)
        case PSI_LET_FUNC:
                iarg = let->val->data.func->arg;
 
-               if (SUCCESS != psi_let_val(let->val->data.func->type, iarg, darg->ptr, real_decl_type(darg->type)->strct, &darg->mem)) {
+               if (!(darg->ptr = psi_let_val(let->val->data.func->type, iarg, darg->ptr, real_decl_type(darg->type)->strct, &darg->mem))) {
                        return NULL;
                }
        }
@@ -758,8 +771,9 @@ static inline void psi_do_free(free_stmt *fre)
                for (j = 0; j < f->vars->count; ++j) {
                        decl_var *dvar = f->vars->vars[j];
                        decl_arg *darg = dvar->arg;
+                       impl_val *fval = darg->let ? darg->let->ptr : darg->ptr;
 
-                       f->decl->call.args[j] = &darg->val;
+                       f->decl->call.args[j] = deref_impl_val(fval, dvar);
                }
 
                /* FIXME: check in validate_* that free functions return scalar */
@@ -767,10 +781,30 @@ static inline void psi_do_free(free_stmt *fre)
        }
 }
 
+static inline void psi_clean_array_struct(decl_arg *darg) {
+       if (darg->let
+       &&      darg->let->val->kind == PSI_LET_FUNC
+       &&      darg->let->val->data.func->type == PSI_T_ARRVAL) {
+               decl_type *type = real_decl_type(darg->type);
+
+               if (type->type == PSI_T_STRUCT) {
+                       void **ptr = (void **) ((char *) darg->mem + type->strct->size);
+
+                       while (*ptr) {
+                               efree(*ptr++);
+                       }
+               }
+       }
+}
+
 static inline void psi_do_clean(impl *impl)
 {
        size_t i;
 
+       if (impl->decl->func->ptr != &impl->decl->func->val) {
+               efree(impl->decl->func->ptr);
+               impl->decl->func->ptr = &impl->decl->func->val;
+       }
        for (i = 0; i < impl->func->args->count; ++i ) {
                impl_arg *iarg = impl->func->args->args[i];
 
@@ -787,18 +821,11 @@ static inline void psi_do_clean(impl *impl)
                decl_arg *darg = impl->decl->args->args[i];
 
                if (darg->mem) {
-                       decl_type *type = real_decl_type(darg->type);
-
-                       if (type->type == PSI_T_STRUCT) {
-                               void **ptr = (void **) ((char *) darg->mem + type->strct->size);
-
-                               while (*ptr) {
-                                       efree(*ptr++);
-                               }
-                       }
+                       psi_clean_array_struct(darg);
                        efree(darg->mem);
                        darg->mem = NULL;
                }
+               darg->ptr = &darg->val;
        }
 
        if (impl->func->args->vararg.args) {
@@ -1059,6 +1086,16 @@ static inline void psi_do_args(impl *impl) {
        for (i = 0; i < impl->decl->args->count; ++i) {
                impl->decl->call.args[i] = impl->decl->args->args[i]->let->ptr;
        }
+
+       if (!impl->decl->func->var->pointer_level) {
+               decl_type *real = real_decl_type(impl->decl->func->type);
+
+               switch (real->type) {
+               case PSI_T_STRUCT:
+                       impl->decl->func->ptr = psi_array_to_struct(real->strct, NULL);
+                       break;
+               }
+       }
 }
 
 static inline impl_vararg *psi_do_varargs(impl *impl) {
@@ -1100,7 +1137,10 @@ static inline impl_vararg *psi_do_varargs(impl *impl) {
                }
 
                va->types[i] = vatype;
-               psi_let_val(let_fn, vaarg, &va->values[i], NULL, &to_free);
+               /* FIXME: varargs with struct-by-value :) */
+               if (!psi_let_val(let_fn, vaarg, &va->values[i], NULL, &to_free)) {
+                       return NULL;
+               }
 
                if (to_free) {
                        if (!va->free_list) {