X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCval.c;h=e520aff50004b4956ba99a54493ca600d3e09338;hb=5294a698ee4cea2593f685b81b3b623e72b66518;hp=5a49f4dc0003c178507db417f482b3ffff5717f3;hpb=478e6bc0bb6903e61ba8d9c12612adfae6dee7a3;p=fw%2Fsdcc diff --git a/src/SDCCval.c b/src/SDCCval.c index 5a49f4dc..e520aff5 100644 --- a/src/SDCCval.c +++ b/src/SDCCval.c @@ -27,6 +27,7 @@ #include #include #include +#include #include "newalloc.h" int cNestLevel; @@ -35,7 +36,7 @@ int cNestLevel; /* newValue - allocates and returns a new value */ /*-----------------------------------------------------------------*/ value * -newValue () +newValue (void) { value *val; @@ -52,11 +53,11 @@ newiList (int type, void *ilist) { initList *nilist; - nilist = Safe_alloc (sizeof (initList)); nilist->type = type; - nilist->lineno = mylineno; + nilist->filename = lexFilename; + nilist->lineno = lexLineno; switch (type) { @@ -73,7 +74,7 @@ newiList (int type, void *ilist) } /*------------------------------------------------------------------*/ -/* revinit - reverses the initial values for a value chain */ +/* revinit - reverses the initial values for a value chain */ /*------------------------------------------------------------------*/ initList * revinit (initList * val) @@ -98,70 +99,76 @@ revinit (initList * val) } bool -convertIListToConstList(initList *src, literalList **lList) +convertIListToConstList(initList *src, literalList **lList, int size) { + int cnt = 0; initList *iLoop; literalList *head, *last, *newL; - + head = last = NULL; - - if (!src || src->type != INIT_DEEP) + + if (src && src->type != INIT_DEEP) { - return FALSE; + return FALSE; } - - iLoop = src->init.deep; - + + iLoop = src ? src->init.deep : NULL; + while (iLoop) { - if (iLoop->type != INIT_NODE) - { - return FALSE; - } - - if (!IS_AST_LIT_VALUE(decorateType(resolveSymbols(iLoop->init.node)))) - { - return FALSE; - } - iLoop = iLoop->next; - } - - // We've now established that the initializer list contains only literal values. - - iLoop = src->init.deep; - while (iLoop) + if (iLoop->type != INIT_NODE) + { + return FALSE; + } + + if (!IS_AST_LIT_VALUE(decorateType(resolveSymbols(iLoop->init.node), RESULT_TYPE_NONE))) + { + return FALSE; + } + iLoop = iLoop->next; + cnt++; + } + if (!size) + { + size = cnt; + } + + /* We've now established that the initializer list contains only literal values. */ + + iLoop = src ? src->init.deep : NULL; + while (size--) { - double val = AST_LIT_VALUE(iLoop->init.node); - - if (last && last->literalValue == val) - { - last->count++; - } - else - { - newL = Safe_alloc(sizeof(literalList)); - newL->literalValue = val; - newL->count = 1; - newL->next = NULL; - - if (last) - { - last->next = newL; - } - else - { - head = newL; - } - last = newL; - } - iLoop = iLoop->next; - } - - if (!head) - { - return FALSE; - } - + double val = iLoop ? AST_FLOAT_VALUE(iLoop->init.node) : 0; + + if (last && last->literalValue == val) + { + last->count++; + } + else + { + newL = Safe_alloc(sizeof(literalList)); + newL->literalValue = val; + newL->count = 1; + newL->next = NULL; + + if (last) + { + last->next = newL; + } + else + { + head = newL; + } + last = newL; + } + iLoop = iLoop ? iLoop->next : NULL; + } + + if (!head) + { + return FALSE; + } + *lList = head; return TRUE; } @@ -170,36 +177,36 @@ literalList * copyLiteralList(literalList *src) { literalList *head, *prev, *newL; - + head = prev = NULL; - + while (src) { - newL = Safe_alloc(sizeof(literalList)); - - newL->literalValue = src->literalValue; - newL->count = src->count; - newL->next = NULL; - - if (prev) - { - prev->next = newL; - } - else - { - head = newL; - } - prev = newL; - src = src->next; - } - + newL = Safe_alloc(sizeof(literalList)); + + newL->literalValue = src->literalValue; + newL->count = src->count; + newL->next = NULL; + + if (prev) + { + prev->next = newL; + } + else + { + head = newL; + } + prev = newL; + src = src->next; + } + return head; } /*------------------------------------------------------------------*/ -/* copyIlist - copy initializer list */ +/* copyIlist - copy initializer list */ /*------------------------------------------------------------------*/ initList * copyIlist (initList * src) @@ -228,7 +235,7 @@ copyIlist (initList * src) /*------------------------------------------------------------------*/ /* list2int - converts the first element of the list to value */ /*------------------------------------------------------------------*/ -double +double list2int (initList * val) { initList *i = val; @@ -260,6 +267,8 @@ list2val (initList * val) ast * list2expr (initList * ilist) { + if (!ilist) + return NULL; if (ilist->type == INIT_DEEP) return list2expr (ilist->init.deep); return ilist->init.node; @@ -268,24 +277,31 @@ list2expr (initList * ilist) /*------------------------------------------------------------------*/ /* resolveIvalSym - resolve symbols in initial values */ /*------------------------------------------------------------------*/ -void -resolveIvalSym (initList * ilist) +void +resolveIvalSym (initList * ilist, sym_link * type) { - if (!ilist) - return; + int is_ptr = IS_PTR (type); + RESULT_TYPE resultType = getResultTypeFromType (getSpec (type)); - if (ilist->type == INIT_NODE) - ilist->init.node = decorateType (resolveSymbols (ilist->init.node)); - - if (ilist->type == INIT_DEEP) - resolveIvalSym (ilist->init.deep); + while (ilist) + { + if (ilist->type == INIT_NODE) + { + ilist->init.node = decorateType (resolveSymbols (ilist->init.node), + is_ptr ? RESULT_TYPE_INT : resultType); + } + else if (ilist->type == INIT_DEEP) + { + resolveIvalSym (ilist->init.deep, type); + } - resolveIvalSym (ilist->next); + ilist = ilist->next; + } } -/*-----------------------------------------------------------------*/ -/* symbolVal - creates a value for a symbol */ -/*-----------------------------------------------------------------*/ +/*------------------------------------------------------------------*/ +/* symbolVal - creates a value for a symbol */ +/*------------------------------------------------------------------*/ value * symbolVal (symbol * sym) { @@ -305,69 +321,307 @@ symbolVal (symbol * sym) if (*sym->rname) { - SNPRINTF (val->name, sizeof(val->name), "%s", sym->rname); + SNPRINTF (val->name, sizeof(val->name), "%s", sym->rname); } else { - SNPRINTF (val->name, sizeof(val->name), "_%s", sym->name); + SNPRINTF (val->name, sizeof(val->name), "_%s", sym->name); } return val; } /*--------------------------------------------------------------------*/ -/* cheapestVal - convert a val to the cheapest as possible value */ +/* cheapestVal - try to reduce 'signed int' to 'char' */ /*--------------------------------------------------------------------*/ -value *cheapestVal (value *val) { - TYPE_DWORD sval=0; - TYPE_UDWORD uval=0; +static value * +cheapestVal (value *val) +{ + /* only int can be reduced */ + if (!IS_INT(val->type)) + return val; - if (IS_FLOAT(val->type) || IS_CHAR(val->type)) + /* long must not be changed */ + if (SPEC_LONG(val->type)) return val; - if (SPEC_LONG(val->type)) { - if (SPEC_USIGN(val->type)) { - uval=SPEC_CVAL(val->type).v_ulong; - } else { - sval=SPEC_CVAL(val->type).v_long; - } - } else { - if (SPEC_USIGN(val->type)) { - uval=SPEC_CVAL(val->type).v_uint; - } else { - sval=SPEC_CVAL(val->type).v_int; - } - } - - if (SPEC_USIGN(val->type)) { - if (uval<=0xffff) { - SPEC_LONG(val->type)=0; - SPEC_CVAL(val->type).v_uint = uval; - if (uval<=0xff) { - SPEC_NOUN(val->type)=V_CHAR; - } + /* unsigned must not be changed */ + if (SPEC_USIGN(val->type)) + return val; + + /* the only possible reduction is from signed int to (un)signed char, + because it's automatically promoted back to signed int. + + a reduction from unsigned int to unsigned char is a bug, + because an _unsigned_ char is promoted to _signed_ int! */ + if (SPEC_CVAL(val->type).v_int < -128 || + SPEC_CVAL(val->type).v_int > 255) + { + /* not in the range of (un)signed char */ + return val; } - } else { // not unsigned - if (sval<0) { - if (sval>=-32768) { - SPEC_LONG(val->type)=0; - SPEC_CVAL(val->type).v_int = sval; - if (sval>=-128) { - SPEC_NOUN(val->type)=V_CHAR; - } - } - } else { // sval>=0 - SPEC_USIGN(val->type)=1; - if (sval<=65535) { - SPEC_LONG(val->type)=0; - SPEC_CVAL(val->type).v_int = sval; - if (sval<=255) { - SPEC_NOUN(val->type)=V_CHAR; - } + + SPEC_NOUN(val->type) = V_CHAR; + + /* 'unsigned char' promotes to 'signed int', so that we can + reduce it the other way */ + if (SPEC_CVAL(val->type).v_int >= 0) + { + SPEC_USIGN(val->type) = 1; + } + return (val); +} + +/*--------------------------------------------------------------------*/ +/* checkConstantRange - check if constant fits in numeric range of */ +/* var type in comparisons and assignments */ +/*--------------------------------------------------------------------*/ +CCR_RESULT +checkConstantRange (sym_link *var, sym_link *lit, int op, bool exchangeLeftRight) +{ + sym_link *reType; + double litVal; + int varBits; + + litVal = floatFromVal (valFromType (lit)); + varBits = bitsForType (var); + + /* sanity checks */ + if ( IS_FLOAT (var) + || IS_FIXED (var)) + return CCR_OK; + if (varBits < 1) + return CCR_ALWAYS_FALSE; + if (varBits > 32) + return CCR_ALWAYS_TRUE; + + /* special: assignment */ + if (op == '=') + { + if (IS_BIT (var)) + return CCR_OK; + + if (getenv ("SDCC_VERY_PEDANTIC")) + { + if (SPEC_USIGN (var)) + { + TYPE_TARGET_ULONG maxVal = 0xffffffffu >> (32 - varBits); + + if ( litVal < 0 + || litVal > maxVal) + return CCR_OVL; + return CCR_OK; + } + else + { + TYPE_TARGET_LONG minVal = 0xffffffff << (varBits - 1); + TYPE_TARGET_LONG maxVal = 0x7fffffff >> (32 - varBits); + + if ( litVal < minVal + || litVal > maxVal) + return CCR_OVL; + return CCR_OK; + } + } + else + { + /* ignore signedness, e.g. allow everything + from -127...+255 for (unsigned) char */ + TYPE_TARGET_LONG minVal = 0xffffffff << (varBits - 1); + TYPE_TARGET_ULONG maxVal = 0xffffffffu >> (32 - varBits); + + if ( litVal < minVal + || litVal > maxVal) + return CCR_OVL; + return CCR_OK; + } + } + + if (exchangeLeftRight) + switch (op) + { + case EQ_OP: break; + case NE_OP: break; + case '>': op = '<'; break; + case GE_OP: op = LE_OP; break; + case '<': op = '>'; break; + case LE_OP: op = GE_OP; break; + default: return CCR_ALWAYS_FALSE; } + + reType = computeType (var, lit, RESULT_TYPE_NONE, op); + + if (SPEC_USIGN (reType)) + { + /* unsigned operation */ + TYPE_TARGET_ULONG minValP, maxValP, minValM, maxValM; + TYPE_TARGET_ULONG opBitsMask = 0xffffffffu >> (32 - bitsForType (reType)); + + if (SPEC_USIGN (lit) && SPEC_USIGN (var)) + { + /* both operands are unsigned, this is easy */ + minValP = 0; + maxValP = 0xffffffffu >> (32 - varBits); + /* there's only range, just copy it to 2nd set */ + minValM = minValP; + maxValM = maxValP; + } + else if (SPEC_USIGN (var)) + { + /* lit is casted from signed to unsigned, e.g.: + unsigned u; + u == (char) -17 + -> u == 0xffef' + */ + minValP = 0; + maxValP = 0xffffffffu >> (32 - varBits); + /* there's only one range, just copy it to 2nd set */ + minValM = minValP; + maxValM = maxValP; + + /* it's an unsigned operation */ + if ( IS_CHAR (reType) + || IS_INT (reType)) + { + /* make signed literal unsigned and + limit no of bits to size of return type */ + litVal = (TYPE_TARGET_ULONG) double2ul (litVal) & opBitsMask; + } + } + else /* SPEC_USIGN (lit) */ + { + /* var is casted from signed to unsigned, e.g.: + signed char c; + c == (unsigned) -17 + -> c == 0xffef' + + The possible values after casting var + split up in two, nonconsecutive ranges: + + minValP = 0; positive range: 0...127 + maxValP = 0x7f; + minValM = 0xff80; negative range: -128...-1 + maxValM = 0xffff; + */ + + /* positive range */ + minValP = 0; + maxValP = 0x7fffffffu >> (32 - varBits); + + /* negative range */ + minValM = 0xffffffff << (varBits - 1); + maxValM = 0xffffffffu; /* -1 */ + /* limit no of bits to size of return type */ + minValM &= opBitsMask; + maxValM &= opBitsMask; + } + + switch (op) + { + case EQ_OP: /* var == lit */ + if ( litVal <= maxValP + && litVal >= minValP) /* 0 */ + return CCR_OK; + if ( litVal <= maxValM + && litVal >= minValM) + return CCR_OK; + return CCR_ALWAYS_FALSE; + case NE_OP: /* var != lit */ + if ( litVal <= maxValP + && litVal >= minValP) /* 0 */ + return CCR_OK; + if ( litVal <= maxValM + && litVal >= minValM) + return CCR_OK; + return CCR_ALWAYS_TRUE; + case '>': /* var > lit */ + if (litVal >= maxValM) + return CCR_ALWAYS_FALSE; + if (litVal < minValP) /* 0 */ + return CCR_ALWAYS_TRUE; + return CCR_OK; + case GE_OP: /* var >= lit */ + if (litVal > maxValM) + return CCR_ALWAYS_FALSE; + if (litVal <= minValP) /* 0 */ + return CCR_ALWAYS_TRUE; + return CCR_OK; + case '<': /* var < lit */ + if (litVal > maxValM) + return CCR_ALWAYS_TRUE; + if (litVal <= minValP) /* 0 */ + return CCR_ALWAYS_FALSE; + return CCR_OK; + case LE_OP: /* var <= lit */ + if (litVal >= maxValM) + return CCR_ALWAYS_TRUE; + if (litVal < minValP) /* 0 */ + return CCR_ALWAYS_FALSE; + return CCR_OK; + default: + return CCR_ALWAYS_FALSE; + } + } + else + { + /* signed operation */ + TYPE_TARGET_LONG minVal, maxVal; + + if (SPEC_USIGN (var)) + { + /* unsigned var, but signed operation. This happens + when var is promoted to signed int. + Set actual min/max values of var. */ + minVal = 0; + maxVal = 0xffffffff >> (32 - varBits); + } + else + { + /* signed var */ + minVal = 0xffffffff << (varBits - 1); + maxVal = 0x7fffffff >> (32 - varBits); + } + + switch (op) + { + case EQ_OP: /* var == lit */ + if ( litVal > maxVal + || litVal < minVal) + return CCR_ALWAYS_FALSE; + return CCR_OK; + case NE_OP: /* var != lit */ + if ( litVal > maxVal + || litVal < minVal) + return CCR_ALWAYS_TRUE; + return CCR_OK; + case '>': /* var > lit */ + if (litVal >= maxVal) + return CCR_ALWAYS_FALSE; + if (litVal < minVal) + return CCR_ALWAYS_TRUE; + return CCR_OK; + case GE_OP: /* var >= lit */ + if (litVal > maxVal) + return CCR_ALWAYS_FALSE; + if (litVal <= minVal) + return CCR_ALWAYS_TRUE; + return CCR_OK; + case '<': /* var < lit */ + if (litVal > maxVal) + return CCR_ALWAYS_TRUE; + if (litVal <= minVal) + return CCR_ALWAYS_FALSE; + return CCR_OK; + case LE_OP: /* var <= lit */ + if (litVal >= maxVal) + return CCR_ALWAYS_TRUE; + if (litVal < minVal) + return CCR_ALWAYS_FALSE; + return CCR_OK; + default: + return CCR_ALWAYS_FALSE; + } } - } - return val; } /*-----------------------------------------------------------------*/ @@ -378,9 +632,9 @@ valueFromLit (double lit) { char buffer[50]; - if ((((TYPE_DWORD) lit) - lit) == 0) + if ((((TYPE_TARGET_LONG) lit) - lit) == 0) { - SNPRINTF (buffer, sizeof(buffer), "%d", (TYPE_DWORD) lit); + SNPRINTF (buffer, sizeof(buffer), "%d", (TYPE_TARGET_LONG) lit); return constVal (buffer); } @@ -392,15 +646,17 @@ valueFromLit (double lit) /* constFloatVal - converts a FLOAT constant to value */ /*-----------------------------------------------------------------*/ value * -constFloatVal (char *s) +constFloatVal (const char *s) { value *val = newValue (); double sval; + char *p; - if (sscanf (s, "%lf", &sval) != 1) + sval = strtod(s, &p); + if (p == s) { werror (E_INVALID_FLOAT_CONST, s); - return constVal ("0"); + return constCharVal (0); } val->type = val->etype = newLink (SPECIFIER); @@ -411,267 +667,204 @@ constFloatVal (char *s) return val; } +/*-----------------------------------------------------------------*/ +/* constFixed16x16Val - converts a FIXED16X16 constant to value */ +/*-----------------------------------------------------------------*/ +value * +constFixed16x16Val (const char *s) +{ + value *val = newValue (); + double sval; + char *p; + + sval = strtod(s, &p); + if (p == s) + { + werror (E_INVALID_FLOAT_CONST, s); + return constCharVal (0); + } + + val->type = val->etype = newLink (SPECIFIER); + SPEC_NOUN (val->type) = V_FLOAT; + SPEC_SCLS (val->type) = S_LITERAL; + SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble ( sval ); + + return val; +} + /*-----------------------------------------------------------------*/ /* constVal - converts an INTEGER constant into a cheapest value */ /*-----------------------------------------------------------------*/ -value *constVal (char *s) +value *constVal (const char *s) { value *val; - short hex = 0, octal = 0; - char scanFmt[10]; - int scI = 0; + char *p; double dval; + bool is_integral = 0; - val = newValue (); /* alloc space for value */ + val = newValue (); /* alloc space for value */ - val->type = val->etype = newLink (SPECIFIER); /* create the spcifier */ + val->type = val->etype = newLink (SPECIFIER); /* create the specifier */ SPEC_SCLS (val->type) = S_LITERAL; - // let's start with an unsigned char + /* let's start with a signed char */ SPEC_NOUN (val->type) = V_CHAR; SPEC_USIGN (val->type) = 0; - hex = ((strchr (s, 'x') || strchr (s, 'X')) ? 1 : 0); - - /* set the octal flag */ - if (!hex && *s == '0' && *(s + 1)) - octal = 1; - - /* create the scan string */ - scanFmt[scI++] = '%'; - - scanFmt[scI++] = 'l'; - - if (octal) - scanFmt[scI++] = 'o'; - else if (hex) - scanFmt[scI++] = 'x'; + errno = 0; + if (s[0] == '0') + { + if (s[1] == 'b' || s[1] == 'B') + dval = strtoul (s + 2, &p, 2); + else + dval = strtoul (s, &p, 0); + is_integral = 1; + } else - scanFmt[scI++] = 'f'; - - scanFmt[scI++] = '\0'; + dval = strtod (s, &p); - if (octal || hex) { - unsigned long sval; - sscanf (s, scanFmt, &sval); - dval=sval; - SPEC_USIGN (val->type) = 1; - } else { - sscanf (s, scanFmt, &dval); - } + if (errno) + { + dval = 4294967295.0; + werror (W_INVALID_INT_CONST, s, dval); + } /* Setup the flags first */ - /* set the _long flag if 'lL' is found */ - if (strchr (s, 'l') || strchr (s, 'L')) { - SPEC_NOUN (val->type) = V_INT; - SPEC_LONG (val->type) = 1; - } - /* set the unsigned flag if 'uU' is found */ - if (strchr (s, 'u') || strchr (s, 'U')) { - SPEC_USIGN (val->type) = 1; - } + if (strchr (p, 'u') || strchr (p, 'U')) + { + SPEC_USIGN (val->type) = 1; + } - if (dval<0) { // "-28u" will still be signed and negative - if (dval<-128) { // check if we have to promote to int + /* set the b_long flag if 'lL' is found */ + if (strchr (p, 'l') || strchr (p, 'L')) + { SPEC_NOUN (val->type) = V_INT; - } - if (dval<-32768) { // check if we have to promote to long int SPEC_LONG (val->type) = 1; } - } else { // >=0 - if (dval>0xff && SPEC_USIGN (val->type)) { // check if we have to promote to int - SPEC_NOUN (val->type) = V_INT; + else + { + if (dval < 0) + { /* "-28u" will still be signed and negative */ + if (dval < -128) + { /* check if we have to promote to int */ + SPEC_NOUN (val->type) = V_INT; + } + if (dval < -32768) + { /* check if we have to promote to long int */ + SPEC_LONG (val->type) = 1; + } + } + else + { /* >=0 */ + if (dval > 0xff || /* check if we have to promote to int */ + SPEC_USIGN (val->type)) + { /* if it's unsigned, we can't use unsigned + char. After an integral promotion it will + be a signed int; this certainly isn't what + the programer wants */ + SPEC_NOUN (val->type) = V_INT; + } + else + { /* store char's always as unsigned; this helps other optimizations */ + SPEC_USIGN (val->type) = 1; + } + if (dval > 0xffff && SPEC_USIGN (val->type)) + { /* check if we have to promote to long */ + SPEC_LONG (val->type) = 1; + } + else if (dval > 0x7fff && !SPEC_USIGN (val->type)) + { /* check if we have to promote to long int */ + if (is_integral && /* integral (hex, octal and binary) constants may be stored in unsigned type */ + dval <= 0xffff) + { + SPEC_USIGN (val->type) = 1; + } + else + { + SPEC_LONG (val->type) = 1; + if (dval > 0x7fffffff) + { + SPEC_USIGN (val->type) = 1; + } + } + } + } } - else if (dval>0x7f && !SPEC_USIGN (val->type)) { // check if we have to promote to int - SPEC_NOUN (val->type) = V_INT; + + /* check for out of range */ + if (dval < -2147483648.0) + { + dval = -2147483648.0; + werror (W_INVALID_INT_CONST, s, dval); } - if (dval>0xffff && SPEC_USIGN (val->type)) { // check if we have to promote to long - SPEC_LONG (val->type) = 1; + if (dval > 2147483647.0 && !SPEC_USIGN (val->type)) + { + dval = 2147483647.0; + werror (W_INVALID_INT_CONST, s, dval); } - else if (dval>0x7fff && !SPEC_USIGN (val->type)) { // check if we have to promote to long int - SPEC_LONG (val->type) = 1; + if (dval > 4294967295.0) + { + dval = 4294967295.0; + werror (W_INVALID_INT_CONST, s, dval); } - } if (SPEC_LONG (val->type)) { if (SPEC_USIGN (val->type)) { - SPEC_CVAL (val->type).v_ulong = dval; + SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) double2ul (dval); } else { - SPEC_CVAL (val->type).v_long = dval; + SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) double2ul (dval); } } else { if (SPEC_USIGN (val->type)) { - SPEC_CVAL (val->type).v_uint = dval; + SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) double2ul (dval); } else { - SPEC_CVAL (val->type).v_int = dval; + SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) double2ul (dval); } } return val; } -/*! /fn char hexEscape(char **src) - - /param src Pointer to 'x' from start of hex character value -*/ - -unsigned char hexEscape(char **src) +value *constCharVal (unsigned char v) { - char *s ; - unsigned long value ; - - (*src)++ ; /* Skip over the 'x' */ - s = *src ; /* Save for error detection */ - - value = strtol (*src, src, 16); - - if (s == *src) { - // no valid hex found - werror(E_INVALID_HEX); - } else { - if (value > 255) { - werror(W_ESC_SEQ_OOR_FOR_CHAR); - } - } - return (char) value; -} + value *val = newValue (); /* alloc space for value */ -/*------------------------------------------------------------------*/ -/* octalEscape - process an octal constant of max three digits */ -/* return the octal value, throw a warning for illegal octal */ -/* adjust src to point at the last proccesed char */ -/*------------------------------------------------------------------*/ + val->type = val->etype = newLink (SPECIFIER); /* create the specifier */ + SPEC_SCLS (val->type) = S_LITERAL; -unsigned char octalEscape (char **str) { - int digits; - unsigned value=0; + SPEC_NOUN (val->type) = V_CHAR; - for (digits=0; digits<3; digits++) { - if (**str>='0' && **str<='7') { - value = value*8 + (**str-'0'); - (*str)++; - } else { - break; - } - } - if (digits) { - if (value > 255 /* || (**str>='0' && **str<='7') */ ) { - werror (W_ESC_SEQ_OOR_FOR_CHAR); + if (options.unsigned_char) + { + SPEC_USIGN (val->type) = 1; + SPEC_CVAL (val->type).v_uint = (unsigned char) v; } - } - return value; -} - -/*! - /fn int copyStr (char *dest, char *src) - - Copies a source string to a dest buffer interpreting escape sequences - and special characters - - /param dest Buffer to receive the resultant string - /param src Buffer containing the source string with escape sequecnes - /return Number of characters in output string - -*/ - -int -copyStr (char *dest, char *src) - -{ - char *OriginalDest = dest ; - - while (*src) - { - if (*src == '\"') - src++; - else if (*src == '\\') - { - src++; - switch (*src) - { - case 'n': - *dest++ = '\n'; - break; - case 't': - *dest++ = '\t'; - break; - case 'v': - *dest++ = '\v'; - break; - case 'b': - *dest++ = '\b'; - break; - case 'r': - *dest++ = '\r'; - break; - case 'f': - *dest++ = '\f'; - break; - case 'a': - *dest++ = '\a'; - break; - - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - *dest++ = octalEscape(&src); - src-- ; - break; - - case 'x': - *dest++ = hexEscape(&src) ; - src-- ; - break ; - - case '\\': - *dest++ = '\\'; - break; - case '\?': - *dest++ = '\?'; - break; - case '\'': - *dest++ = '\''; - break; - case '\"': - *dest++ = '\"'; - break; - default: - *dest++ = *src; - } - src++; - } - else - *dest++ = *src++; + else + { + SPEC_CVAL (val->type).v_int = (signed char) v; } - *dest++ = '\0'; - - return dest - OriginalDest ; + return val; } /*------------------------------------------------------------------*/ -/* strVal - converts a string constant to a value */ +/* strVal - converts a string constant to a value */ /*------------------------------------------------------------------*/ value * -strVal (char *s) +strVal (const char *s) { value *val; - val = newValue (); /* get a new one */ + val = newValue (); /* get a new one */ /* get a declarator */ val->type = newLink (DECLARATOR); @@ -774,85 +967,59 @@ copyValue (value * src) } /*------------------------------------------------------------------*/ -/* charVal - converts a character constant to a value */ +/* charVal - converts a character constant to a value */ /*------------------------------------------------------------------*/ value * -charVal (char *s) +charVal (const char *s) { - value *val; - - val = newValue (); - - val->type = val->etype = newLink (SPECIFIER); - SPEC_NOUN (val->type) = V_CHAR; - SPEC_USIGN(val->type) = 1; - SPEC_SCLS (val->type) = S_LITERAL; - - s++; /* get rid of quotation */ + /* get rid of quotation */ /* if \ then special processing */ - if (*s == '\\') - { - s++; /* go beyond the backslash */ - switch (*s) - { - case 'n': - SPEC_CVAL (val->type).v_uint = '\n'; - break; - case 't': - SPEC_CVAL (val->type).v_uint = '\t'; - break; - case 'v': - SPEC_CVAL (val->type).v_uint = '\v'; - break; - case 'b': - SPEC_CVAL (val->type).v_uint = '\b'; - break; - case 'r': - SPEC_CVAL (val->type).v_uint = '\r'; - break; - case 'f': - SPEC_CVAL (val->type).v_uint = '\f'; - break; - case 'a': - SPEC_CVAL (val->type).v_uint = '\a'; - break; - case '\\': - SPEC_CVAL (val->type).v_uint = '\\'; - break; - case '\?': - SPEC_CVAL (val->type).v_uint = '\?'; - break; - case '\'': - SPEC_CVAL (val->type).v_uint = '\''; - break; - case '\"': - SPEC_CVAL (val->type).v_uint = '\"'; - break; - - case '0' : - case '1' : - case '2' : - case '3' : - case '4' : - case '5' : - case '6' : - case '7' : - SPEC_CVAL (val->type).v_uint = octalEscape(&s); - break; - - case 'x': - SPEC_CVAL (val->type).v_uint = hexEscape(&s) ; - break; - - default: - SPEC_CVAL (val->type).v_uint = (unsigned char)*s; - break; - } - } - else /* not a backslash */ - SPEC_CVAL (val->type).v_uint = (unsigned char)*s; - - return val; + if (*++s == '\\') + { + switch (*++s) /* go beyond the backslash */ + { + case 'n': + return constCharVal ('\n'); + case 't': + return constCharVal ('\t'); + case 'v': + return constCharVal ('\v'); + case 'b': + return constCharVal ('\b'); + case 'r': + return constCharVal ('\r'); + case 'f': + return constCharVal ('\f'); + case 'a': + return constCharVal ('\a'); + case '\\': + return constCharVal ('\\'); + case '\?': + return constCharVal ('\?'); + case '\'': + return constCharVal ('\''); + case '\"': + return constCharVal ('\"'); + + case '0' : + case '1' : + case '2' : + case '3' : + case '4' : + case '5' : + case '6' : + case '7' : + return constCharVal (octalEscape (&s)); + + case 'x': + return constCharVal (hexEscape (&s)); + + default: + return constCharVal (*s); + } + } + else /* not a backslash */ + return constCharVal (*s); } /*------------------------------------------------------------------*/ @@ -870,7 +1037,7 @@ valFromType (sym_link * type) /*------------------------------------------------------------------*/ /* floatFromVal - value to double float conversion */ /*------------------------------------------------------------------*/ -double +double floatFromVal (value * val) { if (!val) @@ -885,47 +1052,159 @@ floatFromVal (value * val) /* if it is not a specifier then we can assume that */ /* it will be an unsigned long */ if (!IS_SPEC (val->type)) - return (double) SPEC_CVAL (val->etype).v_ulong; + return SPEC_CVAL (val->etype).v_ulong; if (SPEC_NOUN (val->etype) == V_FLOAT) - return (double) SPEC_CVAL (val->etype).v_float; + return SPEC_CVAL (val->etype).v_float; + + if (SPEC_NOUN (val->etype) == V_FIXED16X16) + return doubleFromFixed16x16 (SPEC_CVAL (val->etype).v_fixed16x16); if (SPEC_LONG (val->etype)) { if (SPEC_USIGN (val->etype)) - return (double) SPEC_CVAL (val->etype).v_ulong; + return SPEC_CVAL (val->etype).v_ulong; else - return (double) SPEC_CVAL (val->etype).v_long; - } - - if (SPEC_NOUN (val->etype) == V_INT) { - if (SPEC_USIGN (val->etype)) - return (double) SPEC_CVAL (val->etype).v_uint; - else - return (double) SPEC_CVAL (val->etype).v_int; - } - - if (SPEC_NOUN (val->etype) == V_CHAR) { - if (SPEC_USIGN (val->etype)) - return (double) (unsigned char)SPEC_CVAL (val->etype).v_uint; - else - return (double) (signed char)SPEC_CVAL (val->etype).v_int; - } - - if (IS_BITVAR(val->etype)) { - return (double) SPEC_CVAL (val->etype).v_uint; - } - - if (SPEC_NOUN (val->etype) == V_VOID) { - return (double) SPEC_CVAL (val->etype).v_ulong; - } - - // we are lost ! - werror (E_INTERNAL_ERROR, __FILE__, __LINE__, - "floatFromVal: unknown value"); + return SPEC_CVAL (val->etype).v_long; + } + + if (SPEC_NOUN (val->etype) == V_INT) + { + if (SPEC_USIGN (val->etype)) + return SPEC_CVAL (val->etype).v_uint; + else + return SPEC_CVAL (val->etype).v_int; + } + + if (SPEC_NOUN (val->etype) == V_CHAR) + { + if (SPEC_USIGN (val->etype)) + return (unsigned char) SPEC_CVAL (val->etype).v_uint; + else + return (signed char) SPEC_CVAL (val->etype).v_int; + } + + if (IS_BITVAR(val->etype)) + return SPEC_CVAL (val->etype).v_uint; + + if (SPEC_NOUN (val->etype) == V_VOID) + return SPEC_CVAL (val->etype).v_ulong; + + /* we are lost ! */ + werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "floatFromVal: unknown value"); return 0; } +/*------------------------------------------------------------------*/ +/* ulFromVal - value to unsigned long conversion */ +/*------------------------------------------------------------------*/ +unsigned long +ulFromVal (value * val) +{ + if (!val) + return 0; + + if (val->etype && SPEC_SCLS (val->etype) != S_LITERAL) + { + werror (E_CONST_EXPECTED, val->name); + return 0; + } + + /* if it is not a specifier then we can assume that */ + /* it will be an unsigned long */ + if (!IS_SPEC (val->type)) + return SPEC_CVAL (val->etype).v_ulong; + + if (SPEC_NOUN (val->etype) == V_FLOAT) + return double2ul (SPEC_CVAL (val->etype).v_float); + + if (SPEC_NOUN (val->etype) == V_FIXED16X16) + return double2ul (doubleFromFixed16x16 (SPEC_CVAL (val->etype).v_fixed16x16)); + + if (SPEC_LONG (val->etype)) + { + if (SPEC_USIGN (val->etype)) + return SPEC_CVAL (val->etype).v_ulong; + else + return SPEC_CVAL (val->etype).v_long; + } + + if (SPEC_NOUN (val->etype) == V_INT) + { + if (SPEC_USIGN (val->etype)) + return SPEC_CVAL (val->etype).v_uint; + else + return SPEC_CVAL (val->etype).v_int; + } + + if (SPEC_NOUN (val->etype) == V_CHAR) + { + if (SPEC_USIGN (val->etype)) + return (unsigned char) SPEC_CVAL (val->etype).v_uint; + else + return (signed char) SPEC_CVAL (val->etype).v_int; + } + + if (IS_BITVAR(val->etype)) + return SPEC_CVAL (val->etype).v_uint; + + if (SPEC_NOUN (val->etype) == V_VOID) + return SPEC_CVAL (val->etype).v_ulong; + + /* we are lost ! */ + werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "ulFromVal: unknown value"); + return 0; +} + +/*-----------------------------------------------------------------*/ +/* doubleFromFixed16x16 - convert a fixed16x16 to double */ +/*-----------------------------------------------------------------*/ +double doubleFromFixed16x16(TYPE_TARGET_ULONG value) +{ +#if 0 + /* This version is incorrect negative values. */ + double tmp=0, exp=2; + + tmp = (value & 0xffff0000) >> 16; + + while(value) { + value &= 0xffff; + if(value & 0x8000)tmp += 1/exp; + exp *= 2; + value <<= 1; + } + + return (tmp); +#else + return ((double)(value * 1.0) / (double)(1UL << 16)); +#endif +} + +TYPE_TARGET_ULONG fixed16x16FromDouble(double value) +{ +#if 0 + /* This version is incorrect negative values. */ + unsigned int tmp=0, pos=16; + TYPE_TARGET_ULONG res; + + tmp = floor( value ); + res = tmp << 16; + value -= tmp; + + tmp = 0; + while(pos--) { + value *= 2; + if(value >= 1.0)tmp |= (1 << pos); + value -= floor( value ); + } + + res |= tmp; + + return (res); +#else + return double2ul (value * (double)(1UL << 16)); +#endif +} /*------------------------------------------------------------------*/ /* valUnaryPM - does the unary +/- operation on a constant */ @@ -936,31 +1215,33 @@ valUnaryPM (value * val) /* depending on type */ if (SPEC_NOUN (val->etype) == V_FLOAT) SPEC_CVAL (val->etype).v_float = -1.0 * SPEC_CVAL (val->etype).v_float; + else if (SPEC_NOUN (val->etype) == V_FIXED16X16) + SPEC_CVAL (val->etype).v_fixed16x16 = (TYPE_TARGET_ULONG) -((long) SPEC_CVAL (val->etype).v_fixed16x16); else { if (SPEC_LONG (val->etype)) - { - if (SPEC_USIGN (val->etype)) - SPEC_CVAL (val->etype).v_ulong = 0-SPEC_CVAL (val->etype).v_ulong; - else - SPEC_CVAL (val->etype).v_long = -SPEC_CVAL (val->etype).v_long; - } + { + if (SPEC_USIGN (val->etype)) + SPEC_CVAL (val->etype).v_ulong = 0-SPEC_CVAL (val->etype).v_ulong; + else + SPEC_CVAL (val->etype).v_long = -SPEC_CVAL (val->etype).v_long; + } else - { - if (SPEC_USIGN (val->etype)) - SPEC_CVAL (val->etype).v_uint = 0-SPEC_CVAL (val->etype).v_uint; - else - SPEC_CVAL (val->etype).v_int = -SPEC_CVAL (val->etype).v_int; - } - } - // -(unsigned 3) now really is signed - SPEC_USIGN(val->etype)=0; - // -(unsigned char)135 now really is an int - if (SPEC_NOUN(val->etype) == V_CHAR) { - if (SPEC_CVAL(val->etype).v_int < -128) { - SPEC_NOUN(val->etype) = V_INT; - } - } + { + if (SPEC_USIGN (val->etype)) + SPEC_CVAL (val->etype).v_uint = 0-SPEC_CVAL (val->etype).v_uint; + else + SPEC_CVAL (val->etype).v_int = -SPEC_CVAL (val->etype).v_int; + + if (SPEC_NOUN(val->etype) == V_CHAR) + { + /* promote to 'signed int', cheapestVal() might reduce it again */ + SPEC_USIGN(val->etype) = 0; + SPEC_NOUN(val->etype) = V_INT; + } + return cheapestVal (val); + } + } return val; } @@ -974,19 +1255,25 @@ valComplement (value * val) if (SPEC_LONG (val->etype)) { if (SPEC_USIGN (val->etype)) - SPEC_CVAL (val->etype).v_ulong = ~SPEC_CVAL (val->etype).v_ulong; + SPEC_CVAL (val->etype).v_ulong = ~SPEC_CVAL (val->etype).v_ulong; else - SPEC_CVAL (val->etype).v_long = ~SPEC_CVAL (val->etype).v_long; + SPEC_CVAL (val->etype).v_long = ~SPEC_CVAL (val->etype).v_long; } else { if (SPEC_USIGN (val->etype)) - SPEC_CVAL (val->etype).v_uint = ~SPEC_CVAL (val->etype).v_uint; + SPEC_CVAL (val->etype).v_uint = ~SPEC_CVAL (val->etype).v_uint; else - SPEC_CVAL (val->etype).v_int = ~SPEC_CVAL (val->etype).v_int; + SPEC_CVAL (val->etype).v_int = ~SPEC_CVAL (val->etype).v_int; + + if (SPEC_NOUN(val->etype) == V_CHAR) + { + /* promote to 'signed int', cheapestVal() might reduce it again */ + SPEC_USIGN(val->etype) = 0; + SPEC_NOUN(val->etype) = V_INT; + } + return cheapestVal (val); } - // ~(unsigned 3) now really is signed - SPEC_USIGN(val->etype)=0; return val; } @@ -1000,17 +1287,23 @@ valNot (value * val) if (SPEC_LONG (val->etype)) { if (SPEC_USIGN (val->etype)) - SPEC_CVAL (val->etype).v_ulong = !SPEC_CVAL (val->etype).v_ulong; + SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_ulong; else - SPEC_CVAL (val->etype).v_long = !SPEC_CVAL (val->etype).v_long; + SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_long; } else { if (SPEC_USIGN (val->etype)) - SPEC_CVAL (val->etype).v_uint = !SPEC_CVAL (val->etype).v_uint; + SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_uint; else - SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_int; + SPEC_CVAL (val->etype).v_int = !SPEC_CVAL (val->etype).v_int; + } + /* ANSI: result type is int, value is 0 or 1 */ + /* sdcc will hold this in an 'unsigned char' */ + SPEC_USIGN(val->etype) = 1; + SPEC_LONG (val->etype) = 0; + SPEC_NOUN(val->etype) = V_CHAR; return val; } @@ -1024,44 +1317,41 @@ valMult (value * lval, value * rval) /* create a new value */ val = newValue (); - val->type = val->etype = newLink (SPECIFIER); - SPEC_NOUN (val->type) = (IS_FLOAT (lval->etype) || - IS_FLOAT (rval->etype) ? V_FLOAT : V_INT); - SPEC_SCLS (val->type) = S_LITERAL; /* will remain literal */ - SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) | SPEC_USIGN (rval->etype)); - SPEC_LONG (val->type) = (SPEC_LONG (lval->etype) | SPEC_LONG (rval->etype)); + val->type = val->etype = computeType (lval->etype, + rval->etype, + RESULT_TYPE_INT, + '*'); + SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */ if (IS_FLOAT (val->type)) SPEC_CVAL (val->type).v_float = floatFromVal (lval) * floatFromVal (rval); else - { + if (IS_FIXED16X16 (val->type)) + SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble(floatFromVal (lval) * floatFromVal (rval)); /* signed and unsigned mul are the same, as long as the precision of the result isn't bigger than the precision of the operands. */ - if (SPEC_LONG (val->type)) - SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) * - (TYPE_UDWORD) floatFromVal (rval); - else - { - TYPE_UDWORD ul = (TYPE_UWORD) floatFromVal (lval) * - (TYPE_UWORD) floatFromVal (rval); - - SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) ul; - if (!options.lessPedantic) - { - if (SPEC_USIGN (val->type)) - { - if (ul != SPEC_CVAL (val->type).v_uint) - werror (W_INT_OVL); - } - else /* signed result */ - { - if ((TYPE_DWORD) ul != SPEC_CVAL (val->type).v_int) - werror (W_INT_OVL); - } - } - } + else if (SPEC_LONG (val->type)) + SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) ulFromVal (lval) * + (TYPE_TARGET_ULONG) ulFromVal (rval); + else if (SPEC_USIGN (val->type)) /* unsigned int */ + { + TYPE_TARGET_ULONG ul = (TYPE_TARGET_UINT) ulFromVal (lval) * + (TYPE_TARGET_UINT) ulFromVal (rval); + + SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ul; + if (ul != (TYPE_TARGET_UINT) ul) + werror (W_INT_OVL); } - return cheapestVal(val); + else /* signed int */ + { + TYPE_TARGET_LONG l = (TYPE_TARGET_INT) floatFromVal (lval) * + (TYPE_TARGET_INT) floatFromVal (rval); + + SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) l; + if (l != (TYPE_TARGET_INT) l) + werror (W_INT_OVL); + } + return cheapestVal (val); } /*------------------------------------------------------------------*/ @@ -1080,39 +1370,35 @@ valDiv (value * lval, value * rval) /* create a new value */ val = newValue (); - val->type = val->etype = newLink(SPECIFIER); - SPEC_NOUN (val->type) = (IS_FLOAT (lval->etype) || - IS_FLOAT (rval->etype) ? V_FLOAT : V_INT); - SPEC_SCLS (val->etype) = S_LITERAL; - SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) | SPEC_USIGN (rval->etype)); - SPEC_LONG (val->type) = (SPEC_LONG (lval->etype) | SPEC_LONG (rval->etype)); + val->type = val->etype = computeType (lval->etype, + rval->etype, + RESULT_TYPE_INT, + '/'); + SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */ if (IS_FLOAT (val->type)) SPEC_CVAL (val->type).v_float = floatFromVal (lval) / floatFromVal (rval); + else if (IS_FIXED16X16 (val->type)) + SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble( floatFromVal (lval) / floatFromVal (rval) ); + else if (SPEC_LONG (val->type)) + { + if (SPEC_USIGN (val->type)) + SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) ulFromVal (lval) / + (TYPE_TARGET_ULONG) ulFromVal (rval); + else + SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) ulFromVal (lval) / + (TYPE_TARGET_LONG) ulFromVal (rval); + } else { - if (SPEC_LONG (val->type)) - { - if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_ulong = - (unsigned long) floatFromVal (lval) / - (unsigned long) floatFromVal (rval); - else - SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) / - (long) floatFromVal (rval); - } + if (SPEC_USIGN (val->type)) + SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ulFromVal (lval) / + (TYPE_TARGET_UINT) ulFromVal (rval); else - { - if (SPEC_USIGN (val->type)) { - SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) / - (unsigned) floatFromVal (rval); - } else { - SPEC_CVAL (val->type).v_int = (int) floatFromVal (lval) / - (int) floatFromVal (rval); - } - } + SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) ulFromVal (lval) / + (TYPE_TARGET_INT) ulFromVal (rval); } - return cheapestVal(val); + return cheapestVal (val); } /*------------------------------------------------------------------*/ @@ -1124,34 +1410,32 @@ valMod (value * lval, value * rval) value *val; /* create a new value */ - val = newValue (); - val->type = val->etype = newLink (SPECIFIER); - SPEC_NOUN (val->type) = V_INT; /* type is int */ - SPEC_SCLS (val->type) = S_LITERAL; /* will remain literal */ - SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) | SPEC_USIGN (rval->etype)); - SPEC_LONG (val->type) = (SPEC_LONG (lval->etype) | SPEC_LONG (rval->etype)); + val = newValue(); + val->type = val->etype = computeType (lval->etype, + rval->etype, + RESULT_TYPE_INT, + '%'); + SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */ if (SPEC_LONG (val->type)) { if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_ulong = (unsigned long) floatFromVal (lval) % - (unsigned long) floatFromVal (rval); + SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) ulFromVal (lval) % + (TYPE_TARGET_ULONG) ulFromVal (rval); else - SPEC_CVAL (val->type).v_long = (unsigned long) floatFromVal (lval) % - (unsigned long) floatFromVal (rval); + SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) ulFromVal (lval) % + (TYPE_TARGET_LONG) ulFromVal (rval); } else { - if (SPEC_USIGN (val->type)) { - SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) % - (unsigned) floatFromVal (rval); - } else { - SPEC_CVAL (val->type).v_int = (unsigned) floatFromVal (lval) % - (unsigned) floatFromVal (rval); - } + if (SPEC_USIGN (val->type)) + SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ulFromVal (lval) % + (TYPE_TARGET_UINT) ulFromVal (rval); + else + SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) ulFromVal (lval) % + (TYPE_TARGET_INT) ulFromVal (rval); } - - return cheapestVal(val); + return cheapestVal (val); } /*------------------------------------------------------------------*/ @@ -1163,33 +1447,37 @@ valPlus (value * lval, value * rval) value *val; /* create a new value */ - val = newValue (); - val->type = val->etype = newLink (SPECIFIER); - SPEC_NOUN (val->type) = (IS_FLOAT (lval->etype) || - IS_FLOAT (rval->etype) ? V_FLOAT : V_INT); - SPEC_SCLS (val->type) = S_LITERAL; /* will remain literal */ - SPEC_USIGN (val->type) = - SPEC_USIGN (lval->etype) && - SPEC_USIGN (rval->etype) && - (floatFromVal(lval)+floatFromVal(rval))>=0; - - SPEC_LONG (val->type) = 1; + val = newValue(); + val->type = val->etype = computeType (lval->etype, + rval->etype, + RESULT_TYPE_INT, + '+'); + SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */ if (IS_FLOAT (val->type)) SPEC_CVAL (val->type).v_float = floatFromVal (lval) + floatFromVal (rval); else + if (IS_FIXED16X16 (val->type)) + SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble( floatFromVal (lval) + floatFromVal (rval) ); + else if (SPEC_LONG (val->type)) { - if (SPEC_LONG (val->type)) - { - if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_ulong = (unsigned long) floatFromVal (lval) + - (unsigned long) floatFromVal (rval); - else - SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) + - (long) floatFromVal (rval); - } + if (SPEC_USIGN (val->type)) + SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) ulFromVal (lval) + + (TYPE_TARGET_ULONG) ulFromVal (rval); + else + SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) ulFromVal (lval) + + (TYPE_TARGET_LONG) ulFromVal (rval); } - return cheapestVal(val); + else + { + if (SPEC_USIGN (val->type)) + SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ulFromVal (lval) + + (TYPE_TARGET_UINT) ulFromVal (rval); + else + SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) ulFromVal (lval) + + (TYPE_TARGET_INT) ulFromVal (rval); + } + return cheapestVal (val); } /*------------------------------------------------------------------*/ @@ -1201,45 +1489,37 @@ valMinus (value * lval, value * rval) value *val; /* create a new value */ - val = newValue (); - val->type = val->etype = newLink (SPECIFIER); - SPEC_NOUN (val->type) = (IS_FLOAT (lval->etype) || - IS_FLOAT (rval->etype) ? V_FLOAT : V_INT); - SPEC_SCLS (val->type) = S_LITERAL; /* will remain literal */ - SPEC_USIGN (val->type) = - SPEC_USIGN (lval->etype) && - SPEC_USIGN (rval->etype) && - (floatFromVal(lval)-floatFromVal(rval))>=0; - - SPEC_LONG (val->type) = (SPEC_LONG (lval->etype) | SPEC_LONG (rval->etype)); + val = newValue(); + val->type = val->etype = computeType (lval->etype, + rval->etype, + RESULT_TYPE_INT, + '-'); + SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */ if (IS_FLOAT (val->type)) SPEC_CVAL (val->type).v_float = floatFromVal (lval) - floatFromVal (rval); else + if (IS_FIXED16X16 (val->type)) + SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble( floatFromVal (lval) - floatFromVal (rval) ); + else if (SPEC_LONG (val->type)) { - if (SPEC_LONG (val->type)) - { - if (SPEC_USIGN (val->type)) { - SPEC_CVAL (val->type).v_ulong = - (unsigned long) floatFromVal (lval) - - (unsigned long) floatFromVal (rval); - } else { - SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) - - (long) floatFromVal (rval); - } - } + if (SPEC_USIGN (val->type)) + SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) ulFromVal (lval) - + (TYPE_TARGET_ULONG) ulFromVal (rval); else - { - if (SPEC_USIGN (val->type)) { - SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) - - (unsigned) floatFromVal (rval); - } else { - SPEC_CVAL (val->type).v_int = (int) floatFromVal (lval) - - (int) floatFromVal (rval); - } - } + SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) ulFromVal (lval) - + (TYPE_TARGET_LONG) ulFromVal (rval); } - return cheapestVal(val); + else + { + if (SPEC_USIGN (val->type)) + SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ulFromVal (lval) - + (TYPE_TARGET_UINT) ulFromVal (rval); + else + SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) ulFromVal (lval) - + (TYPE_TARGET_INT) ulFromVal (rval); + } + return cheapestVal (val); } /*------------------------------------------------------------------*/ @@ -1251,25 +1531,53 @@ valShift (value * lval, value * rval, int lr) value *val; /* create a new value */ - val = newValue (); - val->type = val->etype = newIntLink (); - SPEC_SCLS (val->type) = S_LITERAL; /* will remain literal */ - SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) & SPEC_USIGN (rval->etype)); - SPEC_LONG (val->type) = 1; + val = newValue(); + val->type = val->etype = computeType (lval->etype, + NULL, + RESULT_TYPE_INT, + 'S'); + SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */ + + if (getSize (val->type) * 8 <= (TYPE_TARGET_ULONG) ulFromVal (rval) && + /* left shift */ + (lr || + /* right shift and unsigned */ + (!lr && SPEC_USIGN (rval->type)))) + { + werror (W_SHIFT_CHANGED, (lr ? "left" : "right")); + } if (SPEC_LONG (val->type)) { if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_ulong = lr ? - (unsigned long) floatFromVal (lval) << (unsigned long) floatFromVal (rval) : \ - (unsigned long) floatFromVal (lval) >> (unsigned long) floatFromVal (rval); + { + SPEC_CVAL (val->type).v_ulong = lr ? + (TYPE_TARGET_ULONG) ulFromVal (lval) << (TYPE_TARGET_ULONG) ulFromVal (rval) : \ + (TYPE_TARGET_ULONG) ulFromVal (lval) >> (TYPE_TARGET_ULONG) ulFromVal (rval); + } else - SPEC_CVAL (val->type).v_long = lr ? - (long) floatFromVal (lval) << (long) floatFromVal (rval) : \ - (long) floatFromVal (lval) >> (long) floatFromVal (rval); + { + SPEC_CVAL (val->type).v_long = lr ? + (TYPE_TARGET_LONG) ulFromVal (lval) << (TYPE_TARGET_ULONG) ulFromVal (rval) : \ + (TYPE_TARGET_LONG) ulFromVal (lval) >> (TYPE_TARGET_ULONG) ulFromVal (rval); + } } - - return cheapestVal(val); + else + { + if (SPEC_USIGN (val->type)) + { + SPEC_CVAL (val->type).v_uint = lr ? + (TYPE_TARGET_UINT) ulFromVal (lval) << (TYPE_TARGET_ULONG) ulFromVal (rval) : \ + (TYPE_TARGET_UINT) ulFromVal (lval) >> (TYPE_TARGET_ULONG) ulFromVal (rval); + } + else + { + SPEC_CVAL (val->type).v_int = lr ? + (TYPE_TARGET_INT) ulFromVal (lval) << (TYPE_TARGET_ULONG) ulFromVal (rval) : \ + (TYPE_TARGET_INT) ulFromVal (lval) >> (TYPE_TARGET_ULONG) ulFromVal (rval); + } + } + return cheapestVal (val); } /*------------------------------------------------------------------*/ @@ -1284,9 +1592,9 @@ valCompare (value * lval, value * rval, int ctype) val = newValue (); val->type = val->etype = newCharLink (); val->type->class = SPECIFIER; - SPEC_NOUN (val->type) = V_CHAR; /* type is char */ + SPEC_NOUN (val->type) = V_CHAR; /* type is char */ SPEC_USIGN (val->type) = 1; - SPEC_SCLS (val->type) = S_LITERAL; /* will remain literal */ + SPEC_SCLS (val->type) = S_LITERAL; /* will remain literal */ switch (ctype) { @@ -1307,11 +1615,70 @@ valCompare (value * lval, value * rval, int ctype) break; case EQ_OP: - SPEC_CVAL (val->type).v_int = floatFromVal (lval) == floatFromVal (rval); + if (SPEC_NOUN(lval->type) == V_FLOAT || + SPEC_NOUN(rval->type) == V_FLOAT) + { + SPEC_CVAL (val->type).v_int = floatFromVal (lval) == floatFromVal (rval); + } + else + if (SPEC_NOUN(lval->type) == V_FIXED16X16 || + SPEC_NOUN(rval->type) == V_FIXED16X16) + { + SPEC_CVAL (val->type).v_int = floatFromVal (lval) == floatFromVal (rval); + } + else + { + /* integrals: ignore signedness */ + TYPE_TARGET_ULONG l, r; + + l = (TYPE_TARGET_ULONG) ulFromVal (lval); + r = (TYPE_TARGET_ULONG) ulFromVal (rval); + /* In order to correctly compare 'signed int' and 'unsigned int' it's + neccessary to strip them to 16 bit. + Literals are reduced to their cheapest type, therefore left and + right might have different types. It's neccessary to find a + common type: int (used for char too) or long */ + if (!IS_LONG (lval->etype) && + !IS_LONG (rval->etype)) + { + r = (TYPE_TARGET_UINT) r; + l = (TYPE_TARGET_UINT) l; + } + SPEC_CVAL (val->type).v_int = l == r; + } break; - case NE_OP: - SPEC_CVAL (val->type).v_int = floatFromVal (lval) != floatFromVal (rval); + if (SPEC_NOUN(lval->type) == V_FLOAT || + SPEC_NOUN(rval->type) == V_FLOAT) + { + SPEC_CVAL (val->type).v_int = floatFromVal (lval) != floatFromVal (rval); + } + else + if (SPEC_NOUN(lval->type) == V_FIXED16X16 || + SPEC_NOUN(rval->type) == V_FIXED16X16) + { + SPEC_CVAL (val->type).v_int = floatFromVal (lval) != floatFromVal (rval); + } + else + { + /* integrals: ignore signedness */ + TYPE_TARGET_ULONG l, r; + + l = (TYPE_TARGET_ULONG) ulFromVal (lval); + r = (TYPE_TARGET_ULONG) ulFromVal (rval); + /* In order to correctly compare 'signed int' and 'unsigned int' it's + neccessary to strip them to 16 bit. + Literals are reduced to their cheapest type, therefore left and + right might have different types. It's neccessary to find a + common type: int (used for char too) or long */ + if (!IS_LONG (lval->etype) && + !IS_LONG (rval->etype)) + { + r = (TYPE_TARGET_UINT) r; + l = (TYPE_TARGET_UINT) l; + } + SPEC_CVAL (val->type).v_int = l != r; + } break; } @@ -1329,73 +1696,74 @@ valBitwise (value * lval, value * rval, int op) /* create a new value */ val = newValue (); - val->type = copyLinkChain (getSize(rval->type) > getSize(lval->type) ? - rval->type : lval->type); + val->type = computeType (lval->etype, rval->etype, RESULT_TYPE_CHAR, op); val->etype = getSpec (val->type); + SPEC_SCLS (val->etype) = S_LITERAL; switch (op) { case '&': if (SPEC_LONG (val->type)) - { - if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_ulong = (unsigned long) floatFromVal (lval) & - (unsigned long) floatFromVal (rval); - else - SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) & - (long) floatFromVal (rval); - } + { + if (SPEC_USIGN (val->type)) + SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) ulFromVal (lval) & + (TYPE_TARGET_ULONG) ulFromVal (rval); + else + SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) ulFromVal (lval) & + (TYPE_TARGET_LONG) ulFromVal (rval); + } else - { - if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) & - (unsigned) floatFromVal (rval); - else - SPEC_CVAL (val->type).v_int = (int) floatFromVal (lval) & (int) floatFromVal (rval); - } + { + if (SPEC_USIGN (val->type)) + SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ulFromVal (lval) & + (TYPE_TARGET_UINT) ulFromVal (rval); + else + SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) ulFromVal (lval) & + (TYPE_TARGET_INT) ulFromVal (rval); + } break; case '|': if (SPEC_LONG (val->type)) - { - if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_ulong = (unsigned long) floatFromVal (lval) | - (unsigned long) floatFromVal (rval); - else - SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) | - (long) floatFromVal (rval); - } + { + if (SPEC_USIGN (val->type)) + SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) ulFromVal (lval) | + (TYPE_TARGET_ULONG) ulFromVal (rval); + else + SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) ulFromVal (lval) | + (TYPE_TARGET_LONG) ulFromVal (rval); + } else - { - if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) | - (unsigned) floatFromVal (rval); - else - SPEC_CVAL (val->type).v_int = - (int) floatFromVal (lval) | (int) floatFromVal (rval); - } + { + if (SPEC_USIGN (val->type)) + SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ulFromVal (lval) | + (TYPE_TARGET_UINT) ulFromVal (rval); + else + SPEC_CVAL (val->type).v_int = + (TYPE_TARGET_INT) ulFromVal (lval) | (TYPE_TARGET_INT) ulFromVal (rval); + } break; case '^': if (SPEC_LONG (val->type)) - { - if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_ulong = (unsigned long) floatFromVal (lval) ^ - (unsigned long) floatFromVal (rval); - else - SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) ^ - (long) floatFromVal (rval); - } + { + if (SPEC_USIGN (val->type)) + SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) ulFromVal (lval) ^ + (TYPE_TARGET_ULONG) ulFromVal (rval); + else + SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) ulFromVal (lval) ^ + (TYPE_TARGET_LONG) ulFromVal (rval); + } else - { - if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) ^ - (unsigned) floatFromVal (rval); - else - SPEC_CVAL (val->type).v_int = - (int) floatFromVal (lval) ^ (int) floatFromVal (rval); - } + { + if (SPEC_USIGN (val->type)) + SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ulFromVal (lval) ^ + (TYPE_TARGET_UINT) ulFromVal (rval); + else + SPEC_CVAL (val->type).v_int = + (TYPE_TARGET_INT) ulFromVal (lval) ^ (TYPE_TARGET_INT) ulFromVal (rval); + } break; } @@ -1414,8 +1782,8 @@ valLogicAndOr (value * lval, value * rval, int op) val = newValue (); val->type = val->etype = newCharLink (); val->type->class = SPECIFIER; - SPEC_SCLS (val->type) = S_LITERAL; /* will remain literal */ - SPEC_USIGN (val->type) = 0; + SPEC_SCLS (val->type) = S_LITERAL; /* will remain literal */ + SPEC_USIGN (val->type) = 1; switch (op) { @@ -1439,43 +1807,83 @@ value * valCastLiteral (sym_link * dtype, double fval) { value *val; + unsigned long l = double2ul (fval); if (!dtype) return NULL; val = newValue (); - val->etype = getSpec (val->type = copyLinkChain (dtype)); + if (dtype) + val->etype = getSpec (val->type = copyLinkChain (dtype)); + else + { + val->etype = val->type = newLink (SPECIFIER); + SPEC_NOUN (val->etype) = V_VOID; + } SPEC_SCLS (val->etype) = S_LITERAL; + /* if it is not a specifier then we can assume that */ /* it will be an unsigned long */ - if (!IS_SPEC (val->type)) { - SPEC_CVAL (val->etype).v_ulong = (unsigned long) fval; + if (!IS_SPEC (val->type)) + { + SPEC_CVAL (val->etype).v_ulong = (TYPE_TARGET_ULONG) l; return val; - } + } - if (SPEC_NOUN (val->etype) == V_FLOAT) + switch (SPEC_NOUN (val->etype)) + { + case V_FLOAT: SPEC_CVAL (val->etype).v_float = fval; - else { - unsigned long l = fval; - if (SPEC_LONG (val->etype)) { - if (SPEC_USIGN (val->etype)) - SPEC_CVAL (val->etype).v_ulong = (unsigned long) l; - else - SPEC_CVAL (val->etype).v_long = (long) l; - } else { - if (SPEC_USIGN (val->etype)) - SPEC_CVAL (val->etype).v_uint = (unsigned short)l; - else - SPEC_CVAL (val->etype).v_int = (short)l; - } - } + break; + + case V_FIXED16X16: + SPEC_CVAL (val->etype).v_fixed16x16 = fixed16x16FromDouble (fval); + break; + + case V_BIT: + case V_SBIT: + SPEC_CVAL (val->etype).v_uint = fval ? 1 : 0; + break; + + case V_BITFIELD: + l &= (0xffffffffu >> (32 - SPEC_BLEN (val->etype))); + if (SPEC_USIGN (val->etype)) + SPEC_CVAL (val->etype).v_uint = (TYPE_TARGET_UINT) l; + else + SPEC_CVAL (val->etype).v_int = (TYPE_TARGET_INT) l; + break; + + case V_CHAR: + if (SPEC_USIGN (val->etype)) + SPEC_CVAL (val->etype).v_uint = (TYPE_TARGET_UCHAR) l; + else + SPEC_CVAL (val->etype).v_int = (TYPE_TARGET_CHAR) l; + break; + + default: + if (SPEC_LONG (val->etype)) + { + if (SPEC_USIGN (val->etype)) + SPEC_CVAL (val->etype).v_ulong = (TYPE_TARGET_ULONG) l; + else + SPEC_CVAL (val->etype).v_long = (TYPE_TARGET_LONG) l; + } + else + { + if (SPEC_USIGN (val->etype)) + SPEC_CVAL (val->etype).v_uint = (TYPE_TARGET_UINT) l; + else + SPEC_CVAL (val->etype).v_int = (TYPE_TARGET_INT) l; + } + } + return val; } /*------------------------------------------------------------------*/ /* getNelements - determines # of elements from init list */ /*------------------------------------------------------------------*/ -int +int getNelements (sym_link * type, initList * ilist) { int i; @@ -1493,16 +1901,16 @@ getNelements (sym_link * type, initList * ilist) ast *iast = ilist->init.node; value *v = (iast->type == EX_VALUE ? iast->opval.val : NULL); if (!v) - { - werror (E_CONST_EXPECTED); - return 0; - } + { + werror (E_CONST_EXPECTED); + return 0; + } if (IS_ARRAY (v->type) && IS_CHAR (v->etype)) - // yep, it's a string - { - return DCL_ELEM (v->type); - } + /* yep, it's a string */ + { + return DCL_ELEM (v->type); + } } i = 0; @@ -1528,16 +1936,16 @@ valForArray (ast * arrExpr) if (IS_AST_OP (arrExpr->left)) { if (arrExpr->left->opval.op == '[') - lval = valForArray (arrExpr->left); + lval = valForArray (arrExpr->left); else if (arrExpr->left->opval.op == '.') - lval = valForStructElem (arrExpr->left->left, - arrExpr->left->right); + lval = valForStructElem (arrExpr->left->left, + arrExpr->left->right); else if (arrExpr->left->opval.op == PTR_OP && - IS_ADDRESS_OF_OP (arrExpr->left->left)) - lval = valForStructElem (arrExpr->left->left->left, - arrExpr->left->right); + IS_ADDRESS_OF_OP (arrExpr->left->left)) + lval = valForStructElem (arrExpr->left->left->left, + arrExpr->left->right); else - return NULL; + return NULL; } else if (!IS_AST_SYM_VALUE (arrExpr->left)) @@ -1549,22 +1957,19 @@ valForArray (ast * arrExpr) val = newValue (); if (!lval) { - SNPRINTF (buffer, sizeof(buffer), "%s", AST_SYMBOL (arrExpr->left)->rname); + SNPRINTF (buffer, sizeof(buffer), "%s", AST_SYMBOL (arrExpr->left)->rname); } else { - SNPRINTF (buffer, sizeof(buffer), "%s", lval->name); + SNPRINTF (buffer, sizeof(buffer), "%s", lval->name); } SNPRINTF (val->name, sizeof(val->name), "(%s + %d)", buffer, - (int) AST_LIT_VALUE (arrExpr->right) * size); + AST_ULONG_VALUE (arrExpr->right) * size); val->type = newLink (DECLARATOR); if (SPEC_SCLS (arrExpr->left->etype) == S_CODE) - { - DCL_TYPE (val->type) = CPOINTER; - DCL_PTR_CONST (val->type) = port->mem.code_ro; - } + DCL_TYPE (val->type) = CPOINTER; else if (SPEC_SCLS (arrExpr->left->etype) == S_XDATA) DCL_TYPE (val->type) = FPOINTER; else if (SPEC_SCLS (arrExpr->left->etype) == S_XSTACK) @@ -1575,7 +1980,7 @@ valForArray (ast * arrExpr) DCL_TYPE (val->type) = EEPPOINTER; else DCL_TYPE (val->type) = POINTER; - val->type->next = arrExpr->left->ftype; + val->type->next = arrExpr->left->ftype->next; val->etype = getSpec (val->type); return val; } @@ -1594,15 +1999,15 @@ valForStructElem (ast * structT, ast * elemT) if (IS_AST_OP (structT)) { if (structT->opval.op == '[') - lval = valForArray (structT); + lval = valForArray (structT); else if (structT->opval.op == '.') - lval = valForStructElem (structT->left, structT->right); + lval = valForStructElem (structT->left, structT->right); else if (structT->opval.op == PTR_OP && - IS_ADDRESS_OF_OP (structT->left)) - lval = valForStructElem (structT->left->left, - structT->right); + IS_ADDRESS_OF_OP (structT->left)) + lval = valForStructElem (structT->left->left, + structT->right); else - return NULL; + return NULL; } if (!IS_AST_SYM_VALUE (elemT)) @@ -1612,7 +2017,7 @@ valForStructElem (ast * structT, ast * elemT) return NULL; if ((sym = getStructElement (SPEC_STRUCT (structT->etype), - AST_SYMBOL (elemT))) == NULL) + AST_SYMBOL (elemT))) == NULL) { return NULL; } @@ -1620,22 +2025,19 @@ valForStructElem (ast * structT, ast * elemT) val = newValue (); if (!lval) { - SNPRINTF(buffer, sizeof(buffer), "%s", AST_SYMBOL (structT)->rname); + SNPRINTF(buffer, sizeof(buffer), "%s", AST_SYMBOL (structT)->rname); } else { - SNPRINTF (buffer, sizeof(buffer), "%s", lval->name); + SNPRINTF (buffer, sizeof(buffer), "%s", lval->name); } SNPRINTF (val->name, sizeof(val->name), "(%s + %d)", buffer, - (int) sym->offset); + (int) sym->offset); val->type = newLink (DECLARATOR); if (SPEC_SCLS (structT->etype) == S_CODE) - { - DCL_TYPE (val->type) = CPOINTER; - DCL_PTR_CONST (val->type) = port->mem.code_ro; - } + DCL_TYPE (val->type) = CPOINTER; else if (SPEC_SCLS (structT->etype) == S_XDATA) DCL_TYPE (val->type) = FPOINTER; else if (SPEC_SCLS (structT->etype) == S_XSTACK) @@ -1668,8 +2070,8 @@ valForCastAggr (ast * aexpr, sym_link * type, ast * cnst, int op) val = newValue (); SNPRINTF (val->name, sizeof(val->name), "(%s %c %d)", - AST_SYMBOL (aexpr)->rname, op, - getSize (type->next) * (int) AST_LIT_VALUE (cnst)); + AST_SYMBOL (aexpr)->rname, op, + getSize (type->next) * AST_ULONG_VALUE (cnst)); val->type = type; val->etype = getSpec (val->type); @@ -1691,7 +2093,7 @@ valForCastArr (ast * aexpr, sym_link * type) val = newValue (); SNPRINTF (val->name, sizeof(val->name), "(%s)", - AST_SYMBOL (aexpr)->rname); + AST_SYMBOL (aexpr)->rname); val->type = type; val->etype = getSpec (val->type);