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 = mylineno;
  61   nilist->filename = currFname;
  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_UDWORD 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_DWORD minVal = 0xffffffff << (varBits - 1);
 413               TYPE_DWORD 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_DWORD  minVal = 0xffffffff  << (varBits - 1);
 426           TYPE_UDWORD 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_UDWORD minValP, maxValP, minValM, maxValM;
 453       TYPE_UDWORD 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_UDWORD) 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_DWORD 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_DWORD) lit) - lit) == 0)
 631     {
 632       SNPRINTF (buffer, sizeof(buffer), "%d", (TYPE_DWORD) 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 (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_UDWORD)dval;
 787         }
 788       else
 789         {
 790           SPEC_CVAL (val->type).v_long = (TYPE_DWORD)dval;
 791         }
 792     }
 793   else
 794     {
 795       if (SPEC_USIGN (val->type))
 796         {
 797           SPEC_CVAL (val->type).v_uint = (TYPE_UWORD)dval;
 798         }
 799       else
 800         {
 801           SPEC_CVAL (val->type).v_int = (TYPE_WORD)dval;
 802         }
 803     }
 804
 805   return val;
 806 }
 807
 808 /*! /fn char hexEscape(char **src)
 809
 810     /param src Pointer to 'x' from start of hex character value
 811 */
 812
 813 unsigned char hexEscape(char **src)
 814 {
 815   char *s ;
 816   unsigned long value ;
 817
 818   (*src)++ ;    /* Skip over the 'x' */
 819   s = *src ;    /* Save for error detection */
 820
 821   value = strtol (*src, src, 16);
 822
 823   if (s == *src) {
 824       // no valid hex found
 825       werror(E_INVALID_HEX);
 826   } else {
 827     if (value > 255) {
 828       werror(W_ESC_SEQ_OOR_FOR_CHAR);
 829     }
 830   }
 831   return (char) value;
 832 }
 833
 834 /*------------------------------------------------------------------*/
 835 /* octalEscape - process an octal constant of max three digits      */
 836 /* return the octal value, throw a warning for illegal octal        */
 837 /* adjust src to point at the last proccesed char                   */
 838 /*------------------------------------------------------------------*/
 839
 840 unsigned char octalEscape (char **str) {
 841   int digits;
 842   unsigned value=0;
 843
 844   for (digits=0; digits<3; digits++) {
 845     if (**str>='0' && **str<='7') {
 846       value = value*8 + (**str-'0');
 847       (*str)++;
 848     } else {
 849       break;
 850     }
 851   }
 852   if (digits) {
 853     if (value > 255 /* || (**str>='0' && **str<='7') */ ) {
 854       werror (W_ESC_SEQ_OOR_FOR_CHAR);
 855     }
 856   }
 857   return value;
 858 }
 859
 860 /*!
 861   /fn int copyStr (char *dest, char *src)
 862
 863   Copies a source string to a dest buffer interpreting escape sequences
 864   and special characters
 865
 866   /param dest Buffer to receive the resultant string
 867   /param src  Buffer containing the source string with escape sequecnes
 868   /return Number of characters in output string
 869
 870 */
 871
 872 int
 873 copyStr (char *dest, char *src)
 874
 875 {
 876   char *OriginalDest = dest ;
 877
 878   while (*src)
 879     {
 880       if (*src == '\"')
 881         src++;
 882       else if (*src == '\\')
 883         {
 884           src++;
 885           switch (*src)
 886             {
 887             case 'n':
 888               *dest++ = '\n';
 889               break;
 890             case 't':
 891               *dest++ = '\t';
 892               break;
 893             case 'v':
 894               *dest++ = '\v';
 895               break;
 896             case 'b':
 897               *dest++ = '\b';
 898               break;
 899             case 'r':
 900               *dest++ = '\r';
 901               break;
 902             case 'f':
 903               *dest++ = '\f';
 904               break;
 905             case 'a':
 906               *dest++ = '\a';
 907               break;
 908
 909             case '0':
 910             case '1':
 911             case '2':
 912             case '3':
 913             case '4':
 914             case '5':
 915             case '6':
 916             case '7':
 917               *dest++ = octalEscape(&src);
 918               src-- ;
 919               break;
 920
 921             case 'x':
 922               *dest++ = hexEscape(&src) ;
 923               src-- ;
 924               break ;
 925
 926             case '\\':
 927               *dest++ = '\\';
 928               break;
 929             case '\?':
 930               *dest++ = '\?';
 931               break;
 932             case '\'':
 933               *dest++ = '\'';
 934               break;
 935             case '\"':
 936               *dest++ = '\"';
 937               break;
 938             default:
 939               *dest++ = *src;
 940             }
 941           src++;
 942         }
 943       else
 944         *dest++ = *src++;
 945     }
 946
 947   *dest++ = '\0';
 948
 949   return dest - OriginalDest ;
 950 }
 951
 952 /*------------------------------------------------------------------*/
 953 /* strVal - converts a string constant to a value       */
 954 /*------------------------------------------------------------------*/
 955 value *
 956 strVal (char *s)
 957 {
 958   value *val;
 959
 960   val = newValue ();            /* get a new one */
 961
 962   /* get a declarator */
 963   val->type = newLink (DECLARATOR);
 964   DCL_TYPE (val->type) = ARRAY;
 965   val->type->next = val->etype = newLink (SPECIFIER);
 966   SPEC_NOUN (val->etype) = V_CHAR;
 967   SPEC_SCLS (val->etype) = S_LITERAL;
 968
 969   SPEC_CVAL (val->etype).v_char = Safe_alloc (strlen (s) + 1);
 970   DCL_ELEM (val->type) = copyStr (SPEC_CVAL (val->etype).v_char, s);
 971
 972   return val;
 973 }
 974
 975
 976 /*------------------------------------------------------------------*/
 977 /* reverseValWithType - reverses value chain with type & etype      */
 978 /*------------------------------------------------------------------*/
 979 value *
 980 reverseValWithType (value * val)
 981 {
 982   sym_link *type;
 983   sym_link *etype;
 984
 985   if (!val)
 986     return NULL;
 987
 988   /* save the type * etype chains */
 989   type = val->type;
 990   etype = val->etype;
 991
 992   /* set the current one 2b null */
 993   val->type = val->etype = NULL;
 994   val = reverseVal (val);
 995
 996   /* restore type & etype */
 997   val->type = type;
 998   val->etype = etype;
 999
1000   return val;
1001 }
1002
1003 /*------------------------------------------------------------------*/
1004 /* reverseVal - reverses the values for a value  chain        */
1005 /*------------------------------------------------------------------*/
1006 value *
1007 reverseVal (value * val)
1008 {
1009   value *prev, *curr, *next;
1010
1011   if (!val)
1012     return NULL;
1013
1014   prev = val;
1015   curr = val->next;
1016
1017   while (curr)
1018     {
1019       next = curr->next;
1020       curr->next = prev;
1021       prev = curr;
1022       curr = next;
1023     }
1024   val->next = (void *) NULL;
1025   return prev;
1026 }
1027
1028 /*------------------------------------------------------------------*/
1029 /* copyValueChain - will copy a chain of values                     */
1030 /*------------------------------------------------------------------*/
1031 value *
1032 copyValueChain (value * src)
1033 {
1034   value *dest;
1035
1036   if (!src)
1037     return NULL;
1038
1039   dest = copyValue (src);
1040   dest->next = copyValueChain (src->next);
1041
1042   return dest;
1043 }
1044
1045 /*------------------------------------------------------------------*/
1046 /* copyValue - copies contents of a value to a fresh one            */
1047 /*------------------------------------------------------------------*/
1048 value *
1049 copyValue (value * src)
1050 {
1051   value *dest;
1052
1053   dest = newValue ();
1054   dest->sym = copySymbol (src->sym);
1055   strncpyz (dest->name, src->name, SDCC_NAME_MAX);
1056   dest->type = (src->type ? copyLinkChain (src->type) : NULL);
1057   dest->etype = (src->type ? getSpec (dest->type) : NULL);
1058
1059   return dest;
1060 }
1061
1062 /*------------------------------------------------------------------*/
1063 /* charVal - converts a character constant to a value       */
1064 /*------------------------------------------------------------------*/
1065 value *
1066 charVal (char *s)
1067 {
1068   value *val;
1069
1070   val = newValue ();
1071
1072   val->type = val->etype = newLink (SPECIFIER);
1073   SPEC_NOUN (val->type) = V_CHAR;
1074   SPEC_USIGN(val->type) = 1;
1075   SPEC_SCLS (val->type) = S_LITERAL;
1076
1077   s++;                          /* get rid of quotation */
1078   /* if \ then special processing */
1079   if (*s == '\\')
1080     {
1081       s++;                      /* go beyond the backslash  */
1082       switch (*s)
1083         {
1084         case 'n':
1085           SPEC_CVAL (val->type).v_uint = '\n';
1086           break;
1087         case 't':
1088           SPEC_CVAL (val->type).v_uint = '\t';
1089           break;
1090         case 'v':
1091           SPEC_CVAL (val->type).v_uint = '\v';
1092           break;
1093         case 'b':
1094           SPEC_CVAL (val->type).v_uint = '\b';
1095           break;
1096         case 'r':
1097           SPEC_CVAL (val->type).v_uint = '\r';
1098           break;
1099         case 'f':
1100           SPEC_CVAL (val->type).v_uint = '\f';
1101           break;
1102         case 'a':
1103           SPEC_CVAL (val->type).v_uint = '\a';
1104           break;
1105         case '\\':
1106           SPEC_CVAL (val->type).v_uint = '\\';
1107           break;
1108         case '\?':
1109           SPEC_CVAL (val->type).v_uint = '\?';
1110           break;
1111         case '\'':
1112           SPEC_CVAL (val->type).v_uint = '\'';
1113           break;
1114         case '\"':
1115           SPEC_CVAL (val->type).v_uint = '\"';
1116           break;
1117
1118         case '0' :
1119         case '1' :
1120         case '2' :
1121         case '3' :
1122         case '4' :
1123         case '5' :
1124         case '6' :
1125         case '7' :
1126           SPEC_CVAL (val->type).v_uint = octalEscape(&s);
1127           break;
1128
1129         case 'x':
1130           SPEC_CVAL (val->type).v_uint = hexEscape(&s) ;
1131           break;
1132
1133         default:
1134           SPEC_CVAL (val->type).v_uint = (unsigned char)*s;
1135           break;
1136         }
1137     }
1138   else                          /* not a backslash */
1139     SPEC_CVAL (val->type).v_uint = (unsigned char)*s;
1140
1141   return val;
1142 }
1143
1144 /*------------------------------------------------------------------*/
1145 /* valFromType - creates a value from type given                    */
1146 /*------------------------------------------------------------------*/
1147 value *
1148 valFromType (sym_link * type)
1149 {
1150   value *val = newValue ();
1151   val->type = copyLinkChain (type);
1152   val->etype = getSpec (val->type);
1153   return val;
1154 }
1155
1156 /*------------------------------------------------------------------*/
1157 /* floatFromVal - value to double float conversion                  */
1158 /*------------------------------------------------------------------*/
1159 double
1160 floatFromVal (value * val)
1161 {
1162   if (!val)
1163     return 0;
1164
1165   if (val->etype && SPEC_SCLS (val->etype) != S_LITERAL)
1166     {
1167       werror (E_CONST_EXPECTED, val->name);
1168       return 0;
1169     }
1170
1171   /* if it is not a specifier then we can assume that */
1172   /* it will be an unsigned long                      */
1173   if (!IS_SPEC (val->type))
1174     return (double) SPEC_CVAL (val->etype).v_ulong;
1175
1176   if (SPEC_NOUN (val->etype) == V_FLOAT)
1177     return (double) SPEC_CVAL (val->etype).v_float;
1178
1179   if (SPEC_NOUN (val->etype) == V_FIXED16X16)
1180     return (double) doubleFromFixed16x16( SPEC_CVAL (val->etype).v_fixed16x16 );
1181
1182   if (SPEC_LONG (val->etype))
1183     {
1184       if (SPEC_USIGN (val->etype))
1185         return (double) SPEC_CVAL (val->etype).v_ulong;
1186       else
1187         return (double) SPEC_CVAL (val->etype).v_long;
1188     }
1189
1190   if (SPEC_NOUN (val->etype) == V_INT) {
1191     if (SPEC_USIGN (val->etype))
1192       return (double) SPEC_CVAL (val->etype).v_uint;
1193     else
1194       return (double) SPEC_CVAL (val->etype).v_int;
1195   }
1196
1197   if (SPEC_NOUN (val->etype) == V_CHAR) {
1198     if (SPEC_USIGN (val->etype))
1199       return (double) (unsigned char)SPEC_CVAL (val->etype).v_uint;
1200     else
1201       return (double) (signed char)SPEC_CVAL (val->etype).v_int;
1202   }
1203
1204   if (IS_BITVAR(val->etype)) {
1205     return (double) SPEC_CVAL (val->etype).v_uint;
1206   }
1207
1208   if (SPEC_NOUN (val->etype) == V_VOID) {
1209     return (double) SPEC_CVAL (val->etype).v_ulong;
1210   }
1211
1212   // we are lost !
1213   werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
1214           "floatFromVal: unknown value");
1215   return 0;
1216 }
1217
1218 /*------------------------------------------------------------------*/
1219 /* valUnaryPM - does the unary +/- operation on a constant          */
1220 /*------------------------------------------------------------------*/
1221 value *
1222 valUnaryPM (value * val)
1223 {
1224   /* depending on type */
1225   if (SPEC_NOUN (val->etype) == V_FLOAT)
1226     SPEC_CVAL (val->etype).v_float = -1.0 * SPEC_CVAL (val->etype).v_float;
1227   else if (SPEC_NOUN (val->etype) == V_FIXED16X16)
1228     SPEC_CVAL (val->etype).v_fixed16x16 = -SPEC_CVAL (val->etype).v_fixed16x16;
1229   else
1230     {
1231       if (SPEC_LONG (val->etype))
1232         {
1233           if (SPEC_USIGN (val->etype))
1234             SPEC_CVAL (val->etype).v_ulong = 0-SPEC_CVAL (val->etype).v_ulong;
1235           else
1236             SPEC_CVAL (val->etype).v_long = -SPEC_CVAL (val->etype).v_long;
1237         }
1238       else
1239         {
1240           if (SPEC_USIGN (val->etype))
1241             SPEC_CVAL (val->etype).v_uint = 0-SPEC_CVAL (val->etype).v_uint;
1242           else
1243             SPEC_CVAL (val->etype).v_int = -SPEC_CVAL (val->etype).v_int;
1244
1245           if (SPEC_NOUN(val->etype) == V_CHAR)
1246             {
1247               /* promote to 'signed int', cheapestVal() might reduce it again */
1248               SPEC_USIGN(val->etype) = 0;
1249               SPEC_NOUN(val->etype) = V_INT;
1250             }
1251           return cheapestVal (val);
1252         }
1253     }
1254   return val;
1255 }
1256
1257 /*------------------------------------------------------------------*/
1258 /* valueComplement - complements a constant                         */
1259 /*------------------------------------------------------------------*/
1260 value *
1261 valComplement (value * val)
1262 {
1263   /* depending on type */
1264   if (SPEC_LONG (val->etype))
1265     {
1266       if (SPEC_USIGN (val->etype))
1267         SPEC_CVAL (val->etype).v_ulong = ~SPEC_CVAL (val->etype).v_ulong;
1268       else
1269         SPEC_CVAL (val->etype).v_long = ~SPEC_CVAL (val->etype).v_long;
1270     }
1271   else
1272     {
1273       if (SPEC_USIGN (val->etype))
1274         SPEC_CVAL (val->etype).v_uint = ~SPEC_CVAL (val->etype).v_uint;
1275       else
1276         SPEC_CVAL (val->etype).v_int = ~SPEC_CVAL (val->etype).v_int;
1277
1278       if (SPEC_NOUN(val->etype) == V_CHAR)
1279         {
1280           /* promote to 'signed int', cheapestVal() might reduce it again */
1281           SPEC_USIGN(val->etype) = 0;
1282           SPEC_NOUN(val->etype) = V_INT;
1283         }
1284       return cheapestVal (val);
1285     }
1286   return val;
1287 }
1288
1289 /*------------------------------------------------------------------*/
1290 /* valueNot - complements a constant                                */
1291 /*------------------------------------------------------------------*/
1292 value *
1293 valNot (value * val)
1294 {
1295   /* depending on type */
1296   if (SPEC_LONG (val->etype))
1297     {
1298       if (SPEC_USIGN (val->etype))
1299         SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_ulong;
1300       else
1301         SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_long;
1302     }
1303   else
1304     {
1305       if (SPEC_USIGN (val->etype))
1306         SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_uint;
1307       else
1308         SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_int;
1309
1310     }
1311   /* ANSI: result type is int, value is 0 or 1 */
1312   /* sdcc will hold this in an 'unsigned char' */
1313   SPEC_USIGN(val->etype) = 1;
1314   SPEC_LONG (val->etype) = 0;
1315   SPEC_NOUN(val->etype) = V_CHAR;
1316   return val;
1317 }
1318
1319 /*------------------------------------------------------------------*/
1320 /* valMult - multiply constants                                     */
1321 /*------------------------------------------------------------------*/
1322 value *
1323 valMult (value * lval, value * rval)
1324 {
1325   value *val;
1326
1327   /* create a new value */
1328   val = newValue ();
1329   val->type = val->etype = computeType (lval->etype,
1330                                         rval->etype,
1331                                         RESULT_TYPE_INT,
1332                                         '*');
1333   SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1334
1335   if (IS_FLOAT (val->type))
1336     SPEC_CVAL (val->type).v_float = floatFromVal (lval) * floatFromVal (rval);
1337   else
1338   if (IS_FIXED16X16 (val->type))
1339     SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble(floatFromVal (lval) * floatFromVal (rval));
1340       /* signed and unsigned mul are the same, as long as the precision of the
1341          result isn't bigger than the precision of the operands. */
1342   else if (SPEC_LONG (val->type))
1343     SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) *
1344                                     (TYPE_UDWORD) floatFromVal (rval);
1345   else if (SPEC_USIGN (val->type)) /* unsigned int */
1346     {
1347       TYPE_UDWORD ul = (TYPE_UWORD) floatFromVal (lval) *
1348                        (TYPE_UWORD) floatFromVal (rval);
1349
1350       SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) ul;
1351       if (ul != (TYPE_UWORD) ul)
1352         werror (W_INT_OVL);
1353     }
1354   else /* signed int */
1355     {
1356       TYPE_DWORD l = (TYPE_WORD) floatFromVal (lval) *
1357                      (TYPE_WORD) floatFromVal (rval);
1358
1359       SPEC_CVAL (val->type).v_int = (TYPE_WORD) l;
1360       if (l != (TYPE_WORD) l)
1361         werror (W_INT_OVL);
1362     }
1363   return cheapestVal (val);
1364 }
1365
1366 /*------------------------------------------------------------------*/
1367 /* valDiv  - Divide   constants                                     */
1368 /*------------------------------------------------------------------*/
1369 value *
1370 valDiv (value * lval, value * rval)
1371 {
1372   value *val;
1373
1374   if (floatFromVal (rval) == 0)
1375     {
1376       werror (E_DIVIDE_BY_ZERO);
1377       return rval;
1378     }
1379
1380   /* create a new value */
1381   val = newValue ();
1382   val->type = val->etype = computeType (lval->etype,
1383                                         rval->etype,
1384                                         RESULT_TYPE_INT,
1385                                         '/');
1386   SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1387
1388   if (IS_FLOAT (val->type))
1389     SPEC_CVAL (val->type).v_float = floatFromVal (lval) / floatFromVal (rval);
1390   else
1391   if (IS_FIXED16X16 (val->type))
1392     SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble( floatFromVal (lval) / floatFromVal (rval) );
1393   else if (SPEC_LONG (val->type))
1394     {
1395       if (SPEC_USIGN (val->type))
1396         SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) /
1397           (TYPE_UDWORD) floatFromVal (rval);
1398       else
1399         SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) /
1400           (TYPE_DWORD) floatFromVal (rval);
1401     }
1402   else
1403     {
1404       if (SPEC_USIGN (val->type))
1405         SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) /
1406           (TYPE_UWORD) floatFromVal (rval);
1407       else
1408         SPEC_CVAL (val->type).v_int = (TYPE_WORD) floatFromVal (lval) /
1409           (TYPE_WORD) floatFromVal (rval);
1410     }
1411   return cheapestVal (val);
1412 }
1413
1414 /*------------------------------------------------------------------*/
1415 /* valMod  - Modulus  constants                                     */
1416 /*------------------------------------------------------------------*/
1417 value *
1418 valMod (value * lval, value * rval)
1419 {
1420   value *val;
1421
1422   /* create a new value */
1423   val = newValue();
1424   val->type = val->etype = computeType (lval->etype,
1425                                         rval->etype,
1426                                         RESULT_TYPE_INT,
1427                                         '%');
1428   SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1429
1430   if (SPEC_LONG (val->type))
1431     {
1432       if (SPEC_USIGN (val->type))
1433         SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) %
1434           (TYPE_UDWORD) floatFromVal (rval);
1435       else
1436         SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) %
1437           (TYPE_DWORD) floatFromVal (rval);
1438     }
1439   else
1440     {
1441       if (SPEC_USIGN (val->type))
1442         SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) %
1443           (TYPE_UWORD) floatFromVal (rval);
1444       else
1445         SPEC_CVAL (val->type).v_int = (TYPE_WORD) floatFromVal (lval) %
1446           (TYPE_WORD) floatFromVal (rval);
1447     }
1448   return cheapestVal (val);
1449 }
1450
1451 /*------------------------------------------------------------------*/
1452 /* valPlus - Addition constants                                     */
1453 /*------------------------------------------------------------------*/
1454 value *
1455 valPlus (value * lval, value * rval)
1456 {
1457   value *val;
1458
1459   /* create a new value */
1460   val = newValue();
1461   val->type = val->etype = computeType (lval->etype,
1462                                         rval->etype,
1463                                         RESULT_TYPE_INT,
1464                                         '+');
1465   SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1466
1467   if (IS_FLOAT (val->type))
1468     SPEC_CVAL (val->type).v_float = floatFromVal (lval) + floatFromVal (rval);
1469   else
1470   if (IS_FIXED16X16 (val->type))
1471     SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble( floatFromVal (lval) + floatFromVal (rval) );
1472   else  if (SPEC_LONG (val->type))
1473     {
1474       if (SPEC_USIGN (val->type))
1475         SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) +
1476          (TYPE_UDWORD) floatFromVal (rval);
1477       else
1478         SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) +
1479           (TYPE_DWORD) floatFromVal (rval);
1480     }
1481   else
1482     {
1483       if (SPEC_USIGN (val->type))
1484         SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) +
1485           (TYPE_UWORD) floatFromVal (rval);
1486       else
1487         SPEC_CVAL (val->type).v_int = (TYPE_WORD) floatFromVal (lval) +
1488           (TYPE_WORD) floatFromVal (rval);
1489     }
1490   return cheapestVal (val);
1491 }
1492
1493 /*------------------------------------------------------------------*/
1494 /* valMinus - Addition constants                                    */
1495 /*------------------------------------------------------------------*/
1496 value *
1497 valMinus (value * lval, value * rval)
1498 {
1499   value *val;
1500
1501   /* create a new value */
1502   val = newValue();
1503   val->type = val->etype = computeType (lval->etype,
1504                                         rval->etype,
1505                                         RESULT_TYPE_INT,
1506                                         '-');
1507   SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1508
1509   if (IS_FLOAT (val->type))
1510     SPEC_CVAL (val->type).v_float = floatFromVal (lval) - floatFromVal (rval);
1511   else
1512   if (IS_FIXED16X16 (val->type))
1513     SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble( floatFromVal (lval) - floatFromVal (rval) );
1514   else  if (SPEC_LONG (val->type))
1515     {
1516       if (SPEC_USIGN (val->type))
1517         SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) -
1518           (TYPE_UDWORD) floatFromVal (rval);
1519       else
1520         SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) -
1521           (TYPE_DWORD) floatFromVal (rval);
1522     }
1523   else
1524    {
1525      if (SPEC_USIGN (val->type))
1526        SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) -
1527          (TYPE_UWORD) floatFromVal (rval);
1528      else
1529        SPEC_CVAL (val->type).v_int = (TYPE_WORD) floatFromVal (lval) -
1530          (TYPE_WORD) floatFromVal (rval);
1531     }
1532   return cheapestVal (val);
1533 }
1534
1535 /*------------------------------------------------------------------*/
1536 /* valShift - Shift left or right                                   */
1537 /*------------------------------------------------------------------*/
1538 value *
1539 valShift (value * lval, value * rval, int lr)
1540 {
1541   value *val;
1542
1543   /* create a new value */
1544   val = newValue();
1545   val->type = val->etype = computeType (lval->etype,
1546                                         NULL,
1547                                         RESULT_TYPE_INT,
1548                                         'S');
1549   SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1550
1551   if (getSize (val->type) * 8 <= (TYPE_UDWORD) floatFromVal (rval) &&
1552        /* left shift */
1553       (lr ||
1554         /* right shift and unsigned */
1555        (!lr && SPEC_USIGN (rval->type))))
1556     {
1557       werror (W_SHIFT_CHANGED, (lr ? "left" : "right"));
1558     }
1559
1560   if (SPEC_LONG (val->type))
1561     {
1562       if (SPEC_USIGN (val->type))
1563         {
1564           SPEC_CVAL (val->type).v_ulong = lr ?
1565             (TYPE_UDWORD) floatFromVal (lval) << (TYPE_UDWORD) floatFromVal (rval) : \
1566             (TYPE_UDWORD) floatFromVal (lval) >> (TYPE_UDWORD) floatFromVal (rval);
1567         }
1568       else
1569         {
1570           SPEC_CVAL (val->type).v_long = lr ?
1571             (TYPE_DWORD) floatFromVal (lval) << (TYPE_UDWORD) floatFromVal (rval) : \
1572             (TYPE_DWORD) floatFromVal (lval) >> (TYPE_UDWORD) floatFromVal (rval);
1573         }
1574     }
1575   else
1576     {
1577       if (SPEC_USIGN (val->type))
1578         {
1579           SPEC_CVAL (val->type).v_uint = lr ?
1580             (TYPE_UWORD) floatFromVal (lval) << (TYPE_UDWORD) floatFromVal (rval) : \
1581             (TYPE_UWORD) floatFromVal (lval) >> (TYPE_UDWORD) floatFromVal (rval);
1582         }
1583       else
1584         {
1585           SPEC_CVAL (val->type).v_int = lr ?
1586             (TYPE_WORD) floatFromVal (lval) << (TYPE_UDWORD) floatFromVal (rval) : \
1587             (TYPE_WORD) floatFromVal (lval) >> (TYPE_UDWORD) floatFromVal (rval);
1588         }
1589     }
1590   return cheapestVal (val);
1591 }
1592
1593 /*------------------------------------------------------------------*/
1594 /* valCompare- Compares two literal                                 */
1595 /*------------------------------------------------------------------*/
1596 value *
1597 valCompare (value * lval, value * rval, int ctype)
1598 {
1599   value *val;
1600
1601   /* create a new value */
1602   val = newValue ();
1603   val->type = val->etype = newCharLink ();
1604   val->type->class = SPECIFIER;
1605   SPEC_NOUN (val->type) = V_CHAR;       /* type is char */
1606   SPEC_USIGN (val->type) = 1;
1607   SPEC_SCLS (val->type) = S_LITERAL;    /* will remain literal */
1608
1609   switch (ctype)
1610     {
1611     case '<':
1612       SPEC_CVAL (val->type).v_int = floatFromVal (lval) < floatFromVal (rval);
1613       break;
1614
1615     case '>':
1616       SPEC_CVAL (val->type).v_int = floatFromVal (lval) > floatFromVal (rval);
1617       break;
1618
1619     case LE_OP:
1620       SPEC_CVAL (val->type).v_int = floatFromVal (lval) <= floatFromVal (rval);
1621       break;
1622
1623     case GE_OP:
1624       SPEC_CVAL (val->type).v_int = floatFromVal (lval) >= floatFromVal (rval);
1625       break;
1626
1627     case EQ_OP:
1628       if (SPEC_NOUN(lval->type) == V_FLOAT ||
1629           SPEC_NOUN(rval->type) == V_FLOAT)
1630         {
1631           SPEC_CVAL (val->type).v_int = floatFromVal (lval) == floatFromVal (rval);
1632         }
1633       else
1634       if (SPEC_NOUN(lval->type) == V_FIXED16X16 ||
1635           SPEC_NOUN(rval->type) == V_FIXED16X16)
1636         {
1637           SPEC_CVAL (val->type).v_int = floatFromVal (lval) == floatFromVal (rval);
1638         }
1639       else
1640         {
1641           /* integrals: ignore signedness */
1642           TYPE_UDWORD l, r;
1643
1644           l = (TYPE_UDWORD) floatFromVal (lval);
1645           r = (TYPE_UDWORD) floatFromVal (rval);
1646           /* In order to correctly compare 'signed int' and 'unsigned int' it's
1647              neccessary to strip them to 16 bit.
1648              Literals are reduced to their cheapest type, therefore left and
1649              right might have different types. It's neccessary to find a
1650              common type: int (used for char too) or long */
1651           if (!IS_LONG (lval->etype) &&
1652               !IS_LONG (rval->etype))
1653             {
1654               r = (TYPE_UWORD) r;
1655               l = (TYPE_UWORD) l;
1656             }
1657           SPEC_CVAL (val->type).v_int = l == r;
1658         }
1659       break;
1660     case NE_OP:
1661       if (SPEC_NOUN(lval->type) == V_FLOAT ||
1662           SPEC_NOUN(rval->type) == V_FLOAT)
1663         {
1664           SPEC_CVAL (val->type).v_int = floatFromVal (lval) != floatFromVal (rval);
1665         }
1666       else
1667       if (SPEC_NOUN(lval->type) == V_FIXED16X16 ||
1668           SPEC_NOUN(rval->type) == V_FIXED16X16)
1669         {
1670           SPEC_CVAL (val->type).v_int = floatFromVal (lval) != floatFromVal (rval);
1671         }
1672       else
1673         {
1674           /* integrals: ignore signedness */
1675           TYPE_UDWORD l, r;
1676
1677           l = (TYPE_UDWORD) floatFromVal (lval);
1678           r = (TYPE_UDWORD) floatFromVal (rval);
1679           /* In order to correctly compare 'signed int' and 'unsigned int' it's
1680              neccessary to strip them to 16 bit.
1681              Literals are reduced to their cheapest type, therefore left and
1682              right might have different types. It's neccessary to find a
1683              common type: int (used for char too) or long */
1684           if (!IS_LONG (lval->etype) &&
1685               !IS_LONG (rval->etype))
1686             {
1687               r = (TYPE_UWORD) r;
1688               l = (TYPE_UWORD) l;
1689             }
1690           SPEC_CVAL (val->type).v_int = l != r;
1691         }
1692       break;
1693
1694     }
1695
1696   return val;
1697 }
1698
1699 /*------------------------------------------------------------------*/
1700 /* valBitwise - Bitwise operation                                   */
1701 /*------------------------------------------------------------------*/
1702 value *
1703 valBitwise (value * lval, value * rval, int op)
1704 {
1705   value *val;
1706
1707   /* create a new value */
1708   val = newValue ();
1709   val->type = computeType (lval->etype, rval->etype, RESULT_TYPE_CHAR, op);
1710   val->etype = getSpec (val->type);
1711   SPEC_SCLS (val->etype) = S_LITERAL;
1712
1713   switch (op)
1714     {
1715     case '&':
1716       if (SPEC_LONG (val->type))
1717         {
1718           if (SPEC_USIGN (val->type))
1719             SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) &
1720               (TYPE_UDWORD) floatFromVal (rval);
1721           else
1722             SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) &
1723               (TYPE_DWORD) floatFromVal (rval);
1724         }
1725       else
1726         {
1727           if (SPEC_USIGN (val->type))
1728             SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) &
1729               (TYPE_UWORD) floatFromVal (rval);
1730           else
1731             SPEC_CVAL (val->type).v_int = (TYPE_WORD) floatFromVal (lval) & (TYPE_WORD) floatFromVal (rval);
1732         }
1733       break;
1734
1735     case '|':
1736       if (SPEC_LONG (val->type))
1737         {
1738           if (SPEC_USIGN (val->type))
1739             SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) |
1740               (TYPE_UDWORD) floatFromVal (rval);
1741           else
1742             SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) |
1743               (TYPE_DWORD) floatFromVal (rval);
1744         }
1745       else
1746         {
1747           if (SPEC_USIGN (val->type))
1748             SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) |
1749               (TYPE_UWORD) floatFromVal (rval);
1750           else
1751             SPEC_CVAL (val->type).v_int =
1752               (TYPE_WORD) floatFromVal (lval) | (TYPE_WORD) floatFromVal (rval);
1753         }
1754
1755       break;
1756
1757     case '^':
1758       if (SPEC_LONG (val->type))
1759         {
1760           if (SPEC_USIGN (val->type))
1761             SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) ^
1762               (TYPE_UDWORD) floatFromVal (rval);
1763           else
1764             SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) ^
1765               (TYPE_DWORD) floatFromVal (rval);
1766         }
1767       else
1768         {
1769           if (SPEC_USIGN (val->type))
1770             SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) ^
1771               (TYPE_UWORD) floatFromVal (rval);
1772           else
1773             SPEC_CVAL (val->type).v_int =
1774               (TYPE_WORD) floatFromVal (lval) ^ (TYPE_WORD) floatFromVal (rval);
1775         }
1776       break;
1777     }
1778
1779   return cheapestVal(val);
1780 }
1781
1782 /*------------------------------------------------------------------*/
1783 /* valAndOr   - Generates code for and / or operation               */
1784 /*------------------------------------------------------------------*/
1785 value *
1786 valLogicAndOr (value * lval, value * rval, int op)
1787 {
1788   value *val;
1789
1790   /* create a new value */
1791   val = newValue ();
1792   val->type = val->etype = newCharLink ();
1793   val->type->class = SPECIFIER;
1794   SPEC_SCLS (val->type) = S_LITERAL;    /* will remain literal */
1795   SPEC_USIGN (val->type) = 1;
1796
1797   switch (op)
1798     {
1799     case AND_OP:
1800       SPEC_CVAL (val->type).v_int = floatFromVal (lval) && floatFromVal (rval);
1801       break;
1802
1803     case OR_OP:
1804       SPEC_CVAL (val->type).v_int = floatFromVal (lval) || floatFromVal (rval);
1805       break;
1806     }
1807
1808
1809   return val;
1810 }
1811
1812 /*------------------------------------------------------------------*/
1813 /* valCastLiteral - casts a literal value to another type           */
1814 /*------------------------------------------------------------------*/
1815 value *
1816 valCastLiteral (sym_link * dtype, double fval)
1817 {
1818   value *val;
1819   TYPE_UDWORD l = (TYPE_UDWORD)fval;
1820
1821   if (!dtype)
1822     return NULL;
1823
1824   val = newValue ();
1825   if (dtype)
1826     val->etype = getSpec (val->type = copyLinkChain (dtype));
1827   else
1828     {
1829       val->etype = val->type = newLink (SPECIFIER);
1830       SPEC_NOUN (val->etype) = V_VOID;
1831     }
1832   SPEC_SCLS (val->etype) = S_LITERAL;
1833
1834   /* if it is not a specifier then we can assume that */
1835   /* it will be an unsigned long                      */
1836   if (!IS_SPEC (val->type)) {
1837       SPEC_CVAL (val->etype).v_ulong = l;
1838       return val;
1839   }
1840
1841   if (SPEC_NOUN (val->etype) == V_FLOAT)
1842       SPEC_CVAL (val->etype).v_float = fval;
1843   else if (SPEC_NOUN (val->etype) == V_FIXED16X16)
1844       SPEC_CVAL (val->etype).v_fixed16x16 = fixed16x16FromDouble( fval );
1845   else if (SPEC_NOUN (val->etype) == V_BIT ||
1846            SPEC_NOUN (val->etype) == V_SBIT)
1847     SPEC_CVAL (val->etype).v_uint = l ? 1 : 0;
1848   else if (SPEC_NOUN (val->etype) == V_BITFIELD)
1849     SPEC_CVAL (val->etype).v_uint = l &
1850                                     (0xffffu >> (16 - SPEC_BLEN (val->etype)));
1851   else if (SPEC_NOUN (val->etype) == V_CHAR) {
1852       if (SPEC_USIGN (val->etype))
1853           SPEC_CVAL (val->etype).v_uint= (TYPE_UBYTE) l;
1854       else
1855           SPEC_CVAL (val->etype).v_int = (TYPE_BYTE) l;
1856   } else {
1857       if (SPEC_LONG (val->etype)) {
1858           if (SPEC_USIGN (val->etype))
1859               SPEC_CVAL (val->etype).v_ulong = (TYPE_UDWORD) l;
1860           else
1861               SPEC_CVAL (val->etype).v_long = (TYPE_DWORD) l;
1862       } else {
1863           if (SPEC_USIGN (val->etype))
1864               SPEC_CVAL (val->etype).v_uint = (TYPE_UWORD)l;
1865           else
1866               SPEC_CVAL (val->etype).v_int = (TYPE_WORD)l;
1867       }
1868   }
1869   return val;
1870 }
1871
1872 /*------------------------------------------------------------------*/
1873 /* getNelements - determines # of elements from init list           */
1874 /*------------------------------------------------------------------*/
1875 int
1876 getNelements (sym_link * type, initList * ilist)
1877 {
1878   int i;
1879
1880   if (!ilist)
1881     return 0;
1882
1883   if (ilist->type == INIT_DEEP)
1884     ilist = ilist->init.deep;
1885
1886   /* if type is a character array and there is only one
1887      (string) initialiser then get the length of the string */
1888   if (IS_ARRAY (type) && IS_CHAR (type->next) && !ilist->next)
1889     {
1890       ast *iast = ilist->init.node;
1891       value *v = (iast->type == EX_VALUE ? iast->opval.val : NULL);
1892       if (!v)
1893         {
1894           werror (E_CONST_EXPECTED);
1895           return 0;
1896         }
1897
1898       if (IS_ARRAY (v->type) && IS_CHAR (v->etype))
1899         // yep, it's a string
1900         {
1901           return DCL_ELEM (v->type);
1902         }
1903     }
1904
1905   i = 0;
1906   while (ilist)
1907     {
1908       i++;
1909       ilist = ilist->next;
1910     }
1911   return i;
1912 }
1913
1914 /*-----------------------------------------------------------------*/
1915 /* valForArray - returns a value with name of array index          */
1916 /*-----------------------------------------------------------------*/
1917 value *
1918 valForArray (ast * arrExpr)
1919 {
1920   value *val, *lval = NULL;
1921   char buffer[128];
1922   int size = getSize (arrExpr->left->ftype->next);
1923   /* if the right or left is an array
1924      resolve it first */
1925   if (IS_AST_OP (arrExpr->left))
1926     {
1927       if (arrExpr->left->opval.op == '[')
1928         lval = valForArray (arrExpr->left);
1929       else if (arrExpr->left->opval.op == '.')
1930         lval = valForStructElem (arrExpr->left->left,
1931                                  arrExpr->left->right);
1932       else if (arrExpr->left->opval.op == PTR_OP &&
1933                IS_ADDRESS_OF_OP (arrExpr->left->left))
1934         lval = valForStructElem (arrExpr->left->left->left,
1935                                  arrExpr->left->right);
1936       else
1937         return NULL;
1938
1939     }
1940   else if (!IS_AST_SYM_VALUE (arrExpr->left))
1941     return NULL;
1942
1943   if (!IS_AST_LIT_VALUE (arrExpr->right))
1944     return NULL;
1945
1946   val = newValue ();
1947   if (!lval)
1948     {
1949         SNPRINTF (buffer, sizeof(buffer), "%s", AST_SYMBOL (arrExpr->left)->rname);
1950     }
1951   else
1952     {
1953         SNPRINTF (buffer, sizeof(buffer), "%s", lval->name);
1954     }
1955
1956   SNPRINTF (val->name, sizeof(val->name), "(%s + %d)", buffer,
1957            (int) AST_LIT_VALUE (arrExpr->right) * size);
1958
1959   val->type = newLink (DECLARATOR);
1960   if (SPEC_SCLS (arrExpr->left->etype) == S_CODE)
1961     DCL_TYPE (val->type) = CPOINTER;
1962   else if (SPEC_SCLS (arrExpr->left->etype) == S_XDATA)
1963     DCL_TYPE (val->type) = FPOINTER;
1964   else if (SPEC_SCLS (arrExpr->left->etype) == S_XSTACK)
1965     DCL_TYPE (val->type) = PPOINTER;
1966   else if (SPEC_SCLS (arrExpr->left->etype) == S_IDATA)
1967     DCL_TYPE (val->type) = IPOINTER;
1968   else if (SPEC_SCLS (arrExpr->left->etype) == S_EEPROM)
1969     DCL_TYPE (val->type) = EEPPOINTER;
1970   else
1971     DCL_TYPE (val->type) = POINTER;
1972   val->type->next = arrExpr->left->ftype->next;
1973   val->etype = getSpec (val->type);
1974   return val;
1975 }
1976
1977 /*-----------------------------------------------------------------*/
1978 /* valForStructElem - returns value with name of struct element    */
1979 /*-----------------------------------------------------------------*/
1980 value *
1981 valForStructElem (ast * structT, ast * elemT)
1982 {
1983   value *val, *lval = NULL;
1984   char buffer[128];
1985   symbol *sym;
1986
1987   /* left could be furthur derefed */
1988   if (IS_AST_OP (structT))
1989     {
1990       if (structT->opval.op == '[')
1991         lval = valForArray (structT);
1992       else if (structT->opval.op == '.')
1993         lval = valForStructElem (structT->left, structT->right);
1994       else if (structT->opval.op == PTR_OP &&
1995                IS_ADDRESS_OF_OP (structT->left))
1996         lval = valForStructElem (structT->left->left,
1997                                  structT->right);
1998       else
1999         return NULL;
2000     }
2001
2002   if (!IS_AST_SYM_VALUE (elemT))
2003     return NULL;
2004
2005   if (!IS_STRUCT (structT->etype))
2006     return NULL;
2007
2008   if ((sym = getStructElement (SPEC_STRUCT (structT->etype),
2009                                AST_SYMBOL (elemT))) == NULL)
2010     {
2011       return NULL;
2012     }
2013
2014   val = newValue ();
2015   if (!lval)
2016     {
2017         SNPRINTF(buffer, sizeof(buffer), "%s", AST_SYMBOL (structT)->rname);
2018     }
2019   else
2020     {
2021         SNPRINTF (buffer, sizeof(buffer), "%s", lval->name);
2022     }
2023
2024   SNPRINTF (val->name, sizeof(val->name), "(%s + %d)", buffer,
2025            (int) sym->offset);
2026
2027   val->type = newLink (DECLARATOR);
2028   if (SPEC_SCLS (structT->etype) == S_CODE)
2029     DCL_TYPE (val->type) = CPOINTER;
2030   else if (SPEC_SCLS (structT->etype) == S_XDATA)
2031     DCL_TYPE (val->type) = FPOINTER;
2032   else if (SPEC_SCLS (structT->etype) == S_XSTACK)
2033     DCL_TYPE (val->type) = PPOINTER;
2034   else if (SPEC_SCLS (structT->etype) == S_IDATA)
2035     DCL_TYPE (val->type) = IPOINTER;
2036   else if (SPEC_SCLS (structT->etype) == S_EEPROM)
2037     DCL_TYPE (val->type) = EEPPOINTER;
2038   else
2039     DCL_TYPE (val->type) = POINTER;
2040   val->type->next = sym->type;
2041   val->etype = getSpec (val->type);
2042   return val;
2043 }
2044
2045 /*-----------------------------------------------------------------*/
2046 /* valForCastAggr - will return value for a cast of an aggregate   */
2047 /*                  plus minus a constant                          */
2048 /*-----------------------------------------------------------------*/
2049 value *
2050 valForCastAggr (ast * aexpr, sym_link * type, ast * cnst, int op)
2051 {
2052   value *val;
2053
2054   if (!IS_AST_SYM_VALUE (aexpr))
2055     return NULL;
2056   if (!IS_AST_LIT_VALUE (cnst))
2057     return NULL;
2058
2059   val = newValue ();
2060
2061   SNPRINTF (val->name, sizeof(val->name), "(%s %c %d)",
2062            AST_SYMBOL (aexpr)->rname, op,
2063            getSize (type->next) * (int) AST_LIT_VALUE (cnst));
2064
2065   val->type = type;
2066   val->etype = getSpec (val->type);
2067   return val;
2068 }
2069
2070 /*-----------------------------------------------------------------*/
2071 /* valForCastAggr - will return value for a cast of an aggregate   */
2072 /*                  with no constant                               */
2073 /*-----------------------------------------------------------------*/
2074 value *
2075 valForCastArr (ast * aexpr, sym_link * type)
2076 {
2077   value *val;
2078
2079   if (!IS_AST_SYM_VALUE (aexpr))
2080     return NULL;
2081
2082   val = newValue ();
2083
2084   SNPRINTF (val->name, sizeof(val->name), "(%s)",
2085            AST_SYMBOL (aexpr)->rname);
2086
2087   val->type = type;
2088   val->etype = getSpec (val->type);
2089   return val;
2090 }