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