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_TARGET_ULONG maxVal = 0xffffffffu >> (32 - varBits);
 404
 405               if (   litVal < 0
 406                   || litVal > maxVal)
 407                 return CCR_OVL;
 408               return CCR_OK;
 409             }
 410           else
 411             {
 412               TYPE_TARGET_LONG minVal = 0xffffffff << (varBits - 1);
 413               TYPE_TARGET_LONG maxVal = 0x7fffffff >> (32 - varBits);
 414
 415               if (   litVal < minVal
 416                   || litVal > maxVal)
 417                 return CCR_OVL;
 418               return CCR_OK;
 419             }
 420         }
 421       else
 422         {
 423           /* ignore signedness, e.g. allow everything
 424              from -127...+255 for (unsigned) char */
 425           TYPE_TARGET_LONG  minVal = 0xffffffff  << (varBits - 1);
 426           TYPE_TARGET_ULONG maxVal = 0xffffffffu >> (32 - varBits);
 427
 428           if (   litVal < minVal
 429               || litVal > maxVal)
 430             return CCR_OVL;
 431           return CCR_OK;
 432         }
 433     }
 434
 435   if (exchangeLeftRight)
 436     switch (op)
 437       {
 438         case EQ_OP:             break;
 439         case NE_OP:             break;
 440         case '>':   op = '<';   break;
 441         case GE_OP: op = LE_OP; break;
 442         case '<':   op = '>';   break;
 443         case LE_OP: op = GE_OP; break;
 444         default:                return CCR_ALWAYS_FALSE;
 445       }
 446
 447   reType = computeType (var, lit, RESULT_TYPE_NONE, op);
 448
 449   if (SPEC_USIGN (reType))
 450     {
 451       /* unsigned operation */
 452       TYPE_TARGET_ULONG minValP, maxValP, minValM, maxValM;
 453       TYPE_TARGET_ULONG opBitsMask = 0xffffffffu >> (32 - bitsForType (reType));
 454
 455       if (SPEC_USIGN (lit) && SPEC_USIGN (var))
 456         {
 457           /* both operands are unsigned, this is easy */
 458           minValP = 0;
 459           maxValP = 0xffffffffu >> (32 - varBits);
 460           /* there's only range, just copy it to 2nd set */
 461           minValM = minValP;
 462           maxValM = maxValP;
 463         }
 464       else if (SPEC_USIGN (var))
 465         {
 466           /* lit is casted from signed to unsigned, e.g.:
 467                unsigned u;
 468                  u == (char) -17
 469               -> u == 0xffef'
 470           */
 471           minValP = 0;
 472           maxValP = 0xffffffffu >> (32 - varBits);
 473           /* there's only one range, just copy it to 2nd set */
 474           minValM = minValP;
 475           maxValM = maxValP;
 476
 477           /* it's an unsigned operation */
 478           if (   IS_CHAR (reType)
 479               || IS_INT (reType))
 480             {
 481               /* make signed literal unsigned and
 482                  limit no of bits to size of return type */
 483               litVal = (TYPE_TARGET_ULONG) litVal & opBitsMask;
 484             }
 485         }
 486       else /* SPEC_USIGN (lit) */
 487         {
 488           /* var is casted from signed to unsigned, e.g.:
 489                signed char c;
 490                  c == (unsigned) -17
 491               -> c == 0xffef'
 492
 493              The possible values after casting var
 494              split up in two, nonconsecutive ranges:
 495
 496              minValP =      0;  positive range: 0...127
 497              maxValP =   0x7f;
 498              minValM = 0xff80;  negative range: -128...-1
 499              maxValM = 0xffff;
 500           */
 501
 502           /* positive range */
 503           minValP = 0;
 504           maxValP = 0x7fffffffu >> (32 - varBits);
 505
 506           /* negative range */
 507           minValM = 0xffffffff  << (varBits - 1);
 508           maxValM = 0xffffffffu; /* -1 */
 509           /* limit no of bits to size of return type */
 510           minValM &= opBitsMask;
 511           maxValM &= opBitsMask;
 512         }
 513
 514       switch (op)
 515         {
 516           case EQ_OP:                   /* var == lit */
 517             if (   litVal <= maxValP
 518                 && litVal >= minValP) /* 0 */
 519               return CCR_OK;
 520             if (   litVal <= maxValM
 521                 && litVal >= minValM)
 522               return CCR_OK;
 523             return CCR_ALWAYS_FALSE;
 524           case NE_OP:                   /* var != lit */
 525             if (   litVal <= maxValP
 526                 && litVal >= minValP) /* 0 */
 527               return CCR_OK;
 528             if (   litVal <= maxValM
 529                 && litVal >= minValM)
 530               return CCR_OK;
 531             return CCR_ALWAYS_TRUE;
 532           case '>':                     /* var >  lit */
 533             if (litVal >= maxValM)
 534               return CCR_ALWAYS_FALSE;
 535             if (litVal <  minValP) /* 0 */
 536               return CCR_ALWAYS_TRUE;
 537             return CCR_OK;
 538           case GE_OP:                   /* var >= lit */
 539             if (litVal >  maxValM)
 540               return CCR_ALWAYS_FALSE;
 541             if (litVal <= minValP) /* 0 */
 542               return CCR_ALWAYS_TRUE;
 543             return CCR_OK;
 544           case '<':                     /* var <  lit */
 545             if (litVal >  maxValM)
 546               return CCR_ALWAYS_TRUE;
 547             if (litVal <= minValP) /* 0 */
 548               return CCR_ALWAYS_FALSE;
 549             return CCR_OK;
 550           case LE_OP:                   /* var <= lit */
 551             if (litVal >= maxValM)
 552               return CCR_ALWAYS_TRUE;
 553             if (litVal <  minValP) /* 0 */
 554               return CCR_ALWAYS_FALSE;
 555             return CCR_OK;
 556           default:
 557             return CCR_ALWAYS_FALSE;
 558         }
 559     }
 560   else
 561     {
 562       /* signed operation */
 563       TYPE_TARGET_LONG minVal, maxVal;
 564
 565       if (SPEC_USIGN (var))
 566         {
 567           /* unsigned var, but signed operation. This happens
 568              when var is promoted to signed int.
 569              Set actual min/max values of var. */
 570           minVal = 0;
 571           maxVal = 0xffffffff >> (32 - varBits);
 572         }
 573       else
 574         {
 575           /* signed var */
 576           minVal = 0xffffffff << (varBits - 1);
 577           maxVal = 0x7fffffff >> (32 - varBits);
 578         }
 579
 580       switch (op)
 581         {
 582           case EQ_OP:                   /* var == lit */
 583             if (   litVal > maxVal
 584                 || litVal < minVal)
 585               return CCR_ALWAYS_FALSE;
 586             return CCR_OK;
 587           case NE_OP:                   /* var != lit */
 588             if (   litVal > maxVal
 589                 || litVal < minVal)
 590               return CCR_ALWAYS_TRUE;
 591             return CCR_OK;
 592           case '>':                     /* var >  lit */
 593             if (litVal >= maxVal)
 594               return CCR_ALWAYS_FALSE;
 595             if (litVal <  minVal)
 596               return CCR_ALWAYS_TRUE;
 597             return CCR_OK;
 598           case GE_OP:                   /* var >= lit */
 599             if (litVal >  maxVal)
 600               return CCR_ALWAYS_FALSE;
 601             if (litVal <= minVal)
 602               return CCR_ALWAYS_TRUE;
 603             return CCR_OK;
 604           case '<':                     /* var <  lit */
 605             if (litVal >  maxVal)
 606               return CCR_ALWAYS_TRUE;
 607             if (litVal <= minVal)
 608               return CCR_ALWAYS_FALSE;
 609             return CCR_OK;
 610           case LE_OP:                   /* var <= lit */
 611             if (litVal >= maxVal)
 612               return CCR_ALWAYS_TRUE;
 613             if (litVal <  minVal)
 614               return CCR_ALWAYS_FALSE;
 615             return CCR_OK;
 616           default:
 617             return CCR_ALWAYS_FALSE;
 618         }
 619     }
 620 }
 621
 622 /*-----------------------------------------------------------------*/
 623 /* valueFromLit - creates a value from a literal                   */
 624 /*-----------------------------------------------------------------*/
 625 value *
 626 valueFromLit (double lit)
 627 {
 628   char buffer[50];
 629
 630   if ((((TYPE_TARGET_LONG) lit) - lit) == 0)
 631     {
 632       SNPRINTF (buffer, sizeof(buffer), "%d", (TYPE_TARGET_LONG) lit);
 633       return constVal (buffer);
 634     }
 635
 636   SNPRINTF (buffer, sizeof(buffer), "%f", lit);
 637   return constFloatVal (buffer);
 638 }
 639
 640 /*-----------------------------------------------------------------*/
 641 /* constFloatVal - converts a FLOAT constant to value              */
 642 /*-----------------------------------------------------------------*/
 643 value *
 644 constFloatVal (char *s)
 645 {
 646   value *val = newValue ();
 647   double sval;
 648
 649   if (sscanf (s, "%lf", &sval) != 1)
 650     {
 651       werror (E_INVALID_FLOAT_CONST, s);
 652       return constVal ("0");
 653     }
 654
 655   val->type = val->etype = newLink (SPECIFIER);
 656   SPEC_NOUN (val->type) = V_FLOAT;
 657   SPEC_SCLS (val->type) = S_LITERAL;
 658   SPEC_CVAL (val->type).v_float = sval;
 659
 660   return val;
 661 }
 662
 663 /*-----------------------------------------------------------------*/
 664 /* constFixed16x16Val - converts a FIXED16X16 constant to value    */
 665 /*-----------------------------------------------------------------*/
 666 value *
 667 constFixed16x16Val (char *s)
 668 {
 669   value *val = newValue ();
 670   double sval;
 671
 672   if (sscanf (s, "%lf", &sval) != 1)
 673     {
 674       werror (E_INVALID_FLOAT_CONST, s);
 675       return constVal ("0");
 676     }
 677
 678   val->type = val->etype = newLink (SPECIFIER);
 679   SPEC_NOUN (val->type) = V_FLOAT;
 680   SPEC_SCLS (val->type) = S_LITERAL;
 681   SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble ( sval );
 682
 683   return val;
 684 }
 685
 686 /*-----------------------------------------------------------------*/
 687 /* constVal - converts an INTEGER constant into a cheapest value   */
 688 /*-----------------------------------------------------------------*/
 689 value *constVal (char *s)
 690 {
 691   value *val;
 692   short hex = 0, octal = 0;
 693   double dval;
 694
 695   val = newValue ();            /* alloc space for value   */
 696
 697   val->type = val->etype = newLink (SPECIFIER); /* create the spcifier */
 698   SPEC_SCLS (val->type) = S_LITERAL;
 699   // let's start with a signed char
 700   SPEC_NOUN (val->type) = V_CHAR;
 701   SPEC_USIGN (val->type) = 0;
 702
 703   hex = ((strchr (s, 'x') || strchr (s, 'X')) ? 1 : 0);
 704
 705   /* set the octal flag   */
 706   if (!hex && *s == '0' && *(s + 1))
 707     octal = 1;
 708
 709   errno = 0;
 710   if (hex || octal) {
 711     unsigned long sval;
 712     sval = strtoul (s, NULL, 0);
 713     dval=sval;
 714     if (errno) {
 715       dval = 4294967295.0;
 716       werror (W_INVALID_INT_CONST, s, dval);
 717     }
 718   } else {
 719     sscanf (s, "%lf", &dval);
 720   }
 721
 722   /* Setup the flags first */
 723   /* set the unsigned flag if 'uU' is found */
 724   if (strchr (s, 'u') || strchr (s, 'U')) {
 725     SPEC_USIGN (val->type) = 1;
 726   }
 727
 728   /* set the b_long flag if 'lL' is found */
 729   if (strchr (s, 'l') || strchr (s, 'L')) {
 730     SPEC_NOUN (val->type) = V_INT;
 731     SPEC_LONG (val->type) = 1;
 732   } else {
 733     if (dval<0) { // "-28u" will still be signed and negative
 734       if (dval<-128) { // check if we have to promote to int
 735         SPEC_NOUN (val->type) = V_INT;
 736       }
 737       if (dval<-32768) { // check if we have to promote to long int
 738         SPEC_LONG (val->type) = 1;
 739       }
 740     } else { // >=0
 741       if (dval>0xff ||  /* check if we have to promote to int */
 742           SPEC_USIGN (val->type)) { /* if it's unsigned, we can't use unsigned
 743                                      char. After an integral promotion it will
 744                                      be a signed int; this certainly isn't what
 745                                      the programer wants */
 746         SPEC_NOUN (val->type) = V_INT;
 747       }
 748       else { /* store char's always as unsigned; this helps other optimizations */
 749         SPEC_USIGN (val->type) = 1;
 750       }
 751       if (dval>0xffff && SPEC_USIGN (val->type)) { // check if we have to promote to long
 752         SPEC_LONG (val->type) = 1;
 753       }
 754       else if (dval>0x7fff && !SPEC_USIGN (val->type)) { // check if we have to promote to long int
 755         if ((hex || octal) && /* hex or octal constants may be stored in unsigned type */
 756             dval<=0xffff) {
 757           SPEC_USIGN (val->type) = 1;
 758         } else {
 759           SPEC_LONG (val->type) = 1;
 760           if (dval>0x7fffffff) {
 761             SPEC_USIGN (val->type) = 1;
 762           }
 763         }
 764       }
 765     }
 766   }
 767
 768   /* check for out of range */
 769   if (dval<-2147483648.0) {
 770     dval = -2147483648.0;
 771     werror (W_INVALID_INT_CONST, s, dval);
 772   }
 773   if (dval>2147483647.0 && !SPEC_USIGN (val->type)) {
 774     dval = 2147483647.0;
 775     werror (W_INVALID_INT_CONST, s, dval);
 776   }
 777   if (dval>4294967295.0) {
 778     dval = 4294967295.0;
 779     werror (W_INVALID_INT_CONST, s, dval);
 780   }
 781
 782   if (SPEC_LONG (val->type))
 783     {
 784       if (SPEC_USIGN (val->type))
 785         {
 786           SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG)dval;
 787         }
 788       else
 789         {
 790           SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG)dval;
 791         }
 792     }
 793   else
 794     {
 795       if (SPEC_USIGN (val->type))
 796         {
 797           SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT)dval;
 798         }
 799       else
 800         {
 801           SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT)dval;
 802         }
 803     }
 804
 805   return val;
 806 }
 807
 808 /*! /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 /* doubleFromFixed16x16 - convert a fixed16x16 to double           */
