git.m6w6.name Git - m6w6/ext-psi/blob - src/types/impl.c

   1 /*******************************************************************************
   2  Copyright (c) 2016, Michael Wallner <mike@php.net>.
   3  All rights reserved.
   4
   5  Redistribution and use in source and binary forms, with or without
   6  modification, are permitted provided that the following conditions are met:
   7
   8  * Redistributions of source code must retain the above copyright notice,
   9  this list of conditions and the following disclaimer.
  10  * Redistributions in binary form must reproduce the above copyright
  11  notice, this list of conditions and the following disclaimer in the
  12  documentation and/or other materials provided with the distribution.
  13
  14  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  15  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
  18  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  20  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  21  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  22  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  *******************************************************************************/
  25
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #else
  29 # include "php_config.h"
  30 #endif
  31 #include "data.h"
  32
  33 #include <assert.h>
  34
  35 struct psi_impl *psi_impl_init(struct psi_impl_func *func,
  36                 struct psi_plist *stmts)
  37 {
  38         struct psi_impl *impl = pecalloc(1, sizeof(*impl), 1);
  39         size_t i = 0;
  40         struct psi_token **abstract_stmt;
  41
  42         impl->stmts.ret = psi_plist_init((psi_plist_dtor) psi_return_stmt_free);
  43         impl->stmts.let = psi_plist_init((psi_plist_dtor) psi_let_stmt_free);
  44         impl->stmts.set = psi_plist_init((psi_plist_dtor) psi_set_stmt_free);
  45         impl->stmts.fre = psi_plist_init((psi_plist_dtor) psi_free_stmt_free);
  46         impl->stmts.ass = psi_plist_init((psi_plist_dtor) psi_assert_stmt_free);
  47
  48         while (psi_plist_get(stmts, i++, &abstract_stmt)) {
  49                 switch ((*abstract_stmt)->type) {
  50                 case PSI_T_RETURN:
  51                         impl->stmts.ret = psi_plist_add(impl->stmts.ret, &abstract_stmt);
  52                         break;
  53                 case PSI_T_LET:
  54                 case PSI_T_TEMP:
  55                         impl->stmts.let = psi_plist_add(impl->stmts.let, &abstract_stmt);
  56                         break;
  57                 case PSI_T_SET:
  58                         impl->stmts.set = psi_plist_add(impl->stmts.set, &abstract_stmt);
  59                         break;
  60                 case PSI_T_FREE:
  61                         impl->stmts.fre = psi_plist_add(impl->stmts.fre, &abstract_stmt);
  62                         break;
  63                 case PSI_T_PRE_ASSERT:
  64                 case PSI_T_POST_ASSERT:
  65                         impl->stmts.ass = psi_plist_add(impl->stmts.ass, &abstract_stmt);
  66                         break;
  67                 default:
  68                         assert(0);
  69                 }
  70         }
  71         free(stmts);
  72
  73         impl->func = func;
  74
  75         return impl;
  76 }
  77
  78 void psi_impl_free(struct psi_impl **impl_ptr)
  79 {
  80         if (*impl_ptr) {
  81                 struct psi_impl *impl = *impl_ptr;
  82
  83                 *impl_ptr = NULL;
  84                 psi_impl_func_free(&impl->func);
  85                 psi_plist_free(impl->stmts.ret);
  86                 psi_plist_free(impl->stmts.let);
  87                 psi_plist_free(impl->stmts.set);
  88                 psi_plist_free(impl->stmts.fre);
  89                 psi_plist_free(impl->stmts.ass);
  90                 free(impl);
  91         }
  92 }
  93
  94 void psi_impl_dump(struct psi_dump *dump, struct psi_impl *impl)
  95 {
  96         size_t i;
  97         struct psi_return_stmt *ret;
  98         struct psi_let_stmt *let;
  99         struct psi_set_stmt *set;
 100         struct psi_free_stmt *fre;
 101         struct psi_assert_stmt *ass;
 102
 103         psi_impl_func_dump(dump, impl->func);
 104         PSI_DUMP(dump, " {\n");
 105         for (i = 0; psi_plist_get(impl->stmts.let, i, &let); ++i) {
 106                 psi_let_stmt_dump(dump, let);
 107         }
 108         for (i = 0; psi_plist_get(impl->stmts.ass, i, &ass); ++i) {
 109                 psi_assert_stmt_dump(dump, ass);
 110         }
 111         for (i = 0; psi_plist_get(impl->stmts.ret, i, &ret); ++i) {
 112                 psi_return_stmt_dump(dump, ret);
 113         }
 114         for (i = 0; psi_plist_get(impl->stmts.set, i, &set); ++i) {
 115                 psi_set_stmt_dump(dump, set);
 116         }
 117         for (i = 0; psi_plist_get(impl->stmts.fre, i, &fre); ++i) {
 118                 psi_free_stmt_dump(dump, fre);
 119         }
 120         PSI_DUMP(dump, "}\n");
 121 }
 122
 123 bool psi_impl_validate(struct psi_data *data, struct psi_impl *impl,
 124                 struct psi_validate_scope *scope)
 125 {
 126         scope->impl = impl;
 127
 128         if (!psi_impl_func_validate(data, impl->func, scope)) {
 129                 return false;
 130         }
 131         if (!psi_return_stmt_validate(data, scope)) {
 132                 return false;
 133         }
 134         if (!psi_let_stmts_validate(data, scope)) {
 135                 return false;
 136         }
 137         if (!psi_set_stmts_validate(data, scope)) {
 138                 return false;
 139         }
 140         if (!psi_assert_stmts_validate(data, scope)) {
 141                 return false;
 142         }
 143         if (!psi_free_stmts_validate(data, scope)) {
 144                 return false;
 145         }
 146         return true;
 147 }
 148
 149 size_t psi_impl_num_min_args(struct psi_impl *impl)
 150 {
 151         size_t i;
 152         struct psi_impl_arg *arg;
 153
 154         for (i = 0; psi_plist_get(impl->func->args, i, &arg); ++i) {
 155                 if (arg->def) {
 156                         break;
 157                 }
 158         }
 159         return i;
 160 }
 161
 162 void psi_impl_stmt_free(struct psi_token ***abstract_stmt)
 163 {
 164         switch ((**abstract_stmt)->type) {
 165         case PSI_T_LET:
 166                 psi_let_stmt_free((void *) abstract_stmt);
 167                 break;
 168         case PSI_T_SET:
 169                 psi_set_stmt_free((void *) abstract_stmt);
 170                 break;
 171         case PSI_T_RETURN:
 172                 psi_return_stmt_free((void *) abstract_stmt);
 173                 break;
 174         case PSI_T_FREE:
 175                 psi_free_stmt_free((void *) abstract_stmt);
 176                 break;
 177         case PSI_T_PRE_ASSERT:
 178         case PSI_T_POST_ASSERT:
 179                 psi_assert_stmt_free((void *) abstract_stmt);
 180                 break;
 181         default:
 182                 assert(0);
 183         }
 184 }
 185
 186 struct psi_decl_arg *psi_impl_get_decl_arg(struct psi_impl *impl,
 187                 struct psi_decl_var *var)
 188 {
 189         struct psi_return_stmt *ret;
 190
 191         if (psi_plist_get(impl->stmts.ret, 0, &ret)) {
 192                 if (ret->exp->args) {
 193                         size_t i = 0;
 194                         struct psi_decl_var *arg;
 195
 196                         while (psi_plist_get(ret->exp->args, i++, &arg)) {
 197                                 if (zend_string_equals(var->name, arg->name)) {
 198                                         return var->arg = arg->arg;
 199                                 }
 200                         }
 201                 }
 202         }
 203
 204         return psi_decl_get_arg(impl->decl, var);
 205 }
 206
 207 struct psi_let_stmt *psi_impl_get_let(struct psi_impl *impl,
 208                 struct psi_decl_var* var)
 209 {
 210         size_t i = 0;
 211         struct psi_let_stmt *let;
 212
 213         while (psi_plist_get(impl->stmts.let, i++, &let)) {
 214                 if (let->exp->var->arg == var->arg) {
 215                         return let;
 216                 }
 217         }
 218         return NULL;
 219 }
 220
 221 struct psi_impl_arg *psi_impl_get_arg(struct psi_impl *impl,
 222                 struct psi_impl_var* var)
 223 {
 224         size_t i = 0;
 225         struct psi_impl_arg *iarg;
 226
 227         while (psi_plist_get(impl->func->args, i++, &iarg)) {
 228                 if (zend_string_equals(var->name, iarg->var->name)) {
 229                         return var->arg = iarg;
 230                 }
 231         }
 232         return NULL;
 233 }
 234
 235 struct psi_decl_arg *psi_impl_get_temp_let_arg(struct psi_impl *impl,
 236                 struct psi_decl_var* var)
 237 {
 238         size_t j = 0;
 239         struct psi_let_stmt *let = NULL;
 240
 241         while (psi_plist_get(impl->stmts.let, j++, &let)) {
 242                 if (let->exp->kind != PSI_LET_TMP) {
 243                         continue;
 244                 }
 245                 if (!zend_string_equals(let->exp->var->name, var->name)) {
 246                         continue;
 247                 }
 248                 return var->arg = let->exp->var->arg;
 249         }
 250         return NULL;
 251 }