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 "newalloc.h"
  31
  32 int cNestLevel;
  33
  34 /*-----------------------------------------------------------------*/
  35 /* newValue - allocates and returns a new value        */
  36 /*-----------------------------------------------------------------*/
  37 value *
  38 newValue ()
  39 {
  40   value *val;
  41
  42   val = Safe_alloc (sizeof (value));
  43
  44   return val;
  45 }
  46
  47 /*-----------------------------------------------------------------*/
  48 /* newiList - new initializer list                                 */
  49 /*-----------------------------------------------------------------*/
  50 initList *
  51 newiList (int type, void *ilist)
  52 {
  53   initList *nilist;
  54
  55
  56   nilist = Safe_alloc (sizeof (initList));
  57
  58   nilist->type = type;
  59   nilist->lineno = yylineno;
  60
  61   switch (type)
  62     {
  63     case INIT_NODE:
  64       nilist->init.node = (struct ast *) ilist;
  65       break;
  66
  67     case INIT_DEEP:
  68       nilist->init.deep = (struct initList *) ilist;
  69       break;
  70     }
  71
  72   return nilist;
  73 }
  74
  75 /*------------------------------------------------------------------*/
  76 /* revinit   - reverses the initial values for a value  chain        */
  77 /*------------------------------------------------------------------*/
  78 initList *
  79 revinit (initList * val)
  80 {
  81   initList *prev, *curr, *next;
  82
  83   if (!val)
  84     return NULL;
  85
  86   prev = val;
  87   curr = val->next;
  88
  89   while (curr)
  90     {
  91       next = curr->next;
  92       curr->next = prev;
  93       prev = curr;
  94       curr = next;
  95     }
  96   val->next = (void *) NULL;
  97   return prev;
  98 }
  99
 100 bool
 101 convertIListToConstList(initList *src, literalList **lList)
 102 {
 103     initList    *iLoop;
 104     literalList *head, *last, *newL;
 105
 106     head = last = NULL;
 107
 108     if (!src || src->type != INIT_DEEP)
 109     {
 110         return FALSE;
 111     }
 112
 113     iLoop =  src->init.deep;
 114
 115     while (iLoop)
 116     {
 117         if (iLoop->type != INIT_NODE)
 118         {
 119             return FALSE;
 120         }
 121
 122         if (!IS_AST_LIT_VALUE(decorateType(resolveSymbols(iLoop->init.node))))
 123         {
 124             return FALSE;
 125         }
 126         iLoop = iLoop->next;
 127     }
 128
 129     // We've now established that the initializer list contains only literal values.
 130
 131     iLoop = src->init.deep;
 132     while (iLoop)
 133     {
 134         double val = AST_LIT_VALUE(iLoop->init.node);
 135
 136         if (last && last->literalValue == val)
 137         {
 138             last->count++;
 139         }
 140         else
 141         {
 142             newL = Safe_alloc(sizeof(literalList));
 143             newL->literalValue = val;
 144             newL->count = 1;
 145             newL->next = NULL;
 146
 147             if (last)
 148             {
 149                 last->next = newL;
 150             }
 151             else
 152             {
 153                 head = newL;
 154             }
 155             last = newL;
 156         }
 157         iLoop = iLoop->next;
 158     }
 159
 160     if (!head)
 161     {
 162         return FALSE;
 163     }
 164
 165     *lList = head;
 166     return TRUE;
 167 }
 168
 169 literalList *
 170 copyLiteralList(literalList *src)
 171 {
 172     literalList *head, *prev, *newL;
 173
 174     head = prev = NULL;
 175
 176     while (src)
 177     {
 178         newL = Safe_alloc(sizeof(literalList));
 179
 180         newL->literalValue = src->literalValue;
 181         newL->count = src->count;
 182         newL->next = NULL;
 183
 184         if (prev)
 185         {
 186             prev->next = newL;
 187         }
 188         else
 189         {
 190             head = newL;
 191         }
 192         prev = newL;
 193         src = src->next;
 194     }
 195
 196     return head;
 197 }
 198
 199
 200
 201 /*------------------------------------------------------------------*/
 202 /* copyIlist - copy initializer list            */
 203 /*------------------------------------------------------------------*/
 204 initList *
 205 copyIlist (initList * src)
 206 {
 207   initList *dest = NULL;
 208
 209   if (!src)
 210     return NULL;
 211
 212   switch (src->type)
 213     {
 214     case INIT_DEEP:
 215       dest = newiList (INIT_DEEP, copyIlist (src->init.deep));
 216       break;
 217     case INIT_NODE:
 218       dest = newiList (INIT_NODE, copyAst (src->init.node));
 219       break;
 220     }
 221
 222   if (src->next)
 223     dest->next = copyIlist (src->next);
 224
 225   return dest;
 226 }
 227
 228 /*------------------------------------------------------------------*/
 229 /* list2int - converts the first element of the list to value       */
 230 /*------------------------------------------------------------------*/
 231 double
 232 list2int (initList * val)
 233 {
 234   initList *i = val;
 235
 236   if (i->type == INIT_DEEP)
 237     return list2int (val->init.deep);
 238
 239   return floatFromVal (constExprValue (val->init.node, TRUE));
 240 }
 241
 242 /*------------------------------------------------------------------*/
 243 /* list2val - converts the first element of the list to value       */
 244 /*------------------------------------------------------------------*/
 245 value *
 246 list2val (initList * val)
 247 {
 248   if (!val)
 249     return NULL;
 250
 251   if (val->type == INIT_DEEP)
 252     return list2val (val->init.deep);
 253
 254   return constExprValue (val->init.node, TRUE);
 255 }
 256
 257 /*------------------------------------------------------------------*/
 258 /* list2expr - returns the first expression in the initializer list */
 259 /*------------------------------------------------------------------*/
 260 ast *
 261 list2expr (initList * ilist)
 262 {
 263   if (ilist->type == INIT_DEEP)
 264     return list2expr (ilist->init.deep);
 265   return ilist->init.node;
 266 }
 267
 268 /*------------------------------------------------------------------*/
 269 /* resolveIvalSym - resolve symbols in initial values               */
 270 /*------------------------------------------------------------------*/
 271 void
 272 resolveIvalSym (initList * ilist)
 273 {
 274   if (!ilist)
 275     return;
 276
 277   if (ilist->type == INIT_NODE)
 278     ilist->init.node = decorateType (resolveSymbols (ilist->init.node));
 279
 280   if (ilist->type == INIT_DEEP)
 281     resolveIvalSym (ilist->init.deep);
 282
 283   resolveIvalSym (ilist->next);
 284 }
 285
 286 /*-----------------------------------------------------------------*/
 287 /* symbolVal - creates a value for a symbol              */
 288 /*-----------------------------------------------------------------*/
 289 value *
 290 symbolVal (symbol * sym)
 291 {
 292   value *val;
 293
 294   if (!sym)
 295     return NULL;
 296
 297   val = newValue ();
 298   val->sym = sym;
 299
 300   if (sym->type)
 301     {
 302       val->type = sym->type;
 303       val->etype = getSpec (val->type);
 304     }
 305
 306   if (*sym->rname)
 307     sprintf (val->name, "%s", sym->rname);
 308   else
 309     sprintf (val->name, "_%s", sym->name);
 310
 311
 312   return val;
 313 }
 314
 315 /*--------------------------------------------------------------------*/
 316 /* cheapestVal - convert a val to the cheapest as possible value      */
 317 /*--------------------------------------------------------------------*/
 318 value *cheapestVal (value *val) {
 319   long sval=0;
 320   unsigned long uval=0;
 321
 322   if (IS_FLOAT(val->type) || IS_CHAR(val->type))
 323     return val;
 324
 325   if (SPEC_LONG(val->type)) {
 326     if (SPEC_USIGN(val->type)) {
 327       uval=SPEC_CVAL(val->type).v_ulong;
 328     } else {
 329       sval=SPEC_CVAL(val->type).v_long;
 330     }
 331   } else {
 332     if (SPEC_USIGN(val->type)) {
 333       uval=SPEC_CVAL(val->type).v_uint;
 334     } else {
 335       sval=SPEC_CVAL(val->type).v_int;
 336     }
 337   }
 338
 339   if (SPEC_USIGN(val->type)) {
 340     if (uval<=0xffff) {
 341       SPEC_LONG(val->type)=0;
 342       SPEC_CVAL(val->type).v_uint = uval;
 343       if (uval<=0xff) {
 344         SPEC_NOUN(val->type)=V_CHAR;
 345       }
 346     }
 347   } else { // not unsigned
 348     if (sval<0) {
 349       if (sval>=-32768) {
 350         SPEC_LONG(val->type)=0;
 351         SPEC_CVAL(val->type).v_int = sval;
 352         if (sval>=-128) {
 353           SPEC_NOUN(val->type)=V_CHAR;
 354         }
 355       }
 356     } else { // sval>=0
 357       SPEC_USIGN(val->type)=1;
 358       if (sval<=65535) {
 359         SPEC_LONG(val->type)=0;
 360         SPEC_CVAL(val->type).v_int = sval;
 361         if (sval<=255) {
 362           SPEC_NOUN(val->type)=V_CHAR;
 363         }
 364       }
 365     }
 366   }
 367   return val;
 368 }
 369
 370 /*-----------------------------------------------------------------*/
 371 /* valueFromLit - creates a value from a literal                   */
 372 /*-----------------------------------------------------------------*/
 373 value *
 374 valueFromLit (double lit)
 375 {
 376   char buffer[50];
 377
 378   if ((((long) lit) - lit) == 0)
 379     {
 380       sprintf (buffer, "%ld", (long) lit);
 381       return constVal (buffer);
 382     }
 383
 384   sprintf (buffer, "%f", lit);
 385   return constFloatVal (buffer);
 386 }
 387
 388 /*-----------------------------------------------------------------*/
 389 /* constFloatVal - converts a FLOAT constant to value              */
 390 /*-----------------------------------------------------------------*/
 391 value *
 392 constFloatVal (char *s)
 393 {
 394   value *val = newValue ();
 395   double sval;
 396
 397   if (sscanf (s, "%lf", &sval) != 1)
 398     {
 399       werror (E_INVALID_FLOAT_CONST, s);
 400       return constVal ("0");
 401     }
 402
 403   val->type = val->etype = newLink ();
 404   val->type->class = SPECIFIER;
 405   SPEC_NOUN (val->type) = V_FLOAT;
 406   SPEC_SCLS (val->type) = S_LITERAL;
 407   SPEC_CVAL (val->type).v_float = sval;
 408
 409   return val;
 410 }
 411
 412 /*-----------------------------------------------------------------*/
 413 /* constVal - converts an INTEGER constant into a cheapest value   */
 414 /*-----------------------------------------------------------------*/
 415 value *constVal (char *s)
 416 {
 417   value *val;
 418   short hex = 0, octal = 0;
 419   char scanFmt[10];
 420   int scI = 0;
 421   double dval;
 422
 423   val = newValue ();            /* alloc space for value   */
 424
 425   val->type = val->etype = newLink ();  /* create the spcifier */
 426   val->type->class = SPECIFIER;
 427   SPEC_SCLS (val->type) = S_LITERAL;
 428   // let's start with an unsigned char
 429   SPEC_NOUN (val->type) = V_CHAR;
 430   SPEC_USIGN (val->type) = 1;
 431
 432   hex = ((strchr (s, 'x') || strchr (s, 'X')) ? 1 : 0);
 433
 434   /* set the octal flag   */
 435   if (!hex && *s == '0' && *(s + 1))
 436     octal = 1;
 437
 438   /* create the scan string */
 439   scanFmt[scI++] = '%';
 440
 441   scanFmt[scI++] = 'l';
 442
 443   if (octal)
 444     scanFmt[scI++] = 'o';
 445   else if (hex)
 446     scanFmt[scI++] = 'x';
 447   else
 448     scanFmt[scI++] = 'f';
 449
 450   scanFmt[scI++] = '\0';
 451
 452   if (octal || hex) {
 453     unsigned long sval;
 454     sscanf (s, scanFmt, &sval);
 455     dval=sval;
 456   } else {
 457     sscanf (s, scanFmt, &dval);
 458   }
 459
 460   /* Setup the flags first */
 461   /* set the _long flag if 'lL' is found */
 462   if (strchr (s, 'l') || strchr (s, 'L')) {
 463     SPEC_NOUN (val->type) = V_INT;
 464     SPEC_LONG (val->type) = 1;
 465   }
 466
 467   if (dval<0) { // "-28u" will still be signed and negative
 468     SPEC_USIGN (val->type) = 0;
 469     if (dval<-128) { // check if we have to promote to int
 470       SPEC_NOUN (val->type) = V_INT;
 471     }
 472     if (dval<-32768) { // check if we have to promote to long int
 473       SPEC_LONG (val->type) = 1;
 474     }
 475   } else { // >=0
 476     if (dval>0xff) { // check if we have to promote to int
 477       SPEC_NOUN (val->type) = V_INT;
 478     }
 479     if (dval>0xffff) { // check if we have to promote to long int
 480       SPEC_LONG (val->type) = 1;
 481     }
 482   }
 483
 484   if (SPEC_LONG (val->type))
 485     {
 486       if (SPEC_USIGN (val->type))
 487         {
 488           SPEC_CVAL (val->type).v_ulong = dval;
 489         }
 490       else
 491         {
 492           SPEC_CVAL (val->type).v_long = dval;
 493         }
 494     }
 495   else
 496     {
 497       if (SPEC_USIGN (val->type))
 498         {
 499           SPEC_CVAL (val->type).v_uint = dval;
 500         }
 501       else
 502         {
 503           SPEC_CVAL (val->type).v_int = dval;
 504         }
 505     }
 506
 507   return val;
 508 }
 509
 510 /*! /fn char hexEscape(char **src)
 511
 512     /param src Pointer to 'x' from start of hex character value
 513 */
 514
 515 unsigned char hexEscape(char **src)
 516 {
 517   char *s ;
 518   unsigned long value ;
 519
 520   (*src)++ ;    /* Skip over the 'x' */
 521   s = *src ;    /* Save for error detection */
 522
 523   value = strtol (*src, src, 16);
 524
 525   if (s == *src) {
 526       // no valid hex found
 527       werror(E_INVALID_HEX);
 528   } else {
 529     if (value > 255) {
 530       werror(W_ESC_SEQ_OOR_FOR_CHAR);
 531     }
 532   }
 533   return (char) value;
 534 }
 535
 536 /*------------------------------------------------------------------*/
 537 /* octalEscape - process an octal constant of max three digits      */
 538 /* return the octal value, throw a warning for illegal octal        */
 539 /* adjust src to point at the last proccesed char                   */
 540 /*------------------------------------------------------------------*/
 541
 542 unsigned char octalEscape (char **str) {
 543   int digits;
 544   unsigned value=0;
 545
 546   for (digits=0; digits<3; digits++) {
 547     if (**str>='0' && **str<='7') {
 548       value = value*8 + (**str-'0');
 549       (*str)++;
 550     } else {
 551       break;
 552     }
 553   }
 554   if (digits) {
 555     if (value > 255 /* || (**str>='0' && **str<='7') */ ) {
 556       werror (W_ESC_SEQ_OOR_FOR_CHAR);
 557     }
 558   }
 559   return value;
 560 }
 561
 562 /*!
 563   /fn int copyStr (char *dest, char *src)
 564
 565   Copies a source string to a dest buffer interpreting escape sequences
 566   and special characters
 567
 568   /param dest Buffer to receive the resultant string
 569   /param src  Buffer containing the source string with escape sequecnes
 570   /return Number of characters in output string
 571
 572 */
 573
 574 int
 575 copyStr (char *dest, char *src)
 576
 577 {
 578   char *OriginalDest = dest ;
 579
 580   while (*src)
 581     {
 582       if (*src == '\"')
 583         src++;
 584       else if (*src == '\\')
 585         {
 586           src++;
 587           switch (*src)
 588             {
 589             case 'n':
 590               *dest++ = '\n';
 591               break;
 592             case 't':
 593               *dest++ = '\t';
 594               break;
 595             case 'v':
 596               *dest++ = '\v';
 597               break;
 598             case 'b':
 599               *dest++ = '\b';
 600               break;
 601             case 'r':
 602               *dest++ = '\r';
 603               break;
 604             case 'f':
 605               *dest++ = '\f';
 606               break;
 607             case 'a':
 608               *dest++ = '\a';
 609               break;
 610
 611             case '0':
 612             case '1':
 613             case '2':
 614             case '3':
 615             case '4':
 616             case '5':
 617             case '6':
 618             case '7':
 619               *dest++ = octalEscape(&src);
 620               src-- ;
 621               break;
 622
 623             case 'x':
 624               *dest++ = hexEscape(&src) ;
 625               src-- ;
 626               break ;
 627
 628             case '\\':
 629               *dest++ = '\\';
 630               break;
 631             case '\?':
 632               *dest++ = '\?';
 633               break;
 634             case '\'':
 635               *dest++ = '\'';
 636               break;
 637             case '\"':
 638               *dest++ = '\"';
 639               break;
 640             default:
 641               *dest++ = *src;
 642             }
 643           src++;
 644         }
 645       else
 646         *dest++ = *src++;
 647     }
 648
 649   *dest++ = '\0';
 650
 651   return dest - OriginalDest ;
 652 }
 653
 654 /*------------------------------------------------------------------*/
 655 /* strVal - converts a string constant to a value       */
 656 /*------------------------------------------------------------------*/
 657 value *
 658 strVal (char *s)
 659 {
 660   value *val;
 661
 662   val = newValue ();            /* get a new one */
 663
 664   /* get a declarator */
 665   val->type = newLink ();
 666   DCL_TYPE (val->type) = ARRAY;
 667   val->type->next = val->etype = newLink ();
 668   val->etype->class = SPECIFIER;
 669   SPEC_NOUN (val->etype) = V_CHAR;
 670   SPEC_SCLS (val->etype) = S_LITERAL;
 671
 672   SPEC_CVAL (val->etype).v_char = Safe_alloc (strlen (s) + 1);
 673   DCL_ELEM (val->type) = copyStr (SPEC_CVAL (val->etype).v_char, s);
 674
 675   return val;
 676 }
 677
 678
 679 /*------------------------------------------------------------------*/
 680 /* reverseValWithType - reverses value chain with type & etype      */
 681 /*------------------------------------------------------------------*/
 682 value *
 683 reverseValWithType (value * val)
 684 {
 685   sym_link *type;
 686   sym_link *etype;
 687
 688   if (!val)
 689     return NULL;
 690
 691   /* save the type * etype chains */
 692   type = val->type;
 693   etype = val->etype;
 694
 695   /* set the current one 2b null */
 696   val->type = val->etype = NULL;
 697   val = reverseVal (val);
 698
 699   /* restore type & etype */
 700   val->type = type;
 701   val->etype = etype;
 702
 703   return val;
 704 }
 705
 706 /*------------------------------------------------------------------*/
 707 /* reverseVal - reverses the values for a value  chain        */
 708 /*------------------------------------------------------------------*/
 709 value *
 710 reverseVal (value * val)
 711 {
 712   value *prev, *curr, *next;
 713
 714   if (!val)
 715     return NULL;
 716
 717   prev = val;
 718   curr = val->next;
 719
 720   while (curr)
 721     {
 722       next = curr->next;
 723       curr->next = prev;
 724       prev = curr;
 725       curr = next;
 726     }
 727   val->next = (void *) NULL;
 728   return prev;
 729 }
 730
 731 /*------------------------------------------------------------------*/
 732 /* copyValueChain - will copy a chain of values                     */
 733 /*------------------------------------------------------------------*/
 734 value *
 735 copyValueChain (value * src)
 736 {
 737   value *dest;
 738
 739   if (!src)
 740     return NULL;
 741
 742   dest = copyValue (src);
 743   dest->next = copyValueChain (src->next);
 744
 745   return dest;
 746 }
 747
 748 /*------------------------------------------------------------------*/
 749 /* copyValue - copies contents of a value to a fresh one            */
 750 /*------------------------------------------------------------------*/
 751 value *
 752 copyValue (value * src)
 753 {
 754   value *dest;
 755
 756   dest = newValue ();
 757   dest->sym = copySymbol (src->sym);
 758   strcpy (dest->name, src->name);
 759   dest->type = (src->type ? copyLinkChain (src->type) : NULL);
 760   dest->etype = (src->type ? getSpec (dest->type) : NULL);
 761
 762   return dest;
 763 }
 764
 765 /*------------------------------------------------------------------*/
 766 /* charVal - converts a character constant to a value       */
 767 /*------------------------------------------------------------------*/
 768 value *
 769 charVal (char *s)
 770 {
 771   value *val;
 772 //  unsigned uValue ;
 773
 774   val = newValue ();
 775
 776   val->type = val->etype = newLink ();
 777   val->type->class = SPECIFIER;
 778   SPEC_NOUN (val->type) = V_CHAR;
 779   SPEC_USIGN(val->type) = 1;
 780   SPEC_SCLS (val->type) = S_LITERAL;
 781
 782   s++;                          /* get rid of quotation */
 783   /* if \ then special processing */
 784   if (*s == '\\')
 785     {
 786       s++;                      /* go beyond the backslash  */
 787       switch (*s)
 788         {
 789         case 'n':
 790           SPEC_CVAL (val->type).v_int = '\n';
 791           break;
 792         case 't':
 793           SPEC_CVAL (val->type).v_int = '\t';
 794           break;
 795         case 'v':
 796           SPEC_CVAL (val->type).v_int = '\v';
 797           break;
 798         case 'b':
 799           SPEC_CVAL (val->type).v_int = '\b';
 800           break;
 801         case 'r':
 802           SPEC_CVAL (val->type).v_int = '\r';
 803           break;
 804         case 'f':
 805           SPEC_CVAL (val->type).v_int = '\f';
 806           break;
 807         case 'a':
 808           SPEC_CVAL (val->type).v_int = '\a';
 809           break;
 810         case '\\':
 811           SPEC_CVAL (val->type).v_int = '\\';
 812           break;
 813         case '\?':
 814           SPEC_CVAL (val->type).v_int = '\?';
 815           break;
 816         case '\'':
 817           SPEC_CVAL (val->type).v_int = '\'';
 818           break;
 819         case '\"':
 820           SPEC_CVAL (val->type).v_int = '\"';
 821           break;
 822
 823         case '0' :
 824         case '1' :
 825         case '2' :
 826         case '3' :
 827         case '4' :
 828         case '5' :
 829         case '6' :
 830         case '7' :
 831           SPEC_CVAL (val->type).v_uint = octalEscape(&s);
 832           break;
 833
 834         case 'x':
 835           SPEC_CVAL (val->type).v_uint = hexEscape(&s) ;
 836           break;
 837
 838         default:
 839           SPEC_CVAL (val->type).v_uint = (unsigned char)*s;
 840           break;
 841         }
 842     }
 843   else                          /* not a backslash */
 844     SPEC_CVAL (val->type).v_uint = (unsigned char)*s;
 845
 846   return val;
 847 }
 848
 849 /*------------------------------------------------------------------*/
 850 /* valFromType - creates a value from type given                    */
 851 /*------------------------------------------------------------------*/
 852 value *
 853 valFromType (sym_link * type)
 854 {
 855   value *val = newValue ();
 856   val->type = copyLinkChain (type);
 857   val->etype = getSpec (val->type);
 858   return val;
 859 }
 860
 861 /*------------------------------------------------------------------*/
 862 /* floatFromVal - value to double float conversion                  */
 863 /*------------------------------------------------------------------*/
 864 double
 865 floatFromVal (value * val)
 866 {
 867   if (!val)
 868     return 0;
 869
 870   if (val->etype && SPEC_SCLS (val->etype) != S_LITERAL)
 871     {
 872       werror (E_CONST_EXPECTED, val->name);
 873       return 0;
 874     }
 875
 876   /* if it is not a specifier then we can assume that */
 877   /* it will be an unsigned long                      */
 878   if (!IS_SPEC (val->type))
 879     return (double) SPEC_CVAL (val->etype).v_ulong;
 880
 881   if (SPEC_NOUN (val->etype) == V_FLOAT)
 882     return (double) SPEC_CVAL (val->etype).v_float;
 883
 884   if (SPEC_LONG (val->etype))
 885     {
 886       if (SPEC_USIGN (val->etype))
 887         return (double) SPEC_CVAL (val->etype).v_ulong;
 888       else
 889         return (double) SPEC_CVAL (val->etype).v_long;
 890     }
 891
 892   if (SPEC_NOUN (val->etype) == V_INT) {
 893     if (SPEC_USIGN (val->etype))
 894       return (double) SPEC_CVAL (val->etype).v_uint;
 895     else
 896       return (double) SPEC_CVAL (val->etype).v_int;
 897   }
 898
 899   if (SPEC_NOUN (val->etype) == V_CHAR) {
 900     if (SPEC_USIGN (val->etype))
 901       return (double) (unsigned char)SPEC_CVAL (val->etype).v_uint;
 902     else
 903       return (double) (signed char)SPEC_CVAL (val->etype).v_int;
 904   }
 905
 906   if (IS_BITVAR(val->etype)) {
 907     return (double) SPEC_CVAL (val->etype).v_ulong;
 908   }
 909
 910   // we are lost !
 911   werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
 912           "floatFromVal: unknown value");
 913   return 0;
 914 }
 915
 916
 917 /*------------------------------------------------------------------*/
 918 /* valUnaryPM - does the unary +/- operation on a constant          */
 919 /*------------------------------------------------------------------*/
 920 value *
 921 valUnaryPM (value * val)
 922 {
 923   /* depending on type */
 924   if (SPEC_NOUN (val->etype) == V_FLOAT)
 925     SPEC_CVAL (val->etype).v_float = -1.0 * SPEC_CVAL (val->etype).v_float;
 926   else
 927     {
 928       if (SPEC_LONG (val->etype))
 929         {
 930           if (SPEC_USIGN (val->etype))
 931             SPEC_CVAL (val->etype).v_ulong = 0-SPEC_CVAL (val->etype).v_ulong;
 932           else
 933             SPEC_CVAL (val->etype).v_long = -SPEC_CVAL (val->etype).v_long;
 934         }
 935       else
 936         {
 937           if (SPEC_USIGN (val->etype))
 938             SPEC_CVAL (val->etype).v_uint = 0-SPEC_CVAL (val->etype).v_uint;
 939           else
 940             SPEC_CVAL (val->etype).v_int = -SPEC_CVAL (val->etype).v_int;
 941         }
 942     }
 943   // -(unsigned 3) now really is signed
 944   SPEC_USIGN(val->etype)=0;
 945   return val;
 946 }
 947
 948 /*------------------------------------------------------------------*/
 949 /* valueComplement - complements a constant                         */
 950 /*------------------------------------------------------------------*/
 951 value *
 952 valComplement (value * val)
 953 {
 954   /* depending on type */
 955   if (SPEC_LONG (val->etype))
 956     {
 957       if (SPEC_USIGN (val->etype))
 958         SPEC_CVAL (val->etype).v_ulong = ~SPEC_CVAL (val->etype).v_ulong;
 959       else
 960         SPEC_CVAL (val->etype).v_long = ~SPEC_CVAL (val->etype).v_long;
 961     }
 962   else
 963     {
 964       if (SPEC_USIGN (val->etype))
 965         SPEC_CVAL (val->etype).v_uint = ~SPEC_CVAL (val->etype).v_uint;
 966       else
 967         SPEC_CVAL (val->etype).v_int = ~SPEC_CVAL (val->etype).v_int;
 968     }
 969   // ~(unsigned 3) now really is signed
 970   SPEC_USIGN(val->etype)=0;
 971   return val;
 972 }
 973
 974 /*------------------------------------------------------------------*/
 975 /* valueNot - complements a constant                                */
 976 /*------------------------------------------------------------------*/
 977 value *
 978 valNot (value * val)
 979 {
 980   /* depending on type */
 981   if (SPEC_LONG (val->etype))
 982     {
 983       if (SPEC_USIGN (val->etype))
 984         SPEC_CVAL (val->etype).v_ulong = !SPEC_CVAL (val->etype).v_ulong;
 985       else
 986         SPEC_CVAL (val->etype).v_long = !SPEC_CVAL (val->etype).v_long;
 987     }
 988   else
 989     {
 990       if (SPEC_USIGN (val->etype))
 991         SPEC_CVAL (val->etype).v_uint = !SPEC_CVAL (val->etype).v_uint;
 992       else
 993         SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_int;
 994     }
 995   return val;
 996 }
 997
 998 /*------------------------------------------------------------------*/
 999 /* valMult - multiply constants                                     */
