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

   1 #ifdef HAVE_CONFIG_H
   2 # include "config.h"
   3 #endif
   4
   5 #include "php.h"
   6
   7 #include <stdio.h>
   8 #ifdef HAVE_SYS_TYPES_H
   9 # include <sys/types.h>
  10 #endif
  11 #ifdef HAVE_SYS_STAT_H
  12 # include <sys/stat.h>
  13 #endif
  14 #ifdef STDC_HEADERS
  15 # include <stdlib.h>
  16 # include <stddef.h>
  17 #else
  18 # ifdef HAVE_STDLIB_H
  19 #  include <stdlib.h>
  20 # endif
  21 #endif
  22 #ifdef HAVE_STRING_H
  23 # if !defined STDC_HEADERS && defined HAVE_MEMORY_H
  24 #  include <memory.h>
  25 # endif
  26 # include <string.h>
  27 #endif
  28 #ifdef HAVE_STRINGS_H
  29 # include <strings.h>
  30 #endif
  31 #ifdef HAVE_INTTYPES_H
  32 # include <inttypes.h>
  33 #endif
  34 #ifdef HAVE_STDINT_H
  35 # include <stdint.h>
  36 #endif
  37 #ifdef HAVE_UNISTD_H
  38 # include <unistd.h>
  39 #endif
  40
  41 #ifdef HAVE_ERRNO_H
  42 # include <errno.h>
  43 #endif
  44 #ifdef HAVE_GLOB_H
  45 # include <glob.h>
  46 #endif
  47 #ifdef HAVE_NETINET_IN_H
  48 # include <netinet/in.h>
  49 #endif
  50 #ifdef HAVE_ARPA_NAMESER_H
  51 # include <arpa/nameser.h>
  52 #endif
  53 #ifdef HAVE_NETDB_H
  54 # include <netdb.h>
  55 #endif
  56 #ifdef HAVE_RESOLV_H
  57 # include <resolv.h>
  58 #endif
  59 #ifdef HAVE_SYS_SELECT_H
  60 # include <sys/select.h>
  61 #endif
  62 #ifdef HAVE_SYS_SOCKET_H
  63 # include <sys/socket.h>
  64 #endif
  65 #ifdef HAVE_SYS_TIME_H
  66 # include <sys/time.h>
  67 #endif
  68 #ifdef HAVE_SYS_TIMES_H
  69 # include <sys/times.h>
  70 #endif
  71 #ifdef HAVE_SYS_UIO_H
  72 # include <sys/uio.h>
  73 #endif
  74 #ifdef HAVE_SYS_UTSNAME_H
  75 # include <sys/utsname.h>
  76 #endif
  77 #ifdef HAVE_TIME_H
  78 # include <time.h>
  79 #endif
  80 #ifdef HAVE_SYSLOG_H
  81 # include <syslog.h>
  82 #endif
  83 #ifdef HAVE_WCHAR_H
  84 # include <wchar.h>
  85 #endif
  86
  87 #ifdef HAVE_DIRENT_H
  88 # include <dirent.h>
  89 # define NAMLEN(dirent) strlen ((dirent)->d_name)
  90 #else
  91 # define dirent direct
  92 # define NAMLEN(dirent) ((dirent)->d_namlen)
  93 # ifdef HAVE_SYS_NDIR_H
  94 #  include <sys/ndir.h>
  95 # endif
  96 # ifdef HAVE_SYS_DIR_H
  97 #  include <sys/dir.h>
  98 # endif
  99 # ifdef HAVE_NDIR_H
 100 #  include <ndir.h>
 101 # endif
 102 #endif
 103
 104 #include <sys/param.h>
 105 #include <dlfcn.h>
 106 #include <fnmatch.h>
 107
 108 #include "php.h"
 109 #include "php_scandir.h"
 110 #include "php_psi.h"
 111
 112 #include "libjit.h"
 113 #include "libffi.h"
 114
 115 static struct psi_std_type {
 116         token_t type_tag;
 117         const char *type_name;
 118 } psi_std_types[] = {
 119         {PSI_T_FLOAT, "float"},
 120         {PSI_T_DOUBLE, "double"},
 121         {PSI_T_INT8, "int8_t"},
 122         {PSI_T_INT16, "int16_t"},
 123         {PSI_T_INT32, "int32_t"},
 124         {PSI_T_INT64, "int64_t"},
 125         {PSI_T_UINT8, "uint8_t"},
 126         {PSI_T_UINT16, "uint16_t"},
 127         {PSI_T_UINT32, "uint32_t"},
 128         {PSI_T_UINT64, "uint64_t"},
 129         {0}
 130 };
 131
 132 static struct psi_predef_type {
 133         token_t type_tag;
 134         const char *type_name;
 135         const char *alias;
 136 } psi_predef_types[] = {
 137         PSI_TYPES
 138         {0}
 139 };
 140
 141 static struct psi_predef_const {
 142         token_t type_tag;
 143         const char *type_name;
 144         const char *var_name;
 145         const char *val_text;
 146         token_t val_type_tag;
 147 } psi_predef_consts[] = {
 148         PSI_CONSTS
 149         {0}
 150 };
 151
 152 PSI_MACROS
 153
 154 int psi_glob(const char *pattern, int flags,
 155                int (*errfunc) (const char *epath, int eerrno),
 156                glob_t *pglob) {
 157         size_t offs = flags & GLOB_DOOFFS ? pglob->gl_offs : 0;
 158         int rv = glob(pattern, flags, errfunc, pglob);
 159         if (pglob->gl_pathv) {
 160                 while (offs--) {
 161                         pglob->gl_pathv[offs] = NULL;
 162                 }
 163         }
 164         return rv;
 165 }
 166
 167 static struct psi_func_redir {
 168         const char *name;
 169         void (*func)(void);
 170 } psi_func_redirs[] = {
 171         {"glob", (void (*)(void)) psi_glob},
 172         PSI_REDIRS
 173         {0}
 174 };
 175
 176 static struct psi_predef_decl {
 177         token_t type_tag;
 178         const char *type_name;
 179         const char *var_name;
 180         size_t pointer_level;
 181         size_t array_size;
 182 } psi_predef_decls[] = {
 183         PSI_DECLS
 184         {0}
 185 };
 186 static struct psi_predef_decl psi_predef_vararg_decls[] = {
 187         PSI_VA_DECLS
 188         {0}
 189 };
 190
 191 static struct psi_predef_struct {
 192         token_t type_tag;
 193         const char *type_name;
 194         const char *var_name;
 195         size_t offset;
 196         size_t size;
 197         size_t pointer_level;
 198         size_t array_size;
 199 } psi_predef_structs[] = {
 200         PSI_STRUCTS
 201         {0}
 202 };
 203
 204 static int validate_lib(PSI_Data *data, void **dlopened) {
 205         char lib[MAXPATHLEN];
 206         const char *ptr = data->psi.file.ln;
 207         size_t len;
 208
 209         if (!ptr) {
 210                 /* FIXME: assume stdlib */
 211                 return 1;
 212         } else if (!strchr(ptr, '/')) {
 213                 len = snprintf(lib, MAXPATHLEN, "lib%s.%s", ptr, PHP_PSI_SHLIB_SUFFIX);
 214                 if (MAXPATHLEN == len) {
 215                         data->error(NULL, PSI_WARNING, "Library name too long: '%s'", ptr);
 216                 }
 217                 lib[len] = 0;
 218                 ptr = lib;
 219         }
 220         if (!(*dlopened = dlopen(ptr, RTLD_LAZY|RTLD_LOCAL))) {
 221                 data->error(NULL, PSI_WARNING, "Could not open library '%s': %s.",
 222                                 data->psi.file.ln, dlerror());
 223                 return 0;
 224         }
 225         return 1;
 226 }
 227
 228 static inline int locate_decl_type_alias(decl_typedefs *defs, decl_type *type) {
 229         size_t i;
 230         struct psi_std_type *stdtyp;
 231
 232         if (type->real) {
 233                 return 1;
 234         }
 235         for (i = 0; i < defs->count; ++i) {
 236                 decl_typedef *def = defs->list[i];
 237
 238                 if (def->type->type != type->type && !strcmp(def->alias, type->name)) {
 239                         type->real = def->type;
 240                         return 1;
 241                 }
 242         }
 243         for (stdtyp = &psi_std_types[0]; stdtyp->type_tag; ++stdtyp) {
 244                 if (!strcmp(type->name, stdtyp->type_name)) {
 245                         type->type = stdtyp->type_tag;
 246                         return 1;
 247                 }
 248         }
 249
 250         return 0;
 251 }
 252 static inline int locate_decl_type_struct(decl_structs *structs, decl_type *type) {
 253         size_t i;
 254
 255         if (type->strct) {
 256                 return 1;
 257         }
 258         for (i = 0; i < structs->count; ++i) {
 259                 if (!strcmp(structs->list[i]->name, type->name)) {
 260                         type->strct = structs->list[i];
 261                         return 1;
 262                 }
 263         }
 264         return 0;
 265 }
 266
 267 static inline int validate_decl_type(PSI_Data *data, decl_type *type) {
 268         switch (type->type) {
 269         case PSI_T_NAME:
 270                 if (!data->defs || !locate_decl_type_alias(data->defs, type)) {
 271                         return 0;
 272                 }
 273                 if (type->real) {
 274                         return validate_decl_type(data, type->real);
 275                 }
 276                 return 1;
 277         case PSI_T_STRUCT:
 278                 if (!data->structs || !locate_decl_type_struct(data->structs, type)) {
 279                         return 0;
 280                 }
 281                 break;
 282         }
 283         return 1;
 284 }
 285 static inline int validate_decl_typedef(PSI_Data *data, decl_typedef *def) {
 286         if (!validate_decl_type(data, def->type)) {
 287                 data->error(def->token, PSI_WARNING,
 288                         "Type '%s' cannot be aliased to %s'%s'",
 289                         def->type->name, def->type->type == PSI_T_STRUCT?"struct ":"",def->alias);
 290                 return 0;
 291         }
 292         /* FIXME: check def->alias */
 293         return 1;
 294 }
 295
 296 static inline int validate_constant(PSI_Data *data, constant *c) {
 297         /* FIXME */
 298         return 1;
 299 }
 300
 301 static inline int validate_decl_arg(PSI_Data *data, decl_arg *arg) {
 302         if (!validate_decl_type(data, arg->type)) {
 303                 data->error(arg->type->token, PSI_WARNING,
 304                         "Cannot use '%s'(%d) as type for decl var '%s'",
 305                         arg->type->name, arg->type->type, arg->var->name);
 306                 return 0;
 307         }
 308         return 1;
 309 }
 310
 311 static inline int validate_decl_struct(PSI_Data *data, decl_struct *s) {
 312         size_t i;
 313
 314         for (i = 0; i < s->args->count; ++i) {
 315                 if (!validate_decl_arg(data, s->args->args[i])) {
 316                         return 0;
 317                 }
 318         }
 319
 320         for (i = 0; i < s->args->count; ++i) {
 321                 decl_arg *darg = s->args->args[i];
 322
 323                 if (!validate_decl_arg(data, darg)) {
 324                         return 0;
 325                 }
 326
 327                 ZEND_ASSERT(!darg->var->arg || darg->var->arg == darg);
 328                 darg->var->arg = darg;
 329
 330                 if (!darg->layout) {
 331                         token_t t;
 332
 333                         if (darg->var->pointer_level && (!darg->var->array_size || darg->var->pointer_level == 1)) {
 334                                 t = PSI_T_POINTER;
 335                         } else {
 336                                 t = real_decl_type(darg->type)->type;
 337                         }
 338
 339                         if (i) {
 340                                 decl_arg *last = s->args->args[i-1];
 341                                 darg->layout = init_decl_struct_layout(
 342                                                 psi_t_align(t, last->layout->pos + last->layout->len),
 343                                                 psi_t_size(t) * darg->var->array_size);
 344                         } else {
 345                                 darg->layout = init_decl_struct_layout(0, psi_t_size(t));
 346                         }
 347                 }
 348                 if (s->size < darg->layout->pos + darg->layout->len) {
 349                         s->size = darg->layout->pos + darg->layout->len;
 350                 }
 351         }
 352         return 1;
 353 }
 354
 355 static const char * const abi_ccs[] = {
 356                 "default", /* \                 */
 357                 "extern",  /*  > - all the same */
 358                 "cdecl",   /* /                 */
 359                 "stdcall",
 360                 "fastcall",
 361 };
 362 static inline int validate_decl_abi(PSI_Data *data, decl_abi *abi) {
 363         size_t i;
 364
 365         for (i = 0; i < sizeof(abi_ccs)/sizeof(char*); ++i) {
 366                 if (strcasecmp(abi->convention, abi_ccs[i])) {
 367                         return 1;
 368                 }
 369         }
 370         return 0;
 371 }
 372 static inline int validate_decl_func(PSI_Data *data, void *dl, decl *decl, decl_arg *func)
 373 {
 374         struct psi_func_redir *redir;
 375
 376         if (!strcmp(func->var->name, "dlsym")) {
 377                 data->error(func->token, PSI_WARNING, "Cannot dlsym dlsym (sic!)");
 378                 return 0;
 379         }
 380
 381         if (!validate_decl_arg(data, func)) {
 382                 return 0;
 383         }
 384         for (redir = &psi_func_redirs[0]; redir->name; ++redir) {
 385                 if (!strcmp(func->var->name, redir->name)) {
 386                         decl->call.sym = redir->func;
 387                 }
 388         }
 389         if (!decl->call.sym) {
 390 #ifndef RTLD_NEXT
 391 # define RTLD_NEXT ((void *) -1l)
 392 #endif
 393                 decl->call.sym = dlsym(dl ?: RTLD_NEXT, func->var->name);
 394                 if (!decl->call.sym) {
 395                         data->error(func->token, PSI_WARNING,
 396                                 "Failed to locate symbol '%s': %s",
 397                                 func->var->name, dlerror());
 398                 }
 399         }
 400         return 1;
 401 }
 402
 403 static inline int validate_decl(PSI_Data *data, void *dl, decl *decl) {
 404         if (!validate_decl_abi(data, decl->abi)) {
 405                 data->error(decl->abi->token, PSI_WARNING,
 406                                 "Invalid calling convention: '%s'", decl->abi->token->text);
 407                 return 0;
 408         }
 409         if (!validate_decl_func(data, dl, decl, decl->func)) {
 410                 return 0;
 411         }
 412         if (decl->args) {
 413                 size_t i;
 414
 415                 for (i = 0; i < decl->args->count; ++i) {
 416                         if (!validate_decl_arg(data, decl->args->args[i])) {
 417                                 return 0;
 418                         }
 419                 }
 420         }
 421         return 1;
 422 }
 423 static inline decl_arg *locate_decl_var_arg(decl_var *var, decl_args *args, decl_arg *func) {
 424         size_t i;
 425
 426         for (i = 0; i < args->count; ++i) {
 427                 decl_arg *arg = args->args[i];
 428
 429                 if (!strcmp(var->name, arg->var->name)) {
 430                         ZEND_ASSERT(!var->arg || var->arg == arg);
 431                         return var->arg = arg;
 432                 }
 433         }
 434         if (func && !strcmp(var->name, func->var->name)) {
 435                 return var->arg = func;
 436         }
 437
 438         return NULL;
 439 }
 440 static inline decl_arg *locate_struct_member(decl_struct *s, decl_var *var) {
 441         if (s->args) {
 442                 return locate_decl_var_arg(var, s->args, NULL);
 443         }
 444
 445         return NULL;
 446 }
 447 static inline constant *locate_num_exp_constant(num_exp *exp, constants *consts) {
 448         size_t i;
 449
 450         for (i = 0; i < consts->count; ++i) {
 451                 constant *cnst = consts->list[i];
 452
 453                 if (!strcmp(cnst->name, exp->u.numb)) {
 454                         free(exp->u.numb);
 455                         return exp->u.cnst = cnst;
 456                 }
 457         }
 458
 459         return NULL;
 460 }
 461 static inline int validate_num_exp(PSI_Data *data, decl_args *dargs, decl_arg *func, num_exp *exp) {
 462         if (exp->operand) {
 463                 switch (exp->operator) {
 464                 case PSI_T_PLUS:
 465                         exp->calculator = psi_calc_add;
 466                         break;
 467                 case PSI_T_MINUS:
 468                         exp->calculator = psi_calc_sub;
 469                         break;
 470                 case PSI_T_ASTERISK:
 471                         exp->calculator = psi_calc_mul;
 472                         break;
 473                 case PSI_T_SLASH:
 474                         exp->calculator = psi_calc_div;
 475                         break;
 476                 EMPTY_SWITCH_DEFAULT_CASE();
 477                 }
 478                 if (!validate_num_exp(data, dargs, func, exp->operand)) {
 479                         return 0;
 480                 }
 481         }
 482         switch (exp->t) {
 483         case PSI_T_NAME:
 484                 if (!locate_decl_var_arg(exp->u.dvar, dargs, func)) {
 485                         data->error(exp->token, PSI_WARNING, "Unknown variable '%s' in numeric expression",
 486                                         exp->u.dvar->name);
 487                         return 0;
 488                 }
 489                 return 1;
 490         case PSI_T_NSNAME:
 491                 if (!locate_num_exp_constant(exp, data->consts)) {
 492                         data->error(exp->token, PSI_WARNING, "Unknown constant '%s' in numeric expression",
 493                                         exp->u.numb);
 494                         return 0;
 495                 }
 496                 return 1;
 497         case PSI_T_NUMBER:
 498                 return 1;
 499         default:
 500                 return 0;
 501         }
 502 }
 503 static inline int validate_set_value_handler(set_value *set) {
 504         switch (set->func->type) {
 505         case PSI_T_TO_BOOL:
 506                 set->func->handler = psi_to_bool;
 507                 break;
 508         case PSI_T_TO_INT:
 509                 set->func->handler = psi_to_int;
 510                 break;
 511         case PSI_T_TO_FLOAT:
 512                 set->func->handler = psi_to_double;
 513                 break;
 514         case PSI_T_TO_STRING:
 515                 set->func->handler = psi_to_string;
 516                 break;
 517         case PSI_T_TO_ARRAY:
 518                 set->func->handler = psi_to_array;
 519                 break;
 520         case PSI_T_TO_OBJECT:
 521                 set->func->handler = psi_to_object;
 522                 break;
 523         case PSI_T_VOID:
 524                 set->func->handler = psi_to_void;
 525                 break;
 526         default:
 527                 return 0;
 528         }
 529         return 1;
 530 }
 531 static inline void decl_var_arg_v(decl_args *args, va_list argp) {
 532         int argc;
 533         decl_arg **argv;
 534
 535         memset(args, 0, sizeof(*args));
 536
 537         while ((argc = va_arg(argp, int))) {
 538                 argv = va_arg(argp, decl_arg **);
 539                 while (argc--) {
 540                         add_decl_arg(args, *argv++);
 541                 }
 542         }
 543 }
 544 static inline int validate_set_value_ex(PSI_Data *data, set_value *set, decl_arg *ref, decl_args *ref_list) {
 545         size_t i;
 546         decl_type *ref_type;
 547         decl_var *set_var = set->vars->vars[0];
 548
 549         if (!validate_set_value_handler(set)) {
 550                 data->error(set->func->token, PSI_WARNING, "Invalid cast '%s'", set->func->name);
 551                 return 0;
 552         }
 553
 554         for (i = 0; i < set->vars->count; ++i) {
 555                 decl_var *svar = set->vars->vars[i];
 556                 if (!svar->arg && !locate_decl_var_arg(svar, ref_list, NULL)) {
 557                         data->error(svar->token, PSI_WARNING, "Unknown variable '%s'", svar->name);
 558                         return 0;
 559                 }
 560         }
 561
 562         if (!ref) {
 563                 ref = set_var->arg;
 564         }
 565         ref_type = real_decl_type(ref->type);
 566
 567         if (set->count) {
 568                 int is_to_array = (set->func->type == PSI_T_TO_ARRAY);
 569                 int is_pointer_to_struct = (ref_type->type == PSI_T_STRUCT && ref->var->pointer_level);
 570
 571                 if (!is_to_array && !is_pointer_to_struct) {
 572                         data->error(set->func->token, E_WARNING, "Inner `set` statement casts only work with "
 573                                         "to_array() casts on structs or pointers: %s(%s...", set->func->name, set->vars->vars[0]->name);
 574                         return 0;
 575                 }
 576         }
 577         if (set->num) {
 578                 if (!validate_num_exp(data, ref_list, ref, set->num)) {
 579                         return 0;
 580                 }
 581         }
 582
 583         if (ref_type->type == PSI_T_STRUCT) {
 584                 /* to_array(struct, to_...) */
 585                 for (i = 0; i < set->count; ++i) {
 586                         decl_var *sub_var = set->inner[i]->vars->vars[0];
 587                         decl_arg *sub_ref = locate_struct_member(ref_type->strct, sub_var);
 588
 589                         set->inner[i]->outer.set = set;
 590                         if (sub_ref) {
 591                                 if (!validate_set_value_ex(data, set->inner[i], sub_ref, ref_type->strct->args)) {
 592                                         return 0;
 593                                 }
 594                         }
 595                 }
 596         } else if (set->count == 1) {
 597                 /* to_array(ptr, to_string(*ptr)) */
 598                 decl_var *sub_var = set->inner[0]->vars->vars[0];
 599                 decl_arg *sub_ref = locate_decl_var_arg(sub_var, ref_list, ref);
 600
 601                 set->inner[0]->outer.set = set;
 602                 if (sub_ref) {
 603                         if (strcmp(sub_var->name, set_var->name)) {
 604                                 data->error(sub_var->token, E_WARNING, "Inner `set` statement casts on pointers must reference the same variable");
 605                                 return 0;
 606                         }
 607                         if (!validate_set_value_ex(data, set->inner[0], sub_ref, ref_list)) {
 608                                 return 0;
 609                         }
 610                 }
 611         } else if (set->count > 1) {
 612                 data->error(set->func->token, E_WARNING, "Inner `set` statement casts on pointers may only occur once");
 613                 return 0;
 614         }
 615
 616         return 1;
 617 }
 618 static inline int validate_set_value(PSI_Data *data, set_value *set, ...) {
 619         va_list argp;
 620         decl_args args = {0};
 621         int check;
 622
 623         va_start(argp, set);
 624         decl_var_arg_v(&args, argp);
 625         va_end(argp);
 626
 627         check = validate_set_value_ex(data, set, NULL, &args);
 628         if (args.args) {
 629                 free(args.args);
 630         }
 631         return check;
 632 }
 633 static inline decl *locate_impl_decl(decls *decls, return_stmt *ret) {
 634         if (decls) {
 635                 size_t i;
 636
 637                 for (i = 0; i < decls->count; ++i) {
 638                         if (!strcmp(decls->list[i]->func->var->name, ret->set->vars->vars[0]->name)) {
 639                                 ret->decl = decls->list[i]->func;
 640                                 return decls->list[i];
 641                         }
 642                 }
 643         }
 644
 645         return NULL;
 646 }
 647 static inline int validate_impl_ret_stmt(PSI_Data *data, impl *impl) {
 648         return_stmt *ret;
 649
 650         /* we must have exactly one ret stmt delcaring the native func to call */
 651         /* and which type cast to apply */
 652         if (impl->stmts->ret.count != 1) {
 653                 if (impl->stmts->ret.count > 1) {
 654                         data->error(impl->stmts->ret.list[1]->token, PSI_WARNING,
 655                                         "Too many `return` statements for implmentation %s;"
 656                                         " found %zu, exactly one is needed",
 657                                         impl->func->name, impl->stmts->ret.count);
 658                 } else {
 659                         data->error(impl->func->token, PSI_WARNING,
 660                                         "Missing `return` statement for implementation %s",
 661                                         impl->func->name);
 662                 }
 663                 return 0;
 664         }
 665
 666         ret = impl->stmts->ret.list[0];
 667
 668         if (!(impl->decl = locate_impl_decl(data->decls, ret))) {
 669                 data->error(ret->token, PSI_WARNING,
 670                                 "Missing declaration '%s' for `return` statment for implementation %s",
 671                                 ret->set->vars->vars[0]->name, impl->func->name);
 672                 return 0;
 673         }
 674
 675         if (!validate_set_value(data, ret->set, 1, &ret->decl, impl->decl->args ? (int) impl->decl->args->count : 0, impl->decl->args ? impl->decl->args->args : NULL, 0)) {
 676                 return 0;
 677         }
 678
 679         impl->decl->impl = impl;
 680
 681         return 1;
 682 }
 683
 684 static inline int validate_impl_let_stmts(PSI_Data *data, impl *impl) {
 685         size_t i, j;
 686         /* we can have multiple let stmts */
 687
 688         /* check that we have a decl arg for every let stmt */
 689         for (i = 0; i < impl->stmts->let.count; ++i) {
 690                 let_stmt *let = impl->stmts->let.list[i];
 691                 decl_var *let_var;
 692                 int check = 0;
 693
 694                 if (let->val && let->val->kind == PSI_LET_TMP) {
 695                         let_var = let->val->data.var;
 696                 } else {
 697                         let_var = let->var;
 698                 }
 699
 700                 if (!locate_decl_var_arg(let_var, impl->decl->args, impl->decl->func)) {
 701                         data->error(let_var->token, PSI_WARNING, "Unknown variable '%s' in `let` statement"
 702                                         " of implementation '%s'", let_var->name, impl->func->name);
 703                         return 0;
 704                 }
 705
 706                 switch (let->val->kind) {
 707                 case PSI_LET_NULL:
 708                         break;
 709                 case PSI_LET_TMP:
 710                         /* e.g. let bar = &strval($bar); // decl_arg(char **bar) */
 711                         /* e.g. let foo = *bar;  */
 712                         let->var->pointer_level = let->val->data.var->pointer_level;
 713                         let->var->arg = init_decl_arg(
 714                                         init_decl_type(
 715                                                         real_decl_type(let->val->data.var->arg->type)->type,
 716                                                         real_decl_type(let->val->data.var->arg->type)->name),
 717                                         init_decl_var(
 718                                                         let->var->name,
 719                                                         let->var->pointer_level,
 720                                                         let->var->array_size));
 721                         break;
 722                 case PSI_LET_NUMEXP:
 723                         if (!validate_num_exp(data, impl->decl->args, impl->decl->func, let->val->data.num)) {
 724                                 return 0;
 725                         }
 726                         break;
 727                 case PSI_LET_CALLOC:
 728                         if (!validate_num_exp(data, impl->decl->args, impl->decl->func, let->val->data.alloc->nmemb)) {
 729                                 return 0;
 730                         }
 731                         if (!validate_num_exp(data, impl->decl->args, impl->decl->func, let->val->data.alloc->size)) {
 732                                 return 0;
 733                         }
 734                         break;
 735                 case PSI_LET_FUNC:
 736                         if (impl->func->args) {
 737                                 for (j = 0; j < impl->func->args->count; ++j) {
 738                                         impl_arg *iarg = impl->func->args->args[j];
 739
 740                                         if (!strcmp(let->val->data.func->var->name, iarg->var->name)) {
 741                                                 let->val->data.func->arg = iarg;
 742                                                 check = 1;
 743                                                 break;
 744                                         }
 745                                 }
 746                         }
 747                         if (!check) {
 748                                 data->error(let->var->token, PSI_WARNING, "Unknown value '$%s' of `let` statement"
 749                                                 " for variable '%s' of implementation '%s'",
 750                                                 let->val->data.func->var->name, let->var->name, impl->func->name);
 751                                 return 0;
 752                         }
 753                         break;
 754                 }
 755         }
 756
 757         /* check that we have a let stmt for every decl arg */
 758         if (impl->decl->args) for (i = 0; i < impl->decl->args->count; ++i) {
 759                 decl_arg *darg = impl->decl->args->args[i];
 760                 int check = 0;
 761
 762                 for (j = 0; j < impl->stmts->let.count; ++j) {
 763                         let_stmt *let = impl->stmts->let.list[j];
 764
 765                         if (!strcmp(let->var->name, darg->var->name)) {
 766                                 darg->let = let;
 767                                 check = 1;
 768                                 break;
 769                         }
 770                 }
 771                 if (!check) {
 772                         data->error(impl->func->token, PSI_WARNING,
 773                                         "Missing `let` statement for arg '%s %.*s%s'"
 774                                         " of declaration '%s' for implementation '%s'",
 775                                         darg->type->name, (int) darg->var->pointer_level, "*****",
 776                                         darg->var->name, impl->decl->func->var->name, impl->func->name);
 777                         return 0;
 778                 }
 779         }
 780
 781         return 1;
 782 }
 783 static inline int validate_impl_set_stmts(PSI_Data *data, impl *impl) {
 784         size_t i, j, k;
 785         /* we can have any count of set stmts; processing out vars */
 786         /* check that set stmts reference known variables */
 787         for (i = 0; i < impl->stmts->set.count; ++i) {
 788                 set_stmt *set = impl->stmts->set.list[i];
 789                 int check = 0;
 790
 791                 if (impl->func->args) for (j = 0; j < impl->func->args->count; ++j) {
 792                         impl_arg *iarg = impl->func->args->args[j];
 793
 794                         if (!strcmp(set->var->name, iarg->var->name)) {
 795                                 set->arg = iarg;
 796                                 check = 1;
 797                                 break;
 798                         }
 799                 }
 800                 if (!check) {
 801                         data->error(set->var->token, PSI_WARNING, "Unknown variable '$%s' of `set` statement"
 802                                         " of implementation '%s'",
 803                                         set->var->name, impl->func->name);
 804                         return 0;
 805                 }
 806
 807                 for (j = 0; j < set->val->vars->count; ++j) {
 808                         decl_var *set_var = set->val->vars->vars[j];
 809
 810                         check = 0;
 811                         if (impl->decl->args) {
 812                                 for (k = 0; k < impl->decl->args->count; ++k) {
 813                                         decl_arg *set_arg = impl->decl->args->args[k];
 814
 815                                         if (!strcmp(set_var->name, set_arg->var->name)) {
 816                                                 check = 1;
 817                                                 set_var->arg = set_arg;
 818                                                 if (!validate_set_value(data, set->val, 1, &set_arg, 1, &impl->decl->func, impl->decl->args->count, impl->decl->args->args, 0)) {
 819                                                         return 0;
 820                                                 }
 821                                                 break;
 822                                         }
 823                                 }
 824                         }
 825                         if (!check) {
 826                                 for (k = 0; k < impl->stmts->let.count; ++k) {
 827                                         let_stmt *let = impl->stmts->let.list[k];
 828
 829                                         /* check temp vars */
 830                                         if (let->val && let->val->kind == PSI_LET_TMP) {
 831                                                 if (!strcmp(set_var->name, let->var->name)) {
 832                                                         check = 1;
 833                                                         set_var->arg = let->var->arg;
 834                                                         if (!validate_set_value(data, set->val, 1, &set_var->arg, 1, &impl->decl->func, impl->decl->args->count, impl->decl->args->args, 0)) {
 835                                                                 return 0;
 836                                                         }
 837                                                         break;
 838                                                 }
 839                                         }
 840                                 }
 841                         }
 842
 843                         if (!check) {
 844                                 data->error(set_var->token, PSI_WARNING, "Unknown value '%s' of `set` statement"
 845                                                 " for variable '$%s' of implementation '%s'",
 846                                                 set_var->name, set->arg->var->name, impl->func->name);
 847                                 return 0;
 848                         }
 849                 }
 850         }
 851         return 1;
 852 }
 853 static inline decl *locate_free_decl(decls *decls, free_call *f) {
 854         if (decls)  {
 855                 size_t i;
 856
 857                 for (i = 0; i < decls->count; ++i) {
 858                         if (!strcmp(decls->list[i]->func->var->name, f->func)) {
 859                                 f->decl = decls->list[i];
 860                                 return decls->list[i];
 861                         }
 862                 }
 863         }
 864
 865         return NULL;
 866 }
 867 static inline int validate_impl_free_stmts(PSI_Data *data, impl *impl) {
 868         size_t i, j, k, l;
 869         /* we can have any count of free stmts; freeing any out vars */
 870         for (i = 0; i < impl->stmts->fre.count; ++i) {
 871                 free_stmt *fre = impl->stmts->fre.list[i];
 872
 873                 for (j = 0; j < fre->calls->count; ++j) {
 874                         free_call *free_call = fre->calls->list[j];
 875
 876                         /* first find the decl of the free func */
 877                         if (!locate_free_decl(data->decls, free_call)) {
 878                                 data->error(free_call->token, PSI_WARNING,
 879                                                 "Missing declaration '%s' in `free` statement"
 880                                                 " of implementation '%s'",
 881                                                 free_call->func, impl->func->name);
 882                                 return 0;
 883                         }
 884                         if (!impl->decl->args) {
 885                                 data->error(free_call->token, PSI_WARNING,
 886                                                 "Declaration '%s' of implementation '%s'"
 887                                                 " does not have any arguments to free",
 888                                                 impl->decl->func->var->name, impl->func->name);
 889                         }
 890
 891                         /* now check for known vars */
 892                         for (l = 0; l < free_call->vars->count; ++l) {
 893                                 int check = 0;
 894                                 decl_var *free_var = free_call->vars->vars[l];
 895
 896                                 for (k = 0; k < impl->decl->args->count; ++k) {
 897                                         decl_arg *free_arg = impl->decl->args->args[k];
 898
 899                                         if (!strcmp(free_var->name, free_arg->var->name)) {
 900                                                 check = 1;
 901                                                 free_var->arg = free_arg;
 902                                                 break;
 903                                         }
 904                                 }
 905
 906                                 if (!check) {
 907                                         data->error(free_var->token, PSI_WARNING,
 908                                                         "Unknown variable '%s' of `free` statement"
 909                                                         " of implementation '%s'",
 910                                                         free_var->name, impl->func->name);
 911                                         return 0;
 912                                 }
 913                         }
 914                 }
 915         }
 916         return 1;
 917 }
 918 static inline int validate_impl_stmts(PSI_Data *data, impl *impl) {
 919         if (!impl->stmts) {
 920                 data->error(impl->func->token, PSI_WARNING,
 921                                 "Missing body for implementation %s!",
 922                                 impl->func->name);
 923                 return 0;
 924         }
 925
 926         if (!validate_impl_ret_stmt(data, impl)) {
 927                 return 0;
 928         }
 929
 930         if (!validate_impl_let_stmts(data, impl)) {
 931                 return 0;
 932         }
 933         if (!validate_impl_set_stmts(data, impl)) {
 934                 return 0;
 935         }
 936         if (!validate_impl_free_stmts(data, impl)) {
 937                 return 0;
 938         }
 939
 940         return 1;
 941 }
 942
 943 PSI_Context *PSI_ContextInit(PSI_Context *C, PSI_ContextOps *ops, PSI_ContextErrorFunc error)
 944 {
 945         size_t i;
 946         PSI_Data T;
 947         struct psi_predef_type *predef_type;
 948         struct psi_predef_const *predef_const;
 949         struct psi_predef_struct *predef_struct;
 950         struct psi_predef_decl *predef_decl;
 951
 952         if (!C) {
 953                 C = malloc(sizeof(*C));
 954         }
 955         memset(C, 0, sizeof(*C));
 956
 957         C->error = error;
 958         C->ops = ops;
 959
 960         if (ops->init) {
 961                 ops->init(C);
 962         }
 963
 964         ZEND_ASSERT(ops->call != NULL);
 965         ZEND_ASSERT(ops->compile != NULL);
 966
 967         /* build up predefs in a temporary PSI_Data for validation */
 968         memset(&T, 0, sizeof(T));
 969         T.error = error;
 970
 971         for (predef_type = &psi_predef_types[0]; predef_type->type_tag; ++predef_type) {
 972                 decl_type *type = init_decl_type(predef_type->type_tag, predef_type->type_name);
 973                 decl_typedef *def = init_decl_typedef(predef_type->alias, type);
 974
 975                 T.defs = add_decl_typedef(T.defs, def);
 976         }
 977         for (predef_const = &psi_predef_consts[0]; predef_const->type_tag; ++predef_const) {
 978                 impl_def_val *val = init_impl_def_val(predef_const->val_type_tag, predef_const->val_text);
 979                 const_type *type = init_const_type(predef_const->type_tag, predef_const->type_name);
 980                 constant *constant = init_constant(type, predef_const->var_name, val);
 981
 982                 T.consts = add_constant(T.consts, constant);
 983         }
 984         for (predef_struct = &psi_predef_structs[0]; predef_struct->type_tag; ++predef_struct) {
 985                 struct psi_predef_struct *member;
 986                 decl_args *dargs = init_decl_args(NULL);
 987                 decl_struct *dstruct = init_decl_struct(predef_struct->var_name, dargs);
 988
 989                 dstruct->size = predef_struct->size;
 990                 for (member = &predef_struct[1]; member->type_tag; ++member) {
 991                         decl_type *type;
 992                         decl_var *dvar;
 993                         decl_arg *darg;
 994
 995                         type = init_decl_type(member->type_tag, member->type_name);
 996                         dvar = init_decl_var(member->var_name, member->pointer_level, member->array_size);
 997                         darg = init_decl_arg(type, dvar);
 998                         darg->layout = init_decl_struct_layout(member->offset, member->size);
 999                         dargs = add_decl_arg(dargs, darg);
1000                 }
1001
1002                 T.structs = add_decl_struct(T.structs, dstruct);
1003                 predef_struct = member;
1004         }
1005         for (predef_decl = &psi_predef_decls[0]; predef_decl->type_tag; ++predef_decl) {
1006                 struct psi_predef_decl *farg;
1007                 decl_type *ftype = init_decl_type(predef_decl->type_tag, predef_decl->type_name);
1008                 decl_var *fname = init_decl_var(predef_decl->var_name, predef_decl->pointer_level, predef_decl->array_size);
1009                 decl_arg *func = init_decl_arg(ftype, fname);
1010                 decl_args *args = init_decl_args(NULL);
1011                 decl *decl = init_decl(init_decl_abi("default"), func, args);
1012
1013                 for (farg = &predef_decl[1]; farg->type_tag; ++farg) {
1014                         decl_type *arg_type = init_decl_type(farg->type_tag, farg->type_name);
1015                         decl_var *arg_var = init_decl_var(farg->var_name, farg->pointer_level, farg->array_size);
1016                         decl_arg *darg = init_decl_arg(arg_type, arg_var);
1017                         args = add_decl_arg(args, darg);
1018                 }
1019
1020                 T.decls = add_decl(T.decls, decl);
1021                 predef_decl = farg;
1022         }
1023
1024         for (predef_decl = &psi_predef_vararg_decls[0]; predef_decl->type_tag; ++predef_decl) {
1025                 struct psi_predef_decl *farg;
1026                 decl_type *ftype = init_decl_type(predef_decl->type_tag, predef_decl->type_name);
1027                 decl_var *fname = init_decl_var(predef_decl->var_name, predef_decl->pointer_level, predef_decl->array_size);
1028                 decl_arg *func = init_decl_arg(ftype, fname);
1029                 decl_args *args = init_decl_args(NULL);
1030                 decl *decl = init_decl(init_decl_abi("default"), func, args);
1031
1032                 for (farg = &predef_decl[1]; farg->type_tag; ++farg) {
1033                         decl_type *arg_type = init_decl_type(farg->type_tag, farg->type_name);
1034                         decl_var *arg_var = init_decl_var(farg->var_name, farg->pointer_level, farg->array_size);
1035                         decl_arg *darg = init_decl_arg(arg_type, arg_var);
1036                         args = add_decl_arg(args, darg);
1037                 }
1038                 args->varargs = 1;
1039
1040                 T.decls = add_decl(T.decls, decl);
1041                 predef_decl = farg;
1042         }
1043
1044         for (i = 0; i < T.defs->count; ++i) {
1045                 decl_typedef *def = T.defs->list[i];
1046
1047                 if (validate_decl_typedef(&T, def)) {
1048                         C->defs = add_decl_typedef(C->defs, def);
1049                 }
1050         }
1051
1052         for (i = 0; i < T.consts->count; ++i) {
1053                 constant *constant = T.consts->list[i];
1054
1055                 if (validate_constant(&T, constant)) {
1056                         C->consts = add_constant(C->consts, constant);
1057                 }
1058         }
1059
1060         for (i = 0; i < T.structs->count; ++i) {
1061                 decl_struct *dstruct = T.structs->list[i];
1062
1063                 if (validate_decl_struct(&T, dstruct)) {
1064                         C->structs = add_decl_struct(C->structs, dstruct);
1065                 }
1066         }
1067
1068         for (i = 0; i < T.decls->count; ++i) {
1069                 decl *decl = T.decls->list[i];
1070
1071                 if (validate_decl(&T, NULL, decl)) {
1072                         C->decls = add_decl(C->decls, decl);
1073                 }
1074         }
1075
1076         C->count = 1;
1077         C->data = malloc(sizeof(*C->data));
1078         PSI_DataExchange(C->data, &T);
1079
1080         return C;
1081 }
1082
1083 int PSI_ContextValidate(PSI_Context *C, PSI_Parser *P)
1084 {
1085         PSI_Data *D;
1086         void *dlopened = NULL;
1087         size_t count = C->count++;
1088
1089         C->data = realloc(C->data, C->count * sizeof(*C->data));
1090         D = PSI_DataExchange(&C->data[count], PSI_DATA(P));
1091
1092         if (D->defs) {
1093                 size_t i;
1094
1095                 for (i = 0; i < D->defs->count; ++i) {
1096                         if (validate_decl_typedef(PSI_DATA(C), D->defs->list[i])) {
1097                                 C->defs = add_decl_typedef(C->defs, D->defs->list[i]);
1098                         }
1099                 }
1100         }
1101         if (D->structs) {
1102                 size_t i;
1103
1104                 for (i = 0; i < D->structs->count; ++i) {
1105                         if (validate_decl_struct(PSI_DATA(C), D->structs->list[i])) {
1106                                 C->structs = add_decl_struct(C->structs, D->structs->list[i]);
1107                         }
1108                 }
1109         }
1110         if (D->consts) {
1111                 size_t i;
1112
1113                 for (i = 0; i < D->consts->count; ++i) {
1114                         if (validate_constant(PSI_DATA(C), D->consts->list[i])) {
1115                                 C->consts = add_constant(C->consts, D->consts->list[i]);
1116                         }
1117                 }
1118         }
1119
1120         if (!validate_lib(D, &dlopened)) {
1121                 return 0;
1122         }
1123
1124         add_decl_lib(&C->psi.libs, dlopened);
1125
1126         if (D->decls) {
1127                 size_t i;
1128
1129                 for (i = 0; i < D->decls->count; ++i) {
1130                         if (validate_decl(PSI_DATA(C), dlopened, D->decls->list[i])) {
1131                                 C->decls = add_decl(C->decls, D->decls->list[i]);
1132                         }
1133                 }
1134         }
1135         if (D->impls) {
1136                 size_t i;
1137
1138                 for (i = 0; i < D->impls->count; ++i) {
1139                         if (validate_impl_stmts(PSI_DATA(C), D->impls->list[i])) {
1140                                 C->impls = add_impl(C->impls, D->impls->list[i]);
1141                         }
1142                 }
1143         }
1144
1145         return 1;
1146 }
1147
1148 static int psi_select_dirent(const struct dirent *entry)
1149 {
1150 #ifndef FNM_CASEFOLD
1151 #define FNM_CASEFOLD 0
1152 #endif
1153         return 0 == fnmatch("*.psi", entry->d_name, FNM_CASEFOLD);
1154 }
1155
1156 void PSI_ContextBuild(PSI_Context *C, const char *paths)
1157 {
1158         int i, n, flags = psi_check_env("PSI_DEBUG") ? PSI_PARSER_DEBUG : 0;
1159         char *sep = NULL, *cpy = strdup(paths), *ptr = cpy;
1160         struct dirent **entries = NULL;
1161
1162
1163         do {
1164                 sep = strchr(ptr, ':');
1165
1166                 if (sep) {
1167                         *sep = 0;
1168                 }
1169
1170                 n = php_scandir(ptr, &entries, psi_select_dirent, alphasort);
1171
1172                 if (n > 0) {
1173                         for (i = 0; i < n; ++i) {
1174                                 char psi[MAXPATHLEN];
1175                                 PSI_Parser P;
1176
1177                                 if (MAXPATHLEN <= slprintf(psi, MAXPATHLEN, "%s/%s", ptr, entries[i]->d_name)) {
1178                                         C->error(NULL, PSI_WARNING, "Path to PSI file too long: %s/%s",
1179                                                 ptr, entries[i]->d_name);
1180                                 }
1181                                 if (!PSI_ParserInit(&P, psi, C->error, flags)) {
1182                                         C->error(NULL, PSI_WARNING, "Failed to init PSI parser (%s): %s",
1183                                                 psi, strerror(errno));
1184                                         continue;
1185                                 }
1186
1187                                 while (0 < PSI_ParserScan(&P)) {
1188                                         PSI_ParserParse(&P, PSI_TokenAlloc(&P));
1189                                         if (P.num == PSI_T_EOF) {
1190                                                 break;
1191                                         }
1192                                 }
1193
1194                                 PSI_ParserParse(&P, NULL);
1195                                 PSI_ContextValidate(C, &P);
1196                                 PSI_ParserDtor(&P);
1197                         }
1198                 }
1199
1200                 if (entries) {
1201                         for (i = 0; i < n; ++i) {
1202                                 free(entries[i]);
1203                         }
1204                         free(entries);
1205                 }
1206
1207                 ptr = sep + 1;
1208         } while (sep);
1209
1210
1211         if (PSI_ContextCompile(C) && SUCCESS != zend_register_functions(NULL, C->closures, NULL, MODULE_PERSISTENT)) {
1212                 C->error(NULL, PSI_WARNING, "Failed to register functions!");
1213         }
1214
1215         free(cpy);
1216
1217 }
1218
1219 zend_function_entry *PSI_ContextCompile(PSI_Context *C)
1220 {
1221         size_t i;
1222
1223         if (C->consts) {
1224                 zend_constant zc;
1225
1226                 zc.flags = CONST_PERSISTENT|CONST_CS;
1227                 zc.module_number = EG(current_module)->module_number;
1228
1229                 for (i = 0; i < C->consts->count; ++i) {
1230                         constant *c = C->consts->list[i];
1231
1232                         zc.name = zend_string_init(c->name + (c->name[0] == '\\'), strlen(c->name) - (c->name[0] == '\\'), 1);
1233                         ZVAL_NEW_STR(&zc.value, zend_string_init(c->val->text, strlen(c->val->text), 1));
1234
1235                         switch (c->type->type) {
1236                         case PSI_T_BOOL:
1237                                 convert_to_boolean(&zc.value);
1238                                 break;
1239                         case PSI_T_INT:
1240                                 convert_to_long(&zc.value);
1241                                 break;
1242                         case PSI_T_FLOAT:
1243                                 convert_to_double(&zc.value);
1244                                 break;
1245                         }
1246                         zend_register_constant(&zc);
1247                 }
1248         }
1249
1250         return C->closures = C->ops->compile(C);
1251 }
1252
1253
1254 void PSI_ContextCall(PSI_Context *C, decl_callinfo *decl_call, impl_vararg *va)
1255 {
1256         C->ops->call(C, decl_call, va);
1257 }
1258
1259 static inline void dump_decl_type(int fd, decl_type *t) {
1260         const char *pre;
1261
1262         switch (t->type) {
1263         case PSI_T_STRUCT:
1264                 pre = "struct ";
1265                 break;
1266         default:
1267                 pre = "";
1268         }
1269         dprintf(fd, "%s%s", pre, t->name);
1270 }
1271 static inline void dump_decl_var(int fd, decl_var *v) {
1272         dprintf(fd, "%.*s%s", v->pointer_level-!!v->array_size, "**********", v->name);
1273         if (v->array_size) {
1274                 dprintf(fd, "[%u]", v->array_size);
1275         }
1276 }
1277 static inline void dump_decl_arg(int fd, decl_arg *a) {
1278         dump_decl_type(fd, a->type);
1279         dprintf(fd, " ");
1280         dump_decl_var(fd, a->var);
1281 }
1282 static inline void dump_level(int fd, unsigned level) {
1283         dprintf(fd, "%.*s", level, "\t\t\t\t\t\t\t\t\t");
1284 }
1285 static inline void dump_num_exp(int fd, num_exp *exp) {
1286         while (exp) {
1287                 switch (exp->t) {
1288                 case PSI_T_NUMBER:
1289                         dprintf(fd, "%s", exp->u.numb);
1290                         break;
1291                 case PSI_T_NSNAME:
1292                         dprintf(fd, "%s", exp->u.cnst->name);
1293                         break;
1294                 case PSI_T_NAME:
1295                         dump_decl_var(fd, exp->u.dvar);
1296                         break;
1297                 EMPTY_SWITCH_DEFAULT_CASE();
1298                 }
1299                 if (exp->operand) {
1300                         char op;
1301
1302                         switch (exp->operator) {
1303                         case PSI_T_PLUS:        op = '+'; break;
1304                         case PSI_T_MINUS:       op = '-'; break;
1305                         case PSI_T_ASTERISK:op = '*'; break;
1306                         case PSI_T_SLASH:       op = '/'; break;
1307                         EMPTY_SWITCH_DEFAULT_CASE();
1308                         }
1309                         dprintf(fd, " %c ", op);
1310                 }
1311                 exp = exp->operand;
1312         }
1313 }
1314 static inline void dump_impl_set_value(int fd, set_value *set, unsigned level) {
1315         size_t i;
1316
1317         if (level > 1) {
1318                 /* only if not directly after `set ...` */
1319                 dump_level(fd, level);
1320         }
1321         dprintf(fd, "%s(", set->func->name);
1322
1323         for (i = 0; i < set->vars->count; ++i) {
1324                 decl_var *svar = set->vars->vars[i];
1325                 if (i) {
1326                         dprintf(fd, ", ");
1327                 }
1328                 dump_decl_var(fd, svar);
1329         }
1330         if (set->num) {
1331                 dprintf(fd, ", ");
1332                 dump_num_exp(fd, set->num);
1333         }
1334         if (set->inner) {
1335                 dprintf(fd, ",\n");
1336                 for (i = 0; i < set->count; ++i) {
1337                         dump_impl_set_value(fd, set->inner[i], level+1);
1338                 }
1339                 /* only if inner stmts, i.e. with new lines, were dumped */
1340                 dump_level(fd, level);
1341         }
1342         if (level > 1) {
1343                 dprintf(fd, "),\n");
1344         } else {
1345                 dprintf(fd, ");\n");
1346         }
1347 }
1348 void PSI_ContextDump(PSI_Context *C, int fd)
1349 {
1350         size_t i, j, k, l;
1351
1352 #ifdef HAVE_LIBJIT
1353         if (C->ops == PSI_Libjit()) {
1354                 dprintf(fd, "// psi.engine=jit\n");
1355         }
1356 #endif
1357 #ifdef HAVE_LIBFFI
1358         if (C->ops == PSI_Libffi()) {
1359                 dprintf(fd, "// psi.engine=ffi\n");
1360         }
1361 #endif
1362         dprintf(fd, "\n");
1363
1364         if (C->defs) {
1365                 for (i = 0; i < C->defs->count; ++i) {
1366                         decl_typedef *tdef = C->defs->list[i];
1367
1368                         dprintf(fd, "typedef ");
1369                         dump_decl_type(fd, tdef->type);
1370                         dprintf(fd, " %s;\n", tdef->alias);
1371                 }
1372                 dprintf(fd, "\n");
1373         }
1374
1375         if (C->structs) {
1376                 for (i = 0; i < C->structs->count; ++i) {
1377                         decl_struct *strct = C->structs->list[i];
1378
1379                         dprintf(fd, "struct %s::(%zu) {\n", strct->name, strct->size);
1380                         if (strct->args) for (j = 0; j < strct->args->count; ++j) {
1381                                 decl_arg *sarg = strct->args->args[j];
1382
1383                                 dprintf(fd, "\t");
1384                                 dump_decl_arg(fd, sarg);
1385                                 dprintf(fd, "::(%zu, %zu);\n", sarg->layout->pos, sarg->layout->len);
1386                         }
1387                         dprintf(fd, "}\n");
1388                 }
1389                 dprintf(fd, "\n");
1390         }
1391         if (C->consts) {
1392                 for (i = 0; i < C->consts->count; ++i) {
1393                         constant *cnst = C->consts->list[i];
1394
1395                         dprintf(fd, "const %s %s = ", cnst->type->name, cnst->name);
1396                         if (cnst->val->type == PSI_T_QUOTED_STRING) {
1397                                 dprintf(fd, "\"%s\";\n", cnst->val->text);
1398                         } else {
1399                                 dprintf(fd, "%s;\n", cnst->val->text);
1400                         }
1401                 }
1402                 dprintf(fd, "\n");
1403         }
1404         if (C->decls) {
1405                 for (i = 0; i < C->decls->count; ++i) {
1406                         decl *decl = C->decls->list[i];
1407
1408                         dprintf(fd, "%s ", decl->abi->convention);
1409                         dump_decl_arg(fd, decl->func);
1410                         dprintf(fd, "(");
1411                         if (decl->args) {
1412                                 for (j = 0; j < decl->args->count; ++j) {
1413                                         if (j) {
1414                                                 dprintf(fd, ", ");
1415                                         }
1416                                         dump_decl_arg(fd, decl->args->args[j]);
1417                                 }
1418                                 if (decl->args->varargs) {
1419                                         dprintf(fd, ", ...");
1420                                 }
1421                         }
1422                         dprintf(fd, ");\n");
1423                 }
1424                 dprintf(fd, "\n");
1425         }
1426         if (C->impls) {
1427                 for (i = 0; i < C->impls->count; ++i) {
1428                         impl *impl = C->impls->list[i];
1429
1430                         dprintf(fd, "function %s(", impl->func->name);
1431                         if (impl->func->args) {
1432                                 for (j = 0; j < impl->func->args->count; ++j) {
1433                                         impl_arg *iarg = impl->func->args->args[j];
1434
1435                                         dprintf(fd, "%s%s %s$%s",
1436                                                         j ? ", " : "",
1437                                                         iarg->type->name,
1438                                                         iarg->var->reference ? "&" : "",
1439                                                         iarg->var->name);
1440                                         if (iarg->def) {
1441                                                 dprintf(fd, " = %s", iarg->def->text);
1442                                         }
1443                                 }
1444                                 if (impl->func->args->vararg.name) {
1445                                         impl_arg *vararg = impl->func->args->vararg.name;
1446
1447                                         dprintf(fd, ", %s %s...$%s",
1448                                                         vararg->type->name,
1449                                                         vararg->var->reference ? "&" : "",
1450                                                         vararg->var->name);
1451                                 }
1452                         }
1453                         dprintf(fd, ") : %s%s {\n",
1454                                         impl->func->return_reference ? "&":"",
1455                                         impl->func->return_type->name);
1456                         if (impl->stmts) {
1457                                 for (j = 0; j < impl->stmts->let.count; ++j) {
1458                                         let_stmt *let = impl->stmts->let.list[j];
1459
1460                                         dprintf(fd, "\tlet %s", let->var->name);
1461                                         if (let->val) {
1462                                                 dprintf(fd, " = %s", let->val->flags.one.is_reference ? "&" : "");
1463                                                 switch (let->val->kind) {
1464                                                 case PSI_LET_NULL:
1465                                                         dprintf(fd, "NULL");
1466                                                         break;
1467                                                 case PSI_LET_TMP:
1468                                                         dump_decl_var(fd, let->val->data.var);
1469                                                         break;
1470                                                 case PSI_LET_CALLOC:
1471                                                         dprintf(fd, "calloc(");
1472                                                         dump_num_exp(fd, let->val->data.alloc->nmemb);
1473                                                         dprintf(fd, ", ");
1474                                                         dump_num_exp(fd, let->val->data.alloc->size);
1475                                                         dprintf(fd, ")");
1476                                                         break;
1477                                                 case PSI_LET_FUNC:
1478                                                         dprintf(fd, "%s($%s)", let->val->data.func->name,
1479                                                                         let->val->data.func->var->name);
1480                                                         break;
1481
1482                                                 EMPTY_SWITCH_DEFAULT_CASE();
1483                                                 }
1484                                                 dprintf(fd, ";\n");
1485                                         }
1486                                 }
1487                                 for (j = 0; j < impl->stmts->ret.count; ++j) {
1488                                         return_stmt *ret = impl->stmts->ret.list[j];
1489
1490                                         dprintf(fd, "\treturn ");
1491                                         dump_impl_set_value(fd, ret->set, 1);
1492                                 }
1493                                 for (j = 0; j < impl->stmts->set.count; ++j) {
1494                                         set_stmt *set = impl->stmts->set.list[j];
1495
1496                                         dprintf(fd, "\tset $%s = ", set->var->name);
1497                                         dump_impl_set_value(fd, set->val, 1);
1498                                 }
1499                                 for (j = 0; j < impl->stmts->fre.count; ++j) {
1500                                         free_stmt *fre = impl->stmts->fre.list[j];
1501
1502                                         dprintf(fd, "\tfree ");
1503                                         for (k = 0; k < fre->calls->count; ++k) {
1504                                                 free_call *call = fre->calls->list[k];
1505
1506                                                 if (k) {
1507                                                         dprintf(fd, ", ");
1508                                                 }
1509                                                 dprintf(fd, "%s(", call->func);
1510                                                 for (l = 0; l < call->vars->count; ++l) {
1511                                                         decl_var *fvar = call->vars->vars[l];
1512
1513                                                         dump_decl_var(fd, fvar);
1514                                                 }
1515                                                 dprintf(fd, ");\n");
1516                                         }
1517                                 }
1518                         }
1519                         dprintf(fd, "}\n");
1520                 }
1521                 dprintf(fd, "\n");
1522         }
1523 }
1524
1525 void PSI_ContextDtor(PSI_Context *C)
1526 {
1527         size_t i;
1528         zend_function_entry *zfe;
1529
1530         if (C->ops->dtor) {
1531                 C->ops->dtor(C);
1532         }
1533
1534         free_decl_libs(&C->psi.libs);
1535
1536         if (C->data) {
1537                 for (i = 0; i < C->count; ++i) {
1538                         PSI_DataDtor(&C->data[i]);
1539                 }
1540                 free(C->data);
1541         }
1542
1543         if (C->closures) {
1544                 for (zfe = C->closures; zfe->fname; ++zfe) {
1545                         free((void *) zfe->arg_info);
1546                 }
1547                 free(C->closures);
1548         }
1549
1550         if (C->consts) {
1551                 if (C->consts->list) {
1552                         free(C->consts->list);
1553                 }
1554                 free(C->consts);
1555         }
1556         if (C->defs) {
1557                 if (C->defs->list) {
1558                         free(C->defs->list);
1559                 }
1560                 free(C->defs);
1561         }
1562         if (C->structs) {
1563                 if (C->structs->list) {
1564                         free(C->structs->list);
1565                 }
1566                 free(C->structs);
1567         }
1568         if (C->decls) {
1569                 if (C->decls->list) {
1570                         free(C->decls->list);
1571                 }
1572                 free(C->decls);
1573         }
1574         if (C->impls) {
1575                 if (C->impls->list) {
1576                         free(C->impls->list);
1577                 }
1578                 free(C->impls);
1579         }
1580
1581         memset(C, 0, sizeof(*C));
1582 }
1583
1584 void PSI_ContextFree(PSI_Context **C)
1585 {
1586         if (*C) {
1587                 PSI_ContextDtor(*C);
1588                 free(*C);
1589                 *C = NULL;
1590         }
1591 }