flush

diff --git a/php_psi.h b/php_psi.h
index 6715c22ed51547fe45575a5f47001942b4b6e0da..85a3805811f58440d49476f81d0453b8fc6d666f 100644 (file)
--- a/php_psi.h
+++ b/php_psi.h
@@ -1,4 +1,3 @@
-

 #ifndef PHP_PSI_H
 #define PHP_PSI_H
 
 #ifndef PHP_PSI_H
 #define PHP_PSI_H
 


@@ -19,8 +18,8 @@ extern zend_module_entry psi_module_entry;
 #include "TSRM.h"
 #endif
 
 #include "TSRM.h"
 #endif
 

-#include "context.h"

 #include "parser.h"
 #include "parser.h"

+#include "context.h"

 
 void psi_error(int type, const char *msg, ...);
 
 
 void psi_error(int type, const char *msg, ...);
 


@@ -78,6 +77,7 @@ static inline zend_long psi_long_num_exp(num_exp *exp, impl_val *ref) {
        case PSI_T_DOUBLE:      return val.dval;
        EMPTY_SWITCH_DEFAULT_CASE();
        }
        case PSI_T_DOUBLE:      return val.dval;
        EMPTY_SWITCH_DEFAULT_CASE();
        }

+       return 0;

 }
 
 int psi_calc_add(int t1, impl_val *v1, int t2, impl_val *v2, impl_val *res);
 }
 
 int psi_calc_add(int t1, impl_val *v1, int t2, impl_val *v2, impl_val *res);

diff --git a/src/context.c b/src/context.c
index ac663afa0eaf5b2bfaee6ec05b9c2a8fd4175b50..1a20af9decd4b57e97757670ea9b881af33b4c62 100644 (file)
--- a/src/context.c
+++ b/src/context.c
@@ -150,10 +150,24 @@ static struct psi_predef_const {
 
 PSI_MACROS
 
 
 PSI_MACROS
 

+size_t psi_fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
+{
+       size_t rv = fread(ptr, size, nmemb, stream);
+       return rv;
+}
+
+FILE *psi_fopen(const char *path, const char *mode)
+{
+       FILE *f = fopen(path, mode);
+       return f;
+}
+

 static struct psi_func_redir {
        const char *name;
        void (*func)(void);
 } psi_func_redirs[] = {
 static struct psi_func_redir {
        const char *name;
        void (*func)(void);
 } psi_func_redirs[] = {

+               {"fopen", (void (*)(void)) psi_fopen},
+               {"fread", (void (*)(void)) psi_fread},

        PSI_REDIRS
        {0}
 };
        PSI_REDIRS
        {0}
 };


@@ -477,11 +491,7 @@ static inline int validate_num_exp(PSI_Data *data, decl_args *dargs, decl_arg *f
                return 0;
        }
 }
                return 0;
        }
 }

-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];
-
+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;
        switch (set->func->type) {
        case PSI_T_TO_BOOL:
                set->func->handler = psi_to_bool;


@@ -504,15 +514,45 @@ static inline int validate_set_value(PSI_Data *data, set_value *set, decl_arg *r
        case PSI_T_VOID:
                set->func->handler = psi_to_void;
                break;
        case PSI_T_VOID:
                set->func->handler = psi_to_void;
                break;

-       EMPTY_SWITCH_DEFAULT_CASE();
+       default:
+               return 0;
+       }
+       return 1;
+}
+static inline void decl_var_arg_v(decl_args *args, va_list argp) {
+       int argc;
+       decl_arg **argv;
+
+       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 (!validate_set_value_handler(set)) {
+               data->error(PSI_WARNING, "Invalid cast '%s'", set->func->name);
+               return 0;

        }
 
        }
 

-       for (i = 1; i < set->vars->count; ++i) {
-               if (!locate_decl_var_arg(set->vars->vars[i], ref_list, ref)) {
+       for (i = 0; i < set->vars->count; ++i) {
+               if (!locate_decl_var_arg(set->vars->vars[i], ref_list, NULL)) {
+                       data->error(PSI_WARNING, "Unknown variable '%s'", set->vars->vars[i]->name);

                        return 0;
                }
        }
                        return 0;
                }
        }

-       set_var->arg = ref;
+
+       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);
 
        if (set->count) {
                int is_to_array = (set->func->type == PSI_T_TO_ARRAY);


@@ -538,7 +578,7 @@ static inline int validate_set_value(PSI_Data *data, set_value *set, decl_arg *r
 
                        set->inner[i]->outer.set = set;
                        if (sub_ref) {
 
                        set->inner[i]->outer.set = set;
                        if (sub_ref) {

-                               if (!validate_set_value(data, set->inner[i], sub_ref, ref_type->strct->args)) {
+                               if (!validate_set_value_ex(data, set->inner[i], sub_ref, ref_type->strct->args)) {

                                        return 0;
                                }
                        }
                                        return 0;
                                }
                        }


@@ -554,7 +594,7 @@ static inline int validate_set_value(PSI_Data *data, set_value *set, decl_arg *r
                                data->error(E_WARNING, "Inner `set` statement casts on pointers must reference the same variable");
                                return 0;
                        }
                                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)) {
+                       if (!validate_set_value_ex(data, set->inner[0], sub_ref, ref_list)) {

                                return 0;
                        }
                }
                                return 0;
                        }
                }


