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