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 typedef int token_t;
  16
  17 typedef struct PSI_Token {
  18         token_t type;
  19         unsigned line;
  20         size_t size;
  21         char text[1];
  22 } PSI_Token;
  23
  24 typedef struct decl_type {
  25         char *name;
  26         token_t type;
  27         struct decl_type *real;
  28         struct decl_struct *strct;
  29 } decl_type;
  30
  31 static inline decl_type *init_decl_type(token_t type, char *name) {
  32         decl_type *t = malloc(sizeof(*t));
  33         t->type = type;
  34         t->name = strdup(name);
  35         t->real = NULL;
  36         return t;
  37 }
  38
  39 static inline decl_type *real_decl_type(decl_type *type) {
  40         while (type->real) {
  41                 type = type->real;
  42         }
  43         return type;
  44 }
  45
  46 static inline void free_decl_type(decl_type *type) {
  47         free(type->name);
  48         free(type);
  49 }
  50
  51 typedef struct decl_typedef {
  52         char *alias;
  53         decl_type *type;
  54 } decl_typedef;
  55
  56 static inline decl_typedef *init_decl_typedef(char *name, decl_type *type) {
  57         decl_typedef *t = malloc(sizeof(*t));
  58         t->alias = strdup(name);
  59         t->type = type;
  60         return t;
  61 }
  62
  63 static inline void free_decl_typedef(decl_typedef *t) {
  64         free(t->alias);
  65         free_decl_type(t->type);
  66         free(t);
  67 }
  68
  69 typedef struct decl_typedefs {
  70         size_t count;
  71         decl_typedef **list;
  72 } decl_typedefs;
  73
  74 static inline decl_typedefs *add_decl_typedef(decl_typedefs *defs, decl_typedef *def) {
  75         if (!defs) {
  76                 defs = calloc(1, sizeof(*defs));
  77         }
  78         defs->list = realloc(defs->list, ++defs->count * sizeof(*defs->list));
  79         defs->list[defs->count-1] = def;
  80         return defs;
  81 }
  82
  83 static void free_decl_typedefs(decl_typedefs *defs) {
  84         size_t i;
  85
  86         for (i = 0; i < defs->count; ++i) {
  87                 free_decl_typedef(defs->list[i]);
  88         }
  89         free(defs->list);
  90         free(defs);
  91 }
  92
  93 typedef struct decl_var {
  94         char *name;
  95         unsigned pointer_level;
  96         unsigned array_size;
  97         struct decl_arg *arg;
  98 } decl_var;
  99
 100 static inline decl_var *init_decl_var(char *name, unsigned pl, unsigned as) {
 101         decl_var *v = malloc(sizeof(*v));
 102         v->name = (char *) strdup((const char *) name);
 103         v->pointer_level = pl;
 104         v->array_size = as;
 105         return v;
 106 }
 107
 108 static inline void free_decl_var(decl_var *var) {
 109         free(var->name);
 110         free(var);
 111 }
 112
 113 typedef struct decl_arg {
 114         decl_type *type;
 115         decl_var *var;
 116         struct let_stmt *let;
 117 } decl_arg;
 118
 119 static inline decl_arg *init_decl_arg(decl_type *type, decl_var *var) {
 120         decl_arg *arg = malloc(sizeof(*arg));
 121         arg->type = type;
 122         arg->var = var;
 123         arg->let = NULL;
 124         return arg;
 125 }
 126
 127 static inline void free_decl_arg(decl_arg *arg) {
 128         free_decl_type(arg->type);
 129         free_decl_var(arg->var);
 130         free(arg);
 131 }
 132
 133 typedef struct decl_vars {
 134         decl_var **vars;
 135         size_t count;
 136 } decl_vars;
 137
 138 static inline decl_vars *init_decl_vars(decl_var *var) {
 139         decl_vars *vars = malloc(sizeof(*vars));
 140         vars->count = 1;
 141         vars->vars = malloc(sizeof(*vars->vars));
 142         vars->vars[0] = var;
 143         return vars;
 144 }
 145
 146 static inline decl_vars *add_decl_var(decl_vars *vars, decl_var *var) {
 147         vars->vars = realloc(vars->vars, ++vars->count * sizeof(*vars->vars));
 148         vars->vars[vars->count-1] = var;
 149         return vars;
 150 }
 151
 152 static inline void free_decl_vars(decl_vars *vars) {
 153         size_t i;
 154
 155         for (i = 0; i < vars->count; ++i) {
 156                 free_decl_var(vars->vars[i]);
 157         }
 158         free(vars->vars);
 159         free(vars);
 160 }
 161
 162 typedef struct decl_args {
 163         decl_arg **args;
 164         size_t count;
 165 } decl_args;
 166
 167 static inline decl_args *init_decl_args(decl_arg *arg) {
 168         decl_args *args = malloc(sizeof(*args));
 169         args->count = 1;
 170         args->args = malloc(sizeof(*args->args));
 171         args->args[0] = arg;
 172         return args;
 173 }
 174
 175 static inline decl_args *add_decl_arg(decl_args *args, decl_arg *arg) {
 176         args->args = realloc(args->args, ++args->count * sizeof(*args->args));
 177         args->args[args->count-1] = arg;
 178         return args;
 179 }
 180
 181 static inline void free_decl_args(decl_args *args) {
 182         size_t i;
 183
 184         for (i = 0; i < args->count; ++i) {
 185                 free_decl_arg(args->args[i]);
 186         }
 187         free(args->args);
 188         free(args);
 189 }
 190
 191 typedef struct decl_abi {
 192         char *convention;
 193 } decl_abi;
 194
 195 static inline decl_abi *init_decl_abi(char *convention) {
 196         decl_abi *abi = malloc(sizeof(*abi));
 197         abi->convention = strdup(convention);
 198         return abi;
 199 }
 200
 201 static inline void free_decl_abi(decl_abi *abi) {
 202         free(abi->convention);
 203         free(abi);
 204 }
 205
 206 typedef struct decl {
 207         decl_abi *abi;
 208         decl_arg *func;
 209         decl_args *args;
 210         void *dlptr;
 211 } decl;
 212
 213 static inline decl* init_decl(decl_abi *abi, decl_arg *func, decl_args *args) {
 214         decl *d = malloc(sizeof(*d));
 215         d->abi = abi;
 216         d->func = func;
 217         d->args = args;
 218         return d;
 219 }
 220
 221 static inline void free_decl(decl *d) {
 222         free_decl_abi(d->abi);
 223         free_decl_arg(d->func);
 224         free_decl_args(d->args);
 225         free(d);
 226 }
 227
 228 typedef struct decls {
 229         size_t count;
 230         decl **list;
 231 } decls;
 232
 233 static inline decls *add_decl(decls *decls, decl *decl) {
 234         if (!decls) {
 235                 decls = calloc(1, sizeof(*decls));
 236         }
 237         decls->list = realloc(decls->list, ++decls->count * sizeof(*decls->list));
 238         decls->list[decls->count-1] = decl;
 239         return decls;
 240 }
 241
 242 static inline void free_decls(decls *decls) {
 243         size_t i;
 244
 245         for (i = 0; i < decls->count; ++i) {
 246                 free_decl(decls->list[i]);
 247         }
 248         free(decls->list);
 249         free(decls);
 250 }
 251
 252 typedef struct decl_struct_layout {
 253         size_t pos;
 254         size_t len;
 255 } decl_struct_layout;
 256
 257 typedef struct decl_struct {
 258         char *name;
 259         decl_args *args;
 260         decl_struct_layout *layout;
 261 } decl_struct;
 262
 263 static inline decl_struct *init_decl_struct(char *name, decl_args *args) {
 264         decl_struct *s = calloc(1, sizeof(*s));
 265         s->name = strdup(name);
 266         s->args = args;
 267         return s;
 268 }
 269
 270 static inline void free_decl_struct(decl_struct *s) {
 271         free_decl_args(s->args);
 272         free(s->name);
 273         free(s);
 274 }
 275
 276 typedef struct decl_structs {
 277         size_t count;
 278         decl_struct **list;
 279 } decl_structs;
 280
 281 static inline decl_structs *add_decl_struct(decl_structs *ss, decl_struct *s) {
 282         if (!ss) {
 283                 ss = calloc(1, sizeof(*ss));
 284         }
 285         ss->list = realloc(ss->list, ++ss->count * sizeof(*ss->list));
 286         ss->list[ss->count-1] = s;
 287         return ss;
 288 }
 289
 290 static inline void free_decl_structs(decl_structs *ss) {
 291         size_t i;
 292
 293         for (i = 0; i < ss->count; ++i) {
 294                 free_decl_struct(ss->list[i]);
 295         }
 296         free(ss->list);
 297         free(ss);
 298 }
 299
 300 typedef union impl_val {
 301         unsigned char bval;
 302         char cval;
 303         short sval;
 304         int ival;
 305         double dval;
 306         zend_long lval;
 307         zend_string *str;
 308         void *ptr;
 309 } impl_val;
 310
 311 static inline impl_val *deref_impl_val(unsigned level, impl_val *ret_val, decl_arg *darg) {
 312         unsigned i;
 313
 314         for (i = level; i < darg->var->pointer_level && ret_val->ptr; ++i) {
 315                 ret_val = *(void **)ret_val;
 316         }
 317         return ret_val;
 318 }
 319
 320 typedef struct impl_type {
 321         char *name;
 322         token_t type;
 323 } impl_type;
 324
 325 static inline impl_type *init_impl_type(token_t type, char *name) {
 326         impl_type *t = malloc(sizeof(*t));
 327
 328         t->type = type;
 329         t->name = (char *) strdup((const char *) name);
 330         return t;
 331 }
 332
 333 static inline void free_impl_type(impl_type *type) {
 334         free(type->name);
 335         free(type);
 336 }
 337
 338 typedef struct impl_var {
 339         char *name;
 340         unsigned reference:1;
 341 } impl_var;
 342
 343 static inline impl_var *init_impl_var(char *name, int is_reference) {
 344         impl_var *var = malloc(sizeof(*var));
 345         var->name = (char *) strdup((const char *) name);
 346         var->reference = is_reference;
 347         return var;
 348 }
 349
 350 static inline void free_impl_var(impl_var *var) {
 351         free(var->name);
 352         free(var);
 353 }
 354
 355 typedef struct impl_def_val {
 356         token_t type;
 357         char *text;
 358 } impl_def_val;
 359
 360 static inline impl_def_val *init_impl_def_val(PSI_Token *T) {
 361         impl_def_val *def = malloc(sizeof(*def));
 362         def->type = T->type;
 363         def->text = strdup(T->text);
 364         return def;
 365 }
 366
 367 static inline void free_impl_def_val(impl_def_val *def) {
 368         free(def->text);
 369         free(def);
 370 }
 371
 372 typedef struct impl_arg {
 373         impl_type *type;
 374         impl_var *var;
 375         impl_def_val *def;
 376         impl_val val;
 377         zval *_zv;
 378 } impl_arg;
 379
 380 static inline impl_arg *init_impl_arg(impl_type *type, impl_var *var, impl_def_val *def) {
 381         impl_arg *arg = malloc(sizeof(*arg));
 382         arg->type = type;
 383         arg->var = var;
 384         arg->def = def;
 385         return arg;
 386 }
 387
 388 static inline void free_impl_arg(impl_arg *arg) {
 389         free_impl_type(arg->type);
 390         free_impl_var(arg->var);
 391         if (arg->def) {
 392                 free_impl_def_val(arg->def);
 393         }
 394         free(arg);
 395 }
 396
 397 typedef struct impl_args {
 398         impl_arg **args;
 399         size_t count;
 400 } impl_args;
 401
 402 static inline impl_args *init_impl_args(impl_arg *arg) {
 403         impl_args *args = malloc(sizeof(*args));
 404         args->args = malloc(sizeof(*args->args));
 405         if (arg) {
 406                 args->count = 1;
 407                 args->args[0] = arg;
 408         } else {
 409                 args->count = 0;
 410                 args->args = NULL;
 411         }
 412         return args;
 413 }
 414
 415 static inline impl_args *add_impl_arg(impl_args *args, impl_arg *arg) {
 416         args->args = realloc(args->args, ++args->count * sizeof(*args->args));
 417         args->args[args->count-1] = arg;
 418         return args;
 419 }
 420
 421 static inline void free_impl_args(impl_args *args) {
 422         size_t i;
 423
 424         for (i = 0; i < args->count; ++i) {
 425                 free_impl_arg(args->args[i]);
 426         }
 427         free(args->args);
 428         free(args);
 429 }
 430
 431 typedef struct impl_func {
 432         char *name;
 433         impl_args *args;
 434         impl_type *return_type;
 435         unsigned return_reference:1;
 436 } impl_func;
 437
 438 static inline impl_func *init_impl_func(char *name, impl_args *args, impl_type *type, int ret_reference) {
 439         impl_func *func = malloc(sizeof(*func));
 440         func->name = strdup(name);
 441         func->args = args ? args : init_impl_args(NULL);
 442         func->return_type = type;
 443         func->return_reference = ret_reference;
 444         return func;
 445 }
 446
 447 static inline void free_impl_func(impl_func *f) {
 448         free_impl_type(f->return_type);
 449         free_impl_args(f->args);
 450         free(f->name);
 451         free(f);
 452 }
 453
 454 typedef struct let_func {
 455         token_t type;
 456         char *name;
 457         size_t size;
 458 } let_func;
 459
 460 static inline let_func *init_let_func(token_t type, char *name, size_t size) {
 461         let_func *func = malloc(sizeof(*func));
 462         func->type = type;
 463         func->name = strdup(name);
 464         func->size = size;
 465         return func;
 466 }
 467
 468 static inline void free_let_func(let_func *func) {
 469         free(func->name);
 470         free(func);
 471 }
 472
 473 typedef struct let_value {
 474         let_func *func;
 475         impl_var *var;
 476         unsigned is_reference:1;
 477 } let_value;
 478
 479 static inline let_value *init_let_value(let_func *func, impl_var *var, int is_reference) {
 480         let_value *val = malloc(sizeof(*val));
 481         val->is_reference = is_reference;
 482         val->func = func;
 483         val->var = var;
 484         return val;
 485 }
 486
 487 static inline void free_let_value(let_value *val) {
 488         if (val->func) {
 489                 free_let_func(val->func);
 490         }
 491         if (val->var) {
 492                 free_impl_var(val->var);
 493         }
 494         free(val);
 495 }
 496
 497 typedef struct let_stmt {
 498         decl_var *var;
 499         let_value *val;
 500         impl_arg *arg;
 501         impl_val out;
 502         void *ptr;
 503         void *mem;
 504 } let_stmt;
 505
 506 static inline let_stmt *init_let_stmt(decl_var *var, let_value *val) {
 507         let_stmt *let = calloc(1, sizeof(*let));
 508         let->var = var;
 509         let->val = val;
 510         return let;
 511 }
 512
 513 static inline void free_let_stmt(let_stmt *stmt) {
 514         free_decl_var(stmt->var);
 515         if (stmt->val) {
 516                 free_let_value(stmt->val);
 517         }
 518         free(stmt);
 519 }
 520
 521 typedef struct set_func {
 522         token_t type;
 523         char *name;
 524 } set_func;
 525
 526 static inline set_func *init_set_func(token_t type, char *name) {
 527         set_func *func = malloc(sizeof(*func));
 528         func->type = type;
 529         func->name = (char *) strdup((const char *) name);
 530         return func;
 531 }
 532
 533 static inline void free_set_func(set_func *func) {
 534         free(func->name);
 535         free(func);
 536 }
 537
 538 typedef struct set_value {
 539         set_func *func;
 540         decl_vars *vars;
 541 } set_value;
 542
 543 static inline set_value *init_set_value(set_func *func, decl_vars *vars) {
 544         set_value *val = malloc(sizeof(*val));
 545         val->func = func;
 546         val->vars = vars;
 547         return val;
 548 }
 549
 550 static inline void free_set_value(set_value *val) {
 551         free_set_func(val->func);
 552         free_decl_vars(val->vars);
 553         free(val);
 554 }
 555
 556 typedef struct set_stmt {
 557         impl_var *var;
 558         set_value *val;
 559         impl_arg *arg;
 560 } set_stmt;
 561
 562 static inline set_stmt *init_set_stmt(impl_var *var, set_value *val) {
 563         set_stmt *set = malloc(sizeof(*set));
 564         set->var = var;
 565         set->val = val;
 566         return set;
 567 }
 568
 569 static inline void free_set_stmt(set_stmt *set) {
 570         free_impl_var(set->var);
 571         free_set_value(set->val);
 572         free(set);
 573 }
 574
 575 typedef struct return_stmt {
 576         set_func *func;
 577         decl_var *decl;
 578 } return_stmt;
 579
 580 static inline return_stmt *init_return_stmt(set_func *func, decl_var *decl) {
 581         return_stmt *ret = malloc(sizeof(*ret));
 582         ret->func = func;
 583         ret->decl = decl;
 584         return ret;
 585 }
 586
 587 static inline void free_return_stmt(return_stmt *ret) {
 588         free_set_func(ret->func);
 589         free_decl_var(ret->decl);
 590         free(ret);
 591 }
 592
 593 typedef struct free_stmt {
 594         decl_vars *vars;
 595 } free_stmt;
 596
 597 static inline free_stmt *init_free_stmt(decl_vars *vars) {
 598         free_stmt *free_ = malloc(sizeof(*free_));
 599         free_->vars = vars;
 600         return free_;
 601 }
 602
 603 static inline void free_free_stmt(free_stmt *free_) {
 604         free_decl_vars(free_->vars);
 605         free(free_);
 606 }
 607
 608 typedef struct impl_stmt {
 609         token_t type;
 610         union {
 611                 let_stmt *let;
 612                 set_stmt *set;
 613                 return_stmt *ret;
 614                 free_stmt *fre;
 615                 void *ptr;
 616         } s;
 617 } impl_stmt;
 618
 619 static inline impl_stmt *init_impl_stmt(token_t type, void *ptr) {
 620         impl_stmt *stmt = malloc(sizeof(*stmt));
 621         stmt->type = type;
 622         stmt->s.ptr = ptr;
 623         return stmt;
 624 }
 625
 626 static inline void free_impl_stmt(impl_stmt *stmt) {
 627         switch (stmt->type) {
 628         case PSI_T_LET:
 629                 free_let_stmt(stmt->s.let);
 630                 break;
 631         case PSI_T_SET:
 632                 free_set_stmt(stmt->s.set);
 633                 break;
 634         case PSI_T_RETURN:
 635                 free_return_stmt(stmt->s.ret);
 636                 break;
 637         case PSI_T_FREE:
 638                 free_free_stmt(stmt->s.fre);
 639                 break;
 640         }
 641         free(stmt);
 642 }
 643
 644 typedef struct impl_stmts {
 645         struct {
 646                 return_stmt **list;
 647                 size_t count;
 648         } ret;
 649         struct {
 650                 let_stmt **list;
 651                 size_t count;
 652         } let;
 653         struct {
 654                 set_stmt **list;
 655                 size_t count;
 656         } set;
 657         struct {
 658                 free_stmt **list;
 659                 size_t count;
 660         } fre;
 661 } impl_stmts;
 662
 663 static inline void *add_impl_stmt_ex(void *list, size_t count, void *stmt) {
 664         list = realloc(list, count * sizeof(list));
 665         ((void **)list)[count-1] = stmt;
 666         return list;
 667 }
 668
 669 static inline impl_stmts *add_impl_stmt(impl_stmts *stmts, impl_stmt *stmt) {
 670         switch (stmt->type) {
 671         case PSI_T_RETURN:
 672                 stmts->ret.list = add_impl_stmt_ex(stmts->ret.list, ++stmts->ret.count, stmt->s.ret);
 673                 break;
 674         case PSI_T_LET:
 675                 stmts->let.list = add_impl_stmt_ex(stmts->let.list, ++stmts->let.count, stmt->s.let);
 676                 break;
 677         case PSI_T_SET:
 678                 stmts->set.list = add_impl_stmt_ex(stmts->set.list, ++stmts->set.count, stmt->s.set);
 679                 break;
 680         case PSI_T_FREE:
 681                 stmts->fre.list = add_impl_stmt_ex(stmts->fre.list, ++stmts->fre.count, stmt->s.fre);
 682                 break;
 683         }
 684         free(stmt);
 685         return stmts;
 686 }
 687
 688 static inline impl_stmts *init_impl_stmts(impl_stmt *stmt) {
 689         impl_stmts *stmts = calloc(1, sizeof(*stmts));
 690         return add_impl_stmt(stmts, stmt);
 691 }
 692
 693 static inline void free_impl_stmts(impl_stmts *stmts) {
 694         size_t i;
 695
 696         for (i = 0; i < stmts->let.count; ++i) {
 697                 free_let_stmt(stmts->let.list[i]);
 698         }
 699         free(stmts->let.list);
 700         for (i = 0; i < stmts->ret.count; ++i) {
 701                 free_return_stmt(stmts->ret.list[i]);
 702         }
 703         free(stmts->ret.list);
 704         for (i = 0; i < stmts->set.count; ++i) {
 705                 free_set_stmt(stmts->set.list[i]);
 706         }
 707         free(stmts->set.list);
 708         for (i = 0; i < stmts->fre.count; ++i) {
 709                 free_free_stmt(stmts->fre.list[i]);
 710         }
 711         free(stmts->fre.list);
 712         free(stmts);
 713 }
 714
 715 typedef struct impl {
 716         impl_func *func;
 717         impl_stmts *stmts;
 718         decl *decl;
 719 } impl;
 720
 721 static inline impl *init_impl(impl_func *func, impl_stmts *stmts) {
 722         impl *i = malloc(sizeof(*i));
 723         i->func = func;
 724         i->stmts = stmts;
 725         return i;
 726 }
 727
 728 static inline void free_impl(impl *impl) {
 729         free_impl_func(impl->func);
 730         free_impl_stmts(impl->stmts);
 731         free(impl);
 732 }
 733
 734 typedef struct impls {
 735         size_t count;
 736         impl **list;
 737 } impls;
 738
 739 static inline impls *add_impl(impls *impls, impl *impl) {
 740         if (!impls) {
 741                 impls = calloc(1, sizeof(*impls));
 742         }
 743         impls->list = realloc(impls->list, ++impls->count * sizeof(*impls->list));
 744         impls->list[impls->count-1] = impl;
 745         return impls;
 746 }
 747
 748 static void free_impls(impls *impls) {
 749         size_t i;
 750
 751         for (i = 0; i < impls->count; ++i) {
 752                 free_impl(impls->list[i]);
 753         }
 754         free(impls->list);
 755         free(impls);
 756 }
 757
 758 typedef struct const_type {
 759         token_t type;
 760         char *name;
 761 } const_type;
 762
 763 static inline const_type *init_const_type(token_t type, const char *name) {
 764         const_type *ct = malloc(sizeof(*ct));
 765         ct->type = type;
 766         ct->name = strdup(name);
 767         return ct;
 768 }
 769
 770 static inline void free_const_type(const_type *type) {
 771         free(type->name);
 772         free(type);
 773 }
 774
 775 typedef struct constant {
 776         const_type *type;
 777         char *name;
 778         impl_def_val *val;
 779 } constant;
 780
 781 static inline constant *init_constant(const_type *type, char *name, impl_def_val *val) {
 782         constant *c = malloc(sizeof(*c));
 783         c->type = type;
 784         c->name = strdup(name);
 785         c->val = val;
 786         return c;
 787 }
 788
 789 static inline void free_constant(constant *constant) {
 790         free_const_type(constant->type);
 791         free(constant->name);
 792         free_impl_def_val(constant->val);
 793         free(constant);
 794 }
 795
 796 typedef struct constants {
 797         size_t count;
 798         constant **list;
 799 } constants;
 800
 801 static inline constants *add_constant(constants *constants, constant *constant) {
 802         if (!constants) {
 803                 constants = calloc(1, sizeof(*constants));
 804         }
 805         constants->list = realloc(constants->list, ++constants->count * sizeof(*constants->list));
 806         constants->list[constants->count-1] = constant;
 807         return constants;
 808 }
 809
 810 static inline void free_constants(constants *c) {
 811         size_t i;
 812
 813         for (i = 0; i < c->count; ++i) {
 814                 free_constant(c->list[i]);
 815         }
 816         free(c->list);
 817         free(c);
 818 }
 819
 820 #define PSI_ERROR 16
 821 #define PSI_WARNING 32
 822 typedef void (*psi_error_cb)(int type, const char *msg, ...);
 823
 824 #define PSI_DATA_MEMBERS \
 825         constants *consts; \
 826         decl_typedefs *defs; \
 827         decl_structs *structs; \
 828         decls *decls; \
 829         impls *impls; \
 830         char *lib; \
 831         char *fn; \
 832         psi_error_cb error
 833 typedef struct PSI_Data {
 834         PSI_DATA_MEMBERS;
 835 } PSI_Data;
 836
 837 static inline void PSI_DataExchange(PSI_Data *dest, PSI_Data *src) {
 838         memcpy(dest, src, sizeof(*dest));
 839         memset(src, 0, sizeof(*src));
 840 }
 841
 842 static inline void PSI_DataDtor(PSI_Data *data) {
 843         if (data->consts) {
 844                 free_constants(data->consts);
 845         }
 846         if (data->defs) {
 847                 free_decl_typedefs(data->defs);
 848         }
 849         if (data->structs) {
 850                 free_decl_structs(data->structs);
 851         }
 852         if (data->decls) {
 853                 free_decls(data->decls);
 854         }
 855         if (data->impls) {
 856                 free_impls(data->impls);
 857         }
 858         if (data->lib) {
 859                 free(data->lib);
 860         }
 861         if (data->fn) {
 862                 free(data->fn);
 863         }
 864 }
 865
 866 typedef struct PSI_Parser {
 867         PSI_DATA_MEMBERS;
 868         FILE *fp;
 869         unsigned flags;
 870         unsigned errors;
 871         void *proc;
 872         size_t line;
 873         token_t num;
 874         char *cur, *tok, *lim, *eof, *ctx, *mrk, buf[BSIZE];
 875 } PSI_Parser;
 876
 877 static inline PSI_Token *PSI_TokenAlloc(PSI_Parser *P) {
 878         PSI_Token *T;
 879         size_t token_len;
 880
 881         if (P->cur <= P->tok) {
 882                 return NULL;
 883         }
 884
 885         token_len = P->cur - P->tok;
 886
 887         T = malloc(sizeof(*T) + token_len);
 888         T->type = P->num;
 889         T->line = P->line;
 890         T->size = token_len;
 891         T->text[token_len] = 0;
 892         memcpy(T->text, P->tok, token_len);
 893
 894         return T;
 895 }
 896
 897 #define PSI_PARSER_DEBUG 0x1
 898
 899 PSI_Parser *PSI_ParserInit(PSI_Parser *P, const char *filename, psi_error_cb error, unsigned flags);
 900 void PSI_ParserSyntaxError(PSI_Parser *P, const char *fn, size_t ln, const char *msg, ...);
 901 size_t PSI_ParserFill(PSI_Parser *P, size_t n);
 902 token_t PSI_ParserScan(PSI_Parser *P);
 903 void PSI_ParserParse(PSI_Parser *P, PSI_Token *T);
 904 void PSI_ParserDtor(PSI_Parser *P);
 905 void PSI_ParserFree(PSI_Parser **P);
 906
 907 #endif