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