1220 /*-----------------------------------------------------------------*/
1221 double doubleFromFixed16x16(TYPE_TARGET_ULONG value)
1222 {
1223 #if 0
1224   /* This version is incorrect negative values. */
1225   double tmp=0, exp=2;
1226
1227     tmp = (value & 0xffff0000) >> 16;
1228
1229     while(value) {
1230       value &= 0xffff;
1231       if(value & 0x8000)tmp += 1/exp;
1232       exp *= 2;
1233       value <<= 1;
1234     }
1235
1236   return (tmp);
1237 #else
1238   return ((double)(value * 1.0) / (double)(1UL << 16));
1239 #endif
1240 }
1241
1242 TYPE_TARGET_ULONG fixed16x16FromDouble(double value)
1243 {
1244 #if 0
1245   /* This version is incorrect negative values. */
1246   unsigned int tmp=0, pos=16;
1247   TYPE_TARGET_ULONG res;
1248
1249     tmp = floor( value );
1250     res = tmp << 16;
1251     value -= tmp;
1252
1253     tmp = 0;
1254     while(pos--) {
1255       value *= 2;
1256       if(value >= 1.0)tmp |= (1 << pos);
1257       value -= floor( value );
1258     }
1259
1260     res |= tmp;
1261
1262   return (res);
1263 #else
1264   return  (TYPE_TARGET_ULONG)(value * (double)(1UL << 16));
1265 #endif
1266 }
1267
1268 /*------------------------------------------------------------------*/
1269 /* valUnaryPM - does the unary +/- operation on a constant          */
1270 /*------------------------------------------------------------------*/
1271 value *
1272 valUnaryPM (value * val)
1273 {
1274   /* depending on type */
1275   if (SPEC_NOUN (val->etype) == V_FLOAT)
1276     SPEC_CVAL (val->etype).v_float = -1.0 * SPEC_CVAL (val->etype).v_float;
1277   else if (SPEC_NOUN (val->etype) == V_FIXED16X16)
1278     SPEC_CVAL (val->etype).v_fixed16x16 = -SPEC_CVAL (val->etype).v_fixed16x16;
1279   else
1280     {
1281       if (SPEC_LONG (val->etype))
1282         {
1283           if (SPEC_USIGN (val->etype))
1284             SPEC_CVAL (val->etype).v_ulong = 0-SPEC_CVAL (val->etype).v_ulong;
1285           else
1286             SPEC_CVAL (val->etype).v_long = -SPEC_CVAL (val->etype).v_long;
1287         }
1288       else
1289         {
1290           if (SPEC_USIGN (val->etype))
1291             SPEC_CVAL (val->etype).v_uint = 0-SPEC_CVAL (val->etype).v_uint;
1292           else
1293             SPEC_CVAL (val->etype).v_int = -SPEC_CVAL (val->etype).v_int;
1294
1295           if (SPEC_NOUN(val->etype) == V_CHAR)
1296             {
1297               /* promote to 'signed int', cheapestVal() might reduce it again */
1298               SPEC_USIGN(val->etype) = 0;
1299               SPEC_NOUN(val->etype) = V_INT;
1300             }
1301           return cheapestVal (val);
1302         }
1303     }
1304   return val;
1305 }
1306
1307 /*------------------------------------------------------------------*/
1308 /* valueComplement - complements a constant                         */
1309 /*------------------------------------------------------------------*/
1310 value *
1311 valComplement (value * val)
1312 {
1313   /* depending on type */
1314   if (SPEC_LONG (val->etype))
1315     {
1316       if (SPEC_USIGN (val->etype))
1317         SPEC_CVAL (val->etype).v_ulong = ~SPEC_CVAL (val->etype).v_ulong;
1318       else
1319         SPEC_CVAL (val->etype).v_long = ~SPEC_CVAL (val->etype).v_long;
1320     }
1321   else
1322     {
1323       if (SPEC_USIGN (val->etype))
1324         SPEC_CVAL (val->etype).v_uint = ~SPEC_CVAL (val->etype).v_uint;
1325       else
1326         SPEC_CVAL (val->etype).v_int = ~SPEC_CVAL (val->etype).v_int;
1327
1328       if (SPEC_NOUN(val->etype) == V_CHAR)
1329         {
1330           /* promote to 'signed int', cheapestVal() might reduce it again */
1331           SPEC_USIGN(val->etype) = 0;
1332           SPEC_NOUN(val->etype) = V_INT;
1333         }
1334       return cheapestVal (val);
1335     }
1336   return val;
1337 }
1338
1339 /*------------------------------------------------------------------*/
1340 /* valueNot - complements a constant                                */
1341 /*------------------------------------------------------------------*/
1342 value *
1343 valNot (value * val)
1344 {
1345   /* depending on type */
1346   if (SPEC_LONG (val->etype))
1347     {
1348       if (SPEC_USIGN (val->etype))
1349         SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_ulong;
1350       else
1351         SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_long;
1352     }
1353   else
1354     {
1355       if (SPEC_USIGN (val->etype))
1356         SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_uint;
1357       else
1358         SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_int;
1359
1360     }
1361   /* ANSI: result type is int, value is 0 or 1 */
1362   /* sdcc will hold this in an 'unsigned char' */
1363   SPEC_USIGN(val->etype) = 1;
1364   SPEC_LONG (val->etype) = 0;
1365   SPEC_NOUN(val->etype) = V_CHAR;
1366   return val;
1367 }
1368
1369 /*------------------------------------------------------------------*/
1370 /* valMult - multiply constants                                     */
1371 /*------------------------------------------------------------------*/
1372 value *
1373 valMult (value * lval, value * rval)
1374 {
1375   value *val;
1376
1377   /* create a new value */
1378   val = newValue ();
1379   val->type = val->etype = computeType (lval->etype,
1380                                         rval->etype,
1381                                         RESULT_TYPE_INT,
1382                                         '*');
1383   SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1384
1385   if (IS_FLOAT (val->type))
1386     SPEC_CVAL (val->type).v_float = floatFromVal (lval) * floatFromVal (rval);
1387   else
1388   if (IS_FIXED16X16 (val->type))
1389     SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble(floatFromVal (lval) * floatFromVal (rval));
1390       /* signed and unsigned mul are the same, as long as the precision of the
1391          result isn't bigger than the precision of the operands. */
1392   else if (SPEC_LONG (val->type))
1393     SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) *
1394                                     (TYPE_TARGET_ULONG) floatFromVal (rval);
1395   else if (SPEC_USIGN (val->type)) /* unsigned int */
1396     {
1397       TYPE_TARGET_ULONG ul = (TYPE_TARGET_UINT) floatFromVal (lval) *
1398                              (TYPE_TARGET_UINT) floatFromVal (rval);
1399
1400       SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ul;
1401       if (ul != (TYPE_TARGET_UINT) ul)
1402         werror (W_INT_OVL);
1403     }
1404   else /* signed int */
1405     {
1406       TYPE_TARGET_LONG l = (TYPE_TARGET_INT) floatFromVal (lval) *
1407                            (TYPE_TARGET_INT) floatFromVal (rval);
1408
1409       SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) l;
1410       if (l != (TYPE_TARGET_INT) l)
1411         werror (W_INT_OVL);
1412     }
1413   return cheapestVal (val);
1414 }
1415
1416 /*------------------------------------------------------------------*/
1417 /* valDiv  - Divide   constants                                     */
1418 /*------------------------------------------------------------------*/
1419 value *
1420 valDiv (value * lval, value * rval)
1421 {
1422   value *val;
1423
1424   if (floatFromVal (rval) == 0)
1425     {
1426       werror (E_DIVIDE_BY_ZERO);
1427       return rval;
1428     }
1429
1430   /* create a new value */
1431   val = newValue ();
1432   val->type = val->etype = computeType (lval->etype,
1433                                         rval->etype,
1434                                         RESULT_TYPE_INT,
1435                                         '/');
1436   SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1437
1438   if (IS_FLOAT (val->type))
1439     SPEC_CVAL (val->type).v_float = floatFromVal (lval) / floatFromVal (rval);
1440   else
1441   if (IS_FIXED16X16 (val->type))
1442     SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble( floatFromVal (lval) / floatFromVal (rval) );
1443   else if (SPEC_LONG (val->type))
1444     {
1445       if (SPEC_USIGN (val->type))
1446         SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) /
1447           (TYPE_TARGET_ULONG) floatFromVal (rval);
1448       else
1449         SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) /
1450           (TYPE_TARGET_LONG) floatFromVal (rval);
1451     }
1452   else
1453     {
1454       if (SPEC_USIGN (val->type))
1455         SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) /
1456           (TYPE_TARGET_UINT) floatFromVal (rval);
1457       else
1458         SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) /
1459           (TYPE_TARGET_INT) floatFromVal (rval);
1460     }
1461   return cheapestVal (val);
1462 }
1463
1464 /*------------------------------------------------------------------*/
1465 /* valMod  - Modulus  constants                                     */
1466 /*------------------------------------------------------------------*/
1467 value *
1468 valMod (value * lval, value * rval)
1469 {
1470   value *val;
1471
1472   /* create a new value */
1473   val = newValue();
1474   val->type = val->etype = computeType (lval->etype,
1475                                         rval->etype,
1476                                         RESULT_TYPE_INT,
1477                                         '%');
1478   SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1479
1480   if (SPEC_LONG (val->type))
1481     {
1482       if (SPEC_USIGN (val->type))
1483         SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) %
1484           (TYPE_TARGET_ULONG) floatFromVal (rval);
1485       else
1486         SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) %
1487           (TYPE_TARGET_LONG) floatFromVal (rval);
1488     }
1489   else
1490     {
1491       if (SPEC_USIGN (val->type))
1492         SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) %
1493           (TYPE_TARGET_UINT) floatFromVal (rval);
1494       else
1495         SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) %
1496           (TYPE_TARGET_INT) floatFromVal (rval);
1497     }
1498   return cheapestVal (val);
1499 }
1500
1501 /*------------------------------------------------------------------*/
1502 /* valPlus - Addition constants                                     */
1503 /*------------------------------------------------------------------*/
1504 value *
1505 valPlus (value * lval, value * rval)
1506 {
1507   value *val;
1508
1509   /* create a new value */
1510   val = newValue();
1511   val->type = val->etype = computeType (lval->etype,
1512                                         rval->etype,
1513                                         RESULT_TYPE_INT,
1514                                         '+');
1515   SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1516
1517   if (IS_FLOAT (val->type))
1518     SPEC_CVAL (val->type).v_float = floatFromVal (lval) + floatFromVal (rval);
1519   else
1520   if (IS_FIXED16X16 (val->type))
1521     SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble( floatFromVal (lval) + floatFromVal (rval) );
1522   else  if (SPEC_LONG (val->type))
1523     {
1524       if (SPEC_USIGN (val->type))
1525         SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) +
1526          (TYPE_TARGET_ULONG) floatFromVal (rval);
1527       else
1528         SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) +
1529           (TYPE_TARGET_LONG) floatFromVal (rval);
1530     }
1531   else
1532     {
1533       if (SPEC_USIGN (val->type))
1534         SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) +
1535           (TYPE_TARGET_UINT) floatFromVal (rval);
1536       else
1537         SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) +
1538           (TYPE_TARGET_INT) floatFromVal (rval);
1539     }
1540   return cheapestVal (val);
1541 }
1542
1543 /*------------------------------------------------------------------*/
1544 /* valMinus - Addition constants                                    */
1545 /*------------------------------------------------------------------*/
1546 value *
1547 valMinus (value * lval, value * rval)
1548 {
1549   value *val;
1550
1551   /* create a new value */
1552   val = newValue();
1553   val->type = val->etype = computeType (lval->etype,
1554                                         rval->etype,
1555                                         RESULT_TYPE_INT,
1556                                         '-');
1557   SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1558
1559   if (IS_FLOAT (val->type))
1560     SPEC_CVAL (val->type).v_float = floatFromVal (lval) - floatFromVal (rval);
1561   else
1562   if (IS_FIXED16X16 (val->type))
1563     SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble( floatFromVal (lval) - floatFromVal (rval) );
1564   else  if (SPEC_LONG (val->type))
1565     {
1566       if (SPEC_USIGN (val->type))
1567         SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) -
1568           (TYPE_TARGET_ULONG) floatFromVal (rval);
1569       else
1570         SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) -
1571           (TYPE_TARGET_LONG) floatFromVal (rval);
1572     }
1573   else
1574    {
1575      if (SPEC_USIGN (val->type))
1576        SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) -
1577          (TYPE_TARGET_UINT) floatFromVal (rval);
1578      else
1579        SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) -
1580          (TYPE_TARGET_INT) floatFromVal (rval);
1581     }
1582   return cheapestVal (val);
1583 }
1584
1585 /*------------------------------------------------------------------*/
1586 /* valShift - Shift left or right                                   */
1587 /*------------------------------------------------------------------*/
1588 value *
1589 valShift (value * lval, value * rval, int lr)
1590 {
1591   value *val;
1592
1593   /* create a new value */
1594   val = newValue();
1595   val->type = val->etype = computeType (lval->etype,
1596                                         NULL,
1597                                         RESULT_TYPE_INT,
1598                                         'S');
1599   SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1600
1601   if (getSize (val->type) * 8 <= (TYPE_TARGET_ULONG) floatFromVal (rval) &&
1602        /* left shift */
1603       (lr ||
1604         /* right shift and unsigned */
1605        (!lr && SPEC_USIGN (rval->type))))
1606     {
1607       werror (W_SHIFT_CHANGED, (lr ? "left" : "right"));
1608     }
1609
1610   if (SPEC_LONG (val->type))
1611     {
1612       if (SPEC_USIGN (val->type))
1613         {
1614           SPEC_CVAL (val->type).v_ulong = lr ?
1615             (TYPE_TARGET_ULONG) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \
1616             (TYPE_TARGET_ULONG) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval);
1617         }
1618       else
1619         {
1620           SPEC_CVAL (val->type).v_long = lr ?
1621             (TYPE_TARGET_LONG) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \
1622             (TYPE_TARGET_LONG) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval);
1623         }
1624     }
1625   else
1626     {
1627       if (SPEC_USIGN (val->type))
1628         {
1629           SPEC_CVAL (val->type).v_uint = lr ?
1630             (TYPE_TARGET_UINT) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \
1631             (TYPE_TARGET_UINT) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval);
1632         }
1633       else
1634         {
1635           SPEC_CVAL (val->type).v_int = lr ?
1636             (TYPE_TARGET_INT) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \
1637             (TYPE_TARGET_INT) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval);
1638         }
1639     }
1640   return cheapestVal (val);
1641 }
1642
1643 /*------------------------------------------------------------------*/
1644 /* valCompare- Compares two literal                                 */
1645 /*------------------------------------------------------------------*/
1646 value *
1647 valCompare (value * lval, value * rval, int ctype)
1648 {
1649   value *val;
1650
1651   /* create a new value */
1652   val = newValue ();
1653   val->type = val->etype = newCharLink ();
1654   val->type->class = SPECIFIER;
1655   SPEC_NOUN (val->type) = V_CHAR;       /* type is char */
1656   SPEC_USIGN (val->type) = 1;
1657   SPEC_SCLS (val->type) = S_LITERAL;    /* will remain literal */
1658
1659   switch (ctype)
1660     {
1661     case '<':
1662       SPEC_CVAL (val->type).v_int = floatFromVal (lval) < floatFromVal (rval);
1663       break;
1664
1665     case '>':
1666       SPEC_CVAL (val->type).v_int = floatFromVal (lval) > floatFromVal (rval);
1667       break;
1668
1669     case LE_OP:
1670       SPEC_CVAL (val->type).v_int = floatFromVal (lval) <= floatFromVal (rval);
1671       break;
1672
1673     case GE_OP:
1674       SPEC_CVAL (val->type).v_int = floatFromVal (lval) >= floatFromVal (rval);
1675       break;
1676
1677     case EQ_OP:
1678       if (SPEC_NOUN(lval->type) == V_FLOAT ||
1679           SPEC_NOUN(rval->type) == V_FLOAT)
1680         {
1681           SPEC_CVAL (val->type).v_int = floatFromVal (lval) == floatFromVal (rval);
1682         }
1683       else
1684       if (SPEC_NOUN(lval->type) == V_FIXED16X16 ||
1685           SPEC_NOUN(rval->type) == V_FIXED16X16)
1686         {
1687           SPEC_CVAL (val->type).v_int = floatFromVal (lval) == floatFromVal (rval);
1688         }
1689       else
1690         {
1691           /* integrals: ignore signedness */
1692           TYPE_TARGET_ULONG l, r;
1693
1694           l = (TYPE_TARGET_ULONG) floatFromVal (lval);
1695           r = (TYPE_TARGET_ULONG) floatFromVal (rval);
1696           /* In order to correctly compare 'signed int' and 'unsigned int' it's
1697              neccessary to strip them to 16 bit.
1698              Literals are reduced to their cheapest type, therefore left and
1699              right might have different types. It's neccessary to find a
1700              common type: int (used for char too) or long */
1701           if (!IS_LONG (lval->etype) &&
1702               !IS_LONG (rval->etype))
1703             {
1704               r = (TYPE_TARGET_UINT) r;
1705               l = (TYPE_TARGET_UINT) l;
1706             }
1707           SPEC_CVAL (val->type).v_int = l == r;
1708         }
1709       break;
1710     case NE_OP:
1711       if (SPEC_NOUN(lval->type) == V_FLOAT ||
1712           SPEC_NOUN(rval->type) == V_FLOAT)
1713         {
1714           SPEC_CVAL (val->type).v_int = floatFromVal (lval) != floatFromVal (rval);
1715         }
1716       else
1717       if (SPEC_NOUN(lval->type) == V_FIXED16X16 ||
1718           SPEC_NOUN(rval->type) == V_FIXED16X16)
1719         {
1720           SPEC_CVAL (val->type).v_int = floatFromVal (lval) != floatFromVal (rval);
1721         }
1722       else
1723         {
1724           /* integrals: ignore signedness */
1725           TYPE_TARGET_ULONG l, r;
1726
1727           l = (TYPE_TARGET_ULONG) floatFromVal (lval);
1728           r = (TYPE_TARGET_ULONG) floatFromVal (rval);
1729           /* In order to correctly compare 'signed int' and 'unsigned int' it's
1730              neccessary to strip them to 16 bit.
1731              Literals are reduced to their cheapest type, therefore left and
1732              right might have different types. It's neccessary to find a
1733              common type: int (used for char too) or long */
1734           if (!IS_LONG (lval->etype) &&
1735               !IS_LONG (rval->etype))
1736             {
1737               r = (TYPE_TARGET_UINT) r;
1738               l = (TYPE_TARGET_UINT) l;
1739             }
1740           SPEC_CVAL (val->type).v_int = l != r;
1741         }
1742       break;
1743
1744     }
1745
1746   return val;
1747 }
1748
1749 /*------------------------------------------------------------------*/
1750 /* valBitwise - Bitwise operation                                   */
1751 /*------------------------------------------------------------------*/
1752 value *
1753 valBitwise (value * lval, value * rval, int op)
1754 {
1755   value *val;
1756
1757   /* create a new value */
1758   val = newValue ();
1759   val->type = computeType (lval->etype, rval->etype, RESULT_TYPE_CHAR, op);
1760   val->etype = getSpec (val->type);
1761   SPEC_SCLS (val->etype) = S_LITERAL;
1762
1763   switch (op)
1764     {
1765     case '&':
1766       if (SPEC_LONG (val->type))
1767         {
1768           if (SPEC_USIGN (val->type))
1769             SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) &
1770               (TYPE_TARGET_ULONG) floatFromVal (rval);
1771           else
1772             SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) &
1773               (TYPE_TARGET_LONG) floatFromVal (rval);
1774         }
1775       else
1776         {
1777           if (SPEC_USIGN (val->type))
1778             SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) &
1779               (TYPE_TARGET_UINT) floatFromVal (rval);
1780           else
1781             SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) &
1782               (TYPE_TARGET_INT) floatFromVal (rval);
1783         }
1784       break;
1785
1786     case '|':
1787       if (SPEC_LONG (val->type))
1788         {
1789           if (SPEC_USIGN (val->type))
1790             SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) |
1791               (TYPE_TARGET_ULONG) floatFromVal (rval);
1792           else
1793             SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) |
1794               (TYPE_TARGET_LONG) floatFromVal (rval);
1795         }
1796       else
1797         {
1798           if (SPEC_USIGN (val->type))
1799             SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) |
1800               (TYPE_TARGET_UINT) floatFromVal (rval);
1801           else
1802             SPEC_CVAL (val->type).v_int =
1803               (TYPE_TARGET_INT) floatFromVal (lval) | (TYPE_TARGET_INT) floatFromVal (rval);
1804         }
1805
1806       break;
1807
1808     case '^':
1809       if (SPEC_LONG (val->type))
1810         {
1811           if (SPEC_USIGN (val->type))
1812             SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) ^
1813               (TYPE_TARGET_ULONG) floatFromVal (rval);
1814           else
1815             SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) ^
1816               (TYPE_TARGET_LONG) floatFromVal (rval);
1817         }
1818       else
1819         {
1820           if (SPEC_USIGN (val->type))
1821             SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) ^
1822               (TYPE_TARGET_UINT) floatFromVal (rval);
1823           else
1824             SPEC_CVAL (val->type).v_int =
1825               (TYPE_TARGET_INT) floatFromVal (lval) ^ (TYPE_TARGET_INT) floatFromVal (rval);
1826         }
1827       break;
1828     }
1829
1830   return cheapestVal(val);
1831 }
1832
1833 /*------------------------------------------------------------------*/
1834 /* valAndOr   - Generates code for and / or operation               */
1835 /*------------------------------------------------------------------*/
1836 value *
1837 valLogicAndOr (value * lval, value * rval, int op)
1838 {
1839   value *val;
1840
1841   /* create a new value */
1842   val = newValue ();
1843   val->type = val->etype = newCharLink ();
1844   val->type->class = SPECIFIER;
1845   SPEC_SCLS (val->type) = S_LITERAL;    /* will remain literal */
1846   SPEC_USIGN (val->type) = 1;
1847
1848   switch (op)
1849     {
1850     case AND_OP:
1851       SPEC_CVAL (val->type).v_int = floatFromVal (lval) && floatFromVal (rval);
1852       break;
1853
1854     case OR_OP:
1855       SPEC_CVAL (val->type).v_int = floatFromVal (lval) || floatFromVal (rval);
1856       break;
1857     }
1858
1859
1860   return val;
1861 }
1862
1863 /*------------------------------------------------------------------*/
1864 /* valCastLiteral - casts a literal value to another type           */
1865 /*------------------------------------------------------------------*/
1866 value *
1867 valCastLiteral (sym_link * dtype, double fval)
1868 {
1869   value *val;
1870   TYPE_TARGET_ULONG l = (TYPE_TARGET_ULONG)fval;
1871
1872   if (!dtype)
1873     return NULL;
1874
1875   val = newValue ();
1876   if (dtype)
1877     val->etype = getSpec (val->type = copyLinkChain (dtype));
1878   else
1879     {
1880       val->etype = val->type = newLink (SPECIFIER);
1881       SPEC_NOUN (val->etype) = V_VOID;
1882     }
1883   SPEC_SCLS (val->etype) = S_LITERAL;
1884
1885   /* if it is not a specifier then we can assume that */
1886   /* it will be an unsigned long                      */
1887   if (!IS_SPEC (val->type)) {
1888       SPEC_CVAL (val->etype).v_ulong = l;
1889       return val;
1890   }
1891
1892   if (SPEC_NOUN (val->etype) == V_FLOAT)
1893       SPEC_CVAL (val->etype).v_float = fval;
1894   else if (SPEC_NOUN (val->etype) == V_FIXED16X16)
1895       SPEC_CVAL (val->etype).v_fixed16x16 = fixed16x16FromDouble( fval );
1896   else if (SPEC_NOUN (val->etype) == V_BIT ||
1897            SPEC_NOUN (val->etype) == V_SBIT)
1898     SPEC_CVAL (val->etype).v_uint = l ? 1 : 0;
1899   else if (SPEC_NOUN (val->etype) == V_BITFIELD)
1900     SPEC_CVAL (val->etype).v_uint = l &
1901                                     (0xffffu >> (16 - SPEC_BLEN (val->etype)));
1902   else if (SPEC_NOUN (val->etype) == V_CHAR) {
1903       if (SPEC_USIGN (val->etype))
1904           SPEC_CVAL (val->etype).v_uint= (TYPE_UBYTE) l;
1905       else
1906           SPEC_CVAL (val->etype).v_int = (TYPE_BYTE) l;
1907   } else {
1908       if (SPEC_LONG (val->etype)) {
1909           if (SPEC_USIGN (val->etype))
1910               SPEC_CVAL (val->etype).v_ulong = (TYPE_TARGET_ULONG) l;
1911           else
1912               SPEC_CVAL (val->etype).v_long = (TYPE_TARGET_LONG) l;
1913       } else {
1914           if (SPEC_USIGN (val->etype))
1915               SPEC_CVAL (val->etype).v_uint = (TYPE_TARGET_UINT)l;
1916           else
1917               SPEC_CVAL (val->etype).v_int = (TYPE_TARGET_INT)l;
1918       }
1919   }
1920   return val;
1921 }
1922
1923 /*------------------------------------------------------------------*/
1924 /* getNelements - determines # of elements from init list           */
1925 /*------------------------------------------------------------------*/
1926 int
1927 getNelements (sym_link * type, initList * ilist)
1928 {
1929   int i;
1930
1931   if (!ilist)
1932     return 0;
1933
1934   if (ilist->type == INIT_DEEP)
1935     ilist = ilist->init.deep;
1936
1937   /* if type is a character array and there is only one
1938      (string) initialiser then get the length of the string */
1939   if (IS_ARRAY (type) && IS_CHAR (type->next) && !ilist->next)
1940     {
1941       ast *iast = ilist->init.node;
1942       value *v = (iast->type == EX_VALUE ? iast->opval.val : NULL);
1943       if (!v)
1944         {
1945           werror (E_CONST_EXPECTED);
1946           return 0;
1947         }
1948
1949       if (IS_ARRAY (v->type) && IS_CHAR (v->etype))
1950         // yep, it's a string
1951         {
1952           return DCL_ELEM (v->type);
1953         }
1954     }
1955
1956   i = 0;
1957   while (ilist)
1958     {
1959       i++;
1960       ilist = ilist->next;
1961     }
1962   return i;
1963 }
1964
1965 /*-----------------------------------------------------------------*/
1966 /* valForArray - returns a value with name of array index          */
1967 /*-----------------------------------------------------------------*/
1968 value *
1969 valForArray (ast * arrExpr)
1970 {
1971   value *val, *lval = NULL;
1972   char buffer[128];
1973   int size = getSize (arrExpr->left->ftype->next);
1974   /* if the right or left is an array
1975      resolve it first */
1976   if (IS_AST_OP (arrExpr->left))
1977     {
1978       if (arrExpr->left->opval.op == '[')
1979         lval = valForArray (arrExpr->left);
1980       else if (arrExpr->left->opval.op == '.')
1981         lval = valForStructElem (arrExpr->left->left,
1982                                  arrExpr->left->right);
1983       else if (arrExpr->left->opval.op == PTR_OP &&
1984                IS_ADDRESS_OF_OP (arrExpr->left->left))
1985         lval = valForStructElem (arrExpr->left->left->left,
1986                                  arrExpr->left->right);
1987       else
1988         return NULL;
1989
1990     }
1991   else if (!IS_AST_SYM_VALUE (arrExpr->left))
1992     return NULL;
1993
1994   if (!IS_AST_LIT_VALUE (arrExpr->right))
1995     return NULL;
1996
1997   val = newValue ();
1998   if (!lval)
1999     {
2000         SNPRINTF (buffer, sizeof(buffer), "%s", AST_SYMBOL (arrExpr->left)->rname);
2001     }
2002   else
2003     {
2004         SNPRINTF (buffer, sizeof(buffer), "%s", lval->name);
2005     }
2006
2007   SNPRINTF (val->name, sizeof(val->name), "(%s + %d)", buffer,
2008            (int) AST_LIT_VALUE (arrExpr->right) * size);
2009
2010   val->type = newLink (DECLARATOR);
2011   if (SPEC_SCLS (arrExpr->left->etype) == S_CODE)
2012     DCL_TYPE (val->type) = CPOINTER;
2013   else if (SPEC_SCLS (arrExpr->left->etype) == S_XDATA)
2014     DCL_TYPE (val->type) = FPOINTER;
2015   else if (SPEC_SCLS (arrExpr->left->etype) == S_XSTACK)
2016     DCL_TYPE (val->type) = PPOINTER;
2017   else if (SPEC_SCLS (arrExpr->left->etype) == S_IDATA)
2018     DCL_TYPE (val->type) = IPOINTER;
2019   else if (SPEC_SCLS (arrExpr->left->etype) == S_EEPROM)
2020     DCL_TYPE (val->type) = EEPPOINTER;
2021   else
2022     DCL_TYPE (val->type) = POINTER;
2023   val->type->next = arrExpr->left->ftype->next;
2024   val->etype = getSpec (val->type);
2025   return val;
2026 }
2027
2028 /*-----------------------------------------------------------------*/
2029 /* valForStructElem - returns value with name of struct element    */
2030 /*-----------------------------------------------------------------*/
2031 value *
2032 valForStructElem (ast * structT, ast * elemT)
2033 {
2034   value *val, *lval = NULL;
2035   char buffer[128];
2036   symbol *sym;
2037
2038   /* left could be furthur derefed */
2039   if (IS_AST_OP (structT))
2040     {
2041       if (structT->opval.op == '[')
2042         lval = valForArray (structT);
2043       else if (structT->opval.op == '.')
2044         lval = valForStructElem (structT->left, structT->right);
2045       else if (structT->opval.op == PTR_OP &&
2046                IS_ADDRESS_OF_OP (structT->left))
2047         lval = valForStructElem (structT->left->left,
2048                                  structT->right);
2049       else
2050         return NULL;
2051     }
2052
2053   if (!IS_AST_SYM_VALUE (elemT))
2054     return NULL;
2055
2056   if (!IS_STRUCT (structT->etype))
2057     return NULL;
2058
2059   if ((sym = getStructElement (SPEC_STRUCT (structT->etype),
2060                                AST_SYMBOL (elemT))) == NULL)
2061     {
2062       return NULL;
2063     }
2064
2065   val = newValue ();
2066   if (!lval)
2067     {
2068         SNPRINTF(buffer, sizeof(buffer), "%s", AST_SYMBOL (structT)->rname);
2069     }
2070   else
2071     {
2072         SNPRINTF (buffer, sizeof(buffer), "%s", lval->name);
2073     }
2074
2075   SNPRINTF (val->name, sizeof(val->name), "(%s + %d)", buffer,
2076            (int) sym->offset);
2077
2078   val->type = newLink (DECLARATOR);
2079   if (SPEC_SCLS (structT->etype) == S_CODE)
2080     DCL_TYPE (val->type) = CPOINTER;
2081   else if (SPEC_SCLS (structT->etype) == S_XDATA)
2082     DCL_TYPE (val->type) = FPOINTER;
2083   else if (SPEC_SCLS (structT->etype) == S_XSTACK)
2084     DCL_TYPE (val->type) = PPOINTER;
2085   else if (SPEC_SCLS (structT->etype) == S_IDATA)
2086     DCL_TYPE (val->type) = IPOINTER;
2087   else if (SPEC_SCLS (structT->etype) == S_EEPROM)
2088     DCL_TYPE (val->type) = EEPPOINTER;
2089   else
2090     DCL_TYPE (val->type) = POINTER;
2091   val->type->next = sym->type;
2092   val->etype = getSpec (val->type);
2093   return val;
2094 }
2095
2096 /*-----------------------------------------------------------------*/
2097 /* valForCastAggr - will return value for a cast of an aggregate   */
2098 /*                  plus minus a constant                          */
2099 /*-----------------------------------------------------------------*/
2100 value *
2101 valForCastAggr (ast * aexpr, sym_link * type, ast * cnst, int op)
2102 {
2103   value *val;
2104
2105   if (!IS_AST_SYM_VALUE (aexpr))
2106     return NULL;
2107   if (!IS_AST_LIT_VALUE (cnst))
2108     return NULL;
2109
2110   val = newValue ();
2111
2112   SNPRINTF (val->name, sizeof(val->name), "(%s %c %d)",
2113            AST_SYMBOL (aexpr)->rname, op,
2114            getSize (type->next) * (int) AST_LIT_VALUE (cnst));
2115
2116   val->type = type;
2117   val->etype = getSpec (val->type);
2118   return val;
2119 }
2120
2121 /*-----------------------------------------------------------------*/
2122 /* valForCastAggr - will return value for a cast of an aggregate   */
2123 /*                  with no constant                               */
2124 /*-----------------------------------------------------------------*/
2125 value *
2126 valForCastArr (ast * aexpr, sym_link * type)
2127 {
2128   value *val;
2129
2130   if (!IS_AST_SYM_VALUE (aexpr))
2131     return NULL;
2132
2133   val = newValue ();
2134
2135   SNPRINTF (val->name, sizeof(val->name), "(%s)",
2136            AST_SYMBOL (aexpr)->rname);
2137
2138   val->type = type;
2139   val->etype = getSpec (val->type);
2140   return val;
2141 }