flush

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

diff --git a/src/module.c b/src/module.c
index 53079d0a1293771ea8b74001595224a7f6ef1350..9d97a3ec29b6de98463dbbb8ae12efe1bd8c2ec4 100644 (file)
--- a/src/module.c
+++ b/src/module.c
@@ -286,7 +286,7 @@ void psi_to_string(zval *return_value, set_value *set, impl_val *ret_val)
                        ret_val = deref_impl_val(ret_val, var);
                        if (ret_val && ret_val->ptr) {
                                if (set->num) {
-                                       RETVAL_STRINGL(ret_val->ptr, psi_long_num_exp(set->num, NULL));
+                                       RETVAL_STRINGL(ret_val->ptr, psi_long_num_exp(set->num, set->outer.val));
                                } else {
                                        RETVAL_STRING(ret_val->ptr);
                                }
@@ -514,10 +514,10 @@ static inline ZEND_RESULT_CODE psi_parse_args(zend_execute_data *execute_data, i
                if (i < EX_NUM_ARGS()) {
                        iarg->_zv = ++zarg;
                        ZVAL_DEREF(iarg->_zv);
-                       if (iarg->var->reference) {
-                               zval_dtor(iarg->_zv);
-                               ZVAL_NULL(iarg->_zv);
-                       }
+//                     if (iarg->var->reference) {
+//                             zval_dtor(iarg->_zv);
+//                             ZVAL_NULL(iarg->_zv);
+//                     }
                }
 
                if (iarg->def) {
@@ -598,26 +598,25 @@ static inline void *psi_do_calloc(let_calloc *alloc)
 static inline void *psi_do_let(let_stmt *let)
 {
        decl_arg *darg = let->var->arg;
-       impl_arg *iarg = darg->let->arg;
        impl_val *arg_val = darg->ptr;
 
-       if (!iarg) {
-               /* let foo = calloc(1, long);
-                * let foo = NULL;
-                * let foo;
-                */
-               if (darg->let->val->func && darg->let->val->func->type == PSI_T_CALLOC) {
-                       arg_val->ptr = psi_do_calloc(darg->let->val->func->alloc);
-                       darg->mem = arg_val->ptr;
-               } else if (darg->var->array_size) {
+       if (!let->val) {
+               if (darg->var->array_size) {
                        arg_val->ptr = ecalloc(darg->var->array_size, sizeof(*arg_val));
                        darg->mem = arg_val->ptr;
                } else {
                        memset(arg_val, 0, sizeof(*arg_val));
                }
+       } else if (let->val->num) {
+               arg_val->zend.lval = psi_long_num_exp(darg->let->val->num, NULL);
        } else {
+               impl_arg *iarg = darg->let->arg;
 
-               switch (darg->let->val->func->type) {
+               switch (let->val->func->type) {
+               case PSI_T_CALLOC:
+                       arg_val->ptr = psi_do_calloc(let->val->func->alloc);
+                       darg->mem = arg_val->ptr;
+                       break;
                case PSI_T_BOOLVAL:
                        if (iarg->type->type == PSI_T_BOOL) {
                                arg_val->cval = iarg->val.zend.bval;
@@ -698,6 +697,7 @@ static inline void *psi_do_let(let_stmt *let)
 
 static inline void psi_do_set(zval *return_value, set_value *set)
 {
+       zval_dtor(return_value);
        set->func->handler(return_value, set, set->vars->vars[0]->arg->ptr);
 }
 
@@ -706,11 +706,6 @@ static inline void psi_do_return(zval *return_value, return_stmt *ret)
        ret->set->func->handler(return_value, ret->set, ret->set->vars->vars[0]->arg->ptr);
 }
 
-static inline void psi_do_return2(zval *return_value, return_stmt *ret, impl_val *ret_val)
-{
-       ret->set->func->handler(return_value, ret->set, ret_val);
-}
-
 static inline void psi_do_free(free_stmt *fre)
 {
        size_t i, j;
@@ -766,8 +761,8 @@ static inline void psi_do_clean(impl *impl)
        }
 }
 
-static inline int psi_calc_num_exp_value(num_exp *exp, impl_val *ref, impl_val *res) {
-       impl_val *tmp = NULL;
+static inline int psi_calc_num_exp_value(num_exp *exp, impl_val *strct, impl_val *res) {
+       impl_val *ref, *tmp = NULL;
 
        switch (exp->t) {
        case PSI_T_NUMBER:
@@ -793,10 +788,10 @@ static inline int psi_calc_num_exp_value(num_exp *exp, impl_val *ref, impl_val *
                break;
 
        case PSI_T_NAME:
-               if (1) {
-                       ref = exp->u.dvar->arg->ptr;
+               if (strct) {
+                       ref = struct_member_ref(exp->u.dvar->arg, strct, &tmp);
                } else {
-                       ref = struct_member_ref(exp->u.dvar->arg, ref, &tmp);
+                       ref = exp->u.dvar->arg->ptr;
                }
                switch (real_decl_type(exp->u.dvar->arg->type)->type) {
                case PSI_T_INT8:
@@ -830,13 +825,13 @@ static inline int psi_calc_num_exp_value(num_exp *exp, impl_val *ref, impl_val *
        return  0;
 }
 
-int psi_calc_num_exp(num_exp *exp, impl_val *ref, impl_val *res) {
+int psi_calc_num_exp(num_exp *exp, impl_val *strct, impl_val *res) {
        impl_val num = {0};
-       int num_type = psi_calc_num_exp_value(exp, ref, &num);
+       int num_type = psi_calc_num_exp_value(exp, strct, &num);
 
        if (exp->operand) {
                impl_val tmp = {0};
-               int tmp_type = psi_calc_num_exp(exp->operand, ref, &tmp);
+               int tmp_type = psi_calc_num_exp(exp->operand, strct, &tmp);
 
                return exp->calculator(num_type, &num, tmp_type, &tmp, res);
        }