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