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