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_WCHAR_H
  81 # include <wchar.h>
  82 #endif
  83
  84 #ifdef HAVE_DIRENT_H
  85 # include <dirent.h>
  86 # define NAMLEN(dirent) strlen ((dirent)->d_name)
  87 #else
  88 # define dirent direct
  89 # define NAMLEN(dirent) ((dirent)->d_namlen)
  90 # ifdef HAVE_SYS_NDIR_H
  91 #  include <sys/ndir.h>
  92 # endif
  93 # ifdef HAVE_SYS_DIR_H
  94 #  include <sys/dir.h>
  95 # endif
  96 # ifdef HAVE_NDIR_H
  97 #  include <ndir.h>
  98 # endif
  99 #endif
 100
 101 #include <sys/param.h>
 102 #include <dlfcn.h>
 103 #include <fnmatch.h>
 104
 105 #include "php.h"
 106 #include "php_scandir.h"
 107 #include "php_psi.h"
 108 #include "context.h"
 109 #include "parser.h"
 110
 111 #include "libjit.h"
 112 #include "libffi.h"
 113
 114 static struct psi_std_type {
 115         token_t type_tag;
 116         const char *type_name;
 117 } psi_std_types[] = {
 118         {PSI_T_FLOAT, "float"},
 119         {PSI_T_DOUBLE, "double"},
 120         {PSI_T_INT8, "int8_t"},
 121         {PSI_T_INT16, "int16_t"},
 122         {PSI_T_INT32, "int32_t"},
 123         {PSI_T_INT64, "int64_t"},
 124         {PSI_T_UINT8, "uint8_t"},
 125         {PSI_T_UINT16, "uint16_t"},
 126         {PSI_T_UINT32, "uint32_t"},
 127         {PSI_T_UINT64, "uint64_t"},
 128         {0}
 129 };
 130
 131 static struct psi_predef_type {
 132         token_t type_tag;
 133         const char *type_name;
 134         const char *alias;
 135 } psi_predef_types[] = {
 136         PSI_TYPES
 137         {0}
 138 };
 139
 140 static struct psi_predef_const {
 141         token_t type_tag;
 142         const char *type_name;
 143         const char *var_name;
 144         const char *val_text;
 145         token_t val_type_tag;
 146 } psi_predef_consts[] = {
 147         PSI_CONSTS
 148         {0}
 149 };
 150
 151 PSI_MACROS
 152
 153 static struct psi_func_redir {
 154         const char *name;
 155         void (*func)(void);
 156 } psi_func_redirs[] = {
 157         PSI_REDIRS
 158         {0}
 159 };
 160
 161 static struct psi_predef_decl {
 162         token_t type_tag;
 163         const char *type_name;
 164         const char *var_name;
 165         size_t pointer_level;
 166         size_t array_size;
 167 } psi_predef_decls[] = {
 168         PSI_DECLS
 169         {0}
 170 };
 171
 172 static struct psi_predef_struct {
 173         token_t type_tag;
 174         const char *type_name;
 175         const char *var_name;
 176         size_t offset;
 177         size_t size;
 178         size_t pointer_level;
 179         size_t array_size;
 180 } psi_predef_structs[] = {
 181         PSI_STRUCTS
 182         {0}
 183 };
 184
 185 static int validate_lib(PSI_Data *data, void **dlopened) {
 186         char lib[MAXPATHLEN];
 187         const char *ptr = data->psi.file.ln;
 188         size_t len;
 189
 190         if (!ptr) {
 191                 /* FIXME: assume stdlib */
 192                 return 1;
 193         } else if (!strchr(ptr, '/')) {
 194                 len = snprintf(lib, MAXPATHLEN, "lib%s.%s", ptr, PHP_PSI_SHLIB_SUFFIX);
 195                 if (MAXPATHLEN == len) {
 196                         data->error(PSI_WARNING, "Library name too long: '%s'", ptr);
 197                 }
 198                 lib[len] = 0;
 199                 ptr = lib;
 200         }
 201         if (!(*dlopened = dlopen(ptr, RTLD_LAZY|RTLD_LOCAL))) {
 202                 data->error(PSI_WARNING, "Could not open library '%s': %s.",
 203                                 data->psi.file.ln, dlerror());
 204                 return 0;
 205         }
 206         return 1;
 207 }
 208
 209 static inline int locate_decl_type_alias(decl_typedefs *defs, decl_type *type) {
 210         size_t i;
 211         struct psi_std_type *stdtyp;
 212
 213         if (type->real) {
 214                 return 1;
 215         }
 216         for (i = 0; i < defs->count; ++i) {
 217                 decl_typedef *def = defs->list[i];
 218
 219                 if (def->type->type != type->type && !strcmp(def->alias, type->name)) {
 220                         type->real = def->type;
 221                         return 1;
 222                 }
 223         }
 224         for (stdtyp = &psi_std_types[0]; stdtyp->type_tag; ++stdtyp) {
 225                 if (!strcmp(type->name, stdtyp->type_name)) {
 226                         type->type = stdtyp->type_tag;
 227                 }
 228                 return 1;
 229         }
 230
 231         return 0;
 232 }
 233 static inline int locate_decl_type_struct(decl_structs *structs, decl_type *type) {
 234         size_t i;
 235
 236         if (type->strct) {
 237                 return 1;
 238         }
 239         for (i = 0; i < structs->count; ++i) {
 240                 if (!strcmp(structs->list[i]->name, type->name)) {
 241                         type->strct = structs->list[i];
 242                         return 1;
 243                 }
 244         }
 245         return 0;
 246 }
 247
 248 static inline int validate_decl_type(PSI_Data *data, decl_type *type) {
 249         switch (type->type) {
 250         case PSI_T_NAME:
 251                 if (!data->defs || !locate_decl_type_alias(data->defs, type)) {
 252                         return 0;
 253                 }
 254                 if (type->real) {
 255                         return validate_decl_type(data, type->real);
 256                 }
 257                 return 1;
 258         case PSI_T_STRUCT:
 259                 if (!data->structs || !locate_decl_type_struct(data->structs, type)) {
 260                         return 0;
 261                 }
 262                 break;
 263         }
 264         return 1;
 265 }
 266 static inline int validate_decl_typedef(PSI_Data *data, decl_typedef *def) {
 267         if (!validate_decl_type(data, def->type)) {
 268                 data->error(PSI_WARNING, "Type '%s' cannot be aliased to %s'%s'",
 269                         def->type->name, def->type->type == PSI_T_STRUCT?"struct ":"",def->alias);
 270                 return 0;
 271         }
 272         /* FIXME: check def->alias */
 273         return 1;
 274 }
 275
 276 static inline int validate_constant(PSI_Data *data, constant *c) {
 277         /* FIXME */
 278         return 1;
 279 }
 280
 281 static inline int validate_decl_arg(PSI_Data *data, decl_arg *arg) {
 282         if (!validate_decl_type(data, arg->type)) {
 283                 data->error(PSI_WARNING, "Cannot use '%s'(%d) as type for '%s'",
 284                         arg->type->name, arg->type->type, arg->var->name);
 285                 return 0;
 286         }
 287         return 1;
 288 }
 289
 290 static inline int validate_decl_struct(PSI_Data *data, decl_struct *s) {
 291         size_t i;
 292
 293         for (i = 0; i < s->args->count; ++i) {
 294                 if (!validate_decl_arg(data, s->args->args[i])) {
 295                         return 0;
 296                 }
 297         }
 298
 299         for (i = 0; i < s->args->count; ++i) {
 300                 decl_arg *darg = s->args->args[i];
 301
 302                 if (!validate_decl_arg(data, darg)) {
 303                         return 0;
 304                 }
 305
 306                 ZEND_ASSERT(!darg->var->arg || darg->var->arg == darg);
 307                 darg->var->arg = darg;
 308
 309                 if (!darg->layout) {
 310                         token_t t;
 311
 312                         if (darg->var->pointer_level && (!darg->var->array_size || darg->var->pointer_level == 1)) {
 313                                 t = PSI_T_POINTER;
 314                         } else {
 315                                 t = real_decl_type(darg->type)->type;
 316                         }
 317
 318                         if (i) {
 319                                 decl_arg *last = s->args->args[i-1];
 320                                 darg->layout = init_decl_struct_layout(
 321                                                 psi_t_align(t, last->layout->pos + last->layout->len),
 322                                                 psi_t_size(t) * darg->var->array_size);
 323                         } else {
 324                                 darg->layout = init_decl_struct_layout(0, psi_t_size(t));
 325                         }
 326                 }
 327                 if (s->size < darg->layout->pos + darg->layout->len) {
 328                         s->size = darg->layout->pos + darg->layout->len;
 329                 }
 330         }
 331         return 1;
 332 }
 333
 334 static const char * const abi_ccs[] = {
 335                 "default", /* \                 */
 336                 "extern",  /*  > - all the same */
 337                 "cdecl",   /* /                 */
 338                 "stdcall",
 339                 "fastcall",
 340 };
 341 static inline int validate_decl_abi(PSI_Data *data, decl_abi *abi) {
 342         size_t i;
 343
 344         for (i = 0; i < sizeof(abi_ccs)/sizeof(char*); ++i) {
 345                 if (strcasecmp(abi->convention, abi_ccs[i])) {
 346                         return 1;
 347                 }
 348         }
 349         data->error(PSI_WARNING, "Invalid calling convention: '%s'", abi->convention);
 350         return 0;
 351 }
 352 static inline int validate_decl_func(PSI_Data *data, void *dl, decl *decl, decl_arg *func)
 353 {
 354         struct psi_func_redir *redir;
 355
 356         if (!strcmp(func->var->name, "dlsym")) {
 357                 data->error(PSI_WARNING, "Cannot dlsym dlsym (sic!)");
 358                 return 0;
 359         }
 360
 361         if (!validate_decl_arg(data, func)) {
 362                 return 0;
 363         }
 364         for (redir = &psi_func_redirs[0]; redir->name; ++redir) {
 365                 if (!strcmp(func->var->name, redir->name)) {
 366                         decl->call.sym = redir->func;
 367                 }
 368         }
 369         if (!decl->call.sym) {
 370 #ifndef RTLD_NEXT
 371 # define RTLD_NEXT ((void *) -1l)
 372 #endif
 373                 decl->call.sym = dlsym(dl ?: RTLD_NEXT, func->var->name);
 374                 if (!decl->call.sym) {
 375                         data->error(PSI_WARNING, "Failed to locate symbol '%s': %s",
 376                                 func->var->name, dlerror());
 377                 }
 378         }
 379         return 1;
 380 }
 381
 382 static inline int validate_decl(PSI_Data *data, void *dl, decl *decl) {
 383         if (!validate_decl_abi(data, decl->abi)) {
 384                 return 0;
 385         }
 386         if (!validate_decl_func(data, dl, decl, decl->func)) {
 387                 return 0;
 388         }
 389         if (decl->args) {
 390                 size_t i;
 391
 392                 for (i = 0; i < decl->args->count; ++i) {
 393                         if (!validate_decl_arg(data, decl->args->args[i])) {
 394                                 return 0;
 395                         }
 396                 }
 397         }
 398         return 1;
 399 }
 400 static inline decl_arg *locate_decl_var_arg(decl_var *var, decl_args *args) {
 401         size_t i;
 402
 403         for (i = 0; i < args->count; ++i) {
 404                 decl_arg *arg = args->args[i];
 405
 406                 if (!strcmp(var->name, arg->var->name)) {
 407                         return var->arg = arg;
 408                 }
 409         }
 410
 411         return NULL;
 412 }
 413 static inline decl_arg *locate_struct_member(decl_struct *s, decl_var *var) {
 414         if (s->args) {
 415                 return locate_decl_var_arg(var, s->args);
 416         }
 417
 418         return NULL;
 419 }
 420 static inline int validate_set_value(PSI_Data *data, set_value *set, decl_arg *ref, decl_args *ref_list) {
 421         size_t i;
 422         decl_type *ref_type = real_decl_type(ref->type);
 423         decl_var *set_var = set->vars->vars[0];
 424
 425         switch (set->func->type) {
 426         case PSI_T_TO_BOOL:
 427                 set->func->handler = psi_to_bool;
 428                 break;
 429         case PSI_T_TO_INT:
 430                 set->func->handler = psi_to_int;
 431                 break;
 432         case PSI_T_TO_FLOAT:
 433                 set->func->handler = psi_to_double;
 434                 break;
 435         case PSI_T_TO_STRING:
 436                 set->func->handler = psi_to_string;
 437                 break;
 438         case PSI_T_TO_ARRAY:
 439                 set->func->handler = psi_to_array;
 440                 break;
 441         EMPTY_SWITCH_DEFAULT_CASE();
 442         }
 443
 444         for (i = 1; i < set->vars->count; ++i) {
 445                 if (!locate_decl_var_arg(set->vars->vars[i], ref_list)) {
 446                         return 0;
 447                 }
 448         }
 449         set_var->arg = ref;
 450
 451         if (set->count && (set->func->type != PSI_T_TO_ARRAY || (ref_type->type != PSI_T_STRUCT && !ref->var->arg->var->pointer_level))) {
 452                 data->error(E_WARNING, "Inner `set` statement casts only work with to_array() casts on structs or pointers");
 453                 return 0;
 454         }
 455
 456         if (ref_type->type == PSI_T_STRUCT) {
 457                 /* to_array(struct, to_...) */
 458                 for (i = 0; i < set->count; ++i) {
 459                         decl_var *sub_var = set->inner[i]->vars->vars[0];
 460                         decl_arg *sub_ref = locate_struct_member(ref_type->strct, sub_var);
 461
 462                         if (sub_ref) {
 463                                 if (!validate_set_value(data, set->inner[i], sub_ref, ref_type->strct->args)) {
 464                                         return 0;
 465                                 }
 466                                 set->inner[i]->outer.set = set;
 467                         }
 468                 }
 469         } else if (set->count == 1) {
 470                 /* to_array(ptr, to_string(*ptr)) */
 471                 decl_var *sub_var = set->inner[0]->vars->vars[0];
 472                 decl_arg *sub_ref = locate_decl_var_arg(sub_var, ref_list);
 473
 474                 if (sub_ref) {
 475                         if (strcmp(sub_var->name, set_var->name)) {
 476                                 data->error(E_WARNING, "Inner `set` statement casts on pointers must reference the same variable");
 477                                 return 0;
 478                         }
 479                         if (!validate_set_value(data, set->inner[0], sub_ref, ref_list)) {
 480                                 return 0;
 481                         }
 482                         set->inner[0]->outer.set = set;
 483                 }
 484         } else if (set->count > 1) {
 485                 data->error(E_WARNING, "Inner `set` statement casts on pointers may only occur once");
 486                 return 0;
 487         }
 488
 489         return 1;
 490 }
 491 static inline decl *locate_impl_decl(decls *decls, return_stmt *ret) {
 492         if (decls) {
 493                 size_t i;
 494
 495                 for (i = 0; i < decls->count; ++i) {
 496                         if (!strcmp(decls->list[i]->func->var->name, ret->set->vars->vars[0]->name)) {
 497                                 ret->decl = decls->list[i]->func;
 498                                 return decls->list[i];
 499                         }
 500                 }
 501         }
 502
 503         return NULL;
 504 }
 505 static inline int validate_impl_ret_stmt(PSI_Data *data, impl *impl) {
 506         return_stmt *ret;
 507
 508         /* we must have exactly one ret stmt delcaring the native func to call */
 509         /* and which type cast to apply */
 510         if (impl->stmts->ret.count != 1) {
 511                 if (impl->stmts->ret.count > 1) {
 512                         data->error(PSI_WARNING, "Too many `return` statements for implmentation %s;"
 513                                         " found %zu, exactly one is needed",
 514                                         impl->func->name, impl->stmts->ret.count);
 515                 } else {
 516                         data->error(PSI_WARNING, "Missing `return` statement for implementation %s",
 517                                         impl->func->name);
 518                 }
 519                 return 0;
 520         }
 521
 522         ret = impl->stmts->ret.list[0];
 523
 524         if (!(impl->decl = locate_impl_decl(data->decls, ret))) {
 525                 data->error(PSI_WARNING, "Missing declaration for implementation %s",
 526                                 impl->func->name);
 527                 return 0;
 528         }
 529
 530         if (!validate_set_value(data, ret->set, ret->decl, impl->decl->args)) {
 531                 return 0;
 532         }
 533
 534         impl->decl->impl = impl;
 535
 536         return 1;
 537 }
 538 static inline int validate_impl_let_stmts(PSI_Data *data, impl *impl) {
 539         size_t i, j;
 540         /* we can have multiple let stmts */
 541         /* check that we have a let stmt for every decl arg */
 542         if (impl->decl->args) for (i = 0; i < impl->decl->args->count; ++i) {
 543                 decl_arg *darg = impl->decl->args->args[i];
 544                 int check = 0;
 545
 546                 for (j = 0; j < impl->stmts->let.count; ++j) {
 547                         let_stmt *let = impl->stmts->let.list[j];
 548
 549                         if (!strcmp(let->var->name, darg->var->name)) {
 550                                 darg->let = let;
 551                                 check = 1;
 552                                 break;
 553                         }
 554                 }
 555                 if (!check) {
 556                         data->error(PSI_WARNING, "Missing `let` statement for arg '%s %.*s%s'"
 557                                         " of declaration '%s' for implementation '%s'",
 558                                         darg->type->name, (int) darg->var->pointer_level, "*****",
 559                                         darg->var->name, impl->decl->func->var->name, impl->func->name);
 560                         return 0;
 561                 }
 562         }
 563         /* check that the let_value references a known variable or NULL */
 564         for (i = 0; i < impl->stmts->let.count; ++i) {
 565                 let_stmt *let = impl->stmts->let.list[i];
 566                 int check = 0;
 567
 568                 if (let->val && let->val->func && let->val->func->alloc) {
 569                         if (!validate_decl_type(data, let->val->func->alloc->type)) {
 570                                 data->error(PSI_WARNING, "Cannot use '%s' as type for calloc in `let` statement",
 571                                         let->val->func->alloc->type->name);
 572                                 return 0;
 573                         }
 574                 }
 575                 if (let->val && let->val->var) {
 576                         if (impl->func->args) for (j = 0; j < impl->func->args->count; ++j) {
 577                                 impl_arg *iarg = impl->func->args->args[j];
 578
 579                                 if (!strcmp(let->val->var->name, iarg->var->name)) {
 580                                         let->arg = iarg;
 581                                         check = 1;
 582                                         break;
 583                                 }
 584                         }
 585                         if (!check) {
 586                                 data->error(PSI_WARNING, "Unknown value '$%s' of `let` statement"
 587                                                 " for variable '%s' of implementation '%s'",
 588                                                 let->val->var->name, let->var->name, impl->func->name);
 589                                 return 0;
 590                         }
 591                 }
 592         }
 593         return 1;
 594 }
 595 static inline int validate_impl_set_stmts(PSI_Data *data, impl *impl) {
 596         size_t i, j, k;
 597         /* we can have any count of set stmts; processing out vars */
 598         /* check that set stmts reference known variables */
 599         for (i = 0; i < impl->stmts->set.count; ++i) {
 600                 set_stmt *set = impl->stmts->set.list[i];
 601                 int check = 0;
 602
 603                 if (impl->func->args) for (j = 0; j < impl->func->args->count; ++j) {
 604                         impl_arg *iarg = impl->func->args->args[j];
 605
 606                         if (!strcmp(set->var->name, iarg->var->name)) {
 607                                 set->arg = iarg;
 608                                 check = 1;
 609                                 break;
 610                         }
 611                 }
 612                 if (!check) {
 613                         data->error(PSI_WARNING, "Unknown variable '$%s' of `set` statement"
 614                                         " of implementation '%s'",
 615                                         set->var->name, impl->func->name);
 616                         return 0;
 617                 }
 618
 619                 for (j = 0; j < set->val->vars->count; ++j) {
 620                         decl_var *set_var = set->val->vars->vars[j];
 621
 622                         check = 0;
 623                         if (impl->decl->args) for (k = 0; k < impl->decl->args->count; ++k) {
 624                                 decl_arg *set_arg = impl->decl->args->args[k];
 625
 626                                 if (!strcmp(set_var->name, set_arg->var->name)) {
 627                                         check = 1;
 628                                         if (!validate_set_value(data, set->val, set_arg, impl->decl->args)) {
 629                                                 return 0;
 630                                         }
 631                                         set_var->arg = set_arg;
 632                                         break;
 633                                 }
 634                         }
 635
 636                         if (!check) {
 637                                 data->error(PSI_WARNING, "Unknown value '%s' of `set` statement"
 638                                                 " for variable '$%s' of implementation '%s'",
 639                                                 set_var->name, set->arg->var->name, impl->func->name);
 640                                 return 0;
 641                         }
 642                 }
 643         }
 644         return 1;
 645 }
 646 static inline decl *locate_free_decl(decls *decls, free_call *f) {
 647         if (decls)  {
 648                 size_t i;
 649
 650                 for (i = 0; i < decls->count; ++i) {
 651                         if (!strcmp(decls->list[i]->func->var->name, f->func)) {
 652                                 f->decl = decls->list[i];
 653                                 return decls->list[i];
 654                         }
 655                 }
 656         }
 657
 658         return NULL;
 659 }
 660 static inline int validate_impl_free_stmts(PSI_Data *data, impl *impl) {
 661         size_t i, j, k, l;
 662         /* we can have any count of free stmts; freeing any out vars */
 663         for (i = 0; i < impl->stmts->fre.count; ++i) {
 664                 free_stmt *fre = impl->stmts->fre.list[i];
 665
 666                 for (j = 0; j < fre->calls->count; ++j) {
 667                         free_call *free_call = fre->calls->list[j];
 668
 669                         /* first find the decl of the free func */
 670                         if (!locate_free_decl(data->decls, free_call)) {
 671                                 data->error(PSI_WARNING, "Unknown function '%s' in `free` statement"
 672                                                 " of implementation '%s'", free_call->func, impl->func->name);
 673                                 return 0;
 674                         }
 675                         if (!impl->decl->args) {
 676                                 data->error(PSI_WARNING, "Declaration '%s' of implementation '%s'"
 677                                                 " does not have any arguments to free",
 678                                                 impl->decl->func->var->name, impl->func->name);
 679                         }
 680
 681                         /* now check for known vars */
 682                         for (l = 0; l < free_call->vars->count; ++l) {
 683                                 int check = 0;
 684                                 decl_var *free_var = free_call->vars->vars[l];
 685
 686                                 for (k = 0; k < impl->decl->args->count; ++k) {
 687                                         decl_arg *free_arg = impl->decl->args->args[k];
 688
 689                                         if (!strcmp(free_var->name, free_arg->var->name)) {
 690                                                 check = 1;
 691                                                 free_var->arg = free_arg;
 692                                                 break;
 693                                         }
 694                                 }
 695
 696                                 if (!check) {
 697                                         data->error(PSI_WARNING, "Unknown variable '%s' of `free` statement"
 698                                                         " of implementation '%s'",
 699                                                         free_var->name, impl->func->name);
 700                                         return 0;
 701                                 }
 702                         }
 703                 }
 704         }
 705         return 1;
 706 }
 707 static inline int validate_impl_stmts(PSI_Data *data, impl *impl) {
 708         if (!impl->stmts) {
 709                 data->error(PSI_WARNING, "Missing body for implementation %s!",
 710                                 impl->func->name);
 711                 return 0;
 712         }
 713
 714         if (!validate_impl_ret_stmt(data, impl)) {
 715                 return 0;
 716         }
 717
 718         if (!validate_impl_let_stmts(data, impl)) {
 719                 return 0;
 720         }
 721         if (!validate_impl_set_stmts(data, impl)) {
 722                 return 0;
 723         }
 724         if (!validate_impl_free_stmts(data, impl)) {
 725                 return 0;
 726         }
 727
 728         return 1;
 729 }
 730
 731 PSI_Context *PSI_ContextInit(PSI_Context *C, PSI_ContextOps *ops, PSI_ContextErrorFunc error)
 732 {
 733         size_t i;
 734         PSI_Data T;
 735         struct psi_predef_type *predef_type;
 736         struct psi_predef_const *predef_const;
 737         struct psi_predef_struct *predef_struct;
 738         struct psi_predef_decl *predef_decl;
 739
 740         if (!C) {
 741                 C = malloc(sizeof(*C));
 742         }
 743         memset(C, 0, sizeof(*C));
 744
 745         C->error = error;
 746         C->ops = ops;
 747
 748         if (ops->init) {
 749                 ops->init(C);
 750         }
 751
 752         ZEND_ASSERT(ops->call != NULL);
 753         ZEND_ASSERT(ops->compile != NULL);
 754
 755         /* build up predefs in a temporary PSI_Data for validation */
 756         memset(&T, 0, sizeof(T));
 757         T.error = error;
 758
 759         for (predef_type = &psi_predef_types[0]; predef_type->type_tag; ++predef_type) {
 760                 decl_type *type = init_decl_type(predef_type->type_tag, predef_type->type_name);
 761                 decl_typedef *def = init_decl_typedef(predef_type->alias, type);
 762
 763                 T.defs = add_decl_typedef(T.defs, def);
 764         }
 765         for (predef_const = &psi_predef_consts[0]; predef_const->type_tag; ++predef_const) {
 766                 impl_def_val *val = init_impl_def_val(predef_const->val_type_tag, predef_const->val_text);
 767                 const_type *type = init_const_type(predef_const->type_tag, predef_const->type_name);
 768                 constant *constant = init_constant(type, predef_const->var_name, val);
 769
 770                 T.consts = add_constant(T.consts, constant);
 771         }
 772         for (predef_struct = &psi_predef_structs[0]; predef_struct->type_tag; ++predef_struct) {
 773                 struct psi_predef_struct *member;
 774                 decl_args *dargs = init_decl_args(NULL);
 775                 decl_struct *dstruct = init_decl_struct(predef_struct->var_name, dargs);
 776
 777                 dstruct->size = predef_struct->size;
 778                 for (member = &predef_struct[1]; member->type_tag; ++member) {
 779                         decl_type *type;
 780                         decl_var *dvar;
 781                         decl_arg *darg;
 782
 783                         type = init_decl_type(member->type_tag, member->type_name);
 784                         dvar = init_decl_var(member->var_name, member->pointer_level, member->array_size);
 785                         darg = init_decl_arg(type, dvar);
 786                         darg->layout = init_decl_struct_layout(member->offset, member->size);
 787                         dargs = add_decl_arg(dargs, darg);
 788                 }
 789
 790                 T.structs = add_decl_struct(T.structs, dstruct);
 791                 predef_struct = member;
 792         }
 793         for (predef_decl = &psi_predef_decls[0]; predef_decl->type_tag; ++predef_decl) {
 794                 struct psi_predef_decl *farg;
 795                 decl_type *ftype = init_decl_type(predef_decl->type_tag, predef_decl->type_name);
 796                 decl_var *fname = init_decl_var(predef_decl->var_name, predef_decl->pointer_level, predef_decl->array_size);
 797                 decl_arg *func = init_decl_arg(ftype, fname);
 798                 decl_args *args = init_decl_args(NULL);
 799                 decl *decl = init_decl(init_decl_abi("default"), func, args);
 800
 801
 802                 for (farg = &predef_decl[1]; farg->type_tag; ++farg) {
 803                         decl_type *arg_type = init_decl_type(farg->type_tag, farg->type_name);
 804                         decl_var *arg_var = init_decl_var(farg->var_name, farg->pointer_level, farg->array_size);
 805                         decl_arg *darg = init_decl_arg(arg_type, arg_var);
 806                         args = add_decl_arg(args, darg);
 807                 }
 808
 809                 T.decls = add_decl(T.decls, decl);
 810                 predef_decl = farg;
 811         }
 812
 813         for (i = 0; i < T.defs->count; ++i) {
 814                 decl_typedef *def = T.defs->list[i];
 815
 816                 if (validate_decl_typedef(&T, def)) {
 817                         C->defs = add_decl_typedef(C->defs, def);
 818                 }
 819         }
 820
 821         for (i = 0; i < T.consts->count; ++i) {
 822                 constant *constant = T.consts->list[i];
 823
 824                 if (validate_constant(&T, constant)) {
 825                         C->consts = add_constant(C->consts, constant);
 826                 }
 827         }
 828
 829         for (i = 0; i < T.structs->count; ++i) {
 830                 decl_struct *dstruct = T.structs->list[i];
 831
 832                 if (validate_decl_struct(&T, dstruct)) {
 833                         C->structs = add_decl_struct(C->structs, dstruct);
 834                 }
 835         }
 836
 837         for (i = 0; i < T.decls->count; ++i) {
 838                 decl *decl = T.decls->list[i];
 839
 840                 if (validate_decl(&T, NULL, decl)) {
 841                         C->decls = add_decl(C->decls, decl);
 842                 }
 843         }
 844
 845         C->count = 1;
 846         C->data = malloc(sizeof(*C->data));
 847         PSI_DataExchange(C->data, &T);
 848
 849         return C;
 850 }
 851
 852 int PSI_ContextValidate(PSI_Context *C, PSI_Parser *P)
 853 {
 854         PSI_Data *D;
 855         void *dlopened = NULL;
 856         size_t count = C->count++;
 857
 858         C->data = realloc(C->data, C->count * sizeof(*C->data));
 859         D = PSI_DataExchange(&C->data[count], PSI_DATA(P));
 860
 861         if (D->defs) {
 862                 size_t i;
 863
 864                 for (i = 0; i < D->defs->count; ++i) {
 865                         if (validate_decl_typedef(PSI_DATA(C), D->defs->list[i])) {
 866                                 C->defs = add_decl_typedef(C->defs, D->defs->list[i]);
 867                         }
 868                 }
 869         }
 870         if (D->structs) {
 871                 size_t i;
 872
 873                 for (i = 0; i < D->structs->count; ++i) {
 874                         if (validate_decl_struct(PSI_DATA(C), D->structs->list[i])) {
 875                                 C->structs = add_decl_struct(C->structs, D->structs->list[i]);
 876                         }
 877                 }
 878         }
 879         if (D->consts) {
 880                 size_t i;
 881
 882                 for (i = 0; i < D->consts->count; ++i) {
 883                         if (validate_constant(PSI_DATA(C), D->consts->list[i])) {
 884                                 C->consts = add_constant(C->consts, D->consts->list[i]);
 885                         }
 886                 }
 887         }
 888
 889         if (!validate_lib(D, &dlopened)) {
 890                 return 0;
 891         }
 892
 893         add_decl_lib(&C->psi.libs, dlopened);
 894
 895         if (D->decls) {
 896                 size_t i;
 897
 898                 for (i = 0; i < D->decls->count; ++i) {
 899                         if (validate_decl(PSI_DATA(C), dlopened, D->decls->list[i])) {
 900                                 C->decls = add_decl(C->decls, D->decls->list[i]);
 901                         }
 902                 }
 903         }
 904         if (D->impls) {
 905                 size_t i;
 906
 907                 for (i = 0; i < D->impls->count; ++i) {
 908                         if (validate_impl_stmts(PSI_DATA(C), D->impls->list[i])) {
 909                                 C->impls = add_impl(C->impls, D->impls->list[i]);
 910                         }
 911                 }
 912         }
 913
 914         return 1;
 915 }
 916
 917 static int psi_select_dirent(const struct dirent *entry)
 918 {
 919 #ifndef FNM_CASEFOLD
 920 #define FNM_CASEFOLD 0
 921 #endif
 922         return 0 == fnmatch("*.psi", entry->d_name, FNM_CASEFOLD);
 923 }
 924
 925 void PSI_ContextBuild(PSI_Context *C, const char *paths)
 926 {
 927         int i, n, flags = psi_check_env("PSI_DEBUG") ? PSI_PARSER_DEBUG : 0;
 928         char *sep = NULL, *cpy = strdup(paths), *ptr = cpy;
 929         struct dirent **entries = NULL;
 930
 931
 932         do {
 933                 sep = strchr(ptr, ':');
 934
 935                 if (sep) {
 936                         *sep = 0;
 937                 }
 938
 939                 n = php_scandir(ptr, &entries, psi_select_dirent, alphasort);
 940
 941                 if (n > 0) {
 942                         for (i = 0; i < n; ++i) {
 943                                 char psi[MAXPATHLEN];
 944                                 PSI_Parser P;
 945
 946                                 if (MAXPATHLEN <= slprintf(psi, MAXPATHLEN, "%s/%s", ptr, entries[i]->d_name)) {
 947                                         C->error(PSI_WARNING, "Path to PSI file too long: %s/%s",
 948                                                 ptr, entries[i]->d_name);
 949                                 }
 950                                 if (!PSI_ParserInit(&P, psi, C->error, flags)) {
 951                                         C->error(PSI_WARNING, "Failed to init PSI parser (%s): %s",
 952                                                 psi, strerror(errno));
 953                                         continue;
 954                                 }
 955
 956                                 while (-1 != PSI_ParserScan(&P)) {
 957                                         PSI_ParserParse(&P, PSI_TokenAlloc(&P));
 958                                 };
 959                                 PSI_ParserParse(&P, NULL);
 960                                 PSI_ContextValidate(C, &P);
 961                                 PSI_ParserDtor(&P);
 962                         }
 963                 }
 964
 965                 if (entries) {
 966                         for (i = 0; i < n; ++i) {
 967                                 free(entries[i]);
 968                         }
 969                         free(entries);
 970                 }
 971
 972                 ptr = sep + 1;
 973         } while (sep);
 974
 975
 976         if (PSI_ContextCompile(C) && SUCCESS != zend_register_functions(NULL, C->closures, NULL, MODULE_PERSISTENT)) {
 977                 C->error(PSI_WARNING, "Failed to register functions!");
 978         }
 979
 980         free(cpy);
 981
 982 }
 983
 984 zend_function_entry *PSI_ContextCompile(PSI_Context *C)
 985 {
 986         size_t i;
 987
 988         if (C->consts) {
 989                 zend_constant zc;
 990
 991                 zc.flags = CONST_PERSISTENT|CONST_CS;
 992                 zc.module_number = EG(current_module)->module_number;
 993
 994                 for (i = 0; i < C->consts->count; ++i) {
 995                         constant *c = C->consts->list[i];
 996
 997                         zc.name = zend_string_init(c->name + (c->name[0] == '\\'), strlen(c->name) - (c->name[0] == '\\'), 1);
 998                         ZVAL_NEW_STR(&zc.value, zend_string_init(c->val->text, strlen(c->val->text), 1));
 999
1000                         switch (c->type->type) {
1001                         case PSI_T_BOOL:
1002                                 convert_to_boolean(&zc.value);
1003                                 break;
1004                         case PSI_T_INT:
1005                                 convert_to_long(&zc.value);
1006                                 break;
1007                         case PSI_T_FLOAT:
1008                                 convert_to_double(&zc.value);
1009                                 break;
1010                         }
1011                         zend_register_constant(&zc);
1012                 }
1013         }
1014
1015         return C->closures = C->ops->compile(C);
1016 }
1017
1018
1019 void PSI_ContextCall(PSI_Context *C, impl_val *ret_val, decl *decl)
1020 {
1021         C->ops->call(C, ret_val, decl);
1022 }
1023
1024 static inline void dump_decl_type(int fd, decl_type *t) {
1025         const char *pre;
1026
1027         switch (t->type) {
1028         case PSI_T_STRUCT:
1029                 pre = "struct ";
1030                 break;
1031         default:
1032                 pre = "";
1033         }
1034         dprintf(fd, "%s%s", pre, t->name);
1035 }
1036 static inline void dump_decl_var(int fd, decl_var *v) {
1037         dprintf(fd, "%.*s%s", v->pointer_level-!!v->array_size, "**********", v->name);
1038         if (v->array_size) {
1039                 dprintf(fd, "[%u]", v->array_size);
1040         }
1041 }
1042 static inline void dump_decl_arg(int fd, decl_arg *a) {
1043         dump_decl_type(fd, a->type);
1044         dprintf(fd, " ");
1045         dump_decl_var(fd, a->var);
1046 }
1047 void PSI_ContextDump(PSI_Context *C, int fd)
1048 {
1049         size_t i, j;
1050
1051 #ifdef HAVE_LIBJIT
1052         if (C->ops == PSI_Libjit()) {
1053                 dprintf(fd, "#PSI(libjit)\n");
1054         }
1055 #endif
1056 #ifdef HAVE_LIBFFI
1057         if (C->ops == PSI_Libffi()) {
1058                 dprintf(fd, "#PSI(libffi)\n");
1059         }
1060 #endif
1061
1062         if (C->defs) for (i = 0; i < C->defs->count; ++i) {
1063                 decl_typedef *tdef = C->defs->list[i];
1064
1065                 dprintf(fd, "typedef ");
1066                 dump_decl_type(fd, tdef->type);
1067                 dprintf(fd, " %s;\n", tdef->alias);
1068         }
1069         if (C->structs) for (i = 0; i < C->structs->count; ++i) {
1070                 decl_struct *strct = C->structs->list[i];
1071                 decl_arg *sarg = NULL;
1072
1073                 dprintf(fd, "struct %s::(%zu) {\n", strct->name, strct->size);
1074                 for (j = 0; j < strct->args->count; ++j) {
1075                         sarg = strct->args->args[j];
1076                         dprintf(fd, "\t");
1077                         dump_decl_arg(fd, sarg);
1078                         dprintf(fd, "::(%zu, %zu);\n", sarg->layout->pos, sarg->layout->len);
1079                 }
1080                 dprintf(fd, "}\n");
1081         }
1082
1083         dprintf(fd, "\n");
1084 }
1085
1086 void PSI_ContextDtor(PSI_Context *C)
1087 {
1088         size_t i;
1089         zend_function_entry *zfe;
1090
1091         if (C->ops->dtor) {
1092                 C->ops->dtor(C);
1093         }
1094
1095         free_decl_libs(&C->psi.libs);
1096
1097         if (C->data) {
1098                 for (i = 0; i < C->count; ++i) {
1099                         PSI_DataDtor(&C->data[i]);
1100                 }
1101                 free(C->data);
1102         }
1103
1104         if (C->closures) {
1105                 for (zfe = C->closures; zfe->fname; ++zfe) {
1106                         free((void *) zfe->arg_info);
1107                 }
1108                 free(C->closures);
1109         }
1110
1111         if (C->consts) {
1112                 if (C->consts->list) {
1113                         free(C->consts->list);
1114                 }
1115                 free(C->consts);
1116         }
1117         if (C->defs) {
1118                 if (C->defs->list) {
1119                         free(C->defs->list);
1120                 }
1121                 free(C->defs);
1122         }
1123         if (C->structs) {
1124                 if (C->structs->list) {
1125                         free(C->structs->list);
1126                 }
1127                 free(C->structs);
1128         }
1129         if (C->decls) {
1130                 if (C->decls->list) {
1131                         free(C->decls->list);
1132                 }
1133                 free(C->decls);
1134         }
1135         if (C->impls) {
1136                 if (C->impls->list) {
1137                         free(C->impls->list);
1138                 }
1139                 free(C->impls);
1140         }
1141
1142         memset(C, 0, sizeof(*C));
1143 }
1144
1145 void PSI_ContextFree(PSI_Context **C)
1146 {
1147         if (*C) {
1148                 PSI_ContextDtor(*C);
1149                 free(*C);
1150                 *C = NULL;
1151         }
1152 }