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