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 #include "php_psi_stdinc.h"
  27 #include "data.h"
  28
  29 #include <assert.h>
  30
  31 struct psi_impl *psi_impl_init(struct psi_impl_func *func,
  32                 struct psi_plist *stmts)
  33 {
  34         struct psi_impl *impl = calloc(1, sizeof(*impl));
  35         size_t i = 0;
  36         struct psi_token **abstract_stmt;
  37
  38         impl->stmts.ret = psi_plist_init((psi_plist_dtor) psi_return_stmt_free);
  39         impl->stmts.let = psi_plist_init((psi_plist_dtor) psi_let_stmt_free);
  40         impl->stmts.set = psi_plist_init((psi_plist_dtor) psi_set_stmt_free);
  41         impl->stmts.fre = psi_plist_init((psi_plist_dtor) psi_free_stmt_free);
  42         impl->stmts.ass = psi_plist_init((psi_plist_dtor) psi_assert_stmt_free);
  43
  44         while (psi_plist_get(stmts, i++, &abstract_stmt)) {
  45                 switch ((*abstract_stmt)->type) {
  46                 case PSI_T_RETURN:
  47                         impl->stmts.ret = psi_plist_add(impl->stmts.ret, &abstract_stmt);
  48                         break;
  49                 case PSI_T_LET:
  50                 case PSI_T_TEMP:
  51                         impl->stmts.let = psi_plist_add(impl->stmts.let, &abstract_stmt);
  52                         break;
  53                 case PSI_T_SET:
  54                         impl->stmts.set = psi_plist_add(impl->stmts.set, &abstract_stmt);
  55                         break;
  56                 case PSI_T_FREE:
  57                         impl->stmts.fre = psi_plist_add(impl->stmts.fre, &abstract_stmt);
  58                         break;
  59                 case PSI_T_PRE_ASSERT:
  60                 case PSI_T_POST_ASSERT:
  61                         impl->stmts.ass = psi_plist_add(impl->stmts.ass, &abstract_stmt);
  62                         break;
  63                 default:
  64                         assert(0);
  65                 }
  66         }
  67         free(stmts);
  68
  69         impl->func = func;
  70
  71         return impl;
  72 }
  73
  74 void psi_impl_free(struct psi_impl **impl_ptr)
  75 {
  76         if (*impl_ptr) {
  77                 struct psi_impl *impl = *impl_ptr;
  78
  79                 *impl_ptr = NULL;
  80                 psi_impl_func_free(&impl->func);
  81                 psi_plist_free(impl->stmts.ret);
  82                 psi_plist_free(impl->stmts.let);
  83                 psi_plist_free(impl->stmts.set);
  84                 psi_plist_free(impl->stmts.fre);
  85                 psi_plist_free(impl->stmts.ass);
  86                 free(impl);
  87         }
  88 }
  89
  90 void psi_impl_dump(int fd, struct psi_impl *impl)
  91 {
  92         size_t i;
  93         struct psi_return_stmt *ret;
  94         struct psi_let_stmt *let;
  95         struct psi_set_stmt *set;
  96         struct psi_free_stmt *fre;
  97         struct psi_assert_stmt *ass;
  98
  99         psi_impl_func_dump(fd, impl->func);
 100         dprintf(fd, " {\n");
 101         for (i = 0; psi_plist_get(impl->stmts.let, i, &let); ++i) {
 102                 psi_let_stmt_dump(fd, let);
 103         }
 104         for (i = 0; psi_plist_get(impl->stmts.ass, i, &ass); ++i) {
 105                 psi_assert_stmt_dump(fd, ass);
 106         }
 107         for (i = 0; psi_plist_get(impl->stmts.ret, i, &ret); ++i) {
 108                 psi_return_stmt_dump(fd, ret);
 109         }
 110         for (i = 0; psi_plist_get(impl->stmts.set, i, &set); ++i) {
 111                 psi_set_stmt_dump(fd, set);
 112         }
 113         for (i = 0; psi_plist_get(impl->stmts.fre, i, &fre); ++i) {
 114                 psi_free_stmt_dump(fd, fre);
 115         }
 116         dprintf(fd, "}\n");
 117 }
 118
 119 bool psi_impl_validate(struct psi_data *data, struct psi_impl *impl,
 120                 struct psi_validate_scope *scope)
 121 {
 122         scope->impl = impl;
 123
 124         if (!psi_impl_func_validate(data, impl->func, scope)) {
 125                 return false;
 126         }
 127         if (!psi_return_stmt_validate(data, scope)) {
 128                 return false;
 129         }
 130         if (!psi_let_stmts_validate(data, scope)) {
 131                 return false;
 132         }
 133         if (!psi_set_stmts_validate(data, scope)) {
 134                 return false;
 135         }
 136         if (!psi_assert_stmts_validate(data, scope)) {
 137                 return false;
 138         }
 139         if (!psi_free_stmts_validate(data, scope)) {
 140                 return false;
 141         }
 142         return true;
 143 }
 144
 145 size_t psi_impl_num_min_args(struct psi_impl *impl)
 146 {
 147         size_t i;
 148         struct psi_impl_arg *arg;
 149
 150         for (i = 0; psi_plist_get(impl->func->args, i, &arg); ++i) {
 151                 if (arg->def) {
 152                         break;
 153                 }
 154         }
 155         return i;
 156 }
 157
 158 void psi_impl_stmt_free(struct psi_token ***abstract_stmt)
 159 {
 160         switch ((**abstract_stmt)->type) {
 161         case PSI_T_LET:
 162                 psi_let_stmt_free((void *) abstract_stmt);
 163                 break;
 164         case PSI_T_SET:
 165                 psi_set_stmt_free((void *) abstract_stmt);
 166                 break;
 167         case PSI_T_RETURN:
 168                 psi_return_stmt_free((void *) abstract_stmt);
 169                 break;
 170         case PSI_T_FREE:
 171                 psi_free_stmt_free((void *) abstract_stmt);
 172                 break;
 173         case PSI_T_PRE_ASSERT:
 174         case PSI_T_POST_ASSERT:
 175                 psi_assert_stmt_free((void *) abstract_stmt);
 176                 break;
 177         default:
 178                 assert(0);
 179         }
 180 }
 181
 182 struct psi_decl_arg *psi_impl_get_decl_arg(struct psi_impl *impl,
 183                 struct psi_decl_var *var)
 184 {
 185         struct psi_return_stmt *ret;
 186
 187         if (psi_plist_get(impl->stmts.ret, 0, &ret)) {
 188                 if (ret->exp->args) {
 189                         size_t i = 0;
 190                         struct psi_decl_var *arg;
 191
 192                         while (psi_plist_get(ret->exp->args, i++, &arg)) {
 193                                 if (!strcmp(var->name, arg->name)) {
 194                                         return var->arg = arg->arg;
 195                                 }
 196                         }
 197                 }
 198         }
 199
 200         return psi_decl_get_arg(impl->decl, var);
 201 }
 202
 203 struct psi_let_stmt *psi_impl_get_let(struct psi_impl *impl,
 204                 struct psi_decl_var* var)
 205 {
 206         size_t i = 0;
 207         struct psi_let_stmt *let;
 208
 209         while (psi_plist_get(impl->stmts.let, i++, &let)) {
 210                 if (let->exp->var->arg == var->arg) {
 211                         return let;
 212                 }
 213         }
 214         return NULL;
 215 }
 216
 217 struct psi_impl_arg *psi_impl_get_arg(struct psi_impl *impl,
 218                 struct psi_impl_var* var)
 219 {
 220         size_t i = 0;
 221         struct psi_impl_arg *iarg;
 222
 223         while (psi_plist_get(impl->func->args, i++, &iarg)) {
 224                 if (!strcmp(var->name, iarg->var->name)) {
 225                         return var->arg = iarg;
 226                 }
 227         }
 228         return NULL;
 229 }
 230
 231 struct psi_decl_arg *psi_impl_get_temp_let_arg(struct psi_impl *impl,
 232                 struct psi_decl_var* var)
 233 {
 234         size_t j = 0;
 235         struct psi_let_stmt *let = NULL;
 236
 237         while (psi_plist_get(impl->stmts.let, j++, &let)) {
 238                 if (let->exp->kind != PSI_LET_TMP) {
 239                         continue;
 240                 }
 241                 if (strcmp(let->exp->var->name, var->name)) {
 242                         continue;
 243                 }
 244                 return var->arg = let->exp->var->arg;
 245         }
 246         return NULL;
 247 }