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


ba587201926ffafc0286fce4b8c76d1dc8fdf491
[m6w6/ext-psi] / 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
109 #include "libjit.h"
110 #include "libffi.h"
111
112 static struct psi_std_type {
113 token_t type_tag;
114 const char *type_name;
115 } psi_std_types[] = {
116 {PSI_T_FLOAT, "float"},
117 {PSI_T_DOUBLE, "double"},
118 {PSI_T_INT8, "int8_t"},
119 {PSI_T_INT16, "int16_t"},
120 {PSI_T_INT32, "int32_t"},
121 {PSI_T_INT64, "int64_t"},
122 {PSI_T_UINT8, "uint8_t"},
123 {PSI_T_UINT16, "uint16_t"},
124 {PSI_T_UINT32, "uint32_t"},
125 {PSI_T_UINT64, "uint64_t"},
126 {0}
127 };
128
129 static struct psi_predef_type {
130 token_t type_tag;
131 const char *type_name;
132 const char *alias;
133 } psi_predef_types[] = {
134 PSI_TYPES
135 {0}
136 };
137
138 static struct psi_predef_const {
139 token_t type_tag;
140 const char *type_name;
141 const char *var_name;
142 const char *val_text;
143 token_t val_type_tag;
144 } psi_predef_consts[] = {
145 PSI_CONSTS
146 {0}
147 };
148
149 PSI_MACROS
150
151 int psi_glob(const char *pattern, int flags,
152 int (*errfunc) (const char *epath, int eerrno),
153 glob_t *pglob) {
154 size_t offs = flags & GLOB_DOOFFS ? pglob->gl_offs : 0;
155 int rv = glob(pattern, flags, errfunc, pglob);
156 if (pglob->gl_pathv) {
157 while (offs--) {
158 pglob->gl_pathv[offs] = NULL;
159 }
160 }
161 return rv;
162 }
163
164 static struct psi_func_redir {
165 const char *name;
166 void (*func)(void);
167 } psi_func_redirs[] = {
168 {"glob", (void (*)(void)) psi_glob},
169 PSI_REDIRS
170 {0}
171 };
172
173 static struct psi_predef_decl {
174 token_t type_tag;
175 const char *type_name;
176 const char *var_name;
177 size_t pointer_level;
178 size_t array_size;
179 } psi_predef_decls[] = {
180 PSI_DECLS
181 {0}
182 };
183
184 static struct psi_predef_struct {
185 token_t type_tag;
186 const char *type_name;
187 const char *var_name;
188 size_t offset;
189 size_t size;
190 size_t pointer_level;
191 size_t array_size;
192 } psi_predef_structs[] = {
193 PSI_STRUCTS
194 {0}
195 };
196
197 static int validate_lib(PSI_Data *data, void **dlopened) {
198 char lib[MAXPATHLEN];
199 const char *ptr = data->psi.file.ln;
200 size_t len;
201
202 if (!ptr) {
203 /* FIXME: assume stdlib */
204 return 1;
205 } else if (!strchr(ptr, '/')) {
206 len = snprintf(lib, MAXPATHLEN, "lib%s.%s", ptr, PHP_PSI_SHLIB_SUFFIX);
207 if (MAXPATHLEN == len) {
208 data->error(PSI_WARNING, "Library name too long: '%s'", ptr);
209 }
210 lib[len] = 0;
211 ptr = lib;
212 }
213 if (!(*dlopened = dlopen(ptr, RTLD_LAZY|RTLD_LOCAL))) {
214 data->error(PSI_WARNING, "Could not open library '%s': %s.",
215 data->psi.file.ln, dlerror());
216 return 0;
217 }
218 return 1;
219 }
220
221 static inline int locate_decl_type_alias(decl_typedefs *defs, decl_type *type) {
222 size_t i;
223 struct psi_std_type *stdtyp;
224
225 if (type->real) {
226 return 1;
227 }
228 for (i = 0; i < defs->count; ++i) {
229 decl_typedef *def = defs->list[i];
230
231 if (def->type->type != type->type && !strcmp(def->alias, type->name)) {
232 type->real = def->type;
233 return 1;
234 }
235 }
236 for (stdtyp = &psi_std_types[0]; stdtyp->type_tag; ++stdtyp) {
237 if (!strcmp(type->name, stdtyp->type_name)) {
238 type->type = stdtyp->type_tag;
239 return 1;
240 }
241 }
242
243 return 0;
244 }
245 static inline int locate_decl_type_struct(decl_structs *structs, decl_type *type) {
246 size_t i;
247
248 if (type->strct) {
249 return 1;
250 }
251 for (i = 0; i < structs->count; ++i) {
252 if (!strcmp(structs->list[i]->name, type->name)) {
253 type->strct = structs->list[i];
254 return 1;
255 }
256 }
257 return 0;
258 }
259
260 static inline int validate_decl_type(PSI_Data *data, decl_type *type) {
261 switch (type->type) {
262 case PSI_T_NAME:
263 if (!data->defs || !locate_decl_type_alias(data->defs, type)) {
264 return 0;
265 }
266 if (type->real) {
267 return validate_decl_type(data, type->real);
268 }
269 return 1;
270 case PSI_T_STRUCT:
271 if (!data->structs || !locate_decl_type_struct(data->structs, type)) {
272 return 0;
273 }
274 break;
275 }
276 return 1;
277 }
278 static inline int validate_decl_typedef(PSI_Data *data, decl_typedef *def) {
279 if (!validate_decl_type(data, def->type)) {
280 data->error(PSI_WARNING, "Type '%s' cannot be aliased to %s'%s'",
281 def->type->name, def->type->type == PSI_T_STRUCT?"struct ":"",def->alias);
282 return 0;
283 }
284 /* FIXME: check def->alias */
285 return 1;
286 }
287
288 static inline int validate_constant(PSI_Data *data, constant *c) {
289 /* FIXME */
290 return 1;
291 }
292
293 static inline int validate_decl_arg(PSI_Data *data, decl_arg *arg) {
294 if (!validate_decl_type(data, arg->type)) {
295 data->error(PSI_WARNING, "Cannot use '%s'(%d) as type for decl var '%s'"
296 " in %s on line %zu at col %zu",
297 arg->type->name, arg->type->type, arg->var->name,
298 arg->type->token->file, arg->type->token->line, arg->type->token->col);
299 return 0;
300 }
301 return 1;
302 }
303
304 static inline int validate_decl_struct(PSI_Data *data, decl_struct *s) {
305 size_t i;
306
307 for (i = 0; i < s->args->count; ++i) {
308 if (!validate_decl_arg(data, s->args->args[i])) {
309 return 0;
310 }
311 }
312
313 for (i = 0; i < s->args->count; ++i) {
314 decl_arg *darg = s->args->args[i];
315
316 if (!validate_decl_arg(data, darg)) {
317 return 0;
318 }
319
320 ZEND_ASSERT(!darg->var->arg || darg->var->arg == darg);
321 darg->var->arg = darg;
322
323 if (!darg->layout) {
324 token_t t;
325
326 if (darg->var->pointer_level && (!darg->var->array_size || darg->var->pointer_level == 1)) {
327 t = PSI_T_POINTER;
328 } else {
329 t = real_decl_type(darg->type)->type;
330 }
331
332 if (i) {
333 decl_arg *last = s->args->args[i-1];
334 darg->layout = init_decl_struct_layout(
335 psi_t_align(t, last->layout->pos + last->layout->len),
336 psi_t_size(t) * darg->var->array_size);
337 } else {
338 darg->layout = init_decl_struct_layout(0, psi_t_size(t));
339 }
340 }
341 if (s->size < darg->layout->pos + darg->layout->len) {
342 s->size = darg->layout->pos + darg->layout->len;
343 }
344 }
345 return 1;
346 }
347
348 static const char * const abi_ccs[] = {
349 "default", /* \ */
350 "extern", /* > - all the same */
351 "cdecl", /* / */
352 "stdcall",
353 "fastcall",
354 };
355 static inline int validate_decl_abi(PSI_Data *data, decl_abi *abi) {
356 size_t i;
357
358 for (i = 0; i < sizeof(abi_ccs)/sizeof(char*); ++i) {
359 if (strcasecmp(abi->convention, abi_ccs[i])) {
360 return 1;
361 }
362 }
363 data->error(PSI_WARNING, "Invalid calling convention: '%s'", abi->convention);
364 return 0;
365 }
366 static inline int validate_decl_func(PSI_Data *data, void *dl, decl *decl, decl_arg *func)
367 {
368 struct psi_func_redir *redir;
369
370 if (!strcmp(func->var->name, "dlsym")) {
371 data->error(PSI_WARNING, "Cannot dlsym dlsym (sic!)");
372 return 0;
373 }
374
375 if (!validate_decl_arg(data, func)) {
376 return 0;
377 }
378 for (redir = &psi_func_redirs[0]; redir->name; ++redir) {
379 if (!strcmp(func->var->name, redir->name)) {
380 decl->call.sym = redir->func;
381 }
382 }
383 if (!decl->call.sym) {
384 #ifndef RTLD_NEXT
385 # define RTLD_NEXT ((void *) -1l)
386 #endif
387 decl->call.sym = dlsym(dl ?: RTLD_NEXT, func->var->name);
388 if (!decl->call.sym) {
389 data->error(PSI_WARNING, "Failed to locate symbol '%s': %s",
390 func->var->name, dlerror());
391 }
392 }
393 return 1;
394 }
395
396 static inline int validate_decl(PSI_Data *data, void *dl, decl *decl) {
397 if (!validate_decl_abi(data, decl->abi)) {
398 return 0;
399 }
400 if (!validate_decl_func(data, dl, decl, decl->func)) {
401 return 0;
402 }
403 if (decl->args) {
404 size_t i;
405
406 for (i = 0; i < decl->args->count; ++i) {
407 if (!validate_decl_arg(data, decl->args->args[i])) {
408 return 0;
409 }
410 }
411 }
412 return 1;
413 }
414 static inline decl_arg *locate_decl_var_arg(decl_var *var, decl_args *args, decl_arg *func) {
415 size_t i;
416
417 for (i = 0; i < args->count; ++i) {
418 decl_arg *arg = args->args[i];
419
420 if (!strcmp(var->name, arg->var->name)) {
421 ZEND_ASSERT(!var->arg || var->arg == arg);
422 return var->arg = arg;
423 }
424 }
425 if (func && !strcmp(var->name, func->var->name)) {
426 return var->arg = func;
427 }
428
429 return NULL;
430 }
431 static inline decl_arg *locate_struct_member(decl_struct *s, decl_var *var) {
432 if (s->args) {
433 return locate_decl_var_arg(var, s->args, NULL);
434 }
435
436 return NULL;
437 }
438 static inline constant *locate_num_exp_constant(num_exp *exp, constants *consts) {
439 size_t i;
440
441 for (i = 0; i < consts->count; ++i) {
442 constant *cnst = consts->list[i];
443
444 if (!strcmp(cnst->name, exp->u.numb)) {
445 free(exp->u.numb);
446 return exp->u.cnst = cnst;
447 }
448 }
449
450 return NULL;
451 }
452 static inline int validate_num_exp(PSI_Data *data, decl_args *dargs, decl_arg *func, num_exp *exp) {
453 if (exp->operand) {
454 switch (exp->operator) {
455 case PSI_T_PLUS:
456 exp->calculator = psi_calc_add;
457 break;
458 case PSI_T_MINUS:
459 exp->calculator = psi_calc_sub;
460 break;
461 case PSI_T_ASTERISK:
462 exp->calculator = psi_calc_mul;
463 break;
464 case PSI_T_SLASH:
465 exp->calculator = psi_calc_div;
466 break;
467 EMPTY_SWITCH_DEFAULT_CASE();
468 }
469 if (!validate_num_exp(data, dargs, func, exp->operand)) {
470 return 0;
471 }
472 }
473 switch (exp->t) {
474 case PSI_T_NAME:
475 if (!locate_decl_var_arg(exp->u.dvar, dargs, func)) {
476 data->error(PSI_WARNING, "Unknown variable '%s' in numeric expression",
477 exp->u.dvar->name);
478 return 0;
479 }
480 return 1;
481 case PSI_T_NSNAME:
482 if (!locate_num_exp_constant(exp, data->consts)) {
483 data->error(PSI_WARNING, "Unknown constant '%s' in numeric expression",
484 exp->u.numb);
485 return 0;
486 }
487 return 1;
488 case PSI_T_NUMBER:
489 return 1;
490 default:
491 return 0;
492 }
493 }
494 static inline int validate_set_value_handler(set_value *set) {
495 switch (set->func->type) {
496 case PSI_T_TO_BOOL:
497 set->func->handler = psi_to_bool;
498 break;
499 case PSI_T_TO_INT:
500 set->func->handler = psi_to_int;
501 break;
502 case PSI_T_TO_FLOAT:
503 set->func->handler = psi_to_double;
504 break;
505 case PSI_T_TO_STRING:
506 set->func->handler = psi_to_string;
507 break;
508 case PSI_T_TO_ARRAY:
509 set->func->handler = psi_to_array;
510 break;
511 case PSI_T_TO_OBJECT:
512 set->func->handler = psi_to_object;
513 break;
514 case PSI_T_VOID:
515 set->func->handler = psi_to_void;
516 break;
517 default:
518 return 0;
519 }
520 return 1;
521 }
522 static inline void decl_var_arg_v(decl_args *args, va_list argp) {
523 int argc;
524 decl_arg **argv;
525
526 memset(args, 0, sizeof(*args));
527
528 while ((argc = va_arg(argp, int))) {
529 argv = va_arg(argp, decl_arg **);
530 while (argc--) {
531 add_decl_arg(args, *argv++);
532 }
533 }
534 }
535 static inline int validate_set_value_ex(PSI_Data *data, set_value *set, decl_arg *ref, decl_args *ref_list) {
536 size_t i;
537 decl_type *ref_type;
538 decl_var *set_var = set->vars->vars[0];
539
540 if (!validate_set_value_handler(set)) {
541 data->error(PSI_WARNING, "Invalid cast '%s'", set->func->name);
542 return 0;
543 }
544
545 for (i = 0; i < set->vars->count; ++i) {
546 decl_var *svar = set->vars->vars[i];
547 if (!svar->arg && !locate_decl_var_arg(svar, ref_list, NULL)) {
548 data->error(PSI_WARNING, "Unknown variable '%s'", svar->name);
549 return 0;
550 }
551 }
552
553 if (!ref) {
554 ref = set_var->arg;
555 }
556 ref_type = real_decl_type(ref->type);
557
558 if (set->count) {
559 int is_to_array = (set->func->type == PSI_T_TO_ARRAY);
560 int is_pointer_to_struct = (ref_type->type == PSI_T_STRUCT && ref->var->pointer_level);
561
562 if (!is_to_array && !is_pointer_to_struct) {
563 data->error(E_WARNING, "Inner `set` statement casts only work with "
564 "to_array() casts on structs or pointers: %s(%s...", set->func->name, set->vars->vars[0]->name);
565 return 0;
566 }
567 }
568 if (set->num) {
569 if (!validate_num_exp(data, ref_list, ref, set->num)) {
570 return 0;
571 }
572 }
573
574 if (ref_type->type == PSI_T_STRUCT) {
575 /* to_array(struct, to_...) */
576 for (i = 0; i < set->count; ++i) {
577 decl_var *sub_var = set->inner[i]->vars->vars[0];
578 decl_arg *sub_ref = locate_struct_member(ref_type->strct, sub_var);
579
580 set->inner[i]->outer.set = set;
581 if (sub_ref) {
582 if (!validate_set_value_ex(data, set->inner[i], sub_ref, ref_type->strct->args)) {
583 return 0;
584 }
585 }
586 }
587 } else if (set->count == 1) {
588 /* to_array(ptr, to_string(*ptr)) */
589 decl_var *sub_var = set->inner[0]->vars->vars[0];
590 decl_arg *sub_ref = locate_decl_var_arg(sub_var, ref_list, ref);
591
592 set->inner[0]->outer.set = set;
593 if (sub_ref) {
594 if (strcmp(sub_var->name, set_var->name)) {
595 data->error(E_WARNING, "Inner `set` statement casts on pointers must reference the same variable");
596 return 0;
597 }
598 if (!validate_set_value_ex(data, set->inner[0], sub_ref, ref_list)) {
599 return 0;
600 }
601 }
602 } else if (set->count > 1) {
603 data->error(E_WARNING, "Inner `set` statement casts on pointers may only occur once");
604 return 0;
605 }
606
607 return 1;
608 }
609 static inline int validate_set_value(PSI_Data *data, set_value *set, ...) {
610 va_list argp;
611 decl_args args = {0};
612 int check;
613
614 va_start(argp, set);
615 decl_var_arg_v(&args, argp);
616 va_end(argp);
617
618 check = validate_set_value_ex(data, set, NULL, &args);
619 if (args.args) {
620 free(args.args);
621 }
622 return check;
623 }
624 static inline decl *locate_impl_decl(decls *decls, return_stmt *ret) {
625 if (decls) {
626 size_t i;
627
628 for (i = 0; i < decls->count; ++i) {
629 if (!strcmp(decls->list[i]->func->var->name, ret->set->vars->vars[0]->name)) {
630 ret->decl = decls->list[i]->func;
631 return decls->list[i];
632 }
633 }
634 }
635
636 return NULL;
637 }
638 static inline int validate_impl_ret_stmt(PSI_Data *data, impl *impl) {
639 return_stmt *ret;
640
641 /* we must have exactly one ret stmt delcaring the native func to call */
642 /* and which type cast to apply */
643 if (impl->stmts->ret.count != 1) {
644 if (impl->stmts->ret.count > 1) {
645 data->error(PSI_WARNING, "Too many `return` statements for implmentation %s;"
646 " found %zu, exactly one is needed",
647 impl->func->name, impl->stmts->ret.count);
648 } else {
649 data->error(PSI_WARNING, "Missing `return` statement for implementation %s",
650 impl->func->name);
651 }
652 return 0;
653 }
654
655 ret = impl->stmts->ret.list[0];
656
657 if (!(impl->decl = locate_impl_decl(data->decls, ret))) {
658 data->error(PSI_WARNING, "Missing declaration for implementation %s",
659 impl->func->name);
660 return 0;
661 }
662
663 if (!validate_set_value(data, ret->set, 1, &ret->decl, impl->decl->args ? (int) impl->decl->args->count : 0, impl->decl->args ? impl->decl->args->args : NULL, 0)) {
664 return 0;
665 }
666
667 impl->decl->impl = impl;
668
669 return 1;
670 }
671
672 static inline int validate_impl_let_stmts(PSI_Data *data, impl *impl) {
673 size_t i, j;
674 /* we can have multiple let stmts */
675
676 /* check that we have a decl arg for every let stmt */
677 for (i = 0; i < impl->stmts->let.count; ++i) {
678 let_stmt *let = impl->stmts->let.list[i];
679 decl_var *let_var;
680 int check = 0;
681
682 if (let->val && let->val->kind == PSI_LET_TMP) {
683 let_var = let->val->data.var;
684 } else {
685 let_var = let->var;
686 }
687
688 if (!locate_decl_var_arg(let_var, impl->decl->args, impl->decl->func)) {
689 data->error(PSI_WARNING, "Unknown variable '%s' in `let` statement"
690 " of implementation '%s'", let_var->name, impl->func->name);
691 return 0;
692 }
693
694 switch (let->val->kind) {
695 case PSI_LET_NULL:
696 break;
697 case PSI_LET_TMP:
698 /* e.g. let bar = &strval($bar); // decl_arg(char **bar) */
699 /* e.g. let foo = *bar; */
700 let->var->pointer_level = let->val->data.var->pointer_level;
701 let->var->arg = init_decl_arg(
702 init_decl_type(
703 real_decl_type(let->val->data.var->arg->type)->type,
704 real_decl_type(let->val->data.var->arg->type)->name),
705 init_decl_var(
706 let->var->name,
707 let->var->pointer_level,
708 let->var->array_size));
709 break;
710 case PSI_LET_NUMEXP:
711 if (!validate_num_exp(data, impl->decl->args, impl->decl->func, let->val->data.num)) {
712 return 0;
713 }
714 break;
715 case PSI_LET_CALLOC:
716 if (!validate_num_exp(data, impl->decl->args, impl->decl->func, let->val->data.alloc->nmemb)) {
717 return 0;
718 }
719 if (!validate_num_exp(data, impl->decl->args, impl->decl->func, let->val->data.alloc->size)) {
720 return 0;
721 }
722 break;
723 case PSI_LET_FUNC:
724 if (impl->func->args) {
725 for (j = 0; j < impl->func->args->count; ++j) {
726 impl_arg *iarg = impl->func->args->args[j];
727
728 if (!strcmp(let->val->data.func->var->name, iarg->var->name)) {
729 let->val->data.func->arg = iarg;
730 check = 1;
731 break;
732 }
733 }
734 }
735 if (!check) {
736 data->error(PSI_WARNING, "Unknown value '$%s' of `let` statement"
737 " for variable '%s' of implementation '%s'",
738 let->val->data.func->var->name, let->var->name, impl->func->name);
739 return 0;
740 }
741 break;
742 }
743 }
744
745 /* check that we have a let stmt for every decl arg */
746 if (impl->decl->args) for (i = 0; i < impl->decl->args->count; ++i) {
747 decl_arg *darg = impl->decl->args->args[i];
748 int check = 0;
749
750 for (j = 0; j < impl->stmts->let.count; ++j) {
751 let_stmt *let = impl->stmts->let.list[j];
752
753 if (!strcmp(let->var->name, darg->var->name)) {
754 darg->let = let;
755 check = 1;
756 break;
757 }
758 }
759 if (!check) {
760 data->error(PSI_WARNING, "Missing `let` statement for arg '%s %.*s%s'"
761 " of declaration '%s' for implementation '%s'",
762 darg->type->name, (int) darg->var->pointer_level, "*****",
763 darg->var->name, impl->decl->func->var->name, impl->func->name);
764 return 0;
765 }
766 }
767
768 return 1;
769 }
770 static inline int validate_impl_set_stmts(PSI_Data *data, impl *impl) {
771 size_t i, j, k;
772 /* we can have any count of set stmts; processing out vars */
773 /* check that set stmts reference known variables */
774 for (i = 0; i < impl->stmts->set.count; ++i) {
775 set_stmt *set = impl->stmts->set.list[i];
776 int check = 0;
777
778 if (impl->func->args) for (j = 0; j < impl->func->args->count; ++j) {
779 impl_arg *iarg = impl->func->args->args[j];
780
781 if (!strcmp(set->var->name, iarg->var->name)) {
782 set->arg = iarg;
783 check = 1;
784 break;
785 }
786 }
787 if (!check) {
788 data->error(PSI_WARNING, "Unknown variable '$%s' of `set` statement"
789 " of implementation '%s'",
790 set->var->name, impl->func->name);
791 return 0;
792 }
793
794 for (j = 0; j < set->val->vars->count; ++j) {
795 decl_var *set_var = set->val->vars->vars[j];
796
797 check = 0;
798 if (impl->decl->args) {
799 for (k = 0; k < impl->decl->args->count; ++k) {
800 decl_arg *set_arg = impl->decl->args->args[k];
801
802 if (!strcmp(set_var->name, set_arg->var->name)) {
803 check = 1;
804 set_var->arg = set_arg;
805 if (!validate_set_value(data, set->val, 1, &set_arg, 1, &impl->decl->func, impl->decl->args->count, impl->decl->args->args, 0)) {
806 return 0;
807 }
808 break;
809 }
810 }
811 }
812 if (!check) {
813 for (k = 0; k < impl->stmts->let.count; ++k) {
814 let_stmt *let = impl->stmts->let.list[k];
815
816 /* check temp vars */
817 if (let->val && let->val->kind == PSI_LET_TMP) {
818 if (!strcmp(set_var->name, let->var->name)) {
819 check = 1;
820 set_var->arg = let->var->arg;
821 if (!validate_set_value(data, set->val, 1, &set_var->arg, 1, &impl->decl->func, impl->decl->args->count, impl->decl->args->args, 0)) {
822 return 0;
823 }
824 break;
825 }
826 }
827 }
828 }
829
830 if (!check) {
831 data->error(PSI_WARNING, "Unknown value '%s' of `set` statement"
832 " for variable '$%s' of implementation '%s'",
833 set_var->name, set->arg->var->name, impl->func->name);
834 return 0;
835 }
836 }
837 }
838 return 1;
839 }
840 static inline decl *locate_free_decl(decls *decls, free_call *f) {
841 if (decls) {
842 size_t i;
843
844 for (i = 0; i < decls->count; ++i) {
845 if (!strcmp(decls->list[i]->func->var->name, f->func)) {
846 f->decl = decls->list[i];
847 return decls->list[i];
848 }
849 }
850 }
851
852 return NULL;
853 }
854 static inline int validate_impl_free_stmts(PSI_Data *data, impl *impl) {
855 size_t i, j, k, l;
856 /* we can have any count of free stmts; freeing any out vars */
857 for (i = 0; i < impl->stmts->fre.count; ++i) {
858 free_stmt *fre = impl->stmts->fre.list[i];
859
860 for (j = 0; j < fre->calls->count; ++j) {
861 free_call *free_call = fre->calls->list[j];
862
863 /* first find the decl of the free func */
864 if (!locate_free_decl(data->decls, free_call)) {
865 data->error(PSI_WARNING, "Unknown function '%s' in `free` statement"
866 " of implementation '%s'", free_call->func, impl->func->name);
867 return 0;
868 }
869 if (!impl->decl->args) {
870 data->error(PSI_WARNING, "Declaration '%s' of implementation '%s'"
871 " does not have any arguments to free",
872 impl->decl->func->var->name, impl->func->name);
873 }
874
875 /* now check for known vars */
876 for (l = 0; l < free_call->vars->count; ++l) {
877 int check = 0;
878 decl_var *free_var = free_call->vars->vars[l];
879
880 for (k = 0; k < impl->decl->args->count; ++k) {
881 decl_arg *free_arg = impl->decl->args->args[k];
882
883 if (!strcmp(free_var->name, free_arg->var->name)) {
884 check = 1;
885 free_var->arg = free_arg;
886 break;
887 }
888 }
889
890 if (!check) {
891 data->error(PSI_WARNING, "Unknown variable '%s' of `free` statement"
892 " of implementation '%s'",
893 free_var->name, impl->func->name);
894 return 0;
895 }
896 }
897 }
898 }
899 return 1;
900 }
901 static inline int validate_impl_stmts(PSI_Data *data, impl *impl) {
902 if (!impl->stmts) {
903 data->error(PSI_WARNING, "Missing body for implementation %s!",
904 impl->func->name);
905 return 0;
906 }
907
908 if (!validate_impl_ret_stmt(data, impl)) {
909 return 0;
910 }
911
912 if (!validate_impl_let_stmts(data, impl)) {
913 return 0;
914 }
915 if (!validate_impl_set_stmts(data, impl)) {
916 return 0;
917 }
918 if (!validate_impl_free_stmts(data, impl)) {
919 return 0;
920 }
921
922 return 1;
923 }
924
925 PSI_Context *PSI_ContextInit(PSI_Context *C, PSI_ContextOps *ops, PSI_ContextErrorFunc error)
926 {
927 size_t i;
928 PSI_Data T;
929 struct psi_predef_type *predef_type;
930 struct psi_predef_const *predef_const;
931 struct psi_predef_struct *predef_struct;
932 struct psi_predef_decl *predef_decl;
933
934 if (!C) {
935 C = malloc(sizeof(*C));
936 }
937 memset(C, 0, sizeof(*C));
938
939 C->error = error;
940 C->ops = ops;
941
942 if (ops->init) {
943 ops->init(C);
944 }
945
946 ZEND_ASSERT(ops->call != NULL);
947 ZEND_ASSERT(ops->compile != NULL);
948
949 /* build up predefs in a temporary PSI_Data for validation */
950 memset(&T, 0, sizeof(T));
951 T.error = error;
952
953 for (predef_type = &psi_predef_types[0]; predef_type->type_tag; ++predef_type) {
954 decl_type *type = init_decl_type(predef_type->type_tag, predef_type->type_name);
955 decl_typedef *def = init_decl_typedef(predef_type->alias, type);
956
957 T.defs = add_decl_typedef(T.defs, def);
958 }
959 for (predef_const = &psi_predef_consts[0]; predef_const->type_tag; ++predef_const) {
960 impl_def_val *val = init_impl_def_val(predef_const->val_type_tag, predef_const->val_text);
961 const_type *type = init_const_type(predef_const->type_tag, predef_const->type_name);
962 constant *constant = init_constant(type, predef_const->var_name, val);
963
964 T.consts = add_constant(T.consts, constant);
965 }
966 for (predef_struct = &psi_predef_structs[0]; predef_struct->type_tag; ++predef_struct) {
967 struct psi_predef_struct *member;
968 decl_args *dargs = init_decl_args(NULL);
969 decl_struct *dstruct = init_decl_struct(predef_struct->var_name, dargs);
970
971 dstruct->size = predef_struct->size;
972 for (member = &predef_struct[1]; member->type_tag; ++member) {
973 decl_type *type;
974 decl_var *dvar;
975 decl_arg *darg;
976
977 type = init_decl_type(member->type_tag, member->type_name);
978 dvar = init_decl_var(member->var_name, member->pointer_level, member->array_size);
979 darg = init_decl_arg(type, dvar);
980 darg->layout = init_decl_struct_layout(member->offset, member->size);
981 dargs = add_decl_arg(dargs, darg);
982 }
983
984 T.structs = add_decl_struct(T.structs, dstruct);
985 predef_struct = member;
986 }
987 for (predef_decl = &psi_predef_decls[0]; predef_decl->type_tag; ++predef_decl) {
988 struct psi_predef_decl *farg;
989 decl_type *ftype = init_decl_type(predef_decl->type_tag, predef_decl->type_name);
990 decl_var *fname = init_decl_var(predef_decl->var_name, predef_decl->pointer_level, predef_decl->array_size);
991 decl_arg *func = init_decl_arg(ftype, fname);
992 decl_args *args = init_decl_args(NULL);
993 decl *decl = init_decl(init_decl_abi("default"), func, args);
994
995
996 for (farg = &predef_decl[1]; farg->type_tag; ++farg) {
997 decl_type *arg_type = init_decl_type(farg->type_tag, farg->type_name);
998 decl_var *arg_var = init_decl_var(farg->var_name, farg->pointer_level, farg->array_size);
999 decl_arg *darg = init_decl_arg(arg_type, arg_var);
1000 args = add_decl_arg(args, darg);
1001 }
1002
1003 T.decls = add_decl(T.decls, decl);
1004 predef_decl = farg;
1005 }
1006
1007 for (i = 0; i < T.defs->count; ++i) {
1008 decl_typedef *def = T.defs->list[i];
1009
1010 if (validate_decl_typedef(&T, def)) {
1011 C->defs = add_decl_typedef(C->defs, def);
1012 }
1013 }
1014
1015 for (i = 0; i < T.consts->count; ++i) {
1016 constant *constant = T.consts->list[i];
1017
1018 if (validate_constant(&T, constant)) {
1019 C->consts = add_constant(C->consts, constant);
1020 }
1021 }
1022
1023 for (i = 0; i < T.structs->count; ++i) {
1024 decl_struct *dstruct = T.structs->list[i];
1025
1026 if (validate_decl_struct(&T, dstruct)) {
1027 C->structs = add_decl_struct(C->structs, dstruct);
1028 }
1029 }
1030
1031 for (i = 0; i < T.decls->count; ++i) {
1032 decl *decl = T.decls->list[i];
1033
1034 if (validate_decl(&T, NULL, decl)) {
1035 C->decls = add_decl(C->decls, decl);
1036 }
1037 }
1038
1039 C->count = 1;
1040 C->data = malloc(sizeof(*C->data));
1041 PSI_DataExchange(C->data, &T);
1042
1043 return C;
1044 }
1045
1046 int PSI_ContextValidate(PSI_Context *C, PSI_Parser *P)
1047 {
1048 PSI_Data *D;
1049 void *dlopened = NULL;
1050 size_t count = C->count++;
1051
1052 C->data = realloc(C->data, C->count * sizeof(*C->data));
1053 D = PSI_DataExchange(&C->data[count], PSI_DATA(P));
1054
1055 if (D->defs) {
1056 size_t i;
1057
1058 for (i = 0; i < D->defs->count; ++i) {
1059 if (validate_decl_typedef(PSI_DATA(C), D->defs->list[i])) {
1060 C->defs = add_decl_typedef(C->defs, D->defs->list[i]);
1061 }
1062 }
1063 }
1064 if (D->structs) {
1065 size_t i;
1066
1067 for (i = 0; i < D->structs->count; ++i) {
1068 if (validate_decl_struct(PSI_DATA(C), D->structs->list[i])) {
1069 C->structs = add_decl_struct(C->structs, D->structs->list[i]);
1070 }
1071 }
1072 }
1073 if (D->consts) {
1074 size_t i;
1075
1076 for (i = 0; i < D->consts->count; ++i) {
1077 if (validate_constant(PSI_DATA(C), D->consts->list[i])) {
1078 C->consts = add_constant(C->consts, D->consts->list[i]);
1079 }
1080 }
1081 }
1082
1083 if (!validate_lib(D, &dlopened)) {
1084 return 0;
1085 }
1086
1087 add_decl_lib(&C->psi.libs, dlopened);
1088
1089 if (D->decls) {
1090 size_t i;
1091
1092 for (i = 0; i < D->decls->count; ++i) {
1093 if (validate_decl(PSI_DATA(C), dlopened, D->decls->list[i])) {
1094 C->decls = add_decl(C->decls, D->decls->list[i]);
1095 }
1096 }
1097 }
1098 if (D->impls) {
1099 size_t i;
1100
1101 for (i = 0; i < D->impls->count; ++i) {
1102 if (validate_impl_stmts(PSI_DATA(C), D->impls->list[i])) {
1103 C->impls = add_impl(C->impls, D->impls->list[i]);
1104 }
1105 }
1106 }
1107
1108 return 1;
1109 }
1110
1111 static int psi_select_dirent(const struct dirent *entry)
1112 {
1113 #ifndef FNM_CASEFOLD
1114 #define FNM_CASEFOLD 0
1115 #endif
1116 return 0 == fnmatch("*.psi", entry->d_name, FNM_CASEFOLD);
1117 }
1118
1119 void PSI_ContextBuild(PSI_Context *C, const char *paths)
1120 {
1121 int i, n, flags = psi_check_env("PSI_DEBUG") ? PSI_PARSER_DEBUG : 0;
1122 char *sep = NULL, *cpy = strdup(paths), *ptr = cpy;
1123 struct dirent **entries = NULL;
1124
1125
1126 do {
1127 sep = strchr(ptr, ':');
1128
1129 if (sep) {
1130 *sep = 0;
1131 }
1132
1133 n = php_scandir(ptr, &entries, psi_select_dirent, alphasort);
1134
1135 if (n > 0) {
1136 for (i = 0; i < n; ++i) {
1137 char psi[MAXPATHLEN];
1138 PSI_Parser P;
1139
1140 if (MAXPATHLEN <= slprintf(psi, MAXPATHLEN, "%s/%s", ptr, entries[i]->d_name)) {
1141 C->error(PSI_WARNING, "Path to PSI file too long: %s/%s",
1142 ptr, entries[i]->d_name);
1143 }
1144 if (!PSI_ParserInit(&P, psi, C->error, flags)) {
1145 C->error(PSI_WARNING, "Failed to init PSI parser (%s): %s",
1146 psi, strerror(errno));
1147 continue;
1148 }
1149
1150 while (0 < PSI_ParserScan(&P)) {
1151 PSI_ParserParse(&P, PSI_TokenAlloc(&P));
1152 if (P.num == PSI_T_EOF) {
1153 break;
1154 }
1155 }
1156
1157 PSI_ParserParse(&P, NULL);
1158 PSI_ContextValidate(C, &P);
1159 PSI_ParserDtor(&P);
1160 }
1161 }
1162
1163 if (entries) {
1164 for (i = 0; i < n; ++i) {
1165 free(entries[i]);
1166 }
1167 free(entries);
1168 }
1169
1170 ptr = sep + 1;
1171 } while (sep);
1172
1173
1174 if (PSI_ContextCompile(C) && SUCCESS != zend_register_functions(NULL, C->closures, NULL, MODULE_PERSISTENT)) {
1175 C->error(PSI_WARNING, "Failed to register functions!");
1176 }
1177
1178 free(cpy);
1179
1180 }
1181
1182 zend_function_entry *PSI_ContextCompile(PSI_Context *C)
1183 {
1184 size_t i;
1185
1186 if (C->consts) {
1187 zend_constant zc;
1188
1189 zc.flags = CONST_PERSISTENT|CONST_CS;
1190 zc.module_number = EG(current_module)->module_number;
1191
1192 for (i = 0; i < C->consts->count; ++i) {
1193 constant *c = C->consts->list[i];
1194
1195 zc.name = zend_string_init(c->name + (c->name[0] == '\\'), strlen(c->name) - (c->name[0] == '\\'), 1);
1196 ZVAL_NEW_STR(&zc.value, zend_string_init(c->val->text, strlen(c->val->text), 1));
1197
1198 switch (c->type->type) {
1199 case PSI_T_BOOL:
1200 convert_to_boolean(&zc.value);
1201 break;
1202 case PSI_T_INT:
1203 convert_to_long(&zc.value);
1204 break;
1205 case PSI_T_FLOAT:
1206 convert_to_double(&zc.value);
1207 break;
1208 }
1209 zend_register_constant(&zc);
1210 }
1211 }
1212
1213 return C->closures = C->ops->compile(C);
1214 }
1215
1216
1217 void PSI_ContextCall(PSI_Context *C, decl_callinfo *decl_call)
1218 {
1219 C->ops->call(C, decl_call);
1220 }
1221
1222 static inline void dump_decl_type(int fd, decl_type *t) {
1223 const char *pre;
1224
1225 switch (t->type) {
1226 case PSI_T_STRUCT:
1227 pre = "struct ";
1228 break;
1229 default:
1230 pre = "";
1231 }
1232 dprintf(fd, "%s%s", pre, t->name);
1233 }
1234 static inline void dump_decl_var(int fd, decl_var *v) {
1235 dprintf(fd, "%.*s%s", v->pointer_level-!!v->array_size, "**********", v->name);
1236 if (v->array_size) {
1237 dprintf(fd, "[%u]", v->array_size);
1238 }
1239 }
1240 static inline void dump_decl_arg(int fd, decl_arg *a) {
1241 dump_decl_type(fd, a->type);
1242 dprintf(fd, " ");
1243 dump_decl_var(fd, a->var);
1244 }
1245 static inline void dump_level(int fd, unsigned level) {
1246 dprintf(fd, "%.*s", level, "\t\t\t\t\t\t\t\t\t");
1247 }
1248 static inline void dump_num_exp(int fd, num_exp *exp) {
1249 while (exp) {
1250 switch (exp->t) {
1251 case PSI_T_NUMBER:
1252 dprintf(fd, "%s", exp->u.numb);
1253 break;
1254 case PSI_T_NSNAME:
1255 dprintf(fd, "%s", exp->u.cnst->name);
1256 break;
1257 case PSI_T_NAME:
1258 dump_decl_var(fd, exp->u.dvar);
1259 break;
1260 EMPTY_SWITCH_DEFAULT_CASE();
1261 }
1262 if (exp->operand) {
1263 char op;
1264
1265 switch (exp->operator) {
1266 case PSI_T_PLUS: op = '+'; break;
1267 case PSI_T_MINUS: op = '-'; break;
1268 case PSI_T_ASTERISK:op = '*'; break;
1269 case PSI_T_SLASH: op = '/'; break;
1270 EMPTY_SWITCH_DEFAULT_CASE();
1271 }
1272 dprintf(fd, " %c ", op);
1273 }
1274 exp = exp->operand;
1275 }
1276 }
1277 static inline void dump_impl_set_value(int fd, set_value *set, unsigned level) {
1278 size_t i;
1279
1280 if (level > 1) {
1281 /* only if not directly after `set ...` */
1282 dump_level(fd, level);
1283 }
1284 dprintf(fd, "%s(", set->func->name);
1285
1286 for (i = 0; i < set->vars->count; ++i) {
1287 decl_var *svar = set->vars->vars[i];
1288 if (i) {
1289 dprintf(fd, ", ");
1290 }
1291 dump_decl_var(fd, svar);
1292 }
1293 if (set->num) {
1294 dprintf(fd, ", ");
1295 dump_num_exp(fd, set->num);
1296 }
1297 if (set->inner) {
1298 dprintf(fd, ",\n");
1299 for (i = 0; i < set->count; ++i) {
1300 dump_impl_set_value(fd, set->inner[i], level+1);
1301 }
1302 /* only if inner stmts, i.e. with new lines, were dumped */
1303 dump_level(fd, level);
1304 }
1305 if (level > 1) {
1306 dprintf(fd, "),\n");
1307 } else {
1308 dprintf(fd, ");\n");
1309 }
1310 }
1311 void PSI_ContextDump(PSI_Context *C, int fd)
1312 {
1313 size_t i, j, k, l;
1314
1315 #ifdef HAVE_LIBJIT
1316 if (C->ops == PSI_Libjit()) {
1317 dprintf(fd, "// psi.engine=jit\n");
1318 }
1319 #endif
1320 #ifdef HAVE_LIBFFI
1321 if (C->ops == PSI_Libffi()) {
1322 dprintf(fd, "// psi.engine=ffi\n");
1323 }
1324 #endif
1325 dprintf(fd, "\n");
1326
1327 if (C->defs) {
1328 for (i = 0; i < C->defs->count; ++i) {
1329 decl_typedef *tdef = C->defs->list[i];
1330
1331 dprintf(fd, "typedef ");
1332 dump_decl_type(fd, tdef->type);
1333 dprintf(fd, " %s;\n", tdef->alias);
1334 }
1335 dprintf(fd, "\n");
1336 }
1337
1338 if (C->structs) {
1339 for (i = 0; i < C->structs->count; ++i) {
1340 decl_struct *strct = C->structs->list[i];
1341
1342 dprintf(fd, "struct %s::(%zu) {\n", strct->name, strct->size);
1343 if (strct->args) for (j = 0; j < strct->args->count; ++j) {
1344 decl_arg *sarg = strct->args->args[j];
1345
1346 dprintf(fd, "\t");
1347 dump_decl_arg(fd, sarg);
1348 dprintf(fd, "::(%zu, %zu);\n", sarg->layout->pos, sarg->layout->len);
1349 }
1350 dprintf(fd, "}\n");
1351 }
1352 dprintf(fd, "\n");
1353 }
1354 if (C->consts) {
1355 for (i = 0; i < C->consts->count; ++i) {
1356 constant *cnst = C->consts->list[i];
1357
1358 dprintf(fd, "const %s %s = ", cnst->type->name, cnst->name);
1359 if (cnst->val->type == PSI_T_QUOTED_STRING) {
1360 dprintf(fd, "\"%s\";\n", cnst->val->text);
1361 } else {
1362 dprintf(fd, "%s;\n", cnst->val->text);
1363 }
1364 }
1365 dprintf(fd, "\n");
1366 }
1367 if (C->decls) {
1368 for (i = 0; i < C->decls->count; ++i) {
1369 decl *decl = C->decls->list[i];
1370
1371 dprintf(fd, "%s ", decl->abi->convention);
1372 dump_decl_arg(fd, decl->func);
1373 dprintf(fd, "(");
1374 if (decl->args) {
1375 for (j = 0; j < decl->args->count; ++j) {
1376 if (j) {
1377 dprintf(fd, ", ");
1378 }
1379 dump_decl_arg(fd, decl->args->args[j]);
1380 }
1381 if (decl->args->varargs) {
1382 dprintf(fd, ", ...");
1383 }
1384 }
1385 dprintf(fd, ");\n");
1386 }
1387 dprintf(fd, "\n");
1388 }
1389 if (C->impls) {
1390 for (i = 0; i < C->impls->count; ++i) {
1391 impl *impl = C->impls->list[i];
1392
1393 dprintf(fd, "function %s(", impl->func->name);
1394 if (impl->func->args) {
1395 for (j = 0; j < impl->func->args->count; ++j) {
1396 impl_arg *iarg = impl->func->args->args[j];
1397
1398 dprintf(fd, "%s%s %s$%s",
1399 j ? ", " : "",
1400 iarg->type->name,
1401 iarg->var->reference ? "&" : "",
1402 iarg->var->name);
1403 if (iarg->def) {
1404 dprintf(fd, " = %s", iarg->def->text);
1405 }
1406 }
1407 if (impl->func->args->vararg) {
1408 impl_arg *vararg = impl->func->args->vararg;
1409
1410 dprintf(fd, ", %s %s...$%s",
1411 vararg->type->name,
1412 vararg->var->reference ? "&" : "",
1413 vararg->var->name);
1414 }
1415 }
1416 dprintf(fd, ") : %s%s {\n",
1417 impl->func->return_reference ? "&":"",
1418 impl->func->return_type->name);
1419 if (impl->stmts) {
1420 for (j = 0; j < impl->stmts->let.count; ++j) {
1421 let_stmt *let = impl->stmts->let.list[j];
1422
1423 dprintf(fd, "\tlet %s", let->var->name);
1424 if (let->val) {
1425 dprintf(fd, " = %s", let->val->flags.one.is_reference ? "&" : "");
1426 switch (let->val->kind) {
1427 case PSI_LET_NULL:
1428 dprintf(fd, "NULL");
1429 break;
1430 case PSI_LET_TMP:
1431 dump_decl_var(fd, let->val->data.var);
1432 break;
1433 case PSI_LET_CALLOC:
1434 dprintf(fd, "calloc(");
1435 dump_num_exp(fd, let->val->data.alloc->nmemb);
1436 dprintf(fd, ", ");
1437 dump_num_exp(fd, let->val->data.alloc->size);
1438 dprintf(fd, ")");
1439 break;
1440 case PSI_LET_FUNC:
1441 dprintf(fd, "%s($%s)", let->val->data.func->name,
1442 let->val->data.func->var->name);
1443 break;
1444
1445 EMPTY_SWITCH_DEFAULT_CASE();
1446 }
1447 dprintf(fd, ";\n");
1448 }
1449 }
1450 for (j = 0; j < impl->stmts->ret.count; ++j) {
1451 return_stmt *ret = impl->stmts->ret.list[j];
1452
1453 dprintf(fd, "\treturn ");
1454 dump_impl_set_value(fd, ret->set, 1);
1455 }
1456 for (j = 0; j < impl->stmts->set.count; ++j) {
1457 set_stmt *set = impl->stmts->set.list[j];
1458
1459 dprintf(fd, "\tset $%s = ", set->var->name);
1460 dump_impl_set_value(fd, set->val, 1);
1461 }
1462 for (j = 0; j < impl->stmts->fre.count; ++j) {
1463 free_stmt *fre = impl->stmts->fre.list[j];
1464
1465 dprintf(fd, "\tfree ");
1466 for (k = 0; k < fre->calls->count; ++k) {
1467 free_call *call = fre->calls->list[k];
1468
1469 if (k) {
1470 dprintf(fd, ", ");
1471 }
1472 dprintf(fd, "%s(", call->func);
1473 for (l = 0; l < call->vars->count; ++l) {
1474 decl_var *fvar = call->vars->vars[l];
1475
1476 dump_decl_var(fd, fvar);
1477 }
1478 dprintf(fd, ");\n");
1479 }
1480 }
1481 }
1482 dprintf(fd, "}\n");
1483 }
1484 dprintf(fd, "\n");
1485 }
1486 }
1487
1488 void PSI_ContextDtor(PSI_Context *C)
1489 {
1490 size_t i;
1491 zend_function_entry *zfe;
1492
1493 if (C->ops->dtor) {
1494 C->ops->dtor(C);
1495 }
1496
1497 free_decl_libs(&C->psi.libs);
1498
1499 if (C->data) {
1500 for (i = 0; i < C->count; ++i) {
1501 PSI_DataDtor(&C->data[i]);
1502 }
1503 free(C->data);
1504 }
1505
1506 if (C->closures) {
1507 for (zfe = C->closures; zfe->fname; ++zfe) {
1508 free((void *) zfe->arg_info);
1509 }
1510 free(C->closures);
1511 }
1512
1513 if (C->consts) {
1514 if (C->consts->list) {
1515 free(C->consts->list);
1516 }
1517 free(C->consts);
1518 }
1519 if (C->defs) {
1520 if (C->defs->list) {
1521 free(C->defs->list);
1522 }
1523 free(C->defs);
1524 }
1525 if (C->structs) {
1526 if (C->structs->list) {
1527 free(C->structs->list);
1528 }
1529 free(C->structs);
1530 }
1531 if (C->decls) {
1532 if (C->decls->list) {
1533 free(C->decls->list);
1534 }
1535 free(C->decls);
1536 }
1537 if (C->impls) {
1538 if (C->impls->list) {
1539 free(C->impls->list);
1540 }
1541 free(C->impls);
1542 }
1543
1544 memset(C, 0, sizeof(*C));
1545 }
1546
1547 void PSI_ContextFree(PSI_Context **C)
1548 {
1549 if (*C) {
1550 PSI_ContextDtor(*C);
1551 free(*C);
1552 *C = NULL;
1553 }
1554 }
PHP System Interface / POSIX Standard Interface