git.m6w6.name Git - m6w6/ext-psi/blob - 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                         size_t size, align;
 226
 227                         if (darg->var->pointer_level && (!darg->var->array_size || darg->var->pointer_level == 1)) {
 228                                 t = PSI_T_POINTER;
 229                         } else {
 230                                 t = real_decl_type(darg->type)->type;
 231                         }
 232
 233                         size = psi_t_size(t) * (darg->var->array_size ?: 1);
 234
 235                         if (i) {
 236                                 decl_arg *last = s->args->args[i-1];
 237
 238                                 align = psi_t_align(t, last->layout->pos + last->layout->len);
 239                         } else {
 240                                 align = 0;
 241                         }
 242
 243                         darg->layout = init_decl_struct_layout(align, size);
 244                 }
 245                 if (s->size < darg->layout->pos + darg->layout->len) {
 246                         s->size = darg->layout->pos + darg->layout->len;
 247                         /* FIXME: align struct */
 248                 }
 249         }
 250
 251         psi_sort_struct_args(s);
 252
 253         return 1;
 254 }
 255
 256 static const char * const abi_ccs[] = {
 257                 "default", /* \                 */
 258                 "extern",  /*  > - all the same */
 259                 "cdecl",   /* /                 */
 260                 "mscdecl",
 261                 "stdcall",
 262                 "fastcall",
 263 };
 264 static inline int validate_decl_abi(PSI_Data *data, decl_abi *abi) {
 265         size_t i;
 266
 267         for (i = 0; i < sizeof(abi_ccs)/sizeof(char*); ++i) {
 268                 if (strcasecmp(abi->convention, abi_ccs[i])) {
 269                         return 1;
 270                 }
 271         }
 272         return 0;
 273 }
 274 static inline int validate_decl_func(PSI_Data *data, void *dl, decl *decl, decl_arg *func)
 275 {
 276         struct psi_func_redir *redir;
 277
 278         if (!strcmp(func->var->name, "dlsym")) {
 279                 data->error(func->token, PSI_WARNING, "Cannot dlsym dlsym (sic!)");
 280                 return 0;
 281         }
 282
 283         if (!validate_decl_arg(data, func)) {
 284                 return 0;
 285         }
 286         for (redir = &psi_func_redirs[0]; redir->name; ++redir) {
 287                 if (!strcmp(func->var->name, redir->name)) {
 288                         decl->call.sym = redir->func;
 289                 }
 290         }
 291         if (!decl->call.sym) {
 292 #ifndef RTLD_NEXT
 293 # define RTLD_NEXT ((void *) -1l)
 294 #endif
 295                 decl->call.sym = dlsym(dl ?: RTLD_NEXT, func->var->name);
 296                 if (!decl->call.sym) {
 297                         data->error(func->token, PSI_WARNING,
 298                                 "Failed to locate symbol '%s': %s",
 299                                 func->var->name, dlerror());
 300                 }
 301         }
 302         return 1;
 303 }
 304
 305 static inline int validate_decl(PSI_Data *data, void *dl, decl *decl) {
 306         if (!validate_decl_abi(data, decl->abi)) {
 307                 data->error(decl->abi->token, PSI_WARNING,
 308                                 "Invalid calling convention: '%s'", decl->abi->token->text);
 309                 return 0;
 310         }
 311         if (!validate_decl_func(data, dl, decl, decl->func)) {
 312                 return 0;
 313         }
 314         if (decl->args) {
 315                 size_t i;
 316
 317                 for (i = 0; i < decl->args->count; ++i) {
 318                         if (!validate_decl_arg(data, decl->args->args[i])) {
 319                                 return 0;
 320                         }
 321                 }
 322         }
 323         return 1;
 324 }
 325 static inline decl_arg *locate_decl_var_arg(decl_var *var, decl_args *args, decl_arg *func) {
 326         size_t i;
 327
 328         if (args) for (i = 0; i < args->count; ++i) {
 329                 decl_arg *arg = args->args[i];
 330
 331                 if (!strcmp(var->name, arg->var->name)) {
 332                         ZEND_ASSERT(!var->arg || var->arg == arg);
 333                         return var->arg = arg;
 334                 }
 335         }
 336         if (func && !strcmp(var->name, func->var->name)) {
 337                 return var->arg = func;
 338         }
 339
 340         return NULL;
 341 }
 342 static inline decl_arg *locate_struct_member(decl_struct *s, decl_var *var) {
 343         if (s->args) {
 344                 return locate_decl_var_arg(var, s->args, NULL);
 345         }
 346
 347         return NULL;
 348 }
 349 static inline constant *locate_num_exp_constant(num_exp *exp, constants *consts) {
 350         size_t i;
 351
 352         for (i = 0; i < consts->count; ++i) {
 353                 constant *cnst = consts->list[i];
 354
 355                 if (!strcmp(cnst->name, exp->u.numb)) {
 356                         free(exp->u.numb);
 357                         return exp->u.cnst = cnst;
 358                 }
 359         }
 360
 361         return NULL;
 362 }
 363 static inline decl_enum_item *locate_num_exp_enum_item_ex(num_exp *exp, decl_enum *e) {
 364         size_t k;
 365
 366         if (e) for (k = 0; k < e->items->count; ++k) {
 367                 decl_enum_item *i = e->items->list[k];
 368
 369                 if (!strcmp(i->name, exp->u.dvar->name)) {
 370                         free_decl_var(exp->u.dvar);
 371                         exp->t = PSI_T_ENUM;
 372                         exp->u.enm = i;
 373                         return i;
 374                 }
 375         }
 376         return NULL;
 377 }
 378 static inline decl_enum_item *locate_num_exp_enum_item(num_exp *exp, decl_enums *enums) {
 379         size_t j;
 380
 381         if (enums) for (j = 0; j < enums->count; ++j) {
 382                 decl_enum *e = enums->list[j];
 383                 decl_enum_item *i = locate_num_exp_enum_item_ex(exp, e);
 384
 385                 if (i) {
 386                         return i;
 387                 }
 388         }
 389         return NULL;
 390 }
 391 static inline int validate_num_exp(PSI_Data *data, num_exp *exp, decl_args *dargs, decl_arg *func, decl_enum *enm) {
 392         if (exp->operand) {
 393                 switch (exp->operator) {
 394                 case PSI_T_PLUS:
 395                         exp->calculator = psi_calc_add;
 396                         break;
 397                 case PSI_T_MINUS:
 398                         exp->calculator = psi_calc_sub;
 399                         break;
 400                 case PSI_T_ASTERISK:
 401                         exp->calculator = psi_calc_mul;
 402                         break;
 403                 case PSI_T_SLASH:
 404                         exp->calculator = psi_calc_div;
 405                         break;
 406                 EMPTY_SWITCH_DEFAULT_CASE();
 407                 }
 408                 if (!validate_num_exp(data, exp->operand, dargs, func, enm)) {
 409                         return 0;
 410                 }
 411         }
 412         switch (exp->t) {
 413         case PSI_T_NAME:
 414                 if (!locate_decl_var_arg(exp->u.dvar, dargs, func)) {
 415                         if (!locate_num_exp_enum_item(exp, data->enums) && !locate_num_exp_enum_item_ex(exp, enm)) {
 416                                 data->error(exp->token, PSI_WARNING, "Unknown variable '%s' in numeric expression",
 417                                                 exp->u.dvar->name);
 418                                 return 0;
 419                         }
 420                 }
 421                 return 1;
 422         case PSI_T_NSNAME:
 423                 if (!locate_num_exp_constant(exp, data->consts)) {
 424                         data->error(exp->token, PSI_WARNING, "Unknown constant '%s' in numeric expression",
 425                                         exp->u.numb);
 426                         return 0;
 427                 }
 428                 return 1;
 429         case PSI_T_NUMBER:
 430         case PSI_T_ENUM:
 431                 return 1;
 432         default:
 433                 return 0;
 434         }
 435 }
 436
 437 static inline int validate_decl_enum(PSI_Data *data, decl_enum *e) {
 438         size_t j;
 439
 440         if (!e->items || !e->items->count) {
 441                 data->error(e->token, PSI_WARNING, "Empty enum '%s'", e->name);
 442                 return 0;
 443         }
 444
 445         for (j = 0; j < e->items->count; ++j) {
 446                 decl_enum_item *i = e->items->list[j];
 447
 448                 if (!i->num) {
 449                         if (j) {
 450                                 i->inc.t = PSI_T_NUMBER;
 451                                 i->inc.u.numb = "1";
 452                                 i->inc.operator = PSI_T_PLUS;
 453                                 i->inc.operand = i->prev->num ?: &i->prev->inc;
 454                                 i->num = &i->inc;
 455                         } else {
 456                                 i->inc.t = PSI_T_NUMBER;
 457                                 i->inc.u.numb = "0";
 458                                 i->num = &i->inc;
 459                         }
 460                 }
 461                 if (!validate_num_exp(data, i->num, NULL, NULL, e)) {
 462                         return 0;
 463                 }
 464         }
 465
 466         return 1;
 467 }
 468
 469 static inline int validate_set_value_handler(set_value *set) {
 470         switch (set->func->type) {
 471         case PSI_T_TO_BOOL:
 472                 set->func->handler = psi_to_bool;
 473                 break;
 474         case PSI_T_TO_INT:
 475                 set->func->handler = psi_to_int;
 476                 break;
 477         case PSI_T_TO_FLOAT:
 478                 set->func->handler = psi_to_double;
 479                 break;
 480         case PSI_T_TO_STRING:
 481                 set->func->handler = psi_to_string;
 482                 break;
 483         case PSI_T_TO_ARRAY:
 484                 set->func->handler = psi_to_array;
 485                 break;
 486         case PSI_T_TO_OBJECT:
 487                 set->func->handler = psi_to_object;
 488                 break;
 489         case PSI_T_VOID:
 490                 set->func->handler = psi_to_void;
 491                 break;
 492         case PSI_T_ELLIPSIS:
 493                 if (set->outer.set && set->outer.set->func->type == PSI_T_TO_ARRAY) {
 494                         set->func->handler = psi_to_recursive;
 495                         set->inner = set->outer.set->inner;
 496                         set->count = set->outer.set->count;
 497                         break;
 498                 }
 499                 /* no break */
 500         default:
 501                 return 0;
 502         }
 503         return 1;
 504 }
 505 static inline void decl_var_arg_v(decl_args *args, va_list argp) {
 506         int argc;
 507         decl_arg **argv;
 508
 509         memset(args, 0, sizeof(*args));
 510
 511         while ((argc = va_arg(argp, int))) {
 512                 argv = va_arg(argp, decl_arg **);
 513                 while (argc--) {
 514                         add_decl_arg(args, *argv++);
 515                 }
 516         }
 517 }
 518 static inline int validate_set_value_ex(PSI_Data *data, set_value *set, decl_arg *ref, decl_args *ref_list) {
 519         size_t i;
 520         decl_type *ref_type;
 521         decl_var *set_var = set->vars->vars[0];
 522
 523         if (!validate_set_value_handler(set)) {
 524                 data->error(set->func->token, PSI_WARNING, "Invalid cast '%s' in `set` statement", set->func->name);
 525                 return 0;
 526         }
 527
 528         for (i = 0; i < set->vars->count; ++i) {
 529                 decl_var *svar = set->vars->vars[i];
 530                 if (!svar->arg && !locate_decl_var_arg(svar, ref_list, NULL)) {
 531                         data->error(svar->token, PSI_WARNING, "Unknown variable '%s' in `set` statement", svar->name);
 532                         return 0;
 533                 }
 534         }
 535
 536         if (!ref) {
 537                 ref = set_var->arg;
 538         }
 539         ref_type = real_decl_type(ref->type);
 540
 541         if (set->count) {
 542                 int is_to_array = (set->func->type == PSI_T_TO_ARRAY);
 543                 int is_pointer_to_struct = (ref_type->type == PSI_T_STRUCT && ref->var->pointer_level);
 544
 545                 if (!is_to_array && !is_pointer_to_struct) {
 546                         data->error(set->func->token, E_WARNING, "Inner `set` statement casts only work with "
 547                                         "to_array() casts on structs or pointers: %s(%s...", set->func->name, set->vars->vars[0]->name);
 548                         return 0;
 549                 }
 550         }
 551         if (set->num) {
 552                 if (!validate_num_exp(data, set->num, ref_list, ref, NULL)) {
 553                         return 0;
 554                 }
 555         }
 556
 557         if (ref_type->type == PSI_T_STRUCT) {
 558                 /* to_array(struct, to_...) */
 559                 if (!set->outer.set || set->outer.set->inner != set->inner) {
 560                         for (i = 0; i < set->count; ++i) {
 561                                 decl_var *sub_var = set->inner[i]->vars->vars[0];
 562                                 decl_arg *sub_ref = locate_struct_member(ref_type->strct, sub_var);
 563
 564                                 if (sub_ref) {
 565                                         if (!validate_set_value_ex(data, set->inner[i], sub_ref, ref_type->strct->args)) {
 566                                                 return 0;
 567                                         }
 568                                 }
 569                         }
 570                 }
 571         } else if (set->count == 1) {
 572                 /* to_array(ptr, to_string(*ptr)) */
 573                 decl_var *sub_var = set->inner[0]->vars->vars[0];
 574                 decl_arg *sub_ref = locate_decl_var_arg(sub_var, ref_list, ref);
 575
 576                 if (sub_ref) {
 577                         if (strcmp(sub_var->name, set_var->name)) {
 578                                 data->error(sub_var->token, E_WARNING, "Inner `set` statement casts on pointers must reference the same variable");
 579                                 return 0;
 580                         }
 581                         if (!validate_set_value_ex(data, set->inner[0], sub_ref, ref_list)) {
 582                                 return 0;
 583                         }
 584                 }
 585         } else if (set->count > 1) {
 586                 data->error(set->func->token, E_WARNING, "Inner `set` statement casts on pointers may only occur once");
 587                 return 0;
 588         }
 589
 590         return 1;
 591 }
 592 static inline int validate_set_value(PSI_Data *data, set_value *set, ...) {
 593         va_list argp;
 594         decl_args args = {0};
 595         int check;
 596
 597         va_start(argp, set);
 598         decl_var_arg_v(&args, argp);
 599         va_end(argp);
 600
 601         check = validate_set_value_ex(data, set, NULL, &args);
 602         if (args.args) {
 603                 free(args.args);
 604         }
 605         return check;
 606 }
 607 static inline decl *locate_impl_decl(decls *decls, return_stmt *ret) {
 608         if (decls) {
 609                 size_t i;
 610
 611                 for (i = 0; i < decls->count; ++i) {
 612                         if (!strcmp(decls->list[i]->func->var->name, ret->set->vars->vars[0]->name)) {
 613                                 ret->decl = decls->list[i]->func;
 614                                 return decls->list[i];
 615                         }
 616                 }
 617         }
 618
 619         return NULL;
 620 }
 621 static inline int validate_impl_ret_stmt(PSI_Data *data, impl *impl) {
 622         return_stmt *ret;
 623
 624         /* we must have exactly one ret stmt delcaring the native func to call */
 625         /* and which type cast to apply */
 626         if (impl->stmts->ret.count != 1) {
 627                 if (impl->stmts->ret.count > 1) {
 628                         data->error(impl->stmts->ret.list[1]->token, PSI_WARNING,
 629                                         "Too many `return` statements for implmentation %s;"
 630                                         " found %zu, exactly one is needed",
 631                                         impl->func->name, impl->stmts->ret.count);
 632                 } else {
 633                         data->error(impl->func->token, PSI_WARNING,
 634                                         "Missing `return` statement for implementation %s",
 635                                         impl->func->name);
 636                 }
 637                 return 0;
 638         }
 639
 640         ret = impl->stmts->ret.list[0];
 641
 642         if (!(impl->decl = locate_impl_decl(data->decls, ret))) {
 643                 data->error(ret->token, PSI_WARNING,
 644                                 "Missing declaration '%s' for `return` statment for implementation %s",
 645                                 ret->set->vars->vars[0]->name, impl->func->name);
 646                 return 0;
 647         }
 648
 649         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)) {
 650                 return 0;
 651         }
 652
 653         impl->decl->impl = impl;
 654
 655         return 1;
 656 }
 657
 658 static inline int validate_impl_let_stmts(PSI_Data *data, impl *impl) {
 659         size_t i, j;
 660         /* we can have multiple let stmts */
 661
 662         /* check that we have a decl arg for every let stmt */
 663         for (i = 0; i < impl->stmts->let.count; ++i) {
 664                 let_stmt *let = impl->stmts->let.list[i];
 665                 decl_var *let_var;
 666                 int check = 0;
 667
 668                 if (let->val && let->val->kind == PSI_LET_TMP) {
 669                         let_var = let->val->data.var;
 670                 } else {
 671                         let_var = let->var;
 672                 }
 673
 674                 if (!locate_decl_var_arg(let_var, impl->decl->args, impl->decl->func)) {
 675                         data->error(let_var->token, PSI_WARNING, "Unknown variable '%s' in `let` statement"
 676                                         " of implementation '%s'", let_var->name, impl->func->name);
 677                         return 0;
 678                 }
 679
 680                 switch (let->val->kind) {
 681                 case PSI_LET_NULL:
 682                         break;
 683                 case PSI_LET_TMP:
 684                         /* e.g. let bar = &strval($bar); // decl_arg(char **bar) */
 685                         /* e.g. let foo = *bar;  */
 686                         let->var->pointer_level = let->val->data.var->pointer_level;
 687                         let->var->arg = init_decl_arg(
 688                                         init_decl_type(
 689                                                         real_decl_type(let->val->data.var->arg->type)->type,
 690                                                         real_decl_type(let->val->data.var->arg->type)->name),
 691                                         init_decl_var(
 692                                                         let->var->name,
 693                                                         let->var->pointer_level,
 694                                                         let->var->array_size));
 695                         break;
 696                 case PSI_LET_NUMEXP:
 697                         if (!validate_num_exp(data, let->val->data.num, impl->decl->args, impl->decl->func, NULL)) {
 698                                 return 0;
 699                         }
 700                         break;
 701                 case PSI_LET_CALLOC:
 702                         if (!validate_num_exp(data, let->val->data.alloc->nmemb, impl->decl->args, impl->decl->func, NULL)) {
 703                                 return 0;
 704                         }
 705                         if (!validate_num_exp(data, let->val->data.alloc->size, impl->decl->args, impl->decl->func, NULL)) {
 706                                 return 0;
 707                         }
 708                         break;
 709                 case PSI_LET_FUNC:
 710                         if (impl->func->args) {
 711                                 for (j = 0; j < impl->func->args->count; ++j) {
 712                                         impl_arg *iarg = impl->func->args->args[j];
 713
 714                                         if (!strcmp(let->val->data.func->var->name, iarg->var->name)) {
 715                                                 let->val->data.func->arg = iarg;
 716                                                 check = 1;
 717                                                 break;
 718                                         }
 719                                 }
 720                         }
 721                         if (!check) {
 722                                 data->error(let->var->token, PSI_WARNING, "Unknown value '$%s' of `let` statement"
 723                                                 " for variable '%s' of implementation '%s'",
 724                                                 let->val->data.func->var->name, let->var->name, impl->func->name);
 725                                 return 0;
 726                         }
 727                         break;
 728                 }
 729         }
 730
 731         /* check that we have a let stmt for every decl arg */
 732         if (impl->decl->args) for (i = 0; i < impl->decl->args->count; ++i) {
 733                 decl_arg *darg = impl->decl->args->args[i];
 734                 int check = 0;
 735
 736                 for (j = 0; j < impl->stmts->let.count; ++j) {
 737                         let_stmt *let = impl->stmts->let.list[j];
 738
 739                         if (!strcmp(let->var->name, darg->var->name)) {
 740                                 darg->let = let;
 741                                 check = 1;
 742                                 break;
 743                         }
 744                 }
 745                 if (!check) {
 746                         data->error(impl->func->token, PSI_WARNING,
 747                                         "Missing `let` statement for arg '%s %.*s%s'"
 748                                         " of declaration '%s' for implementation '%s'",
 749                                         darg->type->name, (int) darg->var->pointer_level, "*****",
 750                                         darg->var->name, impl->decl->func->var->name, impl->func->name);
 751                         return 0;
 752                 }
 753         }
 754
 755         return 1;
 756 }
 757 static inline int validate_impl_set_stmts(PSI_Data *data, impl *impl) {
 758         size_t i, j, k;
 759         /* we can have any count of set stmts; processing out vars */
 760         /* check that set stmts reference known variables */
 761         for (i = 0; i < impl->stmts->set.count; ++i) {
 762                 set_stmt *set = impl->stmts->set.list[i];
 763                 int check = 0;
 764
 765                 if (impl->func->args) for (j = 0; j < impl->func->args->count; ++j) {
 766                         impl_arg *iarg = impl->func->args->args[j];
 767
 768                         if (!strcmp(set->var->name, iarg->var->name)) {
 769                                 set->arg = iarg;
 770                                 check = 1;
 771                                 break;
 772                         }
 773                 }
 774                 if (!check) {
 775                         data->error(set->var->token, PSI_WARNING, "Unknown variable '$%s' of `set` statement"
 776                                         " of implementation '%s'",
 777                                         set->var->name, impl->func->name);
 778                         return 0;
 779                 }
 780
 781                 for (j = 0; j < set->val->vars->count; ++j) {
 782                         decl_var *set_var = set->val->vars->vars[j];
 783
 784                         check = 0;
 785                         if (impl->decl->args) {
 786                                 for (k = 0; k < impl->decl->args->count; ++k) {
 787                                         decl_arg *set_arg = impl->decl->args->args[k];
 788
 789                                         if (!strcmp(set_var->name, set_arg->var->name)) {
 790                                                 check = 1;
 791                                                 set_var->arg = set_arg;
 792                                                 if (!validate_set_value(data, set->val, 1, &set_arg, 1, &impl->decl->func, impl->decl->args->count, impl->decl->args->args, 0)) {
 793                                                         return 0;
 794                                                 }
 795                                                 break;
 796                                         }
 797                                 }
 798                         }
 799                         if (!check) {
 800                                 for (k = 0; k < impl->stmts->let.count; ++k) {
 801                                         let_stmt *let = impl->stmts->let.list[k];
 802
 803                                         /* check temp vars */
 804                                         if (let->val && let->val->kind == PSI_LET_TMP) {
 805                                                 if (!strcmp(set_var->name, let->var->name)) {
 806                                                         check = 1;
 807                                                         set_var->arg = let->var->arg;
 808                                                         if (!validate_set_value(data, set->val, 1, &set_var->arg, 1, &impl->decl->func, impl->decl->args->count, impl->decl->args->args, 0)) {
 809                                                                 return 0;
 810                                                         }
 811                                                         break;
 812                                                 }
 813                                         }
 814                                 }
 815                         }
 816
 817                         if (!check) {
 818                                 data->error(set_var->token, PSI_WARNING, "Unknown value '%s' of `set` statement"
 819                                                 " for variable '$%s' of implementation '%s'",
 820                                                 set_var->name, set->arg->var->name, impl->func->name);
 821                                 return 0;
 822                         }
 823                 }
 824         }
 825         return 1;
 826 }
 827 static inline decl *locate_free_decl(decls *decls, free_call *f) {
 828         if (decls)  {
 829                 size_t i;
 830
 831                 for (i = 0; i < decls->count; ++i) {
 832                         if (!strcmp(decls->list[i]->func->var->name, f->func)) {
 833                                 f->decl = decls->list[i];
 834                                 return decls->list[i];
 835                         }
 836                 }
 837         }
 838
 839         return NULL;
 840 }
 841 static inline int validate_impl_free_stmts(PSI_Data *data, impl *impl) {
 842         size_t i, j, k, l;
 843         /* we can have any count of free stmts; freeing any out vars */
 844         for (i = 0; i < impl->stmts->fre.count; ++i) {
 845                 free_stmt *fre = impl->stmts->fre.list[i];
 846
 847                 for (j = 0; j < fre->calls->count; ++j) {
 848                         free_call *free_call = fre->calls->list[j];
 849
 850                         /* first find the decl of the free func */
 851                         if (!locate_free_decl(data->decls, free_call)) {
 852                                 data->error(free_call->token, PSI_WARNING,
 853                                                 "Missing declaration '%s' in `free` statement"
 854                                                 " of implementation '%s'",
 855                                                 free_call->func, impl->func->name);
 856                                 return 0;
 857                         }
 858
 859
 860
 861                         /* now check for known vars */
 862                         for (l = 0; l < free_call->vars->count; ++l) {
 863                                 int check = 0;
 864                                 decl_var *free_var = free_call->vars->vars[l];
 865
 866                                 if (!strcmp(free_var->name, impl->decl->func->var->name)) {
 867                                         check = 1;
 868                                         free_var->arg = impl->decl->func;
 869                                 } else if (impl->decl->args) {
 870                                         for (k = 0; k < impl->decl->args->count; ++k) {
 871                                                 decl_arg *free_arg = impl->decl->args->args[k];
 872
 873                                                 if (!strcmp(free_var->name, free_arg->var->name)) {
 874                                                         check = 1;
 875                                                         free_var->arg = free_arg;
 876                                                         break;
 877                                                 }
 878                                         }
 879                                 }
 880
 881                                 if (!check) {
 882                                         data->error(free_var->token, PSI_WARNING,
 883                                                         "Unknown variable '%s' of `free` statement"
 884                                                         " of implementation '%s'",
 885                                                         free_var->name, impl->func->name);
 886                                         return 0;
 887                                 }
 888                         }
 889                 }
 890         }
 891         return 1;
 892 }
 893 static inline int validate_impl_stmts(PSI_Data *data, impl *impl) {
 894         if (!impl->stmts) {
 895                 data->error(impl->func->token, PSI_WARNING,
 896                                 "Missing body for implementation %s!",
 897                                 impl->func->name);
 898                 return 0;
 899         }
 900
 901         if (!validate_impl_ret_stmt(data, impl)) {
 902                 return 0;
 903         }
 904
 905         if (!validate_impl_let_stmts(data, impl)) {
 906                 return 0;
 907         }
 908         if (!validate_impl_set_stmts(data, impl)) {
 909                 return 0;
 910         }
 911         if (!validate_impl_free_stmts(data, impl)) {
 912                 return 0;
 913         }
 914
 915         return 1;
 916 }
 917
 918 static inline int validate_impl_args(PSI_Data *data, impl *impl) {
 919         int def = 0;
 920         size_t i;
 921
 922         for (i = 0; i < impl->func->args->count; ++i) {
 923                 impl_arg *iarg = impl->func->args->args[i];
 924
 925                 if (iarg->def) {
 926                         def = 1;
 927                 } else if (def) {
 928                         data->error(impl->func->token, PSI_WARNING,
 929                                         "Non-optional argument %zu '$%s' of implementation '%s'"
 930                                         " follows optional argument",
 931                                         i+1, iarg->var->name, impl->func->name);
 932                         return 0;
 933                 }
 934         }
 935
 936         return 1;
 937 }
 938 static inline int validate_impl(PSI_Data *data, impl *impl) {
 939         if (!validate_impl_args(data, impl)) {
 940                 return 0;
 941         }
 942         return validate_impl_stmts(data, impl);
 943 }
 944
 945
 946 int PSI_ContextValidate(PSI_Context *C, PSI_Parser *P)
 947 {
 948         PSI_Data *D;
 949         void *dlopened = NULL;
 950         size_t count = C->count++;
 951
 952         C->data = realloc(C->data, C->count * sizeof(*C->data));
 953         D = PSI_DataExchange(&C->data[count], PSI_DATA(P));
 954
 955         if (D->defs) {
 956                 size_t i;
 957
 958                 for (i = 0; i < D->defs->count; ++i) {
 959                         if (validate_decl_typedef(PSI_DATA(C), D->defs->list[i])) {
 960                                 C->defs = add_decl_typedef(C->defs, D->defs->list[i]);
 961                         }
 962                 }
 963         }
 964         if (D->structs) {
 965                 size_t i;
 966
 967                 for (i = 0; i < D->structs->count; ++i) {
 968                         if (validate_decl_struct(PSI_DATA(C), D->structs->list[i])) {
 969                                 C->structs = add_decl_struct(C->structs, D->structs->list[i]);
 970                         }
 971                 }
 972         }
 973         if (D->enums) {
 974                 size_t i;
 975
 976                 for (i = 0; i < D->enums->count; ++i) {
 977                         if (validate_decl_enum(PSI_DATA(C), D->enums->list[i])) {
 978                                 C->enums = add_decl_enum(C->enums, D->enums->list[i]);
 979                         }
 980                 }
 981         }
 982         if (D->consts) {
 983                 size_t i;
 984
 985                 for (i = 0; i < D->consts->count; ++i) {
 986                         if (validate_constant(PSI_DATA(C), D->consts->list[i])) {
 987                                 C->consts = add_constant(C->consts, D->consts->list[i]);
 988                         }
 989                 }
 990         }
 991
 992         if (!validate_lib(D, &dlopened)) {
 993                 return 0;
 994         }
 995
 996         add_decl_lib(&C->psi.libs, dlopened);
 997
 998         if (D->decls) {
 999                 size_t i;
1000
1001                 for (i = 0; i < D->decls->count; ++i) {
1002                         if (validate_decl(PSI_DATA(C), dlopened, D->decls->list[i])) {
1003                                 C->decls = add_decl(C->decls, D->decls->list[i]);
1004                         }
1005                 }
1006         }
1007         if (D->impls) {
1008                 size_t i;
1009
1010                 for (i = 0; i < D->impls->count; ++i) {
1011                         if (validate_impl(PSI_DATA(C), D->impls->list[i])) {
1012                                 C->impls = add_impl(C->impls, D->impls->list[i]);
1013                         }
1014                 }
1015         }
1016
1017         return 1;
1018 }
1019
1020 int PSI_ContextValidateData(PSI_Data *dest, PSI_Data *source)
1021 {
1022         size_t i;
1023         int errors = 0;
1024
1025         if (source->defs) for (i = 0; i < source->defs->count; ++i) {
1026                 decl_typedef *def = source->defs->list[i];
1027
1028                 if (validate_decl_typedef(source, def)) {
1029                         if (dest) {
1030                                 dest->defs = add_decl_typedef(dest->defs, def);
1031                         }
1032                 } else {
1033                         ++errors;
1034                 }
1035         }
1036
1037         if (source->consts) for (i = 0; i < source->consts->count; ++i) {
1038                 constant *constant = source->consts->list[i];
1039
1040                 if (validate_constant(source, constant)) {
1041                         if (dest) {
1042                                 dest->consts = add_constant(dest->consts, constant);
1043                         }
1044                 } else {
1045                         ++errors;
1046                 }
1047         }
1048
1049         if (source->structs) for (i = 0; i < source->structs->count; ++i) {
1050                 decl_struct *dstruct = source->structs->list[i];
1051
1052                 if (validate_decl_struct(source, dstruct)) {
1053                         if (dest) {
1054                                 dest->structs = add_decl_struct(dest->structs, dstruct);
1055                         }
1056                 } else {
1057                         ++errors;
1058                 }
1059         }
1060
1061         if (source->enums) for (i = 0; i < source->enums->count; ++i) {
1062                 decl_enum *denum = source->enums->list[i];
1063
1064                 if (validate_decl_enum(source, denum)) {
1065                         if (dest) {
1066                                 dest->enums = add_decl_enum(dest->enums, denum);
1067                         }
1068                 } else {
1069                         ++errors;
1070                 }
1071         }
1072
1073         if (source->decls) for (i = 0; i < source->decls->count; ++i) {
1074                 decl *decl = source->decls->list[i];
1075
1076                 if (validate_decl(source, NULL, decl)) {
1077                         if (dest) {
1078                                 dest->decls = add_decl(dest->decls, decl);
1079                         }
1080                 } else {
1081                         ++errors;
1082                 }
1083         }
1084
1085         if (source->impls) for (i = 0; i < source->impls->count; ++i) {
1086                 impl *impl = source->impls->list[i];
1087
1088                 if (validate_impl(source, impl)) {
1089                         if (dest) {
1090                                 dest->impls = add_impl(dest->impls, impl);
1091                         }
1092                 } else {
1093                         ++errors;
1094                 }
1095         }
1096
1097         return errors;
1098 }