@@ -565,6 +605,21 @@ static inline int validate_set_value(PSI_Data *data, set_value *set, decl_arg *r
 
        return 1;
 }
 
        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) {
        if (decls) {
                size_t i;
 static inline decl *locate_impl_decl(decls *decls, return_stmt *ret) {
        if (decls) {
                size_t i;


@@ -604,7 +659,7 @@ static inline int validate_impl_ret_stmt(PSI_Data *data, impl *impl) {
                return 0;
        }
 
                return 0;
        }
 

-       if (!validate_set_value(data, ret->set, ret->decl, impl->decl->args)) {
+       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;
        }
 
                return 0;
        }
 


@@ -616,6 +671,17 @@ static inline int validate_impl_ret_stmt(PSI_Data *data, impl *impl) {
 static inline int validate_impl_let_stmts(PSI_Data *data, impl *impl) {
        size_t i, j;
        /* we can have multiple let stmts */
 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];
+
+               if (!locate_decl_var_arg(let->var, impl->decl->args, impl->decl->func)) {
+                       data->error(PSI_WARNING, "Unknown variable '%s' in `let` statement"
+                                       " of implementation '%s'", let->var->name, impl->func->name);
+                       return 0;
+               }
+       }
+

        /* 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];
        /* 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];


@@ -705,7 +771,7 @@ static inline int validate_impl_set_stmts(PSI_Data *data, impl *impl) {
                                if (!strcmp(set_var->name, set_arg->var->name)) {
                                        check = 1;
                                        set_var->arg = set_arg;
                                if (!strcmp(set_var->name, set_arg->var->name)) {
                                        check = 1;
                                        set_var->arg = set_arg;

-                                       if (!validate_set_value(data, set->val, set_arg, impl->decl->args)) {
+                                       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;
                                                return 0;
                                        }
                                        break;


@@ -1101,7 +1167,6 @@ zend_function_entry *PSI_ContextCompile(PSI_Context *C)
 
 void PSI_ContextCall(PSI_Context *C, impl_val *ret_val, decl *decl)
 {
 
 void PSI_ContextCall(PSI_Context *C, impl_val *ret_val, decl *decl)
 {

-       errno = 0;

        C->ops->call(C, ret_val, decl);
 }
 
        C->ops->call(C, ret_val, decl);
 }
 


@@ -1131,6 +1196,35 @@ static inline void dump_decl_arg(int fd, decl_arg *a) {
 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_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;
 
 static inline void dump_impl_set_value(int fd, set_value *set, unsigned level) {
        size_t i;
 


@@ -1147,6 +1241,10 @@ static inline void dump_impl_set_value(int fd, set_value *set, unsigned level) {
                }
                dump_decl_var(fd, svar);
        }
                }
                dump_decl_var(fd, svar);
        }

+       if (set->num) {
+               dprintf(fd, ", ");
+               dump_num_exp(fd, set->num);
+       }

        if (set->inner) {
                dprintf(fd, ",\n");
                for (i = 0; i < set->count; ++i) {
        if (set->inner) {
                dprintf(fd, ",\n");
                for (i = 0; i < set->count; ++i) {


@@ -1161,20 +1259,6 @@ static inline void dump_impl_set_value(int fd, set_value *set, unsigned level) {
                dprintf(fd, ");\n");
        }
 }
                dprintf(fd, ");\n");
        }
 }

-static inline void dump_num_exp(int fd, num_exp *exp) {
-       switch (exp->t) {
-       case PSI_T_NUMBER:
-               dprintf(fd, "%s", exp->u.numb);
-               break;
-       case PSI_T_NAME:
-               dump_decl_var(fd, exp->u.dvar);
-               break;
-       case PSI_T_NSNAME:
-               dprintf(fd, "%s", exp->u.cnst->name);
-               break;
-       EMPTY_SWITCH_DEFAULT_CASE();
-       }
-}

 void PSI_ContextDump(PSI_Context *C, int fd)
 {
        size_t i, j, k, l;
 void PSI_ContextDump(PSI_Context *C, int fd)
 {
        size_t i, j, k, l;

diff --git a/src/module.c b/src/module.c
index b06e0bd32a8d255b2cb50bc0c01c7e5b3efa0e5f..53079d0a1293771ea8b74001595224a7f6ef1350 100644 (file)
--- a/src/module.c
+++ b/src/module.c
@@ -12,6 +12,7 @@
 
 #include "php_psi.h"
 #include "parser.h"
 
 #include "php_psi.h"
 #include "parser.h"

+#include "context.h"

 
 #if HAVE_LIBJIT
 # include "libjit.h"
 
 #if HAVE_LIBJIT
 # include "libjit.h"


@@ -66,6 +67,7 @@ size_t psi_t_alignment(token_t t)
                return ALIGNOF_VOID_P;
        EMPTY_SWITCH_DEFAULT_CASE();
        }
                return ALIGNOF_VOID_P;
        EMPTY_SWITCH_DEFAULT_CASE();
        }

+       return 0;

 }
 
 size_t psi_t_size(token_t t)
 }
 
 size_t psi_t_size(token_t t)


@@ -88,6 +90,7 @@ size_t psi_t_size(token_t t)
                return SIZEOF_VOID_P;
        EMPTY_SWITCH_DEFAULT_CASE();
        }
                return SIZEOF_VOID_P;
        EMPTY_SWITCH_DEFAULT_CASE();
        }

+       return 0;

 }
 
 size_t psi_t_align(token_t t, size_t s)
 }
 
 size_t psi_t_align(token_t t, size_t s)


@@ -282,7 +285,11 @@ void psi_to_string(zval *return_value, set_value *set, impl_val *ret_val)
                } else {
                        ret_val = deref_impl_val(ret_val, var);
                        if (ret_val && ret_val->ptr) {
                } else {
                        ret_val = deref_impl_val(ret_val, var);
                        if (ret_val && ret_val->ptr) {

-                               RETVAL_STRING(ret_val->ptr);
+                               if (set->num) {
+                                       RETVAL_STRINGL(ret_val->ptr, psi_long_num_exp(set->num, NULL));
+                               } else {
+                                       RETVAL_STRING(ret_val->ptr);
+                               }

                        } else {
                                RETVAL_EMPTY_STRING();
                        }
                        } else {
                                RETVAL_EMPTY_STRING();
                        }


@@ -426,7 +433,7 @@ void psi_to_array(zval *return_value, set_value *set, impl_val *r_val)
                zval ele;
 
                if (set->outer.set) {
                zval ele;
 
                if (set->outer.set) {

-                       /* struct *//*
+                       / * struct *//*

                        for (i = 1; i < set->vars->count; ++i) {
                                impl_val *tmp = NULL, *cnt_val;
                                decl_var *cnt_var = set->vars->vars[i];
                        for (i = 1; i < set->vars->count; ++i) {
                                impl_val *tmp = NULL, *cnt_val;
                                decl_var *cnt_var = set->vars->vars[i];


@@ -485,6 +492,8 @@ void psi_to_object(zval *return_value, set_value *set, impl_val *r_val)
 
 static inline ZEND_RESULT_CODE psi_parse_args(zend_execute_data *execute_data, impl *impl)
 {
 
 static inline ZEND_RESULT_CODE psi_parse_args(zend_execute_data *execute_data, impl *impl)
 {

+       size_t i;
+       zval *zarg = ZEND_CALL_ARG(execute_data, 0);

        impl_arg *iarg;
        zend_error_handling zeh;
 
        impl_arg *iarg;
        zend_error_handling zeh;
 


@@ -498,6 +507,39 @@ static inline ZEND_RESULT_CODE psi_parse_args(zend_execute_data *execute_data, i
                return rv;
        }
 
                return rv;
        }
 

+       /* set up defaults */
+       for (i = 0; i < impl->func->args->count; ++i) {
+               iarg = impl->func->args->args[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->def) {
+                       switch (iarg->type->type) {
+                       case PSI_T_BOOL:
+                               iarg->val.zend.bval = iarg->def->type == PSI_T_TRUE ? 1 : 0;
+                               break;
+                       case PSI_T_INT:
+                               iarg->val.zend.lval = zend_atol(iarg->def->text, strlen(iarg->def->text));
+                               break;
+                       case PSI_T_FLOAT:
+                       case PSI_T_DOUBLE:
+                               iarg->val.dval = zend_strtod(iarg->def->text, NULL);
+                               break;
+                       case PSI_T_STRING:
+                               /* FIXME */
+                               iarg->val.zend.str = zend_string_init(&iarg->def->text[1], strlen(iarg->def->text) - 2, 0);
+                               break;
+                       }
+               }
+       }
+

        ZEND_PARSE_PARAMETERS_START(psi_num_min_args(impl), impl->func->args->count)
        nextarg:
                iarg = impl->func->args->args[_i];
        ZEND_PARSE_PARAMETERS_START(psi_num_min_args(impl), impl->func->args->count)
        nextarg:
                iarg = impl->func->args->args[_i];


@@ -520,29 +562,20 @@ static inline ZEND_RESULT_CODE psi_parse_args(zend_execute_data *execute_data, i
                        }
                        Z_PARAM_DOUBLE(iarg->val.dval);
                } else if (PSI_T_STRING == iarg->type->type) {
                        }
                        Z_PARAM_DOUBLE(iarg->val.dval);
                } else if (PSI_T_STRING == iarg->type->type) {

-                       struct {char *val; size_t len;} str;
-                       if (iarg->def) {
-                               /* FIXME */
-                               str.len = strlen(iarg->def->text) - 2;
-                               str.val = &iarg->def->text[1];
-                       }
-                       Z_PARAM_STR_EX(iarg->val.zend.str, 1, 0);
-                       if (iarg->val.zend.str) {
-                               zend_string_addref(iarg->val.zend.str);
-                       } else if (iarg->def) {
-                               iarg->val.zend.str = zend_string_init(str.val, str.len, 0);
+                       zend_string *str = iarg->val.zend.str;
+                       Z_PARAM_STR_EX(iarg->val.zend.str, 1, iarg->var->reference);
+                       if (str && str != iarg->val.zend.str) {
+                               zend_string_release(str);

                        }
                } else if (PSI_T_ARRAY == iarg->type->type) {
                        }
                } else if (PSI_T_ARRAY == iarg->type->type) {

-                       /* handled as _zv in let or set */
-                       Z_PARAM_ARRAY_EX(iarg->_zv, 1, 0);
+                       Z_PARAM_PROLOGUE(0);

                } else if (PSI_T_OBJECT == iarg->type->type) {
                } else if (PSI_T_OBJECT == iarg->type->type) {

-                       Z_PARAM_OBJECT_EX(iarg->_zv, 1, 0);
+                       Z_PARAM_PROLOGUE(0);

                } else {
                        error_code = ZPP_ERROR_FAILURE;
                        break;
                }
                } else {
                        error_code = ZPP_ERROR_FAILURE;
                        break;
                }

