git.m6w6.name Git - m6w6/ext-psi/blob - idl/types.h

   1 typedef struct PSI_Data {
   2         decl_typedefs *defs;
   3         decls *decls;
   4         impls *impls;
   5         char *lib;
   6         char *fn;
   7 } PSI_Data;
   8
   9 static inline void PSI_DataExchange(PSI_Data *dest, PSI_Data *src) {
  10         memcpy(dest, src, sizeof(*dest));
  11         memset(src, 0, sizeof(*src));
  12 }
  13
  14 struct decl_typedef;
  15
  16 typedef struct decl_type {
  17         char *name;
  18         token_t type;
  19         struct decl_type *real;
  20 } decl_type;
  21
  22 static inline decl_type *init_decl_type(token_t type, char *name) {
  23         decl_type *t = malloc(sizeof(*t));
  24         t->type = type;
  25         t->name = strdup(name);
  26         return t;
  27 }
  28
  29 static inline void free_decl_type(decl_type *type) {
  30         free(type->name);
  31         free(type);
  32 }
  33
  34 typedef struct decl_typedef {
  35         char *alias;
  36         decl_type *type;
  37 } decl_typedef;
  38
  39 static inline decl_typedef *init_decl_typedef(char *name, decl_type *type) {
  40         decl_typedef *t = malloc(sizeof(*t));
  41         t->alias = strdup(name);
  42         t->type = type;
  43         return t;
  44 }
  45
  46 static inline void free_decl_typedef(decl_typedef *t) {
  47         free(t->alias);
  48         free_decl_type(t->type);
  49         free(t);
  50 }
  51
  52 typedef struct decl_typedefs {
  53         size_t count;
  54         decl_typedef **list;
  55 } decl_typedefs;
  56
  57 static decl_typedefs *add_decl_typedef(decl_typedefs *defs, decl_typedef *def) {
  58         if (!defs) {
  59                 defs = calloc(1, sizeof(*defs));
  60         }
  61         defs->list = realloc(defs->list, ++defs->count * sizeof(*defs->list));
  62         defs->list[defs->count-1] = def;
  63         return defs;
  64 }
  65
  66 static void free_decl_typedefs(decl_typedefs *defs) {
  67         size_t i;
  68
  69         for (i = 0; i < defs->count; ++i) {
  70                 free_decl_typedef(defs->list[i]);
  71         }
  72         free(defs->list);
  73         free(defs);
  74 }
  75
  76 typedef struct decl_var {
  77         char *name;
  78         unsigned pointer_level;
  79 } decl_var;
  80
  81 static inline decl_var *init_decl_var(char *name, unsigned pl) {
  82         decl_var *v = malloc(sizeof(*v));
  83         v->name = (char *) strdup((const char *) name);
  84         v->pointer_level = pl;
  85         return v;
  86 }
  87
  88 static inline void free_decl_var(decl_var *var) {
  89         free(var->name);
  90         free(var);
  91 }
  92
  93 typedef struct decl_arg {
  94         decl_type *type;
  95         decl_var *var;
  96 } decl_arg;
  97
  98 static inline decl_arg *init_decl_arg(decl_type *type, decl_var *var) {
  99         decl_arg *arg = malloc(sizeof(*arg));
 100         arg->type = type;
 101         arg->var = var;
 102         return arg;
 103 }
 104
 105 static inline void free_decl_arg(decl_arg *arg) {
 106         free_decl_type(arg->type);
 107         free_decl_var(arg->var);
 108         free(arg);
 109 }
 110
 111 typedef struct decl_vars {
 112         decl_var **vars;
 113         size_t count;
 114 } decl_vars;
 115
 116 static inline decl_vars *init_decl_vars(decl_var *var) {
 117         decl_vars *vars = malloc(sizeof(*vars));
 118         vars->count = 1;
 119         vars->vars = malloc(sizeof(*vars->vars));
 120         vars->vars[0] = var;
 121         return vars;
 122 }
 123
 124 static inline decl_vars *add_decl_var(decl_vars *vars, decl_var *var) {
 125         vars->vars = realloc(vars->vars, ++vars->count * sizeof(*vars->vars));
 126         vars->vars[vars->count-1] = var;
 127         return vars;
 128 }
 129
 130 static inline void free_decl_vars(decl_vars *vars) {
 131         size_t i;
 132
 133         for (i = 0; i < vars->count; ++i) {
 134                 free_decl_var(vars->vars[i]);
 135         }
 136         free(vars->vars);
 137         free(vars);
 138 }
 139
 140 typedef struct decl_args {
 141         decl_arg **args;
 142         size_t count;
 143 } decl_args;
 144
 145 static inline decl_args *init_decl_args(decl_arg *arg) {
 146         decl_args *args = malloc(sizeof(*args));
 147         args->count = 1;
 148         args->args = malloc(sizeof(*args->args));
 149         args->args[0] = arg;
 150         return args;
 151 }
 152
 153 static inline decl_args *add_decl_arg(decl_args *args, decl_arg *arg) {
 154         args->args = realloc(args->args, ++args->count * sizeof(*args->args));
 155         args->args[args->count-1] = arg;
 156         return args;
 157 }
 158
 159 static inline void free_decl_args(decl_args *args) {
 160         size_t i;
 161
 162         for (i = 0; i < args->count; ++i) {
 163                 free_decl_arg(args->args[i]);
 164         }
 165         free(args->args);
 166         free(args);
 167 }
 168
 169 typedef struct decl_abi {
 170         char *convention;
 171 } decl_abi;
 172
 173 static inline decl_abi *init_decl_abi(char *convention) {
 174         decl_abi *abi = malloc(sizeof(*abi));
 175         abi->convention = strdup(convention);
 176         return abi;
 177 }
 178
 179 static inline void free_decl_abi(decl_abi *abi) {
 180         free(abi->convention);
 181         free(abi);
 182 }
 183
 184 typedef struct decl {
 185         decl_abi *abi;
 186         decl_arg *func;
 187         decl_args *args;
 188         void *dlptr;
 189 } decl;
 190
 191 static inline decl* init_decl(decl_abi *abi, decl_arg *func, decl_args *args) {
 192         decl *d = malloc(sizeof(*d));
 193         d->abi = abi;
 194         d->func = func;
 195         d->args = args;
 196         return d;
 197 }
 198
 199 static inline void free_decl(decl *d) {
 200         free_decl_abi(d->abi);
 201         free_decl_arg(d->func);
 202         free_decl_args(d->args);
 203         free(d);
 204 }
 205
 206 typedef struct decls {
 207         size_t count;
 208         decl **list;
 209 } decls;
 210
 211 static inline decls *add_decl(decls *decls, decl *decl) {
 212         if (!decls) {
 213                 decls = calloc(1, sizeof(*decls));
 214         }
 215         decls->list = realloc(decls->list, ++decls->count * sizeof(*decls->list));
 216         decls->list[decls->count-1] = decl;
 217         return decls;
 218 }
 219
 220 static inline void free_decls(decls *decls) {
 221         size_t i;
 222
 223         for (i = 0; i < decls->count; ++i) {
 224                 free_decl(decls->list[i]);
 225         }
 226         free(decls->list);
 227         free(decls);
 228 }
 229
 230 typedef struct impl_type {
 231         char *name;
 232         token_t type;
 233 } impl_type;
 234
 235 static inline impl_type *init_impl_type(token_t type, char *name) {
 236         impl_type *t = malloc(sizeof(*t));
 237
 238         t->type = type;
 239         t->name = (char *) strdup((const char *) name);
 240         return t;
 241 }
 242
 243 static inline void free_impl_type(impl_type *type) {
 244         free(type->name);
 245         free(type);
 246 }
 247
 248 typedef struct impl_var {
 249         char *name;
 250         unsigned reference:1;
 251 } impl_var;
 252
 253 static inline impl_var *init_impl_var(char *name, int is_reference) {
 254         impl_var *var = malloc(sizeof(*var));
 255         var->name = (char *) strdup((const char *) name);
 256         var->reference = is_reference;
 257         return var;
 258 }
 259
 260 static inline void free_impl_var(impl_var *var) {
 261         free(var->name);
 262         free(var);
 263 }
 264
 265 typedef struct impl_def_val {
 266         token_t type;
 267         union {
 268                 int64_t digits;
 269                 double decimals;
 270         } v;
 271         unsigned is_null:1;
 272 } impl_def_val;
 273
 274 static inline impl_def_val *init_impl_def_val() {
 275         impl_def_val *def = malloc(sizeof(*def));
 276         def->type = 0;
 277         def->is_null = 1;
 278         return def;
 279 }
 280
 281 static inline void free_impl_def_val(impl_def_val *def) {
 282         free(def);
 283 }
 284
 285 typedef struct impl_arg {
 286         impl_type *type;
 287         impl_var *var;
 288         impl_def_val *def;
 289 } impl_arg;
 290
 291 static inline impl_arg *init_impl_arg(impl_type *type, impl_var *var, impl_def_val *def) {
 292         impl_arg *arg = malloc(sizeof(*arg));
 293         arg->type = type;
 294         arg->var = var;
 295         arg->def = def;
 296         return arg;
 297 }
 298
 299 static inline void free_impl_arg(impl_arg *arg) {
 300         free_impl_type(arg->type);
 301         free_impl_var(arg->var);
 302         if (arg->def) {
 303                 free_impl_def_val(arg->def);
 304         }
 305         free(arg);
 306 }
 307
 308 typedef struct impl_args {
 309         impl_arg **args;
 310         size_t count;
 311 } impl_args;
 312
 313 static inline impl_args *init_impl_args(impl_arg *arg) {
 314         impl_args *args = malloc(sizeof(*args));
 315         args->args = malloc(sizeof(*args->args));
 316         if (arg) {
 317                 args->count = 1;
 318                 args->args[0] = arg;
 319         } else {
 320                 args->count = 0;
 321                 args->args = NULL;
 322         }
 323         return args;
 324 }
 325
 326 static inline impl_args *add_impl_arg(impl_args *args, impl_arg *arg) {
 327         args->args = realloc(args->args, ++args->count * sizeof(*args->args));
 328         args->args[args->count-1] = arg;
 329         return args;
 330 }
 331
 332 static inline void free_impl_args(impl_args *args) {
 333         size_t i;
 334
 335         for (i = 0; i < args->count; ++i) {
 336                 free_impl_arg(args->args[i]);
 337         }
 338         free(args->args);
 339         free(args);
 340 }
 341
 342 typedef struct impl_func {
 343         char *name;
 344         impl_args *args;
 345         impl_type *return_type;
 346 } impl_func;
 347
 348 static inline impl_func *init_impl_func(char *name, impl_args *args, impl_type *type) {
 349         impl_func *func = malloc(sizeof(*func));
 350         func->name = strdup(name);
 351         func->args = args ? args : init_impl_args(NULL);
 352         func->return_type = type;
 353         return func;
 354 }
 355
 356 static inline void free_impl_func(impl_func *f) {
 357         free_impl_type(f->return_type);
 358         free_impl_args(f->args);
 359         free(f->name);
 360         free(f);
 361 }
 362
 363 typedef struct let_func {
 364         token_t type;
 365         char *name;
 366 } let_func;
 367
 368 static inline let_func *init_let_func(token_t type, char *name) {
 369         let_func *func = malloc(sizeof(*func));
 370         func->type = type;
 371         func->name = (char *) strdup((const char *) name);
 372         return func;
 373 }
 374
 375 static inline void free_let_func(let_func *func) {
 376         free(func->name);
 377         free(func);
 378 }
 379
 380 typedef struct let_value {
 381         let_func *func;
 382         impl_var *var;
 383         unsigned null_pointer_ref:1;
 384 } let_value;
 385
 386 static inline let_value *init_let_value(let_func *func, impl_var *var, int null_pointer_ref) {
 387         let_value *val = malloc(sizeof(*val));
 388         val->null_pointer_ref = null_pointer_ref;
 389         val->func = func;
 390         val->var = var;
 391         return val;
 392 }
 393
 394 static inline void free_let_value(let_value *val) {
 395         if (val->func) {
 396                 free_let_func(val->func);
 397         }
 398         if (val->var) {
 399                 free_impl_var(val->var);
 400         }
 401         free(val);
 402 }
 403
 404 typedef struct let_stmt {
 405         decl_var *var;
 406         let_value *val;
 407 } let_stmt;
 408
 409 static inline let_stmt *init_let_stmt(decl_var *var, let_value *val) {
 410         let_stmt *let = malloc(sizeof(*let));
 411         let->var = var;
 412         let->val = val;
 413         return let;
 414 }
 415
 416 static inline void free_let_stmt(let_stmt *stmt) {
 417         free_decl_var(stmt->var);
 418         free_let_value(stmt->val);
 419         free(stmt);
 420 }
 421
 422 typedef struct set_func {
 423         token_t type;
 424         char *name;
 425 } set_func;
 426
 427 static inline set_func *init_set_func(token_t type, char *name) {
 428         set_func *func = malloc(sizeof(*func));
 429         func->type = type;
 430         func->name = (char *) strdup((const char *) name);
 431         return func;
 432 }
 433
 434 static inline void free_set_func(set_func *func) {
 435         free(func->name);
 436         free(func);
 437 }
 438
 439 typedef struct set_value {
 440         set_func *func;
 441         decl_vars *vars;
 442 } set_value;
 443
 444 static inline set_value *init_set_value(set_func *func, decl_vars *vars) {
 445         set_value *val = malloc(sizeof(*val));
 446         val->func = func;
 447         val->vars = vars;
 448         return val;
 449 }
 450
 451 static inline void free_set_value(set_value *val) {
 452         free_set_func(val->func);
 453         free_decl_vars(val->vars);
 454         free(val);
 455 }
 456
 457 typedef struct set_stmt {
 458         impl_var *var;
 459         set_value *val;
 460 } set_stmt;
 461
 462 static inline set_stmt *init_set_stmt(impl_var *var, set_value *val) {
 463         set_stmt *set = malloc(sizeof(*set));
 464         set->var = var;
 465         set->val = val;
 466         return set;
 467 }
 468
 469 static inline void free_set_stmt(set_stmt *set) {
 470         free_impl_var(set->var);
 471         free_set_value(set->val);
 472         free(set);
 473 }
 474
 475 typedef struct ret_stmt {
 476         set_func *func;
 477         decl_var *decl;
 478 } ret_stmt;
 479
 480 static inline ret_stmt *init_ret_stmt(set_func *func, decl_var *decl) {
 481         ret_stmt *ret = malloc(sizeof(*ret));
 482         ret->func = func;
 483         ret->decl = decl;
 484         return ret;
 485 }
 486
 487 static inline void free_ret_stmt(ret_stmt *ret) {
 488         free_set_func(ret->func);
 489         free_decl_var(ret->decl);
 490         free(ret);
 491 }
 492
 493 typedef struct impl_stmt {
 494         token_t type;
 495         union {
 496                 let_stmt *let;
 497                 set_stmt *set;
 498                 ret_stmt *ret;
 499                 void *ptr;
 500         } s;
 501 } impl_stmt;
 502
 503 static inline impl_stmt *init_impl_stmt(token_t type, void *ptr) {
 504         impl_stmt *stmt = malloc(sizeof(*stmt));
 505         stmt->type = type;
 506         stmt->s.ptr = ptr;
 507         return stmt;
 508 }
 509
 510 static inline void free_impl_stmt(impl_stmt *stmt) {
 511         switch (stmt->type) {
 512         case PSI_T_LET:
 513                 free_let_stmt(stmt->s.let);
 514                 break;
 515         case PSI_T_SET:
 516                 free_set_stmt(stmt->s.set);
 517                 break;
 518         case PSI_T_RET:
 519                 free_ret_stmt(stmt->s.ret);
 520                 break;
 521         }
 522         free(stmt);
 523 }
 524
 525 typedef struct impl_stmts {
 526         impl_stmt **stmts;
 527         size_t count;
 528 } impl_stmts;
 529
 530 static inline impl_stmts *init_impl_stmts(impl_stmt *stmt) {
 531         impl_stmts *stmts = malloc(sizeof(*stmts));
 532         stmts->count = 1;
 533         stmts->stmts = malloc(sizeof(*stmts->stmts));
 534         stmts->stmts[0] = stmt;
 535         return stmts;
 536 }
 537
 538 static inline impl_stmts *add_impl_stmt(impl_stmts *stmts, impl_stmt *stmt) {
 539         stmts->stmts = realloc(stmts->stmts, ++stmts->count * sizeof(*stmts->stmts));
 540         stmts->stmts[stmts->count-1] = stmt;
 541         return stmts;
 542 }
 543
 544 static inline void free_impl_stmts(impl_stmts *stmts) {
 545         size_t i;
 546
 547         for (i = 0; i < stmts->count; ++i) {
 548                 free_impl_stmt(stmts->stmts[i]);
 549         }
 550         free(stmts->stmts);
 551         free(stmts);
 552 }
 553
 554 typedef struct impl {
 555         impl_func *func;
 556         impl_stmts *stmts;
 557 } impl;
 558
 559 static inline impl *init_impl(impl_func *func, impl_stmts *stmts) {
 560         impl *i = malloc(sizeof(*i));
 561         i->func = func;
 562         i->stmts = stmts;
 563         return i;
 564 }
 565
 566 static inline void free_impl(impl *impl) {
 567         free_impl_func(impl->func);
 568         free_impl_stmts(impl->stmts);
 569         free(impl);
 570 }
 571
 572 typedef struct impls {
 573         size_t count;
 574         impl **list;
 575 } impls;
 576
 577 static impls *add_impl(impls *impls, impl *impl) {
 578         if (!impls) {
 579                 impls = calloc(1, sizeof(*impls));
 580         }
 581         impls->list = realloc(impls->list, ++impls->count * sizeof(*impls->list));
 582         impls->list[impls->count-1] = impl;
 583         return impls;
 584 }
 585
 586 static void free_impls(impls *impls) {
 587         size_t i;
 588
 589         for (i = 0; i < impls->count; ++i) {
 590                 free_impl(impls->list[i]);
 591         }
 592         free(impls->list);
 593         free(impls);
 594 }