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