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