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