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