-               iarg->_zv = _arg;
-               if (_i < _max_num_args) {
+               if (_i < _num_args) {

                        goto nextarg;
                }
        ZEND_PARSE_PARAMETERS_END_EX(
                        goto nextarg;
                }
        ZEND_PARSE_PARAMETERS_END_EX(


@@ -562,13 +595,11 @@ static inline void *psi_do_calloc(let_calloc *alloc)
        return mem;
 }
 
        return mem;
 }
 

-static inline void *psi_do_let(decl_arg *darg)
+static inline void *psi_do_let(let_stmt *let)

 {
 {

+       decl_arg *darg = let->var->arg;

        impl_arg *iarg = darg->let->arg;
        impl_arg *iarg = darg->let->arg;

-       impl_val *arg_val;
-
-       darg->let->ptr = &darg->let->out;
-       arg_val = darg->let->ptr;
+       impl_val *arg_val = darg->ptr;

 
        if (!iarg) {
                /* let foo = calloc(1, long);
 
        if (!iarg) {
                /* let foo = calloc(1, long);


@@ -577,10 +608,10 @@ static inline void *psi_do_let(decl_arg *darg)
                 */
                if (darg->let->val->func && darg->let->val->func->type == PSI_T_CALLOC) {
                        arg_val->ptr = psi_do_calloc(darg->let->val->func->alloc);
                 */
                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->let->mem = arg_val->ptr;
+                       darg->mem = arg_val->ptr;

                } else if (darg->var->array_size) {
                        arg_val->ptr = ecalloc(darg->var->array_size, sizeof(*arg_val));
                } else if (darg->var->array_size) {
                        arg_val->ptr = ecalloc(darg->var->array_size, sizeof(*arg_val));

-                       darg->let->mem = arg_val->ptr;
+                       darg->mem = arg_val->ptr;

                } else {
                        memset(arg_val, 0, sizeof(*arg_val));
                }
                } else {
                        memset(arg_val, 0, sizeof(*arg_val));
                }


@@ -605,12 +636,12 @@ static inline void *psi_do_let(decl_arg *darg)
                case PSI_T_STRVAL:
                        if (iarg->type->type == PSI_T_STRING) {
                                arg_val->ptr = estrdup(iarg->val.zend.str->val);
                case PSI_T_STRVAL:
                        if (iarg->type->type == PSI_T_STRING) {
                                arg_val->ptr = estrdup(iarg->val.zend.str->val);

-                               darg->let->mem = arg_val->ptr;
+                               darg->mem = arg_val->ptr;

                                zend_string_release(iarg->val.zend.str);
                        } else {
                                zend_string *zs = zval_get_string(iarg->_zv);
                                arg_val->ptr = estrdup(zs->val);
                                zend_string_release(iarg->val.zend.str);
                        } else {
                                zend_string *zs = zval_get_string(iarg->_zv);
                                arg_val->ptr = estrdup(zs->val);

-                               darg->let->mem = arg_val->ptr;
+                               darg->mem = arg_val->ptr;

                                zend_string_release(zs);
                        }
                        if (PSI_T_PATHVAL == darg->let->val->func->type) {
                                zend_string_release(zs);
                        }
                        if (PSI_T_PATHVAL == darg->let->val->func->type) {


@@ -637,7 +668,7 @@ static inline void *psi_do_let(decl_arg *darg)
                                switch (type->type) {
                                case PSI_T_STRUCT:
                                        arg_val->ptr = psi_array_to_struct(type->strct, HASH_OF(iarg->_zv));
                                switch (type->type) {
                                case PSI_T_STRUCT:
                                        arg_val->ptr = psi_array_to_struct(type->strct, HASH_OF(iarg->_zv));

-                                       darg->let->mem = arg_val->ptr;
+                                       darg->mem = arg_val->ptr;

                                        break;
                                }
                        }
                                        break;
                                }
                        }


@@ -659,21 +690,23 @@ static inline void *psi_do_let(decl_arg *darg)
        }
 
        if (darg->let->val && darg->let->val->is_reference) {
        }
 
        if (darg->let->val && darg->let->val->is_reference) {

-               return &darg->let->ptr;
+               return darg->let->ptr = &darg->ptr;

        } else {
        } else {

-               return darg->let->ptr;
+               return darg->let->ptr = darg->ptr;

        }
 }
 
 static inline void psi_do_set(zval *return_value, set_value *set)
 {
        }
 }
 
 static inline void psi_do_set(zval *return_value, set_value *set)
 {

-       ZVAL_DEREF(return_value);
-       zval_dtor(return_value);
+       set->func->handler(return_value, set, set->vars->vars[0]->arg->ptr);
+}

 
 

