ncc.c

   1 /*
   2  * THE NEATCC C COMPILER
   3  *
   4  * Copyright (C) 2010-2016 Ali Gholami Rudi
   5  *
   6  * Permission to use, copy, modify, and/or distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18 /*
  19  * neatcc parser
  20  *
  21  * The parser reads tokens from the tokenizer (tok_*) and calls the
  22  * appropriate code generation functions (o_*).  The generator
  23  * maintains a stack of values pushed via, for instance, o_num()
  24  * and generates the necessary code for the accesses to the items
  25  * in this stack, like o_bop() for performing a binary operations
  26  * on the top two items of the stack.  The parser maintains the
  27  * types of values pushed to the generator stack in its type stack
  28  * (ts_*).  For instance, for binary operations two types are
  29  * popped first and the resulting type is pushed to the type stack
  30  * (ts_binop()).
  31  *
  32  */
  33 #include <ctype.h>
  34 #include <fcntl.h>
  35 #include <unistd.h>
  36 #include <stdarg.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <stdio.h>
  40 #include <sys/stat.h>
  41 #include <sys/types.h>
  42 #include "ncc.h"
  43
  44 #define ALIGN(x, a)             (((x) + (a) - 1) & ~((a) - 1))
  45 #define MIN(a, b)               ((a) < (b) ? (a) : (b))
  46 #define MAX(a, b)               ((a) < (b) ? (b) : (a))
  47
  48 #define TYPE_BT(t)              ((t)->ptr ? ULNG : (t)->bt)
  49 #define TYPE_SZ(t)              ((t)->ptr ? ULNG : (t)->bt & T_MSIZE)
  50 #define TYPE_VOID(t)            (!(t)->bt && !(t)->flags && !(t)->ptr)
  51
  52 /* type->flag values */
  53 #define T_ARRAY         0x01
  54 #define T_STRUCT        0x02
  55 #define T_FUNC          0x04
  56
  57 /* variable definition flags */
  58 #define F_STATIC        0x01
  59 #define F_EXTERN        0x02
  60
  61 struct type {
  62         unsigned bt;
  63         unsigned flags;
  64         int ptr;
  65         int id;         /* for structs, functions and arrays */
  66         int addr;       /* the address is passed to gen.c; deref for value */
  67 };
  68
  69 /* type stack */
  70 static struct type ts[NTMPS];
  71 static int nts;
  72
  73 static void ts_push_bt(unsigned bt)
  74 {
  75         ts[nts].ptr = 0;
  76         ts[nts].flags = 0;
  77         ts[nts].addr = 0;
  78         ts[nts++].bt = bt;
  79 #ifdef NCCWORDCAST
  80         o_cast(bt);             /* casting to architecture word */
  81 #endif
  82 }
  83
  84 static void ts_push(struct type *t)
  85 {
  86         struct type *d = &ts[nts++];
  87         memcpy(d, t, sizeof(*t));
  88 }
  89
  90 static void ts_push_addr(struct type *t)
  91 {
  92         ts_push(t);
  93         ts[nts - 1].addr = 1;
  94 }
  95
  96 static void ts_pop(struct type *type)
  97 {
  98         nts--;
  99         if (type)
 100                 *type = ts[nts];
 101 }
 102
 103 void err(char *fmt, ...)
 104 {
 105         va_list ap;
 106         char msg[512];
 107         va_start(ap, fmt);
 108         vsprintf(msg, fmt, ap);
 109         va_end(ap);
 110         die("%s: %s", cpp_loc(tok_addr()), msg);
 111 }
 112
 113 void *mextend(void *old, long oldsz, long newsz, long memsz)
 114 {
 115         void *new = malloc(newsz * memsz);
 116         memcpy(new, old, oldsz * memsz);
 117         memset(new + oldsz * memsz, 0, (newsz - oldsz) * memsz);
 118         free(old);
 119         return new;
 120 }
 121
 122 struct name {
 123         char name[NAMELEN];
 124         char elfname[NAMELEN];  /* local elf name for function static variables */
 125         struct type type;
 126         long addr;              /* local stack offset, global data addr, struct offset */
 127 };
 128
 129 static struct name *locals;
 130 static int locals_n, locals_sz;
 131 static struct name *globals;
 132 static int globals_n, globals_sz;
 133
 134 static void local_add(struct name *name)
 135 {
 136         if (locals_n >= locals_sz) {
 137                 locals_sz = MAX(128, locals_sz * 2);
 138                 locals = mextend(locals, locals_n, locals_sz, sizeof(locals[0]));
 139         }
 140         memcpy(&locals[locals_n++], name, sizeof(*name));
 141 }
 142
 143 static int local_find(char *name)
 144 {
 145         int i;
 146         for (i = locals_n - 1; i >= 0; --i)
 147                 if (!strcmp(locals[i].name, name))
 148                         return i;
 149         return -1;
 150 }
 151
 152 static int global_find(char *name)
 153 {
 154         int i;
 155         for (i = globals_n - 1; i >= 0; i--)
 156                 if (!strcmp(name, globals[i].name))
 157                         return i;
 158         return -1;
 159 }
 160
 161 static void global_add(struct name *name)
 162 {
 163         if (globals_n >= globals_sz) {
 164                 globals_sz = MAX(128, globals_sz * 2);
 165                 globals = mextend(globals, globals_n, globals_sz, sizeof(globals[0]));
 166         }
 167         memcpy(&globals[globals_n++], name, sizeof(*name));
 168 }
 169
 170 #define LABEL()                 (++label)
 171
 172 static int label;               /* last used label id */
 173 static int l_break;             /* current break label */
 174 static int l_cont;              /* current continue label */
 175
 176 static struct enumval {
 177         char name[NAMELEN];
 178         int n;
 179 } *enums;
 180 static int enums_n, enums_sz;
 181
 182 static void enum_add(char *name, int val)
 183 {
 184         struct enumval *ev;
 185         if (enums_n >= enums_sz) {
 186                 enums_sz = MAX(128, enums_sz * 2);
 187                 enums = mextend(enums, enums_n, enums_sz, sizeof(enums[0]));
 188         }
 189         ev = &enums[enums_n++];
 190         strcpy(ev->name, name);
 191         ev->n = val;
 192 }
 193
 194 static int enum_find(int *val, char *name)
 195 {
 196         int i;
 197         for (i = enums_n - 1; i >= 0; --i)
 198                 if (!strcmp(name, enums[i].name)) {
 199                         *val = enums[i].n;
 200                         return 0;
 201                 }
 202         return 1;
 203 }
 204
 205 static struct typdefinfo {
 206         char name[NAMELEN];
 207         struct type type;
 208 } *typedefs;
 209 static int typedefs_n, typedefs_sz;
 210
 211 static void typedef_add(char *name, struct type *type)
 212 {
 213         struct typdefinfo *ti;
 214         if (typedefs_n >= typedefs_sz) {
 215                 typedefs_sz = MAX(128, typedefs_sz * 2);
 216                 typedefs = mextend(typedefs, typedefs_n, typedefs_sz,
 217                                         sizeof(typedefs[0]));
 218         }
 219         ti = &typedefs[typedefs_n++];
 220         strcpy(ti->name, name);
 221         memcpy(&ti->type, type, sizeof(*type));
 222 }
 223
 224 static int typedef_find(char *name)
 225 {
 226         int i;
 227         for (i = typedefs_n - 1; i >= 0; --i)
 228                 if (!strcmp(name, typedefs[i].name))
 229                         return i;
 230         return -1;
 231 }
 232
 233 static struct array {
 234         struct type type;
 235         int n;
 236 } *arrays;
 237 static int arrays_n, arrays_sz;
 238
 239 static int array_add(struct type *type, int n)
 240 {
 241         struct array *a;
 242         if (arrays_n >= arrays_sz) {
 243                 arrays_sz = MAX(128, arrays_sz * 2);
 244                 arrays = mextend(arrays, arrays_n, arrays_sz, sizeof(arrays[0]));
 245         }
 246         a = &arrays[arrays_n++];
 247         memcpy(&a->type, type, sizeof(*type));
 248         a->n = n;
 249         return a - arrays;
 250 }
 251
 252 static void array2ptr(struct type *t)
 253 {
 254         if (t->flags & T_ARRAY && !t->ptr) {
 255                 memcpy(t, &arrays[t->id].type, sizeof(*t));
 256                 t->ptr++;
 257         }
 258 }
 259
 260 static struct structinfo {
 261         char name[NAMELEN];
 262         struct name fields[NFIELDS];
 263         int nfields;
 264         int isunion;
 265         int size;
 266 } *structs;
 267 static int structs_n, structs_sz;
 268
 269 static int struct_find(char *name, int isunion)
 270 {
 271         int i;
 272         for (i = structs_n - 1; i >= 0; --i)
 273                 if (*structs[i].name && !strcmp(name, structs[i].name) &&
 274                                 structs[i].isunion == isunion)
 275                         return i;
 276         if (structs_n >= structs_sz) {
 277                 structs_sz = MAX(128, structs_sz * 2);
 278                 structs = mextend(structs, structs_n, structs_sz, sizeof(structs[0]));
 279         }
 280         i = structs_n++;
 281         memset(&structs[i], 0, sizeof(structs[i]));
 282         strcpy(structs[i].name, name);
 283         structs[i].isunion = isunion;
 284         return i;
 285 }
 286
 287 static struct name *struct_field(int id, char *name)
 288 {
 289         struct structinfo *si = &structs[id];
 290         int i;
 291         for (i = 0; i < si->nfields; i++)
 292                 if (!strcmp(name, si->fields[i].name))
 293                         return &si->fields[i];
 294         err("unknown field <%s>\n", name);
 295         return NULL;
 296 }
 297
 298 /* return t's size */
 299 static int type_totsz(struct type *t)
 300 {
 301         if (t->ptr)
 302                 return ULNG;
 303         if (t->flags & T_ARRAY)
 304                 return arrays[t->id].n * type_totsz(&arrays[t->id].type);
 305         return t->flags & T_STRUCT ? structs[t->id].size : T_SZ(t->bt);
 306 }
 307
 308 /* return t's dereferenced size */
 309 static unsigned type_szde(struct type *t)
 310 {
 311         struct type de = *t;
 312         array2ptr(&de);
 313         de.ptr--;
 314         return type_totsz(&de);
 315 }
 316
 317 /* dereference stack top if t->addr (ie. address is pushed to gen.c) */
 318 static void ts_de(int deref)
 319 {
 320         struct type *t = &ts[nts - 1];
 321         array2ptr(t);
 322         if (deref && t->addr && (t->ptr || !(t->flags & T_FUNC)))
 323                 o_deref(TYPE_BT(t));
 324         t->addr = 0;
 325 }
 326
 327 /* pop stack pop to *t and dereference if t->addr */
 328 static void ts_pop_de(struct type *t)
 329 {
 330         ts_de(1);
 331         ts_pop(t);
 332 }
 333
 334 /* pop the top 2 stack values and dereference them if t->addr */
 335 static void ts_pop_de2(struct type *t1, struct type *t2)
 336 {
 337         ts_pop_de(t1);
 338         o_tmpswap();
 339         ts_pop_de(t2);
 340         o_tmpswap();
 341 }
 342
 343 /* the previous identifier; to handle labels */
 344 static char tok_previden[NAMELEN];
 345
 346 static char *tok_iden(void)
 347 {
 348         snprintf(tok_previden, sizeof(tok_previden), "%s", tok_get());
 349         return tok_previden;
 350 }
 351
 352 static int tok_jmp(char *tok)
 353 {
 354         if (strcmp(tok, tok_see()))
 355                 return 1;
 356         tok_get();
 357         return 0;
 358 }
 359
 360 static int tok_comes(char *tok)
 361 {
 362         return !strcmp(tok, tok_see());
 363 }
 364
 365 static void tok_req(char *tok)
 366 {
 367         char *got = tok_get();
 368         if (strcmp(tok, got))
 369                 err("syntax error (expected <%s> but got <%s>)\n", tok, got);
 370 }
 371
 372 static int tok_grp(void)
 373 {
 374         int c = (unsigned char) tok_see()[0];
 375         if (c == '"')
 376                 return '"';
 377         if (c == '\'' || isdigit(c))
 378                 return '0';
 379         if (c == '_' || isalpha(c))
 380                 return 'a';
 381         return 0;
 382 }
 383
 384 /* the result of a binary operation on variables of type bt1 and bt2 */
 385 static unsigned bt_op(unsigned bt1, unsigned bt2)
 386 {
 387         int sz = MAX(T_SZ(bt1), T_SZ(bt2));
 388         return ((bt1 | bt2) & T_MSIGN) | MAX(sz, UINT);
 389 }
 390
 391 /* the result of a unary operation on variables of bt */
 392 static unsigned bt_uop(unsigned bt)
 393 {
 394         return bt_op(bt, UINT);
 395 }
 396
 397 /* push the result of a binary operation on the type stack */
 398 static void ts_binop(int op)
 399 {
 400         struct type t1, t2;
 401         unsigned bt1, bt2, bt;
 402         ts_pop_de2(&t1, &t2);
 403         bt1 = TYPE_BT(&t1);
 404         bt2 = TYPE_BT(&t2);
 405         bt = bt_op(bt1, bt2);
 406         if (op == O_DIV || op == O_MOD)
 407                 bt = T_MK(bt2 & T_MSIGN, bt);
 408         o_bop(O_MK(op, bt));
 409         ts_push_bt(bt);
 410 }
 411
 412 /* push the result of an additive binary operation on the type stack */
 413 static void ts_addop(int op)
 414 {
 415         struct type t1, t2;
 416         ts_pop_de2(&t1, &t2);
 417         if (!t1.ptr && !t2.ptr) {
 418                 o_bop(op);
 419                 ts_push_bt(bt_op(TYPE_BT(&t1), TYPE_BT(&t2)));
 420                 return;
 421         }
 422         if (t1.ptr && !t2.ptr)
 423                 o_tmpswap();
 424         if (!t1.ptr && t2.ptr)
 425                 if (type_szde(&t2) > 1) {
 426                         o_num(type_szde(&t2));
 427                         o_bop(O_MUL);
 428                 }
 429         if (t1.ptr && !t2.ptr)
 430                 o_tmpswap();
 431         o_bop(op);
 432         if (t1.ptr && t2.ptr) {
 433                 int sz = type_szde(&t1);
 434                 if (sz > 1) {
 435                         o_num(sz);
 436                         o_bop(O_DIV);
 437                 }
 438                 ts_push_bt(SLNG);
 439         } else {
 440                 ts_push(t1.ptr ? &t1 : &t2);
 441         }
 442 }
 443
 444 /* function prototypes for parsing function and variable declarations */
 445 static int readname(struct type *main, char *name, struct type *base);
 446 static int readtype(struct type *type);
 447 static int readdefs(void (*def)(long data, struct name *name, unsigned flags),
 448                         long data);
 449 static int readdefs_int(void (*def)(long data, struct name *name, unsigned flags),
 450                         long data);
 451
 452 /* function prototypes for parsing initializer expressions */
 453 static int initsize(void);
 454 static void initexpr(struct type *t, int off, void *obj,
 455                 void (*set)(void *obj, int off, struct type *t));
 456
 457 static int type_alignment(struct type *t)
 458 {
 459         if (t->flags & T_ARRAY && !t->ptr)
 460                 return type_alignment(&arrays[t->id].type);
 461         if (t->flags & T_STRUCT && !t->ptr)
 462                 return type_alignment(&structs[t->id].fields[0].type);
 463         return MIN(ULNG, type_totsz(t));
 464 }
 465
 466 static void structdef(long data, struct name *name, unsigned flags)
 467 {
 468         struct structinfo *si = &structs[data];
 469         if (si->isunion) {
 470                 name->addr = 0;
 471                 if (si->size < type_totsz(&name->type))
 472                         si->size = type_totsz(&name->type);
 473         } else {
 474                 struct type *t = &name->type;
 475                 int alignment = type_alignment(t);
 476                 if (t->flags & T_ARRAY && !t->ptr)
 477                         alignment = MIN(ULNG, type_totsz(&arrays[t->id].type));
 478                 si->size = ALIGN(si->size, alignment);
 479                 name->addr = si->size;
 480                 si->size += type_totsz(&name->type);
 481         }
 482         memcpy(&si->fields[si->nfields++], name, sizeof(*name));
 483 }
 484
 485 static int struct_create(char *name, int isunion)
 486 {
 487         int id = struct_find(name, isunion);
 488         tok_req("{");
 489         while (tok_jmp("}")) {
 490                 readdefs(structdef, id);
 491                 tok_req(";");
 492         }
 493         return id;
 494 }
 495
 496 static void readexpr(void);
 497
 498 static void enum_create(void)
 499 {
 500         long n = 0;
 501         tok_req("{");
 502         while (tok_jmp("}")) {
 503                 char name[NAMELEN];
 504                 strcpy(name, tok_get());
 505                 if (!tok_jmp("=")) {
 506                         readexpr();
 507                         ts_pop_de(NULL);
 508                         if (o_popnum(&n))
 509                                 err("const expr expected!\n");
 510                 }
 511                 enum_add(name, n++);
 512                 tok_jmp(",");
 513         }
 514 }
 515
 516 /* used to differentiate labels from case and cond exprs */
 517 static int ncexpr;
 518 static int caseexpr;
 519
 520 static void readpre(void);
 521
 522 static char *tmp_str(char *buf, int len)
 523 {
 524         static char name[NAMELEN];
 525         static int id;
 526         sprintf(name, "__neatcc.s%d", id++);
 527         buf[len] = '\0';
 528         o_dscpy(o_dsnew(name, len + 1, 0), buf, len + 1);
 529         return name;
 530 }
 531
 532 static void readprimary(void)
 533 {
 534         if (tok_grp() == '0') {
 535                 long n;
 536                 int bt = tok_num(tok_get(), &n);
 537                 o_num(n);
 538                 ts_push_bt(bt);
 539                 return;
 540         }
 541         if (tok_grp() == '"') {
 542                 struct type t = {};     /* char type inside the arrays */
 543                 struct type a = {};     /* the char array type */
 544                 char *buf = tok_get() + 1;
 545                 int len = tok_len() - 2;
 546                 t.bt = 1 | T_MSIGN;
 547                 a.id = array_add(&t, len + 1);
 548                 a.flags = T_ARRAY;
 549                 o_sym(tmp_str(buf, len));
 550                 ts_push(&a);
 551                 return;
 552         }
 553         if (tok_grp() == 'a') {
 554                 struct name unkn = {""};
 555                 char *name = unkn.name;
 556                 int n;
 557                 strcpy(name, tok_iden());
 558                 /* don't search for labels here */
 559                 if (!ncexpr && !caseexpr && tok_comes(":"))
 560                         return;
 561                 if ((n = local_find(name)) != -1) {
 562                         struct name *l = &locals[n];
 563                         o_local(l->addr);
 564                         ts_push_addr(&l->type);
 565                         return;
 566                 }
 567                 if ((n = global_find(name)) != -1) {
 568                         struct name *g = &globals[n];
 569                         o_sym(*g->elfname ? g->elfname : g->name);
 570                         ts_push_addr(&g->type);
 571                         return;
 572                 }
 573                 if (!enum_find(&n, name)) {
 574                         o_num(n);
 575                         ts_push_bt(SINT);
 576                         return;
 577                 }
 578                 if (!tok_comes("("))
 579                         err("unknown symbol <%s>\n", name);
 580                 global_add(&unkn);
 581                 o_sym(unkn.name);
 582                 ts_push_bt(ULNG);
 583                 return;
 584         }
 585         if (!tok_jmp("(")) {
 586                 struct type t;
 587                 if (!readtype(&t)) {
 588                         struct type o;
 589                         tok_req(")");
 590                         readpre();
 591                         ts_pop_de(&o);
 592                         ts_push(&t);
 593                         if (!t.ptr || !o.ptr)
 594                                 o_cast(TYPE_BT(&t));
 595                 } else {
 596                         readexpr();
 597                         while (tok_jmp(")")) {
 598                                 tok_req(",");
 599                                 ts_pop(NULL);
 600                                 o_tmpdrop(1);
 601                                 readexpr();
 602                         }
 603                 }
 604                 return;
 605         }
 606 }
 607
 608 static void arrayderef(void)
 609 {
 610         struct type t;
 611         int sz;
 612         ts_pop_de(NULL);
 613         ts_pop(&t);
 614         if (!(t.flags & T_ARRAY && !t.ptr) && t.addr) {
 615                 o_tmpswap();
 616                 o_deref(TYPE_BT(&t));
 617                 o_tmpswap();
 618         }
 619         array2ptr(&t);
 620         t.ptr--;
 621         sz = type_totsz(&t);
 622         t.addr = 1;
 623         if (sz > 1) {
 624                 o_num(sz);
 625                 o_bop(O_MUL);
 626         }
 627         o_bop(O_ADD);
 628         ts_push(&t);
 629 }
 630
 631 static void inc_post(int op)
 632 {
 633         struct type t = ts[nts - 1];
 634         /* pushing the value before inc */
 635         o_tmpcopy();
 636         ts_de(1);
 637         o_tmpswap();
 638
 639         /* increment by 1 or pointer size */
 640         o_tmpcopy();
 641         ts_push(&t);
 642         ts_pop_de(&t);
 643         o_num(t.ptr > 0 ? type_szde(&t) : 1);
 644         o_bop(op);
 645
 646         /* assign back */
 647         o_assign(TYPE_BT(&t));
 648         o_tmpdrop(1);
 649 }
 650
 651 static void readfield(void)
 652 {
 653         struct name *field;
 654         struct type t;
 655         ts_pop(&t);
 656         array2ptr(&t);
 657         field = struct_field(t.id, tok_get());
 658         if (field->addr) {
 659                 o_num(field->addr);
 660                 o_bop(O_ADD);
 661         }
 662         ts_push_addr(&field->type);
 663 }
 664
 665 static struct funcinfo {
 666         struct type args[NARGS];
 667         struct type ret;
 668         int nargs;
 669         int varg;
 670         /* function and argument names; useful only when defining */
 671         char argnames[NARGS][NAMELEN];
 672         char name[NAMELEN];
 673 } *funcs;
 674 static int funcs_n, funcs_sz;
 675
 676 static int func_create(struct type *ret, char *name, char argnames[][NAMELEN],
 677                         struct type *args, int nargs, int varg)
 678 {
 679         struct funcinfo *fi;
 680         int i;
 681         if (funcs_n >= funcs_sz) {
 682                 funcs_sz = MAX(128, funcs_sz * 2);
 683                 funcs = mextend(funcs, funcs_n, funcs_sz, sizeof(funcs[0]));
 684         }
 685         fi = &funcs[funcs_n++];
 686         memcpy(&fi->ret, ret, sizeof(*ret));
 687         for (i = 0; i < nargs; i++)
 688                 memcpy(&fi->args[i], &args[i], sizeof(*ret));
 689         fi->nargs = nargs;
 690         fi->varg = varg;
 691         strcpy(fi->name, name ? name : "");
 692         for (i = 0; i < nargs; i++)
 693                 strcpy(fi->argnames[i], argnames[i]);
 694         return fi - funcs;
 695 }
 696
 697 static void readcall(void)
 698 {
 699         struct type t;
 700         struct funcinfo *fi;
 701         int argc = 0;
 702         ts_pop(&t);
 703         if (t.flags & T_FUNC && t.ptr > 0)
 704                 o_deref(ULNG);
 705         if (!tok_comes(")")) {
 706                 do {
 707                         readexpr();
 708                         ts_pop_de(NULL);
 709                         argc++;
 710                 } while (!tok_jmp(","));
 711         }
 712         tok_req(")");
 713         fi = t.flags & T_FUNC ? &funcs[t.id] : NULL;
 714         o_call(argc, fi ? TYPE_BT(&fi->ret) : SINT);
 715         if (fi) {
 716                 if (TYPE_BT(&fi->ret))
 717                         o_cast(TYPE_BT(&fi->ret));
 718                 ts_push(&fi->ret);
 719         } else {
 720                 ts_push_bt(SINT);
 721         }
 722 }
 723
 724 static void readpost(void)
 725 {
 726         readprimary();
 727         while (1) {
 728                 if (!tok_jmp("[")) {
 729                         readexpr();
 730                         tok_req("]");
 731                         arrayderef();
 732                         continue;
 733                 }
 734                 if (!tok_jmp("(")) {
 735                         readcall();
 736                         continue;
 737                 }
 738                 if (!tok_jmp("++")) {
 739                         inc_post(O_ADD);
 740                         continue;
 741                 }
 742                 if (!tok_jmp("--")) {
 743                         inc_post(O_SUB);
 744                         continue;
 745                 }
 746                 if (!tok_jmp(".")) {
 747                         readfield();
 748                         continue;
 749                 }
 750                 if (!tok_jmp("->")) {
 751                         ts_de(1);
 752                         readfield();
 753                         continue;
 754                 }
 755                 break;
 756         }
 757 }
 758
 759 static void inc_pre(int op)
 760 {
 761         struct type t;
 762         readpre();
 763         /* copy the destination */
 764         o_tmpcopy();
 765         ts_push(&ts[nts - 1]);
 766         /* increment by 1 or pointer size */
 767         ts_pop_de(&t);
 768         o_num(t.ptr > 0 ? type_szde(&t) : 1);
 769         o_bop(op);
 770         /* assign the result */
 771         o_assign(TYPE_BT(&t));
 772         ts_de(0);
 773 }
 774
 775 static void readpre(void)
 776 {
 777         struct type t;
 778         if (!tok_jmp("&")) {
 779                 readpre();
 780                 ts_pop(&t);
 781                 if (!t.addr)
 782                         err("cannot use the address\n");
 783                 t.ptr++;
 784                 t.addr = 0;
 785                 ts_push(&t);
 786                 return;
 787         }
 788         if (!tok_jmp("*")) {
 789                 readpre();
 790                 ts_pop(&t);
 791                 array2ptr(&t);
 792                 if (!t.ptr)
 793                         err("dereferencing non-pointer\n");
 794                 if (t.addr)
 795                         o_deref(TYPE_BT(&t));
 796                 t.ptr--;
 797                 t.addr = 1;
 798                 ts_push(&t);
 799                 return;
 800         }
 801         if (!tok_jmp("!")) {
 802                 readpre();
 803                 ts_pop_de(NULL);
 804                 o_uop(O_LNOT);
 805                 ts_push_bt(SINT);
 806                 return;
 807         }
 808         if (!tok_jmp("+")) {
 809                 readpre();
 810                 ts_de(1);
 811                 ts_pop(&t);
 812                 ts_push_bt(bt_uop(TYPE_BT(&t)));
 813                 return;
 814         }
 815         if (!tok_jmp("-")) {
 816                 readpre();
 817                 ts_de(1);
 818                 ts_pop(&t);
 819                 o_uop(O_NEG);
 820                 ts_push_bt(bt_uop(TYPE_BT(&t)));
 821                 return;
 822         }
 823         if (!tok_jmp("~")) {
 824                 readpre();
 825                 ts_de(1);
 826                 ts_pop(&t);
 827                 o_uop(O_NOT);
 828                 ts_push_bt(bt_uop(TYPE_BT(&t)));
 829                 return;
 830         }
 831         if (!tok_jmp("++")) {
 832                 inc_pre(O_ADD);
 833                 return;
 834         }
 835         if (!tok_jmp("--")) {
 836                 inc_pre(O_SUB);
 837                 return;
 838         }
 839         if (!tok_jmp("sizeof")) {
 840                 struct type t;
 841                 int op = !tok_jmp("(");
 842                 if (readtype(&t)) {
 843                         long m = o_mark();
 844                         if (op)
 845                                 readexpr();
 846                         else
 847                                 readpre();
 848                         o_back(m);
 849                         ts_pop(&t);
 850                         o_tmpdrop(1);
 851                 }
 852                 o_num(type_totsz(&t));
 853                 ts_push_bt(ULNG);
 854                 if (op)
 855                         tok_req(")");
 856                 return;
 857         }
 858         readpost();
 859 }
 860
 861 static void readmul(void)
 862 {
 863         readpre();
 864         while (1) {
 865                 if (!tok_jmp("*")) {
 866                         readpre();
 867                         ts_binop(O_MUL);
 868                         continue;
 869                 }
 870                 if (!tok_jmp("/")) {
 871                         readpre();
 872                         ts_binop(O_DIV);
 873                         continue;
 874                 }
 875                 if (!tok_jmp("%")) {
 876                         readpre();
 877                         ts_binop(O_MOD);
 878                         continue;
 879                 }
 880                 break;
 881         }
 882 }
 883
 884 static void readadd(void)
 885 {
 886         readmul();
 887         while (1) {
 888                 if (!tok_jmp("+")) {
 889                         readmul();
 890                         ts_addop(O_ADD);
 891                         continue;
 892                 }
 893                 if (!tok_jmp("-")) {
 894                         readmul();
 895                         ts_addop(O_SUB);
 896                         continue;
 897                 }
 898                 break;
 899         }
 900 }
 901
 902 static void shift(int op)
 903 {
 904         struct type t;
 905         readadd();
 906         ts_pop_de2(NULL, &t);
 907         o_bop(O_MK(op, TYPE_BT(&t)));
 908         ts_push_bt(bt_uop(TYPE_BT(&t)));
 909 }
 910
 911 static void readshift(void)
 912 {
 913         readadd();
 914         while (1) {
 915                 if (!tok_jmp("<<")) {
 916                         shift(O_SHL);
 917                         continue;
 918                 }
 919                 if (!tok_jmp(">>")) {
 920                         shift(O_SHR);
 921                         continue;
 922                 }
 923                 break;
 924         }
 925 }
 926
 927 static void cmp(int op)
 928 {
 929         struct type t1, t2;
 930         int bt;
 931         readshift();
 932         ts_pop_de2(&t1, &t2);
 933         bt = bt_op(TYPE_BT(&t1), TYPE_BT(&t2));
 934         o_bop(O_MK(op, bt));
 935         ts_push_bt(SINT);
 936 }
 937
 938 static void readcmp(void)
 939 {
 940         readshift();
 941         while (1) {
 942                 if (!tok_jmp("<")) {
 943                         cmp(O_LT);
 944                         continue;
 945                 }
 946                 if (!tok_jmp(">")) {
 947                         cmp(O_GT);
 948                         continue;
 949                 }
 950                 if (!tok_jmp("<=")) {
 951                         cmp(O_LE);
 952                         continue;
 953                 }
 954                 if (!tok_jmp(">=")) {
 955                         cmp(O_GE);
 956                         continue;
 957                 }
 958                 break;
 959         }
 960 }
 961
 962 static void eq(int op)
 963 {
 964         readcmp();
 965         ts_pop_de2(NULL, NULL);
 966         o_bop(op);
 967         ts_push_bt(SINT);
 968 }
 969
 970 static void readeq(void)
 971 {
 972         readcmp();
 973         while (1) {
 974                 if (!tok_jmp("==")) {
 975                         eq(O_EQ);
 976                         continue;
 977                 }
 978                 if (!tok_jmp("!=")) {
 979                         eq(O_NE);
 980                         continue;
 981                 }
 982                 break;
 983         }
 984 }
 985
 986 static void readbitand(void)
 987 {
 988         readeq();
 989         while (!tok_jmp("&")) {
 990                 readeq();
 991                 ts_binop(O_AND);
 992         }
 993 }
 994
 995 static void readxor(void)
 996 {
 997         readbitand();
 998         while (!tok_jmp("^")) {
 999                 readbitand();
1000                 ts_binop(O_XOR);
1001         }
1002 }
1003
1004 static void readbitor(void)
1005 {
1006         readxor();
1007         while (!tok_jmp("|")) {
1008                 readxor();
1009                 ts_binop(O_OR);
1010         }
1011 }
1012
1013 static void savelocal(long val, int bt)
1014 {
1015         o_local(val);
1016         o_tmpswap();
1017         o_assign(bt);
1018         o_tmpdrop(1);
1019 }
1020
1021 static void loadlocal(long val, int bt)
1022 {
1023         o_local(val);
1024         o_deref(bt);
1025         o_rmlocal(val, bt);
1026 }
1027
1028 static void readand(void)
1029 {
1030         int l_out, l_fail;
1031         long val;
1032         readbitor();
1033         if (!tok_comes("&&"))
1034                 return;
1035         val = o_mklocal(UINT);
1036         l_out = LABEL();
1037         l_fail = LABEL();
1038         ts_pop_de(NULL);
1039         o_jz(l_fail);
1040         while (!tok_jmp("&&")) {
1041                 readbitor();
1042                 ts_pop_de(NULL);
1043                 o_jz(l_fail);
1044         }
1045         o_num(1);
1046         savelocal(val, UINT);
1047         o_jmp(l_out);
1048         o_label(l_fail);
1049         o_num(0);
1050         savelocal(val, UINT);
1051         o_label(l_out);
1052         loadlocal(val, SINT);
1053         ts_push_bt(SINT);
1054 }
1055
1056 static void reador(void)
1057 {
1058         int l_pass, l_end;
1059         long val;
1060         readand();
1061         if (!tok_comes("||"))
1062                 return;
1063         val = o_mklocal(UINT);
1064         l_pass = LABEL();
1065         l_end = LABEL();
1066         ts_pop_de(NULL);
1067         o_uop(O_LNOT);
1068         o_jz(l_pass);
1069         while (!tok_jmp("||")) {
1070                 readand();
1071                 ts_pop_de(NULL);
1072                 o_uop(O_LNOT);
1073                 o_jz(l_pass);
1074         }
1075         o_num(0);
1076         savelocal(val, SINT);
1077         o_jmp(l_end);
1078         o_label(l_pass);
1079         o_num(1);
1080         savelocal(val, SINT);
1081         o_label(l_end);
1082         loadlocal(val, SINT);
1083         ts_push_bt(SINT);
1084 }
1085
1086 static void readcexpr(void);
1087
1088 static int readcexpr_const(void)
1089 {
1090         long c, m = 0;
1091         if (o_popnum(&c))
1092                 return -1;
1093         if (!c)
1094                 m = o_mark();
1095         readcexpr();
1096         /* both branches yield the same type; so ignore the first */
1097         ts_pop_de(NULL);
1098         tok_req(":");
1099         if (!c) {
1100                 o_back(m);
1101                 o_tmpdrop(1);
1102         }
1103         if (c)
1104                 m = o_mark();
1105         readcexpr();
1106         /* making sure t->addr == 0 on both branches */
1107         ts_de(1);
1108         if (c) {
1109                 o_back(m);
1110                 o_tmpdrop(1);
1111         }
1112         return 0;
1113 }
1114
1115 static void readcexpr(void)
1116 {
1117         reador();
1118         if (tok_jmp("?"))
1119                 return;
1120         ncexpr++;
1121         ts_pop_de(NULL);
1122         if (readcexpr_const()) {
1123                 long val = 0;
1124                 int l_fail = LABEL();
1125                 int l_end = LABEL();
1126                 struct type ret;
1127                 o_jz(l_fail);
1128                 readcexpr();
1129                 /* both branches yield the same type; so ignore the first */
1130                 ts_pop_de(&ret);
1131                 if (!TYPE_VOID(&ret)) {
1132                         val = o_mklocal(ULNG);
1133                         savelocal(val, ULNG);
1134                 }
1135                 o_jmp(l_end);
1136
1137                 tok_req(":");
1138                 o_label(l_fail);
1139                 readcexpr();
1140                 /* making sure t->addr == 0 on both branches */
1141                 ts_de(1);
1142                 if (!TYPE_VOID(&ret)) {
1143                         savelocal(val, ULNG);
1144                 }
1145                 o_label(l_end);
1146                 if (!TYPE_VOID(&ret)) {
1147                         loadlocal(val, ULNG);
1148                 }
1149         }
1150         ncexpr--;
1151 }
1152
1153 static void opassign(int op, int ptrop)
1154 {
1155         struct type t = ts[nts - 1];
1156         o_tmpcopy();
1157         ts_push(&t);
1158         readexpr();
1159         if (op == O_ADD || op == O_SUB)
1160                 ts_addop(op);
1161         else
1162                 ts_binop(op);
1163         o_assign(TYPE_BT(&ts[nts - 2]));
1164         ts_pop(NULL);
1165         ts_de(0);
1166 }
1167
1168 static void doassign(void)
1169 {
1170         struct type t = ts[nts - 1];
1171         if (!t.ptr && t.flags & T_STRUCT) {
1172                 ts_pop(NULL);
1173                 o_num(type_totsz(&t));
1174                 o_memcpy();
1175         } else {
1176                 ts_pop_de(NULL);
1177                 o_assign(TYPE_BT(&ts[nts - 1]));
1178                 ts_de(0);
1179         }
1180 }
1181
1182 static void readexpr(void)
1183 {
1184         readcexpr();
1185         if (!tok_jmp("=")) {
1186                 readexpr();
1187                 doassign();
1188                 return;
1189         }
1190         if (!tok_jmp("+=")) {
1191                 opassign(O_ADD, 1);
1192                 return;
1193         }
1194         if (!tok_jmp("-=")) {
1195                 opassign(O_SUB, 1);
1196                 return;
1197         }
1198         if (!tok_jmp("*=")) {
1199                 opassign(O_MUL, 0);
1200                 return;
1201         }
1202         if (!tok_jmp("/=")) {
1203                 opassign(O_DIV, 0);
1204                 return;
1205         }
1206         if (!tok_jmp("%=")) {
1207                 opassign(O_MOD, 0);
1208                 return;
1209         }
1210         if (!tok_jmp("<<=")) {
1211                 opassign(O_SHL, 0);
1212                 return;
1213         }
1214         if (!tok_jmp(">>=")) {
1215                 opassign(O_SHR, 0);
1216                 return;
1217         }
1218         if (!tok_jmp("&=")) {
1219                 opassign(O_AND, 0);
1220                 return;
1221         }
1222         if (!tok_jmp("|=")) {
1223                 opassign(O_OR, 0);
1224                 return;
1225         }
1226         if (!tok_jmp("^=")) {
1227                 opassign(O_XOR, 0);
1228                 return;
1229         }
1230 }
1231
1232 static void readestmt(void)
1233 {
1234         do {
1235                 o_tmpdrop(-1);
1236                 nts = 0;
1237                 readexpr();
1238         } while (!tok_jmp(","));
1239 }
1240
1241 #define F_GLOBAL(flags)         (!((flags) & F_STATIC))
1242
1243 static void globalinit(void *obj, int off, struct type *t)
1244 {
1245         struct name *name = obj;
1246         char *elfname = *name->elfname ? name->elfname : name->name;
1247         if (t->flags & T_ARRAY && tok_grp() == '"') {
1248                 struct type *t_de = &arrays[t->id].type;
1249                 if (!t_de->ptr && !t_de->flags && TYPE_SZ(t_de) == 1) {
1250                         char *buf = tok_get() + 1;
1251                         int len = tok_len() - 2;
1252                         buf[len] = '\0';
1253                         o_dscpy(name->addr + off, buf, len + 1);
1254                         return;
1255                 }
1256         }
1257         readexpr();
1258         o_dsset(elfname, off, TYPE_BT(t));
1259         ts_pop(NULL);
1260 }
1261
1262 static void readfunc(struct name *name, int flags);
1263
1264 static void globaldef(long data, struct name *name, unsigned flags)
1265 {
1266         struct type *t = &name->type;
1267         char *elfname = *name->elfname ? name->elfname : name->name;
1268         int sz;
1269         if (t->flags & T_ARRAY && !t->ptr && !arrays[t->id].n)
1270                 if (~flags & F_EXTERN)
1271                         arrays[t->id].n = initsize();
1272         sz = type_totsz(t);
1273         if (!(flags & F_EXTERN) && (!(t->flags & T_FUNC) || t->ptr)) {
1274                 if (tok_comes("="))
1275                         name->addr = o_dsnew(elfname, sz, F_GLOBAL(flags));
1276                 else
1277                         o_bsnew(elfname, sz, F_GLOBAL(flags));
1278         }
1279         global_add(name);
1280         if (!tok_jmp("="))
1281                 initexpr(t, 0, name, globalinit);
1282         if (tok_comes("{") && name->type.flags & T_FUNC)
1283                 readfunc(name, flags);
1284 }
1285
1286 /* generate the address of local + off */
1287 static void o_localoff(long addr, int off)
1288 {
1289         o_local(addr);
1290         if (off) {
1291                 o_num(off);
1292                 o_bop(O_ADD);
1293         }
1294 }
1295
1296 static void localinit(void *obj, int off, struct type *t)
1297 {
1298         long addr = *(long *) obj;
1299         if (t->flags & T_ARRAY && tok_grp() == '"') {
1300                 struct type *t_de = &arrays[t->id].type;
1301                 if (!t_de->ptr && !t_de->flags && TYPE_SZ(t_de) == 1) {
1302                         char *buf = tok_get() + 1;
1303                         int len = tok_len() - 2;
1304                         o_localoff(addr, off);
1305                         o_sym(tmp_str(buf, len));
1306                         o_num(len + 1);
1307                         o_memcpy();
1308                         o_tmpdrop(1);
1309                         return;
1310                 }
1311         }
1312         o_localoff(addr, off);
1313         ts_push(t);
1314         readexpr();
1315         doassign();
1316         ts_pop(NULL);
1317         o_tmpdrop(1);
1318 }
1319
1320 /* current function name */
1321 static char func_name[NAMELEN];
1322
1323 static void localdef(long data, struct name *name, unsigned flags)
1324 {
1325         struct type *t = &name->type;
1326         if ((flags & F_EXTERN) || ((t->flags & T_FUNC) && !t->ptr)) {
1327                 global_add(name);
1328                 return;
1329         }
1330         if (flags & F_STATIC) {
1331                 sprintf(name->elfname, "__neatcc.%s.%s", func_name, name->name);
1332                 globaldef(data, name, flags);
1333                 return;
1334         }
1335         if (t->flags & T_ARRAY && !t->ptr && !arrays[t->id].n)
1336                 arrays[t->id].n = initsize();
1337         name->addr = o_mklocal(type_totsz(&name->type));
1338         local_add(name);
1339         if (!tok_jmp("=")) {
1340                 /* this is not necessary for "struct x = y" */
1341                 if (t->flags & (T_ARRAY | T_STRUCT) && !t->ptr) {
1342                         o_local(name->addr);
1343                         o_num(0);
1344                         o_num(type_totsz(t));
1345                         o_memset();
1346                         o_tmpdrop(1);
1347                 }
1348                 initexpr(t, 0, &name->addr, localinit);
1349         }
1350 }
1351
1352 static void typedefdef(long data, struct name *name, unsigned flags)
1353 {
1354         typedef_add(name->name, &name->type);
1355 }
1356
1357 static void readstmt(void);
1358
1359 static void readswitch(void)
1360 {
1361         int o_break = l_break;
1362         long val_addr = o_mklocal(ULNG);
1363         struct type t;
1364         int ncases = 0;                 /* number of case labels */
1365         int l_failed = LABEL();         /* address of last failed jmp */
1366         int l_matched = LABEL();        /* address of last walk through jmp */
1367         int l_default = 0;              /* default case label */
1368         l_break = LABEL();
1369         tok_req("(");
1370         readexpr();
1371         ts_pop_de(&t);
1372         o_local(val_addr);
1373         o_tmpswap();
1374         o_assign(TYPE_BT(&t));
1375         ts_de(0);
1376         o_tmpdrop(1);
1377         tok_req(")");
1378         tok_req("{");
1379         while (tok_jmp("}")) {
1380                 if (!tok_comes("case") && !tok_comes("default")) {
1381                         readstmt();
1382                         continue;
1383                 }
1384                 if (ncases)
1385                         o_jmp(l_matched);
1386                 if (!strcmp("case", tok_get())) {
1387                         o_label(l_failed);
1388                         l_failed = LABEL();
1389                         caseexpr = 1;
1390                         readexpr();
1391                         ts_pop_de(NULL);
1392                         caseexpr = 0;
1393                         o_local(val_addr);
1394                         o_deref(TYPE_BT(&t));
1395                         o_bop(O_EQ);
1396                         o_jz(l_failed);
1397                         o_tmpdrop(1);
1398                 } else {
1399                         if (!ncases)
1400                                 o_jmp(l_failed);
1401                         l_default = LABEL();
1402                         o_label(l_default);
1403                 }
1404                 tok_req(":");
1405                 o_label(l_matched);
1406                 l_matched = LABEL();
1407                 ncases++;
1408         }
1409         o_rmlocal(val_addr, ULNG);
1410         o_jmp(l_break);
1411         o_label(l_failed);
1412         if (l_default)
1413                 o_jmp(l_default);
1414         o_label(l_break);
1415         l_break = o_break;
1416 }
1417
1418 static char (*label_name)[NAMELEN];
1419 static int *label_ids;
1420 static int label_n, label_sz;
1421
1422 static int label_id(char *name)
1423 {
1424         int i;
1425         if (label_n >= label_sz) {
1426                 label_sz = MAX(128, label_sz * 2);
1427                 label_name = mextend(label_name, label_n, label_sz,
1428                                         sizeof(label_name[0]));
1429                 label_ids = mextend(label_ids, label_n, label_sz,
1430                                         sizeof(label_ids[0]));
1431         }
1432         for (i = label_n - 1; i >= 0; --i)
1433                 if (!strcmp(label_name[i], name))
1434                         return label_ids[i];
1435         strcpy(label_name[label_n], name);
1436         label_ids[label_n] = LABEL();
1437         return label_ids[label_n++];
1438 }
1439
1440 static void readstmt(void)
1441 {
1442         o_tmpdrop(-1);
1443         nts = 0;
1444         if (!tok_jmp("{")) {
1445                 int _nlocals = locals_n;
1446                 int _nglobals = globals_n;
1447                 int _nenums = enums_n;
1448                 int _ntypedefs = typedefs_n;
1449                 int _nstructs = structs_n;
1450                 int _nfuncs = funcs_n;
1451                 int _narrays = arrays_n;
1452                 while (tok_jmp("}"))
1453                         readstmt();
1454                 locals_n = _nlocals;
1455                 enums_n = _nenums;
1456                 typedefs_n = _ntypedefs;
1457                 structs_n = _nstructs;
1458                 funcs_n = _nfuncs;
1459                 arrays_n = _narrays;
1460                 globals_n = _nglobals;
1461                 return;
1462         }
1463         if (!readdefs(localdef, 0)) {
1464                 tok_req(";");
1465                 return;
1466         }
1467         if (!tok_jmp("typedef")) {
1468                 readdefs(typedefdef, 0);
1469                 tok_req(";");
1470                 return;
1471         }
1472         if (!tok_jmp("if")) {
1473                 int l_fail = LABEL();
1474                 int l_end = LABEL();
1475                 tok_req("(");
1476                 readestmt();
1477                 tok_req(")");
1478                 ts_pop_de(NULL);
1479                 o_jz(l_fail);
1480                 readstmt();
1481                 if (!tok_jmp("else")) {
1482                         o_jmp(l_end);
1483                         o_label(l_fail);
1484                         readstmt();
1485                         o_label(l_end);
1486                 } else {
1487                         o_label(l_fail);
1488                 }
1489                 return;
1490         }
1491         if (!tok_jmp("while")) {
1492                 int o_break = l_break;
1493                 int o_cont = l_cont;
1494                 l_break = LABEL();
1495                 l_cont = LABEL();
1496                 o_label(l_cont);
1497                 tok_req("(");
1498                 readestmt();
1499                 tok_req(")");
1500                 ts_pop_de(NULL);
1501                 o_jz(l_break);
1502                 readstmt();
1503                 o_jmp(l_cont);
1504                 o_label(l_break);
1505                 l_break = o_break;
1506                 l_cont = o_cont;
1507                 return;
1508         }
1509         if (!tok_jmp("do")) {
1510                 int o_break = l_break;
1511                 int o_cont = l_cont;
1512                 int l_beg = LABEL();
1513                 l_break = LABEL();
1514                 l_cont = LABEL();
1515                 o_label(l_beg);
1516                 readstmt();
1517                 tok_req("while");
1518                 tok_req("(");
1519                 o_label(l_cont);
1520                 readexpr();
1521                 ts_pop_de(NULL);
1522                 o_uop(O_LNOT);
1523                 o_jz(l_beg);
1524                 tok_req(")");
1525                 o_label(l_break);
1526                 tok_req(";");
1527                 l_break = o_break;
1528                 l_cont = o_cont;
1529                 return;
1530         }
1531         if (!tok_jmp("for")) {
1532                 int o_break = l_break;
1533                 int o_cont = l_cont;
1534                 int l_check = LABEL();  /* for condition label */
1535                 int l_body = LABEL();   /* for block label */
1536                 l_cont = LABEL();
1537                 l_break = LABEL();
1538                 tok_req("(");
1539                 if (!tok_comes(";"))
1540                         readestmt();
1541                 tok_req(";");
1542                 o_label(l_check);
1543                 if (!tok_comes(";")) {
1544                         readestmt();
1545                         ts_pop_de(NULL);
1546                         o_jz(l_break);
1547                 }
1548                 tok_req(";");
1549                 o_jmp(l_body);
1550                 o_label(l_cont);
1551                 if (!tok_comes(")"))
1552                         readestmt();
1553                 tok_req(")");
1554                 o_jmp(l_check);
1555                 o_label(l_body);
1556                 readstmt();
1557                 o_jmp(l_cont);
1558                 o_label(l_break);
1559                 l_break = o_break;
1560                 l_cont = o_cont;
1561                 return;
1562         }
1563         if (!tok_jmp("switch")) {
1564                 readswitch();
1565                 return;
1566         }
1567         if (!tok_jmp("return")) {
1568                 int ret = !tok_comes(";");
1569                 if (ret) {
1570                         readexpr();
1571                         ts_pop_de(NULL);
1572                 }
1573                 tok_req(";");
1574                 o_ret(ret);
1575                 return;
1576         }
1577         if (!tok_jmp("break")) {
1578                 tok_req(";");
1579                 o_jmp(l_break);
1580                 return;
1581         }
1582         if (!tok_jmp("continue")) {
1583                 tok_req(";");
1584                 o_jmp(l_cont);
1585                 return;
1586         }
1587         if (!tok_jmp("goto")) {
1588                 o_jmp(label_id(tok_get()));
1589                 tok_req(";");
1590                 return;
1591         }
1592         readestmt();
1593         /* labels */
1594         if (!tok_jmp(":")) {
1595                 o_label(label_id(tok_previden));
1596                 return;
1597         }
1598         tok_req(";");
1599 }
1600
1601 static void readfunc(struct name *name, int flags)
1602 {
1603         struct funcinfo *fi = &funcs[name->type.id];
1604         int i;
1605         strcpy(func_name, fi->name);
1606         o_func_beg(func_name, fi->nargs, F_GLOBAL(flags), fi->varg);
1607         for (i = 0; i < fi->nargs; i++) {
1608                 struct name arg = {"", "", fi->args[i], o_arg2loc(i)};
1609                 strcpy(arg.name, fi->argnames[i]);
1610                 local_add(&arg);
1611         }
1612         label = 0;
1613         label_n = 0;
1614         readstmt();
1615         o_func_end();
1616         func_name[0] = '\0';
1617         locals_n = 0;
1618 }
1619
1620 static void readdecl(void)
1621 {
1622         if (!tok_jmp("typedef")) {
1623                 readdefs(typedefdef, 0);
1624                 tok_req(";");
1625                 return;
1626         }
1627         readdefs_int(globaldef, 0);
1628         tok_jmp(";");
1629 }
1630
1631 static void parse(void)
1632 {
1633         while (tok_jmp(""))
1634                 readdecl();
1635 }
1636
1637 static void compat_macros(void)
1638 {
1639         cpp_define("__STDC__", "");
1640         cpp_define("__linux__", "");
1641         cpp_define(I_ARCH, "");
1642
1643         /* ignored keywords */
1644         cpp_define("const", "");
1645         cpp_define("register", "");
1646         cpp_define("volatile", "");
1647         cpp_define("inline", "");
1648         cpp_define("restrict", "");
1649         cpp_define("__inline__", "");
1650         cpp_define("__restrict__", "");
1651         cpp_define("__attribute__(x)", "");
1652         cpp_define("__builtin_va_list__", "long");
1653 }
1654
1655 static int ncc_opt = 2;
1656
1657 /* return one if the given optimization level is enabled */
1658 int opt(int level)
1659 {
1660         return level <= ncc_opt;
1661 }
1662
1663 int main(int argc, char *argv[])
1664 {
1665         char obj[128] = "";
1666         int ofd;
1667         int i;
1668         compat_macros();
1669         for (i = 1; i < argc && argv[i][0] == '-'; i++) {
1670                 if (argv[i][1] == 'I')
1671                         cpp_path(argv[i][2] ? argv[i] + 2 : argv[++i]);
1672                 if (argv[i][1] == 'O')
1673                         ncc_opt = argv[i][2] ? atoi(argv[i] + 2) : 2;
1674                 if (argv[i][1] == 'D') {
1675                         char *name = argv[i] + 2;
1676                         char *def = "";
1677                         char *eq = strchr(name, '=');
1678                         if (eq) {
1679                                 *eq = '\0';
1680                                 def = eq + 1;
1681                         }
1682                         cpp_define(name, def);
1683                 }
1684                 if (argv[i][1] == 'o')
1685                         strcpy(obj, argv[i][2] ? argv[i] + 2 : argv[++i]);
1686                 if (argv[i][1] == 'h') {
1687                         printf("neatcc: [options] source\n");
1688                         printf("\n");
1689                         printf("Options:\n");
1690                         printf("  -I dir     \tspecify a header directory\n");
1691                         printf("  -o out     \tspecify output file name\n");
1692                         printf("  -Dname=val \tdefine macro\n");
1693                         printf("  -On        \toptimize (-O0 to disable)\n");
1694                         return 0;
1695                 }
1696         }
1697         if (i == argc)
1698                 die("neatcc: no file given\n");
1699         if (cpp_init(argv[i]))
1700                 die("neatcc: cannot open <%s>\n", argv[i]);
1701         out_init(0);
1702         parse();
1703         if (!*obj) {
1704                 strcpy(obj, argv[i]);
1705                 obj[strlen(obj) - 1] = 'o';
1706         }
1707         free(locals);
1708         free(globals);
1709         free(label_name);
1710         free(label_ids);
1711         free(funcs);
1712         free(typedefs);
1713         free(structs);
1714         free(arrays);
1715         tok_done();
1716         ofd = open(obj, O_WRONLY | O_TRUNC | O_CREAT, 0600);
1717         o_write(ofd);
1718         close(ofd);
1719         return 0;
1720 }
1721
1722 \f
1723 /* parsing function and variable declarations */
1724
1725 /* read the base type of a variable */
1726 static int basetype(struct type *type, unsigned *flags)
1727 {
1728         int sign = 1;
1729         int size = UINT;
1730         int done = 0;
1731         int i = 0;
1732         int isunion;
1733         char name[NAMELEN] = "";
1734         *flags = 0;
1735         type->flags = 0;
1736         type->ptr = 0;
1737         type->addr = 0;
1738         while (!done) {
1739                 if (!tok_jmp("static")) {
1740                         *flags |= F_STATIC;
1741                 } else if (!tok_jmp("extern")) {
1742                         *flags |= F_EXTERN;
1743                 } else if (!tok_jmp("void")) {
1744                         sign = 0;
1745                         size = 0;
1746                         done = 1;
1747                 } else if (!tok_jmp("int")) {
1748                         done = 1;
1749                 } else if (!tok_jmp("char")) {
1750                         size = UCHR;
1751                         done = 1;
1752                 } else if (!tok_jmp("short")) {
1753                         size = USHT;
1754                 } else if (!tok_jmp("long")) {
1755                         size = ULNG;
1756                 } else if (!tok_jmp("signed")) {
1757                         sign = 1;
1758                 } else if (!tok_jmp("unsigned")) {
1759                         sign = 0;
1760                 } else if (tok_comes("union") || tok_comes("struct")) {
1761                         isunion = !strcmp("union", tok_get());
1762                         if (tok_grp() == 'a')
1763                                 strcpy(name, tok_get());
1764                         if (tok_comes("{"))
1765                                 type->id = struct_create(name, isunion);
1766                         else
1767                                 type->id = struct_find(name, isunion);
1768                         type->flags |= T_STRUCT;
1769                         type->bt = ULNG;
1770                         return 0;
1771                 } else if (!tok_jmp("enum")) {
1772                         if (tok_grp() == 'a')
1773                                 tok_get();
1774                         if (tok_comes("{"))
1775                                 enum_create();
1776                         type->bt = SINT;
1777                         return 0;
1778                 } else {
1779                         if (tok_grp() == 'a') {
1780                                 int id = typedef_find(tok_see());
1781                                 if (id != -1) {
1782                                         tok_get();
1783                                         memcpy(type, &typedefs[id].type,
1784                                                 sizeof(*type));
1785                                         return 0;
1786                                 }
1787                         }
1788                         if (!i)
1789                                 return 1;
1790                         done = 1;
1791                         continue;
1792                 }
1793                 i++;
1794         }
1795         type->bt = size | (sign ? T_MSIGN : 0);
1796         return 0;
1797 }
1798
1799 static void readptrs(struct type *type)
1800 {
1801         while (!tok_jmp("*")) {
1802                 type->ptr++;
1803                 if (!type->bt)
1804                         type->bt = 1;
1805         }
1806 }
1807
1808 /* read function arguments */
1809 static int readargs(struct type *args, char argnames[][NAMELEN], int *varg)
1810 {
1811         int nargs = 0;
1812         tok_req("(");
1813         *varg = 0;
1814         while (!tok_comes(")")) {
1815                 if (!tok_jmp("...")) {
1816                         *varg = 1;
1817                         break;
1818                 }
1819                 if (readname(&args[nargs], argnames[nargs], NULL)) {
1820                         /* argument has no type, assume int */
1821                         memset(&args[nargs], 0, sizeof(struct type));
1822                         args[nargs].bt = SINT;
1823                         strcpy(argnames[nargs], tok_get());
1824                 }
1825                 /* argument arrays are pointers */
1826                 array2ptr(&args[nargs]);
1827                 nargs++;
1828                 if (tok_jmp(","))
1829                         break;
1830         }
1831         tok_req(")");
1832         /* void argument */
1833         if (nargs == 1 && !TYPE_BT(&args[0]))
1834                 return 0;
1835         return nargs;
1836 }
1837
1838 /* read K&R function arguments */
1839 static void krdef(long data, struct name *name, unsigned flags)
1840 {
1841         struct funcinfo *fi = &funcs[data];
1842         int i;
1843         for (i = 0; i < fi->nargs; i++)
1844                 if (!strcmp(fi->argnames[i], name->name))
1845                         memcpy(&fi->args[i], &name->type, sizeof(name->type));
1846 }
1847
1848 /*
1849  * readarrays() parses array specifiers when reading a definition in
1850  * readname().  The "type" parameter contains the type contained in the
1851  * inner array; for instance, type in "int *a[10][20]" would be an int
1852  * pointer.  When returning, the "type" parameter is changed to point
1853  * to the final array.  The function returns a pointer to the type in
1854  * the inner array; this is useful when the type is not complete yet,
1855  * like when creating an array of function pointers as in
1856  * "int (*f[10])(int)".  If there is no array brackets, NULL is returned.
1857  */
1858 static struct type *readarrays(struct type *type)
1859 {
1860         long arsz[16];
1861         struct type *inner = NULL;
1862         int nar = 0;
1863         int i;
1864         while (!tok_jmp("[")) {
1865                 long n = 0;
1866                 if (tok_jmp("]")) {
1867                         readexpr();
1868                         ts_pop_de(NULL);
1869                         if (o_popnum(&n))
1870                                 err("const expr expected\n");
1871                         tok_req("]");
1872                 }
1873                 arsz[nar++] = n;
1874         }
1875         for (i = nar - 1; i >= 0; i--) {
1876                 type->id = array_add(type, arsz[i]);
1877                 if (!inner)
1878                         inner = &arrays[type->id].type;
1879                 type->flags = T_ARRAY;
1880                 type->bt = ULNG;
1881                 type->ptr = 0;
1882         }
1883         return inner;
1884 }
1885
1886 static struct type *innertype(struct type *t)
1887 {
1888         while (t->flags & T_ARRAY && !t->ptr)
1889                 t = &arrays[t->id].type;
1890         return t;
1891 }
1892
1893 static void innertype_modify(struct type *t, struct type *s)
1894 {
1895         struct type *inner = innertype(t);
1896         int ptr = inner->ptr;
1897         memcpy(inner, s, sizeof(*inner));
1898         inner->ptr = ptr;
1899 }
1900
1901 /*
1902  * readname() reads a variable definition; the name is copied into
1903  * "name" and the type is copied into "main" argument.  The "base"
1904  * argument, if not NULL, indicates the base type of the variable.
1905  * For instance, the base type of "a" and "b" in "int *a, b[10]" is
1906  * "int".  If NULL, basetype() is called directly to read the base
1907  * type of the variable.  readname() returns zero, only if the
1908  * variable can be read.
1909  */
1910 static int readname(struct type *main, char *name, struct type *base)
1911 {
1912         struct type type;       /* the main type */
1913         struct type btype;      /* type before parenthesis; e.g. "int *" in "int *(*p)[10] */
1914         int paren;
1915         unsigned flags;
1916         if (name)
1917                 *name = '\0';
1918         if (!base) {
1919                 if (basetype(&type, &flags))
1920                         return 1;
1921         } else {
1922                 type = *base;
1923         }
1924         readptrs(&type);
1925         paren = !tok_jmp("(");
1926         if (paren) {
1927                 btype = type;
1928                 readptrs(&type);
1929         }
1930         if (tok_grp() == 'a' && name)
1931                 strcpy(name, tok_get());
1932         readarrays(&type);
1933         if (paren)
1934                 tok_req(")");
1935         if (tok_comes("(")) {
1936                 struct type args[NARGS];
1937                 char argnames[NARGS][NAMELEN];
1938                 int varg = 0;
1939                 int nargs = readargs(args, argnames, &varg);
1940                 struct type rtype = type;       /* return type */
1941                 struct type ftype = {0};        /* function type */
1942                 if (paren)
1943                         rtype = btype;
1944                 ftype.flags = T_FUNC;
1945                 ftype.bt = ULNG;
1946                 ftype.id = func_create(&rtype, name, argnames, args, nargs, varg);
1947                 if (paren)
1948                         innertype_modify(&type, &ftype);
1949                 else
1950                         type = ftype;
1951                 if (!tok_comes(";"))
1952                         while (!tok_comes("{") && !readdefs(krdef, type.id))
1953                                 tok_req(";");
1954         } else {
1955                 if (paren && readarrays(&btype))
1956                                 innertype_modify(&type, &btype);
1957         }
1958         *main = type;
1959         return 0;
1960 }
1961
1962 static int readtype(struct type *type)
1963 {
1964         return readname(type, NULL, NULL);
1965 }
1966
1967 /*
1968  * readdefs() reads a variable definition statement.  The definition
1969  * can appear in different contexts: global variables, function
1970  * local variables, struct fields, and typedefs.  For each defined
1971  * variable, def() callback is called with the appropriate name
1972  * struct and flags; the callback should finish parsing the definition
1973  * by possibly reading the initializer expression and saving the name
1974  * struct.
1975  */
1976 static int readdefs(void (*def)(long data, struct name *name, unsigned flags),
1977                         long data)
1978 {
1979         struct type base;
1980         unsigned base_flags;
1981         if (basetype(&base, &base_flags))
1982                 return 1;
1983         if (tok_comes(";") || tok_comes("{"))
1984                 return 0;
1985         do {
1986                 struct name name = {{""}};
1987                 if (readname(&name.type, name.name, &base))
1988                         break;
1989                 def(data, &name, base_flags);
1990         } while (!tok_jmp(","));
1991         return 0;
1992 }
1993
1994 /* just like readdefs, but default to int type; for handling K&R functions */
1995 static int readdefs_int(void (*def)(long data, struct name *name, unsigned flags),
1996                         long data)
1997 {
1998         struct type base;
1999         unsigned flags = 0;
2000         if (basetype(&base, &flags)) {
2001                 if (tok_grp() != 'a')
2002                         return 1;
2003                 memset(&base, 0, sizeof(base));
2004                 base.bt = SINT;
2005         }
2006         if (!tok_comes(";")) {
2007                 do {
2008                         struct name name = {{""}};
2009                         if (readname(&name.type, name.name, &base))
2010                                 break;
2011                         def(data, &name, flags);
2012                 } while (!tok_jmp(","));
2013         }
2014         return 0;
2015 }
2016
2017 \f
2018 /* parsing initializer expressions */
2019
2020 static void jumpbrace(void)
2021 {
2022         int depth = 0;
2023         while (!tok_comes("}") || depth--)
2024                 if (!strcmp("{", tok_get()))
2025                         depth++;
2026         tok_req("}");
2027 }
2028
2029 /* compute the size of the initializer expression */
2030 static int initsize(void)
2031 {
2032         long addr = tok_addr();
2033         int n = 0;
2034         if (tok_jmp("="))
2035                 return 0;
2036         if (tok_grp() == '"') {
2037                 tok_get();
2038                 n = tok_len() - 2 + 1;
2039                 tok_jump(addr);
2040                 return n;
2041         }
2042         tok_req("{");
2043         while (tok_jmp("}")) {
2044                 long idx = n;
2045                 if (!tok_jmp("[")) {
2046                         readexpr();
2047                         ts_pop_de(NULL);
2048                         o_popnum(&idx);
2049                         tok_req("]");
2050                         tok_req("=");
2051                 }
2052                 if (n < idx + 1)
2053                         n = idx + 1;
2054                 while (!tok_comes("}") && !tok_comes(","))
2055                         if (!strcmp("{", tok_get()))
2056                                 jumpbrace();
2057                 tok_jmp(",");
2058         }
2059         tok_jump(addr);
2060         return n;
2061 }
2062
2063 /* read the initializer expression and initialize basic types using set() cb */
2064 static void initexpr(struct type *t, int off, void *obj,
2065                 void (*set)(void *obj, int off, struct type *t))
2066 {
2067         if (tok_jmp("{")) {
2068                 set(obj, off, t);
2069                 return;
2070         }
2071         if (!t->ptr && t->flags & T_STRUCT) {
2072                 struct structinfo *si = &structs[t->id];
2073                 int i;
2074                 for (i = 0; i < si->nfields && !tok_comes("}"); i++) {
2075                         struct name *field = &si->fields[i];
2076                         if (!tok_jmp(".")) {
2077                                 field = struct_field(t->id, tok_get());
2078                                 tok_req("=");
2079                         }
2080                         initexpr(&field->type, off + field->addr, obj, set);
2081                         if (tok_jmp(","))
2082                                 break;
2083                 }
2084         } else if (t->flags & T_ARRAY) {
2085                 struct type t_de = arrays[t->id].type;
2086                 int i;
2087                 /* handling extra braces as in: char s[] = {"sth"} */
2088                 if (TYPE_SZ(&t_de) == 1 && tok_grp() == '"') {
2089                         set(obj, off, t);
2090                         tok_req("}");
2091                         return;
2092                 }
2093                 for (i = 0; !tok_comes("}"); i++) {
2094                         long idx = i;
2095                         struct type it = t_de;
2096                         if (!tok_jmp("[")) {
2097                                 readexpr();
2098                                 ts_pop_de(NULL);
2099                                 o_popnum(&idx);
2100                                 tok_req("]");
2101                                 tok_req("=");
2102                         }
2103                         if (!tok_comes("{") && (tok_grp() != '"' ||
2104                                                 !(it.flags & T_ARRAY)))
2105                                 it = *innertype(&t_de);
2106                         initexpr(&it, off + type_totsz(&it) * idx, obj, set);
2107                         if (tok_jmp(","))
2108                                 break;
2109                 }
2110         }
2111         tok_req("}");
2112 }