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_psi_stdinc.h"
   6
   7 #include "php.h"
   8
   9 #ifdef HAVE_DIRENT_H
  10 # include <dirent.h>
  11 # define NAMLEN(dirent) strlen ((dirent)->d_name)
  12 #else
  13 # define dirent direct
  14 # define NAMLEN(dirent) ((dirent)->d_namlen)
  15 # ifdef HAVE_SYS_NDIR_H
  16 #  include <sys/ndir.h>
  17 # endif
  18 # ifdef HAVE_SYS_DIR_H
  19 #  include <sys/dir.h>
  20 # endif
  21 # ifdef HAVE_NDIR_H
  22 #  include <ndir.h>
  23 # endif
  24 #endif
  25
  26 #include <fnmatch.h>
  27
  28 #include "php_scandir.h"
  29 #include "php_psi.h"
  30 #include "calc.h"
  31 #include "libjit.h"
  32 #include "libffi.h"
  33
  34 #include "token.h"
  35 #include "parser.h"
  36
  37 #include "php_psi_types.h"
  38 #include "php_psi_consts.h"
  39 #include "php_psi_decls.h"
  40 #include "php_psi_va_decls.h"
  41 #include "php_psi_fn_decls.h"
  42 #include "php_psi_structs.h"
  43 #include "php_psi_unions.h"
  44
  45 struct psi_context *psi_context_init(struct psi_context *C, struct psi_context_ops *ops, psi_context_error_func error, unsigned flags)
  46 {
  47         struct psi_data T;
  48         struct psi_predef_type *predef_type;
  49         struct psi_predef_const *predef_const;
  50         struct psi_predef_struct *predef_struct;
  51         struct psi_predef_union *predef_union;
  52         struct psi_predef_decl *predef_decl;
  53
  54         if (!C) {
  55                 C = malloc(sizeof(*C));
  56         }
  57         memset(C, 0, sizeof(*C));
  58
  59         C->error = error;
  60         C->flags = flags;
  61         C->ops = ops;
  62
  63         if (ops->init) {
  64                 ops->init(C);
  65         }
  66
  67         ZEND_ASSERT(ops->call != NULL);
  68         ZEND_ASSERT(ops->compile != NULL);
  69
  70         /* build up predefs in a temporary PSI_Data for validation */
  71         memset(&T, 0, sizeof(T));
  72         T.error = error;
  73
  74         for (predef_type = &psi_predef_types[0]; predef_type->type_tag; ++predef_type) {
  75                 decl_type *type = init_decl_type(predef_type->type_tag, predef_type->type_name);
  76                 decl_var *var = init_decl_var(predef_type->alias, 0, 0); /* FIXME: indirection */
  77                 decl_arg *def = init_decl_arg(type, var);
  78
  79                 T.defs = add_decl_typedef(T.defs, def);
  80         }
  81         for (predef_const = &psi_predef_consts[0]; predef_const->type_tag; ++predef_const) {
  82                 impl_def_val *val = init_impl_def_val(predef_const->val_type_tag, predef_const->val_text);
  83                 const_type *type = init_const_type(predef_const->type_tag, predef_const->type_name);
  84                 constant *constant = init_constant(type, predef_const->var_name, val);
  85
  86                 T.consts = add_constant(T.consts, constant);
  87         }
  88         for (predef_struct = &psi_predef_structs[0]; predef_struct->type_tag; ++predef_struct) {
  89                 struct psi_predef_struct *member;
  90                 decl_args *dargs = init_decl_args(NULL);
  91                 decl_struct *dstruct = init_decl_struct(predef_struct->var_name, dargs);
  92
  93                 dstruct->size = predef_struct->size;
  94                 dstruct->align = predef_struct->offset;
  95                 for (member = &predef_struct[1]; member->type_tag; ++member) {
  96                         decl_type *type;
  97                         decl_var *dvar;
  98                         decl_arg *darg;
  99
 100                         type = init_decl_type(member->type_tag, member->type_name);
 101                         dvar = init_decl_var(member->var_name, member->pointer_level, member->array_size);
 102                         darg = init_decl_arg(type, dvar);
 103                         darg->layout = init_decl_struct_layout(member->offset, member->size);
 104                         dargs = add_decl_arg(dargs, darg);
 105                 }
 106
 107                 T.structs = add_decl_struct(T.structs, dstruct);
 108                 predef_struct = member;
 109         }
 110         for (predef_union = &psi_predef_unions[0]; predef_union->type_tag; ++predef_union) {
 111                 struct psi_predef_union *member;
 112                 decl_args *dargs = init_decl_args(NULL);
 113                 decl_union *dunion = init_decl_union(predef_union->var_name, dargs);
 114
 115                 dunion->size = predef_union->size;
 116                 dunion->align = predef_union->offset;
 117                 for (member = &predef_union[1]; member->type_tag; ++member) {
 118                         decl_type *type;
 119                         decl_var *dvar;
 120                         decl_arg *darg;
 121
 122                         type = init_decl_type(member->type_tag, member->type_name);
 123                         dvar = init_decl_var(member->var_name, member->pointer_level, member->array_size);
 124                         darg = init_decl_arg(type, dvar);
 125                         darg->layout = init_decl_struct_layout(member->offset, member->size);
 126                         dargs = add_decl_arg(dargs, darg);
 127                 }
 128
 129                 T.unions = add_decl_union(T.unions, dunion);
 130                 predef_union = member;
 131         }
 132         for (predef_decl = &psi_predef_decls[0]; predef_decl->type_tag; ++predef_decl) {
 133                 struct psi_predef_decl *farg;
 134                 decl_type *ftype = init_decl_type(predef_decl->type_tag, predef_decl->type_name);
 135                 decl_var *fname = init_decl_var(predef_decl->var_name, predef_decl->pointer_level, predef_decl->array_size);
 136                 decl_arg *func = init_decl_arg(ftype, fname);
 137                 decl_args *args = init_decl_args(NULL);
 138                 decl *decl = init_decl(init_decl_abi("default"), func, args);
 139
 140                 for (farg = &predef_decl[1]; farg->type_tag; ++farg) {
 141                         decl_type *arg_type = init_decl_type(farg->type_tag, farg->type_name);
 142                         decl_var *arg_var = init_decl_var(farg->var_name, farg->pointer_level, farg->array_size);
 143                         decl_arg *darg = init_decl_arg(arg_type, arg_var);
 144                         args = add_decl_arg(args, darg);
 145                 }
 146
 147                 T.decls = add_decl(T.decls, decl);
 148                 predef_decl = farg;
 149         }
 150
 151         for (predef_decl = &psi_predef_vararg_decls[0]; predef_decl->type_tag; ++predef_decl) {
 152                 struct psi_predef_decl *farg;
 153                 decl_type *ftype = init_decl_type(predef_decl->type_tag, predef_decl->type_name);
 154                 decl_var *fname = init_decl_var(predef_decl->var_name, predef_decl->pointer_level, predef_decl->array_size);
 155                 decl_arg *func = init_decl_arg(ftype, fname);
 156                 decl_args *args = init_decl_args(NULL);
 157                 decl *decl = init_decl(init_decl_abi("default"), func, args);
 158
 159                 for (farg = &predef_decl[1]; farg->type_tag; ++farg) {
 160                         decl_type *arg_type = init_decl_type(farg->type_tag, farg->type_name);
 161                         decl_var *arg_var = init_decl_var(farg->var_name, farg->pointer_level, farg->array_size);
 162                         decl_arg *darg = init_decl_arg(arg_type, arg_var);
 163                         args = add_decl_arg(args, darg);
 164                 }
 165                 args->varargs = 1;
 166
 167                 T.decls = add_decl(T.decls, decl);
 168                 predef_decl = farg;
 169         }
 170
 171         for (predef_decl = &psi_predef_functor_decls[0]; predef_decl->type_tag; ++predef_decl) {
 172                 struct psi_predef_decl *farg;
 173                 decl_type *dtype, *ftype = init_decl_type(predef_decl->type_tag, predef_decl->type_name);
 174                 decl_var *fname = init_decl_var(predef_decl->var_name, predef_decl->pointer_level, predef_decl->array_size);
 175                 decl_arg *tdef, *func = init_decl_arg(ftype, fname);
 176                 decl_args *args = init_decl_args(NULL);
 177                 decl *decl = init_decl(init_decl_abi("default"), func, args);
 178
 179                 for (farg = &predef_decl[1]; farg->type_tag; ++farg) {
 180                         decl_type *arg_type = init_decl_type(farg->type_tag, farg->type_name);
 181                         decl_var *arg_var = init_decl_var(farg->var_name, farg->pointer_level, farg->array_size);
 182                         decl_arg *darg = init_decl_arg(arg_type, arg_var);
 183                         args = add_decl_arg(args, darg);
 184                 }
 185
 186                 dtype = init_decl_type(PSI_T_FUNCTION, fname->name);
 187                 dtype->real.func = decl;
 188                 tdef = init_decl_arg(dtype, copy_decl_var(fname));
 189                 T.defs = add_decl_typedef(T.defs, tdef);
 190
 191                 predef_decl = farg;
 192         }
 193
 194         psi_context_validate_data(PSI_DATA(C), &T);
 195
 196         C->count = 1;
 197         C->data = malloc(sizeof(*C->data));
 198         psi_data_exchange(C->data, &T);
 199
 200         return C;
 201 }
 202
 203 static int psi_select_dirent(const struct dirent *entry)
 204 {
 205 #ifndef FNM_CASEFOLD
 206 #define FNM_CASEFOLD 0
 207 #endif
 208         return 0 == fnmatch("*.psi", entry->d_name, FNM_CASEFOLD);
 209 }
 210
 211 void psi_context_build(struct psi_context *C, const char *paths)
 212 {
 213         int i, n;
 214         char *sep = NULL, *cpy = strdup(paths), *ptr = cpy;
 215         struct dirent **entries;
 216
 217         do {
 218                 sep = strchr(ptr, ':');
 219
 220                 if (sep) {
 221                         *sep = 0;
 222                 }
 223
 224                 entries = NULL;
 225                 n = php_scandir(ptr, &entries, psi_select_dirent, alphasort);
 226
 227                 if (n > 0) {
 228                         for (i = 0; i < n; ++i) {
 229                                 char psi[MAXPATHLEN];
 230                                 struct psi_parser P;
 231
 232                                 if (MAXPATHLEN <= slprintf(psi, MAXPATHLEN, "%s/%s", ptr, entries[i]->d_name)) {
 233                                         C->error(C, NULL, PSI_WARNING, "Path to PSI file too long: %s/%s",
 234                                                 ptr, entries[i]->d_name);
 235                                 }
 236                                 if (!psi_parser_init(&P, psi, C->error, C->flags)) {
 237                                         C->error(C, NULL, PSI_WARNING, "Failed to init PSI parser (%s): %s",
 238                                                 psi, strerror(errno));
 239                                         continue;
 240                                 }
 241
 242                                 while (0 < psi_parser_scan(&P)) {
 243                                         psi_parser_parse(&P, psi_token_alloc(&P));
 244                                         if (P.num == PSI_T_EOF) {
 245                                                 break;
 246                                         }
 247                                 }
 248
 249                                 psi_parser_parse(&P, NULL);
 250                                 psi_context_validate(C, &P);
 251                                 psi_parser_dtor(&P);
 252                         }
 253                 }
 254
 255                 if (entries) {
 256                         for (i = 0; i < n; ++i) {
 257                                 free(entries[i]);
 258                         }
 259                         free(entries);
 260                 }
 261
 262                 ptr = sep + 1;
 263         } while (sep);
 264
 265
 266         if (psi_context_compile(C) && SUCCESS != zend_register_functions(NULL, C->closures, NULL, MODULE_PERSISTENT)) {
 267                 C->error(C, NULL, PSI_WARNING, "Failed to register functions!");
 268         }
 269
 270         free(cpy);
 271
 272 }
 273
 274 zend_function_entry *psi_context_compile(struct psi_context *C)
 275 {
 276         size_t i;
 277         zend_constant zc;
 278
 279         zc.flags = CONST_PERSISTENT|CONST_CS;
 280         zc.module_number = EG(current_module)->module_number;
 281
 282         if (C->consts) {
 283                 for (i = 0; i < C->consts->count; ++i) {
 284                         constant *c = C->consts->list[i];
 285
 286                         zc.name = zend_string_init(c->name + (c->name[0] == '\\'), strlen(c->name) - (c->name[0] == '\\'), 1);
 287                         ZVAL_NEW_STR(&zc.value, zend_string_init(c->val->text, strlen(c->val->text), 1));
 288
 289                         switch (c->type->type) {
 290                         case PSI_T_BOOL:
 291                                 convert_to_boolean(&zc.value);
 292                                 break;
 293                         case PSI_T_INT:
 294                                 convert_to_long(&zc.value);
 295                                 break;
 296                         case PSI_T_FLOAT:
 297                                 convert_to_double(&zc.value);
 298                                 break;
 299                         }
 300                         zend_register_constant(&zc);
 301                 }
 302         }
 303         if (C->enums) {
 304                 for (i = 0; i < C->enums->count; ++i) {
 305                         decl_enum *e = C->enums->list[i];
 306                         size_t j;
 307
 308                         for (j = 0; j < e->items->count; ++j) {
 309                                 decl_enum_item *i = e->items->list[j];
 310                                 zend_string *name = strpprintf(0, "psi\\%s\\%s", e->name, i->name);
 311
 312                                 zc.name = zend_string_dup(name, 1);
 313                                 ZVAL_LONG(&zc.value, psi_long_num_exp(i->num, NULL));
 314                                 zend_register_constant(&zc);
 315                                 zend_string_release(name);
 316                         }
 317                 }
 318         }
 319
 320         return C->closures = C->ops->compile(C);
 321 }
 322
 323
 324 void psi_context_call(struct psi_context *C, struct decl_callinfo *decl_call, struct impl_vararg *va)
 325 {
 326         C->ops->call(C, decl_call, va);
 327 }
 328
 329
 330 void psi_context_dtor(struct psi_context *C)
 331 {
 332         size_t i;
 333         zend_function_entry *zfe;
 334
 335         if (C->ops->dtor) {
 336                 C->ops->dtor(C);
 337         }
 338
 339         free_decl_libs(&C->psi.libs);
 340
 341         if (C->data) {
 342                 for (i = 0; i < C->count; ++i) {
 343                         psi_data_dtor(&C->data[i]);
 344                 }
 345                 free(C->data);
 346         }
 347
 348         if (C->closures) {
 349                 for (zfe = C->closures; zfe->fname; ++zfe) {
 350                         free((void *) zfe->arg_info);
 351                 }
 352                 free(C->closures);
 353         }
 354
 355         if (C->consts) {
 356                 if (C->consts->list) {
 357                         free(C->consts->list);
 358                 }
 359                 free(C->consts);
 360         }
 361         if (C->defs) {
 362                 if (C->defs->list) {
 363                         free(C->defs->list);
 364                 }
 365                 free(C->defs);
 366         }
 367         if (C->structs) {
 368                 if (C->structs->list) {
 369                         free(C->structs->list);
 370                 }
 371                 free(C->structs);
 372         }
 373         if (C->unions) {
 374                 if (C->unions->list) {
 375                         free(C->unions->list);
 376                 }
 377                 free(C->unions);
 378         }
 379         if (C->enums) {
 380                 if (C->enums->list) {
 381                         free(C->enums->list);
 382                 }
 383                 free(C->enums);
 384         }
 385         if (C->decls) {
 386                 if (C->decls->list) {
 387                         free(C->decls->list);
 388                 }
 389                 free(C->decls);
 390         }
 391         if (C->impls) {
 392                 if (C->impls->list) {
 393                         free(C->impls->list);
 394                 }
 395                 free(C->impls);
 396         }
 397
 398         memset(C, 0, sizeof(*C));
 399 }
 400
 401 void psi_context_free(struct psi_context **C)
 402 {
 403         if (*C) {
 404                 psi_context_dtor(*C);
 405                 free(*C);
 406                 *C = NULL;
 407         }
 408 }