-       set->func->handler(return_value, set, set->vars->vars[0]->arg->let->ptr);
+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_return(zval *return_value, return_stmt *ret, impl_val *ret_val)
+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);
 }
 {
        ret->set->func->handler(return_value, ret->set, ret_val);
 }


@@ -690,7 +723,7 @@ static inline void psi_do_free(free_stmt *fre)
                        decl_var *dvar = f->vars->vars[j];
                        decl_arg *darg = dvar->arg;
 
                        decl_var *dvar = f->vars->vars[j];
                        decl_arg *darg = dvar->arg;
 

-                       f->decl->call.args[j] = &darg->let->out;
+                       f->decl->call.args[j] = &darg->val;

                }
 
                /* FIXME: check in validate_* that free functions return scalar */
                }
 
                /* FIXME: check in validate_* that free functions return scalar */


@@ -717,18 +750,18 @@ static inline void psi_do_clean(impl *impl)
        if (impl->decl->args) for (i = 0; i < impl->decl->args->count; ++i) {
                decl_arg *darg = impl->decl->args->args[i];
 
        if (impl->decl->args) for (i = 0; i < impl->decl->args->count; ++i) {
                decl_arg *darg = impl->decl->args->args[i];
 

-               if (darg->let && darg->let->mem) {
+               if (darg->mem) {

                        decl_type *type = real_decl_type(darg->type);
 
                        if (type->type == PSI_T_STRUCT) {
                        decl_type *type = real_decl_type(darg->type);
 
                        if (type->type == PSI_T_STRUCT) {

-                               void **ptr = (void **) ((char *) darg->let->mem + type->strct->size);
+                               void **ptr = (void **) ((char *) darg->mem + type->strct->size);

 
                                while (*ptr) {
                                        efree(*ptr++);
                                }
                        }
 
                                while (*ptr) {
                                        efree(*ptr++);
                                }
                        }

-                       efree(darg->let->mem);
-                       darg->let->mem = NULL;
+                       efree(darg->mem);
+                       darg->mem = NULL;

                }
        }
 }
                }
        }
 }


