git.m6w6.name Git - m6w6/ext-psi/blob - src/parser.h

   1 #ifndef _PSI_PARSER_H
   2 #define _PSI_PARSER_H
   3
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <stdarg.h>
   7 #include <string.h>
   8
   9 #include <Zend/zend_types.h>
  10
  11 #include "parser_proc.h"
  12
  13 #define BSIZE 256
  14
  15 #define PSI_T_POINTER PSI_T_ASTERISK
  16 typedef int token_t;
  17
  18 /* in php_psi.h */
  19 size_t psi_t_alignment(token_t);
  20 size_t psi_t_size(token_t);
  21
  22 typedef struct PSI_Token {
  23         token_t type;
  24         size_t size, line, col;
  25         char *text, *file;
  26         char buf[1];
  27 } PSI_Token;
  28
  29 typedef union impl_val {
  30         char cval;
  31         int8_t i8;
  32         uint8_t u8;
  33         short sval;
  34         int16_t i16;
  35         uint16_t u16;
  36         int ival;
  37         int32_t i32;
  38         uint32_t u32;
  39         long lval;
  40         int64_t i64;
  41         uint64_t u64;
  42         float fval;
  43         double dval;
  44         union {
  45                 zend_bool bval;
  46                 zend_long lval;
  47                 zend_string *str;
  48         } zend;
  49         void *ptr;
  50         uint8_t _dbg[sizeof(void *)];
  51 } impl_val;
  52
  53 typedef struct decl_type {
  54         PSI_Token *token;
  55         char *name;
  56         token_t type;
  57         struct decl_type *real;
  58         struct decl_struct *strct;
  59 } decl_type;
  60
  61 static inline decl_type *init_decl_type(token_t type, const char *name) {
  62         decl_type *t = calloc(1, sizeof(*t));
  63         t->type = type;
  64         t->name = strdup(name);
  65         return t;
  66 }
  67
  68 static inline decl_type *real_decl_type(decl_type *type) {
  69         while (type->real) {
  70                 type = type->real;
  71         }
  72         return type;
  73 }
  74
  75 static inline void free_decl_type(decl_type *type) {
  76         free(type->name);
  77         free(type);
  78 }
  79
  80 typedef struct decl_typedef {
  81         char *alias;
  82         decl_type *type;
  83 } decl_typedef;
  84
  85 static inline decl_typedef *init_decl_typedef(const char *name, decl_type *type) {
  86         decl_typedef *t = calloc(1, sizeof(*t));
  87         t->alias = strdup(name);
  88         t->type = type;
  89         return t;
  90 }
  91
  92 static inline void free_decl_typedef(decl_typedef *t) {
  93         free(t->alias);
  94         free_decl_type(t->type);
  95         free(t);
  96 }
  97
  98 typedef struct decl_typedefs {
  99         size_t count;
 100         decl_typedef **list;
 101 } decl_typedefs;
 102
 103 static inline decl_typedefs *add_decl_typedef(decl_typedefs *defs, decl_typedef *def) {
 104         if (!defs) {
 105                 defs = calloc(1, sizeof(*defs));
 106         }
 107         defs->list = realloc(defs->list, ++defs->count * sizeof(*defs->list));
 108         defs->list[defs->count-1] = def;
 109         return defs;
 110 }
 111
 112 static void free_decl_typedefs(decl_typedefs *defs) {
 113         size_t i;
 114
 115         for (i = 0; i < defs->count; ++i) {
 116                 free_decl_typedef(defs->list[i]);
 117         }
 118         free(defs->list);
 119         free(defs);
 120 }
 121
 122 typedef struct decl_var {
 123         char *name;
 124         unsigned pointer_level;
 125         unsigned array_size;
 126         struct decl_arg *arg;
 127 } decl_var;
 128
 129 static inline decl_var *init_decl_var(const char *name, unsigned pl, unsigned as) {
 130         decl_var *v = calloc(1, sizeof(*v));
 131         v->name = (char *) strdup((const char *) name);
 132         v->pointer_level = pl;
 133         v->array_size = as;
 134         return v;
 135 }
 136
 137 static inline void free_decl_var(decl_var *var) {
 138         free(var->name);
 139         free(var);
 140 }
 141
 142 typedef struct decl_struct_layout {
 143         size_t pos;
 144         size_t len;
 145 } decl_struct_layout;
 146
 147 static inline decl_struct_layout *init_decl_struct_layout(size_t pos, size_t len) {
 148         decl_struct_layout *l = calloc(1, sizeof(*l));
 149
 150         l->pos = pos;
 151         l->len = len;
 152         return l;
 153 }
 154
 155 static inline void free_decl_struct_layout(decl_struct_layout *l) {
 156         free(l);
 157 }
 158
 159 typedef struct decl_arg {
 160         decl_type *type;
 161         decl_var *var;
 162         decl_struct_layout *layout;
 163         struct let_stmt *let;
 164         impl_val val;
 165         void *ptr;
 166         void *mem;
 167 } decl_arg;
 168
 169 static inline decl_arg *init_decl_arg(decl_type *type, decl_var *var) {
 170         decl_arg *arg = calloc(1, sizeof(*arg));
 171         arg->type = type;
 172         arg->var = var;
 173         var->arg = arg;
 174         arg->ptr = &arg->val;
 175         return arg;
 176 }
 177
 178 static inline void free_decl_arg(decl_arg *arg) {
 179         free_decl_type(arg->type);
 180         free_decl_var(arg->var);
 181         if (arg->layout) {
 182                 free_decl_struct_layout(arg->layout);
 183         }
 184         free(arg);
 185 }
 186
 187 typedef struct decl_vars {
 188         decl_var **vars;
 189         size_t count;
 190 } decl_vars;
 191
 192 static inline decl_vars *init_decl_vars(decl_var *var) {
 193         decl_vars *vars = calloc(1, sizeof(*vars));
 194         if (var) {
 195                 vars->count = 1;
 196                 vars->vars = calloc(1, sizeof(*vars->vars));
 197                 vars->vars[0] = var;
 198         }
 199         return vars;
 200 }
 201
 202 static inline decl_vars *add_decl_var(decl_vars *vars, decl_var *var) {
 203         vars->vars = realloc(vars->vars, ++vars->count * sizeof(*vars->vars));
 204         vars->vars[vars->count-1] = var;
 205         return vars;
 206 }
 207
 208 static inline void free_decl_vars(decl_vars *vars) {
 209         size_t i;
 210
 211         for (i = 0; i < vars->count; ++i) {
 212                 free_decl_var(vars->vars[i]);
 213         }
 214         free(vars->vars);
 215         free(vars);
 216 }
 217
 218 typedef struct decl_args {
 219         decl_arg **args;
 220         size_t count;
 221         unsigned varargs:1;
 222 } decl_args;
 223
 224 static inline decl_args *init_decl_args(decl_arg *arg) {
 225         decl_args *args = calloc(1, sizeof(*args));
 226         if (arg) {
 227                 args->count = 1;
 228                 args->args = calloc(1, sizeof(*args->args));
 229                 args->args[0] = arg;
 230         }
 231         return args;
 232 }
 233
 234 static inline decl_args *add_decl_arg(decl_args *args, decl_arg *arg) {
 235         args->args = realloc(args->args, ++args->count * sizeof(*args->args));
 236         args->args[args->count-1] = arg;
 237         return args;
 238 }
 239
 240 static inline void free_decl_args(decl_args *args) {
 241         size_t i;
 242
 243         for (i = 0; i < args->count; ++i) {
 244                 free_decl_arg(args->args[i]);
 245         }
 246         free(args->args);
 247         free(args);
 248 }
 249
 250 typedef struct decl_abi {
 251         char *convention;
 252 } decl_abi;
 253
 254 static inline decl_abi *init_decl_abi(const char *convention) {
 255         decl_abi *abi = calloc(1, sizeof(*abi));
 256         abi->convention = strdup(convention);
 257         return abi;
 258 }
 259
 260 static inline void free_decl_abi(decl_abi *abi) {
 261         free(abi->convention);
 262         free(abi);
 263 }
 264
 265 typedef struct decl_callinfo {
 266         void *sym;
 267         void *info;
 268         size_t argc;
 269         void **args;
 270         void *rval;
 271 } decl_callinfo;
 272
 273 typedef struct decl {
 274         decl_abi *abi;
 275         decl_arg *func;
 276         decl_args *args;
 277         struct impl *impl;
 278         decl_callinfo call;
 279 } decl;
 280
 281 static inline decl* init_decl(decl_abi *abi, decl_arg *func, decl_args *args) {
 282         decl *d = calloc(1, sizeof(*d));
 283         d->abi = abi;
 284         d->func = func;
 285         d->args = args;
 286         return d;
 287 }
 288
 289 static inline void free_decl(decl *d) {
 290         free_decl_abi(d->abi);
 291         free_decl_arg(d->func);
 292         if (d->args) {
 293                 free_decl_args(d->args);
 294         }
 295         free(d);
 296 }
 297
 298 typedef struct decls {
 299         size_t count;
 300         decl **list;
 301 } decls;
 302
 303 static inline decls *add_decl(decls *decls, decl *decl) {
 304         if (!decls) {
 305                 decls = calloc(1, sizeof(*decls));
 306         }
 307         decls->list = realloc(decls->list, ++decls->count * sizeof(*decls->list));
 308         decls->list[decls->count-1] = decl;
 309         return decls;
 310 }
 311
 312 static inline void free_decls(decls *decls) {
 313         size_t i;
 314
 315         for (i = 0; i < decls->count; ++i) {
 316                 free_decl(decls->list[i]);
 317         }
 318         free(decls->list);
 319         free(decls);
 320 }
 321
 322 typedef struct decl_struct {
 323         char *name;
 324         decl_args *args;
 325         size_t size;
 326 } decl_struct;
 327
 328 static inline decl_struct *init_decl_struct(const char *name, decl_args *args) {
 329         decl_struct *s = calloc(1, sizeof(*s));
 330         s->name = strdup(name);
 331         s->args = args;
 332         return s;
 333 }
 334
 335 static inline void free_decl_struct(decl_struct *s) {
 336         if (s->args) {
 337                 free_decl_args(s->args);
 338         }
 339         free(s->name);
 340         free(s);
 341 }
 342
 343 typedef struct decl_structs {
 344         size_t count;
 345         decl_struct **list;
 346 } decl_structs;
 347
 348 static inline decl_structs *add_decl_struct(decl_structs *ss, decl_struct *s) {
 349         if (!ss) {
 350                 ss = calloc(1, sizeof(*ss));
 351         }
 352         ss->list = realloc(ss->list, ++ss->count * sizeof(*ss->list));
 353         ss->list[ss->count-1] = s;
 354         return ss;
 355 }
 356
 357 static inline void free_decl_structs(decl_structs *ss) {
 358         size_t i;
 359
 360         for (i = 0; i < ss->count; ++i) {
 361                 free_decl_struct(ss->list[i]);
 362         }
 363         free(ss->list);
 364         free(ss);
 365 }
 366
 367 typedef struct impl_type {
 368         char *name;
 369         token_t type;
 370 } impl_type;
 371
 372 static inline impl_type *init_impl_type(token_t type, const char *name) {
 373         impl_type *t = calloc(1, sizeof(*t));
 374
 375         t->type = type;
 376         t->name = strdup(name);
 377         return t;
 378 }
 379
 380 static inline void free_impl_type(impl_type *type) {
 381         free(type->name);
 382         free(type);
 383 }
 384
 385 typedef struct impl_var {
 386         char *name;
 387         unsigned reference:1;
 388 } impl_var;
 389
 390 static inline impl_var *init_impl_var(const char *name, int is_reference) {
 391         impl_var *var = calloc(1, sizeof(*var));
 392         var->name = strdup(name);
 393         var->reference = is_reference;
 394         return var;
 395 }
 396
 397 static inline void free_impl_var(impl_var *var) {
 398         free(var->name);
 399         free(var);
 400 }
 401
 402 typedef struct impl_def_val {
 403         token_t type;
 404         char *text;
 405 } impl_def_val;
 406
 407 static inline impl_def_val *init_impl_def_val(token_t t, const char *text) {
 408         impl_def_val *def = calloc(1, sizeof(*def));
 409         def->type = t;
 410         def->text = strdup(text);
 411         return def;
 412 }
 413
 414 static inline void free_impl_def_val(impl_def_val *def) {
 415         free(def->text);
 416         free(def);
 417 }
 418
 419 typedef struct const_type {
 420         token_t type;
 421         char *name;
 422 } const_type;
 423
 424 static inline const_type *init_const_type(token_t type, const char *name) {
 425         const_type *ct = calloc(1, sizeof(*ct));
 426         ct->type = type;
 427         ct->name = strdup(name);
 428         return ct;
 429 }
 430
 431 static inline void free_const_type(const_type *type) {
 432         free(type->name);
 433         free(type);
 434 }
 435
 436 typedef struct constant {
 437         const_type *type;
 438         char *name;
 439         impl_def_val *val;
 440 } constant;
 441
 442 static inline constant *init_constant(const_type *type, const char *name, impl_def_val *val) {
 443         constant *c = calloc(1, sizeof(*c));
 444         c->type = type;
 445         c->name = strdup(name);
 446         c->val = val;
 447         return c;
 448 }
 449
 450 static inline void free_constant(constant *constant) {
 451         free_const_type(constant->type);
 452         free(constant->name);
 453         free_impl_def_val(constant->val);
 454         free(constant);
 455 }
 456
 457 typedef struct constants {
 458         size_t count;
 459         constant **list;
 460 } constants;
 461
 462 static inline constants *add_constant(constants *constants, constant *constant) {
 463         if (!constants) {
 464                 constants = calloc(1, sizeof(*constants));
 465         }
 466         constants->list = realloc(constants->list, ++constants->count * sizeof(*constants->list));
 467         constants->list[constants->count-1] = constant;
 468         return constants;
 469 }
 470
 471 static inline void free_constants(constants *c) {
 472         size_t i;
 473
 474         for (i = 0; i < c->count; ++i) {
 475                 free_constant(c->list[i]);
 476         }
 477         free(c->list);
 478         free(c);
 479 }
 480
 481 typedef struct impl_arg {
 482         impl_type *type;
 483         impl_var *var;
 484         impl_def_val *def;
 485         impl_val val;
 486         zval *_zv;
 487 } impl_arg;
 488
 489 static inline impl_arg *init_impl_arg(impl_type *type, impl_var *var, impl_def_val *def) {
 490         impl_arg *arg = calloc(1, sizeof(*arg));
 491         arg->type = type;
 492         arg->var = var;
 493         arg->def = def;
 494         return arg;
 495 }
 496
 497 static inline void free_impl_arg(impl_arg *arg) {
 498         free_impl_type(arg->type);
 499         free_impl_var(arg->var);
 500         if (arg->def) {
 501                 free_impl_def_val(arg->def);
 502         }
 503         free(arg);
 504 }
 505
 506 typedef struct impl_args {
 507         impl_arg **args;
 508         size_t count;
 509         impl_arg *vararg;
 510 } impl_args;
 511
 512 static inline impl_args *init_impl_args(impl_arg *arg) {
 513         impl_args *args = calloc(1, sizeof(*args));
 514         if (arg) {
 515                 args->count = 1;
 516                 args->args = calloc(1, sizeof(*args->args));
 517                 args->args[0] = arg;
 518         }
 519         return args;
 520 }
 521
 522 static inline impl_args *add_impl_arg(impl_args *args, impl_arg *arg) {
 523         args->args = realloc(args->args, ++args->count * sizeof(*args->args));
 524         args->args[args->count-1] = arg;
 525         return args;
 526 }
 527
 528 static inline void free_impl_args(impl_args *args) {
 529         size_t i;
 530
 531         for (i = 0; i < args->count; ++i) {
 532                 free_impl_arg(args->args[i]);
 533         }
 534         free(args->args);
 535         free(args);
 536 }
 537
 538 typedef struct impl_func {
 539         char *name;
 540         impl_args *args;
 541         impl_type *return_type;
 542         unsigned return_reference:1;
 543 } impl_func;
 544
 545 static inline impl_func *init_impl_func(char *name, impl_args *args, impl_type *type, int ret_reference) {
 546         impl_func *func = calloc(1, sizeof(*func));
 547         func->name = strdup(name);
 548         func->args = args ? args : init_impl_args(NULL);
 549         func->return_type = type;
 550         func->return_reference = ret_reference;
 551         return func;
 552 }
 553
 554 static inline void free_impl_func(impl_func *f) {
 555         free_impl_type(f->return_type);
 556         free_impl_args(f->args);
 557         free(f->name);
 558         free(f);
 559 }
 560
 561 typedef struct num_exp {
 562         token_t t;
 563         union {
 564                 char *numb;
 565                 constant *cnst;
 566                 decl_var *dvar;
 567         } u;
 568         token_t operator;
 569         int (*calculator)(int t1, impl_val *v1, int t2, impl_val *v2, impl_val *res);
 570         struct num_exp *operand;
 571 } num_exp;
 572
 573 static inline num_exp *init_num_exp(token_t t, void *num) {
 574         num_exp *exp = calloc(1, sizeof(*exp));
 575         switch (exp->t = t) {
 576         case PSI_T_NUMBER:
 577         case PSI_T_NSNAME:
 578                 exp->u.numb = strdup(num);
 579                 break;
 580         case PSI_T_NAME:
 581                 exp->u.dvar = num;
 582                 break;
 583         EMPTY_SWITCH_DEFAULT_CASE();
 584         }
 585         return exp;
 586 }
 587
 588 static inline void free_num_exp(num_exp *exp) {
 589         switch (exp->t) {
 590         case PSI_T_NUMBER:
 591                 free(exp->u.numb);
 592                 break;
 593         case PSI_T_NSNAME:
 594                 break;
 595         case PSI_T_NAME:
 596                 free_decl_var(exp->u.dvar);
 597                 break;
 598         EMPTY_SWITCH_DEFAULT_CASE();
 599         }
 600         if (exp->operand) {
 601                 free_num_exp(exp->operand);
 602         }
 603         free(exp);
 604 }
 605
 606 typedef struct let_calloc {
 607         num_exp *nmemb;
 608         num_exp *size;
 609 } let_calloc;
 610
 611 static inline let_calloc *init_let_calloc(num_exp *nmemb, num_exp *size) {
 612         let_calloc *alloc = calloc(1, sizeof(*alloc));
 613         alloc->nmemb = nmemb;
 614         alloc->size = size;
 615         return alloc;
 616 }
 617
 618 static inline void free_let_calloc(let_calloc *alloc) {
 619         free_num_exp(alloc->nmemb);
 620         free_num_exp(alloc->size);
 621         free(alloc);
 622 }
 623
 624 typedef struct let_func {
 625         token_t type;
 626         char *name;
 627         impl_var *var;
 628         impl_arg *arg;
 629 } let_func;
 630
 631 static inline let_func *init_let_func(token_t type, const char *name, impl_var *var) {
 632         let_func *func = calloc(1, sizeof(*func));
 633         func->type = type;
 634         func->name = strdup(name);
 635         func->var = var;
 636         return func;
 637 }
 638
 639 static inline void free_let_func(let_func *func) {
 640         free_impl_var(func->var);
 641         free(func->name);
 642         free(func);
 643 }
 644
 645 #define PSI_LET_REFERENCE 0x1;
 646 typedef struct let_val {
 647         enum let_val_kind {
 648                 PSI_LET_NULL,
 649                 PSI_LET_NUMEXP,
 650                 PSI_LET_CALLOC,
 651                 PSI_LET_FUNC,
 652                 PSI_LET_TMP,
 653         } kind;
 654         union {
 655                 num_exp *num;
 656                 let_calloc *alloc;
 657                 let_func *func;
 658                 decl_var *var;
 659         } data;
 660         union {
 661                 struct {
 662                         unsigned is_reference:1;
 663                 } one;
 664                 unsigned all;
 665         } flags;
 666 } let_val;
 667
 668 static inline let_val *init_let_val(enum let_val_kind kind, void *data) {
 669         let_val *let = calloc(1, sizeof(*let));
 670         switch (let->kind = kind) {
 671         case PSI_LET_NULL:
 672                 break;
 673         case PSI_LET_NUMEXP:
 674                 let->data.num = data;
 675                 break;
 676         case PSI_LET_CALLOC:
 677                 let->data.alloc = data;
 678                 break;
 679         case PSI_LET_FUNC:
 680                 let->data.func = data;
 681                 break;
 682         case PSI_LET_TMP:
 683                 let->data.var = data;
 684                 break;
 685         EMPTY_SWITCH_DEFAULT_CASE();
 686         }
 687         return let;
 688 }
 689
 690 static inline void free_let_val(let_val *let) {
 691         switch (let->kind) {
 692         case PSI_LET_NULL:
 693                 break;
 694         case PSI_LET_NUMEXP:
 695                 free_num_exp(let->data.num);
 696                 break;
 697         case PSI_LET_CALLOC:
 698                 free_let_calloc(let->data.alloc);
 699                 break;
 700         case PSI_LET_FUNC:
 701                 free_let_func(let->data.func);
 702                 break;
 703         case PSI_LET_TMP:
 704                 free_decl_var(let->data.var);
 705                 break;
 706         EMPTY_SWITCH_DEFAULT_CASE();
 707         }
 708         free(let);
 709 }
 710
 711 typedef struct let_stmt {
 712         decl_var *var;
 713         let_val *val;
 714
 715         void *ptr;
 716 } let_stmt;
 717
 718 static inline let_stmt *init_let_stmt(decl_var *var, let_val *val) {
 719         let_stmt *let = calloc(1, sizeof(*let));
 720         let->var = var;
 721         let->val = val;
 722         return let;
 723 }
 724
 725 static inline void free_let_stmt(let_stmt *stmt) {
 726         if (stmt->val) {
 727                 if (stmt->val->kind == PSI_LET_TMP && stmt->var->arg) {
 728                         free_decl_arg(stmt->var->arg);
 729                 }
 730                 free_let_val(stmt->val);
 731         }
 732         free_decl_var(stmt->var);
 733         free(stmt);
 734 }
 735
 736 struct set_value;
 737
 738 typedef struct set_func {
 739         token_t type;
 740         char *name;
 741         void (*handler)(zval *, struct set_value *set, impl_val *ret_val);
 742 } set_func;
 743
 744 static inline set_func *init_set_func(token_t type, const char *name) {
 745         set_func *func = calloc(1, sizeof(*func));
 746         func->type = type;
 747         func->name = strdup(name);
 748         return func;
 749 }
 750
 751 static inline void free_set_func(set_func *func) {
 752         free(func->name);
 753         free(func);
 754 }
 755
 756 typedef struct set_value {
 757         set_func *func;
 758         decl_vars *vars;
 759         num_exp *num;
 760         struct {
 761                 struct set_value *set;
 762                 impl_val *val;
 763         } outer;
 764         struct set_value **inner;
 765         size_t count;
 766 } set_value;
 767
 768 static inline set_value *init_set_value(set_func *func, decl_vars *vars) {
 769         set_value *val = calloc(1, sizeof(*val));
 770         val->func = func;
 771         val->vars = vars;
 772         return val;
 773 }
 774 static inline set_value *add_inner_set_value(set_value *val, set_value *inner) {
 775         val->inner = realloc(val->inner, ++val->count * sizeof(*val->inner));
 776         val->inner[val->count-1] = inner;
 777         return val;
 778 }
 779
 780 static inline void free_set_value(set_value *val) {
 781         free_set_func(val->func);
 782         free_decl_vars(val->vars);
 783         if (val->inner) {
 784                 size_t i;
 785                 for (i = 0; i < val->count; ++i) {
 786                         free_set_value(val->inner[i]);
 787                 }
 788                 free(val->inner);
 789         }
 790         if (val->num) {
 791                 free_num_exp(val->num);
 792         }
 793         free(val);
 794 }
 795
 796 typedef struct set_stmt {
 797         impl_var *var;
 798         set_value *val;
 799         impl_arg *arg;
 800 } set_stmt;
 801
 802 static inline set_stmt *init_set_stmt(impl_var *var, set_value *val) {
 803         set_stmt *set = calloc(1, sizeof(*set));
 804         set->var = var;
 805         set->val = val;
 806         return set;
 807 }
 808
 809 static inline void free_set_stmt(set_stmt *set) {
 810         free_impl_var(set->var);
 811         free_set_value(set->val);
 812         free(set);
 813 }
 814
 815 typedef struct return_stmt {
 816         set_value *set;
 817         decl_arg *decl;
 818 } return_stmt;
 819
 820 static inline return_stmt *init_return_stmt(set_value *val) {
 821         return_stmt *ret = calloc(1, sizeof(*ret));
 822         ret->set = val;
 823         return ret;
 824 }
 825
 826 static inline void free_return_stmt(return_stmt *ret) {
 827         //free_set_func(ret->func);
 828         //free_decl_var(ret->decl);
 829         free_set_value(ret->set);
 830         free(ret);
 831 }
 832
 833 typedef struct free_call {
 834         char *func;
 835         decl_vars *vars;
 836         decl *decl;
 837 } free_call;
 838
 839 static inline free_call *init_free_call(const char *func, decl_vars *vars) {
 840         free_call *f = calloc(1, sizeof(*f));
 841         f->func = strdup(func);
 842         f->vars = vars;
 843         return f;
 844 }
 845
 846 static inline void free_free_call(free_call *f) {
 847         free(f->func);
 848         free_decl_vars(f->vars);
 849         free(f);
 850 }
 851
 852 typedef struct free_calls {
 853         free_call **list;
 854         size_t count;
 855 } free_calls;
 856
 857 static inline free_calls *init_free_calls(free_call *f) {
 858         free_calls *fcs = calloc(1, sizeof(*fcs));
 859         if (f) {
 860                 fcs->count = 1;
 861                 fcs->list = calloc(1, sizeof(*fcs->list));
 862                 fcs->list[0] = f;
 863         }
 864         return fcs;
 865 }
 866
 867 static inline void free_free_calls(free_calls *fcs) {
 868         size_t i;
 869
 870         for (i = 0; i < fcs->count; ++i) {
 871                 free_free_call(fcs->list[i]);
 872         }
 873         free(fcs->list);
 874         free(fcs);
 875 }
 876
 877 static inline free_calls *add_free_call(free_calls *fcs, free_call *f) {
 878         fcs->list = realloc(fcs->list, ++fcs->count * sizeof(*fcs->list));
 879         fcs->list[fcs->count-1] = f;
 880         return fcs;
 881 }
 882
 883 typedef struct free_stmt {
 884         free_calls *calls;
 885 } free_stmt;
 886
 887 static inline free_stmt *init_free_stmt(free_calls *calls) {
 888         free_stmt *f = calloc(1, sizeof(*f));
 889         f->calls = calls;
 890         return f;
 891 }
 892
 893 static inline void free_free_stmt(free_stmt *f) {
 894         free_free_calls(f->calls);
 895         free(f);
 896 }
 897
 898 typedef struct impl_stmt {
 899         token_t type;
 900         union {
 901                 let_stmt *let;
 902                 set_stmt *set;
 903                 return_stmt *ret;
 904                 free_stmt *fre;
 905                 void *ptr;
 906         } s;
 907 } impl_stmt;
 908
 909 static inline impl_stmt *init_impl_stmt(token_t type, void *ptr) {
 910         impl_stmt *stmt = calloc(1, sizeof(*stmt));
 911         stmt->type = type;
 912         stmt->s.ptr = ptr;
 913         return stmt;
 914 }
 915
 916 static inline void free_impl_stmt(impl_stmt *stmt) {
 917         switch (stmt->type) {
 918         case PSI_T_LET:
 919                 free_let_stmt(stmt->s.let);
 920                 break;
 921         case PSI_T_SET:
 922                 free_set_stmt(stmt->s.set);
 923                 break;
 924         case PSI_T_RETURN:
 925                 free_return_stmt(stmt->s.ret);
 926                 break;
 927         case PSI_T_FREE:
 928                 free_free_stmt(stmt->s.fre);
 929                 break;
 930         }
 931         free(stmt);
 932 }
 933
 934 typedef struct impl_stmts {
 935         struct {
 936                 return_stmt **list;
 937                 size_t count;
 938         } ret;
 939         struct {
 940                 let_stmt **list;
 941                 size_t count;
 942         } let;
 943         struct {
 944                 set_stmt **list;
 945                 size_t count;
 946         } set;
 947         struct {
 948                 free_stmt **list;
 949                 size_t count;
 950         } fre;
 951 } impl_stmts;
 952
 953 static inline void *add_impl_stmt_ex(void *list, size_t count, void *stmt) {
 954         list = realloc(list, count * sizeof(list));
 955         ((void **)list)[count-1] = stmt;
 956         return list;
 957 }
 958
 959 static inline impl_stmts *add_impl_stmt(impl_stmts *stmts, impl_stmt *stmt) {
 960         switch (stmt->type) {
 961         case PSI_T_RETURN:
 962                 stmts->ret.list = add_impl_stmt_ex(stmts->ret.list, ++stmts->ret.count, stmt->s.ret);
 963                 break;
 964         case PSI_T_LET:
 965                 stmts->let.list = add_impl_stmt_ex(stmts->let.list, ++stmts->let.count, stmt->s.let);
 966                 break;
 967         case PSI_T_SET:
 968                 stmts->set.list = add_impl_stmt_ex(stmts->set.list, ++stmts->set.count, stmt->s.set);
 969                 break;
 970         case PSI_T_FREE:
 971                 stmts->fre.list = add_impl_stmt_ex(stmts->fre.list, ++stmts->fre.count, stmt->s.fre);
 972                 break;
 973         }
 974         free(stmt);
 975         return stmts;
 976 }
 977
 978 static inline impl_stmts *init_impl_stmts(impl_stmt *stmt) {
 979         impl_stmts *stmts = calloc(1, sizeof(*stmts));
 980         return add_impl_stmt(stmts, stmt);
 981 }
 982
 983 static inline void free_impl_stmts(impl_stmts *stmts) {
 984         size_t i;
 985
 986         for (i = 0; i < stmts->let.count; ++i) {
 987                 free_let_stmt(stmts->let.list[i]);
 988         }
 989         free(stmts->let.list);
 990         for (i = 0; i < stmts->ret.count; ++i) {
 991                 free_return_stmt(stmts->ret.list[i]);
 992         }
 993         free(stmts->ret.list);
 994         for (i = 0; i < stmts->set.count; ++i) {
 995                 free_set_stmt(stmts->set.list[i]);
 996         }
 997         free(stmts->set.list);
 998         for (i = 0; i < stmts->fre.count; ++i) {
 999                 free_free_stmt(stmts->fre.list[i]);
1000         }
1001         free(stmts->fre.list);
1002         free(stmts);
1003 }
1004
1005 typedef struct impl {
1006         impl_func *func;
1007         impl_stmts *stmts;
1008         decl *decl;
1009 } impl;
1010
1011 static inline impl *init_impl(impl_func *func, impl_stmts *stmts) {
1012         impl *i = calloc(1, sizeof(*i));
1013         i->func = func;
1014         i->stmts = stmts;
1015         return i;
1016 }
1017
1018 static inline void free_impl(impl *impl) {
1019         free_impl_func(impl->func);
1020         free_impl_stmts(impl->stmts);
1021         free(impl);
1022 }
1023
1024 typedef struct impls {
1025         size_t count;
1026         impl **list;
1027 } impls;
1028
1029 static inline impls *add_impl(impls *impls, impl *impl) {
1030         if (!impls) {
1031                 impls = calloc(1, sizeof(*impls));
1032         }
1033         impls->list = realloc(impls->list, ++impls->count * sizeof(*impls->list));
1034         impls->list[impls->count-1] = impl;
1035         return impls;
1036 }
1037
1038 static void free_impls(impls *impls) {
1039         size_t i;
1040
1041         for (i = 0; i < impls->count; ++i) {
1042                 free_impl(impls->list[i]);
1043         }
1044         free(impls->list);
1045         free(impls);
1046 }
1047
1048 typedef struct decl_file {
1049         char *ln;
1050         char *fn;
1051 } decl_file;
1052
1053 static inline void free_decl_file(decl_file *file) {
1054         if (file->ln) {
1055                 free(file->ln);
1056         }
1057         if (file->fn) {
1058                 free(file->fn);
1059         }
1060         memset(file, 0, sizeof(*file));
1061 }
1062
1063 typedef struct decl_libs {
1064         void **dl;
1065         size_t count;
1066 } decl_libs;
1067
1068 static inline void free_decl_libs(decl_libs *libs) {
1069         if (libs->dl) {
1070                 size_t i;
1071                 for (i = 0; i < libs->count; ++i) {
1072                         if (libs->dl[i]) {
1073                                 dlclose(libs->dl[i]);
1074                         }
1075                 }
1076                 free(libs->dl);
1077         }
1078         memset(libs, 0, sizeof(*libs));
1079 }
1080
1081 static inline void add_decl_lib(decl_libs *libs, void *dlopened) {
1082         libs->dl = realloc(libs->dl, ++libs->count * sizeof(*libs->dl));
1083         libs->dl[libs->count-1] = dlopened;
1084 }
1085
1086 static inline impl_val *deref_impl_val(impl_val *ret_val, decl_var *var) {
1087         unsigned i;
1088
1089         if (var->arg->var != var) for (i = 1; i < var->pointer_level; ++i) {
1090                 ret_val = *(void **) ret_val;
1091         }
1092         return ret_val;
1093 }
1094
1095 static inline impl_val *enref_impl_val(void *ptr, decl_var *var) {
1096         impl_val *val, *val_ptr;
1097         unsigned i;
1098
1099         if (!var->pointer_level && real_decl_type(var->arg->type)->type != PSI_T_STRUCT) {
1100                 return ptr;
1101         }
1102         val = val_ptr = calloc(var->pointer_level + 1, sizeof(void *));
1103         for (i = 1; i < var->pointer_level; ++i) {
1104                 val_ptr->ptr = (void **) val_ptr + 1;
1105                 val_ptr = val_ptr->ptr;
1106         }
1107         val_ptr->ptr = ptr;
1108         return val;
1109 }
1110
1111 static inline impl_val *struct_member_ref(decl_arg *set_arg, impl_val *struct_ptr, impl_val **to_free) {
1112         void *ptr = (char *) struct_ptr->ptr + set_arg->layout->pos;
1113         impl_val *val = enref_impl_val(ptr, set_arg->var);
1114
1115         if (val != ptr) {
1116                 *to_free = val;
1117         }
1118
1119         return val;
1120 }
1121
1122 #define PSI_ERROR 16
1123 #define PSI_WARNING 32
1124 typedef void (*psi_error_cb)(int type, const char *msg, ...);
1125
1126 #define PSI_DATA(D) ((PSI_Data *) (D))
1127 #define PSI_DATA_MEMBERS \
1128         constants *consts; \
1129         decl_typedefs *defs; \
1130         decl_structs *structs; \
1131         decls *decls; \
1132         impls *impls; \
1133         union { \
1134                 decl_file file; \
1135                 decl_libs libs; \
1136         } psi; \
1137         psi_error_cb error
1138 typedef struct PSI_Data {
1139         PSI_DATA_MEMBERS;
1140 } PSI_Data;
1141
1142 static inline PSI_Data *PSI_DataExchange(PSI_Data *dest, PSI_Data *src) {
1143         if (!dest) {
1144                 dest = malloc(sizeof(*dest));
1145         }
1146         memcpy(dest, src, sizeof(*dest));
1147         memset(src, 0, sizeof(*src));
1148         return dest;
1149 }
1150
1151 static inline void PSI_DataDtor(PSI_Data *data) {
1152         if (data->consts) {
1153                 free_constants(data->consts);
1154         }
1155         if (data->defs) {
1156                 free_decl_typedefs(data->defs);
1157         }
1158         if (data->structs) {
1159                 free_decl_structs(data->structs);
1160         }
1161         if (data->decls) {
1162                 free_decls(data->decls);
1163         }
1164         if (data->impls) {
1165                 free_impls(data->impls);
1166         }
1167         free_decl_file(&data->psi.file);
1168 }
1169
1170 typedef struct PSI_Parser {
1171         PSI_DATA_MEMBERS;
1172         FILE *fp;
1173         unsigned flags;
1174         unsigned errors;
1175         void *proc;
1176         size_t line, col;
1177         token_t num;
1178         char *cur, *tok, *lim, *eof, *ctx, *mrk, buf[BSIZE];
1179 } PSI_Parser;
1180
1181 static inline PSI_Token *PSI_TokenAlloc(PSI_Parser *P) {
1182         PSI_Token *T;
1183         size_t token_len, fname_len;
1184         token_t token_typ;
1185
1186         if (P->cur < P->tok) {
1187                 return NULL;
1188         }
1189
1190         token_typ = P->num;
1191         token_len = P->cur - P->tok;
1192         fname_len = strlen(P->psi.file.fn);
1193
1194         T = calloc(1, sizeof(*T) + token_len + fname_len + 1);
1195         T->type = token_typ;
1196         T->size = token_len;
1197         T->line = P->line;
1198         T->col = P->col;
1199         T->file = &T->buf[0];
1200         T->text = &T->buf[fname_len + 1];
1201
1202         memcpy(T->file, P->psi.file.fn, fname_len);
1203         memcpy(T->text, P->tok, token_len);
1204
1205         return T;
1206 }
1207
1208 static inline PSI_Token *PSI_TokenCopy(PSI_Token *src) {
1209         size_t fname_len = strlen(src->file);
1210         size_t strct_len = sizeof(*src) + src->size + fname_len + 1;
1211         PSI_Token *ptr = malloc(strct_len);
1212
1213         memcpy(ptr, src, strct_len);
1214
1215         ptr->file = &ptr->buf[0];
1216         ptr->text = &ptr->buf[fname_len + 1];
1217
1218         return ptr;
1219 }
1220
1221 #define PSI_PARSER_DEBUG 0x1
1222
1223 PSI_Parser *PSI_ParserInit(PSI_Parser *P, const char *filename, psi_error_cb error, unsigned flags);
1224 void PSI_ParserSyntaxError(PSI_Parser *P, const char *fn, size_t ln, const char *msg, ...);
1225 size_t PSI_ParserFill(PSI_Parser *P, size_t n);
1226 token_t PSI_ParserScan(PSI_Parser *P);
1227 void PSI_ParserParse(PSI_Parser *P, PSI_Token *src);
1228 void PSI_ParserDtor(PSI_Parser *P);
1229 void PSI_ParserFree(PSI_Parser **P);
1230
1231 #endif