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


66b2a77f0b3a7ee2dcb2a6f0d49b7f0781ef1da8
[m6w6/ext-psi] / src / context_validate.c
1 #ifdef HAVE_CONFIG_H
2 # include "config.h"
3 #endif
4
5 #include "php.h"
6
7 #include <sys/param.h>
8 #include <dlfcn.h>
9
10 #include "php_psi.h"
11 #include "php_psi_stdinc.h"
12 #include "php_psi_stdtypes.h"
13 #include "php_psi_macros.h"
14 #include "php_psi_redirs.h"
15
16 #include "calc.h"
17 #include "marshal.h"
18 #include "engine.h"
19
20 static int validate_lib(PSI_Data *data, void **dlopened) {
21 char lib[MAXPATHLEN];
22 const char *ptr = data->psi.file.ln;
23 size_t len;
24
25 if (!ptr) {
26 /* FIXME: assume stdlib */
27 return 1;
28 } else if (!strchr(ptr, '/')) {
29 len = snprintf(lib, MAXPATHLEN, "lib%s.%s", ptr, PHP_PSI_SHLIB_SUFFIX);
30 if (MAXPATHLEN == len) {
31 data->error(NULL, PSI_WARNING, "Library name too long: '%s'", ptr);
32 }
33 lib[len] = 0;
34 ptr = lib;
35 }
36 if (!(*dlopened = dlopen(ptr, RTLD_LAZY|RTLD_LOCAL))) {
37 data->error(NULL, PSI_WARNING, "Could not open library '%s': %s.",
38 data->psi.file.ln, dlerror());
39 return 0;
40 }
41 return 1;
42 }
43
44 static inline int locate_decl_type_alias(decl_typedefs *defs, decl_type *type) {
45 size_t i;
46 struct psi_std_type *stdtyp;
47
48 if (type->real) {
49 return 1;
50 }
51 for (i = 0; i < defs->count; ++i) {
52 decl_typedef *def = defs->list[i];
53
54 if (def->type->type != type->type && !strcmp(def->alias, type->name)) {
55 type->real = def->type;
56 return 1;
57 }
58 }
59 for (stdtyp = &psi_std_types[0]; stdtyp->type_tag; ++stdtyp) {
60 if (!strcmp(type->name, stdtyp->alias ?: stdtyp->type_name)) {
61 type->type = stdtyp->type_tag;
62 return 1;
63 }
64 }
65
66 return 0;
67 }
68
69 static inline int locate_decl_type_struct(decl_structs *structs, decl_type *type) {
70 size_t i;
71
72 if (type->strct) {
73 return 1;
74 }
75 for (i = 0; i < structs->count; ++i) {
76 if (!strcmp(structs->list[i]->name, type->name)) {
77 type->strct = structs->list[i];
78 return 1;
79 }
80 }
81 return 0;
82 }
83
84 static inline int locate_decl_type_enum(decl_enums *enums, decl_type *type) {
85 size_t i;
86
87 if (type->enm) {
88 return 1;
89 }
90 for (i = 0; i < enums->count; ++i) {
91 if (!strcmp(enums->list[i]->name, type->name)) {
92 type->enm = enums->list[i];
93 return 1;
94 }
95 }
96 return 0;
97 }
98
99 static inline int validate_decl_type(PSI_Data *data, decl_type *type) {
100 switch (type->type) {
101 case PSI_T_CHAR:
102 case PSI_T_SHORT:
103 case PSI_T_INT:
104 case PSI_T_LONG:
105 case PSI_T_NAME:
106 if (!data->defs || !locate_decl_type_alias(data->defs, type)) {
107 return 0;
108 }
109 if (type->real) {
110 return validate_decl_type(data, type->real);
111 }
112 return 1;
113 case PSI_T_STRUCT:
114 if (!data->structs || !locate_decl_type_struct(data->structs, type)) {
115 return 0;
116 }
117 break;
118 case PSI_T_ENUM:
119 if (!data->enums || !locate_decl_type_enum(data->enums, type)) {
120 return 0;
121 }
122 }
123 return 1;
124 }
125 static inline int validate_decl_typedef(PSI_Data *data, decl_typedef *def) {
126 if (!validate_decl_type(data, def->type)) {
127 data->error(def->token, PSI_WARNING,
128 "Type '%s' cannot be aliased to %s'%s'",
129 def->type->name, def->type->type == PSI_T_STRUCT?"struct ":"",def->alias);
130 return 0;
131 }
132 /* FIXME: check def->alias */
133 return 1;
134 }
135
136 static inline int validate_constant(PSI_Data *data, constant *c) {
137 /* FIXME */
138 return 1;
139 }
140
141 static inline int validate_decl_arg(PSI_Data *data, decl_arg *arg) {
142 if (!validate_decl_type(data, arg->type)) {
143 data->error(arg->type->token, PSI_WARNING,
144 "Cannot use '%s'(%d) as type for decl var '%s'",
145 arg->type->name, arg->type->type, arg->var->name);
146 return 0;
147 }
148 return 1;
149 }
150
151 static int psi_sort_struct_arg_cmp(const void *_a, const void *_b) {
152 decl_arg *a = *(decl_arg **)_a, *b = *(decl_arg **)_b;
153
154 if (a->layout->pos == b->layout->pos) {
155 if (a->layout->len == b->layout->len) {
156 return 0;
157 } else if (a->layout->len > b->layout->len) {
158 return -1;
159 } else {
160 return 1;
161 }
162 } else if (a->layout->pos > b->layout->pos) {
163 return 1;
164 } else {
165 return -1;
166 }
167 }
168 static void psi_sort_struct_arg_swp(void *a, void *b) {
169 decl_arg **_a = a, **_b = b, *_c;
170
171 _c = *_b;
172 *_b = *_a;
173 *_a = _c;
174 }
175 static inline void psi_sort_struct_args(decl_struct *s) {
176 zend_insert_sort(s->args->args, s->args->count, sizeof(*s->args->args),
177 psi_sort_struct_arg_cmp, psi_sort_struct_arg_swp);
178 }
179
180 static inline int validate_decl_struct(PSI_Data *data, decl_struct *s) {
181 size_t i;
182
183 for (i = 0; i < s->args->count; ++i) {
184 if (!validate_decl_arg(data, s->args->args[i])) {
185 return 0;
186 }
187 }
188
189 for (i = 0; i < s->args->count; ++i) {
190 decl_arg *darg = s->args->args[i];
191
192 if (!validate_decl_arg(data, darg)) {
193 return 0;
194 }
195
196 ZEND_ASSERT(!darg->var->arg || darg->var->arg == darg);
197 darg->var->arg = darg;
198
199 if (darg->layout) {
200 size_t size;
201
202 if (darg->var->array_size) {
203 size = psi_t_size(real_decl_type(darg->type)->type) * darg->var->array_size;
204 } else if (darg->var->pointer_level) {
205 size = psi_t_size(PSI_T_POINTER);
206 } else {
207 decl_type *real = real_decl_type(darg->type);
208
209 if (real->type == PSI_T_STRUCT) {
210 size = real->strct->size;
211 } else {
212 size = psi_t_size(real->type);
213 }
214 }
215 if (darg->layout->len != size) {
216 data->error(darg->token, PSI_WARNING,
217 "Computed length %zu of %s.%s does not match"
218 " pre-defined length %zu of type '%s'",
219 darg->layout->len, s->name, darg->var->name, size,
220 darg->type->name);
221 return 0;
222 }
223 } else {
224 token_t t;
225
226 if (darg->var->pointer_level && (!darg->var->array_size || darg->var->pointer_level == 1)) {
227 t = PSI_T_POINTER;
228 } else {
229 t = real_decl_type(darg->type)->type;
230 }
231
232 if (i) {
233 decl_arg *last = s->args->args[i-1];
234 darg->layout = init_decl_struct_layout(
235 psi_t_align(t, last->layout->pos + last->layout->len),
236 psi_t_size(t) * darg->var->array_size);
237 } else {
238 darg->layout = init_decl_struct_layout(0, psi_t_size(t));
239 }
240 }
241 if (s->size < darg->layout->pos + darg->layout->len) {
242 s->size = darg->layout->pos + darg->layout->len;
243 }
244 }
245
246 psi_sort_struct_args(s);
247
248 return 1;
249 }
250
251 static const char * const abi_ccs[] = {
252 "default", /* \ */
253 "extern", /* > - all the same */
254 "cdecl", /* / */
255 "mscdecl",
256 "stdcall",
257 "fastcall",
258 };
259 static inline int validate_decl_abi(PSI_Data *data, decl_abi *abi) {
260 size_t i;
261
262 for (i = 0; i < sizeof(abi_ccs)/sizeof(char*); ++i) {
263 if (strcasecmp(abi->convention, abi_ccs[i])) {
264 return 1;
265 }
266 }
267 return 0;
268 }
269 static inline int validate_decl_func(PSI_Data *data, void *dl, decl *decl, decl_arg *func)
270 {
271 struct psi_func_redir *redir;
272
273 if (!strcmp(func->var->name, "dlsym")) {
274 data->error(func->token, PSI_WARNING, "Cannot dlsym dlsym (sic!)");
275 return 0;
276 }
277
278 if (!validate_decl_arg(data, func)) {
279 return 0;
280 }
281 for (redir = &psi_func_redirs[0]; redir->name; ++redir) {
282 if (!strcmp(func->var->name, redir->name)) {
283 decl->call.sym = redir->func;
284 }
285 }
286 if (!decl->call.sym) {
287 #ifndef RTLD_NEXT
288 # define RTLD_NEXT ((void *) -1l)
289 #endif
290 decl->call.sym = dlsym(dl ?: RTLD_NEXT, func->var->name);
291 if (!decl->call.sym) {
292 data->error(func->token, PSI_WARNING,
293 "Failed to locate symbol '%s': %s",
294 func->var->name, dlerror());
295 }
296 }
297 return 1;
298 }
299
300 static inline int validate_decl(PSI_Data *data, void *dl, decl *decl) {
301 if (!validate_decl_abi(data, decl->abi)) {
302 data->error(decl->abi->token, PSI_WARNING,
303 "Invalid calling convention: '%s'", decl->abi->token->text);
304 return 0;
305 }
306 if (!validate_decl_func(data, dl, decl, decl->func)) {
307 return 0;
308 }
309 if (decl->args) {
310 size_t i;
311
312 for (i = 0; i < decl->args->count; ++i) {
313 if (!validate_decl_arg(data, decl->args->args[i])) {
314 return 0;
315 }
316 }
317 }
318 return 1;
319 }
320 static inline decl_arg *locate_decl_var_arg(decl_var *var, decl_args *args, decl_arg *func) {
321 size_t i;
322
323 if (args) for (i = 0; i < args->count; ++i) {
324 decl_arg *arg = args->args[i];
325
326 if (!strcmp(var->name, arg->var->name)) {
327 ZEND_ASSERT(!var->arg || var->arg == arg);
328 return var->arg = arg;
329 }
330 }
331 if (func && !strcmp(var->name, func->var->name)) {
332 return var->arg = func;
333 }
334
335 return NULL;
336 }
337 static inline decl_arg *locate_struct_member(decl_struct *s, decl_var *var) {
338 if (s->args) {
339 return locate_decl_var_arg(var, s->args, NULL);
340 }
341
342 return NULL;
343 }
344 static inline constant *locate_num_exp_constant(num_exp *exp, constants *consts) {
345 size_t i;
346
347 for (i = 0; i < consts->count; ++i) {
348 constant *cnst = consts->list[i];
349
350 if (!strcmp(cnst->name, exp->u.numb)) {
351 free(exp->u.numb);
352 return exp->u.cnst = cnst;
353 }
354 }
355
356 return NULL;
357 }
358 static inline decl_enum_item *locate_num_exp_enum_item_ex(num_exp *exp, decl_enum *e) {
359 size_t k;
360
361 if (e) for (k = 0; k < e->items->count; ++k) {
362 decl_enum_item *i = e->items->list[k];
363
364 if (!strcmp(i->name, exp->u.dvar->name)) {
365 free_decl_var(exp->u.dvar);
366 exp->t = PSI_T_ENUM;
367 exp->u.enm = i;
368 return i;
369 }
370 }
371 return NULL;
372 }
373 static inline decl_enum_item *locate_num_exp_enum_item(num_exp *exp, decl_enums *enums) {
374 size_t j;
375
376 if (enums) for (j = 0; j < enums->count; ++j) {
377 decl_enum *e = enums->list[j];
378 decl_enum_item *i = locate_num_exp_enum_item_ex(exp, e);
379
380 if (i) {
381 return i;
382 }
383 }
384 return NULL;
385 }
386 static inline int validate_num_exp(PSI_Data *data, num_exp *exp, decl_args *dargs, decl_arg *func, decl_enum *enm) {
387 if (exp->operand) {
388 switch (exp->operator) {
389 case PSI_T_PLUS:
390 exp->calculator = psi_calc_add;
391 break;
392 case PSI_T_MINUS:
393 exp->calculator = psi_calc_sub;
394 break;
395 case PSI_T_ASTERISK:
396 exp->calculator = psi_calc_mul;
397 break;
398 case PSI_T_SLASH:
399 exp->calculator = psi_calc_div;
400 break;
401 EMPTY_SWITCH_DEFAULT_CASE();
402 }
403 if (!validate_num_exp(data, exp->operand, dargs, func, enm)) {
404 return 0;
405 }
406 }
407 switch (exp->t) {
408 case PSI_T_NAME:
409 if (!locate_decl_var_arg(exp->u.dvar, dargs, func)) {
410 if (!locate_num_exp_enum_item(exp, data->enums) && !locate_num_exp_enum_item_ex(exp, enm)) {
411 data->error(exp->token, PSI_WARNING, "Unknown variable '%s' in numeric expression",
412 exp->u.dvar->name);
413 return 0;
414 }
415 }
416 return 1;
417 case PSI_T_NSNAME:
418 if (!locate_num_exp_constant(exp, data->consts)) {
419 data->error(exp->token, PSI_WARNING, "Unknown constant '%s' in numeric expression",
420 exp->u.numb);
421 return 0;
422 }
423 return 1;
424 case PSI_T_NUMBER:
425 case PSI_T_ENUM:
426 return 1;
427 default:
428 return 0;
429 }
430 }
431
432 static inline int validate_decl_enum(PSI_Data *data, decl_enum *e) {
433 size_t j;
434
435 if (!e->items || !e->items->count) {
436 data->error(e->token, PSI_WARNING, "Empty enum '%s'", e->name);
437 return 0;
438 }
439
440 for (j = 0; j < e->items->count; ++j) {
441 decl_enum_item *i = e->items->list[j];
442
443 if (!i->num) {
444 if (j) {
445 i->inc.t = PSI_T_NUMBER;
446 i->inc.u.numb = "1";
447 i->inc.operator = PSI_T_PLUS;
448 i->inc.operand = i->prev->num ?: &i->prev->inc;
449 i->num = &i->inc;
450 } else {
451 i->inc.t = PSI_T_NUMBER;
452 i->inc.u.numb = "0";
453 i->num = &i->inc;
454 }
455 }
456 if (!validate_num_exp(data, i->num, NULL, NULL, e)) {
457 return 0;
458 }
459 }
460
461 return 1;
462 }
463
464 static inline int validate_set_value_handler(set_value *set) {
465 switch (set->func->type) {
466 case PSI_T_TO_BOOL:
467 set->func->handler = psi_to_bool;
468 break;
469 case PSI_T_TO_INT:
470 set->func->handler = psi_to_int;
471 break;
472 case PSI_T_TO_FLOAT:
473 set->func->handler = psi_to_double;
474 break;
475 case PSI_T_TO_STRING:
476 set->func->handler = psi_to_string;
477 break;
478 case PSI_T_TO_ARRAY:
479 set->func->handler = psi_to_array;
480 break;
481 case PSI_T_TO_OBJECT:
482 set->func->handler = psi_to_object;
483 break;
484 case PSI_T_VOID:
485 set->func->handler = psi_to_void;
486 break;
487 case PSI_T_ELLIPSIS:
488 if (set->outer.set && set->outer.set->func->type == PSI_T_TO_ARRAY) {
489 set->func->handler = psi_to_recursive;
490 set->inner = set->outer.set->inner;
491 set->count = set->outer.set->count;
492 break;
493 }
494 /* no break */
495 default:
496 return 0;
497 }
498 return 1;
499 }
500 static inline void decl_var_arg_v(decl_args *args, va_list argp) {
501 int argc;
502 decl_arg **argv;
503
504 memset(args, 0, sizeof(*args));
505
506 while ((argc = va_arg(argp, int))) {
507 argv = va_arg(argp, decl_arg **);
508 while (argc--) {
509 add_decl_arg(args, *argv++);
510 }
511 }
512 }
513 static inline int validate_set_value_ex(PSI_Data *data, set_value *set, decl_arg *ref, decl_args *ref_list) {
514 size_t i;
515 decl_type *ref_type;
516 decl_var *set_var = set->vars->vars[0];
517
518 if (!validate_set_value_handler(set)) {
519 data->error(set->func->token, PSI_WARNING, "Invalid cast '%s' in `set` statement", set->func->name);
520 return 0;
521 }
522
523 for (i = 0; i < set->vars->count; ++i) {
524 decl_var *svar = set->vars->vars[i];
525 if (!svar->arg && !locate_decl_var_arg(svar, ref_list, NULL)) {
526 data->error(svar->token, PSI_WARNING, "Unknown variable '%s' in `set` statement", svar->name);
527 return 0;
528 }
529 }
530
531 if (!ref) {
532 ref = set_var->arg;
533 }
534 ref_type = real_decl_type(ref->type);
535
536 if (set->count) {
537 int is_to_array = (set->func->type == PSI_T_TO_ARRAY);
538 int is_pointer_to_struct = (ref_type->type == PSI_T_STRUCT && ref->var->pointer_level);
539
540 if (!is_to_array && !is_pointer_to_struct) {
541 data->error(set->func->token, E_WARNING, "Inner `set` statement casts only work with "
542 "to_array() casts on structs or pointers: %s(%s...", set->func->name, set->vars->vars[0]->name);
543 return 0;
544 }
545 }
546 if (set->num) {
547 if (!validate_num_exp(data, set->num, ref_list, ref, NULL)) {
548 return 0;
549 }
550 }
551
552 if (ref_type->type == PSI_T_STRUCT) {
553 /* to_array(struct, to_...) */
554 if (!set->outer.set || set->outer.set->inner != set->inner) {
555 for (i = 0; i < set->count; ++i) {
556 decl_var *sub_var = set->inner[i]->vars->vars[0];
557 decl_arg *sub_ref = locate_struct_member(ref_type->strct, sub_var);
558
559 if (sub_ref) {
560 if (!validate_set_value_ex(data, set->inner[i], sub_ref, ref_type->strct->args)) {
561 return 0;
562 }
563 }
564 }
565 }
566 } else if (set->count == 1) {
567 /* to_array(ptr, to_string(*ptr)) */
568 decl_var *sub_var = set->inner[0]->vars->vars[0];
569 decl_arg *sub_ref = locate_decl_var_arg(sub_var, ref_list, ref);
570
571 if (sub_ref) {
572 if (strcmp(sub_var->name, set_var->name)) {
573 data->error(sub_var->token, E_WARNING, "Inner `set` statement casts on pointers must reference the same variable");
574 return 0;
575 }
576 if (!validate_set_value_ex(data, set->inner[0], sub_ref, ref_list)) {
577 return 0;
578 }
579 }
580 } else if (set->count > 1) {
581 data->error(set->func->token, E_WARNING, "Inner `set` statement casts on pointers may only occur once");
582 return 0;
583 }
584
585 return 1;
586 }
587 static inline int validate_set_value(PSI_Data *data, set_value *set, ...) {
588 va_list argp;
589 decl_args args = {0};
590 int check;
591
592 va_start(argp, set);
593 decl_var_arg_v(&args, argp);
594 va_end(argp);
595
596 check = validate_set_value_ex(data, set, NULL, &args);
597 if (args.args) {
598 free(args.args);
599 }
600 return check;
601 }
602 static inline decl *locate_impl_decl(decls *decls, return_stmt *ret) {
603 if (decls) {
604 size_t i;
605
606 for (i = 0; i < decls->count; ++i) {
607 if (!strcmp(decls->list[i]->func->var->name, ret->set->vars->vars[0]->name)) {
608 ret->decl = decls->list[i]->func;
609 return decls->list[i];
610 }
611 }
612 }
613
614 return NULL;
615 }
616 static inline int validate_impl_ret_stmt(PSI_Data *data, impl *impl) {
617 return_stmt *ret;
618
619 /* we must have exactly one ret stmt delcaring the native func to call */
620 /* and which type cast to apply */
621 if (impl->stmts->ret.count != 1) {
622 if (impl->stmts->ret.count > 1) {
623 data->error(impl->stmts->ret.list[1]->token, PSI_WARNING,
624 "Too many `return` statements for implmentation %s;"
625 " found %zu, exactly one is needed",
626 impl->func->name, impl->stmts->ret.count);
627 } else {
628 data->error(impl->func->token, PSI_WARNING,
629 "Missing `return` statement for implementation %s",
630 impl->func->name);
631 }
632 return 0;
633 }
634
635 ret = impl->stmts->ret.list[0];
636
637 if (!(impl->decl = locate_impl_decl(data->decls, ret))) {
638 data->error(ret->token, PSI_WARNING,
639 "Missing declaration '%s' for `return` statment for implementation %s",
640 ret->set->vars->vars[0]->name, impl->func->name);
641 return 0;
642 }
643
644 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)) {
645 return 0;
646 }
647
648 impl->decl->impl = impl;
649
650 return 1;
651 }
652
653 static inline int validate_impl_let_stmts(PSI_Data *data, impl *impl) {
654 size_t i, j;
655 /* we can have multiple let stmts */
656
657 /* check that we have a decl arg for every let stmt */
658 for (i = 0; i < impl->stmts->let.count; ++i) {
659 let_stmt *let = impl->stmts->let.list[i];
660 decl_var *let_var;
661 int check = 0;
662
663 if (let->val && let->val->kind == PSI_LET_TMP) {
664 let_var = let->val->data.var;
665 } else {
666 let_var = let->var;
667 }
668
669 if (!locate_decl_var_arg(let_var, impl->decl->args, impl->decl->func)) {
670 data->error(let_var->token, PSI_WARNING, "Unknown variable '%s' in `let` statement"
671 " of implementation '%s'", let_var->name, impl->func->name);
672 return 0;
673 }
674
675 switch (let->val->kind) {
676 case PSI_LET_NULL:
677 break;
678 case PSI_LET_TMP:
679 /* e.g. let bar = &strval($bar); // decl_arg(char **bar) */
680 /* e.g. let foo = *bar; */
681 let->var->pointer_level = let->val->data.var->pointer_level;
682 let->var->arg = init_decl_arg(
683 init_decl_type(
684 real_decl_type(let->val->data.var->arg->type)->type,
685 real_decl_type(let->val->data.var->arg->type)->name),
686 init_decl_var(
687 let->var->name,
688 let->var->pointer_level,
689 let->var->array_size));
690 break;
691 case PSI_LET_NUMEXP:
692 if (!validate_num_exp(data, let->val->data.num, impl->decl->args, impl->decl->func, NULL)) {
693 return 0;
694 }
695 break;
696 case PSI_LET_CALLOC:
697 if (!validate_num_exp(data, let->val->data.alloc->nmemb, impl->decl->args, impl->decl->func, NULL)) {
698 return 0;
699 }
700 if (!validate_num_exp(data, let->val->data.alloc->size, impl->decl->args, impl->decl->func, NULL)) {
701 return 0;
702 }
703 break;
704 case PSI_LET_FUNC:
705 if (impl->func->args) {
706 for (j = 0; j < impl->func->args->count; ++j) {
707 impl_arg *iarg = impl->func->args->args[j];
708
709 if (!strcmp(let->val->data.func->var->name, iarg->var->name)) {
710 let->val->data.func->arg = iarg;
711 check = 1;
712 break;
713 }
714 }
715 }
716 if (!check) {
717 data->error(let->var->token, PSI_WARNING, "Unknown value '$%s' of `let` statement"
718 " for variable '%s' of implementation '%s'",
719 let->val->data.func->var->name, let->var->name, impl->func->name);
720 return 0;
721 }
722 break;
723 }
724 }
725
726 /* check that we have a let stmt for every decl arg */
727 if (impl->decl->args) for (i = 0; i < impl->decl->args->count; ++i) {
728 decl_arg *darg = impl->decl->args->args[i];
729 int check = 0;
730
731 for (j = 0; j < impl->stmts->let.count; ++j) {
732 let_stmt *let = impl->stmts->let.list[j];
733
734 if (!strcmp(let->var->name, darg->var->name)) {
735 darg->let = let;
736 check = 1;
737 break;
738 }
739 }
740 if (!check) {
741 data->error(impl->func->token, PSI_WARNING,
742 "Missing `let` statement for arg '%s %.*s%s'"
743 " of declaration '%s' for implementation '%s'",
744 darg->type->name, (int) darg->var->pointer_level, "*****",
745 darg->var->name, impl->decl->func->var->name, impl->func->name);
746 return 0;
747 }
748 }
749
750 return 1;
751 }
752 static inline int validate_impl_set_stmts(PSI_Data *data, impl *impl) {
753 size_t i, j, k;
754 /* we can have any count of set stmts; processing out vars */
755 /* check that set stmts reference known variables */
756 for (i = 0; i < impl->stmts->set.count; ++i) {
757 set_stmt *set = impl->stmts->set.list[i];
758 int check = 0;
759
760 if (impl->func->args) for (j = 0; j < impl->func->args->count; ++j) {
761 impl_arg *iarg = impl->func->args->args[j];
762
763 if (!strcmp(set->var->name, iarg->var->name)) {
764 set->arg = iarg;
765 check = 1;
766 break;
767 }
768 }
769 if (!check) {
770 data->error(set->var->token, PSI_WARNING, "Unknown variable '$%s' of `set` statement"
771 " of implementation '%s'",
772 set->var->name, impl->func->name);
773 return 0;
774 }
775
776 for (j = 0; j < set->val->vars->count; ++j) {
777 decl_var *set_var = set->val->vars->vars[j];
778
779 check = 0;
780 if (impl->decl->args) {
781 for (k = 0; k < impl->decl->args->count; ++k) {
782 decl_arg *set_arg = impl->decl->args->args[k];
783
784 if (!strcmp(set_var->name, set_arg->var->name)) {
785 check = 1;
786 set_var->arg = set_arg;
787 if (!validate_set_value(data, set->val, 1, &set_arg, 1, &impl->decl->func, impl->decl->args->count, impl->decl->args->args, 0)) {
788 return 0;
789 }
790 break;
791 }
792 }
793 }
794 if (!check) {
795 for (k = 0; k < impl->stmts->let.count; ++k) {
796 let_stmt *let = impl->stmts->let.list[k];
797
798 /* check temp vars */
799 if (let->val && let->val->kind == PSI_LET_TMP) {
800 if (!strcmp(set_var->name, let->var->name)) {
801 check = 1;
802 set_var->arg = let->var->arg;
803 if (!validate_set_value(data, set->val, 1, &set_var->arg, 1, &impl->decl->func, impl->decl->args->count, impl->decl->args->args, 0)) {
804 return 0;
805 }
806 break;
807 }
808 }
809 }
810 }
811
812 if (!check) {
813 data->error(set_var->token, PSI_WARNING, "Unknown value '%s' of `set` statement"
814 " for variable '$%s' of implementation '%s'",
815 set_var->name, set->arg->var->name, impl->func->name);
816 return 0;
817 }
818 }
819 }
820 return 1;
821 }
822 static inline decl *locate_free_decl(decls *decls, free_call *f) {
823 if (decls) {
824 size_t i;
825
826 for (i = 0; i < decls->count; ++i) {
827 if (!strcmp(decls->list[i]->func->var->name, f->func)) {
828 f->decl = decls->list[i];
829 return decls->list[i];
830 }
831 }
832 }
833
834 return NULL;
835 }
836 static inline int validate_impl_free_stmts(PSI_Data *data, impl *impl) {
837 size_t i, j, k, l;
838 /* we can have any count of free stmts; freeing any out vars */
839 for (i = 0; i < impl->stmts->fre.count; ++i) {
840 free_stmt *fre = impl->stmts->fre.list[i];
841
842 for (j = 0; j < fre->calls->count; ++j) {
843 free_call *free_call = fre->calls->list[j];
844
845 /* first find the decl of the free func */
846 if (!locate_free_decl(data->decls, free_call)) {
847 data->error(free_call->token, PSI_WARNING,
848 "Missing declaration '%s' in `free` statement"
849 " of implementation '%s'",
850 free_call->func, impl->func->name);
851 return 0;
852 }
853
854
855
856 /* now check for known vars */
857 for (l = 0; l < free_call->vars->count; ++l) {
858 int check = 0;
859 decl_var *free_var = free_call->vars->vars[l];
860
861 if (!strcmp(free_var->name, impl->decl->func->var->name)) {
862 check = 1;
863 free_var->arg = impl->decl->func;
864 } else if (impl->decl->args) {
865 for (k = 0; k < impl->decl->args->count; ++k) {
866 decl_arg *free_arg = impl->decl->args->args[k];
867
868 if (!strcmp(free_var->name, free_arg->var->name)) {
869 check = 1;
870 free_var->arg = free_arg;
871 break;
872 }
873 }
874 }
875
876 if (!check) {
877 data->error(free_var->token, PSI_WARNING,
878 "Unknown variable '%s' of `free` statement"
879 " of implementation '%s'",
880 free_var->name, impl->func->name);
881 return 0;
882 }
883 }
884 }
885 }
886 return 1;
887 }
888 static inline int validate_impl_stmts(PSI_Data *data, impl *impl) {
889 if (!impl->stmts) {
890 data->error(impl->func->token, PSI_WARNING,
891 "Missing body for implementation %s!",
892 impl->func->name);
893 return 0;
894 }
895
896 if (!validate_impl_ret_stmt(data, impl)) {
897 return 0;
898 }
899
900 if (!validate_impl_let_stmts(data, impl)) {
901 return 0;
902 }
903 if (!validate_impl_set_stmts(data, impl)) {
904 return 0;
905 }
906 if (!validate_impl_free_stmts(data, impl)) {
907 return 0;
908 }
909
910 return 1;
911 }
912
913 static inline int validate_impl_args(PSI_Data *data, impl *impl) {
914 int def = 0;
915 size_t i;
916
917 for (i = 0; i < impl->func->args->count; ++i) {
918 impl_arg *iarg = impl->func->args->args[i];
919
920 if (iarg->def) {
921 def = 1;
922 } else if (def) {
923 data->error(impl->func->token, PSI_WARNING,
924 "Non-optional argument %zu '$%s' of implementation '%s'"
925 " follows optional argument",
926 i+1, iarg->var->name, impl->func->name);
927 return 0;
928 }
929 }
930
931 return 1;
932 }
933 static inline int validate_impl(PSI_Data *data, impl *impl) {
934 if (!validate_impl_args(data, impl)) {
935 return 0;
936 }
937 return validate_impl_stmts(data, impl);
938 }
939
940
941 int PSI_ContextValidate(PSI_Context *C, PSI_Parser *P)
942 {
943 PSI_Data *D;
944 void *dlopened = NULL;
945 size_t count = C->count++;
946
947 C->data = realloc(C->data, C->count * sizeof(*C->data));
948 D = PSI_DataExchange(&C->data[count], PSI_DATA(P));
949
950 if (D->defs) {
951 size_t i;
952
953 for (i = 0; i < D->defs->count; ++i) {
954 if (validate_decl_typedef(PSI_DATA(C), D->defs->list[i])) {
955 C->defs = add_decl_typedef(C->defs, D->defs->list[i]);
956 }
957 }
958 }
959 if (D->structs) {
960 size_t i;
961
962 for (i = 0; i < D->structs->count; ++i) {
963 if (validate_decl_struct(PSI_DATA(C), D->structs->list[i])) {
964 C->structs = add_decl_struct(C->structs, D->structs->list[i]);
965 }
966 }
967 }
968 if (D->enums) {
969 size_t i;
970
971 for (i = 0; i < D->enums->count; ++i) {
972 if (validate_decl_enum(PSI_DATA(C), D->enums->list[i])) {
973 C->enums = add_decl_enum(C->enums, D->enums->list[i]);
974 }
975 }
976 }
977 if (D->consts) {
978 size_t i;
979
980 for (i = 0; i < D->consts->count; ++i) {
981 if (validate_constant(PSI_DATA(C), D->consts->list[i])) {
982 C->consts = add_constant(C->consts, D->consts->list[i]);
983 }
984 }
985 }
986
987 if (!validate_lib(D, &dlopened)) {
988 return 0;
989 }
990
991 add_decl_lib(&C->psi.libs, dlopened);
992
993 if (D->decls) {
994 size_t i;
995
996 for (i = 0; i < D->decls->count; ++i) {
997 if (validate_decl(PSI_DATA(C), dlopened, D->decls->list[i])) {
998 C->decls = add_decl(C->decls, D->decls->list[i]);
999 }
1000 }
1001 }
1002 if (D->impls) {
1003 size_t i;
1004
1005 for (i = 0; i < D->impls->count; ++i) {
1006 if (validate_impl(PSI_DATA(C), D->impls->list[i])) {
1007 C->impls = add_impl(C->impls, D->impls->list[i]);
1008 }
1009 }
1010 }
1011
1012 return 1;
1013 }
1014
1015 int PSI_ContextValidateData(PSI_Data *dest, PSI_Data *source)
1016 {
1017 size_t i;
1018 int errors = 0;
1019
1020 if (source->defs) for (i = 0; i < source->defs->count; ++i) {
1021 decl_typedef *def = source->defs->list[i];
1022
1023 if (validate_decl_typedef(source, def)) {
1024 if (dest) {
1025 dest->defs = add_decl_typedef(dest->defs, def);
1026 }
1027 } else {
1028 ++errors;
1029 }
1030 }
1031
1032 if (source->consts) for (i = 0; i < source->consts->count; ++i) {
1033 constant *constant = source->consts->list[i];
1034
1035 if (validate_constant(source, constant)) {
1036 if (dest) {
1037 dest->consts = add_constant(dest->consts, constant);
1038 }
1039 } else {
1040 ++errors;
1041 }
1042 }
1043
1044 if (source->structs) for (i = 0; i < source->structs->count; ++i) {
1045 decl_struct *dstruct = source->structs->list[i];
1046
1047 if (validate_decl_struct(source, dstruct)) {
1048 if (dest) {
1049 dest->structs = add_decl_struct(dest->structs, dstruct);
1050 }
1051 } else {
1052 ++errors;
1053 }
1054 }
1055
1056 if (source->enums) for (i = 0; i < source->enums->count; ++i) {
1057 decl_enum *denum = source->enums->list[i];
1058
1059 if (validate_decl_enum(source, denum)) {
1060 if (dest) {
1061 dest->enums = add_decl_enum(dest->enums, denum);
1062 }
1063 } else {
1064 ++errors;
1065 }
1066 }
1067
1068 if (source->decls) for (i = 0; i < source->decls->count; ++i) {
1069 decl *decl = source->decls->list[i];
1070
1071 if (validate_decl(source, NULL, decl)) {
1072 if (dest) {
1073 dest->decls = add_decl(dest->decls, decl);
1074 }
1075 } else {
1076 ++errors;
1077 }
1078 }
1079
1080 if (source->impls) for (i = 0; i < source->impls->count; ++i) {
1081 impl *impl = source->impls->list[i];
1082
1083 if (validate_impl(source, impl)) {
1084 if (dest) {
1085 dest->impls = add_impl(dest->impls, impl);
1086 }
1087 } else {
1088 ++errors;
1089 }
1090 }
1091
1092 return errors;
1093 }
PHP System Interface / POSIX Standard Interface