1 /*----------------------------------------------------------------------
2 SDCCval.c :- has routine to do all kinds of fun stuff with the
3 value wrapper & with initialiser lists.
5 Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998)
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
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.
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.
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 -------------------------------------------------------------------------*/
35 /*-----------------------------------------------------------------*/
36 /* newValue - allocates and returns a new value */
37 /*-----------------------------------------------------------------*/
43 val = Safe_alloc (sizeof (value));
48 /*-----------------------------------------------------------------*/
49 /* newiList - new initializer list */
50 /*-----------------------------------------------------------------*/
52 newiList (int type, void *ilist)
57 nilist = Safe_alloc (sizeof (initList));
60 nilist->lineno = lexLineno;
61 nilist->filename = lexFilename;
66 nilist->init.node = (struct ast *) ilist;
70 nilist->init.deep = (struct initList *) ilist;
77 /*------------------------------------------------------------------*/
78 /* revinit - reverses the initial values for a value chain */
79 /*------------------------------------------------------------------*/
81 revinit (initList * val)
83 initList *prev, *curr, *next;
98 val->next = (void *) NULL;
103 convertIListToConstList(initList *src, literalList **lList)
106 literalList *head, *last, *newL;
110 if (!src || src->type != INIT_DEEP)
115 iLoop = src->init.deep;
119 if (iLoop->type != INIT_NODE)
124 if (!IS_AST_LIT_VALUE(decorateType(resolveSymbols(iLoop->init.node), RESULT_TYPE_NONE)))
131 /* We've now established that the initializer list contains only literal values. */
133 iLoop = src->init.deep;
136 double val = AST_FLOAT_VALUE(iLoop->init.node);
138 if (last && last->literalValue == val)
144 newL = Safe_alloc(sizeof(literalList));
145 newL->literalValue = val;
172 copyLiteralList(literalList *src)
174 literalList *head, *prev, *newL;
180 newL = Safe_alloc(sizeof(literalList));
182 newL->literalValue = src->literalValue;
183 newL->count = src->count;
203 /*------------------------------------------------------------------*/
204 /* copyIlist - copy initializer list */
205 /*------------------------------------------------------------------*/
207 copyIlist (initList * src)
209 initList *dest = NULL;
217 dest = newiList (INIT_DEEP, copyIlist (src->init.deep));
220 dest = newiList (INIT_NODE, copyAst (src->init.node));
225 dest->next = copyIlist (src->next);
230 /*------------------------------------------------------------------*/
231 /* list2int - converts the first element of the list to value */
232 /*------------------------------------------------------------------*/
234 list2int (initList * val)
238 if (i->type == INIT_DEEP)
239 return list2int (val->init.deep);
241 return floatFromVal (constExprValue (val->init.node, TRUE));
244 /*------------------------------------------------------------------*/
245 /* list2val - converts the first element of the list to value */
246 /*------------------------------------------------------------------*/
248 list2val (initList * val)
253 if (val->type == INIT_DEEP)
254 return list2val (val->init.deep);
256 return constExprValue (val->init.node, TRUE);
259 /*------------------------------------------------------------------*/
260 /* list2expr - returns the first expression in the initializer list */
261 /*------------------------------------------------------------------*/
263 list2expr (initList * ilist)
265 if (ilist->type == INIT_DEEP)
266 return list2expr (ilist->init.deep);
267 return ilist->init.node;
270 /*------------------------------------------------------------------*/
271 /* resolveIvalSym - resolve symbols in initial values */
272 /*------------------------------------------------------------------*/
274 resolveIvalSym (initList * ilist, sym_link * type)
276 int is_ptr = IS_PTR (type);
277 RESULT_TYPE resultType = getResultTypeFromType (getSpec (type));
281 if (ilist->type == INIT_NODE)
283 ilist->init.node = decorateType (resolveSymbols (ilist->init.node),
284 is_ptr ? RESULT_TYPE_INT : resultType);
286 else if (ilist->type == INIT_DEEP)
288 resolveIvalSym (ilist->init.deep, type);
295 /*------------------------------------------------------------------*/
296 /* symbolVal - creates a value for a symbol */
297 /*------------------------------------------------------------------*/
299 symbolVal (symbol * sym)
311 val->type = sym->type;
312 val->etype = getSpec (val->type);
317 SNPRINTF (val->name, sizeof(val->name), "%s", sym->rname);
321 SNPRINTF (val->name, sizeof(val->name), "_%s", sym->name);
327 /*--------------------------------------------------------------------*/
328 /* cheapestVal - try to reduce 'signed int' to 'char' */
329 /*--------------------------------------------------------------------*/
331 cheapestVal (value *val)
333 /* only int can be reduced */
334 if (!IS_INT(val->type))
337 /* long must not be changed */
338 if (SPEC_LONG(val->type))
341 /* unsigned must not be changed */
342 if (SPEC_USIGN(val->type))
345 /* the only possible reduction is from signed int to (un)signed char,
346 because it's automatically promoted back to signed int.
348 a reduction from unsigned int to unsigned char is a bug,
349 because an _unsigned_ char is promoted to _signed_ int! */
350 if (SPEC_CVAL(val->type).v_int < -128 ||
351 SPEC_CVAL(val->type).v_int > 255)
353 /* not in the range of (un)signed char */
357 SPEC_NOUN(val->type) = V_CHAR;
359 /* 'unsigned char' promotes to 'signed int', so that we can
360 reduce it the other way */
361 if (SPEC_CVAL(val->type).v_int >= 0)
363 SPEC_USIGN(val->type) = 1;
368 /*--------------------------------------------------------------------*/
369 /* checkConstantRange - check if constant fits in numeric range of */
370 /* var type in comparisons and assignments */
371 /*--------------------------------------------------------------------*/
373 checkConstantRange (sym_link *var, sym_link *lit, int op, bool exchangeLeftRight)
379 litVal = floatFromVal (valFromType (lit));
380 varBits = bitsForType (var);
387 return CCR_ALWAYS_FALSE;
389 return CCR_ALWAYS_TRUE;
391 /* special: assignment */
397 if (getenv ("SDCC_VERY_PEDANTIC"))
399 if (SPEC_USIGN (var))
401 TYPE_TARGET_ULONG maxVal = 0xffffffffu >> (32 - varBits);
410 TYPE_TARGET_LONG minVal = 0xffffffff << (varBits - 1);
411 TYPE_TARGET_LONG maxVal = 0x7fffffff >> (32 - varBits);
421 /* ignore signedness, e.g. allow everything
422 from -127...+255 for (unsigned) char */
423 TYPE_TARGET_LONG minVal = 0xffffffff << (varBits - 1);
424 TYPE_TARGET_ULONG maxVal = 0xffffffffu >> (32 - varBits);
433 if (exchangeLeftRight)
438 case '>': op = '<'; break;
439 case GE_OP: op = LE_OP; break;
440 case '<': op = '>'; break;
441 case LE_OP: op = GE_OP; break;
442 default: return CCR_ALWAYS_FALSE;
445 reType = computeType (var, lit, RESULT_TYPE_NONE, op);
447 if (SPEC_USIGN (reType))
449 /* unsigned operation */
450 TYPE_TARGET_ULONG minValP, maxValP, minValM, maxValM;
451 TYPE_TARGET_ULONG opBitsMask = 0xffffffffu >> (32 - bitsForType (reType));
453 if (SPEC_USIGN (lit) && SPEC_USIGN (var))
455 /* both operands are unsigned, this is easy */
457 maxValP = 0xffffffffu >> (32 - varBits);
458 /* there's only range, just copy it to 2nd set */
462 else if (SPEC_USIGN (var))
464 /* lit is casted from signed to unsigned, e.g.:
470 maxValP = 0xffffffffu >> (32 - varBits);
471 /* there's only one range, just copy it to 2nd set */
475 /* it's an unsigned operation */
476 if ( IS_CHAR (reType)
479 /* make signed literal unsigned and
480 limit no of bits to size of return type */
481 litVal = (TYPE_TARGET_ULONG) double2ul (litVal) & opBitsMask;
484 else /* SPEC_USIGN (lit) */
486 /* var is casted from signed to unsigned, e.g.:
491 The possible values after casting var
492 split up in two, nonconsecutive ranges:
494 minValP = 0; positive range: 0...127
496 minValM = 0xff80; negative range: -128...-1
502 maxValP = 0x7fffffffu >> (32 - varBits);
505 minValM = 0xffffffff << (varBits - 1);
506 maxValM = 0xffffffffu; /* -1 */
507 /* limit no of bits to size of return type */
508 minValM &= opBitsMask;
509 maxValM &= opBitsMask;
514 case EQ_OP: /* var == lit */
515 if ( litVal <= maxValP
516 && litVal >= minValP) /* 0 */
518 if ( litVal <= maxValM
519 && litVal >= minValM)
521 return CCR_ALWAYS_FALSE;
522 case NE_OP: /* var != lit */
523 if ( litVal <= maxValP
524 && litVal >= minValP) /* 0 */
526 if ( litVal <= maxValM
527 && litVal >= minValM)
529 return CCR_ALWAYS_TRUE;
530 case '>': /* var > lit */
531 if (litVal >= maxValM)
532 return CCR_ALWAYS_FALSE;
533 if (litVal < minValP) /* 0 */
534 return CCR_ALWAYS_TRUE;
536 case GE_OP: /* var >= lit */
537 if (litVal > maxValM)
538 return CCR_ALWAYS_FALSE;
539 if (litVal <= minValP) /* 0 */
540 return CCR_ALWAYS_TRUE;
542 case '<': /* var < lit */
543 if (litVal > maxValM)
544 return CCR_ALWAYS_TRUE;
545 if (litVal <= minValP) /* 0 */
546 return CCR_ALWAYS_FALSE;
548 case LE_OP: /* var <= lit */
549 if (litVal >= maxValM)
550 return CCR_ALWAYS_TRUE;
551 if (litVal < minValP) /* 0 */
552 return CCR_ALWAYS_FALSE;
555 return CCR_ALWAYS_FALSE;
560 /* signed operation */
561 TYPE_TARGET_LONG minVal, maxVal;
563 if (SPEC_USIGN (var))
565 /* unsigned var, but signed operation. This happens
566 when var is promoted to signed int.
567 Set actual min/max values of var. */
569 maxVal = 0xffffffff >> (32 - varBits);
574 minVal = 0xffffffff << (varBits - 1);
575 maxVal = 0x7fffffff >> (32 - varBits);
580 case EQ_OP: /* var == lit */
583 return CCR_ALWAYS_FALSE;
585 case NE_OP: /* var != lit */
588 return CCR_ALWAYS_TRUE;
590 case '>': /* var > lit */
591 if (litVal >= maxVal)
592 return CCR_ALWAYS_FALSE;
594 return CCR_ALWAYS_TRUE;
596 case GE_OP: /* var >= lit */
598 return CCR_ALWAYS_FALSE;
599 if (litVal <= minVal)
600 return CCR_ALWAYS_TRUE;
602 case '<': /* var < lit */
604 return CCR_ALWAYS_TRUE;
605 if (litVal <= minVal)
606 return CCR_ALWAYS_FALSE;
608 case LE_OP: /* var <= lit */
609 if (litVal >= maxVal)
610 return CCR_ALWAYS_TRUE;
612 return CCR_ALWAYS_FALSE;
615 return CCR_ALWAYS_FALSE;
620 /*-----------------------------------------------------------------*/
621 /* valueFromLit - creates a value from a literal */
622 /*-----------------------------------------------------------------*/
624 valueFromLit (double lit)
628 if ((((TYPE_TARGET_LONG) lit) - lit) == 0)
630 SNPRINTF (buffer, sizeof(buffer), "%d", (TYPE_TARGET_LONG) lit);
631 return constVal (buffer);
634 SNPRINTF (buffer, sizeof(buffer), "%f", lit);
635 return constFloatVal (buffer);
638 /*-----------------------------------------------------------------*/
639 /* constFloatVal - converts a FLOAT constant to value */
640 /*-----------------------------------------------------------------*/
642 constFloatVal (const char *s)
644 value *val = newValue ();
648 sval = strtod(s, &p);
651 werror (E_INVALID_FLOAT_CONST, s);
652 return constCharVal (0);
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;
663 /*-----------------------------------------------------------------*/
664 /* constFixed16x16Val - converts a FIXED16X16 constant to value */
665 /*-----------------------------------------------------------------*/
667 constFixed16x16Val (const char *s)
669 value *val = newValue ();
673 sval = strtod(s, &p);
676 werror (E_INVALID_FLOAT_CONST, s);
677 return constCharVal (0);
680 val->type = val->etype = newLink (SPECIFIER);
681 SPEC_NOUN (val->type) = V_FLOAT;
682 SPEC_SCLS (val->type) = S_LITERAL;
683 SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble ( sval );
688 /*-----------------------------------------------------------------*/
689 /* constVal - converts an INTEGER constant into a cheapest value */
690 /*-----------------------------------------------------------------*/
691 value *constVal (const char *s)
694 bool hex = FALSE, octal = FALSE;
698 val = newValue (); /* alloc space for value */
700 val->type = val->etype = newLink (SPECIFIER); /* create the specifier */
701 SPEC_SCLS (val->type) = S_LITERAL;
702 /* let's start with a signed char */
703 SPEC_NOUN (val->type) = V_CHAR;
704 SPEC_USIGN (val->type) = 0;
708 if (s[1] == 'x' || s[1] == 'X')
710 else if (isdigit(s[1]))
717 dval = strtoul (s, &p, 0);
721 werror (W_INVALID_INT_CONST, s, dval);
726 dval = strtod(s, &p);
729 /* Setup the flags first */
730 /* set the unsigned flag if 'uU' is found */
731 if (strchr (p, 'u') || strchr (p, 'U'))
733 SPEC_USIGN (val->type) = 1;
736 /* set the b_long flag if 'lL' is found */
737 if (strchr (p, 'l') || strchr (p, 'L'))
739 SPEC_NOUN (val->type) = V_INT;
740 SPEC_LONG (val->type) = 1;
745 { /* "-28u" will still be signed and negative */
747 { /* check if we have to promote to int */
748 SPEC_NOUN (val->type) = V_INT;
751 { /* check if we have to promote to long int */
752 SPEC_LONG (val->type) = 1;
757 if (dval > 0xff || /* check if we have to promote to int */
758 SPEC_USIGN (val->type))
759 { /* if it's unsigned, we can't use unsigned
760 char. After an integral promotion it will
761 be a signed int; this certainly isn't what
762 the programer wants */
763 SPEC_NOUN (val->type) = V_INT;
766 { /* store char's always as unsigned; this helps other optimizations */
767 SPEC_USIGN (val->type) = 1;
769 if (dval > 0xffff && SPEC_USIGN (val->type))
770 { /* check if we have to promote to long */
771 SPEC_LONG (val->type) = 1;
773 else if (dval > 0x7fff && !SPEC_USIGN (val->type))
774 { /* check if we have to promote to long int */
775 if ((hex || octal) && /* hex or octal constants may be stored in unsigned type */
778 SPEC_USIGN (val->type) = 1;
782 SPEC_LONG (val->type) = 1;
783 if (dval > 0x7fffffff)
785 SPEC_USIGN (val->type) = 1;
792 /* check for out of range */
793 if (dval < -2147483648.0)
795 dval = -2147483648.0;
796 werror (W_INVALID_INT_CONST, s, dval);
798 if (dval > 2147483647.0 && !SPEC_USIGN (val->type))
801 werror (W_INVALID_INT_CONST, s, dval);
803 if (dval > 4294967295.0)
806 werror (W_INVALID_INT_CONST, s, dval);
809 if (SPEC_LONG (val->type))
811 if (SPEC_USIGN (val->type))
813 SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) double2ul (dval);
817 SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) double2ul (dval);
822 if (SPEC_USIGN (val->type))
824 SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) double2ul (dval);
828 SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) double2ul (dval);
835 value *constCharVal (unsigned char v)
837 value *val = newValue (); /* alloc space for value */
839 val->type = val->etype = newLink (SPECIFIER); /* create the specifier */
840 SPEC_SCLS (val->type) = S_LITERAL;
841 /* let's start with a signed char */
842 SPEC_NOUN (val->type) = V_CHAR;
843 SPEC_USIGN (val->type) = 1;
844 SPEC_CVAL (val->type).v_uint = v;
849 /*------------------------------------------------------------------*/
850 /* strVal - converts a string constant to a value */
851 /*------------------------------------------------------------------*/
853 strVal (const char *s)
857 val = newValue (); /* get a new one */
859 /* get a declarator */
860 val->type = newLink (DECLARATOR);
861 DCL_TYPE (val->type) = ARRAY;
862 val->type->next = val->etype = newLink (SPECIFIER);
863 SPEC_NOUN (val->etype) = V_CHAR;
864 SPEC_SCLS (val->etype) = S_LITERAL;
866 SPEC_CVAL (val->etype).v_char = Safe_alloc (strlen (s) + 1);
867 DCL_ELEM (val->type) = copyStr (SPEC_CVAL (val->etype).v_char, s);
873 /*------------------------------------------------------------------*/
874 /* reverseValWithType - reverses value chain with type & etype */
875 /*------------------------------------------------------------------*/
877 reverseValWithType (value * val)
885 /* save the type * etype chains */
889 /* set the current one 2b null */
890 val->type = val->etype = NULL;
891 val = reverseVal (val);
893 /* restore type & etype */
900 /*------------------------------------------------------------------*/
901 /* reverseVal - reverses the values for a value chain */
902 /*------------------------------------------------------------------*/
904 reverseVal (value * val)
906 value *prev, *curr, *next;
921 val->next = (void *) NULL;
925 /*------------------------------------------------------------------*/
926 /* copyValueChain - will copy a chain of values */
927 /*------------------------------------------------------------------*/
929 copyValueChain (value * src)
936 dest = copyValue (src);
937 dest->next = copyValueChain (src->next);
942 /*------------------------------------------------------------------*/
943 /* copyValue - copies contents of a value to a fresh one */
944 /*------------------------------------------------------------------*/
946 copyValue (value * src)
951 dest->sym = copySymbol (src->sym);
952 strncpyz (dest->name, src->name, SDCC_NAME_MAX);
953 dest->type = (src->type ? copyLinkChain (src->type) : NULL);
954 dest->etype = (src->type ? getSpec (dest->type) : NULL);
959 /*------------------------------------------------------------------*/
960 /* charVal - converts a character constant to a value */
961 /*------------------------------------------------------------------*/
963 charVal (const char *s)
965 /* get rid of quotation */
966 /* if \ then special processing */
969 switch (*++s) /* go beyond the backslash */
972 return constCharVal ('\n');
974 return constCharVal ('\t');
976 return constCharVal ('\v');
978 return constCharVal ('\b');
980 return constCharVal ('\r');
982 return constCharVal ('\f');
984 return constCharVal ('\a');
986 return constCharVal ('\\');
988 return constCharVal ('\?');
990 return constCharVal ('\'');
992 return constCharVal ('\"');
1002 return constCharVal (octalEscape (&s));
1005 return constCharVal (hexEscape (&s));
1008 return constCharVal (*s);
1011 else /* not a backslash */
1012 return constCharVal (*s);
1015 /*------------------------------------------------------------------*/
1016 /* valFromType - creates a value from type given */
1017 /*------------------------------------------------------------------*/
1019 valFromType (sym_link * type)
1021 value *val = newValue ();
1022 val->type = copyLinkChain (type);
1023 val->etype = getSpec (val->type);
1027 /*------------------------------------------------------------------*/
1028 /* floatFromVal - value to double float conversion */
1029 /*------------------------------------------------------------------*/
1031 floatFromVal (value * val)
1036 if (val->etype && SPEC_SCLS (val->etype) != S_LITERAL)
1038 werror (E_CONST_EXPECTED, val->name);
1042 /* if it is not a specifier then we can assume that */
1043 /* it will be an unsigned long */
1044 if (!IS_SPEC (val->type))
1045 return SPEC_CVAL (val->etype).v_ulong;
1047 if (SPEC_NOUN (val->etype) == V_FLOAT)
1048 return SPEC_CVAL (val->etype).v_float;
1050 if (SPEC_NOUN (val->etype) == V_FIXED16X16)
1051 return doubleFromFixed16x16 (SPEC_CVAL (val->etype).v_fixed16x16);
1053 if (SPEC_LONG (val->etype))
1055 if (SPEC_USIGN (val->etype))
1056 return SPEC_CVAL (val->etype).v_ulong;
1058 return SPEC_CVAL (val->etype).v_long;
1061 if (SPEC_NOUN (val->etype) == V_INT)
1063 if (SPEC_USIGN (val->etype))
1064 return SPEC_CVAL (val->etype).v_uint;
1066 return SPEC_CVAL (val->etype).v_int;
1069 if (SPEC_NOUN (val->etype) == V_CHAR)
1071 if (SPEC_USIGN (val->etype))
1072 return (unsigned char) SPEC_CVAL (val->etype).v_uint;
1074 return (signed char) SPEC_CVAL (val->etype).v_int;
1077 if (IS_BITVAR(val->etype))
1078 return SPEC_CVAL (val->etype).v_uint;
1080 if (SPEC_NOUN (val->etype) == V_VOID)
1081 return SPEC_CVAL (val->etype).v_ulong;
1084 werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "floatFromVal: unknown value");
1088 /*------------------------------------------------------------------*/
1089 /* ulFromVal - value to unsigned long conversion */
1090 /*------------------------------------------------------------------*/
1092 ulFromVal (value * val)
1097 if (val->etype && SPEC_SCLS (val->etype) != S_LITERAL)
1099 werror (E_CONST_EXPECTED, val->name);
1103 /* if it is not a specifier then we can assume that */
1104 /* it will be an unsigned long */
1105 if (!IS_SPEC (val->type))
1106 return SPEC_CVAL (val->etype).v_ulong;
1108 if (SPEC_NOUN (val->etype) == V_FLOAT)
1109 return double2ul (SPEC_CVAL (val->etype).v_float);
1111 if (SPEC_NOUN (val->etype) == V_FIXED16X16)
1112 return double2ul (doubleFromFixed16x16 (SPEC_CVAL (val->etype).v_fixed16x16));
1114 if (SPEC_LONG (val->etype))
1116 if (SPEC_USIGN (val->etype))
1117 return SPEC_CVAL (val->etype).v_ulong;
1119 return SPEC_CVAL (val->etype).v_long;
1122 if (SPEC_NOUN (val->etype) == V_INT)
1124 if (SPEC_USIGN (val->etype))
1125 return SPEC_CVAL (val->etype).v_uint;
1127 return SPEC_CVAL (val->etype).v_int;
1130 if (SPEC_NOUN (val->etype) == V_CHAR)
1132 if (SPEC_USIGN (val->etype))
1133 return (unsigned char) SPEC_CVAL (val->etype).v_uint;
1135 return (signed char) SPEC_CVAL (val->etype).v_int;
1138 if (IS_BITVAR(val->etype))
1139 return SPEC_CVAL (val->etype).v_uint;
1141 if (SPEC_NOUN (val->etype) == V_VOID)
1142 return SPEC_CVAL (val->etype).v_ulong;
1145 werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "ulFromVal: unknown value");
1149 /*-----------------------------------------------------------------*/
1150 /* doubleFromFixed16x16 - convert a fixed16x16 to double */
1151 /*-----------------------------------------------------------------*/
1152 double doubleFromFixed16x16(TYPE_TARGET_ULONG value)
1155 /* This version is incorrect negative values. */
1156 double tmp=0, exp=2;
1158 tmp = (value & 0xffff0000) >> 16;
1162 if(value & 0x8000)tmp += 1/exp;
1169 return ((double)(value * 1.0) / (double)(1UL << 16));
1173 TYPE_TARGET_ULONG fixed16x16FromDouble(double value)
1176 /* This version is incorrect negative values. */
1177 unsigned int tmp=0, pos=16;
1178 TYPE_TARGET_ULONG res;
1180 tmp = floor( value );
1187 if(value >= 1.0)tmp |= (1 << pos);
1188 value -= floor( value );
1195 return double2ul (value * (double)(1UL << 16));
1199 /*------------------------------------------------------------------*/
1200 /* valUnaryPM - does the unary +/- operation on a constant */
1201 /*------------------------------------------------------------------*/
1203 valUnaryPM (value * val)
1205 /* depending on type */
1206 if (SPEC_NOUN (val->etype) == V_FLOAT)
1207 SPEC_CVAL (val->etype).v_float = -1.0 * SPEC_CVAL (val->etype).v_float;
1208 else if (SPEC_NOUN (val->etype) == V_FIXED16X16)
1209 SPEC_CVAL (val->etype).v_fixed16x16 = (TYPE_TARGET_ULONG) -((long) SPEC_CVAL (val->etype).v_fixed16x16);
1212 if (SPEC_LONG (val->etype))
1214 if (SPEC_USIGN (val->etype))
1215 SPEC_CVAL (val->etype).v_ulong = 0-SPEC_CVAL (val->etype).v_ulong;
1217 SPEC_CVAL (val->etype).v_long = -SPEC_CVAL (val->etype).v_long;
1221 if (SPEC_USIGN (val->etype))
1222 SPEC_CVAL (val->etype).v_uint = 0-SPEC_CVAL (val->etype).v_uint;
1224 SPEC_CVAL (val->etype).v_int = -SPEC_CVAL (val->etype).v_int;
1226 if (SPEC_NOUN(val->etype) == V_CHAR)
1228 /* promote to 'signed int', cheapestVal() might reduce it again */
1229 SPEC_USIGN(val->etype) = 0;
1230 SPEC_NOUN(val->etype) = V_INT;
1232 return cheapestVal (val);
1238 /*------------------------------------------------------------------*/
1239 /* valueComplement - complements a constant */
1240 /*------------------------------------------------------------------*/
1242 valComplement (value * val)
1244 /* depending on type */
1245 if (SPEC_LONG (val->etype))
1247 if (SPEC_USIGN (val->etype))
1248 SPEC_CVAL (val->etype).v_ulong = ~SPEC_CVAL (val->etype).v_ulong;
1250 SPEC_CVAL (val->etype).v_long = ~SPEC_CVAL (val->etype).v_long;
1254 if (SPEC_USIGN (val->etype))
1255 SPEC_CVAL (val->etype).v_uint = ~SPEC_CVAL (val->etype).v_uint;
1257 SPEC_CVAL (val->etype).v_int = ~SPEC_CVAL (val->etype).v_int;
1259 if (SPEC_NOUN(val->etype) == V_CHAR)
1261 /* promote to 'signed int', cheapestVal() might reduce it again */
1262 SPEC_USIGN(val->etype) = 0;
1263 SPEC_NOUN(val->etype) = V_INT;
1265 return cheapestVal (val);
1270 /*------------------------------------------------------------------*/
1271 /* valueNot - complements a constant */
1272 /*------------------------------------------------------------------*/
1274 valNot (value * val)
1276 /* depending on type */
1277 if (SPEC_LONG (val->etype))
1279 if (SPEC_USIGN (val->etype))
1280 SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_ulong;
1282 SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_long;
1286 if (SPEC_USIGN (val->etype))
1287 SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_uint;
1289 SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_int;
1292 /* ANSI: result type is int, value is 0 or 1 */
1293 /* sdcc will hold this in an 'unsigned char' */
1294 SPEC_USIGN(val->etype) = 1;
1295 SPEC_LONG (val->etype) = 0;
1296 SPEC_NOUN(val->etype) = V_CHAR;
1300 /*------------------------------------------------------------------*/
1301 /* valMult - multiply constants */
1302 /*------------------------------------------------------------------*/
1304 valMult (value * lval, value * rval)
1308 /* create a new value */
1310 val->type = val->etype = computeType (lval->etype,
1314 SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1316 if (IS_FLOAT (val->type))
1317 SPEC_CVAL (val->type).v_float = floatFromVal (lval) * floatFromVal (rval);
1319 if (IS_FIXED16X16 (val->type))
1320 SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble(floatFromVal (lval) * floatFromVal (rval));
1321 /* signed and unsigned mul are the same, as long as the precision of the
1322 result isn't bigger than the precision of the operands. */
1323 else if (SPEC_LONG (val->type))
1324 SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) ulFromVal (lval) *
1325 (TYPE_TARGET_ULONG) ulFromVal (rval);
1326 else if (SPEC_USIGN (val->type)) /* unsigned int */
1328 TYPE_TARGET_ULONG ul = (TYPE_TARGET_UINT) ulFromVal (lval) *
1329 (TYPE_TARGET_UINT) ulFromVal (rval);
1331 SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ul;
1332 if (ul != (TYPE_TARGET_UINT) ul)
1335 else /* signed int */
1337 TYPE_TARGET_LONG l = (TYPE_TARGET_INT) floatFromVal (lval) *
1338 (TYPE_TARGET_INT) floatFromVal (rval);
1340 SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) l;
1341 if (l != (TYPE_TARGET_INT) l)
1344 return cheapestVal (val);
1347 /*------------------------------------------------------------------*/
1348 /* valDiv - Divide constants */
1349 /*------------------------------------------------------------------*/
1351 valDiv (value * lval, value * rval)
1355 if (floatFromVal (rval) == 0)
1357 werror (E_DIVIDE_BY_ZERO);
1361 /* create a new value */
1363 val->type = val->etype = computeType (lval->etype,
1367 SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1369 if (IS_FLOAT (val->type))
1370 SPEC_CVAL (val->type).v_float = floatFromVal (lval) / floatFromVal (rval);
1372 if (IS_FIXED16X16 (val->type))
1373 SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble( floatFromVal (lval) / floatFromVal (rval) );
1374 else if (SPEC_LONG (val->type))
1376 if (SPEC_USIGN (val->type))
1377 SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) ulFromVal (lval) /
1378 (TYPE_TARGET_ULONG) ulFromVal (rval);
1380 SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) ulFromVal (lval) /
1381 (TYPE_TARGET_LONG) ulFromVal (rval);
1385 if (SPEC_USIGN (val->type))
1386 SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ulFromVal (lval) /
1387 (TYPE_TARGET_UINT) ulFromVal (rval);
1389 SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) ulFromVal (lval) /
1390 (TYPE_TARGET_INT) ulFromVal (rval);
1392 return cheapestVal (val);
1395 /*------------------------------------------------------------------*/
1396 /* valMod - Modulus constants */
1397 /*------------------------------------------------------------------*/
1399 valMod (value * lval, value * rval)
1403 /* create a new value */
1405 val->type = val->etype = computeType (lval->etype,
1409 SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1411 if (SPEC_LONG (val->type))
1413 if (SPEC_USIGN (val->type))
1414 SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) ulFromVal (lval) %
1415 (TYPE_TARGET_ULONG) ulFromVal (rval);
1417 SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) ulFromVal (lval) %
1418 (TYPE_TARGET_LONG) ulFromVal (rval);
1422 if (SPEC_USIGN (val->type))
1423 SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ulFromVal (lval) %
1424 (TYPE_TARGET_UINT) ulFromVal (rval);
1426 SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) ulFromVal (lval) %
1427 (TYPE_TARGET_INT) ulFromVal (rval);
1429 return cheapestVal (val);
1432 /*------------------------------------------------------------------*/
1433 /* valPlus - Addition constants */
1434 /*------------------------------------------------------------------*/
1436 valPlus (value * lval, value * rval)
1440 /* create a new value */
1442 val->type = val->etype = computeType (lval->etype,
1446 SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1448 if (IS_FLOAT (val->type))
1449 SPEC_CVAL (val->type).v_float = floatFromVal (lval) + floatFromVal (rval);
1451 if (IS_FIXED16X16 (val->type))
1452 SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble( floatFromVal (lval) + floatFromVal (rval) );
1453 else if (SPEC_LONG (val->type))
1455 if (SPEC_USIGN (val->type))
1456 SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) ulFromVal (lval) +
1457 (TYPE_TARGET_ULONG) ulFromVal (rval);
1459 SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) ulFromVal (lval) +
1460 (TYPE_TARGET_LONG) ulFromVal (rval);
1464 if (SPEC_USIGN (val->type))
1465 SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ulFromVal (lval) +
1466 (TYPE_TARGET_UINT) ulFromVal (rval);
1468 SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) ulFromVal (lval) +
1469 (TYPE_TARGET_INT) ulFromVal (rval);
1471 return cheapestVal (val);
1474 /*------------------------------------------------------------------*/
1475 /* valMinus - Addition constants */
1476 /*------------------------------------------------------------------*/
1478 valMinus (value * lval, value * rval)
1482 /* create a new value */
1484 val->type = val->etype = computeType (lval->etype,
1488 SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1490 if (IS_FLOAT (val->type))
1491 SPEC_CVAL (val->type).v_float = floatFromVal (lval) - floatFromVal (rval);
1493 if (IS_FIXED16X16 (val->type))
1494 SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble( floatFromVal (lval) - floatFromVal (rval) );
1495 else if (SPEC_LONG (val->type))
1497 if (SPEC_USIGN (val->type))
1498 SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) ulFromVal (lval) -
1499 (TYPE_TARGET_ULONG) ulFromVal (rval);
1501 SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) ulFromVal (lval) -
1502 (TYPE_TARGET_LONG) ulFromVal (rval);
1506 if (SPEC_USIGN (val->type))
1507 SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ulFromVal (lval) -
1508 (TYPE_TARGET_UINT) ulFromVal (rval);
1510 SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) ulFromVal (lval) -
1511 (TYPE_TARGET_INT) ulFromVal (rval);
1513 return cheapestVal (val);
1516 /*------------------------------------------------------------------*/
1517 /* valShift - Shift left or right */
1518 /*------------------------------------------------------------------*/
1520 valShift (value * lval, value * rval, int lr)
1524 /* create a new value */
1526 val->type = val->etype = computeType (lval->etype,
1530 SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
1532 if (getSize (val->type) * 8 <= (TYPE_TARGET_ULONG) ulFromVal (rval) &&
1535 /* right shift and unsigned */
1536 (!lr && SPEC_USIGN (rval->type))))
1538 werror (W_SHIFT_CHANGED, (lr ? "left" : "right"));
1541 if (SPEC_LONG (val->type))
1543 if (SPEC_USIGN (val->type))
1545 SPEC_CVAL (val->type).v_ulong = lr ?
1546 (TYPE_TARGET_ULONG) ulFromVal (lval) << (TYPE_TARGET_ULONG) ulFromVal (rval) : \
1547 (TYPE_TARGET_ULONG) ulFromVal (lval) >> (TYPE_TARGET_ULONG) ulFromVal (rval);
1551 SPEC_CVAL (val->type).v_long = lr ?
1552 (TYPE_TARGET_LONG) ulFromVal (lval) << (TYPE_TARGET_ULONG) ulFromVal (rval) : \
1553 (TYPE_TARGET_LONG) ulFromVal (lval) >> (TYPE_TARGET_ULONG) ulFromVal (rval);
1558 if (SPEC_USIGN (val->type))
1560 SPEC_CVAL (val->type).v_uint = lr ?
1561 (TYPE_TARGET_UINT) ulFromVal (lval) << (TYPE_TARGET_ULONG) ulFromVal (rval) : \
1562 (TYPE_TARGET_UINT) ulFromVal (lval) >> (TYPE_TARGET_ULONG) ulFromVal (rval);
1566 SPEC_CVAL (val->type).v_int = lr ?
1567 (TYPE_TARGET_INT) ulFromVal (lval) << (TYPE_TARGET_ULONG) ulFromVal (rval) : \
1568 (TYPE_TARGET_INT) ulFromVal (lval) >> (TYPE_TARGET_ULONG) ulFromVal (rval);
1571 return cheapestVal (val);
1574 /*------------------------------------------------------------------*/
1575 /* valCompare- Compares two literal */
1576 /*------------------------------------------------------------------*/
1578 valCompare (value * lval, value * rval, int ctype)
1582 /* create a new value */
1584 val->type = val->etype = newCharLink ();
1585 val->type->class = SPECIFIER;
1586 SPEC_NOUN (val->type) = V_CHAR; /* type is char */
1587 SPEC_USIGN (val->type) = 1;
1588 SPEC_SCLS (val->type) = S_LITERAL; /* will remain literal */
1593 SPEC_CVAL (val->type).v_int = floatFromVal (lval) < floatFromVal (rval);
1597 SPEC_CVAL (val->type).v_int = floatFromVal (lval) > floatFromVal (rval);
1601 SPEC_CVAL (val->type).v_int = floatFromVal (lval) <= floatFromVal (rval);
1605 SPEC_CVAL (val->type).v_int = floatFromVal (lval) >= floatFromVal (rval);
1609 if (SPEC_NOUN(lval->type) == V_FLOAT ||
1610 SPEC_NOUN(rval->type) == V_FLOAT)
1612 SPEC_CVAL (val->type).v_int = floatFromVal (lval) == floatFromVal (rval);
1615 if (SPEC_NOUN(lval->type) == V_FIXED16X16 ||
1616 SPEC_NOUN(rval->type) == V_FIXED16X16)
1618 SPEC_CVAL (val->type).v_int = floatFromVal (lval) == floatFromVal (rval);
1622 /* integrals: ignore signedness */
1623 TYPE_TARGET_ULONG l, r;
1625 l = (TYPE_TARGET_ULONG) ulFromVal (lval);
1626 r = (TYPE_TARGET_ULONG) ulFromVal (rval);
1627 /* In order to correctly compare 'signed int' and 'unsigned int' it's
1628 neccessary to strip them to 16 bit.
1629 Literals are reduced to their cheapest type, therefore left and
1630 right might have different types. It's neccessary to find a
1631 common type: int (used for char too) or long */
1632 if (!IS_LONG (lval->etype) &&
1633 !IS_LONG (rval->etype))
1635 r = (TYPE_TARGET_UINT) r;
1636 l = (TYPE_TARGET_UINT) l;
1638 SPEC_CVAL (val->type).v_int = l == r;
1642 if (SPEC_NOUN(lval->type) == V_FLOAT ||
1643 SPEC_NOUN(rval->type) == V_FLOAT)
1645 SPEC_CVAL (val->type).v_int = floatFromVal (lval) != floatFromVal (rval);
1648 if (SPEC_NOUN(lval->type) == V_FIXED16X16 ||
1649 SPEC_NOUN(rval->type) == V_FIXED16X16)
1651 SPEC_CVAL (val->type).v_int = floatFromVal (lval) != floatFromVal (rval);
1655 /* integrals: ignore signedness */
1656 TYPE_TARGET_ULONG l, r;
1658 l = (TYPE_TARGET_ULONG) ulFromVal (lval);
1659 r = (TYPE_TARGET_ULONG) ulFromVal (rval);
1660 /* In order to correctly compare 'signed int' and 'unsigned int' it's
1661 neccessary to strip them to 16 bit.
1662 Literals are reduced to their cheapest type, therefore left and
1663 right might have different types. It's neccessary to find a
1664 common type: int (used for char too) or long */
1665 if (!IS_LONG (lval->etype) &&
1666 !IS_LONG (rval->etype))
1668 r = (TYPE_TARGET_UINT) r;
1669 l = (TYPE_TARGET_UINT) l;
1671 SPEC_CVAL (val->type).v_int = l != r;
1680 /*------------------------------------------------------------------*/
1681 /* valBitwise - Bitwise operation */
1682 /*------------------------------------------------------------------*/
1684 valBitwise (value * lval, value * rval, int op)
1688 /* create a new value */
1690 val->type = computeType (lval->etype, rval->etype, RESULT_TYPE_CHAR, op);
1691 val->etype = getSpec (val->type);
1692 SPEC_SCLS (val->etype) = S_LITERAL;
1697 if (SPEC_LONG (val->type))
1699 if (SPEC_USIGN (val->type))
1700 SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) ulFromVal (lval) &
1701 (TYPE_TARGET_ULONG) ulFromVal (rval);
1703 SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) ulFromVal (lval) &
1704 (TYPE_TARGET_LONG) ulFromVal (rval);
1708 if (SPEC_USIGN (val->type))
1709 SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ulFromVal (lval) &
1710 (TYPE_TARGET_UINT) ulFromVal (rval);
1712 SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) ulFromVal (lval) &
1713 (TYPE_TARGET_INT) ulFromVal (rval);
1718 if (SPEC_LONG (val->type))
1720 if (SPEC_USIGN (val->type))
1721 SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) ulFromVal (lval) |
1722 (TYPE_TARGET_ULONG) ulFromVal (rval);
1724 SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) ulFromVal (lval) |
1725 (TYPE_TARGET_LONG) ulFromVal (rval);
1729 if (SPEC_USIGN (val->type))
1730 SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ulFromVal (lval) |
1731 (TYPE_TARGET_UINT) ulFromVal (rval);
1733 SPEC_CVAL (val->type).v_int =
1734 (TYPE_TARGET_INT) ulFromVal (lval) | (TYPE_TARGET_INT) ulFromVal (rval);
1740 if (SPEC_LONG (val->type))
1742 if (SPEC_USIGN (val->type))
1743 SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) ulFromVal (lval) ^
1744 (TYPE_TARGET_ULONG) ulFromVal (rval);
1746 SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) ulFromVal (lval) ^
1747 (TYPE_TARGET_LONG) ulFromVal (rval);
1751 if (SPEC_USIGN (val->type))
1752 SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ulFromVal (lval) ^
1753 (TYPE_TARGET_UINT) ulFromVal (rval);
1755 SPEC_CVAL (val->type).v_int =
1756 (TYPE_TARGET_INT) ulFromVal (lval) ^ (TYPE_TARGET_INT) ulFromVal (rval);
1761 return cheapestVal(val);
1764 /*------------------------------------------------------------------*/
1765 /* valAndOr - Generates code for and / or operation */
1766 /*------------------------------------------------------------------*/
1768 valLogicAndOr (value * lval, value * rval, int op)
1772 /* create a new value */
1774 val->type = val->etype = newCharLink ();
1775 val->type->class = SPECIFIER;
1776 SPEC_SCLS (val->type) = S_LITERAL; /* will remain literal */
1777 SPEC_USIGN (val->type) = 1;
1782 SPEC_CVAL (val->type).v_int = floatFromVal (lval) && floatFromVal (rval);
1786 SPEC_CVAL (val->type).v_int = floatFromVal (lval) || floatFromVal (rval);
1794 /*------------------------------------------------------------------*/
1795 /* valCastLiteral - casts a literal value to another type */
1796 /*------------------------------------------------------------------*/
1798 valCastLiteral (sym_link * dtype, double fval)
1801 unsigned long l = double2ul (fval);
1808 val->etype = getSpec (val->type = copyLinkChain (dtype));
1811 val->etype = val->type = newLink (SPECIFIER);
1812 SPEC_NOUN (val->etype) = V_VOID;
1814 SPEC_SCLS (val->etype) = S_LITERAL;
1816 /* if it is not a specifier then we can assume that */
1817 /* it will be an unsigned long */
1818 if (!IS_SPEC (val->type))
1820 SPEC_CVAL (val->etype).v_ulong = (TYPE_TARGET_ULONG) l;
1824 switch (SPEC_NOUN (val->etype))
1827 SPEC_CVAL (val->etype).v_float = fval;
1831 SPEC_CVAL (val->etype).v_fixed16x16 = fixed16x16FromDouble (fval);
1836 SPEC_CVAL (val->etype).v_uint = fval ? 1 : 0;
1840 l &= (0xffffffffu >> (32 - SPEC_BLEN (val->etype)));
1841 if (SPEC_USIGN (val->etype))
1842 SPEC_CVAL (val->etype).v_uint = (TYPE_TARGET_UINT) l;
1844 SPEC_CVAL (val->etype).v_int = (TYPE_TARGET_INT) l;
1848 if (SPEC_USIGN (val->etype))
1849 SPEC_CVAL (val->etype).v_uint = (TYPE_TARGET_UCHAR) l;
1851 SPEC_CVAL (val->etype).v_int = (TYPE_TARGET_CHAR) l;
1855 if (SPEC_LONG (val->etype))
1857 if (SPEC_USIGN (val->etype))
1858 SPEC_CVAL (val->etype).v_ulong = (TYPE_TARGET_ULONG) l;
1860 SPEC_CVAL (val->etype).v_long = (TYPE_TARGET_LONG) l;
1864 if (SPEC_USIGN (val->etype))
1865 SPEC_CVAL (val->etype).v_uint = (TYPE_TARGET_UINT) l;
1867 SPEC_CVAL (val->etype).v_int = (TYPE_TARGET_INT) l;
1874 /*------------------------------------------------------------------*/
1875 /* getNelements - determines # of elements from init list */
1876 /*------------------------------------------------------------------*/
1878 getNelements (sym_link * type, initList * ilist)
1885 if (ilist->type == INIT_DEEP)
1886 ilist = ilist->init.deep;
1888 /* if type is a character array and there is only one
1889 (string) initialiser then get the length of the string */
1890 if (IS_ARRAY (type) && IS_CHAR (type->next) && !ilist->next)
1892 ast *iast = ilist->init.node;
1893 value *v = (iast->type == EX_VALUE ? iast->opval.val : NULL);
1896 werror (E_CONST_EXPECTED);
1900 if (IS_ARRAY (v->type) && IS_CHAR (v->etype))
1901 /* yep, it's a string */
1903 return DCL_ELEM (v->type);
1911 ilist = ilist->next;
1916 /*-----------------------------------------------------------------*/
1917 /* valForArray - returns a value with name of array index */
1918 /*-----------------------------------------------------------------*/
1920 valForArray (ast * arrExpr)
1922 value *val, *lval = NULL;
1924 int size = getSize (arrExpr->left->ftype->next);
1925 /* if the right or left is an array
1927 if (IS_AST_OP (arrExpr->left))
1929 if (arrExpr->left->opval.op == '[')
1930 lval = valForArray (arrExpr->left);
1931 else if (arrExpr->left->opval.op == '.')
1932 lval = valForStructElem (arrExpr->left->left,
1933 arrExpr->left->right);
1934 else if (arrExpr->left->opval.op == PTR_OP &&
1935 IS_ADDRESS_OF_OP (arrExpr->left->left))
1936 lval = valForStructElem (arrExpr->left->left->left,
1937 arrExpr->left->right);
1942 else if (!IS_AST_SYM_VALUE (arrExpr->left))
1945 if (!IS_AST_LIT_VALUE (arrExpr->right))
1951 SNPRINTF (buffer, sizeof(buffer), "%s", AST_SYMBOL (arrExpr->left)->rname);
1955 SNPRINTF (buffer, sizeof(buffer), "%s", lval->name);
1958 SNPRINTF (val->name, sizeof(val->name), "(%s + %d)", buffer,
1959 AST_ULONG_VALUE (arrExpr->right) * size);
1961 val->type = newLink (DECLARATOR);
1962 if (SPEC_SCLS (arrExpr->left->etype) == S_CODE)
1963 DCL_TYPE (val->type) = CPOINTER;
1964 else if (SPEC_SCLS (arrExpr->left->etype) == S_XDATA)
1965 DCL_TYPE (val->type) = FPOINTER;
1966 else if (SPEC_SCLS (arrExpr->left->etype) == S_XSTACK)
1967 DCL_TYPE (val->type) = PPOINTER;
1968 else if (SPEC_SCLS (arrExpr->left->etype) == S_IDATA)
1969 DCL_TYPE (val->type) = IPOINTER;
1970 else if (SPEC_SCLS (arrExpr->left->etype) == S_EEPROM)
1971 DCL_TYPE (val->type) = EEPPOINTER;
1973 DCL_TYPE (val->type) = POINTER;
1974 val->type->next = arrExpr->left->ftype->next;
1975 val->etype = getSpec (val->type);
1979 /*-----------------------------------------------------------------*/
1980 /* valForStructElem - returns value with name of struct element */
1981 /*-----------------------------------------------------------------*/
1983 valForStructElem (ast * structT, ast * elemT)
1985 value *val, *lval = NULL;
1989 /* left could be furthur derefed */
1990 if (IS_AST_OP (structT))
1992 if (structT->opval.op == '[')
1993 lval = valForArray (structT);
1994 else if (structT->opval.op == '.')
1995 lval = valForStructElem (structT->left, structT->right);
1996 else if (structT->opval.op == PTR_OP &&
1997 IS_ADDRESS_OF_OP (structT->left))
1998 lval = valForStructElem (structT->left->left,
2004 if (!IS_AST_SYM_VALUE (elemT))
2007 if (!IS_STRUCT (structT->etype))
2010 if ((sym = getStructElement (SPEC_STRUCT (structT->etype),
2011 AST_SYMBOL (elemT))) == NULL)
2019 SNPRINTF(buffer, sizeof(buffer), "%s", AST_SYMBOL (structT)->rname);
2023 SNPRINTF (buffer, sizeof(buffer), "%s", lval->name);
2026 SNPRINTF (val->name, sizeof(val->name), "(%s + %d)", buffer,
2029 val->type = newLink (DECLARATOR);
2030 if (SPEC_SCLS (structT->etype) == S_CODE)
2031 DCL_TYPE (val->type) = CPOINTER;
2032 else if (SPEC_SCLS (structT->etype) == S_XDATA)
2033 DCL_TYPE (val->type) = FPOINTER;
2034 else if (SPEC_SCLS (structT->etype) == S_XSTACK)
2035 DCL_TYPE (val->type) = PPOINTER;
2036 else if (SPEC_SCLS (structT->etype) == S_IDATA)
2037 DCL_TYPE (val->type) = IPOINTER;
2038 else if (SPEC_SCLS (structT->etype) == S_EEPROM)
2039 DCL_TYPE (val->type) = EEPPOINTER;
2041 DCL_TYPE (val->type) = POINTER;
2042 val->type->next = sym->type;
2043 val->etype = getSpec (val->type);
2047 /*-----------------------------------------------------------------*/
2048 /* valForCastAggr - will return value for a cast of an aggregate */
2049 /* plus minus a constant */
2050 /*-----------------------------------------------------------------*/
2052 valForCastAggr (ast * aexpr, sym_link * type, ast * cnst, int op)
2056 if (!IS_AST_SYM_VALUE (aexpr))
2058 if (!IS_AST_LIT_VALUE (cnst))
2063 SNPRINTF (val->name, sizeof(val->name), "(%s %c %d)",
2064 AST_SYMBOL (aexpr)->rname, op,
2065 getSize (type->next) * AST_ULONG_VALUE (cnst));
2068 val->etype = getSpec (val->type);
2072 /*-----------------------------------------------------------------*/
2073 /* valForCastAggr - will return value for a cast of an aggregate */
2074 /* with no constant */
2075 /*-----------------------------------------------------------------*/
2077 valForCastArr (ast * aexpr, sym_link * type)
2081 if (!IS_AST_SYM_VALUE (aexpr))
2086 SNPRINTF (val->name, sizeof(val->name), "(%s)",
2087 AST_SYMBOL (aexpr)->rname);
2090 val->etype = getSpec (val->type);