1000 /*------------------------------------------------------------------*/
1001 value *
1002 valMult (value * lval, value * rval)
1003 {
1004   value *val;
1005
1006   /* create a new value */
1007   val = newValue ();
1008   val->type = val->etype = newLink ();
1009   val->type->class = SPECIFIER;
1010   SPEC_NOUN (val->type) = (IS_FLOAT (lval->etype) ||
1011                            IS_FLOAT (rval->etype) ? V_FLOAT : V_INT);
1012   SPEC_SCLS (val->type) = S_LITERAL;    /* will remain literal */
1013   SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) & SPEC_USIGN (rval->etype));
1014   SPEC_LONG (val->type) = 1;
1015
1016   if (IS_FLOAT (val->type))
1017     SPEC_CVAL (val->type).v_float = floatFromVal (lval) * floatFromVal (rval);
1018   else
1019     {
1020       if (SPEC_LONG (val->type))
1021         {
1022           if (SPEC_USIGN (val->type))
1023             SPEC_CVAL (val->type).v_ulong = (unsigned long) floatFromVal (lval) *
1024               (unsigned long) floatFromVal (rval);
1025           else
1026             SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) *
1027               (long) floatFromVal (rval);
1028         }
1029     }
1030   return cheapestVal(val);
1031 }
1032
1033 /*------------------------------------------------------------------*/
1034 /* valDiv  - Divide   constants                                     */
1035 /*------------------------------------------------------------------*/
1036 value *
1037 valDiv (value * lval, value * rval)
1038 {
1039   value *val;
1040
1041   if (floatFromVal (rval) == 0)
1042     {
1043       werror (E_DIVIDE_BY_ZERO);
1044       return rval;
1045     }
1046
1047   /* create a new value */
1048   val = newValue ();
1049   val->type = val->etype = newLink();
1050   val->type->class = SPECIFIER;
1051   SPEC_NOUN (val->type) = (IS_FLOAT (lval->etype) ||
1052                            IS_FLOAT (rval->etype) ? V_FLOAT : V_INT);
1053   SPEC_SCLS (val->etype) = S_LITERAL;
1054   SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) & SPEC_USIGN (rval->etype));
1055   SPEC_LONG (val->type) = (SPEC_LONG (lval->etype) | SPEC_LONG (rval->etype));
1056
1057   if (IS_FLOAT (val->type))
1058     SPEC_CVAL (val->type).v_float = floatFromVal (lval) / floatFromVal (rval);
1059   else
1060     {
1061       if (SPEC_LONG (val->type))
1062         {
1063           if (SPEC_USIGN (val->type))
1064             SPEC_CVAL (val->type).v_ulong =
1065               (unsigned long) floatFromVal (lval) /
1066               (unsigned long) floatFromVal (rval);
1067           else
1068             SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) /
1069               (long) floatFromVal (rval);
1070         }
1071       else
1072         {
1073           if (SPEC_USIGN (val->type)) {
1074             SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) /
1075               (unsigned) floatFromVal (rval);
1076           } else {
1077             SPEC_CVAL (val->type).v_int = (int) floatFromVal (lval) /
1078               (int) floatFromVal (rval);
1079           }
1080         }
1081     }
1082   return cheapestVal(val);
1083 }
1084
1085 /*------------------------------------------------------------------*/
1086 /* valMod  - Modulus  constants                                     */
1087 /*------------------------------------------------------------------*/
1088 value *
1089 valMod (value * lval, value * rval)
1090 {
1091   value *val;
1092
1093   /* create a new value */
1094   val = newValue ();
1095   val->type = val->etype = newLink ();
1096   val->type->class = SPECIFIER;
1097   SPEC_NOUN (val->type) = V_INT;        /* type is int */
1098   SPEC_SCLS (val->type) = S_LITERAL;    /* will remain literal */
1099   SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) & SPEC_USIGN (rval->etype));
1100   SPEC_LONG (val->type) = (SPEC_LONG (lval->etype) | SPEC_LONG (rval->etype));
1101
1102   if (SPEC_LONG (val->type))
1103     {
1104       if (SPEC_USIGN (val->type))
1105         SPEC_CVAL (val->type).v_ulong = (unsigned long) floatFromVal (lval) %
1106           (unsigned long) floatFromVal (rval);
1107       else
1108         SPEC_CVAL (val->type).v_long = (unsigned long) floatFromVal (lval) %
1109           (unsigned long) floatFromVal (rval);
1110     }
1111   else
1112     {
1113       if (SPEC_USIGN (val->type)) {
1114         SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) %
1115           (unsigned) floatFromVal (rval);
1116       } else {
1117         SPEC_CVAL (val->type).v_int = (unsigned) floatFromVal (lval) %
1118           (unsigned) floatFromVal (rval);
1119       }
1120     }
1121
1122   return cheapestVal(val);
1123 }
1124
1125 /*------------------------------------------------------------------*/
1126 /* valPlus - Addition constants                                     */
1127 /*------------------------------------------------------------------*/
1128 value *
1129 valPlus (value * lval, value * rval)
1130 {
1131   value *val;
1132
1133   /* create a new value */
1134   val = newValue ();
1135   val->type = val->etype = newLink ();
1136   val->type->class = SPECIFIER;
1137   SPEC_NOUN (val->type) = (IS_FLOAT (lval->etype) ||
1138                            IS_FLOAT (rval->etype) ? V_FLOAT : V_INT);
1139   SPEC_SCLS (val->type) = S_LITERAL;    /* will remain literal */
1140   SPEC_USIGN (val->type) =
1141     SPEC_USIGN (lval->etype) &&
1142     SPEC_USIGN (rval->etype) &&
1143     (floatFromVal(lval)+floatFromVal(rval))>=0;
1144
1145   SPEC_LONG (val->type) = 1;
1146
1147   if (IS_FLOAT (val->type))
1148     SPEC_CVAL (val->type).v_float = floatFromVal (lval) + floatFromVal (rval);
1149   else
1150     {
1151       if (SPEC_LONG (val->type))
1152         {
1153           if (SPEC_USIGN (val->type))
1154             SPEC_CVAL (val->type).v_ulong = (unsigned long) floatFromVal (lval) +
1155               (unsigned long) floatFromVal (rval);
1156           else
1157             SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) +
1158               (long) floatFromVal (rval);
1159         }
1160     }
1161   return cheapestVal(val);
1162 }
1163
1164 /*------------------------------------------------------------------*/
1165 /* valMinus - Addition constants                                    */
1166 /*------------------------------------------------------------------*/
1167 value *
1168 valMinus (value * lval, value * rval)
1169 {
1170   value *val;
1171
1172   /* create a new value */
1173   val = newValue ();
1174   val->type = val->etype = newLink ();
1175   val->type->class = SPECIFIER;
1176   SPEC_NOUN (val->type) = (IS_FLOAT (lval->etype) ||
1177                            IS_FLOAT (rval->etype) ? V_FLOAT : V_INT);
1178   SPEC_SCLS (val->type) = S_LITERAL;    /* will remain literal */
1179   SPEC_USIGN (val->type) =
1180     SPEC_USIGN (lval->etype) &&
1181     SPEC_USIGN (rval->etype) &&
1182     (floatFromVal(lval)-floatFromVal(rval))>=0;
1183
1184   SPEC_LONG (val->type) = (SPEC_LONG (lval->etype) | SPEC_LONG (rval->etype));
1185
1186   if (IS_FLOAT (val->type))
1187     SPEC_CVAL (val->type).v_float = floatFromVal (lval) - floatFromVal (rval);
1188   else
1189     {
1190       if (SPEC_LONG (val->type))
1191         {
1192           if (SPEC_USIGN (val->type)) {
1193             SPEC_CVAL (val->type).v_ulong =
1194               (unsigned long) floatFromVal (lval) -
1195               (unsigned long) floatFromVal (rval);
1196           } else {
1197             SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) -
1198               (long) floatFromVal (rval);
1199           }
1200         }
1201       else
1202         {
1203           if (SPEC_USIGN (val->type)) {
1204             SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) -
1205               (unsigned) floatFromVal (rval);
1206           } else {
1207             SPEC_CVAL (val->type).v_int = (int) floatFromVal (lval) -
1208               (int) floatFromVal (rval);
1209           }
1210         }
1211     }
1212   return cheapestVal(val);
1213 }
1214
1215 /*------------------------------------------------------------------*/
1216 /* valShift - Shift left or right                                   */
1217 /*------------------------------------------------------------------*/
1218 value *
1219 valShift (value * lval, value * rval, int lr)
1220 {
1221   value *val;
1222
1223   /* create a new value */
1224   val = newValue ();
1225   val->type = val->etype = newIntLink ();
1226   SPEC_SCLS (val->type) = S_LITERAL;    /* will remain literal */
1227   SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) & SPEC_USIGN (rval->etype));
1228   SPEC_LONG (val->type) = 1;
1229
1230   if (SPEC_LONG (val->type))
1231     {
1232       if (SPEC_USIGN (val->type))
1233         SPEC_CVAL (val->type).v_ulong = lr ?
1234           (unsigned long) floatFromVal (lval) << (unsigned long) floatFromVal (rval) : \
1235           (unsigned long) floatFromVal (lval) >> (unsigned long) floatFromVal (rval);
1236       else
1237         SPEC_CVAL (val->type).v_long = lr ?
1238           (long) floatFromVal (lval) << (long) floatFromVal (rval) : \
1239           (long) floatFromVal (lval) >> (long) floatFromVal (rval);
1240     }
1241
1242   return cheapestVal(val);
1243 }
1244
1245 /*------------------------------------------------------------------*/
1246 /* valCompare- Compares two literal                                 */
1247 /*------------------------------------------------------------------*/
1248 value *
1249 valCompare (value * lval, value * rval, int ctype)
1250 {
1251   value *val;
1252
1253   /* create a new value */
1254   val = newValue ();
1255   val->type = val->etype = newCharLink ();
1256   val->type->class = SPECIFIER;
1257   SPEC_NOUN (val->type) = V_CHAR;       /* type is char */
1258   SPEC_USIGN (val->type) = 1;
1259   SPEC_SCLS (val->type) = S_LITERAL;    /* will remain literal */
1260
1261   switch (ctype)
1262     {
1263     case '<':
1264       SPEC_CVAL (val->type).v_int = floatFromVal (lval) < floatFromVal (rval);
1265       break;
1266
1267     case '>':
1268       SPEC_CVAL (val->type).v_int = floatFromVal (lval) > floatFromVal (rval);
1269       break;
1270
1271     case LE_OP:
1272       SPEC_CVAL (val->type).v_int = floatFromVal (lval) <= floatFromVal (rval);
1273       break;
1274
1275     case GE_OP:
1276       SPEC_CVAL (val->type).v_int = floatFromVal (lval) >= floatFromVal (rval);
1277       break;
1278
1279     case EQ_OP:
1280       SPEC_CVAL (val->type).v_int = floatFromVal (lval) == floatFromVal (rval);
1281       break;
1282
1283     case NE_OP:
1284       SPEC_CVAL (val->type).v_int = floatFromVal (lval) != floatFromVal (rval);
1285       break;
1286
1287     }
1288
1289   return val;
1290 }
1291
1292 /*------------------------------------------------------------------*/
1293 /* valBitwise - Bitwise operation                                   */
1294 /*------------------------------------------------------------------*/
1295 value *
1296 valBitwise (value * lval, value * rval, int op)
1297 {
1298   value *val;
1299
1300   /* create a new value */
1301   val = newValue ();
1302   val->type = copyLinkChain (lval->type);
1303   val->etype = getSpec (val->type);
1304
1305   switch (op)
1306     {
1307     case '&':
1308       if (SPEC_LONG (val->type))
1309         {
1310           if (SPEC_USIGN (val->type))
1311             SPEC_CVAL (val->type).v_ulong = (unsigned long) floatFromVal (lval) &
1312               (unsigned long) floatFromVal (rval);
1313           else
1314             SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) &
1315               (long) floatFromVal (rval);
1316         }
1317       else
1318         {
1319           if (SPEC_USIGN (val->type))
1320             SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) &
1321               (unsigned) floatFromVal (rval);
1322           else
1323             SPEC_CVAL (val->type).v_int = (int) floatFromVal (lval) & (int) floatFromVal (rval);
1324         }
1325       break;
1326
1327     case '|':
1328       if (SPEC_LONG (val->type))
1329         {
1330           if (SPEC_USIGN (val->type))
1331             SPEC_CVAL (val->type).v_ulong = (unsigned long) floatFromVal (lval) |
1332               (unsigned long) floatFromVal (rval);
1333           else
1334             SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) |
1335               (long) floatFromVal (rval);
1336         }
1337       else
1338         {
1339           if (SPEC_USIGN (val->type))
1340             SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) |
1341               (unsigned) floatFromVal (rval);
1342           else
1343             SPEC_CVAL (val->type).v_int =
1344               (int) floatFromVal (lval) | (int) floatFromVal (rval);
1345         }
1346
1347       break;
1348
1349     case '^':
1350       if (SPEC_LONG (val->type))
1351         {
1352           if (SPEC_USIGN (val->type))
1353             SPEC_CVAL (val->type).v_ulong = (unsigned long) floatFromVal (lval) ^
1354               (unsigned long) floatFromVal (rval);
1355           else
1356             SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) ^
1357               (long) floatFromVal (rval);
1358         }
1359       else
1360         {
1361           if (SPEC_USIGN (val->type))
1362             SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) ^
1363               (unsigned) floatFromVal (rval);
1364           else
1365             SPEC_CVAL (val->type).v_int =
1366               (int) floatFromVal (lval) ^ (int) floatFromVal (rval);
1367         }
1368       break;
1369     }
1370
1371   return cheapestVal(val);
1372 }
1373
1374 /*------------------------------------------------------------------*/
1375 /* valAndOr   - Generates code for and / or operation               */
1376 /*------------------------------------------------------------------*/
1377 value *
1378 valLogicAndOr (value * lval, value * rval, int op)
1379 {
1380   value *val;
1381
1382   /* create a new value */
1383   val = newValue ();
1384   val->type = val->etype = newCharLink ();
1385   val->type->class = SPECIFIER;
1386   SPEC_SCLS (val->type) = S_LITERAL;    /* will remain literal */
1387   SPEC_USIGN (val->type) = 0;
1388
1389   switch (op)
1390     {
1391     case AND_OP:
1392       SPEC_CVAL (val->type).v_int = floatFromVal (lval) && floatFromVal (rval);
1393       break;
1394
1395     case OR_OP:
1396       SPEC_CVAL (val->type).v_int = floatFromVal (lval) || floatFromVal (rval);
1397       break;
1398     }
1399
1400
1401   return val;
1402 }
1403
1404 /*------------------------------------------------------------------*/
1405 /* valCastLiteral - casts a literal value to another type           */
1406 /*------------------------------------------------------------------*/
1407 value *
1408 valCastLiteral (sym_link * dtype, double fval)
1409 {
1410   value *val;
1411
1412   if (!dtype)
1413     return NULL;
1414
1415   val = newValue ();
1416   val->etype = getSpec (val->type = copyLinkChain (dtype));
1417   SPEC_SCLS (val->etype) = S_LITERAL;
1418   /* if it is not a specifier then we can assume that */
1419   /* it will be an unsigned long                      */
1420   if (!IS_SPEC (val->type)) {
1421       SPEC_CVAL (val->etype).v_ulong = (unsigned long) fval;
1422       return val;
1423   }
1424
1425   if (SPEC_NOUN (val->etype) == V_FLOAT)
1426       SPEC_CVAL (val->etype).v_float = fval;
1427   else {
1428       unsigned long l = fval;
1429       if (SPEC_LONG (val->etype)) {
1430           if (SPEC_USIGN (val->etype))
1431               SPEC_CVAL (val->etype).v_ulong = (unsigned long) l;
1432           else
1433               SPEC_CVAL (val->etype).v_long = (long) l;
1434       } else {
1435           if (SPEC_USIGN (val->etype))
1436               SPEC_CVAL (val->etype).v_uint = (unsigned short)l;
1437           else
1438               SPEC_CVAL (val->etype).v_int = (short)l;
1439       }
1440   }
1441   return val;
1442 }
1443
1444 /*------------------------------------------------------------------*/
1445 /* getNelements - determines # of elements from init list           */
1446 /*------------------------------------------------------------------*/
1447 int
1448 getNelements (sym_link * type, initList * ilist)
1449 {
1450   sym_link *etype = getSpec (type);
1451   int i;
1452
1453   if (!ilist)
1454     return 0;
1455
1456   if (ilist->type == INIT_DEEP)
1457     ilist = ilist->init.deep;
1458
1459   /* if type is a character array and there is only one
1460      (string) initialiser then get the length of the string */
1461   if (IS_ARRAY (type) && IS_CHAR (etype) && !ilist->next)
1462     {
1463       ast *iast = ilist->init.node;
1464       value *v = (iast->type == EX_VALUE ? iast->opval.val : NULL);
1465       if (!v)
1466         {
1467           werror (W_INIT_WRONG);
1468           return 0;
1469         }
1470
1471       if (IS_ARRAY (v->type) && IS_CHAR (v->etype))
1472         // yep, it's a string
1473         {
1474           return DCL_ELEM (v->type);
1475         }
1476     }
1477
1478   i = 0;
1479   while (ilist)
1480     {
1481       i++;
1482       ilist = ilist->next;
1483     }
1484
1485   return i;
1486 }
1487
1488 /*-----------------------------------------------------------------*/
1489 /* valForArray - returns a value with name of array index          */
1490 /*-----------------------------------------------------------------*/
1491 value *
1492 valForArray (ast * arrExpr)
1493 {
1494   value *val, *lval = NULL;
1495   char buffer[128];
1496   int size = getSize (arrExpr->left->ftype->next);
1497   /* if the right or left is an array
1498      resolve it first */
1499   if (IS_AST_OP (arrExpr->left))
1500     {
1501       if (arrExpr->left->opval.op == '[')
1502         lval = valForArray (arrExpr->left);
1503       else if (arrExpr->left->opval.op == '.')
1504         lval = valForStructElem (arrExpr->left->left,
1505                                  arrExpr->left->right);
1506       else if (arrExpr->left->opval.op == PTR_OP &&
1507                IS_ADDRESS_OF_OP (arrExpr->left->left))
1508         lval = valForStructElem (arrExpr->left->left->left,
1509                                  arrExpr->left->right);
1510       else
1511         return NULL;
1512
1513     }
1514   else if (!IS_AST_SYM_VALUE (arrExpr->left))
1515     return NULL;
1516
1517   if (!IS_AST_LIT_VALUE (arrExpr->right))
1518     return NULL;
1519
1520   val = newValue ();
1521   if (!lval)
1522     sprintf (buffer, "%s", AST_SYMBOL (arrExpr->left)->rname);
1523   else
1524     sprintf (buffer, "%s", lval->name);
1525
1526   sprintf (val->name, "(%s + %d)", buffer,
1527            (int) AST_LIT_VALUE (arrExpr->right) * size);
1528
1529   val->type = newLink ();
1530   if (SPEC_SCLS (arrExpr->left->etype) == S_CODE)
1531     {
1532       DCL_TYPE (val->type) = CPOINTER;
1533       DCL_PTR_CONST (val->type) = port->mem.code_ro;
1534     }
1535   else if (SPEC_SCLS (arrExpr->left->etype) == S_XDATA)
1536     DCL_TYPE (val->type) = FPOINTER;
1537   else if (SPEC_SCLS (arrExpr->left->etype) == S_XSTACK)
1538     DCL_TYPE (val->type) = PPOINTER;
1539   else if (SPEC_SCLS (arrExpr->left->etype) == S_IDATA)
1540     DCL_TYPE (val->type) = IPOINTER;
1541   else if (SPEC_SCLS (arrExpr->left->etype) == S_EEPROM)
1542     DCL_TYPE (val->type) = EEPPOINTER;
1543   else
1544     DCL_TYPE (val->type) = POINTER;
1545   val->type->next = arrExpr->left->ftype;
1546   val->etype = getSpec (val->type);
1547   return val;
1548 }
1549
1550 /*-----------------------------------------------------------------*/
1551 /* valForStructElem - returns value with name of struct element    */
1552 /*-----------------------------------------------------------------*/
1553 value *
1554 valForStructElem (ast * structT, ast * elemT)
1555 {
1556   value *val, *lval = NULL;
1557   char buffer[128];
1558   symbol *sym;
1559
1560   /* left could be furthur derefed */
1561   if (IS_AST_OP (structT))
1562     {
1563       if (structT->opval.op == '[')
1564         lval = valForArray (structT);
1565       else if (structT->opval.op == '.')
1566         lval = valForStructElem (structT->left, structT->right);
1567       else if (structT->opval.op == PTR_OP &&
1568                IS_ADDRESS_OF_OP (structT->left))
1569         lval = valForStructElem (structT->left->left,
1570                                  structT->right);
1571       else
1572         return NULL;
1573     }
1574
1575   if (!IS_AST_SYM_VALUE (elemT))
1576     return NULL;
1577
1578   if (!IS_STRUCT (structT->etype))
1579     return NULL;
1580
1581   if ((sym = getStructElement (SPEC_STRUCT (structT->etype),
1582                                AST_SYMBOL (elemT))) == NULL)
1583     {
1584       return NULL;
1585     }
1586
1587   val = newValue ();
1588   if (!lval)
1589     sprintf (buffer, "%s", AST_SYMBOL (structT)->rname);
1590   else
1591     sprintf (buffer, "%s", lval->name);
1592
1593   sprintf (val->name, "(%s + %d)", buffer,
1594            (int) sym->offset);
1595
1596   val->type = newLink ();
1597   if (SPEC_SCLS (structT->etype) == S_CODE)
1598     {
1599       DCL_TYPE (val->type) = CPOINTER;
1600       DCL_PTR_CONST (val->type) = port->mem.code_ro;
1601     }
1602   else if (SPEC_SCLS (structT->etype) == S_XDATA)
1603     DCL_TYPE (val->type) = FPOINTER;
1604   else if (SPEC_SCLS (structT->etype) == S_XSTACK)
1605     DCL_TYPE (val->type) = PPOINTER;
1606   else if (SPEC_SCLS (structT->etype) == S_IDATA)
1607     DCL_TYPE (val->type) = IPOINTER;
1608   else if (SPEC_SCLS (structT->etype) == S_EEPROM)
1609     DCL_TYPE (val->type) = EEPPOINTER;
1610   else
1611     DCL_TYPE (val->type) = POINTER;
1612   val->type->next = sym->type;
1613   val->etype = getSpec (val->type);
1614   return val;
1615 }
1616
1617 /*-----------------------------------------------------------------*/
1618 /* valForCastAggr - will return value for a cast of an aggregate   */
1619 /*                  plus minus a constant                          */
1620 /*-----------------------------------------------------------------*/
1621 value *
1622 valForCastAggr (ast * aexpr, sym_link * type, ast * cnst, int op)
1623 {
1624   value *val;
1625
1626   if (!IS_AST_SYM_VALUE (aexpr))
1627     return NULL;
1628   if (!IS_AST_LIT_VALUE (cnst))
1629     return NULL;
1630
1631   val = newValue ();
1632
1633   sprintf (val->name, "(%s %c %d)",
1634            AST_SYMBOL (aexpr)->rname, op,
1635            getSize (type->next) * (int) AST_LIT_VALUE (cnst));
1636
1637   val->type = type;
1638   val->etype = getSpec (val->type);
1639   return val;
1640 }
1641
1642 /*-----------------------------------------------------------------*/
1643 /* valForCastAggr - will return value for a cast of an aggregate   */
1644 /*                  with no constant                               */
1645 /*-----------------------------------------------------------------*/
1646 value *
1647 valForCastArr (ast * aexpr, sym_link * type)
1648 {
1649   value *val;
1650
1651   if (!IS_AST_SYM_VALUE (aexpr))
1652     return NULL;
1653
1654   val = newValue ();
1655
1656   sprintf (val->name, "(%s)",
1657            AST_SYMBOL (aexpr)->rname);
1658
1659   val->type = type;
1660   val->etype = getSpec (val->type);
1661   return val;
1662 }