return val;
}
-#if defined(REDUCE_LITERALS)
/*--------------------------------------------------------------------*/
-/* cheapestVal - convert a val to the cheapest as possible value */
+/* cheapestVal - try to reduce 'signed int' to 'char' */
/*--------------------------------------------------------------------*/
-static value *cheapestVal (value *val) {
- TYPE_DWORD sval=0;
- TYPE_UDWORD uval=0;
-
- if (IS_FLOAT(val->type) || IS_FIXED(val->type) || IS_CHAR(val->type))
+static value *
+cheapestVal (value *val)
+{
+ /* only int can be reduced */
+ if (!IS_INT(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 = (TYPE_UWORD)uval;
- if (uval<=0xff) {
- SPEC_NOUN(val->type)=V_CHAR;
- }
- }
- } else { // not unsigned
- if (sval<0) {
- if (sval>=-32768) {
- SPEC_LONG(val->type)=0;
- SPEC_CVAL(val->type).v_int = (TYPE_WORD)sval;
- if (sval>=-128) {
- SPEC_NOUN(val->type)=V_CHAR;
- }
- }
- } else { // sval>=0
- if (sval<=32767) {
- SPEC_LONG(val->type)=0;
- SPEC_CVAL(val->type).v_int = (TYPE_WORD)sval;
- if (sval<=127) {
- SPEC_NOUN(val->type)=V_CHAR;
- }
- }
- }
- }
- return val;
-}
-
-#else
-
-static value *cheapestVal (value *val)
-{
- if (IS_FLOAT (val->type) || IS_FIXED (val->type) || IS_CHAR (val->type))
+ /* long must not be changed */
+ if (SPEC_LONG(val->type))
return val;
- /* - signed/unsigned must not be changed.
- - long must not be changed.
+ /* unsigned must not be changed */
+ if (SPEC_USIGN(val->type))
+ return val;
- the only possible reduction is from signed int to signed char,
+ /* 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 (IS_INT(val->type) &&
- !SPEC_USIGN(val->type) &&
- !SPEC_LONG(val->type) &&
- SPEC_CVAL(val->type).v_int >= -128 &&
- SPEC_CVAL(val->type).v_int < 0)
-
+ if (SPEC_CVAL(val->type).v_int < -128 ||
+ SPEC_CVAL(val->type).v_int > 255)
{
- SPEC_NOUN(val->type) = V_CHAR;
+ /* not in the range of (un)signed char */
+ return val;
}
+
+ SPEC_NOUN(val->type) = V_CHAR;
+
/* 'unsigned char' promotes to 'signed int', so that we can
reduce it the other way */
- if (IS_INT(val->type) &&
- !SPEC_USIGN(val->type) &&
- !SPEC_LONG(val->type) &&
- SPEC_CVAL(val->type).v_int >= 0 &&
- SPEC_CVAL(val->type).v_int <= 255)
-
+ if (SPEC_CVAL(val->type).v_int >= 0)
{
- SPEC_NOUN(val->type) = V_CHAR;
SPEC_USIGN(val->type) = 1;
}
return (val);
}
-#endif
+
+/*--------------------------------------------------------------------*/
+/* 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 */
{
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);
}
{
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;
}
}
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 */
/*------------------------------------------------------------------*/
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);
}
}
- // -(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;
- }
- }
return val;
}
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;
+
if (SPEC_NOUN(val->etype) == V_CHAR)
- if ( SPEC_CVAL(val->etype).v_int < -128
- || SPEC_CVAL(val->etype).v_int > 127)
+ {
+ /* 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;
}
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;
+
}
+ /* 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;
}
/* 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);
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);
}
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);
}
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);
}
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);
}
'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 */
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
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);
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
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;
}
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
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;
}
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;
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;
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;
}
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;
} 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;
projects / fw / sdcc / blobdiff