git.maemo.org Git - opencv/blob - apps/cvenv/EiC/typesets.c

   1 /* typesets.c
   2  *
   3  *      (C) Copyright Apr 15 1995, Edmond J. Breen.
   4  *                 ALL RIGHTS RESERVED.
   5  * This code may be copied for personal, non-profit use only.
   6  *
   7  * Documentation in:  ../doc/tech_doc/typesets.doc
   8  *
   9  */
  10
  11
  12 /* Modified by Intel OpenCV team. The bug fix has been applied to EiC_castvar function
  13    in order to prevent throwing of errors while parsing ISO C compatible input. */
  14
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17
  18 #include "MachSet.h"
  19 #include "global.h"
  20 #include "lexer.h"
  21 #include "typemod.h"
  22 #include "xalloc.h"
  23 #include "typesets.h"
  24 #include "symbol.h"
  25 #include "parser.h"
  26 #include "error.h"
  27
  28 static void binhint(), binhuint();
  29 static void binhlong(), binhulong(), binhdouble(), binhconst(), binhllong();
  30 extern void EiC_binhlval();
  31
  32 void (*BINFUN[]) () = {
  33     NULL, NULL,         /* t_error,   t_bool, */
  34     binhint, binhint,   /* t_char,    t_uchar, */
  35     binhint, binhint,   /* t_short,   t_ushort */
  36     binhint, binhint,   /* t_int,     t_enum, */
  37     binhuint,           /* t_uint, */
  38
  39     binhlong, binhulong,  /* t_long,    t_ulong, */
  40     binhllong,                 /* t_llong */
  41     binhdouble, binhdouble, /* t_float,   t_double, */
  42     EiC_binhlval, NULL,   /* t_pointer, t_void */
  43     NULL,NULL,            /* t_struct, t_union */
  44     NULL,EiC_binhlval,        /* t_lval,  t_array */
  45
  46 };
  47
  48 typedef unsigned long set_t;
  49 #define ismem(S,m) (((long)1 << (m)) & (S))
  50 #define I(x)       ((long)1 << (x))
  51
  52 #define SETNUM   I(t_char)+I(t_short)+I(t_int)+I(t_enum)+I(t_long)+I(t_llong)
  53 #define SETUNUM  I(t_uchar)+I(t_ushort)+I(t_uint)+I(t_ulong)
  54 #define SETFLOAT I(t_float)+I(t_double)
  55
  56 typedef struct {
  57     set_t Lset;
  58     set_t Rset;
  59 } LRset_t;
  60
  61 LRset_t modLR[] =
  62 {
  63 {SETNUM + SETUNUM,
  64      SETNUM + SETUNUM,}
  65 };
  66
  67 /*
  68  * two pointers cannot be added together
  69  */
  70 LRset_t addLR[] =
  71 {
  72 {SETNUM + SETUNUM + SETFLOAT,
  73      SETNUM + SETUNUM + SETFLOAT},
  74 {I(t_pointer) + I(t_array),
  75      SETNUM + SETUNUM},
  76 {SETNUM + SETUNUM,
  77      I(t_pointer) + I(t_array)},
  78 };
  79
  80 /*
  81  * integrals can be subtracted from a pointer
  82  * but not visa a versa
  83  */
  84 LRset_t subLR[] =
  85 {
  86 {SETNUM + SETUNUM + SETFLOAT,
  87      SETNUM + SETUNUM + SETFLOAT},
  88 {I(t_pointer) + I(t_array),
  89      I(t_pointer) + I(t_array) + SETNUM + SETUNUM},
  90 };
  91
  92 LRset_t multLR[] =
  93 {
  94 {SETNUM + SETUNUM + SETFLOAT ,
  95      SETNUM + SETUNUM + SETFLOAT }};
  96
  97 LRset_t divLR[] =
  98 {
  99 {SETNUM + SETUNUM + SETFLOAT ,
 100      SETNUM + SETUNUM + SETFLOAT}};
 101
 102 LRset_t LTLR[] =
 103 {
 104 {I(t_pointer) + I(t_array) + SETNUM + SETUNUM + SETFLOAT ,
 105      I(t_pointer) + I(t_array) + SETNUM + SETUNUM + SETFLOAT}};
 106
 107 val_t VAL;
 108 typedef struct {
 109 unsigned oper;
 110 LRset_t *LRset;
 111 unsigned N;
 112 } Binset;
 113
 114 Binset BINSET[] =
 115 {
 116     {'+', addLR, sizeof(addLR) / sizeof(LRset_t),},
 117     {'-', subLR, sizeof(subLR) / sizeof(LRset_t),},
 118     {'*', multLR, sizeof(multLR) / sizeof(LRset_t),},
 119     {'/', divLR, sizeof(divLR) / sizeof(LRset_t),},
 120     {'%', modLR, sizeof(modLR) / sizeof(LRset_t),},
 121     {LSHT, modLR, sizeof(modLR) / sizeof(LRset_t),},
 122     {RSHT, modLR, sizeof(modLR) / sizeof(LRset_t),},
 123     {BOR, modLR, sizeof(modLR) / sizeof(LRset_t),},
 124     {XOR, modLR, sizeof(modLR) / sizeof(LRset_t),},
 125     {AND, modLR, sizeof(modLR) / sizeof(LRset_t),},
 126     {LT, LTLR, sizeof(LTLR) / sizeof(LRset_t),},
 127     {LE, LTLR, sizeof(LTLR) / sizeof(LRset_t),},
 128     {EQ, LTLR, sizeof(LTLR) / sizeof(LRset_t),},
 129     {NE, LTLR, sizeof(LTLR) / sizeof(LRset_t),},
 130     {GT, LTLR, sizeof(LTLR) / sizeof(LRset_t),},
 131     {GE, LTLR, sizeof(LTLR) / sizeof(LRset_t),},
 132     {LOR, LTLR, sizeof(LTLR) / sizeof(LRset_t),},
 133     {LAND, LTLR, sizeof(LTLR) / sizeof(LRset_t),},
 134 };
 135
 136
 137 void EiC_castvar(token_t * e1,
 138              token_t * e2, int explicit)
 139 {
 140     /* cast e1 into e2 */
 141     type_expr *t;
 142     if (EiC_gettype(e2->Type) == t_func) {
 143         token_t e3;
 144         EiC_inittoken(&e3);
 145         e3.Type = EiC_copytype(nextType(e2->Type));
 146         EiC_castvar(e1, &e3, explicit);
 147         EiC_freetype(e3.Type);
 148         return;
 149     }
 150     if (EiC_gettype(e2->Type) == t_lval) {
 151         t = e2->Type;
 152         e2->Type = nextType(e2->Type);
 153         EiC_castvar(e1, e2, explicit);
 154         e2->Type = t;
 155         return;
 156     }
 157     if(EiC_gettype(e2->Type) == t_void) {
 158         e1->Type = EiC_addtype(t_void,EiC_freetype(e1->Type));
 159         return;
 160     }
 161
 162     switch (EiC_gettype(e1->Type)) {
 163       CASE_INT:
 164         switch (EiC_gettype(e2->Type)) {
 165           case t_uchar:
 166             EiC_generate(&e1->Code,int2uchar,&e1->Val,0);
 167             break;
 168           case t_ushort:
 169             EiC_generate(&e1->Code,int2ushort,&e1->Val,0);
 170             break;
 171           case t_char: case t_short: case t_int: case t_uint:
 172             break;
 173           CASE_LONG: CASE_ULONG:
 174             if(sizeof(int) != sizeof(long))
 175                 EiC_generate(&e1->Code, int2long, &e1->Val, 0);
 176             break;
 177           case t_llong:
 178             if(sizeof(int) != sizeof(eic_llong))
 179                 EiC_generate(&e1->Code, int2llong, &e1->Val, 0);
 180             break;
 181           CASE_FLOAT:
 182             EiC_generate(&e1->Code, int2double, &e1->Val, 0);
 183             break;
 184           case t_pointer:
 185             EiC_generate(&e1->Code, int2ptr, &e1->Val, 0);
 186             e1->Type = EiC_addtype(t_pointer,e1->Type);
 187             if (!explicit)
 188                 EiC_warningerror("Suspicious pointer conversion");
 189             return;
 190
 191           default:
 192             EiC_error("Illegal cast operation");
 193         }
 194         break;
 195       CASE_UINT:
 196         switch (EiC_gettype(e2->Type)) {
 197           CASE_INT: CASE_UINT:
 198             break;
 199           CASE_LONG: CASE_ULONG:
 200             if(sizeof(int) != sizeof(long))
 201                 EiC_generate(&e1->Code, uint2long, &e1->Val, 0);
 202             break;
 203         case t_llong:
 204             if(sizeof(int) != sizeof(eic_llong))
 205                 EiC_generate(&e1->Code, uint2llong, &e1->Val, 0);
 206             break;
 207           CASE_FLOAT:
 208             EiC_generate(&e1->Code, uint2double, &e1->Val, 0);
 209             break;
 210           case t_pointer:
 211             EiC_generate(&e1->Code, int2ptr, &e1->Val, 0);
 212             e1->Type = EiC_addtype(t_pointer,e1->Type);
 213             if (!explicit)
 214                 EiC_warningerror("Suspicious pointer conversion");
 215             return;
 216           default:
 217             EiC_error("Illegal cast operation");
 218         }
 219         break;
 220       CASE_LONG:
 221         switch (EiC_gettype(e2->Type)) {
 222           CASE_INT: CASE_UINT:
 223             if(sizeof(int) != sizeof(long))
 224                 EiC_generate(&e1->Code, long2int, &e1->Val, 0);
 225             break;
 226           CASE_LONG: CASE_ULONG:
 227             break;
 228           CASE_FLOAT:
 229             EiC_generate(&e1->Code, long2double, &e1->Val, 0);
 230             break;
 231         case t_llong:
 232           EiC_generate(&e1->Code, long2llong, &e1->Val, 0); break;
 233           case t_pointer:
 234             EiC_generate(&e1->Code, int2ptr, &e1->Val, 0);
 235             e1->Type = EiC_addtype(t_pointer,e1->Type);
 236             if (!explicit)
 237                 EiC_warningerror("Suspicious pointer conversion");
 238             return;
 239           default:
 240             EiC_error("Illegal cast operation");
 241         }
 242         break;
 243       CASE_ULONG:
 244         switch (EiC_gettype(e2->Type)) {
 245           CASE_INT: CASE_UINT:
 246             if(sizeof(int) != sizeof(long))
 247                 EiC_generate(&e1->Code, ulong2int, &e1->Val, 0);
 248             break;
 249           CASE_LONG: CASE_ULONG:
 250             break;
 251           CASE_FLOAT:
 252             EiC_generate(&e1->Code, ulong2double, &e1->Val, 0);
 253             break;
 254         case t_llong:
 255           EiC_generate(&e1->Code, ulong2llong, &e1->Val, 0); break;
 256           case t_pointer:
 257             EiC_generate(&e1->Code, int2ptr, &e1->Val, 0);
 258             e1->Type = EiC_addtype(t_pointer,e1->Type);
 259             if (!explicit)
 260                 EiC_warningerror("Suspicious pointer conversion");
 261             return;
 262           default:
 263             EiC_error("Illegal cast operation");
 264         }
 265         break;
 266
 267       case t_llong:
 268
 269         switch (EiC_gettype(e2->Type)) {
 270
 271             CASE_INT:
 272             CASE_UINT:
 273               if(sizeof(int) != sizeof(eic_llong))
 274                   EiC_generate(&e1->Code, llong2int, &e1->Val, 0);
 275               break;
 276
 277             CASE_LONG: CASE_ULONG:
 278               if(sizeof(long) != sizeof(eic_llong))
 279                   EiC_generate(&e1->Code, llong2long, &e1->Val, 0);
 280               break;
 281
 282             case t_llong: break;
 283             default:
 284                 EiC_error("Illegal cast operation");
 285         }
 286         break;
 287       CASE_FLOAT:
 288         switch (EiC_gettype(e2->Type)) {
 289           CASE_INT: CASE_UINT:
 290             EiC_generate(&e1->Code, double2int, &e1->Val, 0);
 291             break;
 292           CASE_LONG: CASE_ULONG:
 293             EiC_generate(&e1->Code, double2long, &e1->Val, 0);
 294             break;
 295         case t_llong:
 296             EiC_generate(&e1->Code, double2llong, &e1->Val, 0);
 297             break;
 298           CASE_FLOAT:
 299             /*
 300             if(EiC_gettype(e1->Type) == t_double
 301                && EiC_gettype(e2->Type) == t_float)
 302                 EiC_generate(&e1->Code, double2float, &e1->Val, 0);
 303             else
 304                 return;
 305                 break;
 306                 */
 307             return;
 308           default:
 309             EiC_error("Illegal cast operation");
 310         }
 311         break;
 312
 313       case t_pointer:
 314         switch (EiC_gettype(e2->Type)) {
 315           case t_uchar:
 316           case t_char:
 317             EiC_error("Illegal cast operation");
 318             return;
 319           case t_short:
 320           case t_int:
 321           case t_ushort:
 322           case t_uint:
 323             EiC_generate(&e1->Code, ptr2int, &e1->Val, 0);
 324             break;
 325           CASE_LONG:
 326           case t_ulong:
 327             EiC_generate(&e1->Code, ptr2long, &e1->Val, 0);
 328             break;
 329           CASE_FLOAT:EiC_error("Illegal cast operation");
 330             return;
 331           case t_pointer:
 332             if (!EiC_sametypes(e1->Type, e2->Type)) {
 333                 if (EiC_gettype(e2->Type) != t_pointer)
 334                     EiC_error("Illegal cast operation");
 335                 else if (!explicit)
 336                     EiC_warningerror("Suspicious pointer conversion");
 337             } else if(!explicit)
 338                 if(ConstIntegrity(nextType(e2->Type),nextType(e1->Type)))
 339                     EiC_error("Cast loses const qualifier");
 340             if(!EiC_compareSafe(nextType(e1->Type),nextType(e2->Type)))
 341                 EiC_error("Casting between safe and unsafe address");
 342             break;
 343           default:
 344             EiC_error("Illegal cast operation");
 345             return;
 346         }
 347         EiC_freetype(e1->Type);
 348         e1->Type = EiC_copytype(e2->Type);
 349         return;
 350       case t_array:
 351         if (EiC_gettype(e2->Type) == t_pointer) {
 352             EiC_exchtype(t_pointer, e1->Type);
 353             if (!EiC_sametypes(e1->Type, e2->Type) && !explicit)
 354                 EiC_warningerror("Suspicious pointer conversion");
 355         } else if(EiC_gettype(e2->Type) == t_array) {
 356             if (!EiC_sametypes(e1->Type, e2->Type))
 357                 EiC_error("Illegal cast operation");
 358         } else
 359             EiC_error("Illegal cast operation");
 360         return;
 361       case t_lval:
 362         e1->Type = EiC_succType(e1->Type);
 363         EiC_castvar(e1, e2, explicit);
 364         setConst(e1->Type);
 365         return;
 366       case t_union:
 367       case t_struct:
 368         if (EiC_gettype(e2->Type) == t_lval) {
 369             if (!EiC_sametypes(e1->Type, nextType(e2->Type)))
 370                 EiC_error("Illegal cast operation");
 371         } else if (!EiC_sametypes(e1->Type, e2->Type))
 372             EiC_error("Illegal cast operation");
 373         return;
 374       default:
 375         EiC_error("Illegal cast operation");
 376     }
 377     EiC_set_bastype(EiC_bastype(e2->Type), e1->Type);
 378 }
 379
 380
 381 int TREFON=0;
 382
 383 void EiC_castconst(token_t * e1, token_t * e2, int explicit)
 384 {
 385     /*
 386      *  cast e1 type into an e2 type and
 387      *  where e1 is a constant
 388      */
 389     unsigned t;
 390     if (EiC_gettype(e2->Type) == t_func) {
 391         token_t e3;
 392         e3.Type = EiC_copytype(nextType(e2->Type));
 393         EiC_castconst(e1, &e3, explicit);
 394         EiC_freetype(e3.Type);
 395         return;
 396     }
 397     if (e1->Pflag) {
 398         EiC_castvar(e1, e2, explicit);
 399         return;
 400     }
 401     if(EiC_gettype(e2->Type) == t_void) {
 402         e1->Type = EiC_addtype(t_void,EiC_freetype(e1->Type));
 403         setConst(e1->Type);
 404         return;
 405     }
 406
 407     switch ((t = EiC_gettype(e2->Type))) {
 408       CASE_INT: CASE_UINT:
 409         switch (EiC_gettype(e1->Type)) {
 410           CASE_INT: CASE_UINT: break;
 411           CASE_LONG:e1->Val.ival = (int) e1->Val.lval;   break;
 412           CASE_ULONG:e1->Val.ival = (int) e1->Val.ulval; break;
 413           CASE_FLOAT:e1->Val.ival = (int) e1->Val.dval;  break;
 414           case t_llong: e1->Val.ival = (int)e1->Val.llval; break;
 415           default:
 416             EiC_error("Illegal cast operation");
 417         }
 418         break;
 419       CASE_LONG:
 420         switch (EiC_gettype(e1->Type)) {
 421           CASE_INT:e1->Val.lval = (long) e1->Val.ival;
 422             break;
 423           CASE_UINT:e1->Val.lval = (long) e1->Val.uival;
 424             break;
 425           CASE_LONG:return;
 426           case t_ulong:
 427             break;
 428         case t_llong:e1->Val.lval = (long)e1->Val.llval;
 429           break;
 430
 431           CASE_FLOAT:e1->Val.lval = (long) e1->Val.dval;
 432             break;
 433           default:
 434             EiC_error("Illegal cast operation");
 435         }
 436         break;
 437       case t_ulong:
 438         switch (EiC_gettype(e1->Type)) {
 439           CASE_INT:e1->Val.ulval = (unsigned long) e1->Val.ival;
 440             break;
 441           CASE_UINT:e1->Val.ulval = (unsigned long) e1->Val.uival;
 442             break;
 443           CASE_LONG:break;
 444           case t_ulong:
 445             return;
 446         case t_llong: e1->Val.ulval = (long)e1->Val.llval; break;
 447
 448           CASE_FLOAT:e1->Val.ulval = (unsigned long) e1->Val.dval;
 449             break;
 450           default:
 451             EiC_error("Illegal cast operation");
 452         }
 453         break;
 454
 455       case t_llong:
 456         switch (EiC_gettype(e1->Type)) {
 457           CASE_INT:    e1->Val.llval =   (eic_llong) e1->Val.ival;   break;
 458           CASE_UINT:   e1->Val.llval =  (eic_llong) e1->Val.uival; break;
 459           CASE_LONG:   e1->Val.llval =  (eic_llong) e1->Val.lval;  break;
 460           case t_ulong:e1->Val.llval =(eic_llong) e1->Val.ulval;  break;
 461           case t_llong: break;
 462
 463           CASE_FLOAT:e1->Val.llval = (eic_llong)e1->Val.dval;
 464             break;
 465           default:
 466             EiC_error("Illegal cast operation");
 467         }
 468         break;
 469
 470     CASE_FLOAT:
 471         switch (EiC_gettype(e1->Type)) {
 472         CASE_INT:e1->Val.dval = (double) e1->Val.ival;
 473         break;
 474         CASE_UINT:e1->Val.dval = (double) e1->Val.uival;
 475         break;
 476         CASE_LONG:e1->Val.dval = (double) e1->Val.lval;
 477         break;
 478         case t_ulong:
 479             e1->Val.dval = (double) e1->Val.ulval;
 480             break;
 481         case t_llong: e1->Val.dval = (double)e1->Val.llval; break;
 482         case t_pointer:
 483             EiC_error("Illegal floating point operation");
 484             break;
 485         case t_float:
 486             e1->Val.dval = (float)e1->Val.dval; break;
 487         case t_double:
 488             return;
 489         }
 490         break;
 491       case t_lval:
 492         e2->Type = EiC_succType(e2->Type);
 493         EiC_castconst(e1, e2, explicit);
 494         e2->Type = EiC_addtype(t, e2->Type);
 495         return;
 496       case t_pointer:
 497         if (EiC_gettype(e1->Type) != t_pointer && !explicit
 498             && e1->Val.ival != 0 && !TREFON)
 499             EiC_warningerror("Suspicious pointer conversion");
 500         switch (EiC_gettype(e1->Type)) {
 501         CASE_INT: e1->Val.p.sp = e1->Val.p.p =  (void *) e1->Val.ival;
 502                   if(EiC_gettype(nextType(e2->Type)) != t_void)
 503                      e1->Val.p.ep = (void *) (e1->Val.ival + EiC_get_sizeof(nextType(e2->Type)));
 504                   else
 505                     e1->Val.p.ep = (void *) (e1->Val.ival + sizeof(void *));
 506             break;
 507         CASE_UINT:  e1->Val.p.sp = e1->Val.p.p = (void *) e1->Val.uival;
 508                     if(EiC_gettype(nextType(e2->Type)) != t_void)
 509                        e1->Val.p.ep = (void *) (e1->Val.uival + EiC_get_sizeof(nextType(e2->Type)));
 510                     else
 511                       e1->Val.p.ep = (void *) (e1->Val.uival + sizeof(void *));
 512                 break;
 513         CASE_LONG:
 514         case t_ulong:
 515               e1->Val.p.sp =  e1->Val.p.p = (void *) e1->Val.ulval;
 516               if(EiC_gettype(nextType(e2->Type)) != t_void)
 517                 e1->Val.p.ep = (void *) (e1->Val.ulval + EiC_get_sizeof(nextType(e2->Type)));
 518               else
 519                 e1->Val.p.ep = (void *) (e1->Val.ulval + sizeof(void *));
 520               break;
 521           case t_pointer:
 522             if (!EiC_sametypes(e2->Type,e1->Type))
 523                 EiC_warningerror("Suspicious pointer conversion");
 524             e1->Type = EiC_freetype(e1->Type);
 525             e1->Type = EiC_copytype(e2->Type);
 526             setConst(e1->Type);
 527             return;
 528           default:
 529             EiC_error("Illegal cast operation");
 530             break;
 531         }
 532         EiC_exchtype(t_pointer, e1->Type);
 533         /*if(!explicit) */
 534         if(!issafe(e2->Type))
 535             setUnSafe(e1->Type);
 536         setConst(e1->Type);
 537         return;
 538       case t_union:
 539       case t_struct:
 540         if (EiC_gettype(e2->Type) == t_lval) {
 541             if (!EiC_sametypes(e1->Type, nextType(e2->Type)))
 542                 EiC_error("Illegal cast operation");
 543         } else if (!EiC_sametypes(e1->Type, e2->Type))
 544             EiC_error("Illegal cast operation");
 545         return;
 546       default:
 547         EiC_error("Illegal cast operation");
 548     }
 549     EiC_set_bastype(EiC_bastype(e2->Type), e1->Type);
 550 }
 551
 552
 553 void EiC_do_lor(token_t *e1, int n)
 554 {
 555     int inst;
 556     val_t u1;
 557     EiC_output(e1);
 558     switch(EiC_gettype(e1->Type)) {
 559       CASE_INT:
 560       CASE_UINT: inst = jmpTint;  break;
 561       CASE_LONG:
 562       CASE_ULONG: inst = jmpTlng; break;
 563       CASE_FLOAT: inst = jmpTdbl; break;
 564       case t_pointer: inst = jmpTptr;break;
 565       default:
 566         EiC_error("syntax error near '||'");
 567         return;
 568     }
 569     EiC_exchtype(t_int,e1->Type);
 570     u1.ival = n;
 571     EiC_generate(&e1->Code, inst, &u1, 0);
 572 }
 573 void EiC_do_land(token_t *e1, int n)
 574 {
 575     int inst;
 576     val_t u1;
 577     EiC_output(e1);
 578     switch(EiC_gettype(e1->Type)) {
 579       CASE_INT:
 580       CASE_UINT: inst = jmpFint;  break;
 581       CASE_LONG:
 582       CASE_ULONG: inst = jmpFlng; break;
 583       CASE_FLOAT: inst = jmpFdbl; break;
 584       case t_pointer: inst = jmpFptr;break;
 585       default:
 586         EiC_error("syntax error associated near '&&'");
 587         return;
 588     }
 589     EiC_exchtype(t_int,e1->Type);
 590     u1.ival = n;
 591     EiC_generate(&e1->Code, inst, &u1, 0);
 592 }
 593
 594 static void checkint(unsigned obj, token_t * e1, token_t * e2)
 595 {
 596     if (EiC_gettype(e1->Type) != obj) {
 597         if(!isconst(e1->Type))
 598             EiC_exchtype(obj, e1->Type);
 599         else
 600             EiC_castconst(e1,e2,0);
 601     }
 602     if (EiC_gettype(e2->Type) != obj) {
 603         if(!isconst(e1->Type))
 604             EiC_exchtype(obj, e2->Type);
 605         else
 606             EiC_castconst(e2, e1, 0);
 607     }
 608     if (!e2->Pflag)
 609         EiC_output(e2);
 610 }
 611
 612
 613 void binhint(unsigned oper, token_t * e1, token_t * e2)
 614 {
 615     checkint(t_int, e1, e2);
 616     switch (oper) {
 617       case '+':
 618         EiC_generate(&e2->Code, addint, &e2->Val, 0);
 619         break;
 620       case '-':
 621         EiC_generate(&e2->Code, subint, &e2->Val, 0);
 622         break;
 623       case '*':
 624         EiC_generate(&e2->Code, multint, &e2->Val, 0);
 625         break;
 626       case '/':
 627         EiC_generate(&e2->Code, divint, &e2->Val, 0);
 628         break;
 629       case '%':
 630         EiC_generate(&e2->Code, modint, &e2->Val, 0);
 631         break;
 632       case LSHT:
 633         EiC_generate(&e2->Code, lshtint, &e2->Val, 0);
 634         break;
 635       case RSHT:
 636         EiC_generate(&e2->Code, rshtint, &e2->Val, 0);
 637         break;
 638       case LT:
 639         EiC_generate(&e2->Code, ltint, &e2->Val, 0);
 640         break;
 641       case LE:
 642         EiC_generate(&e2->Code, leint, &e2->Val, 0);
 643         break;
 644       case EQ:
 645         EiC_generate(&e2->Code, eqint, &e2->Val, 0);
 646         break;
 647       case NE:
 648         EiC_generate(&e2->Code, neint, &e2->Val, 0);
 649         break;
 650       case GT:
 651         EiC_generate(&e2->Code, gtint, &e2->Val, 0);
 652         break;
 653       case GE:
 654         EiC_generate(&e2->Code, geint, &e2->Val, 0);
 655         break;
 656       case BOR:
 657         EiC_generate(&e2->Code, borint, &e2->Val, 0);
 658         break;
 659       case XOR:
 660         EiC_generate(&e2->Code, xorint, &e2->Val, 0);
 661         break;
 662       case AND:
 663         EiC_generate(&e2->Code, andint, &e2->Val, 0);
 664         break;
 665     }
 666 }
 667
 668 void binhuint(unsigned oper, token_t * e1, token_t * e2)
 669 {
 670     checkint(t_uint, e1, e2);
 671     switch (oper) {
 672       case '+':
 673         EiC_generate(&e2->Code, adduint, &e2->Val, 0);
 674         break;
 675       case '-':
 676         EiC_generate(&e2->Code, subuint, &e2->Val, 0);
 677         break;
 678       case '*':
 679         EiC_generate(&e2->Code, multuint, &e2->Val, 0);
 680         break;
 681       case '/':
 682         EiC_generate(&e2->Code, divuint, &e2->Val, 0);
 683         break;
 684       case '%':
 685         EiC_generate(&e2->Code, moduint, &e2->Val, 0);
 686         break;
 687       case LSHT:
 688         EiC_generate(&e2->Code, lshtuint, &e2->Val, 0);
 689         break;
 690       case RSHT:
 691         EiC_generate(&e2->Code, rshtuint, &e2->Val, 0);
 692         break;
 693       case BOR:
 694         EiC_generate(&e2->Code, boruint, &e2->Val, 0);
 695         break;
 696       case XOR:
 697         EiC_generate(&e2->Code, xoruint, &e2->Val, 0);
 698         break;
 699       case AND:
 700         EiC_generate(&e2->Code, anduint, &e2->Val, 0);
 701         break;
 702       default:
 703         EiC_output(e1);
 704         EiC_exchtype(t_int, e1->Type);  /* should really be boolean */
 705         switch (oper) {
 706           case LT:
 707             EiC_generate(&e2->Code, ltuint, &e2->Val, 0);
 708             break;
 709           case LE:
 710             EiC_generate(&e2->Code, leuint, &e2->Val, 0);
 711             break;
 712           case EQ:
 713             EiC_generate(&e2->Code, equint, &e2->Val, 0);
 714             break;
 715           case NE:
 716             EiC_generate(&e2->Code, neuint, &e2->Val, 0);
 717             break;
 718           case GT:
 719             EiC_generate(&e2->Code, gtuint, &e2->Val, 0);
 720             break;
 721           case GE:
 722             EiC_generate(&e2->Code, geuint, &e2->Val, 0);
 723             break;
 724         }
 725     }
 726 }
 727
 728 static void checklong(unsigned obj, token_t * e1, token_t * e2)
 729 {
 730     int t;
 731     if ((t=EiC_gettype(e1->Type)) != obj) {
 732         if (!isconst(e1->Type)) {
 733             if (!e1->Pflag)
 734                 EiC_output(e1);
 735             if(sizeof(int) != sizeof(long))
 736                 switch (t) {
 737                 CASE_INT:EiC_generate(&e1->Code, int2long, &e1->Val, 0);
 738                 break;
 739                 CASE_UINT:EiC_generate(&e1->Code, uint2long, &e1->Val, 0);
 740                 break;
 741                 }
 742             EiC_exchtype(obj, e1->Type);
 743         } else
 744             EiC_castconst(e1, e2, 0);
 745     }
 746     if ((t=EiC_gettype(e2->Type)) != obj) {
 747         if (!isconst(e2->Type)) {
 748             if (!e2->Pflag)
 749                 EiC_output(e2);
 750             if(sizeof(int) != sizeof(long))
 751                 switch (t) {
 752                 CASE_INT:EiC_generate(&e2->Code, int2long, &e1->Val, 0);
 753                 break;
 754                 CASE_UINT:EiC_generate(&e2->Code, uint2long, &e1->Val, 0);
 755                 break;
 756                 }
 757             EiC_exchtype(obj, e2->Type);
 758         } else
 759             EiC_castconst(e2, e1, 0);
 760     }
 761     if (!e2->Pflag)
 762         EiC_output(e2);
 763 }
 764
 765 void binhlong(unsigned oper, token_t * e1, token_t * e2)
 766 {
 767     checklong(t_long, e1, e2);
 768
 769     switch (oper) {
 770       case '+':
 771         EiC_generate(&e2->Code, addlong, &e2->Val, 0);
 772         break;
 773       case '-':
 774         EiC_generate(&e2->Code, sublong, &e2->Val, 0);
 775         break;
 776       case '*':
 777         EiC_generate(&e2->Code, multlong, &e2->Val, 0);
 778         break;
 779       case '/':
 780         EiC_generate(&e2->Code, divlong, &e2->Val, 0);
 781         break;
 782       case '%':
 783         EiC_generate(&e2->Code, modlong, &e2->Val, 0);
 784         break;
 785       case LSHT:
 786         EiC_generate(&e2->Code, lshtlong, &e2->Val, 0);
 787         break;
 788       case RSHT:
 789         EiC_generate(&e2->Code, rshtlong, &e2->Val, 0);
 790         break;
 791       case BOR:
 792         EiC_generate(&e2->Code, borlong, &e2->Val, 0);
 793         break;
 794       case XOR:
 795         EiC_generate(&e2->Code, xorlong, &e2->Val, 0);
 796         break;
 797       case AND:
 798         EiC_generate(&e2->Code, andlong, &e2->Val, 0);
 799         break;
 800       default:
 801         EiC_output(e1);
 802         EiC_exchtype(t_int, e1->Type);  /* should really be boolean */
 803         switch (oper) {
 804           case LT:
 805             EiC_generate(&e2->Code, ltlong, &e2->Val, 0);
 806             break;
 807           case LE:
 808             EiC_generate(&e2->Code, lelong, &e2->Val, 0);
 809             break;
 810           case EQ:
 811             EiC_generate(&e2->Code, eqlong, &e2->Val, 0);
 812             break;
 813           case NE:
 814             EiC_generate(&e2->Code, nelong, &e2->Val, 0);
 815             break;
 816           case GT:
 817             EiC_generate(&e2->Code, gtlong, &e2->Val, 0);
 818             break;
 819           case GE:
 820             EiC_generate(&e2->Code, gelong, &e2->Val, 0);
 821             break;
 822         }
 823         break;
 824     }
 825 }
 826
 827 void binhulong(unsigned oper, token_t * e1, token_t * e2)
 828 {
 829     checklong(t_ulong, e1, e2);
 830     switch (oper) {
 831       case '+':
 832         EiC_generate(&e2->Code, addulong, &e2->Val, 0);
 833         break;
 834       case '-':
 835         EiC_generate(&e2->Code, subulong, &e2->Val, 0);
 836         break;
 837       case '*':
 838         EiC_generate(&e2->Code, multulong, &e2->Val, 0);
 839         break;
 840       case '/':
 841         EiC_generate(&e2->Code, divulong, &e2->Val, 0);
 842         break;
 843       case '%':
 844         EiC_generate(&e2->Code, modulong, &e2->Val, 0);
 845         break;
 846       case LSHT:
 847         EiC_generate(&e2->Code, lshtulong, &e2->Val, 0);
 848         break;
 849       case RSHT:
 850         EiC_generate(&e2->Code, rshtulong, &e2->Val, 0);
 851         break;
 852       case BOR:
 853         EiC_generate(&e2->Code, borulong, &e2->Val, 0);
 854         break;
 855       case XOR:
 856         EiC_generate(&e2->Code, xorulong, &e2->Val, 0);
 857         break;
 858       case AND:
 859         EiC_generate(&e2->Code, andulong, &e2->Val, 0);
 860         break;
 861       default:
 862         EiC_output(e1);
 863         EiC_exchtype(t_int, e1->Type);  /* should really be boolean */
 864         switch (oper) {
 865           case LT:
 866             EiC_generate(&e2->Code, ltulong, &e2->Val, 0);
 867             break;
 868           case LE:
 869             EiC_generate(&e2->Code, leulong, &e2->Val, 0);
 870             break;
 871           case EQ:
 872             EiC_generate(&e2->Code, equlong, &e2->Val, 0);
 873             break;
 874           case NE:
 875             EiC_generate(&e2->Code, neulong, &e2->Val, 0);
 876             break;
 877           case GT:
 878             EiC_generate(&e2->Code, gtulong, &e2->Val, 0);
 879             break;
 880           case GE:
 881             EiC_generate(&e2->Code, geulong, &e2->Val, 0);
 882             break;
 883         }
 884         break;
 885     }
 886 }
 887
 888 static void checkllong(unsigned obj, token_t * e1, token_t * e2)
 889 {
 890   int t;
 891   if ((t=EiC_gettype(e1->Type)) != obj) {
 892     if (!isconst(e1->Type)) {
 893       if (!e1->Pflag)
 894         EiC_output(e1);
 895       if(t <= t_uint && sizeof(int) != sizeof(eic_llong)) {
 896         switch (t) {
 897         CASE_INT:EiC_generate(&e1->Code, int2llong, &e1->Val, 0);
 898         break;
 899         CASE_UINT:EiC_generate(&e1->Code, uint2llong, &e1->Val, 0);
 900         }
 901       } else if(sizeof(long) != sizeof(eic_llong)) {
 902         switch (t) {
 903         case t_long:EiC_generate(&e1->Code, long2llong, &e1->Val, 0);
 904           break;
 905         case t_ulong:EiC_generate(&e1->Code, ulong2llong, &e1->Val, 0);
 906         }
 907       }
 908       EiC_exchtype(obj, e1->Type);
 909     } else
 910       EiC_castconst(e1, e2, 0);
 911   }
 912   if ((t=EiC_gettype(e2->Type)) != obj) {
 913     if (!isconst(e2->Type)) {
 914       if (!e2->Pflag)
 915         EiC_output(e2);
 916       if(t <= t_uint && sizeof(int) != sizeof(eic_llong)) {
 917         switch (t) {
 918         CASE_INT:EiC_generate(&e2->Code, int2llong, &e1->Val, 0);
 919         break;
 920         CASE_UINT:EiC_generate(&e2->Code, uint2llong, &e1->Val, 0);
 921         }
 922       } else if(sizeof(long) != sizeof(eic_llong)) {
 923         switch (t) {
 924         case t_long:EiC_generate(&e2->Code, long2llong, &e1->Val, 0);
 925           break;
 926         case t_ulong:EiC_generate(&e2->Code, ulong2llong, &e1->Val, 0);
 927         }
 928       }
 929       EiC_exchtype(obj, e2->Type);
 930     } else
 931       EiC_castconst(e2, e1, 0);
 932   }
 933   if (!e2->Pflag)
 934     EiC_output(e2);
 935 }
 936
 937
 938 void binhllong(unsigned oper, token_t * e1, token_t * e2)
 939 {
 940     checkllong(t_llong, e1, e2);
 941
 942     switch (oper) {
 943       case '+':
 944         EiC_generate(&e2->Code, addllong, &e2->Val, 0);
 945         break;
 946       case '-':
 947         EiC_generate(&e2->Code, subllong, &e2->Val, 0);
 948         break;
 949       case '*':
 950         EiC_generate(&e2->Code, multllong, &e2->Val, 0);
 951         break;
 952       case '/':
 953         EiC_generate(&e2->Code, divllong, &e2->Val, 0);
 954         break;
 955       case '%':
 956         EiC_generate(&e2->Code, modllong, &e2->Val, 0);
 957         break;
 958       case LSHT:
 959         EiC_generate(&e2->Code, lshtllong, &e2->Val, 0);
 960         break;
 961       case RSHT:
 962         EiC_generate(&e2->Code, rshtllong, &e2->Val, 0);
 963         break;
 964       case BOR:
 965         EiC_generate(&e2->Code, borllong, &e2->Val, 0);
 966         break;
 967       case XOR:
 968         EiC_generate(&e2->Code, xorllong, &e2->Val, 0);
 969         break;
 970       case AND:
 971         EiC_generate(&e2->Code, andllong, &e2->Val, 0);
 972         break;
 973       default:
 974         EiC_output(e1);
 975         EiC_exchtype(t_int, e1->Type);  /* should really be boolean */
 976         switch (oper) {
 977           case LT:
 978             EiC_generate(&e2->Code, ltllong, &e2->Val, 0);
 979             break;
 980           case LE:
 981             EiC_generate(&e2->Code, lellong, &e2->Val, 0);
 982             break;
 983           case EQ:
 984             EiC_generate(&e2->Code, eqllong, &e2->Val, 0);
 985             break;
 986           case NE:
 987             EiC_generate(&e2->Code, nellong, &e2->Val, 0);
 988             break;
 989           case GT:
 990             EiC_generate(&e2->Code, gtllong, &e2->Val, 0);
 991             break;
 992           case GE:
 993             EiC_generate(&e2->Code, gellong, &e2->Val, 0);
 994             break;
 995         }
 996         break;
 997     }
 998 }
 999
