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