@@ -760,8 +793,8 @@ static inline int psi_calc_num_exp_value(num_exp *exp, impl_val *ref, impl_val *
                break;
 
        case PSI_T_NAME:
                break;
 
        case PSI_T_NAME:

-               if (exp->u.dvar->arg->let) {
-                       ref = exp->u.dvar->arg->let->ptr;
+               if (1) {
+                       ref = exp->u.dvar->arg->ptr;

                } else {
                        ref = struct_member_ref(exp->u.dvar->arg, ref, &tmp);
                }
                } else {
                        ref = struct_member_ref(exp->u.dvar->arg, ref, &tmp);
                }


@@ -816,14 +849,14 @@ int psi_calc_num_exp(num_exp *exp, impl_val *ref, impl_val *res) {
 #define PRIdval "lf"
 
 #define PSI_CALC_OP(var) do { \
 #define PRIdval "lf"
 
 #define PSI_CALC_OP(var) do { \

-       const char *fmt = "calc: %" PRI##var ", %" PRI##var ": %" PRI##var "\n"; \
+       const char *fmt = "calc %" PRI##var ", %" PRI##var ": %" PRI##var "\n"; \

        res->var = PSI_CALC(v1->var, v2->var); \
        res->var = PSI_CALC(v1->var, v2->var); \

-       /*fprintf(stderr, fmt, v1->var, v2->var, res->var);*/ \
+       if (!res->var) fprintf(stderr, fmt, v1->var, v2->var, res->var); \

 } while (0)
 #define PSI_CALC_OP2(vres, var1, var2) do { \
 } while (0)
 #define PSI_CALC_OP2(vres, var1, var2) do { \

