nilist = Safe_alloc (sizeof (initList));
nilist->type = type;
- nilist->lineno = mylineno;
- nilist->filename = currFname;
+ nilist->lineno = lexLineno;
+ nilist->filename = lexFilename;
switch (type)
{
void
resolveIvalSym (initList * ilist, sym_link * type)
{
- RESULT_TYPE resultType;
+ int is_ptr = IS_PTR (type);
+ RESULT_TYPE resultType = getResultTypeFromType (getSpec (type));
- if (!ilist)
- return;
-
- if (ilist->type == INIT_NODE)
+ while (ilist)
{
- if (IS_PTR (type))
- resultType = RESULT_TYPE_INT;
- else
- resultType = getResultTypeFromType (getSpec (type));
- ilist->init.node = decorateType (resolveSymbols (ilist->init.node),
- resultType);
- }
-
- if (ilist->type == INIT_DEEP)
- resolveIvalSym (ilist->init.deep, type);
+ 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, type);
+ ilist = ilist->next;
+ }
}
-/*-----------------------------------------------------------------*/
-/* symbolVal - creates a value for a symbol */
-/*-----------------------------------------------------------------*/
+/*------------------------------------------------------------------*/
+/* symbolVal - creates a value for a symbol */
+/*------------------------------------------------------------------*/
value *
symbolVal (symbol * sym)
{
{
if (SPEC_USIGN (var))
{
- TYPE_UDWORD maxVal = 0xffffffffu >> (32 - varBits);
+ TYPE_TARGET_ULONG maxVal = 0xffffffffu >> (32 - varBits);
if ( litVal < 0
|| litVal > maxVal)
}
else
{
- TYPE_DWORD minVal = 0xffffffff << (varBits - 1);
- TYPE_DWORD maxVal = 0x7fffffff >> (32 - varBits);
+ TYPE_TARGET_LONG minVal = 0xffffffff << (varBits - 1);
+ TYPE_TARGET_LONG maxVal = 0x7fffffff >> (32 - varBits);
if ( litVal < minVal
|| litVal > maxVal)
{
/* ignore signedness, e.g. allow everything
from -127...+255 for (unsigned) char */
- TYPE_DWORD minVal = 0xffffffff << (varBits - 1);
- TYPE_UDWORD maxVal = 0xffffffffu >> (32 - varBits);
+ TYPE_TARGET_LONG minVal = 0xffffffff << (varBits - 1);
+ TYPE_TARGET_ULONG maxVal = 0xffffffffu >> (32 - varBits);
if ( litVal < minVal
|| litVal > maxVal)
if (SPEC_USIGN (reType))
{
/* unsigned operation */
- TYPE_UDWORD minValP, maxValP, minValM, maxValM;
- TYPE_UDWORD opBitsMask = 0xffffffffu >> (32 - bitsForType (reType));
+ TYPE_TARGET_ULONG minValP, maxValP, minValM, maxValM;
+ TYPE_TARGET_ULONG opBitsMask = 0xffffffffu >> (32 - bitsForType (reType));
if (SPEC_USIGN (lit) && SPEC_USIGN (var))
{
{
/* make signed literal unsigned and
limit no of bits to size of return type */
- litVal = (TYPE_UDWORD) litVal & opBitsMask;
+ litVal = (TYPE_TARGET_ULONG) litVal & opBitsMask;
}
}
else /* SPEC_USIGN (lit) */
else
{
/* signed operation */
- TYPE_DWORD minVal, maxVal;
+ TYPE_TARGET_LONG minVal, maxVal;
if (SPEC_USIGN (var))
{
{
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);
}
/*-----------------------------------------------------------------*/
/* 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;
{
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 val;
}
-/*! /fn char hexEscape(char **src)
-
- /param src Pointer to 'x' from start of hex character value
-*/
-
-unsigned char hexEscape(char **src)
-{
- 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;
-}
-
-/*------------------------------------------------------------------*/
-/* 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 */
-/*------------------------------------------------------------------*/
-
-unsigned char octalEscape (char **str) {
- int digits;
- unsigned value=0;
-
- 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);
- }
- }
- 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++;
- }
-
- *dest++ = '\0';
-
- return dest - OriginalDest ;
-}
-
/*------------------------------------------------------------------*/
/* strVal - converts a string constant to a value */
/*------------------------------------------------------------------*/
value *
-strVal (char *s)
+strVal (const char *s)
{
value *val;
/* charVal - converts a character constant to a value */
/*------------------------------------------------------------------*/
value *
-charVal (char *s)
+charVal (const char *s)
{
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 */
/*------------------------------------------------------------------*/
/* 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;