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