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,
 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, 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_plist *darg_members;
 319
 320         darg_members = psi_decl_type_get_args(darg->type, NULL);
 321         frame_arg = psi_call_frame_get_argument(frame, func->var->fqn);
 322
 323         if (frame_arg->zval_ptr && Z_TYPE_P(frame_arg->zval_ptr) != IS_ARRAY) {
 324                 convert_to_array(frame_arg->zval_ptr);
 325         }
 326
 327         if (darg_members && func->inner) {
 328                 /* struct or union
 329                  * arrval($foo,
 330                  *  str = strval($str),
 331                  *  num = intval($num));
 332                  */
 333                 size_t i = 0, size;
 334                 struct psi_let_exp *inner;
 335                 struct psi_decl_arg *darg_member;
 336
 337                 val->var->pointer_level += val->is_reference;
 338                 size = psi_decl_var_get_size(val->var);
 339                 container = ecalloc(1, size);
 340                 val->var->pointer_level -= val->is_reference;
 341
 342                 if (frame_arg->zval_ptr) {
 343                         while (psi_plist_get(func->inner, i++, &inner)) {
 344                                 darg_member = psi_decl_arg_get_by_name(darg_members,
 345                                                 psi_let_exp_get_decl_var_name(inner));
 346
 347                                 exec_let_func_arrval_inner(func, darg, darg_member, frame_arg,
 348                                                 inner, container, frame);
 349                         }
 350                 }
 351         } else if (func->inner) {
 352                 /* array
 353                  * arrval($foo, foo = intval($foo))
 354                  */
 355                 size_t arcount;
 356                 struct psi_let_exp *inner;
 357
 358                 if (!frame_arg->zval_ptr) {
 359                         return NULL;
 360                 }
 361                 assert(psi_plist_count(func->inner) == 1);
 362
 363                 arcount = zend_array_count(Z_ARRVAL_P(frame_arg->zval_ptr));
 364                 psi_plist_get(func->inner, 0, &inner);
 365
 366                 inner->var->pointer_level += inner->is_reference;
 367                 container = ecalloc(arcount + 1, psi_decl_var_get_size(inner->var));
 368                 inner->var->pointer_level -= inner->is_reference;
 369
 370                 exec_let_func_arrval_seq(func, darg, frame_arg, inner, container, frame);
 371         } else {
 372                 assert(0);
 373         }
 374
 375         return *psi_call_frame_push_auto(frame, container);
 376 }
 377
 378 void *psi_let_func_exec(struct psi_let_exp *val, struct psi_let_func *func,
 379                 struct psi_decl_arg *darg, struct psi_call_frame *frame)
 380 {
 381         struct psi_call_frame_symbol *frame_sym;
 382         psi_marshal_let let_fn = locate_let_func_fn(func->type);
 383
 384         frame_sym = psi_call_frame_fetch_symbol(frame, val->var);
 385
 386         if (let_fn) {
 387                 void *temp = NULL;
 388                 struct psi_call_frame_argument *iarg;
 389
 390                 iarg = psi_call_frame_get_argument(frame, func->var->fqn);
 391
 392                 assert(iarg);
 393
 394                 frame_sym->ival_ptr = let_fn(&frame_sym->temp_val, darg,
 395                                 iarg->spec ? iarg->spec->type->type : 0, iarg->ival_ptr,
 396                                 iarg->zval_ptr, &temp);
 397                 if (temp) {
 398                         psi_call_frame_push_auto(frame, temp);
 399                 }
 400         } else if (func->type == PSI_T_ARRVAL) {
 401                 frame_sym->ival_ptr = exec_let_func_arrval(val, func, darg, frame);
 402         }
 403
 404         return frame_sym->ival_ptr;
 405 }