git.m6w6.name Git - m6w6/ext-psi/blob - src/context.c

   1 /*******************************************************************************
   2  Copyright (c) 2016, Michael Wallner <mike@php.net>.
   3  All rights reserved.
   4
   5  Redistribution and use in source and binary forms, with or without
   6  modification, are permitted provided that the following conditions are met:
   7
   8      * Redistributions of source code must retain the above copyright notice,
   9        this list of conditions and the following disclaimer.
  10      * Redistributions in binary form must reproduce the above copyright
  11        notice, this list of conditions and the following disclaimer in the
  12        documentation and/or other materials provided with the distribution.
  13
  14  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  15  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
  18  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  20  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  21  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  22  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24 *******************************************************************************/
  25
  26 #include "php_psi_stdinc.h"
  27
  28 #include "php.h"
  29
  30 #ifdef HAVE_DIRENT_H
  31 # include <dirent.h>
  32 # define NAMLEN(dirent) strlen ((dirent)->d_name)
  33 #else
  34 # define dirent direct
  35 # define NAMLEN(dirent) ((dirent)->d_namlen)
  36 # ifdef HAVE_SYS_NDIR_H
  37 #  include <sys/ndir.h>
  38 # endif
  39 # ifdef HAVE_SYS_DIR_H
  40 #  include <sys/dir.h>
  41 # endif
  42 # ifdef HAVE_NDIR_H
  43 #  include <ndir.h>
  44 # endif
  45 #endif
  46
  47 #include <fnmatch.h>
  48
  49 #include "php_scandir.h"
  50 #include "php_psi.h"
  51 #include "calc.h"
  52 #include "call.h"
  53 #include "libjit.h"
  54 #include "libffi.h"
  55
  56 #include "token.h"
  57 #include "parser.h"
  58
  59 #define PSI_PREDEF_TYPES
  60 #define PSI_PREDEF_CONSTS
  61 #define PSI_PREDEF_COMPOSITES
  62 #define PSI_PREDEF_DECLS
  63 #include "php_psi_posix.h"
  64
  65 struct psi_context *psi_context_init(struct psi_context *C, struct psi_context_ops *ops, psi_error_cb error, unsigned flags)
  66 {
  67         struct psi_data T;
  68         struct psi_predef_type *predef_type;
  69         struct psi_predef_const *predef_const;
  70         struct psi_predef_composite *predef_composite;
  71         struct psi_predef_decl *predef_decl;
  72
  73         if (!C) {
  74                 C = malloc(sizeof(*C));
  75         }
  76         memset(C, 0, sizeof(*C));
  77
  78         psi_data_ctor(PSI_DATA(C), error, flags);
  79         C->ops = ops;
  80
  81         if (ops->init) {
  82                 ops->init(C);
  83         }
  84
  85         assert(ops->call != NULL);
  86         assert(ops->compile != NULL);
  87
  88         /* build up predefs in a temporary PSI_Data for validation */
  89         memset(&T, 0, sizeof(T));
  90         psi_data_ctor_with_dtors(&T, error, flags);
  91
  92         for (predef_type = &psi_predef_types[0]; predef_type->type_tag; ++predef_type) {
  93                 struct psi_decl_type *type = psi_decl_type_init(predef_type->type_tag, predef_type->type_name);
  94                 struct psi_decl_var *var = psi_decl_var_init(predef_type->alias, 0, 0); /* FIXME: indirection */
  95                 struct psi_decl_arg *def = psi_decl_arg_init(type, var);
  96
  97                 T.types = psi_plist_add(T.types, &def);
  98         }
  99         for (predef_const = &psi_predef_consts[0]; predef_const->type_tag; ++predef_const) {
 100                 struct psi_const_type *type = psi_const_type_init(predef_const->type_tag, predef_const->type_name);
 101                 struct psi_impl_def_val *val;
 102                 struct psi_const *constant;
 103
 104                 switch (type->type) {
 105                 case PSI_T_INT:
 106                         val = psi_impl_def_val_init(PSI_T_INT, NULL);
 107                         val->ival.zend.lval = predef_const->value.lval;
 108                         break;
 109                 case PSI_T_STRING:
 110                         val = psi_impl_def_val_init(PSI_T_STRING, NULL);
 111                         val->ival.zend.str = zend_string_init(predef_const->value.ptr, strlen(predef_const->value.ptr), 1);
 112                         break;
 113                 default:
 114                         assert(0);
 115                         break;
 116                 }
 117
 118                 constant = psi_const_init(type, predef_const->var_name, val);
 119                 T.consts = psi_plist_add(T.consts, &constant);
 120         }
 121         for (predef_composite = &psi_predef_composites[0]; predef_composite->type_tag; ++predef_composite) {
 122                 struct psi_predef_composite *member;
 123                 struct psi_decl_struct *dstruct;
 124                 struct psi_decl_union *dunion;
 125                 struct psi_plist *dargs = psi_plist_init((psi_plist_dtor) psi_decl_arg_free);
 126
 127                 switch (predef_composite->type_tag) {
 128                 case PSI_T_STRUCT:
 129                         dstruct = psi_decl_struct_init(predef_composite->var_name, dargs);
 130                         dstruct->size = predef_composite->size;
 131                         dstruct->align = predef_composite->offset;
 132                         break;
 133                 case PSI_T_UNION:
 134                         dunion = psi_decl_union_init(predef_composite->var_name, dargs);
 135                         dunion->size = predef_composite->size;
 136                         dunion->align = predef_composite->offset;
 137                         break;
 138                 default:
 139                         assert(0);
 140                 }
 141                 for (member = &predef_composite[1]; member->type_tag; ++member) {
 142                         struct psi_decl_type *type;
 143                         struct psi_decl_var *dvar;
 144                         struct psi_decl_arg *darg;
 145
 146                         type = psi_decl_type_init(member->type_tag, member->type_name);
 147                         dvar = psi_decl_var_init(member->var_name, member->pointer_level, member->array_size);
 148                         darg = psi_decl_arg_init(type, dvar);
 149                         darg->layout = psi_layout_init(member->offset, member->size, NULL);
 150
 151                         switch (predef_composite->type_tag) {
 152                         case PSI_T_STRUCT:
 153                                 dstruct->args = psi_plist_add(dstruct->args, &darg);
 154                                 break;
 155                         case PSI_T_UNION:
 156                                 dunion->args = psi_plist_add(dunion->args, &darg);
 157                                 break;
 158                         default:
 159                                 assert(0);
 160                         }
 161                 }
 162                 switch (predef_composite->type_tag) {
 163                 case PSI_T_STRUCT:
 164                         T.structs = psi_plist_add(T.structs, &dstruct);
 165                         break;
 166                 case PSI_T_UNION:
 167                         T.unions = psi_plist_add(T.unions, &dunion);
 168                         break;
 169                 default:
 170                         assert(0);
 171                 }
 172
 173                 predef_composite = member;
 174         }
 175         for (predef_decl = &psi_predef_decls[0]; predef_decl->type_tag; ++predef_decl) {
 176                 struct psi_predef_decl *farg;
 177                 struct psi_decl_type *dtype, *ftype = psi_decl_type_init(predef_decl->type_tag, predef_decl->type_name);
 178                 struct psi_decl_var *fname = psi_decl_var_init(predef_decl->var_name, predef_decl->pointer_level, predef_decl->array_size);
 179                 struct psi_decl_arg *tdef, *func = psi_decl_arg_init(ftype, fname);
 180                 struct psi_plist *args = psi_plist_init((psi_plist_dtor) psi_decl_arg_free);
 181                 struct psi_decl *decl = psi_decl_init(func, args);
 182
 183                 for (farg = &predef_decl[1]; farg->type_tag; ++farg) {
 184                         struct psi_decl_type *arg_type = psi_decl_type_init(farg->type_tag, farg->type_name);
 185                         struct psi_decl_var *arg_var = psi_decl_var_init(farg->var_name, farg->pointer_level, farg->array_size);
 186                         struct psi_decl_arg *darg = psi_decl_arg_init(arg_type, arg_var);
 187                         decl->args = psi_plist_add(decl->args, &darg);
 188                 }
 189
 190                 switch (predef_decl->kind) {
 191                 case DECL_KIND_VARARG:
 192                         decl->varargs = 1;
 193                         /* no break */
 194                 case DECL_KIND_STD:
 195                         T.decls = psi_plist_add(T.decls, &decl);
 196                         break;
 197                 case DECL_KIND_FUNCTOR:
 198                         dtype = psi_decl_type_init(PSI_T_FUNCTION, fname->name);
 199                         dtype->real.func = decl;
 200                         tdef = psi_decl_arg_init(dtype, psi_decl_var_copy(fname));
 201                         T.types = psi_plist_add(T.types, &tdef);
 202                         break;
 203                 default:
 204                         assert(0);
 205                 }
 206
 207                 predef_decl = farg;
 208         }
 209
 210         psi_context_add_data(C, &T);
 211
 212         return C;
 213 }
 214
 215 static int psi_select_dirent(const struct dirent *entry)
 216 {
 217 #ifndef FNM_CASEFOLD
 218 # define FNM_CASEFOLD 0
 219 #endif
 220         return 0 == fnmatch("*.psi", entry->d_name, FNM_CASEFOLD);
 221 }
 222
 223 void psi_context_build(struct psi_context *C, const char *paths)
 224 {
 225         int i, n;
 226         char *sep = NULL, *cpy = strdup(paths), *ptr = cpy;
 227         struct dirent **entries;
 228
 229         do {
 230                 sep = strchr(ptr, ':');
 231
 232                 if (sep) {
 233                         *sep = 0;
 234                 }
 235
 236                 entries = NULL;
 237                 n = php_scandir(ptr, &entries, psi_select_dirent, alphasort);
 238
 239                 if (n > 0) {
 240                         for (i = 0; i < n; ++i) {
 241                                 char psi[MAXPATHLEN];
 242                                 struct psi_parser P;
 243                                 struct psi_parser_input *I;
 244
 245                                 if (MAXPATHLEN <= slprintf(psi, MAXPATHLEN, "%s/%s", ptr, entries[i]->d_name)) {
 246                                         C->error(PSI_DATA(C), NULL, PSI_WARNING, "Path to PSI file too long: %s/%s",
 247                                                 ptr, entries[i]->d_name);
 248                                 }
 249                                 if (!psi_parser_init(&P, C->error, C->flags)) {
 250                                         C->error(PSI_DATA(C), NULL, PSI_WARNING, "Failed to init PSI parser (%s): %s",
 251                                                 psi, strerror(errno));
 252                                         continue;
 253                                 }
 254                                 if (!(I = psi_parser_open_file(&P, psi, true))) {
 255                                         C->error(PSI_DATA(C), NULL, PSI_WARNING, "Failed to open PSI file (%s): %s",
 256                                                 psi, strerror(errno));
 257                                         continue;
 258                                 }
 259                                 psi_parser_parse(&P, I);
 260                                 psi_context_add_data(C, PSI_DATA(&P));
 261                                 psi_parser_dtor(&P);
 262                                 free(I);
 263                         }
 264                 }
 265
 266                 if (entries) {
 267                         for (i = 0; i < n; ++i) {
 268                                 free(entries[i]);
 269                         }
 270                         free(entries);
 271                 }
 272
 273                 ptr = sep + 1;
 274         } while (sep);
 275
 276
 277         if (psi_context_compile(C) && SUCCESS != zend_register_functions(NULL, C->closures, NULL, MODULE_PERSISTENT)) {
 278                 C->error(PSI_DATA(C), NULL, PSI_WARNING, "Failed to register functions!");
 279         }
 280
 281         free(cpy);
 282 }
 283
 284 zend_function_entry *psi_context_compile(struct psi_context *C)
 285 {
 286         zend_constant zc;
 287
 288         zc.flags = CONST_PERSISTENT|CONST_CS;
 289         zc.module_number = EG(current_module)->module_number;
 290
 291         if (C->consts) {
 292                 size_t i = 0;
 293                 struct psi_const *c;
 294
 295                 while (psi_plist_get(C->consts, i++, &c)) {
 296
 297                         if (zend_get_constant_str(c->name, strlen(c->name))) {
 298                                 continue;
 299                         }
 300
 301                         zc.name = zend_string_init(c->name, strlen(c->name), 1);
 302
 303                         switch (c->type->type) {
 304                         case PSI_T_BOOL:
 305                                 ZVAL_BOOL(&zc.value, c->val->ival.zend.bval);
 306                                 break;
 307                         case PSI_T_INT:
 308                                 ZVAL_LONG(&zc.value, c->val->ival.zend.lval);
 309                                 break;
 310                         case PSI_T_FLOAT:
 311                                 ZVAL_DOUBLE(&zc.value, c->val->ival.dval);
 312                                 break;
 313                         case PSI_T_STRING:
 314                         case PSI_T_QUOTED_STRING:
 315                                 ZVAL_NEW_STR(&zc.value, zend_string_copy(c->val->ival.zend.str));
 316                                 break;
 317                         default:
 318                                 assert(0);
 319                                 break;
 320                         }
 321
 322                         zend_register_constant(&zc);
 323                 }
 324         }
 325
 326         if (C->enums) {
 327                 size_t i = 0;
 328                 struct psi_decl_enum *e;
 329
 330                 while (psi_plist_get(C->enums, i++, &e)) {
 331                         size_t j = 0;
 332                         struct psi_decl_enum_item *item;
 333
 334                         while (psi_plist_get(e->items, j++, &item)) {
 335                                 zend_string *name = strpprintf(0, "psi\\%s\\%s", e->name, item->name);
 336
 337                                 zc.name = zend_string_dup(name, 1);
 338                                 ZVAL_LONG(&zc.value, psi_long_num_exp(item->num, NULL, NULL));
 339                                 zend_register_constant(&zc);
 340                                 zend_string_release(name);
 341                         }
 342                 }
 343         }
 344
 345         return C->closures = C->ops->compile(C);
 346 }
 347
 348
 349 ZEND_RESULT_CODE psi_context_call(struct psi_context *C, zend_execute_data *execute_data, zval *return_value, struct psi_impl *impl)
 350 {
 351         struct psi_call_frame *frame;
 352
 353         frame = psi_call_frame_init(C, impl->decl, impl);
 354
 355         if (SUCCESS != psi_call_frame_parse_args(frame, execute_data)) {
 356                 psi_call_frame_free(frame);
 357
 358                 return FAILURE;
 359         }
 360
 361         psi_call_frame_enter(frame);
 362
 363         if (SUCCESS != psi_call_frame_do_let(frame)) {
 364                 psi_call_frame_do_return(frame, return_value);
 365                 psi_call_frame_free(frame);
 366
 367                 return FAILURE;
 368         }
 369
 370         if (SUCCESS != psi_call_frame_do_assert(frame, PSI_ASSERT_PRE)) {
 371                 psi_call_frame_do_return(frame, return_value);
 372                 psi_call_frame_free(frame);
 373
 374                 return FAILURE;
 375         }
 376
 377         psi_call_frame_do_call(frame);
 378
 379         if (SUCCESS != psi_call_frame_do_assert(frame, PSI_ASSERT_POST)) {
 380                 psi_call_frame_do_return(frame, return_value);
 381                 psi_call_frame_free(frame);
 382
 383                 return FAILURE;
 384         }
 385
 386         psi_call_frame_do_return(frame, return_value);
 387         psi_call_frame_do_set(frame);
 388         psi_call_frame_do_free(frame);
 389         psi_call_frame_free(frame);
 390
 391         return SUCCESS;
 392 }
 393
 394
 395 void psi_context_dtor(struct psi_context *C)
 396 {
 397         size_t i;
 398         zend_function_entry *zfe;
 399
 400         if (C->ops->dtor) {
 401                 C->ops->dtor(C);
 402         }
 403
 404         psi_data_dtor(PSI_DATA(C));
 405
 406         if (C->data) {
 407                 for (i = 0; i < C->count; ++i) {
 408                         psi_data_dtor(&C->data[i]);
 409                 }
 410                 free(C->data);
 411         }
 412
 413         if (C->closures) {
 414                 for (zfe = C->closures; zfe->fname; ++zfe) {
 415                         free((void *) zfe->arg_info);
 416                 }
 417                 free(C->closures);
 418         }
 419 }
 420
 421 void psi_context_free(struct psi_context **C)
 422 {
 423         if (*C) {
 424                 psi_context_dtor(*C);
 425                 free(*C);
 426                 *C = NULL;
 427         }
 428 }
 429
 430 bool psi_context_add_data(struct psi_context *C, struct psi_data *P)
 431 {
 432         struct psi_data *D;
 433
 434         C->data = realloc(C->data, (C->count + 1) * sizeof(*C->data));
 435         D = psi_data_exchange(&C->data[C->count++], P);
 436
 437         return psi_data_validate(PSI_DATA(C), D);
 438 }
 439
 440 void psi_context_dump(struct psi_context *C, int fd)
 441 {
 442
 443         dprintf(fd, "// psi.engine=%s\n",
 444                         (char *) C->ops->query(C, PSI_CONTEXT_QUERY_SELF, NULL));
 445
 446         psi_data_dump(fd, PSI_DATA(C));
 447
 448 //      size_t i;
 449 //      dprintf(fd, "/* parsed\n");
 450 //      for (i = 0; i < C->count; ++i) {
 451 //              psi_data_dump(fd, &C->data[i]);
 452 //      }
 453 //      dprintf(fd, "*/\n");
 454
 455 }