commit after reset fuckup

[m6w6/ext-psi] / src / types / impl.c

diff --git a/src/types/impl.c b/src/types/impl.c
index 33d3301fa8a7863abe0e63dfbebabc072f8eb575..c1b9b9a29fe65be234eeffdb1a7f9b3636811dc7 100644 (file)
--- a/src/types/impl.c
+++ b/src/types/impl.c
@@ -31,7 +31,7 @@
 struct psi_impl *psi_impl_init(struct psi_impl_func *func,
                struct psi_plist *stmts)
 {
-       struct psi_impl *impl = calloc(1, sizeof(*impl));
+       struct psi_impl *impl = pecalloc(1, sizeof(*impl), 1);
        size_t i = 0;
        struct psi_token **abstract_stmt;
 
@@ -39,6 +39,7 @@ struct psi_impl *psi_impl_init(struct psi_impl_func *func,
        impl->stmts.let = psi_plist_init((psi_plist_dtor) psi_let_stmt_free);
        impl->stmts.set = psi_plist_init((psi_plist_dtor) psi_set_stmt_free);
        impl->stmts.fre = psi_plist_init((psi_plist_dtor) psi_free_stmt_free);
+       impl->stmts.ass = psi_plist_init((psi_plist_dtor) psi_assert_stmt_free);
 
        while (psi_plist_get(stmts, i++, &abstract_stmt)) {
                switch ((*abstract_stmt)->type) {
@@ -55,6 +56,10 @@ struct psi_impl *psi_impl_init(struct psi_impl_func *func,
                case PSI_T_FREE:
                        impl->stmts.fre = psi_plist_add(impl->stmts.fre, &abstract_stmt);
                        break;
+               case PSI_T_PRE_ASSERT:
+               case PSI_T_POST_ASSERT:
+                       impl->stmts.ass = psi_plist_add(impl->stmts.ass, &abstract_stmt);
+                       break;
                default:
                        assert(0);
                }
@@ -77,50 +82,61 @@ void psi_impl_free(struct psi_impl **impl_ptr)
                psi_plist_free(impl->stmts.let);
                psi_plist_free(impl->stmts.set);
                psi_plist_free(impl->stmts.fre);
+               psi_plist_free(impl->stmts.ass);
                free(impl);
        }
 }
 
-void psi_impl_dump(int fd, struct psi_impl *impl)
+void psi_impl_dump(struct psi_dump *dump, struct psi_impl *impl)
 {
        size_t i;
        struct psi_return_stmt *ret;
        struct psi_let_stmt *let;
        struct psi_set_stmt *set;
        struct psi_free_stmt *fre;
+       struct psi_assert_stmt *ass;
 
-       psi_impl_func_dump(fd, impl->func);
-       dprintf(fd, " {\n");
+       psi_impl_func_dump(dump, impl->func);
+       PSI_DUMP(dump, " {\n");
        for (i = 0; psi_plist_get(impl->stmts.let, i, &let); ++i) {
-               psi_let_stmt_dump(fd, let);
+               psi_let_stmt_dump(dump, let);
+       }
+       for (i = 0; psi_plist_get(impl->stmts.ass, i, &ass); ++i) {
+               psi_assert_stmt_dump(dump, ass);
        }
        for (i = 0; psi_plist_get(impl->stmts.ret, i, &ret); ++i) {
-               psi_return_stmt_dump(fd, ret);
+               psi_return_stmt_dump(dump, ret);
        }
        for (i = 0; psi_plist_get(impl->stmts.set, i, &set); ++i) {
-               psi_set_stmt_dump(fd, set);
+               psi_set_stmt_dump(dump, set);
        }
        for (i = 0; psi_plist_get(impl->stmts.fre, i, &fre); ++i) {
-               psi_free_stmt_dump(fd, fre);
+               psi_free_stmt_dump(dump, fre);
        }
-       dprintf(fd, "}\n");
+       PSI_DUMP(dump, "}\n");
 }
 
-bool psi_impl_validate(struct psi_data *data, struct psi_impl *impl)
+bool psi_impl_validate(struct psi_data *data, struct psi_impl *impl,
+               struct psi_validate_scope *scope)
 {
-       if (!psi_impl_func_validate(data, impl->func)) {
+       scope->impl = impl;
+
+       if (!psi_impl_func_validate(data, impl->func, scope)) {
+               return false;
+       }
+       if (!psi_return_stmt_validate(data, scope)) {
                return false;
        }
-       if (!psi_return_stmt_validate(data, impl)) {
+       if (!psi_let_stmts_validate(data, scope)) {
                return false;
        }
-       if (!psi_let_stmts_validate(data, impl)) {
+       if (!psi_set_stmts_validate(data, scope)) {
                return false;
        }
-       if (!psi_set_stmts_validate(data, impl)) {
+       if (!psi_assert_stmts_validate(data, scope)) {
                return false;
        }
-       if (!psi_free_stmts_validate(data, impl)) {
+       if (!psi_free_stmts_validate(data, scope)) {
                return false;
        }
        return true;
@@ -154,11 +170,36 @@ void psi_impl_stmt_free(struct psi_token ***abstract_stmt)
        case PSI_T_FREE:
                psi_free_stmt_free((void *) abstract_stmt);
                break;
+       case PSI_T_PRE_ASSERT:
+       case PSI_T_POST_ASSERT:
+               psi_assert_stmt_free((void *) abstract_stmt);
+               break;
        default:
                assert(0);
        }
 }
 
+struct psi_decl_arg *psi_impl_get_decl_arg(struct psi_impl *impl,
+               struct psi_decl_var *var)
+{
+       struct psi_return_stmt *ret;
+
+       if (psi_plist_get(impl->stmts.ret, 0, &ret)) {
+               if (ret->exp->args) {
+                       size_t i = 0;
+                       struct psi_decl_var *arg;
+
+                       while (psi_plist_get(ret->exp->args, i++, &arg)) {
+                               if (zend_string_equals(var->name, arg->name)) {
+                                       return var->arg = arg->arg;
+                               }
+                       }
+               }
+       }
+
+       return psi_decl_get_arg(impl->decl, var);
+}
+
 struct psi_let_stmt *psi_impl_get_let(struct psi_impl *impl,
                struct psi_decl_var* var)
 {
@@ -180,7 +221,7 @@ struct psi_impl_arg *psi_impl_get_arg(struct psi_impl *impl,
        struct psi_impl_arg *iarg;
 
        while (psi_plist_get(impl->func->args, i++, &iarg)) {
-               if (!strcmp(var->name, iarg->var->name)) {
+               if (zend_string_equals(var->name, iarg->var->name)) {
                        return var->arg = iarg;
                }
        }
@@ -197,7 +238,7 @@ struct psi_decl_arg *psi_impl_get_temp_let_arg(struct psi_impl *impl,
                if (let->exp->kind != PSI_LET_TMP) {
                        continue;
                }
-               if (strcmp(let->exp->var->name, var->name)) {
+               if (!zend_string_equals(let->exp->var->name, var->name)) {
                        continue;
                }
                return var->arg = let->exp->var->arg;