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