X-Git-Url: https://git.gag.com/?a=blobdiff_plain;ds=sidebyside;f=src%2FSDCCval.c;h=e0821e1e45129eba22c1d4b2c1979665437b8e71;hb=90bdb43b342189fcb94a398855d43f3f47f96738;hp=11d80e4aa9411c5e6ccd810e1ed0a3eef346f8a5;hpb=916b7e4011f58680d6006400c274310fb1659a7e;p=fw%2Fsdcc diff --git a/src/SDCCval.c b/src/SDCCval.c index 11d80e4a..e0821e1e 100644 --- a/src/SDCCval.c +++ b/src/SDCCval.c @@ -367,6 +367,258 @@ cheapestVal (value *val) 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) 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; + } + } +} + /*-----------------------------------------------------------------*/ /* valueFromLit - creates a value from a literal */ /*-----------------------------------------------------------------*/ @@ -375,9 +627,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); } @@ -531,22 +783,22 @@ value *constVal (char *s) { if (SPEC_USIGN (val->type)) { - SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD)dval; + SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG)dval; } else { - SPEC_CVAL (val->type).v_long = (TYPE_DWORD)dval; + SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG)dval; } } else { if (SPEC_USIGN (val->type)) { - SPEC_CVAL (val->type).v_uint = (TYPE_UWORD)dval; + SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT)dval; } else { - SPEC_CVAL (val->type).v_int = (TYPE_WORD)dval; + SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT)dval; } } @@ -963,6 +1215,56 @@ floatFromVal (value * val) 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 (TYPE_TARGET_ULONG)(value * (double)(1UL << 16)); +#endif +} + /*------------------------------------------------------------------*/ /* valUnaryPM - does the unary +/- operation on a constant */ /*------------------------------------------------------------------*/ @@ -1044,14 +1346,14 @@ 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; @@ -1088,24 +1390,24 @@ valMult (value * lval, value * 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. */ else if (SPEC_LONG (val->type)) - SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) * - (TYPE_UDWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) * + (TYPE_TARGET_ULONG) floatFromVal (rval); else if (SPEC_USIGN (val->type)) /* unsigned int */ { - TYPE_UDWORD ul = (TYPE_UWORD) floatFromVal (lval) * - (TYPE_UWORD) floatFromVal (rval); + TYPE_TARGET_ULONG ul = (TYPE_TARGET_UINT) floatFromVal (lval) * + (TYPE_TARGET_UINT) floatFromVal (rval); - SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) ul; - if (ul != (TYPE_UWORD) ul) + SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) ul; + if (ul != (TYPE_TARGET_UINT) ul) werror (W_INT_OVL); } else /* signed int */ { - TYPE_DWORD l = (TYPE_WORD) floatFromVal (lval) * - (TYPE_WORD) floatFromVal (rval); + TYPE_TARGET_LONG l = (TYPE_TARGET_INT) floatFromVal (lval) * + (TYPE_TARGET_INT) floatFromVal (rval); - SPEC_CVAL (val->type).v_int = (TYPE_WORD) l; - if (l != (TYPE_WORD) l) + SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) l; + if (l != (TYPE_TARGET_INT) l) werror (W_INT_OVL); } return cheapestVal (val); @@ -1141,20 +1443,20 @@ valDiv (value * lval, value * rval) else if (SPEC_LONG (val->type)) { if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) / - (TYPE_UDWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) / + (TYPE_TARGET_ULONG) floatFromVal (rval); else - SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) / - (TYPE_DWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) / + (TYPE_TARGET_LONG) floatFromVal (rval); } else { if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) / - (TYPE_UWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) / + (TYPE_TARGET_UINT) floatFromVal (rval); else - SPEC_CVAL (val->type).v_int = (TYPE_WORD) floatFromVal (lval) / - (TYPE_WORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) / + (TYPE_TARGET_INT) floatFromVal (rval); } return cheapestVal (val); } @@ -1178,20 +1480,20 @@ valMod (value * lval, value * rval) if (SPEC_LONG (val->type)) { if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) % - (TYPE_UDWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) % + (TYPE_TARGET_ULONG) floatFromVal (rval); else - SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) % - (TYPE_DWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) % + (TYPE_TARGET_LONG) floatFromVal (rval); } else { if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) % - (TYPE_UWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) % + (TYPE_TARGET_UINT) floatFromVal (rval); else - SPEC_CVAL (val->type).v_int = (TYPE_WORD) floatFromVal (lval) % - (TYPE_WORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) % + (TYPE_TARGET_INT) floatFromVal (rval); } return cheapestVal (val); } @@ -1220,20 +1522,20 @@ valPlus (value * lval, value * rval) else if (SPEC_LONG (val->type)) { if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) + - (TYPE_UDWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) + + (TYPE_TARGET_ULONG) floatFromVal (rval); else - SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) + - (TYPE_DWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) + + (TYPE_TARGET_LONG) floatFromVal (rval); } else { if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) + - (TYPE_UWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) + + (TYPE_TARGET_UINT) floatFromVal (rval); else - SPEC_CVAL (val->type).v_int = (TYPE_WORD) floatFromVal (lval) + - (TYPE_WORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) + + (TYPE_TARGET_INT) floatFromVal (rval); } return cheapestVal (val); } @@ -1262,20 +1564,20 @@ valMinus (value * lval, value * rval) else if (SPEC_LONG (val->type)) { if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) - - (TYPE_UDWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) - + (TYPE_TARGET_ULONG) floatFromVal (rval); else - SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) - - (TYPE_DWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) - + (TYPE_TARGET_LONG) floatFromVal (rval); } else { if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) - - (TYPE_UWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) - + (TYPE_TARGET_UINT) floatFromVal (rval); else - SPEC_CVAL (val->type).v_int = (TYPE_WORD) floatFromVal (lval) - - (TYPE_WORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) - + (TYPE_TARGET_INT) floatFromVal (rval); } return cheapestVal (val); } @@ -1296,7 +1598,7 @@ valShift (value * lval, value * rval, int lr) 'S'); SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */ - if (getSize (val->type) * 8 <= (TYPE_UDWORD) floatFromVal (rval) && + if (getSize (val->type) * 8 <= (TYPE_TARGET_ULONG) floatFromVal (rval) && /* left shift */ (lr || /* right shift and unsigned */ @@ -1310,14 +1612,14 @@ valShift (value * lval, value * rval, int lr) if (SPEC_USIGN (val->type)) { SPEC_CVAL (val->type).v_ulong = lr ? - (TYPE_UDWORD) floatFromVal (lval) << (TYPE_UDWORD) floatFromVal (rval) : \ - (TYPE_UDWORD) floatFromVal (lval) >> (TYPE_UDWORD) floatFromVal (rval); + (TYPE_TARGET_ULONG) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \ + (TYPE_TARGET_ULONG) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval); } else { SPEC_CVAL (val->type).v_long = lr ? - (TYPE_DWORD) floatFromVal (lval) << (TYPE_UDWORD) floatFromVal (rval) : \ - (TYPE_DWORD) floatFromVal (lval) >> (TYPE_UDWORD) floatFromVal (rval); + (TYPE_TARGET_LONG) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \ + (TYPE_TARGET_LONG) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval); } } else @@ -1325,14 +1627,14 @@ valShift (value * lval, value * rval, int lr) if (SPEC_USIGN (val->type)) { SPEC_CVAL (val->type).v_uint = lr ? - (TYPE_UWORD) floatFromVal (lval) << (TYPE_UDWORD) floatFromVal (rval) : \ - (TYPE_UWORD) floatFromVal (lval) >> (TYPE_UDWORD) floatFromVal (rval); + (TYPE_TARGET_UINT) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \ + (TYPE_TARGET_UINT) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval); } else { SPEC_CVAL (val->type).v_int = lr ? - (TYPE_WORD) floatFromVal (lval) << (TYPE_UDWORD) floatFromVal (rval) : \ - (TYPE_WORD) floatFromVal (lval) >> (TYPE_UDWORD) floatFromVal (rval); + (TYPE_TARGET_INT) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \ + (TYPE_TARGET_INT) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval); } } return cheapestVal (val); @@ -1387,10 +1689,10 @@ valCompare (value * lval, value * rval, int ctype) else { /* integrals: ignore signedness */ - TYPE_UDWORD l, r; + TYPE_TARGET_ULONG l, r; - l = (TYPE_UDWORD) floatFromVal (lval); - r = (TYPE_UDWORD) floatFromVal (rval); + l = (TYPE_TARGET_ULONG) floatFromVal (lval); + r = (TYPE_TARGET_ULONG) floatFromVal (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 @@ -1399,8 +1701,8 @@ valCompare (value * lval, value * rval, int ctype) if (!IS_LONG (lval->etype) && !IS_LONG (rval->etype)) { - r = (TYPE_UWORD) r; - l = (TYPE_UWORD) l; + r = (TYPE_TARGET_UINT) r; + l = (TYPE_TARGET_UINT) l; } SPEC_CVAL (val->type).v_int = l == r; } @@ -1420,10 +1722,10 @@ valCompare (value * lval, value * rval, int ctype) else { /* integrals: ignore signedness */ - TYPE_UDWORD l, r; + TYPE_TARGET_ULONG l, r; - l = (TYPE_UDWORD) floatFromVal (lval); - r = (TYPE_UDWORD) floatFromVal (rval); + l = (TYPE_TARGET_ULONG) floatFromVal (lval); + r = (TYPE_TARGET_ULONG) floatFromVal (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 @@ -1432,8 +1734,8 @@ valCompare (value * lval, value * rval, int ctype) if (!IS_LONG (lval->etype) && !IS_LONG (rval->etype)) { - r = (TYPE_UWORD) r; - l = (TYPE_UWORD) l; + r = (TYPE_TARGET_UINT) r; + l = (TYPE_TARGET_UINT) l; } SPEC_CVAL (val->type).v_int = l != r; } @@ -1464,19 +1766,20 @@ valBitwise (value * lval, value * rval, int op) if (SPEC_LONG (val->type)) { if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) & - (TYPE_UDWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) & + (TYPE_TARGET_ULONG) floatFromVal (rval); else - SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) & - (TYPE_DWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) & + (TYPE_TARGET_LONG) floatFromVal (rval); } else { if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) & - (TYPE_UWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) & + (TYPE_TARGET_UINT) floatFromVal (rval); else - SPEC_CVAL (val->type).v_int = (TYPE_WORD) floatFromVal (lval) & (TYPE_WORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) floatFromVal (lval) & + (TYPE_TARGET_INT) floatFromVal (rval); } break; @@ -1484,20 +1787,20 @@ valBitwise (value * lval, value * rval, int op) if (SPEC_LONG (val->type)) { if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) | - (TYPE_UDWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) | + (TYPE_TARGET_ULONG) floatFromVal (rval); else - SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) | - (TYPE_DWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) | + (TYPE_TARGET_LONG) floatFromVal (rval); } else { if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) | - (TYPE_UWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) | + (TYPE_TARGET_UINT) floatFromVal (rval); else SPEC_CVAL (val->type).v_int = - (TYPE_WORD) floatFromVal (lval) | (TYPE_WORD) floatFromVal (rval); + (TYPE_TARGET_INT) floatFromVal (lval) | (TYPE_TARGET_INT) floatFromVal (rval); } break; @@ -1506,20 +1809,20 @@ valBitwise (value * lval, value * rval, int op) if (SPEC_LONG (val->type)) { if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) ^ - (TYPE_UDWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) ^ + (TYPE_TARGET_ULONG) floatFromVal (rval); else - SPEC_CVAL (val->type).v_long = (TYPE_DWORD) floatFromVal (lval) ^ - (TYPE_DWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_long = (TYPE_TARGET_LONG) floatFromVal (lval) ^ + (TYPE_TARGET_LONG) floatFromVal (rval); } else { if (SPEC_USIGN (val->type)) - SPEC_CVAL (val->type).v_uint = (TYPE_UWORD) floatFromVal (lval) ^ - (TYPE_UWORD) floatFromVal (rval); + SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) floatFromVal (lval) ^ + (TYPE_TARGET_UINT) floatFromVal (rval); else SPEC_CVAL (val->type).v_int = - (TYPE_WORD) floatFromVal (lval) ^ (TYPE_WORD) floatFromVal (rval); + (TYPE_TARGET_INT) floatFromVal (lval) ^ (TYPE_TARGET_INT) floatFromVal (rval); } break; } @@ -1564,7 +1867,7 @@ value * valCastLiteral (sym_link * dtype, double fval) { value *val; - TYPE_UDWORD l = (TYPE_UDWORD)fval; + TYPE_TARGET_ULONG l = (TYPE_TARGET_ULONG)fval; if (!dtype) return NULL; @@ -1604,14 +1907,14 @@ valCastLiteral (sym_link * dtype, double fval) } else { if (SPEC_LONG (val->etype)) { if (SPEC_USIGN (val->etype)) - SPEC_CVAL (val->etype).v_ulong = (TYPE_UDWORD) l; + SPEC_CVAL (val->etype).v_ulong = (TYPE_TARGET_ULONG) l; else - SPEC_CVAL (val->etype).v_long = (TYPE_DWORD) l; + SPEC_CVAL (val->etype).v_long = (TYPE_TARGET_LONG) l; } else { if (SPEC_USIGN (val->etype)) - SPEC_CVAL (val->etype).v_uint = (TYPE_UWORD)l; + SPEC_CVAL (val->etype).v_uint = (TYPE_TARGET_UINT)l; else - SPEC_CVAL (val->etype).v_int = (TYPE_WORD)l; + SPEC_CVAL (val->etype).v_int = (TYPE_TARGET_INT)l; } } return val;