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 #ifdef HAVE_DIRENT_H
   8 # include <dirent.h>
   9 # define NAMLEN(dirent) strlen ((dirent)->d_name)
  10 #else
  11 # define dirent direct
  12 # define NAMLEN(dirent) ((dirent)->d_namlen)
  13 # ifdef HAVE_SYS_NDIR_H
  14 #  include <sys/ndir.h>
  15 # endif
  16 # ifdef HAVE_SYS_DIR_H
  17 #  include <sys/dir.h>
  18 # endif
  19 # ifdef HAVE_NDIR_H
  20 #  include <ndir.h>
  21 # endif
  22 #endif
  23
  24 #include <fnmatch.h>
  25
  26 #include "php.h"
  27 #include "php_scandir.h"
  28 #include "php_psi.h"
  29
  30 #include "libjit.h"
  31 #include "libffi.h"
  32
  33 #include "php_psi_types.h"
  34 #include "php_psi_consts.h"
  35 #include "php_psi_decls.h"
  36 #include "php_psi_va_decls.h"
  37 #include "php_psi_structs.h"
  38
  39
  40 PSI_Context *PSI_ContextInit(PSI_Context *C, PSI_ContextOps *ops, PSI_ContextErrorFunc error)
  41 {
  42         PSI_Data T;
  43         struct psi_predef_type *predef_type;
  44         struct psi_predef_const *predef_const;
  45         struct psi_predef_struct *predef_struct;
  46         struct psi_predef_decl *predef_decl;
  47
  48         if (!C) {
  49                 C = malloc(sizeof(*C));
  50         }
  51         memset(C, 0, sizeof(*C));
  52
  53         C->error = error;
  54         C->ops = ops;
  55
  56         if (ops->init) {
  57                 ops->init(C);
  58         }
  59
  60         ZEND_ASSERT(ops->call != NULL);
  61         ZEND_ASSERT(ops->compile != NULL);
  62
  63         /* build up predefs in a temporary PSI_Data for validation */
  64         memset(&T, 0, sizeof(T));
  65         T.error = error;
  66
  67         for (predef_type = &psi_predef_types[0]; predef_type->type_tag; ++predef_type) {
  68                 decl_type *type = init_decl_type(predef_type->type_tag, predef_type->type_name);
  69                 decl_typedef *def = init_decl_typedef(predef_type->alias, type);
  70
  71                 T.defs = add_decl_typedef(T.defs, def);
  72         }
  73         for (predef_const = &psi_predef_consts[0]; predef_const->type_tag; ++predef_const) {
  74                 impl_def_val *val = init_impl_def_val(predef_const->val_type_tag, predef_const->val_text);
  75                 const_type *type = init_const_type(predef_const->type_tag, predef_const->type_name);
  76                 constant *constant = init_constant(type, predef_const->var_name, val);
  77
  78                 T.consts = add_constant(T.consts, constant);
  79         }
  80         for (predef_struct = &psi_predef_structs[0]; predef_struct->type_tag; ++predef_struct) {
  81                 struct psi_predef_struct *member;
  82                 decl_args *dargs = init_decl_args(NULL);
  83                 decl_struct *dstruct = init_decl_struct(predef_struct->var_name, dargs);
  84
  85                 dstruct->size = predef_struct->size;
  86                 for (member = &predef_struct[1]; member->type_tag; ++member) {
  87                         decl_type *type;
  88                         decl_var *dvar;
  89                         decl_arg *darg;
  90
  91                         type = init_decl_type(member->type_tag, member->type_name);
  92                         dvar = init_decl_var(member->var_name, member->pointer_level, member->array_size);
  93                         darg = init_decl_arg(type, dvar);
  94                         darg->layout = init_decl_struct_layout(member->offset, member->size);
  95                         dargs = add_decl_arg(dargs, darg);
  96                 }
  97
  98                 T.structs = add_decl_struct(T.structs, dstruct);
  99                 predef_struct = member;
 100         }
 101         for (predef_decl = &psi_predef_decls[0]; predef_decl->type_tag; ++predef_decl) {
 102                 struct psi_predef_decl *farg;
 103                 decl_type *ftype = init_decl_type(predef_decl->type_tag, predef_decl->type_name);
 104                 decl_var *fname = init_decl_var(predef_decl->var_name, predef_decl->pointer_level, predef_decl->array_size);
 105                 decl_arg *func = init_decl_arg(ftype, fname);
 106                 decl_args *args = init_decl_args(NULL);
 107                 decl *decl = init_decl(init_decl_abi("default"), func, args);
 108
 109                 for (farg = &predef_decl[1]; farg->type_tag; ++farg) {
 110                         decl_type *arg_type = init_decl_type(farg->type_tag, farg->type_name);
 111                         decl_var *arg_var = init_decl_var(farg->var_name, farg->pointer_level, farg->array_size);
 112                         decl_arg *darg = init_decl_arg(arg_type, arg_var);
 113                         args = add_decl_arg(args, darg);
 114                 }
 115
 116                 T.decls = add_decl(T.decls, decl);
 117                 predef_decl = farg;
 118         }
 119
 120         for (predef_decl = &psi_predef_vararg_decls[0]; predef_decl->type_tag; ++predef_decl) {
 121                 struct psi_predef_decl *farg;
 122                 decl_type *ftype = init_decl_type(predef_decl->type_tag, predef_decl->type_name);
 123                 decl_var *fname = init_decl_var(predef_decl->var_name, predef_decl->pointer_level, predef_decl->array_size);
 124                 decl_arg *func = init_decl_arg(ftype, fname);
 125                 decl_args *args = init_decl_args(NULL);
 126                 decl *decl = init_decl(init_decl_abi("default"), func, args);
 127
 128                 for (farg = &predef_decl[1]; farg->type_tag; ++farg) {
 129                         decl_type *arg_type = init_decl_type(farg->type_tag, farg->type_name);
 130                         decl_var *arg_var = init_decl_var(farg->var_name, farg->pointer_level, farg->array_size);
 131                         decl_arg *darg = init_decl_arg(arg_type, arg_var);
 132                         args = add_decl_arg(args, darg);
 133                 }
 134                 args->varargs = 1;
 135
 136                 T.decls = add_decl(T.decls, decl);
 137                 predef_decl = farg;
 138         }
 139
 140         PSI_ContextValidatePredef(C, &T);
 141
 142         C->count = 1;
 143         C->data = malloc(sizeof(*C->data));
 144         PSI_DataExchange(C->data, &T);
 145
 146         return C;
 147 }
 148
 149 static int psi_select_dirent(const struct dirent *entry)
 150 {
 151 #ifndef FNM_CASEFOLD
 152 #define FNM_CASEFOLD 0
 153 #endif
 154         return 0 == fnmatch("*.psi", entry->d_name, FNM_CASEFOLD);
 155 }
 156
 157 void PSI_ContextBuild(PSI_Context *C, const char *paths)
 158 {
 159         int i, n, flags = psi_check_env("PSI_DEBUG") ? PSI_PARSER_DEBUG : 0;
 160         char *sep = NULL, *cpy = strdup(paths), *ptr = cpy;
 161         struct dirent **entries = NULL;
 162
 163
 164         do {
 165                 sep = strchr(ptr, ':');
 166
 167                 if (sep) {
 168                         *sep = 0;
 169                 }
 170
 171                 n = php_scandir(ptr, &entries, psi_select_dirent, alphasort);
 172
 173                 if (n > 0) {
 174                         for (i = 0; i < n; ++i) {
 175                                 char psi[MAXPATHLEN];
 176                                 PSI_Parser P;
 177
 178                                 if (MAXPATHLEN <= slprintf(psi, MAXPATHLEN, "%s/%s", ptr, entries[i]->d_name)) {
 179                                         C->error(NULL, PSI_WARNING, "Path to PSI file too long: %s/%s",
 180                                                 ptr, entries[i]->d_name);
 181                                 }
 182                                 if (!PSI_ParserInit(&P, psi, C->error, flags)) {
 183                                         C->error(NULL, PSI_WARNING, "Failed to init PSI parser (%s): %s",
 184                                                 psi, strerror(errno));
 185                                         continue;
 186                                 }
 187
 188                                 while (0 < PSI_ParserScan(&P)) {
 189                                         PSI_ParserParse(&P, PSI_TokenAlloc(&P));
 190                                         if (P.num == PSI_T_EOF) {
 191                                                 break;
 192                                         }
 193                                 }
 194
 195                                 PSI_ParserParse(&P, NULL);
 196                                 PSI_ContextValidate(C, &P);
 197                                 PSI_ParserDtor(&P);
 198                         }
 199                 }
 200
 201                 if (entries) {
 202                         for (i = 0; i < n; ++i) {
 203                                 free(entries[i]);
 204                         }
 205                         free(entries);
 206                 }
 207
 208                 ptr = sep + 1;
 209         } while (sep);
 210
 211
 212         if (PSI_ContextCompile(C) && SUCCESS != zend_register_functions(NULL, C->closures, NULL, MODULE_PERSISTENT)) {
 213                 C->error(NULL, PSI_WARNING, "Failed to register functions!");
 214         }
 215
 216         free(cpy);
 217
 218 }
 219
 220 zend_function_entry *PSI_ContextCompile(PSI_Context *C)
 221 {
 222         size_t i;
 223
 224         if (C->consts) {
 225                 zend_constant zc;
 226
 227                 zc.flags = CONST_PERSISTENT|CONST_CS;
 228                 zc.module_number = EG(current_module)->module_number;
 229
 230                 for (i = 0; i < C->consts->count; ++i) {
 231                         constant *c = C->consts->list[i];
 232
 233                         zc.name = zend_string_init(c->name + (c->name[0] == '\\'), strlen(c->name) - (c->name[0] == '\\'), 1);
 234                         ZVAL_NEW_STR(&zc.value, zend_string_init(c->val->text, strlen(c->val->text), 1));
 235
 236                         switch (c->type->type) {
 237                         case PSI_T_BOOL:
 238                                 convert_to_boolean(&zc.value);
 239                                 break;
 240                         case PSI_T_INT:
 241                                 convert_to_long(&zc.value);
 242                                 break;
 243                         case PSI_T_FLOAT:
 244                                 convert_to_double(&zc.value);
 245                                 break;
 246                         }
 247                         zend_register_constant(&zc);
 248                 }
 249         }
 250
 251         return C->closures = C->ops->compile(C);
 252 }
 253
 254
 255 void PSI_ContextCall(PSI_Context *C, decl_callinfo *decl_call, impl_vararg *va)
 256 {
 257         C->ops->call(C, decl_call, va);
 258 }
 259
 260
 261 void PSI_ContextDtor(PSI_Context *C)
 262 {
 263         size_t i;
 264         zend_function_entry *zfe;
 265
 266         if (C->ops->dtor) {
 267                 C->ops->dtor(C);
 268         }
 269
 270         free_decl_libs(&C->psi.libs);
 271
 272         if (C->data) {
 273                 for (i = 0; i < C->count; ++i) {
 274                         PSI_DataDtor(&C->data[i]);
 275                 }
 276                 free(C->data);
 277         }
 278
 279         if (C->closures) {
 280                 for (zfe = C->closures; zfe->fname; ++zfe) {
 281                         free((void *) zfe->arg_info);
 282                 }
 283                 free(C->closures);
 284         }
 285
 286         if (C->consts) {
 287                 if (C->consts->list) {
 288                         free(C->consts->list);
 289                 }
 290                 free(C->consts);
 291         }
 292         if (C->defs) {
 293                 if (C->defs->list) {
 294                         free(C->defs->list);
 295                 }
 296                 free(C->defs);
 297         }
 298         if (C->structs) {
 299                 if (C->structs->list) {
 300                         free(C->structs->list);
 301                 }
 302                 free(C->structs);
 303         }
 304         if (C->decls) {
 305                 if (C->decls->list) {
 306                         free(C->decls->list);
 307                 }
 308                 free(C->decls);
 309         }
 310         if (C->impls) {
 311                 if (C->impls->list) {
 312                         free(C->impls->list);
 313                 }
 314                 free(C->impls);
 315         }
 316
 317         memset(C, 0, sizeof(*C));
 318 }
 319
 320 void PSI_ContextFree(PSI_Context **C)
 321 {
 322         if (*C) {
 323                 PSI_ContextDtor(*C);
 324                 free(*C);
 325                 *C = NULL;
 326         }
 327 }