git.gag.com Git - fw/sdcc/blob - src/SDCCval.c

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