-       const char *fmt = "calc: %" PRI##var1 ", %" PRI##var2 ": %" PRI##vres "\n"; \
+       const char *fmt = "calc %" PRI##var1 ", %" PRI##var2 ": %" PRI##vres "\n"; \

        res->vres = PSI_CALC(v1->var1, v2->var2); \
        res->vres = PSI_CALC(v1->var1, v2->var2); \

-       /*fprintf(stderr, fmt, v1->var1, v2->var2, res->vres);*/ \
+       if (!res->vres) fprintf(stderr, fmt, v1->var1, v2->var2, res->vres); \

 } while(0)
 #define PSI_CALC_FN(op) int psi_calc_##op(int t1, impl_val *v1, int t2, impl_val *v2, impl_val *res) \
 { \
 } while(0)
 #define PSI_CALC_FN(op) int psi_calc_##op(int t1, impl_val *v1, int t2, impl_val *v2, impl_val *res) \
 { \


@@ -961,27 +994,32 @@ PSI_CALC_FN(div)
 
 void psi_call(zend_execute_data *execute_data, zval *return_value, impl *impl)
 {
 
 void psi_call(zend_execute_data *execute_data, zval *return_value, impl *impl)
 {

-       impl_val ret_val;

        size_t i;
        size_t i;

+       return_stmt *ret = impl->stmts->ret.list[0];
+       decl_var *var = ret->set->vars->vars[0];
+
+       memset(var->arg->ptr, 0, sizeof(impl_val));

 
        if (SUCCESS != psi_parse_args(execute_data, impl)) {
                return;
        }
 
 
        if (SUCCESS != psi_parse_args(execute_data, impl)) {
                return;
        }
 

-       if (impl->decl->args) {
-               for (i = 0; i < impl->decl->args->count; ++i) {
-                       decl_arg *darg = impl->decl->args->args[i];
+       for (i = 0; i < impl->stmts->let.count; ++i) {
+               let_stmt *let = impl->stmts->let.list[i];

 
 

-                       if (!(impl->decl->call.args[i] = psi_do_let(darg))) {
-                               goto cleanup;
-                       }
+               if (!psi_do_let(let)) {
+                       psi_do_return(return_value, ret);
+                       psi_do_clean(impl);
+                       return;

                }
        }
 
                }
        }
 

-       memset(&ret_val, 0, sizeof(ret_val));
-       PSI_ContextCall(&PSI_G(context), &ret_val, impl->decl);
+       if (impl->decl->args) for (i = 0; i < impl->decl->args->count; ++i) {
+               impl->decl->call.args[i] = impl->decl->args->args[i]->let->ptr;
+       }

 
 

-       psi_do_return(return_value, impl->stmts->ret.list[0], &ret_val);
+       PSI_ContextCall(&PSI_G(context), var->arg->ptr, impl->decl);
+       psi_do_return(return_value, ret);

 
        for (i = 0; i < impl->stmts->set.count; ++i) {
                set_stmt *set = impl->stmts->set.list[i];
 
        for (i = 0; i < impl->stmts->set.count; ++i) {
                set_stmt *set = impl->stmts->set.list[i];


@@ -997,12 +1035,6 @@ void psi_call(zend_execute_data *execute_data, zval *return_value, impl *impl)
                psi_do_free(fre);
        }
        psi_do_clean(impl);
                psi_do_free(fre);
        }
        psi_do_clean(impl);

-       return;
-
-cleanup:
-       memset(&ret_val, 0, sizeof(ret_val));
-       psi_do_return(return_value, impl->stmts->ret.list[0], &ret_val);
-       psi_do_clean(impl);

 }
 
 static void psi_object_free(zend_object *o)
 }
 
 static void psi_object_free(zend_object *o)


@@ -1065,6 +1097,7 @@ PHP_MINIT_FUNCTION(psi)
 
        return SUCCESS;
 }
 
        return SUCCESS;
 }

