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