git.m6w6.name Git - m6w6/ext-psi/blob - src/module.c

   1
   2 #ifdef HAVE_CONFIG_H
   3 #include "config.h"
   4 #endif
   5
   6 #include "php.h"
   7 #include "php_ini.h"
   8 #include "ext/standard/info.h"
   9
  10 #include "php_psi.h"
  11 #include "parser.h"
  12
  13 #if HAVE_LIBJIT
  14 # include "libjit.h"
  15 # ifndef HAVE_LIBFFI
  16 #  define PSI_ENGINE "jit"
  17 # endif
  18 #endif
  19 #if HAVE_LIBFFI
  20 # include "libffi.h"
  21 # define PSI_ENGINE "ffi"
  22 #endif
  23
  24 ZEND_DECLARE_MODULE_GLOBALS(psi);
  25
  26 PHP_INI_BEGIN()
  27         STD_PHP_INI_ENTRY("psi.engine", PSI_ENGINE, PHP_INI_SYSTEM, OnUpdateString, engine, zend_psi_globals, psi_globals)
  28         STD_PHP_INI_ENTRY("psi.directory", "psi.d", PHP_INI_SYSTEM, OnUpdateString, directory, zend_psi_globals, psi_globals)
  29 PHP_INI_END();
  30
  31 void psi_error(int type, const char *msg, ...)
  32 {
  33         char buf[0x1000];
  34         va_list argv;
  35
  36         va_start(argv, msg);
  37         vslprintf(buf, 0x1000, msg, argv);
  38         va_end(argv);
  39
  40         php_error(type, buf);
  41 }
  42
  43 size_t psi_t_alignment(token_t t)
  44 {
  45         size_t align;
  46 #define PSI_TAS_D(T) struct PSI_TAS_ ##T { \
  47         char c; \
  48         T x; \
  49 }
  50 #define PSI_TAS_P(T) struct PSI_TAS_ ## T ## _pointer { \
  51         char c; \
  52         T *x; \
  53 }
  54 #define PSI_TAS_C(T) align = offsetof(struct PSI_TAS_ ##T, x)
  55 #define PSI_TAS_CASE(T) { \
  56         PSI_TAS_D(T); \
  57         PSI_TAS_C(T); \
  58 }
  59         switch (t) {
  60         case PSI_T_INT8:
  61                 PSI_TAS_CASE(int8_t);
  62                 break;
  63         case PSI_T_UINT8:
  64                 PSI_TAS_CASE(uint8_t);
  65                 break;
  66         case PSI_T_INT16:
  67                 PSI_TAS_CASE(int16_t);
  68                 break;
  69         case PSI_T_UINT16:
  70                 PSI_TAS_CASE(uint16_t);
  71                 break;
  72         case PSI_T_INT32:
  73                 PSI_TAS_CASE(int32_t);
  74                 break;
  75         case PSI_T_UINT32:
  76                 PSI_TAS_CASE(uint32_t);
  77                 break;
  78         case PSI_T_INT64:
  79                 PSI_TAS_CASE(int64_t);
  80                 break;
  81         case PSI_T_UINT64:
  82                 PSI_TAS_CASE(uint64_t);
  83                 break;
  84         case PSI_T_FLOAT:
  85                 PSI_TAS_CASE(float);
  86                 break;
  87         case PSI_T_DOUBLE:
  88                 PSI_TAS_CASE(double);
  89                 break;
  90         case PSI_T_POINTER:
  91                 {
  92                         PSI_TAS_P(char);
  93                         PSI_TAS_C(char_pointer);
  94                 }
  95                 break;
  96         EMPTY_SWITCH_DEFAULT_CASE();
  97         }
  98
  99         return align;
 100 }
 101
 102 size_t psi_t_size(token_t t)
 103 {
 104         size_t size;
 105
 106         switch (t) {
 107         case PSI_T_INT8:
 108         case PSI_T_UINT8:
 109                 size = 1;
 110                 break;
 111         case PSI_T_INT16:
 112         case PSI_T_UINT16:
 113                 size = 2;
 114                 break;
 115         case PSI_T_INT:
 116                 size = sizeof(int);
 117                 break;
 118         case PSI_T_INT32:
 119         case PSI_T_UINT32:
 120                 size = 4;
 121                 break;
 122         case PSI_T_INT64:
 123         case PSI_T_UINT64:
 124                 size = 8;
 125                 break;
 126         case PSI_T_FLOAT:
 127                 size = sizeof(float);
 128                 break;
 129         case PSI_T_DOUBLE:
 130                 size = sizeof(double);
 131                 break;
 132         case PSI_T_POINTER:
 133                 size = sizeof(char *);
 134                 break;
 135         EMPTY_SWITCH_DEFAULT_CASE();
 136         }
 137         return size;
 138 }
 139
 140 size_t psi_t_align(token_t t, size_t s)
 141 {
 142         size_t a = psi_t_alignment(t);
 143         return ((s - 1) | (a - 1)) + 1;
 144 }
 145
 146 int psi_internal_type(impl_type *type)
 147 {
 148         switch (type->type) {
 149         case PSI_T_BOOL:
 150                 return _IS_BOOL;
 151         case PSI_T_INT:
 152                 return IS_LONG;
 153         case PSI_T_FLOAT:
 154         case PSI_T_DOUBLE:
 155                 return IS_DOUBLE;
 156         case PSI_T_STRING:
 157                 return IS_STRING;
 158         case PSI_T_ARRAY:
 159                 return IS_ARRAY;
 160         default:
 161                 return 0;
 162         }
 163 }
 164
 165 zend_internal_arg_info *psi_internal_arginfo(impl *impl)
 166 {
 167         size_t i;
 168         zend_internal_arg_info *aip;
 169         zend_internal_function_info *fi;
 170
 171         aip = calloc(impl->func->args->count + 1, sizeof(*aip));
 172
 173         fi = (zend_internal_function_info *) &aip[0];
 174         fi->required_num_args = psi_num_min_args(impl);
 175         fi->return_reference = impl->func->return_reference;
 176         fi->type_hint = psi_internal_type(impl->func->return_type);
 177
 178         for (i = 0; i < impl->func->args->count; ++i) {
 179                 impl_arg *iarg = impl->func->args->args[i];
 180                 zend_internal_arg_info *ai = &aip[i+1];
 181
 182                 ai->name = iarg->var->name;
 183                 ai->type_hint = psi_internal_type(iarg->type);
 184                 if (iarg->var->reference) {
 185                         ai->pass_by_reference = 1;
 186                 }
 187                 if (iarg->var->reference || (iarg->def && iarg->def->type == PSI_T_NULL)) {
 188                         ai->allow_null = 1;
 189                 }
 190         }
 191
 192         return aip;
 193 }
 194
 195 size_t psi_num_min_args(impl *impl)
 196 {
 197         size_t i, n = impl->func->args->count;
 198
 199         for (i = 0; i < impl->func->args->count; ++i) {
 200                 if (impl->func->args->args[i]->def) {
 201                         --n;
 202                 }
 203         }
 204         return n;
 205 }
 206
 207 void psi_to_bool(zval *return_value, set_value *set, impl_val *ret_val)
 208 {
 209         decl_var *var = set->vars->vars[0];
 210         token_t t = real_decl_type(var->arg->type)->type;
 211         impl_val *v = deref_impl_val(ret_val, var);
 212
 213         switch (t) {
 214         case PSI_T_FLOAT:
 215                 RETVAL_DOUBLE((double) v->fval);
 216                 break;
 217         case PSI_T_DOUBLE:
 218                 RETVAL_DOUBLE(v->dval);
 219                 break;
 220         default:
 221                 RETVAL_LONG(v->lval);
 222                 break;
 223         }
 224         convert_to_boolean(return_value);
 225 }
 226
 227 void psi_to_int(zval *return_value, set_value *set, impl_val *ret_val)
 228 {
 229         decl_var *var = set->vars->vars[0];
 230         token_t t = real_decl_type(var->arg->type)->type;
 231         impl_val *v = deref_impl_val(ret_val, var);
 232
 233         switch (t) {
 234         case PSI_T_FLOAT:
 235                 RETVAL_DOUBLE((double) v->fval);
 236                 break;
 237         case PSI_T_DOUBLE:
 238                 RETVAL_DOUBLE(v->dval);
 239                 break;
 240         default:
 241                 RETVAL_LONG(v->lval);
 242                 return;
 243         }
 244         convert_to_long(return_value);
 245 }
 246
 247 void psi_to_double(zval *return_value, set_value *set, impl_val *ret_val)
 248 {
 249         decl_var *var = set->vars->vars[0];
 250         token_t t = real_decl_type(var->arg->type)->type;
 251         impl_val *v = deref_impl_val(ret_val, var);
 252
 253         switch (t) {
 254         case PSI_T_FLOAT:
 255                 RETVAL_DOUBLE((double) v->fval);
 256                 break;
 257         case PSI_T_DOUBLE:
 258                 RETVAL_DOUBLE(v->dval);
 259                 break;
 260         default:
 261                 RETVAL_DOUBLE((double) v->lval);
 262                 break;
 263         }
 264 }
 265
 266 void psi_to_string(zval *return_value, set_value *set, impl_val *ret_val)
 267 {
 268         decl_var *var = set->vars->vars[0];
 269         token_t t = real_decl_type(var->arg->type)->type;
 270
 271         switch (t) {
 272         case PSI_T_INT8:
 273         case PSI_T_UINT8:
 274                 if (!var->arg->var->pointer_level) {
 275                         RETVAL_STRINGL(&ret_val->cval, 1);
 276                 } else {
 277                         ret_val = deref_impl_val(ret_val, var);
 278                         if (ret_val && ret_val->ptr) {
 279                                 RETVAL_STRING(ret_val->ptr);
 280                         } else {
 281                                 RETVAL_EMPTY_STRING();
 282                         }
 283                 }
 284                 return;
 285         case PSI_T_FLOAT:
 286                 RETVAL_DOUBLE((double) deref_impl_val(ret_val, var)->fval);
 287                 break;
 288         case PSI_T_DOUBLE:
 289                 RETVAL_DOUBLE(deref_impl_val(ret_val, var)->dval);
 290                 break;
 291         default:
 292                 RETVAL_LONG(deref_impl_val(ret_val, var)->lval);
 293                 break;
 294         }
 295         convert_to_string(return_value);
 296 }
 297
 298
 299 static impl_val *iterate(impl_val *val, size_t size, unsigned i, impl_val *tmp)
 300 {
 301         memset(tmp, 0, sizeof(*tmp));
 302         memcpy(tmp, ((void*) val->ptr) + size * i, size);
 303         return tmp;
 304 }
 305
 306 void psi_from_zval(impl_val *mem, decl_arg *spec, zval *zv, void **tmp)
 307 {
 308         decl_type *type = real_decl_type(spec->type);
 309
 310         switch (type->type) {
 311         case PSI_T_FLOAT:
 312                 mem->fval = (float) zval_get_double(zv);
 313                 break;
 314         case PSI_T_DOUBLE:
 315                 mem->dval = zval_get_double(zv);
 316                 break;
 317         case PSI_T_INT8:
 318         case PSI_T_UINT8:
 319                 if (spec->var->pointer_level) {
 320                         zend_string *zs = zval_get_string(zv);
 321                         *tmp = mem->ptr = estrndup(zs->val, zs->len);
 322                         zend_string_release(zs);
 323                         break;
 324                 }
 325                 /* no break */
 326         default:
 327                 mem->zend.lval = zval_get_long(zv);
 328                 break;
 329         }
 330 }
 331
 332 void *psi_array_to_struct(decl_struct *s, HashTable *arr)
 333 {
 334         size_t i, j = 0;
 335         char *mem = ecalloc(1, s->size + s->args->count * sizeof(void *));
 336
 337         if (arr) for (i = 0; i < s->args->count; ++i) {
 338                 decl_arg *darg = s->args->args[i];
 339                 zval *entry = zend_hash_str_find_ind(arr, darg->var->name, strlen(darg->var->name));
 340
 341                 if (entry) {
 342                         impl_val val;
 343                         void *tmp = NULL;
 344
 345                         memset(&tmp, 0, sizeof(tmp));
 346                         psi_from_zval(&val, darg, entry, &tmp);
 347                         memcpy(mem + darg->layout->pos, &val, darg->layout->len);
 348                         if (tmp) {
 349                                 ((void **)(mem + s->size))[j++] = tmp;
 350                         }
 351                 }
 352         }
 353         return mem;
 354 }
 355
 356 static inline impl_val *struct_member_ref(decl_arg *set_arg, impl_val *struct_ptr, impl_val **to_free) {
 357         void *ptr = (char *) struct_ptr->ptr + set_arg->layout->pos;
 358         impl_val *val = enref_impl_val(ptr, set_arg->var);
 359
 360         if (val != ptr) {
 361                 *to_free = val;
 362         }
 363
 364         return val;
 365 }
 366 void psi_to_array(zval *return_value, set_value *set, impl_val *r_val)
 367 {
 368         size_t i;
 369         decl_var *var = set->vars->vars[0];
 370         token_t t = real_decl_type(var->arg->type)->type;
 371         impl_val tmp, *ret_val = deref_impl_val(r_val, var);
 372
 373         array_init(return_value);
 374
 375         if (t == PSI_T_STRUCT) {
 376                 // decl_struct *s = real_decl_type(var->arg->type)->strct;
 377
 378                 if (set->count) {
 379                         /* explicit member casts */
 380                         for (i = 0; i < set->count; ++i) {
 381                                 set_value *sub_set = set->inner[i];
 382                                 decl_var *sub_var = sub_set->vars->vars[0];
 383
 384                                 sub_set->outer.val = r_val;
 385
 386                                 if (sub_var->arg) {
 387                                         impl_val *tmp = NULL, *val;
 388                                         zval ztmp;
 389
 390                                         val = deref_impl_val(struct_member_ref(sub_var->arg, ret_val, &tmp), sub_var);
 391                                         sub_set->func->handler(&ztmp, sub_set, val);
 392                                         add_assoc_zval(return_value, sub_var->name, &ztmp);
 393
 394                                         if (tmp) {
 395                                                 free(tmp);
 396                                         }
 397                                 }
 398                         }
 399                 }
 400                 return;
 401         }
 402
 403         if (var->arg->var->array_size) {
 404                 /* to_array(foo[NUMBER]) */
 405                 for (i = 0; i < var->arg->var->array_size; ++i) {
 406                         size_t size = psi_t_size(var->arg->var->pointer_level > 1 ? PSI_T_POINTER : t);
 407                         impl_val *ptr = iterate(ret_val, size, i, &tmp);
 408                         zval ele;
 409
 410                         switch (t) {
 411                         case PSI_T_FLOAT:
 412                                 ZVAL_DOUBLE(&ele, (double) ptr->fval);
 413                                 break;
 414                         case PSI_T_DOUBLE:
 415                                 ZVAL_DOUBLE(&ele, ptr->dval);
 416                                 break;
 417                         default:
 418                                 ZVAL_LONG(&ele, ptr->lval);
 419                                 break;
 420                         }
 421
 422                         add_next_index_zval(return_value, &ele);
 423                 }
 424                 return;
 425         } else if (set->vars->count > 1) {
 426                 /* to_array(arr_var, cnt_var[, cnt_var...], to_int(*arr_var))
 427                  * check for length in second var
 428                  */
 429                 size_t count = 0;
 430                 zval ele;
 431
 432                 if (set->outer.set) {
 433                         /* struct */
 434                         for (i = 1; i < set->vars->count; ++i) {
 435                                 impl_val *tmp = NULL, *cnt_val;
 436                                 decl_var *cnt_var = set->vars->vars[i];
 437
 438                                 cnt_val = struct_member_ref(cnt_var->arg, set->outer.val, &tmp);
 439                                 count += deref_impl_val(cnt_val, cnt_var)->lval;
 440
 441                                 if (tmp) {
 442                                         free(tmp);
 443                                 }
 444                         }
 445                 } else {
 446                         ZEND_ASSERT(0);
 447                 }
 448
 449                 for (i = 0; i < count; ++i) {
 450                         size_t size = psi_t_size(var->arg->var->pointer_level ? PSI_T_POINTER : t);
 451                         impl_val *ptr = iterate(ret_val, size, i, &tmp);
 452
 453                         set->inner[0]->func->handler(&ele, set->inner[0], ptr);
 454                         add_next_index_zval(return_value, &ele);
 455                 }
 456         } else {
 457                 ZEND_ASSERT(0);
 458         }
 459
 460 }
 461
 462 static inline ZEND_RESULT_CODE psi_parse_args(zend_execute_data *execute_data, impl *impl)
 463 {
 464         impl_arg *iarg;
 465
 466         if (!impl->func->args->count) {
 467                 return zend_parse_parameters_none();
 468         }
 469
 470         ZEND_PARSE_PARAMETERS_START(psi_num_min_args(impl), impl->func->args->count)
 471         nextarg:
 472                 iarg = impl->func->args->args[_i];
 473                 if (iarg->def) {
 474                         Z_PARAM_OPTIONAL;
 475                 }
 476                 if (PSI_T_BOOL == iarg->type->type) {
 477                         if (iarg->def) {
 478                                 iarg->val.zend.bval = iarg->def->type == PSI_T_TRUE ? 1 : 0;
 479                         }
 480                         Z_PARAM_BOOL(iarg->val.zend.bval);
 481                 } else if (PSI_T_INT == iarg->type->type) {
 482                         if (iarg->def) {
 483                                 iarg->val.zend.lval = zend_atol(iarg->def->text, strlen(iarg->def->text));
 484                         }
 485                         Z_PARAM_LONG(iarg->val.zend.lval);
 486                 } else if (PSI_T_FLOAT == iarg->type->type || PSI_T_DOUBLE == iarg->type->type) {
 487                         if (iarg->def) {
 488                                 iarg->val.dval = zend_strtod(iarg->def->text, NULL);
 489                         }
 490                         Z_PARAM_DOUBLE(iarg->val.dval);
 491                 } else if (PSI_T_STRING == iarg->type->type) {
 492                         struct {char *val; size_t len;} str;
 493                         if (iarg->def) {
 494                                 /* FIXME */
 495                                 str.len = strlen(iarg->def->text) - 2;
 496                                 str.val = &iarg->def->text[1];
 497                         }
 498                         Z_PARAM_STR_EX(iarg->val.zend.str, 1, 0);
 499                         if (iarg->val.zend.str) {
 500                                 zend_string_addref(iarg->val.zend.str);
 501                         } else if (iarg->def) {
 502                                 iarg->val.zend.str = zend_string_init(str.val, str.len, 0);
 503                         }
 504                 } else if (PSI_T_ARRAY == iarg->type->type) {
 505                         /* handled as _zv in let or set */
 506                         Z_PARAM_PROLOGUE(0);
 507                 } else {
 508                         error_code = ZPP_ERROR_FAILURE;
 509                         break;
 510                 }
 511                 iarg->_zv = _arg;
 512                 if (_i < _max_num_args) {
 513                         goto nextarg;
 514                 }
 515         ZEND_PARSE_PARAMETERS_END_EX(return FAILURE);
 516
 517         return SUCCESS;
 518 }
 519
 520 static inline void *psi_do_calloc(let_calloc *alloc)
 521 {
 522         decl_type *type = real_decl_type(alloc->type);
 523         size_t size;
 524
 525         if (type->type == PSI_T_STRUCT) {
 526                 /* psi_do_clean expects at least one NULL pointer after the struct */
 527                 size = type->strct->size + sizeof(void *);
 528         } else {
 529                 size = psi_t_size(type->type);
 530         }
 531
 532         return ecalloc(alloc->n, size);
 533 }
 534
 535 static inline void *psi_do_let(decl_arg *darg)
 536 {
 537         impl_arg *iarg = darg->let->arg;
 538         impl_val *arg_val;
 539
 540         darg->let->ptr = &darg->let->out;
 541         arg_val = darg->let->ptr;
 542
 543         if (!iarg) {
 544                 /* let foo = calloc(1, long);
 545                  * let foo = NULL;
 546                  * let foo;
 547                  */
 548                 if (darg->let->val->func && darg->let->val->func->type == PSI_T_CALLOC) {
 549                         arg_val->ptr = psi_do_calloc(darg->let->val->func->alloc);
 550                         darg->let->mem = arg_val->ptr;
 551                 } else if (darg->var->array_size) {
 552                         arg_val->ptr = ecalloc(darg->var->array_size, sizeof(*arg_val));
 553                         darg->let->mem = arg_val->ptr;
 554                 } else {
 555                         memset(arg_val, 0, sizeof(*arg_val));
 556                 }
 557         } else {
 558
 559                 switch (darg->let->val->func->type) {
 560                 case PSI_T_BOOLVAL:
 561                         if (iarg->type->type == PSI_T_BOOL) {
 562                                 arg_val->cval = iarg->val.zend.bval;
 563                         } else {
 564                                 arg_val->cval = zend_is_true(iarg->_zv);
 565                         }
 566                         break;
 567                 case PSI_T_INTVAL:
 568                         if (iarg->type->type == PSI_T_INT) {
 569                                 arg_val->lval = iarg->val.zend.lval;
 570                         } else {
 571                                 arg_val->lval = zval_get_long(iarg->_zv);
 572                         }
 573                         break;
 574                 case PSI_T_STRVAL:
 575                         if (iarg->type->type == PSI_T_STRING) {
 576                                 arg_val->ptr = estrdup(iarg->val.zend.str->val);
 577                                 darg->let->mem = arg_val->ptr;
 578                                 zend_string_release(iarg->val.zend.str);
 579                         } else {
 580                                 zend_string *zs = zval_get_string(iarg->_zv);
 581                                 arg_val->ptr = estrdup(zs->val);
 582                                 darg->let->mem = arg_val->ptr;
 583                                 zend_string_release(zs);
 584                         }
 585                         break;
 586                 case PSI_T_STRLEN:
 587                         if (iarg->type->type == PSI_T_STRING) {
 588                                 arg_val->lval = iarg->val.zend.str->len;
 589                                 zend_string_release(iarg->val.zend.str);
 590                         } else {
 591                                 zend_string *zs = zval_get_string(iarg->_zv);
 592                                 arg_val->lval = zs->len;
 593                                 zend_string_release(zs);
 594                         }
 595                         break;
 596                 case PSI_T_ARRVAL:
 597                         if (iarg->type->type == PSI_T_ARRAY) {
 598                                 decl_type *type = real_decl_type(darg->type);
 599
 600                                 switch (type->type) {
 601                                 case PSI_T_STRUCT:
 602                                         arg_val->ptr = psi_array_to_struct(type->strct, HASH_OF(iarg->_zv));
 603                                         darg->let->mem = arg_val->ptr;
 604                                         break;
 605                                 }
 606                         }
 607                         break;
 608                 EMPTY_SWITCH_DEFAULT_CASE();
 609                 }
 610         }
 611
 612         if (darg->let->val && darg->let->val->is_reference) {
 613                 return &darg->let->ptr;
 614         } else {
 615                 return darg->let->ptr;
 616         }
 617 }
 618
 619 static inline void psi_do_set(zval *return_value, set_value *set)
 620 {
 621         ZVAL_DEREF(return_value);
 622         zval_dtor(return_value);
 623
 624         set->func->handler(return_value, set, set->vars->vars[0]->arg->let->ptr);
 625 }
 626
 627 static inline void psi_do_return(zval *return_value, return_stmt *ret, impl_val *ret_val)
 628 {
 629         ret->set->func->handler(return_value, ret->set, ret_val);
 630 }
 631
 632 static inline void psi_do_free(free_stmt *fre)
 633 {
 634         size_t i, j;
 635         impl_val dummy;
 636
 637         for (i = 0; i < fre->calls->count; ++i) {
 638                 free_call *f = fre->calls->list[i];
 639
 640                 for (j = 0; j < f->vars->count; ++j) {
 641                         decl_var *dvar = f->vars->vars[j];
 642                         decl_arg *darg = dvar->arg;
 643
 644                         f->decl->call.args[j] = &darg->let->out;
 645                 }
 646
 647                 /* FIXME: check in validate_* that free functions return scalar */
 648                 PSI_ContextCall(&PSI_G(context), &dummy, f->decl);
 649         }
 650 }
 651
 652 static inline void psi_do_clean(impl *impl)
 653 {
 654         size_t i;
 655
 656         for (i = 0; i < impl->func->args->count; ++i ) {
 657                 impl_arg *iarg = impl->func->args->args[i];
 658
 659                 switch (iarg->type->type) {
 660                 case PSI_T_STRING:
 661                         if (iarg->val.zend.str) {
 662                                 zend_string_release(iarg->val.zend.str);
 663                         }
 664                         break;
 665                 }
 666         }
 667
 668         if (impl->decl->args) for (i = 0; i < impl->decl->args->count; ++i) {
 669                 decl_arg *darg = impl->decl->args->args[i];
 670
 671                 if (darg->let && darg->let->mem) {
 672                         decl_type *type = real_decl_type(darg->type);
 673
 674                         if (type->type == PSI_T_STRUCT) {
 675                                 void **ptr = (void **) ((char *) darg->let->mem + type->strct->size);
 676
 677                                 while (*ptr) {
 678                                         efree(*ptr++);
 679                                 }
 680                         }
 681                         efree(darg->let->mem);
 682                         darg->let->mem = NULL;
 683                 }
 684         }
 685 }
 686
 687 void psi_call(zend_execute_data *execute_data, zval *return_value, impl *impl)
 688 {
 689         impl_val ret_val;
 690         size_t i;
 691
 692         if (SUCCESS != psi_parse_args(execute_data, impl)) {
 693                 return;
 694         }
 695
 696         if (impl->decl->args) {
 697                 for (i = 0; i < impl->decl->args->count; ++i) {
 698                         decl_arg *darg = impl->decl->args->args[i];
 699
 700                         impl->decl->call.args[i] = psi_do_let(darg);
 701                 }
 702         }
 703
 704         memset(&ret_val, 0, sizeof(ret_val));
 705         PSI_ContextCall(&PSI_G(context), &ret_val, impl->decl);
 706
 707         psi_do_return(return_value, impl->stmts->ret.list[0], &ret_val);
 708
 709         for (i = 0; i < impl->stmts->set.count; ++i) {
 710                 set_stmt *set = impl->stmts->set.list[i];
 711
 712                 if (set->arg->_zv) {
 713                         psi_do_set(set->arg->_zv, set->val);
 714                 }
 715         }
 716
 717         for (i = 0; i < impl->stmts->fre.count; ++i) {
 718                 free_stmt *fre = impl->stmts->fre.list[i];
 719
 720                 psi_do_free(fre);
 721         }
 722
 723         psi_do_clean(impl);
 724 }
 725
 726 PHP_MINIT_FUNCTION(psi)
 727 {
 728         PSI_ContextOps *ops = NULL;
 729
 730         REGISTER_INI_ENTRIES();
 731
 732 #ifdef HAVE_LIBJIT
 733         if (!strcasecmp(PSI_G(engine), "jit")) {
 734                 ops = PSI_Libjit();
 735         } else
 736 #endif
 737 #ifdef HAVE_LIBFFI
 738                 ops = PSI_Libffi();
 739 #endif
 740
 741         if (!ops) {
 742                 php_error(E_WARNING, "No PSI engine found");
 743                 return FAILURE;
 744         }
 745
 746         PSI_ContextInit(&PSI_G(context), ops, psi_error);
 747         PSI_ContextBuild(&PSI_G(context), PSI_G(directory));
 748
 749         if (getenv("PSI_DUMP")) {
 750                 PSI_ContextDump(&PSI_G(context), STDOUT_FILENO);
 751         }
 752
 753         return SUCCESS;
 754 }
 755 PHP_MSHUTDOWN_FUNCTION(psi)
 756 {
 757         PSI_ContextDtor(&PSI_G(context));
 758
 759         UNREGISTER_INI_ENTRIES();
 760
 761         return SUCCESS;
 762 }
 763
 764 /* Remove if there's nothing to do at request start */
 765 /* {{{ PHP_RINIT_FUNCTION
 766  */
 767 PHP_RINIT_FUNCTION(psi)
 768 {
 769 #if defined(COMPILE_DL_PSI) && defined(ZTS)
 770         ZEND_TSRMLS_CACHE_UPDATE();
 771 #endif
 772         return SUCCESS;
 773 }
 774 /* }}} */
 775
 776 /* Remove if there's nothing to do at request end */
 777 /* {{{ PHP_RSHUTDOWN_FUNCTION
 778  */
 779 PHP_RSHUTDOWN_FUNCTION(psi)
 780 {
 781         return SUCCESS;
 782 }
 783 /* }}} */
 784
 785 PHP_MINFO_FUNCTION(psi)
 786 {
 787         php_info_print_table_start();
 788         php_info_print_table_header(2, "psi support", "enabled");
 789         php_info_print_table_end();
 790
 791         DISPLAY_INI_ENTRIES();
 792 }
 793 const zend_function_entry psi_functions[] = {
 794         PHP_FE_END
 795 };
 796
 797 zend_module_entry psi_module_entry = {
 798         STANDARD_MODULE_HEADER,
 799         "psi",
 800         psi_functions,
 801         PHP_MINIT(psi),
 802         PHP_MSHUTDOWN(psi),
 803         PHP_RINIT(psi),         /* Replace with NULL if there's nothing to do at request start */
 804         PHP_RSHUTDOWN(psi),     /* Replace with NULL if there's nothing to do at request end */
 805         PHP_MINFO(psi),
 806         PHP_PSI_VERSION,
 807         STANDARD_MODULE_PROPERTIES
 808 };
 809
 810 #ifdef COMPILE_DL_PSI
 811 #ifdef ZTS
 812 ZEND_TSRMLS_CACHE_DEFINE();
 813 #endif
 814 ZEND_GET_MODULE(psi)
 815 #endif
 816
 817 /*
 818  * Local variables:
 819  * tab-width: 4
 820  * c-basic-offset: 4
 821  * End:
 822  * vim600: noet sw=4 ts=4 fdm=marker
 823  * vim<600: noet sw=4 ts=4
 824  */