1000
1001
1002 void binhdouble(unsigned oper, token_t * e1, token_t * e2)
1003 {
1004     int t;
1005     if ((t=EiC_gettype(e1->Type)) != t_double) {
1006         if (!isconst(e1->Type)) {
1007             if (!e1->Pflag)
1008                 EiC_output(e1);
1009             switch (t) {
1010               CASE_INT:EiC_generate(&e1->Code, int2double, &e1->Val, 0);
1011                 break;
1012               CASE_UINT:EiC_generate(&e1->Code, uint2double, &e1->Val, 0);
1013                 break;
1014               CASE_LONG:EiC_generate(&e1->Code, long2double, &e1->Val, 0);
1015                 break;
1016               CASE_ULONG:EiC_generate(&e1->Code, ulong2double, &e1->Val, 0);
1017                 break;
1018             case t_llong: EiC_generate(&e1->Code, llong2double, &e1->Val, 0);
1019                 break;
1020             }
1021             EiC_exchtype(t_double, e1->Type);
1022         } else
1023             EiC_castconst(e1, e2, 0);
1024     }
1025     if ((t=EiC_gettype(e2->Type)) != t_double) {
1026         if (!isconst(e2->Type)) {
1027             if (!e2->Pflag)
1028                 EiC_output(e2);
1029             switch (t) {
1030               CASE_INT:EiC_generate(&e2->Code, int2double, &e1->Val, 0);
1031                 break;
1032               CASE_UINT:EiC_generate(&e2->Code, uint2double, &e1->Val, 0);
1033                 break;
1034               CASE_LONG:EiC_generate(&e2->Code, long2double, &e1->Val, 0);
1035                 break;
1036               CASE_ULONG:EiC_generate(&e2->Code, ulong2double, &e1->Val, 0);
1037                 break;
1038               case t_llong:EiC_generate(&e2->Code, llong2double, &e1->Val, 0);
1039                 break;
1040             }
1041             EiC_exchtype(t_double, e2->Type);
1042         } else
1043             EiC_castconst(e2, e1, 0);
1044     }
1045     if (!e2->Pflag)
1046         EiC_output(e2);
1047
1048     switch (oper) {
1049       case '+':
1050         EiC_generate(&e2->Code, adddouble, &e2->Val, 0);
1051         break;
1052       case '-':
1053         EiC_generate(&e2->Code, subdouble, &e2->Val, 0);
1054         break;
1055       case '*':
1056         EiC_generate(&e2->Code, multdouble, &e2->Val, 0);
1057         break;
1058       case '/':
1059         EiC_generate(&e2->Code, divdouble, &e2->Val, 0);
1060         break;
1061       default:
1062         EiC_output(e1);
1063         EiC_exchtype(t_int, e1->Type);  /* should really be boolean */
1064         switch (oper) {
1065           case LT:
1066             EiC_generate(&e2->Code, ltdouble, &e2->Val, 0);
1067             break;
1068           case LE:
1069             EiC_generate(&e2->Code, ledouble, &e2->Val, 0);
1070             break;
1071           case EQ:
1072             EiC_generate(&e2->Code, eqdouble, &e2->Val, 0);
1073             break;
1074           case NE:
1075             EiC_generate(&e2->Code, nedouble, &e2->Val, 0);
1076             break;
1077           case GT:
1078             EiC_generate(&e2->Code, gtdouble, &e2->Val, 0);
1079             break;
1080           case GE:
1081             EiC_generate(&e2->Code, gedouble, &e2->Val, 0);
1082             break;
1083           default:EiC_error("illegal binary operation to `%c'", oper);
1084         }
1085     }
1086 }
1087
1088 #define arrayLimit(type)    /* replaced by runtime checks */
1089
1090 /*if(limit && (e2->Val.type >= limit || \
1091                                       e2->Val.type < 0))\
1092                                EiC_error("Array bound violation");
1093                                */
1094 #define ConstPval(y) { if(oper == '+')\
1095                             e1->Val.p.p = (char*)e1->Val.p.p + e2->Val.y;\
1096                         else\
1097                             e1->Val.p.p = (char*)e1->Val.p.p - e2->Val.y;\
1098                     }
1099
1100 void EiC_binhlval(unsigned oper, token_t * e1, token_t * e2)
1101 {
1102     unsigned limit = 0;
1103     if (EiC_gettype(e1->Type) != t_pointer) {
1104         if(EiC_gettype(e1->Type) != t_array) {
1105             EiC_binhlval(oper,e2,e1);
1106             EiC_swaptokens(e1,e2);
1107             return;
1108         } else { /* convert array to pointer */
1109             limit = getNumElems(e1->Type);
1110             EiC_output(e1);
1111         }
1112     }
1113     if(EiC_gettype(e2->Type) == t_array)
1114         EiC_output(e2);
1115
1116     if (EiC_gettype(e2->Type) != t_pointer) {
1117         if(oper == '+' || oper == '-') {
1118             int c = 0;
1119             VAL.ival = EiC_get_sizeof(nextType(e1->Type));
1120             if(!VAL.ival)
1121                 EiC_error("Illegal pointer operation");
1122             if(isconst(e1->Type) && isconst(e2->Type))
1123                 c = 1;
1124             if(isconst(e2->Type)) {
1125                 switch (EiC_gettype(e2->Type)) {
1126                   CASE_INT:
1127                     arrayLimit(ival);
1128                     e2->Val.ival *= VAL.ival;
1129                     if(c)
1130                         ConstPval(ival);
1131                     break;
1132                   CASE_UINT:
1133                     arrayLimit(uival);
1134                     e2->Val.uival *= VAL.ival;
1135                     if(c)
1136                         ConstPval(uival);
1137                     break;
1138                   CASE_LONG:
1139                     arrayLimit(lval);
1140                     e2->Val.lval *= VAL.ival;
1141                     if(c)
1142                         ConstPval(lval);
1143                     break;
1144                   CASE_ULONG:
1145                     arrayLimit(ulval);
1146                     e2->Val.ulval *= VAL.ival;
1147                     if(c)
1148                         ConstPval(ulval);
1149                     break;
1150                   default:
1151                     EiC_error("Illegal pointer operation");
1152                 }
1153                 VAL.ival = 1;
1154             }
1155             if(!c) {
1156                 if(oper == '-')
1157                     VAL.ival = -VAL.ival;
1158                 EiC_output(e2);
1159                 if(EiC_gettype(e2->Type) > t_uint && sizeof(int) != sizeof(long)) {
1160                     token_t e3;
1161                     EiC_inittoken(&e3);
1162                     e3.Type = EiC_addtype(t_int,NULL);
1163                     EiC_castvar(e2,&e3,0);
1164                     EiC_freetype(e3.Type);
1165                 }
1166                 if(VAL.ival > 1 || VAL.ival < 0)
1167                     EiC_generate(&e2->Code, ixa, &VAL, limit);
1168                 else
1169                     EiC_generate(&e2->Code, addptr2int, &e2->Val, 0);
1170             }
1171             return;
1172         }
1173         if (isconst(e2->Type))
1174             EiC_castconst(e2, e1, 0);
1175         else
1176             EiC_castvar(e2, e1, 0);
1177         EiC_output(e2);
1178
1179     } else if (!EiC_compatibletypes(e1->Type, e2->Type))
1180         EiC_error("Mixed pointer operation");
1181
1182     EiC_output(e2);
1183
1184     switch (oper) {
1185       case '-':
1186         EiC_generate(&e2->Code, subptr, &e2->Val, 0);
1187         VAL.ival = EiC_get_sizeof(nextType(e1->Type));
1188         if (VAL.ival > 1) {
1189             int size = VAL.ival;
1190             VAL.ival = 1;
1191             EiC_generate(&e2->Code, bump, &VAL, 0);
1192             VAL.ival = size;
1193             EiC_generate(&e2->Code, pushint, &VAL, 0);
1194             EiC_generate(&e2->Code, divint, &VAL, 0);
1195         }
1196         break;
1197       case LT:
1198         EiC_generate(&e2->Code, ltptr, &e2->Val, 0);
1199         break;
1200       case LE:
1201         EiC_generate(&e2->Code, leptr, &e2->Val, 0);
1202         break;
1203       case EQ:
1204         EiC_generate(&e2->Code, eqptr, &e2->Val, 0);
1205         break;
1206       case NE:
1207         EiC_generate(&e2->Code, neptr, &e2->Val, 0);
1208         break;
1209       case GT:
1210         EiC_generate(&e2->Code, gtptr, &e2->Val, 0);
1211         break;
1212       case GE:
1213         EiC_generate(&e2->Code, geptr, &e2->Val, 0);
1214         break;
1215     }
1216     EiC_output(e1);
1217     EiC_freetype(e1->Type);
1218     e1->Type = EiC_addtype(t_int, NULL);
1219 }
1220 #undef ConstPval
1221
1222 void (*compatable(LRset_t S[],
1223                   unsigned n, unsigned left,
1224                   unsigned right)) ()
1225 {
1226     static int i, m;
1227
1228     if(left > 32 || right > 32)
1229         return NULL;
1230
1231     for (i = 0; i < n; i++)
1232         if (ismem(S[i].Lset, left) && ismem(S[i].Rset, right)) {
1233             m = left > right ? left : right;
1234             return  BINFUN[m];
1235         }
1236     return NULL;
1237 }
1238
1239 int EiC_bin_validate(unsigned oper, token_t * e1, token_t * e2)
1240 {
1241     int i, left, right;
1242     void (*f) (int op, token_t * e1, token_t * e2);
1243
1244     if(sizeof(int) == sizeof(long)) {
1245         if(EiC_gettype(e1->Type) == t_uint)
1246             EiC_exchtype(t_ulong,e1->Type);
1247         if(EiC_gettype(e2->Type) == t_uint)
1248             EiC_exchtype(t_ulong,e2->Type);
1249     }
1250
1251
1252     if(isconst(e1->Type) || isconst(e2->Type)) {
1253         binhconst(oper,e1,e2);
1254         return 1;
1255     }
1256
1257     left = EiC_gettype(e1->Type);
1258     right = EiC_gettype(e2->Type);
1259
1260     for (i = 0; i < sizeof(BINSET) / sizeof(Binset); i++)
1261         if (oper == BINSET[i].oper) {
1262             f = compatable(BINSET[i].LRset,
1263                            BINSET[i].N,
1264                            left, right);
1265             if (f != NULL) {
1266                 (*f) (oper, e1, e2);
1267                 return 1;
1268             } else
1269                 EiC_error("Incompatible types");
1270         }
1271     return 0;
1272 }
1273
1274 void EiC_cast2comm(token_t * e1, token_t * e2)
1275 {
1276     /* cast e1 and e2 to a common type */
1277
1278     unsigned t1, t2;
1279     t1 = EiC_gettype(e1->Type);
1280     t2 = EiC_gettype(e2->Type);
1281
1282
1283     if(isconst(e1->Type)) {
1284         if(t1 > t2) {
1285             if(isconst(e2->Type))
1286                EiC_castconst(e2, e1, 0);
1287             else
1288                 EiC_castvar(e2, e1, 0);
1289         } else
1290             EiC_castconst(e1, e2, 0);
1291         return;
1292     }
1293
1294     switch (t1) {
1295       CASE_NUM:
1296         if(t2 == t_array || t2 == t_pointer ||
1297            t2 == t_pointer)
1298             EiC_error("Illegal cast operation");
1299         else {
1300             if(t1 > t2) {
1301                 if(isconst(e2->Type))
1302                     EiC_castconst(e2,e1,0);
1303                 else
1304                     EiC_castvar(e2,e1,0);
1305             } else
1306                 EiC_castvar(e1,e2,0);
1307         }
1308         break;
1309       case t_pointer:
1310         if (!EiC_sametypes(e1->Type, e2->Type)) {
1311             if (isconst(e2->Type))
1312                 EiC_castconst(e2, e1, 0);
1313         }
1314         break;
1315       case t_array:
1316         if (EiC_gettype(e2->Type) == t_pointer) {
1317             if (!EiC_sametypes(nextType(e1->Type), nextType(e2->Type)))
1318                 EiC_warningerror("Suspicious pointer conversion");
1319             EiC_exchtype(t_pointer, e1->Type);
1320         } else
1321             EiC_error("Illegal cast operation");
1322         break;
1323       case t_union:
1324       case t_struct:
1325         if(EiC_sametypes(e1->Type,e2->Type))
1326             break;
1327       default:
1328           if(!EiC_sametypes(e1->Type,e2->Type))
1329               EiC_error("Illegal cast operation");
1330     }
1331 }
1332
1333
1334 int EiC_unaryop(token_t * e1, int op)
1335 {
1336     void derefConst(token_t * e1);
1337     int t;
1338
1339     if (!isconst(e1->Type) && op != INC && op != DEC)
1340         EiC_output(e1);
1341
1342     if(!e1->Pflag && isconst(e1->Type)) {
1343         switch(op) {
1344           case '-':
1345             switch (EiC_gettype(e1->Type)) {
1346               CASE_INT:
1347                 e1->Val.ival = -e1->Val.ival;
1348                 break;
1349               CASE_UINT:
1350                 e1->Val.uival = -e1->Val.uival;
1351                 break;
1352               CASE_LONG:
1353                 e1->Val.lval = -e1->Val.lval;
1354                 break;
1355               case t_ulong:
1356                 e1->Val.lval = -e1->Val.ulval;
1357                 break;
1358               CASE_FLOAT:
1359                 e1->Val.dval = -e1->Val.dval;
1360                 break;
1361               default:
1362                 EiC_error("Illegal operand");
1363             }
1364             break;
1365           case '~':
1366             switch (EiC_gettype(e1->Type)) {
1367             CASE_INT:
1368                 e1->Val.ival = ~e1->Val.ival; break;
1369             CASE_UINT:
1370                 e1->Val.uival = ~e1->Val.uival;
1371                 EiC_exchtype(t_uint,e1->Type);
1372                 setConst(e1->Type);
1373                 break;
1374             CASE_LONG:
1375                 e1->Val.lval = ~e1->Val.lval; break;
1376             case t_ulong:
1377                 e1->Val.ulval = ~e1->Val.ulval;
1378                 EiC_exchtype(t_ulong,e1->Type);
1379                 setConst(e1->Type);
1380                 break;
1381               default:
1382                 EiC_error("Illegal operand");
1383             }
1384
1385             break;
1386           case NOT:
1387             switch (EiC_gettype(e1->Type)) {
1388               CASE_INT: CASE_UINT:
1389                 e1->Val.ival = !e1->Val.ival;
1390                 break;
1391               CASE_LONG:
1392               case t_ulong:
1393                 e1->Val.ival = !e1->Val.lval;
1394                 break;
1395               CASE_FLOAT:e1->Val.ival = !e1->Val.dval;
1396                 break;
1397               case t_pointer:
1398                 e1->Val.ival = !e1->Val.p.p;
1399                 break;
1400               default:
1401                 EiC_error("Illegal operand");
1402             }
1403             e1->Type = EiC_addtype(t_int, EiC_freetype(e1->Type));
1404             setConst(e1->Type);
1405             return 1;
1406           case '*':
1407             derefConst(e1);
1408             break;
1409           case '+':
1410             break;
1411           default:
1412             EiC_error("Illegal unary opertion");
1413         }
1414         return 1;
1415     }
1416
1417     switch (op) {
1418       case '+':
1419         break;
1420       case '-':
1421         switch ((t =EiC_gettype(e1->Type))) {
1422           case t_char:
1423           case t_uchar:
1424           case t_short:
1425           case t_ushort:
1426           case t_int:
1427             if(t != t_int)
1428                 EiC_exchtype(t_int,e1->Type);
1429             EiC_generate(&e1->Code, negint, &e1->Val, 0);
1430             break;
1431           case t_uint:
1432             EiC_generate(&e1->Code, neguint, &e1->Val, 0);
1433             break;
1434           CASE_LONG:
1435             EiC_generate(&e1->Code, neglong, &e1->Val, 0);
1436             break;
1437           case t_ulong:
1438             EiC_generate(&e1->Code, negulong, &e1->Val, 0);
1439             break;
1440           CASE_FLOAT:
1441             EiC_generate(&e1->Code, negdouble, &e1->Val, 0);
1442             break;
1443           default:
1444             EiC_error("Illegal operand");
1445
1446         }
1447         break;
1448       case '~':
1449         switch ((t=EiC_gettype(e1->Type))) {
1450           CASE_INT: CASE_UINT:
1451             if(t < t_uint)
1452                 EiC_exchtype(t_uint,e1->Type);
1453             EiC_generate(&e1->Code, compint, &e1->Val, 0);
1454             break;
1455           CASE_LONG:
1456           case t_ulong:
1457             EiC_generate(&e1->Code, compulong, &e1->Val, 0);
1458             EiC_exchtype(t_ulong,e1->Type);
1459             break;
1460           default:
1461             EiC_error("Illegal operand");
1462         }
1463         break;
1464       case NOT:
1465         switch (EiC_gettype(e1->Type)) {
1466           CASE_INT: CASE_UINT:
1467             EiC_generate(&e1->Code, notint, &e1->Val, 0);
1468             break;
1469           CASE_LONG:
1470           case t_ulong:
1471             EiC_generate(&e1->Code, notlong, &e1->Val, 0);
1472             break;
1473           CASE_FLOAT:EiC_generate(&e1->Code, notdouble, &e1->Val, 0);
1474             break;
1475           case t_lval:
1476             t = EiC_gettype(e1->Type);
1477             e1->Type = EiC_succType(e1->Type);
1478             EiC_unaryop(e1, op);
1479             e1->Type = EiC_addtype(t, e1->Type);
1480             break;
1481           case t_pointer:
1482             EiC_generate(&e1->Code, notptr, &e1->Val, 0);
1483             break;
1484           default:
1485             EiC_error("Illegal operand");
1486         }
1487         e1->Type = EiC_addtype(t_int, EiC_freetype(e1->Type));
1488         break;
1489       case INC:
1490       case DEC:
1491
1492         if(isconstp(e1->Type) || isconst(e1->Type)) {
1493           if(op == INC)
1494             EiC_error("increment of read-only variable %s",e1->Sym->id);
1495           else
1496             EiC_error("decrement of read-only variable %s",e1->Sym->id);
1497         }
1498
1499         EiC_do_inc_dec(e1, op);
1500         e1->Pflag = 0;
1501         EiC_do_stooutput(e1);
1502         break;
1503       case '*':
1504         if((t = EiC_gettype(e1->Type)) == t_pointer || t == t_array) {
1505             e1->Pflag = 0;
1506             EiC_exchtype(t_lval, e1->Type);
1507             if(nextType(e1->Type) && (!isconstp(nextType(e1->Type)) ||
1508                          !isconst(nextType(e1->Type))))
1509                 unsetConst(e1->Type);
1510         } else if(t != t_lval)
1511             EiC_error("Must have pointer");
1512         return 1;
1513       default:
1514         EiC_error(" Invalid unary assignment");
1515         break;
1516     }
1517     return 1;
1518 }
1519
1520 int do_binaryop(token_t * e1, token_t * e2, int op)
1521 {
1522     int t1 = EiC_gettype(e1->Type);
1523     int t2 = EiC_gettype(e2->Type);
1524     if(t1 == t_pointer || t2 == t_pointer) {
1525         if(!(op >= LT && op <= GE)) {
1526             EiC_binhlval(op,e1,e2);
1527             return 1;
1528         }
1529     }
1530
1531     if (t1 > t2)
1532         EiC_castconst(e2, e1, 0);
1533     else
1534         EiC_castconst(e1, e2, 0);
1535
1536     switch (EiC_gettype(e1->Type)) {
1537       CASE_FLOAT:
1538         switch (op) {
1539           case '*':
1540             e1->Val.dval *= e2->Val.dval;
1541             break;
1542           case '/':
1543             e1->Val.dval /= e2->Val.dval;
1544             break;
1545           case '+':
1546             e1->Val.dval += e2->Val.dval;
1547             break;
1548           case '-':
1549             e1->Val.dval -= e2->Val.dval;
1550             break;
1551           default:
1552             EiC_set_bastype(t_int, e1->Type);
1553             switch (op) {
1554               case LT:
1555                 e1->Val.ival = e1->Val.dval < e2->Val.dval;
1556                 break;
1557               case LE:
1558                 e1->Val.ival = e1->Val.dval <= e2->Val.dval;
1559                 break;
1560               case EQ:
1561                 e1->Val.ival = e1->Val.dval == e2->Val.dval;
1562                 break;
1563               case NE:
1564                 e1->Val.ival = e1->Val.dval != e2->Val.dval;
1565                 break;
1566               case GT:
1567                 e1->Val.ival = e1->Val.dval > e2->Val.dval;
1568                 break;
1569               case GE:
1570                 e1->Val.ival = e1->Val.dval >= e2->Val.dval;
1571                 break;
1572               default: EiC_error("illegal binary operation to `%c'", op);
1573             }
1574             break;
1575         }
1576         break;
1577       CASE_INT:
1578         switch (op) {
1579           case '*':
1580             e1->Val.ival *= e2->Val.ival;
1581             break;
1582           case '/':
1583             e1->Val.ival /= e2->Val.ival;
1584             break;
1585           case '+':
1586             e1->Val.ival += e2->Val.ival;
1587             break;
1588           case '-':
1589             e1->Val.ival -= e2->Val.ival;
1590             break;
1591           case '%':
1592             e1->Val.ival %= e2->Val.ival;
1593             break;
1594           case LSHT:
1595             e1->Val.ival <<= e2->Val.ival;
1596             break;
1597           case RSHT:
1598             e1->Val.ival >>= e2->Val.ival;
1599             break;
1600           case AND:
1601             e1->Val.ival = e1->Val.ival & e2->Val.ival;
1602             break;
1603           case BOR:
1604             e1->Val.ival = e1->Val.ival | e2->Val.ival;
1605             break;
1606           case XOR:
1607             e1->Val.ival = e1->Val.ival ^ e2->Val.ival;
1608             break;
1609           case LT:
1610             e1->Val.ival = e1->Val.ival < e2->Val.ival;
1611             break;
1612           case LE:
1613             e1->Val.ival = e1->Val.ival <= e2->Val.ival;
1614             break;
1615           case EQ:
1616             e1->Val.ival = e1->Val.ival == e2->Val.ival;
1617             break;
1618           case NE:
1619             e1->Val.ival = e1->Val.ival != e2->Val.ival;
1620             break;
1621           case GT:
1622             e1->Val.ival = e1->Val.ival > e2->Val.ival;
1623             break;
1624           case GE:
1625             e1->Val.ival = e1->Val.ival >= e2->Val.ival;
1626             break;
1627         }
1628         break;
1629       CASE_UINT:
1630         switch (op) {
1631           case '*':
1632             e1->Val.uival *= e2->Val.uival;
1633             break;
1634           case '/':
1635             e1->Val.uival /= e2->Val.uival;
1636             break;
1637           case '+':
1638             e1->Val.uival += e2->Val.uival;
1639             break;
1640           case '-':
1641             e1->Val.uival -= e2->Val.uival;
1642             break;
1643           case '%':
1644             e1->Val.uival %= e2->Val.uival;
1645             break;
1646           case LSHT:
1647             e1->Val.uival <<= e2->Val.uival;
1648             break;
1649           case RSHT:
1650             e1->Val.uival >>= e2->Val.uival;
1651             break;
1652           case AND:
1653             e1->Val.uival = e1->Val.uival & e2->Val.uival;
1654             break;
1655           case BOR:
1656             e1->Val.uival = e1->Val.uival | e2->Val.uival;
1657             break;
1658           case XOR:
1659             e1->Val.uival = e1->Val.uival ^ e2->Val.uival;
1660             break;
1661           default:
1662             EiC_set_bastype(t_int, e1->Type);
1663             switch (op) {
1664               case LT:
1665                 e1->Val.ival = e1->Val.uival < e2->Val.uival;
1666                 break;
1667               case LE:
1668                 e1->Val.ival = e1->Val.uival <= e2->Val.uival;
1669                 break;
1670               case EQ:
1671                 e1->Val.ival = e1->Val.uival == e2->Val.uival;
1672                 break;
1673               case NE:
1674                 e1->Val.ival = e1->Val.uival != e2->Val.uival;
1675                 break;
1676               case GT:
1677                 e1->Val.ival = e1->Val.uival > e2->Val.uival;
1678                 break;
1679               case GE:
1680                 e1->Val.ival = e1->Val.uival >= e2->Val.uival;
1681                 break;
1682             }
1683             break;
1684         }
1685         break;
1686       CASE_LONG:
1687         switch (op) {
1688           case '*':
1689             e1->Val.lval *= e2->Val.lval;
1690             break;
1691           case '/':
1692             e1->Val.lval /= e2->Val.lval;
1693             break;
1694           case '+':
1695             e1->Val.lval += e2->Val.lval;
1696             break;
1697           case '-':
1698             e1->Val.lval -= e2->Val.lval;
1699             break;
1700           case '%':
1701             e1->Val.lval %= e2->Val.lval;
1702             break;
1703           case LSHT:
1704             e1->Val.lval <<= e2->Val.lval;
1705             break;
1706           case RSHT:
1707             e1->Val.lval >>= e2->Val.lval;
1708             break;
1709           case AND:
1710             e1->Val.lval = e1->Val.lval & e2->Val.lval;
1711             break;
1712           case BOR:
1713             e1->Val.lval = e1->Val.lval | e2->Val.lval;
1714             break;
1715           case XOR:
1716             e1->Val.lval = e1->Val.lval ^ e2->Val.lval;
1717             break;
1718           default:
1719             EiC_set_bastype(t_int, e1->Type);
1720             switch (op) {
1721               case LT:
1722                 e1->Val.ival = e1->Val.lval < e2->Val.lval;
1723                 break;
1724               case LE:
1725                 e1->Val.ival = e1->Val.lval <= e2->Val.lval;
1726                 break;
1727               case EQ:
1728                 e1->Val.ival = e1->Val.lval == e2->Val.lval;
1729                 break;
1730               case NE:
1731                 e1->Val.ival = e1->Val.lval != e2->Val.lval;
1732                 break;
1733               case GT:
1734                 e1->Val.ival = e1->Val.lval > e2->Val.lval;
1735                 break;
1736               case GE:
1737                 e1->Val.ival = e1->Val.lval >= e2->Val.lval;
1738                 break;
1739             }
1740             break;
1741         }
1742         break;
1743       case t_ulong:
1744         switch (op) {
1745           case '*':
1746             e1->Val.ulval *= e2->Val.ulval;
1747             break;
1748           case '/':
1749             e1->Val.ulval /= e2->Val.ulval;
1750             break;
1751           case '+':
1752             e1->Val.ulval += e2->Val.ulval;
1753             break;
1754           case '-':
1755             e1->Val.ulval -= e2->Val.ulval;
1756             break;
1757           case '%':
1758             e1->Val.ulval %= e2->Val.ulval;
1759             break;
1760           case LSHT:
1761             e1->Val.ulval <<= e2->Val.ulval;
1762             break;
1763           case RSHT:
1764             e1->Val.ulval >>= e2->Val.ulval;
1765             break;
1766           case AND:
1767             e1->Val.ulval = e1->Val.ulval & e2->Val.ulval;
1768             break;
1769           case BOR:
1770             e1->Val.ulval = e1->Val.ulval | e2->Val.ulval;
1771             break;
1772           case XOR:
1773             e1->Val.ulval = e1->Val.ulval ^ e2->Val.ulval;
1774             break;
1775           default:
1776             EiC_set_bastype(t_int, e1->Type);
1777             switch (op) {
1778               case LT:
1779                 e1->Val.ival = e1->Val.ulval < e2->Val.ulval;
1780                 break;
1781               case LE:
1782                 e1->Val.ival = e1->Val.ulval <= e2->Val.ulval;
1783                 break;
1784               case EQ:
1785                 e1->Val.ival = e1->Val.ulval == e2->Val.ulval;
1786                 break;
1787               case NE:
1788                 e1->Val.ival = e1->Val.ulval != e2->Val.ulval;
1789                 break;
1790               case GT:
1791                 e1->Val.ival = e1->Val.ulval > e2->Val.ulval;
1792                 break;
1793               case GE:
1794                 e1->Val.ival = e1->Val.ulval >= e2->Val.ulval;
1795                 break;
1796             }
1797             break;
1798         }
1799         break;
1800       case t_pointer:
1801         switch (op) {
1802           case LT:
1803             e1->Val.ival = e1->Val.p.p < e2->Val.p.p;
1804             break;
1805           case LE:
1806             e1->Val.ival = e1->Val.p.p <= e2->Val.p.p;
1807             break;
1808           case EQ:
1809             e1->Val.ival = e1->Val.p.p == e2->Val.p.p;
1810             break;
1811           case NE:
1812             e1->Val.ival = e1->Val.p.p != e2->Val.p.p;
1813             break;
1814           case GT:
1815             e1->Val.ival = e1->Val.p.p > e2->Val.p.p;
1816             break;
1817           case GE:
1818             e1->Val.ival = e1->Val.p.p >= e2->Val.p.p;
1819             break;
1820           default:
1821             EiC_error("Illegal constant pointer operation");
1822         }
1823         e1->Type = EiC_addtype(t_int, EiC_freetype(e1->Type));
1824         setConst(e1->Type);
1825         break;
1826       default:
1827         EiC_error("Illegal constants");
1828     }
1829     return 1;
1830 }
1831
1832 void * EiC_getaddress(token_t * e1)
1833 {
1834     void *p = NULL;
1835     int t = EiC_gettype(e1->Type);
1836     switch (t) {
1837         case t_builtin:
1838             if (e1->Sym->val.vfunc != 0)
1839                 p = (void*)e1->Sym->val.vfunc;
1840             else
1841                 EiC_error("No link to builtin function");
1842             e1->Type = EiC_addtype(t_pointer, e1->Type);
1843             break;
1844         case t_funcdec:
1845         case t_func:
1846             p = e1->Sym;
1847             e1->Type = EiC_addtype(t_pointer, e1->Type);
1848             break;
1849         case t_union:
1850         case t_struct:
1851             EiC_error("Illegal use of structure or uion: need an lvalue");
1852         case t_array:
1853             if (t == t_array)
1854                 EiC_exchtype(t_pointer, e1->Type);
1855         case t_pointer:
1856
1857             if(e1->Sym && EiC_gettype(e1->Sym->type) == t_ref)
1858                 p = EiC_ENV->AR[e1->Sym->val.ival].v.p.p;
1859             else
1860                 p = &EiC_ENV->AR[e1->Sym->val.ival].v;
1861             break;
1862
1863         default:
1864             /* watch out 4 reference variables */
1865             if(e1->Sym && EiC_gettype(e1->Sym->type) == t_ref) {
1866                 e1->Type = EiC_succType(e1->Type);
1867                 if(EiC_gettype(e1->Type) != t_pointer)
1868                     EiC_error("Illegal use of reference variable: %s", e1->Sym->id);
1869                 p = *(void**)EiC_ENV->AR[e1->Sym->val.ival].v.p.p;
1870             } else
1871                 EiC_error("Unknown type: need an lvalue");
1872     }
1873     return p;
1874 }
1875
1876 void derefConst(token_t * e1)
1877 {
1878     /* assumes incoming type is a ptr or array */
1879
1880     e1->Type = EiC_succType(e1->Type);
1881
1882     switch(EiC_gettype(e1->Type)) {
1883       case t_char:  case t_uchar:
1884       case t_short: case t_ushort:
1885       case t_int:   case t_uint:
1886       case t_long:  case t_ulong:
1887     case t_llong:
1888       case t_float: case t_double:
1889       case t_pointer:
1890       case t_union:
1891       case t_struct:
1892         EiC_generate(&e1->Code,pushptr,&e1->Val, 0);
1893         e1->Type = EiC_addtype(t_lval,e1->Type);
1894          break;
1895       case t_void:
1896         return;
1897       case t_array:
1898         EiC_exchtype(t_pointer,e1->Type);
1899         setConst(e1->Type);
1900
1901         break;
1902       default:
1903         EiC_error("Unknown const in derefConst");
1904     }
1905
1906 }
1907
1908 #if 0
1909 void EiC_addRval(code_t * code, int type, val_t *v, int st)
1910 {
1911     /* optomise away rvals  */
1912     int i;
1913     if((i=nextinst(code)))
1914         if(IsSto_op(opcode(code,i-1)) && ivalcode(code,i) == ivalcode(code,i-1))
1915             return;
1916
1917     EiC_generate(code,type,v,st);
1918 }
1919 #endif
1920
1921 void EiC_output(token_t * e1)
1922 {
1923     static val_t v;
1924     if (e1->Pflag == 0) {
1925         int t = EiC_gettype(e1->Type);
1926
1927         if(isconst(e1->Type)) {
1928             switch (t) {
1929             CASE_INT:
1930                 EiC_generate(&e1->Code, pushint, &e1->Val, 0); break;
1931             CASE_UINT:
1932                 EiC_generate(&e1->Code, pushuint, &e1->Val, 0); break;
1933             CASE_LONG:
1934                 EiC_generate(&e1->Code, pushlong, &e1->Val, 0); break;
1935             CASE_ULONG:
1936                 EiC_generate(&e1->Code, pushulong, &e1->Val, 0); break;
1937                 case t_llong: EiC_generate(&e1->Code, pushllong, &e1->Val, 0);
1938                     break;
1939             CASE_FLOAT:EiC_generate(&e1->Code, pushdouble, &e1->Val, 0);
1940             break;
1941                 case t_union:
1942                 case t_struct:
1943                 case t_array:
1944                     if (t == t_array)
1945                         EiC_exchtype(t_pointer, e1->Type);
1946                 case t_pointer:
1947                     EiC_generate(&e1->Code, pushptr, &e1->Val, 0);
1948                     break;
1949                 case t_void:
1950                     return;
1951                 default:
1952                     EiC_error("Unknown const type through output");
1953             }
1954             e1->Pflag =1;
1955             unsetConst(e1->Type);
1956             return;
1957         }
1958
1959         switch (t) {
1960             case t_char:
1961                 EiC_generate(&e1->Code, rvalchar, &e1->Val, EiC_GI(e1));
1962                 EiC_exchtype(t_int,e1->Type);
1963                 break;
1964             case t_uchar:
1965                 EiC_generate(&e1->Code, rvaluchar, &e1->Val, EiC_GI(e1));
1966                 EiC_exchtype(t_int,e1->Type);
1967                 break;
1968             case t_short:
1969                 EiC_generate(&e1->Code, rvalshort, &e1->Val, EiC_GI(e1));
1970                 EiC_exchtype(t_int,e1->Type);
1971                 break;
1972             case t_ushort:
1973                 EiC_generate(&e1->Code, rvalushort, &e1->Val, EiC_GI(e1));
1974                 EiC_exchtype(t_int,e1->Type);
1975                 break;
1976             case t_int:
1977             case t_uint:
1978                 /*EiC_addRval(&e1->Code, rvalint, &e1->Val, EiC_GI(e1));*/
1979                 EiC_generate(&e1->Code, rvalint, &e1->Val, EiC_GI(e1));
1980                 break;
1981         CASE_LONG:
1982         CASE_ULONG:EiC_generate(&e1->Code, rvallong, &e1->Val, EiC_GI(e1));
1983         break;
1984
1985             case t_llong:
1986                 EiC_generate(&e1->Code, rvalllong, &e1->Val, EiC_GI(e1)); break;
1987
1988             case t_float:
1989                 EiC_generate(&e1->Code, rvalfloat, &e1->Val,EiC_GI(e1));
1990                 EiC_exchtype(t_double,e1->Type);
1991                 break;
1992
1993             case t_double:
1994                 EiC_generate(&e1->Code, rvaldouble, &e1->Val,EiC_GI(e1));
1995                 break;
1996
1997             case t_builtin:
1998                 if (e1->Sym->val.vfunc != 0) {
1999                     v.vfunc = e1->Sym->val.vfunc;
2000                     EiC_generate(&e1->Code, pushptr, &v, 0);
2001                     e1->Type = EiC_addtype(t_pointer, e1->Type);
2002                 } else
2003                     EiC_error("No link to builtin function");
2004                 break;
2005             case t_funcdec:
2006                 EiC_exchtype(t_func, e1->Type);
2007             case t_func:
2008                 v.p.p = e1->Sym;
2009                 EiC_generate(&e1->Code, pushptr, &v, 0);
2010                 e1->Type = EiC_addtype(t_pointer, e1->Type);
2011                 break;
2012             case t_union:
2013             case t_struct:
2014             case t_array:
2015                 if (t == t_array)
2016                     EiC_exchtype(t_pointer, e1->Type);
2017             case t_pointer:
2018                 if(issafe(e1->Type))
2019                     EiC_generate(&e1->Code, rvalptr, &e1->Val, EiC_GI(e1));
2020                 else
2021                     EiC_generate(&e1->Code, rvaluptr, &e1->Val, EiC_GI(e1));
2022                 break;
2023
2024             case t_ref:
2025
2026                 EiC_generate(&e1->Code, rvaluptr, &e1->Val, EiC_GI(e1));
2027
2028                 return;
2029
2030             case t_lval:
2031                 e1->Type = EiC_succType(e1->Type);
2032                 switch (EiC_gettype(e1->Type)) {
2033                     case t_uchar:
2034                         EiC_generate(&e1->Code, drefuchar, &e1->Val, 0);
2035                         break;
2036                     case t_char:
2037                         EiC_generate(&e1->Code, drefchar, &e1->Val, 0);
2038                         break;
2039                     case t_short:
2040                         EiC_generate(&e1->Code, drefshort, &e1->Val, 0);
2041                         break;
2042                     case t_ushort:
2043                         EiC_generate(&e1->Code, drefushort, &e1->Val, 0);
2044                         break;
2045                     case t_int:
2046                         EiC_generate(&e1->Code, drefint, &e1->Val, 0);
2047                         break;
2048                     case t_uint:
2049                         EiC_generate(&e1->Code, drefuint, &e1->Val, 0);
2050                         break;
2051                 CASE_LONG:EiC_generate(&e1->Code, dreflong, &e1->Val, 0);
2052                 break;
2053                 CASE_ULONG:EiC_generate(&e1->Code, drefulong, &e1->Val, 0);
2054                 break;
2055                     case t_llong:EiC_generate(&e1->Code, drefllong, &e1->Val, 0);
2056                         break;
2057                     case t_float:
2058                         EiC_generate(&e1->Code, dreffloat, &e1->Val, 0);
2059                         break;
2060                     case t_double:
2061                         EiC_generate(&e1->Code, drefdouble, &e1->Val, 0);
2062                         break;
2063                     case t_array:
2064                     case t_struct:
2065                     case t_union:
2066                         break;
2067                     case t_pointer:
2068                         if(issafe(e1->Type))
2069                             EiC_generate(&e1->Code, drefptr, &e1->Val, EiC_GI(e1));
2070                         else
2071                             EiC_generate(&e1->Code, drefuptr, &e1->Val, EiC_GI(e1));
2072                         break;
2073
2074                     case t_funcdec:
2075                     case t_func:
2076                         e1->Type = EiC_succType(e1->Type);
2077                         if(EiC_gettype(nextType(e1->Type)) == t_void)
2078                             EiC_generate(&e1->Code, eiccall, &e1->Val, 0);
2079                         else
2080                             EiC_generate(&e1->Code, eiccall, &e1->Val, 1);
2081                         break;
2082                     case t_builtin:
2083                         if(EiC_gettype(nextType(e1->Type)) == t_void)
2084                            EiC_generate(&e1->Code, call, &e1->Val, 0);
2085                         else
2086                             EiC_generate(&e1->Code, call, &e1->Val, 1);
2087                         e1->Type = EiC_succType(e1->Type);
2088                         break;
2089                     default:
2090                         EiC_error("Illegal lvalue");
2091                         break;
2092                 }
2093                 break;
2094             case t_void:
2095                 return;
2096
2097             case ID:
2098                 EiC_error("Undeclared identifier %s",e1->Sym->id);
2099                 break;
2100
2101             default:
2102                 EiC_error("Unknown type through output");
2103                 return;
2104         }
2105         e1->Pflag = 1;
2106     }
2107 }
2108
2109 void EiC_do_inc_dec(token_t * e1, int op)
2110 {
2111     val_t v;
2112     int t;
2113
2114     switch (EiC_gettype(e1->Type)) {
2115       CASE_INT:
2116         t = EiC_gettype(e1->Type);
2117         EiC_output(e1);
2118         v.ival = 1;
2119         if (op == INC)
2120             op = incint;
2121         else
2122             op = decint;
2123         EiC_exchtype(t,e1->Type);
2124         break;
2125       CASE_UINT:
2126         t = EiC_gettype(e1->Type);
2127         EiC_output(e1);
2128         v.ival = 1;
2129         if (op == INC)
2130             op = incuint;
2131         else
2132             op = decuint;
2133         EiC_exchtype(t,e1->Type);
2134         break;
2135       CASE_LONG:
2136         EiC_output(e1);
2137         v.ival = 1;
2138         if (op == INC)
2139             op = inclong;
2140         else
2141             op = declong;
2142         break;
2143       CASE_ULONG:
2144         EiC_output(e1);
2145         v.ival = 1;
2146         if (op == INC)
2147             op = inculong;
2148         else
2149             op = deculong;
2150         break;
2151     case t_llong:
2152         EiC_output(e1);
2153         v.ival = 1;
2154         if (op == INC)
2155             op = incllong;
2156         else
2157             op = decllong;
2158         break;
2159
2160       case t_pointer:
2161         EiC_output(e1);
2162         v.ival = EiC_get_sizeof(nextType(e1->Type));
2163         if (op == INC)
2164             op = incptr;
2165         else
2166             op = decptr;
2167         break;
2168       case t_lval:
2169         v.ival = 1;
2170         EiC_generate(&e1->Code, dupval, &v, 0);
2171         EiC_output(e1);
2172         EiC_do_inc_dec(e1, op);
2173         v.ival = 1;
2174         /*EiC_generate(&e1->Code, bump, &v, 0);*/
2175         e1->Type = EiC_addtype(t_lval, e1->Type);
2176         return;
2177       case t_float:
2178       case t_double:
2179         t = EiC_gettype(e1->Type);
2180         EiC_output(e1);
2181         v.ival = 1;
2182         if (op == INC)
2183             op = incdouble;
2184         else
2185             op = decdouble;
2186         EiC_exchtype(t,e1->Type);
2187         break;
2188
2189       default:
2190         EiC_error("Cannot apply inc\\dec");
2191         return;
2192     }
2193     EiC_generate(&e1->Code, op, &v, 0);
2194 }
2195
2196 void EiC_do_stooutput(token_t * e1)
2197 {
2198
2199     if (e1->Pflag == 0) {
2200         switch (EiC_gettype(e1->Type)) {
2201           case t_char:
2202           case t_uchar:
2203             EiC_generate(&e1->Code, stochar, &e1->Val, EiC_GI(e1));
2204             break;
2205           case t_short:
2206           case t_ushort:
2207             EiC_generate(&e1->Code, stoshort, &e1->Val, EiC_GI(e1));
2208             break;
2209           case t_int:
2210           case t_uint:
2211             EiC_generate(&e1->Code, stoint, &e1->Val, EiC_GI(e1));
2212             break;
2213           CASE_LONG:
2214           CASE_ULONG:EiC_generate(&e1->Code, stolong, &e1->Val, EiC_GI(e1));
2215             break;
2216         case t_llong:EiC_generate(&e1->Code, stollong, &e1->Val, EiC_GI(e1));
2217             break;
2218
2219           case t_float:
2220             EiC_generate(&e1->Code, stofloat, &e1->Val, EiC_GI(e1));
2221             break;
2222           case t_double:
2223             EiC_generate(&e1->Code, stodouble, &e1->Val, EiC_GI(e1));
2224             break;
2225           case t_pointer:
2226             if(issafe(e1->Type))
2227               EiC_generate(&e1->Code, stoptr, &e1->Val, EiC_GI(e1));
2228             else
2229               EiC_generate(&e1->Code, stouptr, &e1->Val, EiC_GI(e1));
2230             break;
2231           case t_struct:
2232           case t_union:{
2233               val_t v;
2234               v.ival = EiC_get_sizeof(e1->Type);
2235               EiC_output(e1);
2236               EiC_generate(&e1->Code, refmem, &v, 0);
2237           }
2238             break;
2239           case t_lval:
2240             e1->Type = EiC_succType(e1->Type);
2241             if(isconst(e1->Type) || isconstp(e1->Type))
2242                 EiC_error("Illegal assignment operation");
2243             switch (EiC_gettype(e1->Type)) {
2244               case t_uchar:
2245               case t_char:
2246                 EiC_generate(&e1->Code, refchar, &e1->Val, 0);
2247                 break;
2248               case t_short:
2249               case t_ushort:
2250                 EiC_generate(&e1->Code, refshort, &e1->Val, 0);
2251                 break;
2252               case t_int:
2253               case t_uint:
2254                 EiC_generate(&e1->Code, refint, &e1->Val, 0);
2255                 break;
2256               CASE_LONG:EiC_generate(&e1->Code, reflong, &e1->Val, 0);
2257                 break;
2258               CASE_ULONG:EiC_generate(&e1->Code, refulong, &e1->Val, 0);
2259                 break;
2260             case t_llong:
2261               EiC_generate(&e1->Code, refllong, &e1->Val, 0);
2262                 break;
2263               case t_float:
2264                 EiC_generate(&e1->Code, reffloat, &e1->Val, 0);
2265                 break;
2266               case t_double:
2267                 EiC_generate(&e1->Code, refdouble, &e1->Val, 0);
2268                 break;
2269               case t_pointer:
2270                 if(issafe(e1->Type))
2271                     EiC_generate(&e1->Code, refptr, &e1->Val, EiC_GI(e1));
2272                 else
2273                     EiC_generate(&e1->Code, refuptr, &e1->Val, EiC_GI(e1));
2274                 break;
2275               case t_struct:
2276               case t_union:{
2277                   val_t v;
2278                   v.ival = EiC_get_sizeof(e1->Type);
2279                   EiC_generate(&e1->Code, refmem, &v, 0);
2280               }
2281                 break;
2282               default:
2283                 EiC_error("Illegal lvalue");
2284                 break;
2285             }
2286             break;
2287           default:
2288             EiC_error(" Invalid assignment");
2289             break;
2290         }
2291         e1->Pflag = 1;
2292     }
2293 }
2294
2295 void binhconst(unsigned opr, token_t * e1, token_t * e2)
2296 {
2297     void (*f) (unsigned, token_t *, token_t *);
2298     int t;
2299
2300     if(!e1->Pflag && isconst(e1->Type) && isconst(e2->Type)) {
2301       if(e2->Pflag)
2302         EiC_output(e1);
2303       else {
2304         do_binaryop(e1, e2, opr);
2305         return;
2306       }
2307
2308     }
2309     /*
2310      * Now perform usual arithmetic conversion
2311      * i.e promote to larger type.
2312      */
2313
2314     if(EiC_gettype(e1->Type) < EiC_gettype(e2->Type))
2315         t = EiC_gettype(e2->Type);
2316     else
2317         t = EiC_gettype(e1->Type);
2318
2319     switch (t) {
2320       CASE_INT:     f = binhint;    break;
2321       CASE_UINT:    f = binhuint;   break;
2322       CASE_LONG:    f = binhlong;   break;
2323       CASE_ULONG:   f = binhulong;  break;
2324       CASE_FLOAT:   f = binhdouble; break;
2325       case t_llong: f = binhllong;  break;
2326
2327       case t_array:
2328       case t_pointer:
2329         f = EiC_binhlval;
2330         break;
2331       default:
2332         EiC_error("Unknown type in binhconst");
2333         return;
2334     }
2335     (*f) (opr, e1, e2);
2336 }
2337
2338
2339
2340
2341
2342