4 # include "php_config.h"
7 #include "php_psi_stdinc.h"
13 # define NAMLEN(dirent) strlen ((dirent)->d_name)
15 # define dirent direct
16 # define NAMLEN(dirent) ((dirent)->d_namlen)
17 # ifdef HAVE_SYS_NDIR_H
18 # include <sys/ndir.h>
20 # ifdef HAVE_SYS_DIR_H
30 #include "php_scandir.h"
39 #include "php_psi_types.h"
40 #include "php_psi_consts.h"
41 #include "php_psi_decls.h"
42 #include "php_psi_va_decls.h"
43 #include "php_psi_fn_decls.h"
44 #include "php_psi_structs.h"
45 #include "php_psi_unions.h"
47 struct psi_context
*psi_context_init(struct psi_context
*C
, struct psi_context_ops
*ops
, psi_error_cb error
, unsigned flags
)
50 struct psi_predef_type
*predef_type
;
51 struct psi_predef_const
*predef_const
;
52 struct psi_predef_struct
*predef_struct
;
53 struct psi_predef_union
*predef_union
;
54 struct psi_predef_decl
*predef_decl
;
57 C
= malloc(sizeof(*C
));
59 memset(C
, 0, sizeof(*C
));
69 ZEND_ASSERT(ops
->call
!= NULL
);
70 ZEND_ASSERT(ops
->compile
!= NULL
);
72 /* build up predefs in a temporary PSI_Data for validation */
73 memset(&T
, 0, sizeof(T
));
76 for (predef_type
= &psi_predef_types
[0]; predef_type
->type_tag
; ++predef_type
) {
77 decl_type
*type
= init_decl_type(predef_type
->type_tag
, predef_type
->type_name
);
78 decl_var
*var
= init_decl_var(predef_type
->alias
, 0, 0); /* FIXME: indirection */
79 decl_arg
*def
= init_decl_arg(type
, var
);
81 T
.defs
= add_decl_typedef(T
.defs
, def
);
83 for (predef_const
= &psi_predef_consts
[0]; predef_const
->type_tag
; ++predef_const
) {
84 impl_def_val
*val
= init_impl_def_val(predef_const
->val_type_tag
, predef_const
->val_text
);
85 const_type
*type
= init_const_type(predef_const
->type_tag
, predef_const
->type_name
);
86 constant
*constant
= init_constant(type
, predef_const
->var_name
, val
);
88 T
.consts
= add_constant(T
.consts
, constant
);
90 for (predef_struct
= &psi_predef_structs
[0]; predef_struct
->type_tag
; ++predef_struct
) {
91 struct psi_predef_struct
*member
;
92 decl_args
*dargs
= init_decl_args(NULL
);
93 decl_struct
*dstruct
= init_decl_struct(predef_struct
->var_name
, dargs
);
95 dstruct
->size
= predef_struct
->size
;
96 dstruct
->align
= predef_struct
->offset
;
97 for (member
= &predef_struct
[1]; member
->type_tag
; ++member
) {
102 type
= init_decl_type(member
->type_tag
, member
->type_name
);
103 dvar
= init_decl_var(member
->var_name
, member
->pointer_level
, member
->array_size
);
104 darg
= init_decl_arg(type
, dvar
);
105 darg
->layout
= init_decl_struct_layout(member
->offset
, member
->size
);
106 dargs
= add_decl_arg(dargs
, darg
);
109 T
.structs
= add_decl_struct(T
.structs
, dstruct
);
110 predef_struct
= member
;
112 for (predef_union
= &psi_predef_unions
[0]; predef_union
->type_tag
; ++predef_union
) {
113 struct psi_predef_union
*member
;
114 decl_args
*dargs
= init_decl_args(NULL
);
115 decl_union
*dunion
= init_decl_union(predef_union
->var_name
, dargs
);
117 dunion
->size
= predef_union
->size
;
118 dunion
->align
= predef_union
->offset
;
119 for (member
= &predef_union
[1]; member
->type_tag
; ++member
) {
124 type
= init_decl_type(member
->type_tag
, member
->type_name
);
125 dvar
= init_decl_var(member
->var_name
, member
->pointer_level
, member
->array_size
);
126 darg
= init_decl_arg(type
, dvar
);
127 darg
->layout
= init_decl_struct_layout(member
->offset
, member
->size
);
128 dargs
= add_decl_arg(dargs
, darg
);
131 T
.unions
= add_decl_union(T
.unions
, dunion
);
132 predef_union
= member
;
134 for (predef_decl
= &psi_predef_decls
[0]; predef_decl
->type_tag
; ++predef_decl
) {
135 struct psi_predef_decl
*farg
;
136 decl_type
*ftype
= init_decl_type(predef_decl
->type_tag
, predef_decl
->type_name
);
137 decl_var
*fname
= init_decl_var(predef_decl
->var_name
, predef_decl
->pointer_level
, predef_decl
->array_size
);
138 decl_arg
*func
= init_decl_arg(ftype
, fname
);
139 decl_args
*args
= init_decl_args(NULL
);
140 decl
*decl
= init_decl(init_decl_abi("default"), func
, args
);
142 for (farg
= &predef_decl
[1]; farg
->type_tag
; ++farg
) {
143 decl_type
*arg_type
= init_decl_type(farg
->type_tag
, farg
->type_name
);
144 decl_var
*arg_var
= init_decl_var(farg
->var_name
, farg
->pointer_level
, farg
->array_size
);
145 decl_arg
*darg
= init_decl_arg(arg_type
, arg_var
);
146 args
= add_decl_arg(args
, darg
);
149 T
.decls
= add_decl(T
.decls
, decl
);
153 for (predef_decl
= &psi_predef_vararg_decls
[0]; predef_decl
->type_tag
; ++predef_decl
) {
154 struct psi_predef_decl
*farg
;
155 decl_type
*ftype
= init_decl_type(predef_decl
->type_tag
, predef_decl
->type_name
);
156 decl_var
*fname
= init_decl_var(predef_decl
->var_name
, predef_decl
->pointer_level
, predef_decl
->array_size
);
157 decl_arg
*func
= init_decl_arg(ftype
, fname
);
158 decl_args
*args
= init_decl_args(NULL
);
159 decl
*decl
= init_decl(init_decl_abi("default"), func
, args
);
161 for (farg
= &predef_decl
[1]; farg
->type_tag
; ++farg
) {
162 decl_type
*arg_type
= init_decl_type(farg
->type_tag
, farg
->type_name
);
163 decl_var
*arg_var
= init_decl_var(farg
->var_name
, farg
->pointer_level
, farg
->array_size
);
164 decl_arg
*darg
= init_decl_arg(arg_type
, arg_var
);
165 args
= add_decl_arg(args
, darg
);
169 T
.decls
= add_decl(T
.decls
, decl
);
173 for (predef_decl
= &psi_predef_functor_decls
[0]; predef_decl
->type_tag
; ++predef_decl
) {
174 struct psi_predef_decl
*farg
;
175 decl_type
*dtype
, *ftype
= init_decl_type(predef_decl
->type_tag
, predef_decl
->type_name
);
176 decl_var
*fname
= init_decl_var(predef_decl
->var_name
, predef_decl
->pointer_level
, predef_decl
->array_size
);
177 decl_arg
*tdef
, *func
= init_decl_arg(ftype
, fname
);
178 decl_args
*args
= init_decl_args(NULL
);
179 decl
*decl
= init_decl(init_decl_abi("default"), func
, args
);
181 for (farg
= &predef_decl
[1]; farg
->type_tag
; ++farg
) {
182 decl_type
*arg_type
= init_decl_type(farg
->type_tag
, farg
->type_name
);
183 decl_var
*arg_var
= init_decl_var(farg
->var_name
, farg
->pointer_level
, farg
->array_size
);
184 decl_arg
*darg
= init_decl_arg(arg_type
, arg_var
);
185 args
= add_decl_arg(args
, darg
);
188 dtype
= init_decl_type(PSI_T_FUNCTION
, fname
->name
);
189 dtype
->real
.func
= decl
;
190 tdef
= init_decl_arg(dtype
, copy_decl_var(fname
));
191 T
.defs
= add_decl_typedef(T
.defs
, tdef
);
196 psi_context_validate_data(PSI_DATA(C
), &T
);
199 C
->data
= malloc(sizeof(*C
->data
));
200 psi_data_exchange(C
->data
, &T
);
205 static int psi_select_dirent(const struct dirent
*entry
)
208 #define FNM_CASEFOLD 0
210 return 0 == fnmatch("*.psi", entry
->d_name
, FNM_CASEFOLD
);
213 void psi_context_build(struct psi_context
*C
, const char *paths
)
216 char *sep
= NULL
, *cpy
= strdup(paths
), *ptr
= cpy
;
217 struct dirent
**entries
;
220 sep
= strchr(ptr
, ':');
227 n
= php_scandir(ptr
, &entries
, psi_select_dirent
, alphasort
);
230 for (i
= 0; i
< n
; ++i
) {
231 char psi
[MAXPATHLEN
];
234 if (MAXPATHLEN
<= slprintf(psi
, MAXPATHLEN
, "%s/%s", ptr
, entries
[i
]->d_name
)) {
235 C
->error(C
, NULL
, PSI_WARNING
, "Path to PSI file too long: %s/%s",
236 ptr
, entries
[i
]->d_name
);
238 if (!psi_parser_init(&P
, psi
, C
->error
, C
->flags
)) {
239 C
->error(C
, NULL
, PSI_WARNING
, "Failed to init PSI parser (%s): %s",
240 psi
, strerror(errno
));
244 while (0 < psi_parser_scan(&P
)) {
245 psi_parser_parse(&P
, psi_token_alloc(&P
));
246 if (P
.num
== PSI_T_EOF
) {
251 psi_parser_parse(&P
, NULL
);
252 psi_context_validate(C
, &P
);
258 for (i
= 0; i
< n
; ++i
) {
268 if (psi_context_compile(C
) && SUCCESS
!= zend_register_functions(NULL
, C
->closures
, NULL
, MODULE_PERSISTENT
)) {
269 C
->error(C
, NULL
, PSI_WARNING
, "Failed to register functions!");
276 zend_function_entry
*psi_context_compile(struct psi_context
*C
)
281 zc
.flags
= CONST_PERSISTENT
|CONST_CS
;
282 zc
.module_number
= EG(current_module
)->module_number
;
285 for (i
= 0; i
< C
->consts
->count
; ++i
) {
286 constant
*c
= C
->consts
->list
[i
];
288 zc
.name
= zend_string_init(c
->name
+ (c
->name
[0] == '\\'), strlen(c
->name
) - (c
->name
[0] == '\\'), 1);
289 ZVAL_NEW_STR(&zc
.value
, zend_string_init(c
->val
->text
, strlen(c
->val
->text
), 1));
291 switch (c
->type
->type
) {
293 convert_to_boolean(&zc
.value
);
296 convert_to_long(&zc
.value
);
299 convert_to_double(&zc
.value
);
302 case PSI_T_QUOTED_STRING
:
307 zend_register_constant(&zc
);
311 for (i
= 0; i
< C
->enums
->count
; ++i
) {
312 decl_enum
*e
= C
->enums
->list
[i
];
315 for (j
= 0; j
< e
->items
->count
; ++j
) {
316 decl_enum_item
*i
= e
->items
->list
[j
];
317 zend_string
*name
= strpprintf(0, "psi\\%s\\%s", e
->name
, i
->name
);
319 zc
.name
= zend_string_dup(name
, 1);
320 ZVAL_LONG(&zc
.value
, psi_long_num_exp(i
->num
, NULL
));
321 zend_register_constant(&zc
);
322 zend_string_release(name
);
327 return C
->closures
= C
->ops
->compile(C
);
331 void psi_context_call(struct psi_context
*C
, struct decl_callinfo
*decl_call
, struct impl_vararg
*va
)
333 C
->ops
->call(C
, decl_call
, va
);
337 void psi_context_dtor(struct psi_context
*C
)
340 zend_function_entry
*zfe
;
346 free_decl_libs(&C
->psi
.libs
);
349 for (i
= 0; i
< C
->count
; ++i
) {
350 psi_data_dtor(&C
->data
[i
]);
356 for (zfe
= C
->closures
; zfe
->fname
; ++zfe
) {
357 free((void *) zfe
->arg_info
);
363 if (C
->consts
->list
) {
364 free(C
->consts
->list
);
375 if (C
->structs
->list
) {
376 free(C
->structs
->list
);
381 if (C
->unions
->list
) {
382 free(C
->unions
->list
);
387 if (C
->enums
->list
) {
388 free(C
->enums
->list
);
393 if (C
->decls
->list
) {
394 free(C
->decls
->list
);
399 if (C
->impls
->list
) {
400 free(C
->impls
->list
);
405 memset(C
, 0, sizeof(*C
));
408 void psi_context_free(struct psi_context
**C
)
411 psi_context_dtor(*C
);
417 int psi_context_validate(struct psi_context
*C
, struct psi_parser
*P
)
420 void *dlopened
= NULL
;
421 size_t i
, count
= C
->count
++, check_round
, check_count
;
422 decl_typedefs
*check_defs
= P
->defs
;
423 decl_structs
*check_structs
= P
->structs
;
424 decl_unions
*check_unions
= P
->unions
;
425 decl_enums
*check_enums
= P
->enums
;
426 unsigned flags
= C
->flags
;
428 C
->data
= realloc(C
->data
, C
->count
* sizeof(*C
->data
));
429 D
= psi_data_exchange(&C
->data
[count
], PSI_DATA(P
));
431 #define REVALIDATE(what) do { \
432 if (check_round && check_ ##what) { \
433 free(check_ ##what->list); \
434 free(check_ ##what); \
436 check_ ##what = recheck_ ##what; \
438 #define CHECK_TOTAL (CHECK_COUNT(defs) + CHECK_COUNT(structs) + CHECK_COUNT(enums))
439 #define CHECK_COUNT(of) (check_ ##of ? check_ ##of->count : 0)
441 if (!(flags
& PSI_PARSER_SILENT
)) {
442 /* no warnings on first round */
443 C
->flags
|= PSI_PARSER_SILENT
;
445 for (check_round
= 0, check_count
= 0; CHECK_TOTAL
&& check_count
!= CHECK_TOTAL
; ++check_round
) {
446 decl_typedefs
*recheck_defs
= NULL
;
447 decl_structs
*recheck_structs
= NULL
;
448 decl_unions
*recheck_unions
= NULL
;
449 decl_enums
*recheck_enums
= NULL
;
451 check_count
= CHECK_TOTAL
;
453 for (i
= 0; i
< CHECK_COUNT(defs
); ++i
) {
454 if (validate_decl_typedef(PSI_DATA(C
), check_defs
->list
[i
])) {
455 C
->defs
= add_decl_typedef(C
->defs
, check_defs
->list
[i
]);
457 recheck_defs
= add_decl_typedef(recheck_defs
, check_defs
->list
[i
]);
460 for (i
= 0; i
< CHECK_COUNT(structs
); ++i
) {
461 if (validate_decl_struct(PSI_DATA(C
), check_structs
->list
[i
])) {
462 C
->structs
= add_decl_struct(C
->structs
, check_structs
->list
[i
]);
464 recheck_structs
= add_decl_struct(recheck_structs
, check_structs
->list
[i
]);
467 for (i
= 0; i
< CHECK_COUNT(unions
); ++i
) {
468 if (validate_decl_union(PSI_DATA(C
), check_unions
->list
[i
])) {
469 C
->unions
= add_decl_union(C
->unions
, check_unions
->list
[i
]);
471 recheck_unions
= add_decl_union(recheck_unions
, check_unions
->list
[i
]);
474 for (i
= 0; i
< CHECK_COUNT(enums
); ++i
) {
475 if (validate_decl_enum(PSI_DATA(C
), check_enums
->list
[i
])) {
476 C
->enums
= add_decl_enum(C
->enums
, check_enums
->list
[i
]);
478 recheck_enums
= add_decl_enum(recheck_enums
, check_enums
->list
[i
]);
487 if (check_round
== 0 && !(flags
& PSI_PARSER_SILENT
)) {
488 C
->flags
^= PSI_PARSER_SILENT
;
495 for (i
= 0; i
< D
->consts
->count
; ++i
) {
496 if (validate_constant(PSI_DATA(C
), D
->consts
->list
[i
])) {
497 C
->consts
= add_constant(C
->consts
, D
->consts
->list
[i
]);
502 if (!validate_file(D
, &dlopened
)) {
506 add_decl_lib(&C
->psi
.libs
, dlopened
);
509 for (i
= 0; i
< D
->decls
->count
; ++i
) {
510 if (validate_decl(PSI_DATA(C
), dlopened
, D
->decls
->list
[i
])) {
511 C
->decls
= add_decl(C
->decls
, D
->decls
->list
[i
]);
516 for (i
= 0; i
< D
->impls
->count
; ++i
) {
517 if (validate_impl(PSI_DATA(C
), D
->impls
->list
[i
])) {
518 C
->impls
= add_impl(C
->impls
, D
->impls
->list
[i
]);
526 int psi_context_validate_data(struct psi_data
*dest
, struct psi_data
*source
)
531 if (source
->defs
) for (i
= 0; i
< source
->defs
->count
; ++i
) {
532 decl_arg
*def
= source
->defs
->list
[i
];
534 if (validate_decl_typedef(source
, def
)) {
536 dest
->defs
= add_decl_typedef(dest
->defs
, def
);
543 if (source
->consts
) for (i
= 0; i
< source
->consts
->count
; ++i
) {
544 constant
*constant
= source
->consts
->list
[i
];
546 if (validate_constant(source
, constant
)) {
548 dest
->consts
= add_constant(dest
->consts
, constant
);
555 if (source
->structs
) for (i
= 0; i
< source
->structs
->count
; ++i
) {
556 decl_struct
*dstruct
= source
->structs
->list
[i
];
558 if (validate_decl_struct(source
, dstruct
)) {
560 dest
->structs
= add_decl_struct(dest
->structs
, dstruct
);
567 if (source
->unions
) for (i
= 0; i
< source
->unions
->count
; ++i
) {
568 decl_union
*dunion
= source
->unions
->list
[i
];
570 if (validate_decl_union(source
, dunion
)) {
572 dest
->unions
= add_decl_union(dest
->unions
, dunion
);
579 if (source
->enums
) for (i
= 0; i
< source
->enums
->count
; ++i
) {
580 decl_enum
*denum
= source
->enums
->list
[i
];
582 if (validate_decl_enum(source
, denum
)) {
584 dest
->enums
= add_decl_enum(dest
->enums
, denum
);
591 if (source
->decls
) for (i
= 0; i
< source
->decls
->count
; ++i
) {
592 decl
*decl
= source
->decls
->list
[i
];
594 if (validate_decl(source
, NULL
, decl
)) {
596 dest
->decls
= add_decl(dest
->decls
, decl
);
603 if (source
->impls
) for (i
= 0; i
< source
->impls
->count
; ++i
) {
604 impl
*impl
= source
->impls
->list
[i
];
606 if (validate_impl(source
, impl
)) {
608 dest
->impls
= add_impl(dest
->impls
, impl
);
618 static inline void dump_data(int fd
, struct psi_data
*D
) {
619 if (D
->psi
.file
.fn
) {
620 dprintf(fd
, "// psi.filename=%s\n", D
->psi
.file
.fn
);
621 if (D
->psi
.file
.ln
) {
622 dprintf(fd
, "lib \"%s\";\n", D
->psi
.file
.ln
);
625 dprintf(fd
, "// builtin predef\n");
628 dump_decl_typedefs(fd
, D
->defs
);
632 dump_decl_unions(fd
, D
->unions
);
636 dump_decl_structs(fd
, D
->structs
);
640 dump_decl_enums(fd
, D
->enums
);
644 dump_constants(fd
, D
->consts
);
648 dump_decls(fd
, D
->decls
);
652 dump_impls(fd
, D
->impls
);
657 void psi_context_dump(struct psi_context
*C
, int fd
)
662 if (C
->ops
== psi_libjit_ops()) {
663 dprintf(fd
, "// psi.engine=jit\n");
667 if (C
->ops
== psi_libffi_ops()) {
668 dprintf(fd
, "// psi.engine=ffi\n");
673 for (i
= 0; i
< C
->count
; ++i
) {
674 dump_data(fd
, &C
->data
[i
]);