git.m6w6.name Git - m6w6/ext-psi/blob - src/types/let_val.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
  32 #include <stdlib.h>
  33 #include <stdio.h>
  34 #include <assert.h>
  35
  36 #include "data.h"
  37
  38 let_val *init_let_val_ex(decl_var *var, enum let_val_kind kind, void *data) {
  39         let_val *val = init_let_val(kind, data);
  40         val->var = var;
  41         return val;
  42 }
  43
  44 let_val *init_let_val(enum let_val_kind kind, void *data) {
  45         let_val *let = calloc(1, sizeof(*let));
  46         switch (let->kind = kind) {
  47         case PSI_LET_NULL:
  48                 assert(!data);
  49                 break;
  50         case PSI_LET_NUMEXP:
  51                 let->data.num = data;
  52                 break;
  53         case PSI_LET_CALLOC:
  54                 let->data.alloc = data;
  55                 break;
  56         case PSI_LET_CALLBACK:
  57                 let->data.callback = data;
  58                 break;
  59         case PSI_LET_FUNC:
  60                 let->data.func = data;
  61                 break;
  62         case PSI_LET_TMP:
  63                 let->data.var = data;
  64                 break;
  65         default:
  66                 assert(0);
  67         }
  68         return let;
  69 }
  70
  71 void free_let_val(let_val *let) {
  72         switch (let->kind) {
  73         case PSI_LET_NULL:
  74                 break;
  75         case PSI_LET_NUMEXP:
  76                 free_num_exp(let->data.num);
  77                 break;
  78         case PSI_LET_CALLOC:
  79                 free_let_calloc(let->data.alloc);
  80                 break;
  81         case PSI_LET_CALLBACK:
  82                 free_let_callback(let->data.callback);
  83                 break;
  84         case PSI_LET_FUNC:
  85                 free_let_func(let->data.func);
  86                 break;
  87         case PSI_LET_TMP:
  88                 if (let->var->arg) {
  89                         free_decl_arg(let->var->arg);
  90                 }
  91                 free_decl_var(let->data.var);
  92                 break;
  93         default:
  94                 assert(0);
  95         }
  96         if (let->var) {
  97                 free_decl_var(let->var);
  98         }
  99         free(let);
 100 }
 101
 102 void dump_let_val(int fd, let_val *val, unsigned level, int last) {
 103         if (level > 1) {
 104                 /* only if not directly after `set ...` */
 105                 dprintf(fd, "%s", psi_t_indent(level));
 106         }
 107
 108         if (val->var) {
 109                 dump_decl_var(fd, val->var);
 110                 dprintf(fd, " = ");
 111         }
 112         if (val->is_reference) {
 113                 dprintf(fd, "&");
 114         }
 115
 116         switch (val->kind) {
 117         case PSI_LET_NULL:
 118                 dprintf(fd, "NULL");
 119                 break;
 120         case PSI_LET_TMP:
 121                 dump_decl_var(fd, val->data.var);
 122                 break;
 123         case PSI_LET_CALLOC:
 124                 dprintf(fd, "calloc(");
 125                 dump_num_exp(fd, val->data.alloc->nmemb);
 126                 dprintf(fd, ", ");
 127                 dump_num_exp(fd, val->data.alloc->size);
 128                 dprintf(fd, ")");
 129                 break;
 130         case PSI_LET_CALLBACK:
 131                 dprintf(fd, "callback %s(%s(", val->data.callback->func->name,
 132                                 val->data.callback->func->var->name);
 133                 if (val->data.callback->args) {
 134                         size_t i, c = val->data.callback->args->count;
 135
 136                         dprintf(fd, "\n");
 137                         for (i = 0; i < c; ++i) {
 138                                 set_value *set = val->data.callback->args->vals[i];
 139                                 ++level;
 140                                 dump_set_value(fd, set, level, i + 1 == c);
 141                                 --level;
 142                         }
 143                         dprintf(fd, "%s", psi_t_indent(level));
 144                 }
 145                 dprintf(fd, "))");
 146                 break;
 147         case PSI_LET_FUNC:
 148                 dump_let_func(fd, val->data.func, level);
 149                 break;
 150         case PSI_LET_NUMEXP:
 151                 dump_num_exp(fd, val->data.num);
 152                 break;
 153
 154         default:
 155                 assert(0);
 156         }
 157
 158         if (level > 1) {
 159                 if (!last) {
 160                         dprintf(fd, ",");
 161                 }
 162         } else {
 163                 dprintf(fd, ";");
 164         }
 165 }
 166
 167 int validate_let_val(struct psi_data *data, let_val *val, decl_var *let_var, impl *impl) {
 168         switch (val->kind) {
 169         case PSI_LET_NULL:
 170                 break;
 171         case PSI_LET_TMP:
 172                 if (!let_var) {
 173                         data->error(data, NULL, PSI_WARNING,
 174                                         "Ivalid temp statement value of implementation '%s'",
 175                                         impl->func->name);
 176                         return 0;
 177                 }
 178                 /* e.g. let bar = &strval($bar); // decl_arg(char **bar) */
 179                 /* e.g. let foo = *bar;  */
 180                 let_var->pointer_level = val->data.var->pointer_level;
 181                 let_var->arg = init_decl_arg(
 182                                 init_decl_type(
 183                                                 real_decl_type(val->data.var->arg->type)->type,
 184                                                 real_decl_type(val->data.var->arg->type)->name),
 185                                 init_decl_var(
 186                                                 let_var->name,
 187                                                 let_var->pointer_level,
 188                                                 let_var->array_size));
 189                 break;
 190         case PSI_LET_NUMEXP:
 191                 if (!validate_num_exp(data, val->data.num, impl->decl->args, impl->decl->func, NULL)) {
 192                         return 0;
 193                 }
 194                 break;
 195         case PSI_LET_CALLOC:
 196                 if (!validate_num_exp(data, val->data.alloc->nmemb, impl->decl->args, impl->decl->func, NULL)) {
 197                         return 0;
 198                 }
 199                 if (!validate_num_exp(data, val->data.alloc->size, impl->decl->args, impl->decl->func, NULL)) {
 200                         return 0;
 201                 }
 202                 break;
 203         case PSI_LET_CALLBACK:
 204                 if (!let_var) {
 205                         data->error(data, NULL, PSI_WARNING,
 206                                         "Ivalid let statement value of implementation '%s'",
 207                                         impl->func->name);
 208                         return 0;
 209                 }
 210                 if (!validate_let_func(data, val, val->data.callback->func, let_var, impl)) {
 211                         return 0;
 212                 }
 213                 if (!validate_let_callback(data, let_var, val->data.callback, impl)) {
 214                         return 0;
 215                 }
 216                 break;
 217         case PSI_LET_FUNC:
 218                 if (!validate_let_func(data, val, val->data.func, let_var, impl)) {
 219                         return 0;
 220                 }
 221                 break;
 222         }
 223
 224         return 1;
 225 }