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