+

 PHP_MSHUTDOWN_FUNCTION(psi)
 {
        PSI_ContextDtor(&PSI_G(context));
 PHP_MSHUTDOWN_FUNCTION(psi)
 {
        PSI_ContextDtor(&PSI_G(context));


@@ -1074,26 +1107,13 @@ PHP_MSHUTDOWN_FUNCTION(psi)
        return SUCCESS;
 }
 
        return SUCCESS;
 }
 

-/* Remove if there's nothing to do at request start */
-/* {{{ PHP_RINIT_FUNCTION
- */
+#if defined(COMPILE_DL_PSI) && defined(ZTS)

 PHP_RINIT_FUNCTION(psi)
 {
 PHP_RINIT_FUNCTION(psi)
 {

-#if defined(COMPILE_DL_PSI) && defined(ZTS)

        ZEND_TSRMLS_CACHE_UPDATE();
        ZEND_TSRMLS_CACHE_UPDATE();

-#endif

        return SUCCESS;
 }
        return SUCCESS;
 }

-/* }}} */
-
-/* Remove if there's nothing to do at request end */
-/* {{{ PHP_RSHUTDOWN_FUNCTION
- */
-PHP_RSHUTDOWN_FUNCTION(psi)
-{
-       return SUCCESS;
-}
-/* }}} */
+#endif

 
 PHP_MINFO_FUNCTION(psi)
 {
 
 PHP_MINFO_FUNCTION(psi)
 {


@@ -1113,8 +1133,12 @@ zend_module_entry psi_module_entry = {
        psi_functions,
        PHP_MINIT(psi),
        PHP_MSHUTDOWN(psi),
        psi_functions,
        PHP_MINIT(psi),
        PHP_MSHUTDOWN(psi),

+#if defined(COMPILE_DL_PSI) && defined(ZTS)

        PHP_RINIT(psi),         /* Replace with NULL if there's nothing to do at request start */
        PHP_RINIT(psi),         /* Replace with NULL if there's nothing to do at request start */

-       PHP_RSHUTDOWN(psi),     /* Replace with NULL if there's nothing to do at request end */
+#else
+       NULL,
+#endif
+       NULL,

        PHP_MINFO(psi),
        PHP_PSI_VERSION,
        STANDARD_MODULE_PROPERTIES
        PHP_MINFO(psi),
        PHP_PSI_VERSION,
        STANDARD_MODULE_PROPERTIES

diff --git a/src/parser.h b/src/parser.h
index 2e551dc51e225193ea04d0cf544e47a7d4443a31..4df5354a6759180d1af0d1704284292a4da7d57e 100644 (file)
--- a/src/parser.h
+++ b/src/parser.h
@@ -26,6 +26,30 @@ typedef struct PSI_Token {
        char text[1];
 } PSI_Token;
 
        char text[1];
 } PSI_Token;
 

+typedef union impl_val {
+       char cval;
+       int8_t i8;
+       uint8_t u8;
+       short sval;
+       int16_t i16;
+       uint16_t u16;
+       int ival;
+       int32_t i32;
+       uint32_t u32;
+       long lval;
+       int64_t i64;
+       uint64_t u64;
+       float fval;
+       double dval;
+       union {
+               zend_bool bval;
+               zend_long lval;
+               zend_string *str;
+       } zend;
+       void *ptr;
+       uint8_t _dbg[sizeof(void *)];
+} impl_val;
+

 typedef struct decl_type {
        char *name;
        token_t type;
 typedef struct decl_type {
        char *name;
        token_t type;


@@ -136,6 +160,9 @@ typedef struct decl_arg {
        decl_var *var;
        decl_struct_layout *layout;
        struct let_stmt *let;
        decl_var *var;
        decl_struct_layout *layout;
        struct let_stmt *let;

+       impl_val val;
+       void *ptr;
+       void *mem;

 } decl_arg;
 
 static inline decl_arg *init_decl_arg(decl_type *type, decl_var *var) {
 } decl_arg;
 
 static inline decl_arg *init_decl_arg(decl_type *type, decl_var *var) {


@@ -143,6 +170,7 @@ static inline decl_arg *init_decl_arg(decl_type *type, decl_var *var) {
        arg->type = type;
        arg->var = var;
        var->arg = arg;
        arg->type = type;
        arg->var = var;
        var->arg = arg;

+       arg->ptr = &arg->val;

        return arg;
 }
 
        return arg;
 }
 


@@ -330,55 +358,6 @@ static inline void free_decl_structs(decl_structs *ss) {
        free(ss);
 }
 
        free(ss);
 }
 

-typedef union impl_val {
-       char cval;
-       int8_t i8;
-       uint8_t u8;
-       short sval;
-       int16_t i16;
-       uint16_t u16;
-       int ival;
-       int32_t i32;
-       uint32_t u32;
-       long lval;
-       int64_t i64;
-       uint64_t u64;
-       float fval;
-       double dval;
-       union {
-               zend_bool bval;
-               zend_long lval;
-               zend_string *str;
-       } zend;
-       void *ptr;
-       uint8_t _dbg[sizeof(void *)];
-} impl_val;
-
-static inline impl_val *deref_impl_val(impl_val *ret_val, decl_var *var) {
-       unsigned i;
-
-       if (var->arg->var != var) for (i = 1; i < var->pointer_level; ++i) {
-               ret_val = *(void **) ret_val;
-       }
-       return ret_val;
-}
-
-static inline impl_val *enref_impl_val(void *ptr, decl_var *var) {
-       impl_val *val, *val_ptr;
-       unsigned i;
-
-       if (!var->pointer_level && real_decl_type(var->arg->type)->type != PSI_T_STRUCT) {
-               return ptr;
-       }
-       val = val_ptr = calloc(var->pointer_level + 1, sizeof(void *));
-       for (i = 1; i < var->pointer_level; ++i) {
-               val_ptr->ptr = (void **) val_ptr + 1;
-               val_ptr = val_ptr->ptr;
-       }
-       val_ptr->ptr = ptr;
-       return val;
-}
-

 typedef struct impl_type {
        char *name;
        token_t type;
 typedef struct impl_type {
        char *name;
        token_t type;


@@ -685,9 +664,7 @@ typedef struct let_stmt {
        decl_var *var;
        let_value *val;
        impl_arg *arg;
        decl_var *var;
        let_value *val;
        impl_arg *arg;

-       impl_val out;

        void *ptr;
        void *ptr;

-       void *mem;

 } let_stmt;
 
 static inline let_stmt *init_let_stmt(decl_var *var, let_value *val) {
 } let_stmt;
 
 static inline let_stmt *init_let_stmt(decl_var *var, let_value *val) {


@@ -1013,21 +990,6 @@ static void free_impls(impls *impls) {
        free(impls);
 }
 
        free(impls);
 }
 

-static inline impl_val *struct_member_ref(decl_arg *set_arg, impl_val *struct_ptr, impl_val **to_free) {
-       void *ptr = (char *) struct_ptr->ptr + set_arg->layout->pos;
-       impl_val *val = enref_impl_val(ptr, set_arg->var);
-
-       if (val != ptr) {
-               *to_free = val;
-       }
-
-       return val;
-}
-
-#define PSI_ERROR 16
-#define PSI_WARNING 32
-typedef void (*psi_error_cb)(int type, const char *msg, ...);
-

 typedef struct decl_file {
        char *ln;
        char *fn;
 typedef struct decl_file {
        char *ln;
        char *fn;


@@ -1066,6 +1028,46 @@ static inline void add_decl_lib(decl_libs *libs, void *dlopened) {
        libs->dl[libs->count-1] = dlopened;
 }
 
        libs->dl[libs->count-1] = dlopened;
 }
 

+static inline impl_val *deref_impl_val(impl_val *ret_val, decl_var *var) {
+       unsigned i;
+
+       if (var->arg->var != var) for (i = 1; i < var->pointer_level; ++i) {
+               ret_val = *(void **) ret_val;
+       }
+       return ret_val;
+}
+
+static inline impl_val *enref_impl_val(void *ptr, decl_var *var) {
+       impl_val *val, *val_ptr;
+       unsigned i;
+
+       if (!var->pointer_level && real_decl_type(var->arg->type)->type != PSI_T_STRUCT) {
+               return ptr;
+       }
+       val = val_ptr = calloc(var->pointer_level + 1, sizeof(void *));
+       for (i = 1; i < var->pointer_level; ++i) {
+               val_ptr->ptr = (void **) val_ptr + 1;
+               val_ptr = val_ptr->ptr;
+       }
+       val_ptr->ptr = ptr;
+       return val;
+}
+
+static inline impl_val *struct_member_ref(decl_arg *set_arg, impl_val *struct_ptr, impl_val **to_free) {
+       void *ptr = (char *) struct_ptr->ptr + set_arg->layout->pos;
+       impl_val *val = enref_impl_val(ptr, set_arg->var);
+
+       if (val != ptr) {
+               *to_free = val;
+       }
+
+       return val;
+}
+
+#define PSI_ERROR 16
+#define PSI_WARNING 32
+typedef void (*psi_error_cb)(int type, const char *msg, ...);
+

 #define PSI_DATA(D) ((PSI_Data *) (D))
 #define PSI_DATA_MEMBERS \
        constants *consts; \
 #define PSI_DATA(D) ((PSI_Data *) (D))
 #define PSI_DATA_MEMBERS \
        constants *consts; \