projects / m6w6 / ext-psi / blob
? search:


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