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