git.gag.com Git - fw/sdcc/blob - src/SDCCval.c

   1 /*----------------------------------------------------------------------
   2     SDCCval.c :- has routine to do all kinds of fun stuff with the
   3                 value wrapper & with initialiser lists.
   4
   5     Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998)
   6
   7     This program is free software; you can redistribute it and/or modify it
   8     under the terms of the GNU General Public License as published by the
   9     Free Software Foundation; either version 2, or (at your option) any
  10     later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program; if not, write to the Free Software
  19     Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20
  21     In other words, you are welcome to use, share and improve this program.
  22     You are forbidden to forbid anyone else to use, share and improve
  23     what you give them.   Help stamp out software-hoarding!
  24 -------------------------------------------------------------------------*/
  25
  26 #include "common.h"
  27 #include <math.h>
  28 #include <stdlib.h>
  29 #include <limits.h>
  30 #include <errno.h>
  31 #include "newalloc.h"
  32
  33 int cNestLevel;
  34
  35 /*-----------------------------------------------------------------*/
  36 /* newValue - allocates and returns a new value        */
  37 /*-----------------------------------------------------------------*/
  38 value *
  39 newValue ()
  40 {
  41   value *val;
  42
  43   val = Safe_alloc (sizeof (value));
  44
  45   return val;
  46 }
  47
  48 /*-----------------------------------------------------------------*/
  49 /* newiList - new initializer list                                 */
  50 /*-----------------------------------------------------------------*/
  51 initList *
  52 newiList (int type, void *ilist)
  53 {
  54   initList *nilist;
  55
  56
  57   nilist = Safe_alloc (sizeof (initList));
  58
  59   nilist->type = type;
  60   nilist->lineno = lexLineno;
  61   nilist->filename = lexFilename;
  62
  63   switch (type)
  64     {
  65     case INIT_NODE:
  66       nilist->init.node = (struct ast *) ilist;
  67       break;
  68
  69     case INIT_DEEP:
  70       nilist->init.deep = (struct initList *) ilist;
  71       break;
  72     }
  73
  74   return nilist;
  75 }
  76
  77 /*------------------------------------------------------------------*/
  78 /* revinit   - reverses the initial values for a value  chain        */
  79 /*------------------------------------------------------------------*/
  80 initList *
  81 revinit (initList * val)
  82 {
  83   initList *prev, *curr, *next;
  84
  85   if (!val)
  86     return NULL;
  87
  88   prev = val;
  89   curr = val->next;
  90
  91   while (curr)
  92     {
  93       next = curr->next;
  94       curr->next = prev;
  95       prev = curr;
  96       curr = next;
  97     }
  98   val->next = (void *) NULL;
  99   return prev;
 100 }
 101
 102 bool
 103 convertIListToConstList(initList *src, literalList **lList)
 104 {
 105     initList    *iLoop;
 106     literalList *head, *last, *newL;
 107
 108     head = last = NULL;
 109
 110     if (!src || src->type != INIT_DEEP)
 111     {
 112         return FALSE;
 113     }
 114
 115     iLoop =  src->init.deep;
 116
 117     while (iLoop)
 118     {
 119         if (iLoop->type != INIT_NODE)
 120         {
 121             return FALSE;
 122         }
 123
 124         if (!IS_AST_LIT_VALUE(decorateType(resolveSymbols(iLoop->init.node), RESULT_TYPE_NONE)))
 125         {
 126             return FALSE;
 127         }
 128         iLoop = iLoop->next;
 129     }
 130
 131     // We've now established that the initializer list contains only literal values.
 132
 133     iLoop = src->init.deep;
 134     while (iLoop)
 135     {
 136         double val = AST_LIT_VALUE(iLoop->init.node);
 137
 138         if (last && last->literalValue == val)
 139         {
 140             last->count++;
 141         }
 142         else
 143         {
 144             newL = Safe_alloc(sizeof(literalList));
 145             newL->literalValue = val;
 146             newL->count = 1;
 147             newL->next = NULL;
 148
 149             if (last)
 150             {
 151                 last->next = newL;
 152             }
 153             else
 154             {
 155                 head = newL;
 156             }
 157             last = newL;
 158         }
 159         iLoop = iLoop->next;
 160     }
 161
 162     if (!head)
 163     {
 164         return FALSE;
 165     }
 166
 167     *lList = head;
 168     return TRUE;
 169 }
 170
 171 literalList *
 172 copyLiteralList(literalList *src)
 173 {
 174     literalList *head, *prev, *newL;
 175
 176     head = prev = NULL;
 177
 178     while (src)
 179     {
 180         newL = Safe_alloc(sizeof(literalList));
 181
 182         newL->literalValue = src->literalValue;
 183         newL->count = src->count;
 184         newL->next = NULL;
 185
 186         if (prev)
 187         {
 188             prev->next = newL;
 189         }
 190         else
 191         {
 192             head = newL;
 193         }
 194         prev = newL;
 195         src = src->next;
 196     }
 197
 198     return head;
 199 }
 200
 201
 202
 203 /*------------------------------------------------------------------*/
 204 /* copyIlist - copy initializer list            */
 205 /*------------------------------------------------------------------*/
 206 initList *
 207 copyIlist (initList * src)
 208 {
 209   initList *dest = NULL;
 210
 211   if (!src)
 212     return NULL;
 213
 214   switch (src->type)
 215     {
 216     case INIT_DEEP:
 217       dest = newiList (INIT_DEEP, copyIlist (src->init.deep));
 218       break;
 219     case INIT_NODE:
 220       dest = newiList (INIT_NODE, copyAst (src->init.node));
 221       break;
 222     }
 223
 224   if (src->next)
 225     dest->next = copyIlist (src->next);
 226
 227   return dest;
 228 }
 229
 230 /*------------------------------------------------------------------*/
 231 /* list2int - converts the first element of the list to value       */
 232 /*------------------------------------------------------------------*/
 233 double
 234 list2int (initList * val)
 235 {
 236   initList *i = val;
 237
 238   if (i->type == INIT_DEEP)
 239     return list2int (val->init.deep);
 240
 241   return floatFromVal (constExprValue (val->init.node, TRUE));
 242 }
 243
 244 /*------------------------------------------------------------------*/
 245 /* list2val - converts the first element of the list to value       */
 246 /*------------------------------------------------------------------*/
 247 value *
 248 list2val (initList * val)
 249 {
 250   if (!val)
 251     return NULL;
 252
 253   if (val->type == INIT_DEEP)
 254     return list2val (val->init.deep);
 255
 256   return constExprValue (val->init.node, TRUE);
 257 }
 258
 259 /*------------------------------------------------------------------*/
 260 /* list2expr - returns the first expression in the initializer list */
 261 /*------------------------------------------------------------------*/
 262 ast *
 263 list2expr (initList * ilist)
 264 {
 265   if (ilist->type == INIT_DEEP)
 266     return list2expr (ilist->init.deep);
 267   return ilist->init.node;
 268 }
 269
 270 /*------------------------------------------------------------------*/
 271 /* resolveIvalSym - resolve symbols in initial values               */
 272 /*------------------------------------------------------------------*/
 273 void
 274 resolveIvalSym (initList * ilist, sym_link * type)
 275 {
 276   RESULT_TYPE resultType;
 277
 278   if (!ilist)
 279     return;
 280
 281   if (ilist->type == INIT_NODE)
 282     {
 283       if (IS_PTR (type))
 284         resultType = RESULT_TYPE_INT;
 285       else
 286         resultType = getResultTypeFromType (getSpec (type));
 287       ilist->init.node = decorateType (resolveSymbols (ilist->init.node),
 288                                        resultType);
 289     }
 290
 291   if (ilist->type == INIT_DEEP)
 292     resolveIvalSym (ilist->init.deep, type);
 293
 294   resolveIvalSym (ilist->next, type);
 295 }
 296
 297 /*-----------------------------------------------------------------*/
 298 /* symbolVal - creates a value for a symbol              */
 299 /*-----------------------------------------------------------------*/
 300 value *
 301 symbolVal (symbol * sym)
 302 {
 303   value *val;
 304
 305   if (!sym)
 306     return NULL;
 307
 308   val = newValue ();
 309   val->sym = sym;
 310
 311   if (sym->type)
 312     {
 313       val->type = sym->type;
 314       val->etype = getSpec (val->type);
 315     }
 316
 317   if (*sym->rname)
 318     {
 319         SNPRINTF (val->name, sizeof(val->name), "%s", sym->rname);
 320     }
 321   else
 322     {
 323         SNPRINTF (val->name, sizeof(val->name), "_%s", sym->name);
 324     }
 325
 326   return val;
 327 }
 328
 329 /*--------------------------------------------------------------------*/
 330 /* cheapestVal - try to reduce 'signed int' to 'char'                 */
 331 /*--------------------------------------------------------------------*/
 332 static value *
 333 cheapestVal (value *val)
 334 {
 335   /* only int can be reduced */
 336   if (!IS_INT(val->type))
 337     return val;
 338
 339   /* long must not be changed */
 340   if (SPEC_LONG(val->type))
 341     return val;
 342
 343   /* unsigned must not be changed */
 344   if (SPEC_USIGN(val->type))
 345     return val;
 346
 347   /* the only possible reduction is from signed int to (un)signed char,
 348      because it's automatically promoted back to signed int.
 349
 350      a reduction from unsigned int to unsigned char is a bug,
 351      because an _unsigned_ char is promoted to _signed_ int! */
 352   if (SPEC_CVAL(val->type).v_int < -128 ||
 353       SPEC_CVAL(val->type).v_int >  255)
 354     {
 355       /* not in the range of (un)signed char */
 356       return val;
 357     }
 358
 359   SPEC_NOUN(val->type) = V_CHAR;
 360
 361   /* 'unsigned char' promotes to 'signed int', so that we can
 362      reduce it the other way */
 363   if (SPEC_CVAL(val->type).v_int >= 0)
 364     {
 365       SPEC_USIGN(val->type) = 1;
 366     }
 367   return (val);
 368 }
 369
 370 /*--------------------------------------------------------------------*/
 371 /* checkConstantRange - check if constant fits in numeric range of    */
 372 /* var type in comparisons and assignments                            */
 373 /*--------------------------------------------------------------------*/
 374 CCR_RESULT
 375 checkConstantRange (sym_link *var, sym_link *lit, int op, bool exchangeLeftRight)
 376 {
 377   sym_link *reType;
 378   double litVal;
 379   int varBits;
 380
 381   litVal = floatFromVal (valFromType (lit));
 382   varBits = bitsForType (var);
 383
 384   /* sanity checks */
 385   if (   IS_FLOAT (var)
 386       || IS_FIXED (var))
 387     return CCR_OK;
 388   if (varBits < 1)
 389     return CCR_ALWAYS_FALSE;
 390   if (varBits > 32)
 391     return CCR_ALWAYS_TRUE;
 392
 393   /* special: assignment */
 394   if (op == '=')
 395     {
 396       if (IS_BIT (var))
 397         return CCR_OK;
 398
 399       if (getenv ("SDCC_VERY_PEDANTIC"))
 400         {
 401           if (SPEC_USIGN (var))
 402             {
 403               TYPE_TARGET_ULONG maxVal = 0xffffffffu >> (32 - varBits);
 404
 405               if (   litVal < 0
 406                   || litVal > maxVal)
 407                 return CCR_OVL;
 408               return CCR_OK;
 409             }
 410           else
 411             {
 412               TYPE_TARGET_LONG minVal = 0xffffffff << (varBits - 1);
 413               TYPE_TARGET_LONG maxVal = 0x7fffffff >> (32 - varBits);
 414
 415               if (   litVal < minVal
 416                   || litVal > maxVal)
 417                 return CCR_OVL;
 418               return CCR_OK;
 419             }
 420         }
 421       else
 422         {
 423           /* ignore signedness, e.g. allow everything
 424              from -127...+255 for (unsigned) char */
 425           TYPE_TARGET_LONG  minVal = 0xffffffff  << (varBits - 1);
 426           TYPE_TARGET_ULONG maxVal = 0xffffffffu >> (32 - varBits);
 427
 428           if (   litVal < minVal
 429               || litVal > maxVal)
 430             return CCR_OVL;
 431           return CCR_OK;
 432         }
 433     }
 434
 435   if (exchangeLeftRight)
 436     switch (op)
 437       {
 438         case EQ_OP:             break;
 439         case NE_OP:             break;
 440         case '>':   op = '<';   break;
 441         case GE_OP: op = LE_OP; break;
 442         case '<':   op = '>';   break;
 443         case LE_OP: op = GE_OP; break;
 444         default:                return CCR_ALWAYS_FALSE;
 445       }
 446
 447   reType = computeType (var, lit, RESULT_TYPE_NONE, op);
 448
 449   if (SPEC_USIGN (reType))
 450     {
 451       /* unsigned operation */
 452       TYPE_TARGET_ULONG minValP, maxValP, minValM, maxValM;
 453       TYPE_TARGET_ULONG opBitsMask = 0xffffffffu >> (32 - bitsForType (reType));
 454
 455       if (SPEC_USIGN (lit) && SPEC_USIGN (var))
 456         {
 457           /* both operands are unsigned, this is easy */
 458           minValP = 0;
 459           maxValP = 0xffffffffu >> (32 - varBits);
 460           /* there's only range, just copy it to 2nd set */
 461           minValM = minValP;
 462           maxValM = maxValP;
 463         }
 464       else if (SPEC_USIGN (var))
 465         {
 466           /* lit is casted from signed to unsigned, e.g.:
 467                unsigned u;
 468                  u == (char) -17
 469               -> u == 0xffef'
 470           */
 471           minValP = 0;
 472           maxValP = 0xffffffffu >> (32 - varBits);
 473           /* there's only one range, just copy it to 2nd set */
 474           minValM = minValP;
 475           maxValM = maxValP;
 476
 477           /* it's an unsigned operation */
 478           if (   IS_CHAR (reType)
 479               || IS_INT (reType))
 480             {
 481               /* make signed literal unsigned and
 482                  limit no of bits to size of return type */
 483               litVal = (TYPE_TARGET_ULONG) litVal & opBitsMask;
 484             }
 485         }
 486       else /* SPEC_USIGN (lit) */
 487         {
 488           /* var is casted from signed to unsigned, e.g.:
 489                signed char c;
 490                  c == (unsigned) -17
 491               -> c == 0xffef'
 492
 493              The possible values after casting var
 494              split up in two, nonconsecutive ranges:
 495
 496              minValP =      0;  positive range: 0...127
 497              maxValP =   0x7f;
 498              minValM = 0xff80;  negative range: -128...-1
 499              maxValM = 0xffff;
 500           */
 501
 502           /* positive range */
 503           minValP = 0;
 504           maxValP = 0x7fffffffu >> (32 - varBits);
 505
 506           /* negative range */
 507           minValM = 0xffffffff  << (varBits - 1);
 508           maxValM = 0xffffffffu; /* -1 */
 509           /* limit no of bits to size of return type */
 510           minValM &= opBitsMask;
 511           maxValM &= opBitsMask;
 512         }
 513
 514       switch (op)
 515         {
 516           case EQ_OP:                   /* var == lit */
 517             if (   litVal <= maxValP
 518                 && litVal >= minValP) /* 0 */
 519               return CCR_OK;
 520             if (   litVal <= maxValM
 521                 && litVal >= minValM)
 522               return CCR_OK;
 523             return CCR_ALWAYS_FALSE;
 524           case NE_OP:                   /* var != lit */
 525             if (   litVal <= maxValP
 526                 && litVal >= minValP) /* 0 */
 527               return CCR_OK;
 528             if (   litVal <= maxValM
 529                 && litVal >= minValM)
 530               return CCR_OK;
 531             return CCR_ALWAYS_TRUE;
 532           case '>':                     /* var >  lit */
 533             if (litVal >= maxValM)
 534               return CCR_ALWAYS_FALSE;
 535             if (litVal <  minValP) /* 0 */
 536               return CCR_ALWAYS_TRUE;
 537             return CCR_OK;
 538           case GE_OP:                   /* var >= lit */
 539             if (litVal >  maxValM)
 540               return CCR_ALWAYS_FALSE;
 541             if (litVal <= minValP) /* 0 */
 542               return CCR_ALWAYS_TRUE;
 543             return CCR_OK;
 544           case '<':                     /* var <  lit */
 545             if (litVal >  maxValM)
 546               return CCR_ALWAYS_TRUE;
 547             if (litVal <= minValP) /* 0 */
 548               return CCR_ALWAYS_FALSE;
 549             return CCR_OK;
 550           case LE_OP:                   /* var <= lit */
 551             if (litVal >= maxValM)
 552               return CCR_ALWAYS_TRUE;
 553             if (litVal <  minValP) /* 0 */
 554               return CCR_ALWAYS_FALSE;
 555             return CCR_OK;
 556           default:
 557             return CCR_ALWAYS_FALSE;
 558         }
 559     }
 560   else
 561     {
 562       /* signed operation */
 563       TYPE_TARGET_LONG minVal, maxVal;
 564
 565       if (SPEC_USIGN (var))
 566         {
 567           /* unsigned var, but signed operation. This happens
 568              when var is promoted to signed int.
 569              Set actual min/max values of var. */
 570           minVal = 0;
 571           maxVal = 0xffffffff >> (32 - varBits);
 572         }
 573       else
 574         {
 575           /* signed var */
 576           minVal = 0xffffffff << (varBits - 1);
 577           maxVal = 0x7fffffff >> (32 - varBits);
 578         }
 579
 580       switch (op)
 581         {
 582           case EQ_OP:                   /* var == lit */
 583             if (   litVal > maxVal
 584                 || litVal < minVal)
 585               return CCR_ALWAYS_FALSE;
 586             return CCR_OK;
 587           case NE_OP:                   /* var != lit */
 588             if (   litVal > maxVal
 589                 || litVal < minVal)
 590               return CCR_ALWAYS_TRUE;
 591             return CCR_OK;
 592           case '>':                     /* var >  lit */
 593             if (litVal >= maxVal)
 594               return CCR_ALWAYS_FALSE;
 595             if (litVal <  minVal)
 596               return CCR_ALWAYS_TRUE;
 597             return CCR_OK;
 598           case GE_OP:                   /* var >= lit */
 599             if (litVal >  maxVal)
 600               return CCR_ALWAYS_FALSE;
 601             if (litVal <= minVal)
 602               return CCR_ALWAYS_TRUE;
 603             return CCR_OK;
 604           case '<':                     /* var <  lit */
 605             if (litVal >  maxVal)
 606               return CCR_ALWAYS_TRUE;
 607             if (litVal <= minVal)
 608               return CCR_ALWAYS_FALSE;
 609             return CCR_OK;
 610           case LE_OP:                   /* var <= lit */
 611             if (litVal >= maxVal)
 612               return CCR_ALWAYS_TRUE;
 613             if (litVal <  minVal)
 614               return CCR_ALWAYS_FALSE;
 615             return CCR_OK;
 616           default:
 617             return CCR_ALWAYS_FALSE;
 618         }
 619     }
 620 }
 621
 622 /*-----------------------------------------------------------------*/
 623 /* valueFromLit - creates a value from a literal                   */
 624 /*-----------------------------------------------------------------*/
 625 value *
 626 valueFromLit (double lit)
 627 {
 628   char buffer[50];
 629
 630   if ((((TYPE_TARGET_LONG) lit) - lit) == 0)
 631     {
 632       SNPRINTF (buffer, sizeof(buffer), "%d", (TYPE_TARGET_LONG) lit);
 633       return constVal (buffer);
 634     }
 635
 636   SNPRINTF (buffer, sizeof(buffer), "%f", lit);
 637   return constFloatVal (buffer);
 638 }
 639
 640 /*-----------------------------------------------------------------*/
 641 /* constFloatVal - converts a FLOAT constant to value              */
 642 /*-----------------------------------------------------------------*/
 643 value *
 644 constFloatVal (char *s)
 645 {
 646   value *val = newValue ();
 647   double sval;
 648
 649   if (sscanf (s, "%lf", &sval) != 1)
 650     {
 651       werror (E_INVALID_FLOAT_CONST, s);
 652       return constVal ("0");
 653     }
 654
 655   val->type = val->etype = newLink (SPECIFIER);
 656   SPEC_NOUN (val->type) = V_FLOAT;
 657   SPEC_SCLS (val->type) = S_LITERAL;
 658   SPEC_CVAL (val->type).v_float = sval;
 659
 660   return val;
 661 }
 662
 663 /*-----------------------------------------------------------------*/
 664 /* constFixed16x16Val - converts a FIXED16X16 constant to value    */
 665 /*-----------------------------------------------------------------*/
 666 value *
 667 constFixed16x16Val (char *s)
 668 {
 669   value *val = newValue ();
 670   double sval;
 671
 672   if (sscanf (s, "%lf", &sval) != 1)
 673     {
 674       werror (E_INVALID_FLOAT_CONST, s);
 675       return constVal ("0");
 676     }
 677
 678   val->type = val->etype = newLink (SPECIFIER);
 679   SPEC_NOUN (val->type) = V_FLOAT;
 680   SPEC_SCLS (val->type) = S_LITERAL;
 681   SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble ( sval );
 682
 683   return val;
 684 }
 685
 686 /*-----------------------------------------------------------------*/
 687 /* constVal - converts an INTEGER constant into a cheapest value   */
 688 /*-----------------------------------------------------------------*/
 689 value *constVal (const char *s)
 690 {
 691   value *val;
 692   short hex = 0, octal = 0;
 693   double dval;
 694
 695   val = newValue ();            /* alloc space for value   */
 696
 697   val->type = val->etype = newLink (SPECIFIER); /* create the spcifier */
 698   SPEC_SCLS (val->type) = S_LITERAL;
 699   // let's start with a signed char
 700   SPEC_NOUN (val->type) = V_CHAR;
 701   SPEC_USIGN (val->type) = 0;
 702
 703   hex = ((strchr (s, 'x') || strchr (s, 'X')) ? 1 : 0);
 704
 705   /* set the octal flag   */
 706   if (!hex && *s == '0' && *(s + 1))
 707     octal = 1;
 708
 709   errno = 0;
 710   if (hex || octal) {
 711     unsigned long sval;
 712     sval = strtoul (s, NULL, 0);
 713     dval=sval;
 714     if (errno) {
 715       dval = 4294967295.0;
 716       werror (W_INVALID_INT_CONST, s, dval);
 717     }
 718   } else {
 719     sscanf (s, "%lf", &dval);
 720   }
 721
 722   /* Setup the flags first */
 723   /* set the unsigned flag if 'uU' is found */
 724   if (strchr (s, 'u') || strchr (s, 'U')) {
 725     SPEC_USIGN (val->type) = 1;
 726   }
 727
 728   /* set the b_long flag if 'lL' is found */
 729   if (strchr (s, 'l') || strchr (s, 'L')) {
 730     SPEC_NOUN (val->type) = V_INT;
 731     SPEC_LONG (val->type) = 1;
 732   } else {
 733     if (dval<0) { // "-28u" will still be signed and negative
 734       if (dval<-128) { // check if we have to promote to int
 735         SPEC_NOUN (val->type) = V_INT;
 736       }
 737       if (dval<-32768) { // check if we have to promote to long int
 738         SPEC_LONG (val->type) = 1;
 739       }
 740     } else { // >=0
 741       if (dval>0xff ||  /* check if we have to promote to int */
 742           SPEC_USIGN (val->type)) { /* if it's unsigned, we can't use unsigned
 743                                      char. After an integral promotion it will
 744                                      be a signed int; this certainly isn't what
 745                                      the programer wants */
 746         SPEC_NOUN (val->type) = V_INT;
 747       }
 748       else { /* store char's always as unsigned; this helps other optimizations */
 749         SPEC_USIGN (val->type) = 1;
 750       }
 751       if (dval>0xffff && SPEC_USIGN (val->type)) { // check if we have to promote to long
 752         SPEC_LONG (val->type) = 1;
 753       }
 754       else if (dval>0x7fff && !SPEC_USIGN (val->type)) { // check if we have to promote to long int
 755         if ((hex || octal) && /* hex or octal constants may be stored in unsigned type */
 756             dval<=0xffff) {
 757           SPEC_USIGN (val->type) = 1;
 758         } else {
 759           SPEC_LONG (val->type) = 1;
 760           if (dval>0x7fffffff) {
 761             SPEC_USIGN (val->type) = 1;
 762           }
 763         }
 764       }
 765     }
 766   }
 767
 768   /* check for out of range */
 769   if (dval<-2147483648.0) {
 770     dval = -2147483648.0;
 771     werror (W_INVALID_INT_CONST, s, dval);
 772   }
 773   if (dval>2147483647.0 && !SPEC_USIGN (val->type)) {
 774     dval = 2147483647.0;
 775     werror (W_INVALID_INT_CONST, s, dval);
 776   }
 777   if (dval>4294967295.0) {
 778     dval = 4294967295.0;
 779     werror (W_INVALID_INT_CONST, s, dval);
 780   }
 781
 782   if (SPEC_LONG (val->type))
 783     {
 784       if (SPEC_USIGN (val->type))
 785         {
 786           SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG)dval;
 787         }
 788       else
 789         {
 790           SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG)dval;
 791         }
 792     }
 793   else
 794     {
 795       if (SPEC_USIGN (val->type))
 796         {
 797           SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT)dval;
 798         }
 799       else
 800         {
 801           SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT)dval;
 802         }
 803     }
 804
 805   return val;
 806 }
 807
 808 /*------------------------------------------------------------------*/
 809 /* strVal - converts a string constant to a value       */
 810 /*------------------------------------------------------------------*/
 811 value *
 812 strVal (const char *s)
 813 {
 814   value *val;
 815
 816   val = newValue ();            /* get a new one */
 817
 818   /* get a declarator */
 819   val->type = newLink (DECLARATOR);
 820   DCL_TYPE (val->type) = ARRAY;
 821   val->type->next = val->etype = newLink (SPECIFIER);
 822   SPEC_NOUN (val->etype) = V_CHAR;
 823   SPEC_SCLS (val->etype) = S_LITERAL;
 824
 825   SPEC_CVAL (val->etype).v_char = Safe_alloc (strlen (s) + 1);
 826   DCL_ELEM (val->type) = copyStr (SPEC_CVAL (val->etype).v_char, s);
 827
 828   return val;
 829 }
 830
 831
 832 /*------------------------------------------------------------------*/
 833 /* reverseValWithType - reverses value chain with type & etype      */
 834 /*------------------------------------------------------------------*/
 835 value *
 836 reverseValWithType (value * val)
 837 {
 838   sym_link *type;
 839   sym_link *etype;
 840
 841   if (!val)
 842     return NULL;
 843
 844   /* save the type * etype chains */
 845   type = val->type;
 846   etype = val->etype;
 847
 848   /* set the current one 2b null */
 849   val->type = val->etype = NULL;
 850   val = reverseVal (val);
 851
 852   /* restore type & etype */
 853   val->type = type;
 854   val->etype = etype;
 855
 856   return val;
 857 }
 858
 859 /*------------------------------------------------------------------*/
 860 /* reverseVal - reverses the values for a value  chain        */
 861 /*------------------------------------------------------------------*/
 862 value *
 863 reverseVal (value * val)
 864 {
 865   value *prev, *curr, *next;
 866
 867   if (!val)
 868     return NULL;
 869
 870   prev = val;
 871   curr = val->next;
 872
 873   while (curr)
 874     {
 875       next = curr->next;
 876       curr->next = prev;
 877       prev = curr;
 878       curr = next;
 879     }
 880   val->next = (void *) NULL;
 881   return prev;
 882 }
 883
 884 /*------------------------------------------------------------------*/
 885 /* copyValueChain - will copy a chain of values                     */
 886 /*------------------------------------------------------------------*/
 887 value *
 888 copyValueChain (value * src)
 889 {
 890   value *dest;
 891
 892   if (!src)
 893     return NULL;
 894
 895   dest = copyValue (src);
 896   dest->next = copyValueChain (src->next);
 897
 898   return dest;
 899 }
 900
 901 /*------------------------------------------------------------------*/
 902 /* copyValue - copies contents of a value to a fresh one            */
 903 /*------------------------------------------------------------------*/
 904 value *
 905 copyValue (value * src)
 906 {
 907   value *dest;
 908
 909   dest = newValue ();
 910   dest->sym = copySymbol (src->sym);
 911   strncpyz (dest->name, src->name, SDCC_NAME_MAX);
 912   dest->type = (src->type ? copyLinkChain (src->type) : NULL);
 913   dest->etype = (src->type ? getSpec (dest->type) : NULL);
 914
 915   return dest;
 916 }
 917
 918 /*------------------------------------------------------------------*/
 919 /* charVal - converts a character constant to a value       */
 920 /*------------------------------------------------------------------*/
 921 value *
 922 charVal (const char *s)
 923 {
 924   value *val;
 925
 926   val = newValue ();
 927
 928   val->type = val->etype = newLink (SPECIFIER);
 929   SPEC_NOUN (val->type) = V_CHAR;
 930   SPEC_USIGN(val->type) = 1;
 931   SPEC_SCLS (val->type) = S_LITERAL;
 932
 933   s++;                          /* get rid of quotation */
 934   /* if \ then special processing */
 935   if (*s == '\\')
 936     {
 937       s++;                      /* go beyond the backslash  */
 938       switch (*s)
 939         {
 940         case 'n':
 941           SPEC_CVAL (val->type).v_uint = '\n';
 942           break;
 943         case 't':
 944           SPEC_CVAL (val->type).v_uint = '\t';
 945           break;
 946         case 'v':
 947           SPEC_CVAL (val->type).v_uint = '\v';
 948           break;
 949         case 'b':
 950           SPEC_CVAL (val->type).v_uint = '\b';
 951           break;
 952         case 'r':
 953           SPEC_CVAL (val->type).v_uint = '\r';
 954           break;
 955         case 'f':
 956           SPEC_CVAL (val->type).v_uint = '\f';
 957           break;
 958         case 'a':
 959           SPEC_CVAL (val->type).v_uint = '\a';
 960           break;
 961         case '\\':
 962           SPEC_CVAL (val->type).v_uint = '\\';
 963           break;
 964         case '\?':
 965           SPEC_CVAL (val->type).v_uint = '\?';
 966           break;
 967         case '\'':
 968           SPEC_CVAL (val->type).v_uint = '\'';
 969           break;
 970         case '\"':
 971           SPEC_CVAL (val->type).v_uint = '\"';
 972           break;
 973
 974         case '0' :
 975         case '1' :
 976         case '2' :
 977         case '3' :
 978         case '4' :
 979         case '5' :
 980         case '6' :
 981         case '7' :
 982           SPEC_CVAL (val->type).v_uint = octalEscape(&s);
 983           break;
 984
 985         case 'x':
 986           SPEC_CVAL (val->type).v_uint = hexEscape(&s) ;
 987           break;
 988
 989         default:
 990           SPEC_CVAL (val->type).v_uint = (unsigned char)*s;
 991           break;
 992         }
 993     }
 994   else                          /* not a backslash */
 995     SPEC_CVAL (val->type).v_uint = (unsigned char)*s;
 996
 997   return val;
 998 }
 999
