git.m6w6.name Git - m6w6/ext-psi/blob - src/types/let_func.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 #include "call.h"
  29 #include "marshal.h"
  30
  31 #include "php.h"
  32
  33 #include <assert.h>
  34
  35 struct psi_let_func *psi_let_func_init(token_t type, const char *name,
  36                 struct psi_impl_var *var)
  37 {
  38         struct psi_let_func *func = calloc(1, sizeof(*func));
  39         func->type = type;
  40         func->name = strdup(name);
  41         func->var = var;
  42         return func;
  43 }
  44
  45 void psi_let_func_free(struct psi_let_func **func_ptr)
  46 {
  47         if (*func_ptr) {
  48                 struct psi_let_func *func = *func_ptr;
  49
  50                 *func_ptr = NULL;
  51                 if (func->token) {
  52                         free(func->token);
  53                 }
  54                 psi_impl_var_free(&func->var);
  55                 free(func->name);
  56                 if (func->inner) {
  57                         psi_plist_free(func->inner);
  58                 }
  59                 free(func);
  60         }
  61 }
  62
  63 void psi_let_func_dump(int fd, struct psi_let_func *func, unsigned level)
  64 {
  65         dprintf(fd, "%s(%s\t/* fqn=%s */", func->name, func->var->name, func->var->fqn);
  66
  67         if (func->inner) {
  68                 size_t i = 0, count = psi_plist_count(func->inner);
  69                 struct psi_let_exp *inner;
  70
  71                 dprintf(fd, ",");
  72                 ++level;
  73                 while (psi_plist_get(func->inner, i++, &inner)) {
  74                         dprintf(fd, "\n");
  75                         psi_let_exp_dump(fd, inner, level, i == count);
  76                 }
  77                 --level;
  78                 dprintf(fd, "\n");
  79                 dprintf(fd, "%s", psi_t_indent(level));
  80         }
  81         dprintf(fd, ")");
  82 }
  83
  84 static inline int validate_let_func_type(struct psi_data *data,
  85                 struct psi_let_func *func, struct psi_impl *impl)
  86 {
  87         switch (func->type) {
  88         case PSI_T_BOOLVAL:
  89         case PSI_T_INTVAL:
  90         case PSI_T_FLOATVAL:
  91         case PSI_T_STRVAL:
  92         case PSI_T_STRLEN:
  93         case PSI_T_PATHVAL:
  94         case PSI_T_OBJVAL:
  95         case PSI_T_ZVAL:
  96         case PSI_T_VOID:
  97         case PSI_T_COUNT:
  98                 return true;
  99
 100         case PSI_T_ARRVAL:
 101                 if (!func->inner) {
 102                         data->error(data, func->token, PSI_WARNING,
 103                                         "Expected sub-expressions in `arrval` expression");
 104                         return false;
 105                 }
 106                 return true;
 107
 108         default:
 109                 data->error(data, func->var->token, PSI_WARNING,
 110                                 "Unknown `let` cast function '%s' of implementation '%s'",
 111                                 func->name, impl->func->name);
 112                 return false;
 113         }
 114 }
 115
 116 static inline bool validate_let_func_inner(struct psi_data *data,
 117                 struct psi_let_exp *exp, struct psi_let_func *func,
 118                 struct psi_impl *impl)
 119 {
 120         if (func->inner) {
 121                 struct psi_decl_var *let_var = psi_let_exp_get_decl_var(exp);
 122                 struct psi_decl_type *var_typ;
 123                 struct psi_plist *sub_args;
 124
 125                 sub_args = psi_decl_type_get_args(let_var->arg->type, &var_typ);
 126
 127                 if (func->type == PSI_T_ARRVAL && sub_args) {
 128                         /* struct = arrval($array,
 129                          *      member = strval($member) ...)
 130                          */
 131                         size_t i = 0;
 132                         struct psi_let_exp *inner;
 133
 134                         while (psi_plist_get(func->inner, i++, &inner)) {
 135                                 const char *name = psi_let_exp_get_decl_var_name(inner);
 136                                 struct psi_decl_arg *sub_arg;
 137
 138                                 inner->outer = exp;
 139
 140                                 if (name) {
 141                                         sub_arg = psi_decl_arg_get_by_name(sub_args, name);
 142                                 }
 143                                 if (!name || !sub_arg) {
 144                                         /* remove expr for portability with different struct members */
 145                                         psi_plist_del(func->inner, --i, NULL);
 146                                         psi_let_exp_free(&inner);
 147                                 } else if (!psi_let_exp_validate(data, inner, impl)) {
 148                                         return false;
 149                                 }
 150                         }
 151                 } else if (func->type == PSI_T_ARRVAL
 152                                 && psi_plist_count(func->inner) == 1
 153                                 && let_var->arg->var->pointer_level) {
 154                         /* array = arrval($array,
 155                          *      strval($array)) // cast foreach entry
 156                          */
 157                         struct psi_let_exp *inner;
 158                         struct psi_impl_var *sub_var;
 159                         struct psi_impl_var *sub_ref;
 160
 161                         psi_plist_get(func->inner, 0, &inner);
 162                         inner->outer = exp;
 163
 164                         sub_var = psi_let_exp_get_impl_var(exp);
 165                         sub_ref = psi_let_exp_get_impl_var(inner);
 166                         if (strcmp(sub_var->name, sub_ref->name)) {
 167                                 data->error(data, sub_var->token, E_WARNING,
 168                                                 "Inner `set` statement casts on pointers must"
 169                                                                 " reference the same variable");
 170                                 return false;
 171                         }
 172                         if (!psi_let_exp_validate(data, inner, impl)) {
 173                                 return false;
 174                         }
 175                 } else {
 176                         data->error(data, let_var->token, PSI_WARNING,
 177                                         "Inner let statement's values must refer to a structure or"
 178                                                         " array type, got '%s%s' for '%s'", var_typ->name,
 179                                         psi_t_indirection(let_var->arg->var->pointer_level),
 180                                         let_var->name);
 181                         return false;
 182                 }
 183
 184                 if (!psi_plist_count(func->inner)) {
 185                         data->error(data, func->token, PSI_WARNING,
 186                                         "No valid sub-expressions left");
 187                         return false;
 188                 }
 189         }
 190
 191         return true;
 192 }
 193
 194 bool psi_let_func_validate(struct psi_data *data, struct psi_let_exp *val,
 195                 struct psi_let_func *func, struct psi_impl *impl)
 196 {
 197         if (impl->func->args) {
 198                 /* FIXME, func->var does not need to be referring to a func arg */
 199                 psi_impl_get_arg(impl, func->var);
 200         }
 201
 202         if (!psi_impl_var_validate(data, func->var, impl, val, NULL)) {
 203                 return false;
 204         }
 205
 206         if (!validate_let_func_type(data, func, impl)) {
 207                 return false;
 208         }
 209         if (!validate_let_func_inner(data, val, func, impl)) {
 210                 return false;
 211         }
 212         return 1;
 213 }
 214
 215 void exec_let_func_arrval_inner(struct psi_let_func *func,
 216                 struct psi_decl_arg *darg, struct psi_decl_arg *inner_decl_arg,
 217                 struct psi_call_frame_argument *frame_arg,
 218                 struct psi_let_exp *inner_let_exp, void *container,
 219                 struct psi_call_frame *frame)
 220 {
 221         struct psi_let_func *inner_func = psi_let_exp_get_func(inner_let_exp);
 222         struct psi_impl_var *inner_var = inner_func->var;
 223
 224         if (psi_decl_type_get_real(darg->type)->type == PSI_T_UNION) {
 225                 /* skip if there's no entry in the outer_zval;
 226                  * we only want to set supplied data on unions
 227                  */
 228                 if (!zend_symtable_str_exists(Z_ARRVAL_P(frame_arg->zval_ptr),
 229                                 &inner_var->name[1], strlen(&inner_var->name[1]))) {
 230                         return;
 231                 }
 232         }
 233         psi_call_frame_sub_argument(frame, inner_var, frame_arg->zval_ptr,
 234                         inner_func->var->fqn);
 235
 236         /* example from dm_store/dbm_fetch with arrval($string) conversion:
 237          let key = arrval($key,
 238          dptr = strval($0),
 239          dsize = strlen($0)
 240          );
 241          # ---
 242          darg = key
 243          frame_arg = $key
 244          inner_var = $0
 245          full_func_var_name = $key.0
 246          inner_decl_arg = key.dptr
 247          */
 248         psi_let_exp_exec(inner_let_exp, inner_decl_arg,
 249                         ((char *) container) + inner_decl_arg->layout->pos,
 250                         inner_decl_arg->layout->len, frame);
 251 }
 252
 253 static void *exec_let_func_arrval(struct psi_let_exp *val,
 254                 struct psi_let_func *func, struct psi_decl_arg *darg,
 255                 struct psi_call_frame *frame);
 256
 257 void exec_let_func_arrval_seq(struct psi_let_func *func,
 258                 struct psi_decl_arg *darg, struct psi_decl_type *darg_type,
 259                 struct psi_call_frame_argument *frame_arg,
 260                 struct psi_let_exp *inner_let_exp, void *container,
 261                 struct psi_call_frame *frame)
 262 {
 263         zval *zval_ptr;
 264         psi_marshal_let let_fn;
 265         size_t i = 0, size;
 266         struct psi_decl_var *dvar;
 267
 268         if (inner_let_exp->var) {
 269                 /* arrval($foo, *foo = intval($foo)); */
 270                 dvar = inner_let_exp->var;
 271         } else {
 272                 /* arrval($foo, intval($foo)); */
 273                 dvar = psi_decl_var_copy(darg->var);
 274                 assert(dvar->pointer_level);
 275                 --dvar->pointer_level;
 276         }
 277
 278         dvar->pointer_level += inner_let_exp->is_reference;
 279         size = psi_decl_var_get_size(dvar);
 280         dvar->pointer_level -= inner_let_exp->is_reference;
 281
 282         let_fn = locate_let_func_fn(inner_let_exp->data.func->type);
 283
 284         ZEND_HASH_FOREACH_VAL_IND(Z_ARRVAL_P(frame_arg->zval_ptr), zval_ptr)
 285         {
 286                 void *temp = NULL;
 287                 impl_val val = {0}, *ptr, *sub;
 288
 289                 if (let_fn) {
 290                         ptr = let_fn(&val, darg_type, 0, NULL, zval_ptr, &temp);
 291                         if (temp) {
 292                                 psi_call_frame_push_auto(frame, temp);
 293                         }
 294                 } else if (func->type == PSI_T_ARRVAL) {
 295                         ptr = exec_let_func_arrval(inner_let_exp,
 296                                         inner_let_exp->data.func, darg, frame);
 297                 } else {
 298                         assert(0);
 299                 }
 300
 301                 sub = deref_impl_val(ptr, dvar);
 302
 303                 memcpy(&((char *) container)[size * i++], &sub, size);
 304         }
 305         ZEND_HASH_FOREACH_END();
 306
 307         if (dvar != inner_let_exp->var) {
 308                 psi_decl_var_free(&dvar);
 309         }
 310 }
 311
 312 static void *exec_let_func_arrval(struct psi_let_exp *val,
 313                 struct psi_let_func *func, struct psi_decl_arg *darg,
 314                 struct psi_call_frame *frame)
 315 {
 316         void *container = NULL;
 317         struct psi_call_frame_argument *frame_arg;
 318         struct psi_decl_type *darg_type;
 319         struct psi_plist *darg_members;
 320
 321         darg_members = psi_decl_type_get_args(darg->type, &darg_type);
 322         frame_arg = psi_call_frame_get_argument(frame, func->var->fqn);
 323
 324         if (frame_arg->zval_ptr && Z_TYPE_P(frame_arg->zval_ptr) != IS_ARRAY) {
 325                 convert_to_array(frame_arg->zval_ptr);
 326         }
 327
 328         if (darg_members && func->inner) {
 329                 /* struct or union
 330                  * arrval($foo,
 331                  *  str = strval($str),
 332                  *  num = intval($num));
 333                  */
 334                 size_t i = 0, size;
 335                 struct psi_let_exp *inner;
 336                 struct psi_decl_arg *darg_member;
 337
 338                 val->var->pointer_level += val->is_reference;
 339                 size = psi_decl_var_get_size(val->var);
 340                 container = ecalloc(1, size);
 341                 val->var->pointer_level -= val->is_reference;
 342
 343                 if (frame_arg->zval_ptr) {
 344                         while (psi_plist_get(func->inner, i++, &inner)) {
 345                                 darg_member = psi_decl_arg_get_by_name(darg_members,
 346                                                 psi_let_exp_get_decl_var_name(inner));
 347
 348                                 exec_let_func_arrval_inner(func, darg, darg_member, frame_arg,
 349                                                 inner, container, frame);
 350                         }
 351                 }
 352         } else if (func->inner) {
 353                 /* array
 354                  * arrval($foo, foo = intval($foo))
 355                  */
 356                 size_t arcount;
 357                 struct psi_let_exp *inner;
 358
 359                 if (!frame_arg->zval_ptr) {
 360                         return NULL;
 361                 }
 362                 assert(psi_plist_count(func->inner) == 1);
 363
 364                 arcount = zend_array_count(Z_ARRVAL_P(frame_arg->zval_ptr));
 365                 psi_plist_get(func->inner, 0, &inner);
 366
 367                 inner->var->pointer_level += inner->is_reference;
 368                 container = ecalloc(arcount + 1, psi_decl_var_get_size(inner->var));
 369                 inner->var->pointer_level -= inner->is_reference;
 370
 371                 exec_let_func_arrval_seq(func, darg, darg_type, frame_arg, inner,
 372                                 container, frame);
 373         } else {
 374                 assert(0);
 375         }
 376
 377         return *psi_call_frame_push_auto(frame, container);
 378 }
 379
 380 void *psi_let_func_exec(struct psi_let_exp *val, struct psi_let_func *func,
 381                 struct psi_decl_arg *darg, struct psi_call_frame *frame)
 382 {
 383         struct psi_call_frame_symbol *frame_sym;
 384         psi_marshal_let let_fn = locate_let_func_fn(func->type);
 385
 386         frame_sym = psi_call_frame_fetch_symbol(frame, val->var);
 387
 388         if (let_fn) {
 389                 void *temp = NULL;
 390                 struct psi_call_frame_argument *iarg;
 391
 392                 iarg = psi_call_frame_get_argument(frame, func->var->fqn);
 393
 394                 assert(iarg);
 395
 396                 frame_sym->ival_ptr = let_fn(&frame_sym->temp_val,
 397                                 psi_decl_type_get_real(darg->type),
 398                                 iarg->spec ? iarg->spec->type->type : 0, iarg->ival_ptr,
 399                                 iarg->zval_ptr, &temp);
 400                 if (temp) {
 401                         psi_call_frame_push_auto(frame, temp);
 402                 }
 403         } else if (func->type == PSI_T_ARRVAL) {
 404                 frame_sym->ival_ptr = exec_let_func_arrval(val, func, darg, frame);
 405         }
 406
 407         return frame_sym->ival_ptr;
 408 }