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

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