1000 /*------------------------------------------------------------------*/
1001 /* valFromType - creates a value from type given                    */
1002 /*------------------------------------------------------------------*/
1003 value *
1004 valFromType (sym_link * type)
1005 {
1006   value *val = newValue ();
1007   val->type = copyLinkChain (type);
1008   val->etype = getSpec (val->type);
1009   return val;
1010 }
1011
1012 /*------------------------------------------------------------------*/
1013 /* floatFromVal - value to double float conversion                  */
1014 /*------------------------------------------------------------------*/
1015 double
1016 floatFromVal (value * val)
1017 {
1018   if (!val)
1019     return 0;
1020
1021   if (val->etype && SPEC_SCLS (val->etype) != S_LITERAL)
1022     {
1023       werror (E_CONST_EXPECTED, val->name);
1024       return 0;
1025     }
1026
1027   /* if it is not a specifier then we can assume that */
1028   /* it will be an unsigned long                      */
1029   if (!IS_SPEC (val->type))
1030     return (double) SPEC_CVAL (val->etype).v_ulong;
1031
1032   if (SPEC_NOUN (val->etype) == V_FLOAT)
1033     return (double) SPEC_CVAL (val->etype).v_float;
1034
1035   if (SPEC_NOUN (val->etype) == V_FIXED16X16)
1036     return (double) doubleFromFixed16x16( SPEC_CVAL (val->etype).v_fixed16x16 );
1037
1038   if (SPEC_LONG (val->etype))
1039     {
1040       if (SPEC_USIGN (val->etype))
1041         return (double) SPEC_CVAL (val->etype).v_ulong;
1042       else
1043         return (double) SPEC_CVAL (val->etype).v_long;
1044     }
1045
1046   if (SPEC_NOUN (val->etype) == V_INT) {
1047     if (SPEC_USIGN (val->etype))
1048       return (double) SPEC_CVAL (val->etype).v_uint;
1049     else
1050       return (double) SPEC_CVAL (val->etype).v_int;
1051   }
1052
1053   if (SPEC_NOUN (val->etype) == V_CHAR) {
1054     if (SPEC_USIGN (val->etype))
1055       return (double) (unsigned char)SPEC_CVAL (val->etype).v_uint;
1056     else
1057       return (double) (signed char)SPEC_CVAL (val->etype).v_int;
1058   }
1059
1060   if (IS_BITVAR(val->etype)) {
1061     return (double) SPEC_CVAL (val->etype).v_uint;
1062   }
1063
1064   if (SPEC_NOUN (val->etype) == V_VOID) {
1065     return (double) SPEC_CVAL (val->etype).v_ulong;
1066   }
1067
1068   // we are lost !
1069   werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
1070           "floatFromVal: unknown value");
1071   return 0;
1072 }
1073
1074 /*-----------------------------------------------------------------*/
1075 /* doubleFromFixed16x16 - convert a fixed16x16 to double           */
1076 /*-----------------------------------------------------------------*/
1077 double doubleFromFixed16x16(TYPE_TARGET_ULONG value)
1078 {
1079 #if 0
1080   /* This version is incorrect negative values. */
1081   double tmp=0, exp=2;
1082
1083     tmp = (value & 0xffff0000) >> 16;
1084
1085     while(value) {
1086       value &= 0xffff;
1087       if(value & 0x8000)tmp += 1/exp;
1088       exp *= 2;
1089       value <<= 1;
1090     }
1091
1092   return (tmp);
1093 #else
1094   return ((double)(value * 1.0) / (double)(1UL << 16));
1095 #endif
1096 }
1097
1098 TYPE_TARGET_ULONG fixed16x16FromDouble(double value)
1099 {
1100 #if 0
1101   /* This version is incorrect negative values. */
1102   unsigned int tmp=0, pos=16;
1103   TYPE_TARGET_ULONG res;
1104
1105     tmp = floor( value );
1106     res = tmp << 16;
1107     value -= tmp;
1108
1109     tmp = 0;
1110     while(pos--) {
1111       value *= 2;
1112       if(value >= 1.0)tmp |= (1 << pos);
1113       value -= floor( value );
1114     }
1115
1116     res |= tmp;
1117
1118   return (res);
1119 #else
1120   return  (TYPE_TARGET_ULONG)(value * (double)(1UL << 16));
1121 #endif
1122 }
1123
1124 /*------------------------------------------------------------------*/
1125 /* valUnaryPM - does the unary +/- operation on a constant          */
1126 /*------------------------------------------------------------------*/
1127 value *
1128 valUnaryPM (value * val)
1129 {
1130   /* depending on type */
1131   if (SPEC_NOUN (val->etype) == V_FLOAT)
1132     SPEC_CVAL (val->etype).v_float = -1.0 * SPEC_CVAL (val->etype).v_float;
1133   else if (SPEC_NOUN (val->etype) == V_FIXED16X16)
1134     SPEC_CVAL (val->etype).v_fixed16x16 = -SPEC_CVAL (val->etype).v_fixed16x16;
1135   else
1136     {
1137       if (SPEC_LONG (val->etype))
1138         {
1139           if (SPEC_USIGN (val->etype))
1140             SPEC_CVAL (val->etype).v_ulong = 0-SPEC_CVAL (val->etype).v_ulong;
1141           else
1142             SPEC_CVAL (val->etype).v_long = -SPEC_CVAL (val->etype).v_long;
1143         }
1144       else
1145         {
1146           if (SPEC_USIGN (val->etype))
1147             SPEC_CVAL (val->etype).v_uint = 0-SPEC_CVAL (val->etype).v_uint;
1148           else
1149             SPEC_CVAL (val->etype).v_int = -SPEC_CVAL (val->etype).v_int;
1150
1151           if (SPEC_NOUN(val->etype) == V_CHAR)
1152             {
1153               /* promote to 'signed int', cheapestVal() might reduce it again */
1154               SPEC_USIGN(val->etype) = 0;
1155               SPEC_NOUN(val->etype) = V_INT;
1156             }
1157           return cheapestVal (val);
1158         }
1159     }
1160   return val;
1161 }
1162
1163 /*------------------------------------------------------------------*/
1164 /* valueComplement - complements a constant                         */
1165 /*------------------------------------------------------------------*/
1166 value *
1167 valComplement (value * val)
1168 {
1169   /* depending on type */
1170   if (SPEC_LONG (val->etype))
1171     {
1172       if (SPEC_USIGN (val->etype))
1173         SPEC_CVAL (val->etype).v_ulong = ~SPEC_CVAL (val->etype).v_ulong;
1174       else
1175         SPEC_CVAL (val->etype).v_long = ~SPEC_CVAL (val->etype).v_long;
1176     }
1177   else
1178     {
1179       if (SPEC_USIGN (val->etype))
1180         SPEC_CVAL (val->etype).v_uint = ~SPEC_CVAL (val->etype).v_uint;
1181       else
1182         SPEC_CVAL (val->etype).v_int = ~SPEC_CVAL (val->etype).v_int;
1183
1184       if (SPEC_NOUN(val->etype) == V_CHAR)
1185         {
1186           /* promote to 'signed int', cheapestVal() might reduce it again */
1187           SPEC_USIGN(val->etype) = 0;
1188           SPEC_NOUN(val->etype) = V_INT;
1189         }
1190       return cheapestVal (val);
1191     }
1192   return val;
1193 }
1194
1195 /*------------------------------------------------------------------*/
1196 /* valueNot - complements a constant                                */
1197 /*------------------------------------------------------------------*/
1198 value *
1199 valNot (value * val)
1200 {
1201   /* depending on type */
1202   if (SPEC_LONG (val->etype))
1203     {
1204       if (SPEC_USIGN (val->etype))
1205         SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_ulong;
1206       else
1207         SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_long;
1208     }
1209   else
1210     {
1211       if (SPEC_USIGN (val->etype))
1212         SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_uint;
1213       else
1214         SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_int;
1215
1216     }
1217   /* ANSI: result type is int, value is 0 or 1 */
1218   /* sdcc will hold this in an 'unsigned char' */
1219   SPEC_USIGN(val->etype) = 1;
1220   SPEC_LONG (val->etype) = 0;
1221   SPEC_NOUN(val->etype) = V_CHAR;
1222   return val;
1223 }
1224
1225 /*------------------------------------------------------------------*/
1226 /* valMult - multiply constants                                     */
1227 /*------------------------------------------------------------------*/
1228 value *
1229 valMult (value * lval, value * rval)
1230 {
1231   value *val;
1232
1233   /* create a new value */
1234   val = newValue ();
1235   val->type = val->etype = computeType (lval->etype,
1236                                         rval->etype,
1237                                         RESULT_TYPE_INT,
1238                                         '*');
1239   SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1240
1241   if (IS_FLOAT (val->type))
1242     SPEC_CVAL (val->type).v_float = floatFromVal (lval) * floatFromVal (rval);
1243   else
1244   if (IS_FIXED16X16 (val->type))
1245     SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble(floatFromVal (lval) * floatFromVal (rval));
1246       /* signed and unsigned mul are the same, as long as the precision of the
1247          result isn't bigger than the precision of the operands. */
1248   else if (SPEC_LONG (val->type))
1249     SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) *
1250                                     (TYPE_TARGET_ULONG) floatFromVal (rval);
1251   else if (SPEC_USIGN (val->type)) /* unsigned int */
1252     {
1253       TYPE_TARGET_ULONG ul = (TYPE_TARGET_UINT) floatFromVal (lval) *
1254                              (TYPE_TARGET_UINT) floatFromVal (rval);
1255
1256       SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ul;
1257       if (ul != (TYPE_TARGET_UINT) ul)
1258         werror (W_INT_OVL);
1259     }
1260   else /* signed int */
1261     {
1262       TYPE_TARGET_LONG l = (TYPE_TARGET_INT) floatFromVal (lval) *
1263                            (TYPE_TARGET_INT) floatFromVal (rval);
1264
1265       SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) l;
1266       if (l != (TYPE_TARGET_INT) l)
1267         werror (W_INT_OVL);
1268     }
1269   return cheapestVal (val);
1270 }
1271
1272 /*------------------------------------------------------------------*/
1273 /* valDiv  - Divide   constants                                     */
1274 /*------------------------------------------------------------------*/
1275 value *
1276 valDiv (value * lval, value * rval)
1277 {
1278   value *val;
1279
1280   if (floatFromVal (rval) == 0)
1281     {
1282       werror (E_DIVIDE_BY_ZERO);
1283       return rval;
1284     }
1285
1286   /* create a new value */
1287   val = newValue ();
1288   val->type = val->etype = computeType (lval->etype,
1289                                         rval->etype,
1290                                         RESULT_TYPE_INT,
1291                                         '/');
1292   SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1293
1294   if (IS_FLOAT (val->type))
1295     SPEC_CVAL (val->type).v_float = floatFromVal (lval) / floatFromVal (rval);
1296   else
1297   if (IS_FIXED16X16 (val->type))
1298     SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble( floatFromVal (lval) / floatFromVal (rval) );
1299   else if (SPEC_LONG (val->type))
1300     {
1301       if (SPEC_USIGN (val->type))
1302         SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) /
1303           (TYPE_TARGET_ULONG) floatFromVal (rval);
1304       else
1305         SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) /
1306           (TYPE_TARGET_LONG) floatFromVal (rval);
1307     }
1308   else
1309     {
1310       if (SPEC_USIGN (val->type))
1311         SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) /
1312           (TYPE_TARGET_UINT) floatFromVal (rval);
1313       else
1314         SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) /
1315           (TYPE_TARGET_INT) floatFromVal (rval);
1316     }
1317   return cheapestVal (val);
1318 }
1319
1320 /*------------------------------------------------------------------*/
1321 /* valMod  - Modulus  constants                                     */
1322 /*------------------------------------------------------------------*/
1323 value *
1324 valMod (value * lval, value * rval)
1325 {
1326   value *val;
1327
1328   /* create a new value */
1329   val = newValue();
1330   val->type = val->etype = computeType (lval->etype,
1331                                         rval->etype,
1332                                         RESULT_TYPE_INT,
1333                                         '%');
1334   SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1335
1336   if (SPEC_LONG (val->type))
1337     {
1338       if (SPEC_USIGN (val->type))
1339         SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) %
1340           (TYPE_TARGET_ULONG) floatFromVal (rval);
1341       else
1342         SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) %
1343           (TYPE_TARGET_LONG) floatFromVal (rval);
1344     }
1345   else
1346     {
1347       if (SPEC_USIGN (val->type))
1348         SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) %
1349           (TYPE_TARGET_UINT) floatFromVal (rval);
1350       else
1351         SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) %
1352           (TYPE_TARGET_INT) floatFromVal (rval);
1353     }
1354   return cheapestVal (val);
1355 }
1356
1357 /*------------------------------------------------------------------*/
1358 /* valPlus - Addition constants                                     */
1359 /*------------------------------------------------------------------*/
1360 value *
1361 valPlus (value * lval, value * rval)
1362 {
1363   value *val;
1364
1365   /* create a new value */
1366   val = newValue();
1367   val->type = val->etype = computeType (lval->etype,
1368                                         rval->etype,
1369                                         RESULT_TYPE_INT,
1370                                         '+');
1371   SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1372
1373   if (IS_FLOAT (val->type))
1374     SPEC_CVAL (val->type).v_float = floatFromVal (lval) + floatFromVal (rval);
1375   else
1376   if (IS_FIXED16X16 (val->type))
1377     SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble( floatFromVal (lval) + floatFromVal (rval) );
1378   else  if (SPEC_LONG (val->type))
1379     {
1380       if (SPEC_USIGN (val->type))
1381         SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) +
1382          (TYPE_TARGET_ULONG) floatFromVal (rval);
1383       else
1384         SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) +
1385           (TYPE_TARGET_LONG) floatFromVal (rval);
1386     }
1387   else
1388     {
1389       if (SPEC_USIGN (val->type))
1390         SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) +
1391           (TYPE_TARGET_UINT) floatFromVal (rval);
1392       else
1393         SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) +
1394           (TYPE_TARGET_INT) floatFromVal (rval);
1395     }
1396   return cheapestVal (val);
1397 }
1398
1399 /*------------------------------------------------------------------*/
1400 /* valMinus - Addition constants                                    */
1401 /*------------------------------------------------------------------*/
1402 value *
1403 valMinus (value * lval, value * rval)
1404 {
1405   value *val;
1406
1407   /* create a new value */
1408   val = newValue();
1409   val->type = val->etype = computeType (lval->etype,
1410                                         rval->etype,
1411                                         RESULT_TYPE_INT,
1412                                         '-');
1413   SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1414
1415   if (IS_FLOAT (val->type))
1416     SPEC_CVAL (val->type).v_float = floatFromVal (lval) - floatFromVal (rval);
1417   else
1418   if (IS_FIXED16X16 (val->type))
1419     SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble( floatFromVal (lval) - floatFromVal (rval) );
1420   else  if (SPEC_LONG (val->type))
1421     {
1422       if (SPEC_USIGN (val->type))
1423         SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) -
1424           (TYPE_TARGET_ULONG) floatFromVal (rval);
1425       else
1426         SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) -
1427           (TYPE_TARGET_LONG) floatFromVal (rval);
1428     }
1429   else
1430    {
1431      if (SPEC_USIGN (val->type))
1432        SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) -
1433          (TYPE_TARGET_UINT) floatFromVal (rval);
1434      else
1435        SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) -
1436          (TYPE_TARGET_INT) floatFromVal (rval);
1437     }
1438   return cheapestVal (val);
1439 }
1440
1441 /*------------------------------------------------------------------*/
1442 /* valShift - Shift left or right                                   */
1443 /*------------------------------------------------------------------*/
1444 value *
1445 valShift (value * lval, value * rval, int lr)
1446 {
1447   value *val;
1448
1449   /* create a new value */
1450   val = newValue();
1451   val->type = val->etype = computeType (lval->etype,
1452                                         NULL,
1453                                         RESULT_TYPE_INT,
1454                                         'S');
1455   SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1456
1457   if (getSize (val->type) * 8 <= (TYPE_TARGET_ULONG) floatFromVal (rval) &&
1458        /* left shift */
1459       (lr ||
1460         /* right shift and unsigned */
1461        (!lr && SPEC_USIGN (rval->type))))
1462     {
1463       werror (W_SHIFT_CHANGED, (lr ? "left" : "right"));
1464     }
1465
1466   if (SPEC_LONG (val->type))
1467     {
1468       if (SPEC_USIGN (val->type))
1469         {
1470           SPEC_CVAL (val->type).v_ulong = lr ?
1471             (TYPE_TARGET_ULONG) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \
1472             (TYPE_TARGET_ULONG) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval);
1473         }
1474       else
1475         {
1476           SPEC_CVAL (val->type).v_long = lr ?
1477             (TYPE_TARGET_LONG) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \
1478             (TYPE_TARGET_LONG) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval);
1479         }
1480     }
1481   else
1482     {
1483       if (SPEC_USIGN (val->type))
1484         {
1485           SPEC_CVAL (val->type).v_uint = lr ?
1486             (TYPE_TARGET_UINT) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \
1487             (TYPE_TARGET_UINT) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval);
1488         }
1489       else
1490         {
1491           SPEC_CVAL (val->type).v_int = lr ?
1492             (TYPE_TARGET_INT) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \
1493             (TYPE_TARGET_INT) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval);
1494         }
1495     }
1496   return cheapestVal (val);
1497 }
1498
1499 /*------------------------------------------------------------------*/
1500 /* valCompare- Compares two literal                                 */
1501 /*------------------------------------------------------------------*/
1502 value *
1503 valCompare (value * lval, value * rval, int ctype)
1504 {
1505   value *val;
1506
1507   /* create a new value */
1508   val = newValue ();
1509   val->type = val->etype = newCharLink ();
1510   val->type->class = SPECIFIER;
1511   SPEC_NOUN (val->type) = V_CHAR;       /* type is char */
1512   SPEC_USIGN (val->type) = 1;
1513   SPEC_SCLS (val->type) = S_LITERAL;    /* will remain literal */
1514
1515   switch (ctype)
1516     {
1517     case '<':
1518       SPEC_CVAL (val->type).v_int = floatFromVal (lval) < floatFromVal (rval);
1519       break;
1520
1521     case '>':
1522       SPEC_CVAL (val->type).v_int = floatFromVal (lval) > floatFromVal (rval);
1523       break;
1524
1525     case LE_OP:
1526       SPEC_CVAL (val->type).v_int = floatFromVal (lval) <= floatFromVal (rval);
1527       break;
1528
1529     case GE_OP:
1530       SPEC_CVAL (val->type).v_int = floatFromVal (lval) >= floatFromVal (rval);
1531       break;
1532
1533     case EQ_OP:
1534       if (SPEC_NOUN(lval->type) == V_FLOAT ||
1535           SPEC_NOUN(rval->type) == V_FLOAT)
1536         {
1537           SPEC_CVAL (val->type).v_int = floatFromVal (lval) == floatFromVal (rval);
1538         }
1539       else
1540       if (SPEC_NOUN(lval->type) == V_FIXED16X16 ||
1541           SPEC_NOUN(rval->type) == V_FIXED16X16)
1542         {
1543           SPEC_CVAL (val->type).v_int = floatFromVal (lval) == floatFromVal (rval);
1544         }
1545       else
1546         {
1547           /* integrals: ignore signedness */
1548           TYPE_TARGET_ULONG l, r;
1549
1550           l = (TYPE_TARGET_ULONG) floatFromVal (lval);
1551           r = (TYPE_TARGET_ULONG) floatFromVal (rval);
1552           /* In order to correctly compare 'signed int' and 'unsigned int' it's
1553              neccessary to strip them to 16 bit.
1554              Literals are reduced to their cheapest type, therefore left and
1555              right might have different types. It's neccessary to find a
1556              common type: int (used for char too) or long */
1557           if (!IS_LONG (lval->etype) &&
1558               !IS_LONG (rval->etype))
1559             {
1560               r = (TYPE_TARGET_UINT) r;
1561               l = (TYPE_TARGET_UINT) l;
1562             }
1563           SPEC_CVAL (val->type).v_int = l == r;
1564         }
1565       break;
1566     case NE_OP:
1567       if (SPEC_NOUN(lval->type) == V_FLOAT ||
1568           SPEC_NOUN(rval->type) == V_FLOAT)
1569         {
1570           SPEC_CVAL (val->type).v_int = floatFromVal (lval) != floatFromVal (rval);
1571         }
1572       else
1573       if (SPEC_NOUN(lval->type) == V_FIXED16X16 ||
1574           SPEC_NOUN(rval->type) == V_FIXED16X16)
1575         {
1576           SPEC_CVAL (val->type).v_int = floatFromVal (lval) != floatFromVal (rval);
1577         }
1578       else
1579         {
1580           /* integrals: ignore signedness */
1581           TYPE_TARGET_ULONG l, r;
1582
1583           l = (TYPE_TARGET_ULONG) floatFromVal (lval);
1584           r = (TYPE_TARGET_ULONG) floatFromVal (rval);
1585           /* In order to correctly compare 'signed int' and 'unsigned int' it's
1586              neccessary to strip them to 16 bit.
1587              Literals are reduced to their cheapest type, therefore left and
1588              right might have different types. It's neccessary to find a
1589              common type: int (used for char too) or long */
1590           if (!IS_LONG (lval->etype) &&
1591               !IS_LONG (rval->etype))
1592             {
1593               r = (TYPE_TARGET_UINT) r;
1594               l = (TYPE_TARGET_UINT) l;
1595             }
1596           SPEC_CVAL (val->type).v_int = l != r;
1597         }
1598       break;
1599
1600     }
1601
1602   return val;
1603 }
1604
1605 /*------------------------------------------------------------------*/
1606 /* valBitwise - Bitwise operation                                   */
1607 /*------------------------------------------------------------------*/
1608 value *
1609 valBitwise (value * lval, value * rval, int op)
1610 {
1611   value *val;
1612
1613   /* create a new value */
1614   val = newValue ();
1615   val->type = computeType (lval->etype, rval->etype, RESULT_TYPE_CHAR, op);
1616   val->etype = getSpec (val->type);
1617   SPEC_SCLS (val->etype) = S_LITERAL;
1618
1619   switch (op)
1620     {
1621     case '&':
1622       if (SPEC_LONG (val->type))
1623         {
1624           if (SPEC_USIGN (val->type))
1625             SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) &
1626               (TYPE_TARGET_ULONG) floatFromVal (rval);
1627           else
1628             SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) &
1629               (TYPE_TARGET_LONG) floatFromVal (rval);
1630         }
1631       else
1632         {
1633           if (SPEC_USIGN (val->type))
1634             SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) &
1635               (TYPE_TARGET_UINT) floatFromVal (rval);
1636           else
1637             SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) &
1638               (TYPE_TARGET_INT) floatFromVal (rval);
1639         }
1640       break;
1641
1642     case '|':
1643       if (SPEC_LONG (val->type))
1644         {
1645           if (SPEC_USIGN (val->type))
1646             SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) |
1647               (TYPE_TARGET_ULONG) floatFromVal (rval);
1648           else
1649             SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) |
1650               (TYPE_TARGET_LONG) floatFromVal (rval);
1651         }
1652       else
1653         {
1654           if (SPEC_USIGN (val->type))
1655             SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) |
1656               (TYPE_TARGET_UINT) floatFromVal (rval);
1657           else
1658             SPEC_CVAL (val->type).v_int =
1659               (TYPE_TARGET_INT) floatFromVal (lval) | (TYPE_TARGET_INT) floatFromVal (rval);
1660         }
1661
1662       break;
1663
1664     case '^':
1665       if (SPEC_LONG (val->type))
1666         {
1667           if (SPEC_USIGN (val->type))
1668             SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) ^
1669               (TYPE_TARGET_ULONG) floatFromVal (rval);
1670           else
1671             SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) ^
1672               (TYPE_TARGET_LONG) floatFromVal (rval);
1673         }
1674       else
1675         {
1676           if (SPEC_USIGN (val->type))
1677             SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) ^
1678               (TYPE_TARGET_UINT) floatFromVal (rval);
1679           else
1680             SPEC_CVAL (val->type).v_int =
1681               (TYPE_TARGET_INT) floatFromVal (lval) ^ (TYPE_TARGET_INT) floatFromVal (rval);
1682         }
1683       break;
1684     }
1685
1686   return cheapestVal(val);
1687 }
1688
1689 /*------------------------------------------------------------------*/
1690 /* valAndOr   - Generates code for and / or operation               */
1691 /*------------------------------------------------------------------*/
1692 value *
1693 valLogicAndOr (value * lval, value * rval, int op)
1694 {
1695   value *val;
1696
1697   /* create a new value */
1698   val = newValue ();
1699   val->type = val->etype = newCharLink ();
1700   val->type->class = SPECIFIER;
1701   SPEC_SCLS (val->type) = S_LITERAL;    /* will remain literal */
1702   SPEC_USIGN (val->type) = 1;
1703
1704   switch (op)
1705     {
1706     case AND_OP:
1707       SPEC_CVAL (val->type).v_int = floatFromVal (lval) && floatFromVal (rval);
1708       break;
1709
1710     case OR_OP:
1711       SPEC_CVAL (val->type).v_int = floatFromVal (lval) || floatFromVal (rval);
1712       break;
1713     }
1714
1715
1716   return val;
1717 }
1718
1719 /*------------------------------------------------------------------*/
1720 /* valCastLiteral - casts a literal value to another type           */
1721 /*------------------------------------------------------------------*/
1722 value *
1723 valCastLiteral (sym_link * dtype, double fval)
1724 {
1725   value *val;
1726   TYPE_TARGET_ULONG l = (TYPE_TARGET_ULONG)fval;
1727
1728   if (!dtype)
1729     return NULL;
1730
1731   val = newValue ();
1732   if (dtype)
1733     val->etype = getSpec (val->type = copyLinkChain (dtype));
1734   else
1735     {
1736       val->etype = val->type = newLink (SPECIFIER);
1737       SPEC_NOUN (val->etype) = V_VOID;
1738     }
1739   SPEC_SCLS (val->etype) = S_LITERAL;
1740
1741   /* if it is not a specifier then we can assume that */
1742   /* it will be an unsigned long                      */
1743   if (!IS_SPEC (val->type)) {
1744       SPEC_CVAL (val->etype).v_ulong = l;
1745       return val;
1746   }
1747
1748   if (SPEC_NOUN (val->etype) == V_FLOAT)
1749       SPEC_CVAL (val->etype).v_float = fval;
1750   else if (SPEC_NOUN (val->etype) == V_FIXED16X16)
1751       SPEC_CVAL (val->etype).v_fixed16x16 = fixed16x16FromDouble( fval );
1752   else if (SPEC_NOUN (val->etype) == V_BIT ||
1753            SPEC_NOUN (val->etype) == V_SBIT)
1754     SPEC_CVAL (val->etype).v_uint = l ? 1 : 0;
1755   else if (SPEC_NOUN (val->etype) == V_BITFIELD)
1756     SPEC_CVAL (val->etype).v_uint = l &
1757                                     (0xffffu >> (16 - SPEC_BLEN (val->etype)));
1758   else if (SPEC_NOUN (val->etype) == V_CHAR) {
1759       if (SPEC_USIGN (val->etype))
1760           SPEC_CVAL (val->etype).v_uint= (TYPE_UBYTE) l;
1761       else
1762           SPEC_CVAL (val->etype).v_int = (TYPE_BYTE) l;
1763   } else {
1764       if (SPEC_LONG (val->etype)) {
1765           if (SPEC_USIGN (val->etype))
1766               SPEC_CVAL (val->etype).v_ulong = (TYPE_TARGET_ULONG) l;
1767           else
1768               SPEC_CVAL (val->etype).v_long = (TYPE_TARGET_LONG) l;
1769       } else {
1770           if (SPEC_USIGN (val->etype))
1771               SPEC_CVAL (val->etype).v_uint = (TYPE_TARGET_UINT)l;
1772           else
1773               SPEC_CVAL (val->etype).v_int = (TYPE_TARGET_INT)l;
1774       }
1775   }
1776   return val;
1777 }
1778
1779 /*------------------------------------------------------------------*/
1780 /* getNelements - determines # of elements from init list           */
1781 /*------------------------------------------------------------------*/
1782 int
1783 getNelements (sym_link * type, initList * ilist)
1784 {
1785   int i;
1786
1787   if (!ilist)
1788     return 0;
1789
1790   if (ilist->type == INIT_DEEP)
1791     ilist = ilist->init.deep;
1792
1793   /* if type is a character array and there is only one
1794      (string) initialiser then get the length of the string */
1795   if (IS_ARRAY (type) && IS_CHAR (type->next) && !ilist->next)
1796     {
1797       ast *iast = ilist->init.node;
1798       value *v = (iast->type == EX_VALUE ? iast->opval.val : NULL);
1799       if (!v)
1800         {
1801           werror (E_CONST_EXPECTED);
1802           return 0;
1803         }
1804
1805       if (IS_ARRAY (v->type) && IS_CHAR (v->etype))
1806         // yep, it's a string
1807         {
1808           return DCL_ELEM (v->type);
1809         }
1810     }
1811
1812   i = 0;
1813   while (ilist)
1814     {
1815       i++;
1816       ilist = ilist->next;
1817     }
1818   return i;
1819 }
1820
1821 /*-----------------------------------------------------------------*/
1822 /* valForArray - returns a value with name of array index          */
1823 /*-----------------------------------------------------------------*/
1824 value *
1825 valForArray (ast * arrExpr)
1826 {
1827   value *val, *lval = NULL;
1828   char buffer[128];
1829   int size = getSize (arrExpr->left->ftype->next);
1830   /* if the right or left is an array
1831      resolve it first */
1832   if (IS_AST_OP (arrExpr->left))
1833     {
1834       if (arrExpr->left->opval.op == '[')
1835         lval = valForArray (arrExpr->left);
1836       else if (arrExpr->left->opval.op == '.')
1837         lval = valForStructElem (arrExpr->left->left,
1838                                  arrExpr->left->right);
1839       else if (arrExpr->left->opval.op == PTR_OP &&
1840                IS_ADDRESS_OF_OP (arrExpr->left->left))
1841         lval = valForStructElem (arrExpr->left->left->left,
1842                                  arrExpr->left->right);
1843       else
1844         return NULL;
1845
1846     }
1847   else if (!IS_AST_SYM_VALUE (arrExpr->left))
1848     return NULL;
1849
1850   if (!IS_AST_LIT_VALUE (arrExpr->right))
1851     return NULL;
1852
1853   val = newValue ();
1854   if (!lval)
1855     {
1856         SNPRINTF (buffer, sizeof(buffer), "%s", AST_SYMBOL (arrExpr->left)->rname);
1857     }
1858   else
1859     {
1860         SNPRINTF (buffer, sizeof(buffer), "%s", lval->name);
1861     }
1862
1863   SNPRINTF (val->name, sizeof(val->name), "(%s + %d)", buffer,
1864            (int) AST_LIT_VALUE (arrExpr->right) * size);
1865
1866   val->type = newLink (DECLARATOR);
1867   if (SPEC_SCLS (arrExpr->left->etype) == S_CODE)
1868     DCL_TYPE (val->type) = CPOINTER;
1869   else if (SPEC_SCLS (arrExpr->left->etype) == S_XDATA)
1870     DCL_TYPE (val->type) = FPOINTER;
1871   else if (SPEC_SCLS (arrExpr->left->etype) == S_XSTACK)
1872     DCL_TYPE (val->type) = PPOINTER;
1873   else if (SPEC_SCLS (arrExpr->left->etype) == S_IDATA)
1874     DCL_TYPE (val->type) = IPOINTER;
1875   else if (SPEC_SCLS (arrExpr->left->etype) == S_EEPROM)
1876     DCL_TYPE (val->type) = EEPPOINTER;
1877   else
1878     DCL_TYPE (val->type) = POINTER;
1879   val->type->next = arrExpr->left->ftype->next;
1880   val->etype = getSpec (val->type);
1881   return val;
1882 }
1883
1884 /*-----------------------------------------------------------------*/
1885 /* valForStructElem - returns value with name of struct element    */
1886 /*-----------------------------------------------------------------*/
1887 value *
1888 valForStructElem (ast * structT, ast * elemT)
1889 {
1890   value *val, *lval = NULL;
1891   char buffer[128];
1892   symbol *sym;
1893
1894   /* left could be furthur derefed */
1895   if (IS_AST_OP (structT))
1896     {
1897       if (structT->opval.op == '[')
1898         lval = valForArray (structT);
1899       else if (structT->opval.op == '.')
1900         lval = valForStructElem (structT->left, structT->right);
1901       else if (structT->opval.op == PTR_OP &&
1902                IS_ADDRESS_OF_OP (structT->left))
1903         lval = valForStructElem (structT->left->left,
1904                                  structT->right);
1905       else
1906         return NULL;
1907     }
1908
1909   if (!IS_AST_SYM_VALUE (elemT))
1910     return NULL;
1911
1912   if (!IS_STRUCT (structT->etype))
1913     return NULL;
1914
1915   if ((sym = getStructElement (SPEC_STRUCT (structT->etype),
1916                                AST_SYMBOL (elemT))) == NULL)
1917     {
1918       return NULL;
1919     }
1920
1921   val = newValue ();
1922   if (!lval)
1923     {
1924         SNPRINTF(buffer, sizeof(buffer), "%s", AST_SYMBOL (structT)->rname);
1925     }
1926   else
1927     {
1928         SNPRINTF (buffer, sizeof(buffer), "%s", lval->name);
1929     }
1930
1931   SNPRINTF (val->name, sizeof(val->name), "(%s + %d)", buffer,
1932            (int) sym->offset);
1933
1934   val->type = newLink (DECLARATOR);
1935   if (SPEC_SCLS (structT->etype) == S_CODE)
1936     DCL_TYPE (val->type) = CPOINTER;
1937   else if (SPEC_SCLS (structT->etype) == S_XDATA)
1938     DCL_TYPE (val->type) = FPOINTER;
1939   else if (SPEC_SCLS (structT->etype) == S_XSTACK)
1940     DCL_TYPE (val->type) = PPOINTER;
1941   else if (SPEC_SCLS (structT->etype) == S_IDATA)
1942     DCL_TYPE (val->type) = IPOINTER;
1943   else if (SPEC_SCLS (structT->etype) == S_EEPROM)
1944     DCL_TYPE (val->type) = EEPPOINTER;
1945   else
1946     DCL_TYPE (val->type) = POINTER;
1947   val->type->next = sym->type;
1948   val->etype = getSpec (val->type);
1949   return val;
1950 }
1951
1952 /*-----------------------------------------------------------------*/
1953 /* valForCastAggr - will return value for a cast of an aggregate   */
1954 /*                  plus minus a constant                          */
1955 /*-----------------------------------------------------------------*/
1956 value *
1957 valForCastAggr (ast * aexpr, sym_link * type, ast * cnst, int op)
1958 {
1959   value *val;
1960
1961   if (!IS_AST_SYM_VALUE (aexpr))
1962     return NULL;
1963   if (!IS_AST_LIT_VALUE (cnst))
1964     return NULL;
1965
1966   val = newValue ();
1967
1968   SNPRINTF (val->name, sizeof(val->name), "(%s %c %d)",
1969            AST_SYMBOL (aexpr)->rname, op,
1970            getSize (type->next) * (int) AST_LIT_VALUE (cnst));
1971
1972   val->type = type;
1973   val->etype = getSpec (val->type);
1974   return val;
1975 }
1976
1977 /*-----------------------------------------------------------------*/
1978 /* valForCastAggr - will return value for a cast of an aggregate   */
1979 /*                  with no constant                               */
1980 /*-----------------------------------------------------------------*/
1981 value *
1982 valForCastArr (ast * aexpr, sym_link * type)
1983 {
1984   value *val;
1985
1986   if (!IS_AST_SYM_VALUE (aexpr))
1987     return NULL;
1988
1989   val = newValue ();
1990
1991   SNPRINTF (val->name, sizeof(val->name), "(%s)",
1992            AST_SYMBOL (aexpr)->rname);
1993
1994   val->type = type;
1995   val->etype = getSpec (val->type);
1996   return val;
1997 }