iLoop = iLoop->next;
}
- // We've now established that the initializer list contains only literal values.
+ /* We've now established that the initializer list contains only literal values. */
iLoop = src->init.deep;
while (iLoop)
{
- double val = AST_LIT_VALUE(iLoop->init.node);
+ double val = AST_FLOAT_VALUE(iLoop->init.node);
if (last && last->literalValue == val)
{
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)
{
{
/* make signed literal unsigned and
limit no of bits to size of return type */
- litVal = (TYPE_TARGET_ULONG) litVal & opBitsMask;
+ litVal = (TYPE_TARGET_ULONG) double2ul (litVal) & opBitsMask;
}
}
else /* SPEC_USIGN (lit) */
{
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");
{
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");
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 a signed char
+ /* let's start with a signed char */
SPEC_NOUN (val->type) = V_CHAR;
SPEC_USIGN (val->type) = 0;
if (hex || octal) {
unsigned long sval;
sval = strtoul (s, NULL, 0);
- dval=sval;
+ dval = sval;
if (errno) {
dval = 4294967295.0;
werror (W_INVALID_INT_CONST, s, dval);
}
} else {
- sscanf (s, "%lf", &dval);
+ dval = strtod(s, NULL);
}
/* Setup the flags first */
SPEC_NOUN (val->type) = V_INT;
SPEC_LONG (val->type) = 1;
} else {
- if (dval<0) { // "-28u" will still be signed and negative
- if (dval<-128) { // check if we have to promote to int
+ 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
+ if (dval<-32768) { /* check if we have to promote to long int */
SPEC_LONG (val->type) = 1;
}
- } else { // >=0
+ } 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
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
+ 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
+ else if (dval>0x7fff && !SPEC_USIGN (val->type)) { /* check if we have to promote to long int */
if ((hex || octal) && /* hex or octal constants may be stored in unsigned type */
dval<=0xffff) {
SPEC_USIGN (val->type) = 1;
{
if (SPEC_USIGN (val->type))
{
- SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG)dval;
+ SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) double2ul (dval);
}
else
{
- SPEC_CVAL (val->type).v_long = (TYPE_TARGET_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 = (TYPE_TARGET_UINT)dval;
+ SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) double2ul (dval);
}
else
{
- SPEC_CVAL (val->type).v_int = (TYPE_TARGET_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(const char **src)
-{
- char *s ;
- unsigned long value ;
-
- (*src)++ ; /* Skip over the 'x' */
-
- value = strtol (*src, &s, 16);
-
- if (s == *src) {
- // no valid hex found
- werror(E_INVALID_HEX);
- } else {
- if (value > 255) {
- werror(W_ESC_SEQ_OOR_FOR_CHAR);
- }
- }
- *src = s;
-
- 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 (const 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, const 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 */
+/* strVal - converts a string constant to a value */
/*------------------------------------------------------------------*/
value *
strVal (const char *s)
}
/*------------------------------------------------------------------*/
-/* charVal - converts a character constant to a value */
+/* charVal - converts a character constant to a value */
/*------------------------------------------------------------------*/
value *
charVal (const char *s)
/* 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 (double) doubleFromFixed16x16( SPEC_CVAL (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;
+ return 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_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 (double) (unsigned char)SPEC_CVAL (val->etype).v_uint;
- else
- return (double) (signed char)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 (double) SPEC_CVAL (val->etype).v_uint;
- }
+ if (IS_BITVAR(val->etype))
+ return SPEC_CVAL (val->etype).v_uint;
- if (SPEC_NOUN (val->etype) == V_VOID) {
- return (double) SPEC_CVAL (val->etype).v_ulong;
- }
+ 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");
+ /* 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;
}
return (res);
#else
- return (TYPE_TARGET_ULONG)(value * (double)(1UL << 16));
+ return double2ul (value * (double)(1UL << 16));
#endif
}
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 = -SPEC_CVAL (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))
/* 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_TARGET_ULONG) floatFromVal (lval) *
- (TYPE_TARGET_ULONG) floatFromVal (rval);
+ 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) floatFromVal (lval) *
- (TYPE_TARGET_UINT) floatFromVal (rval);
+ 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)
else if (SPEC_LONG (val->type))
{
if (SPEC_USIGN (val->type))
- SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) /
- (TYPE_TARGET_ULONG) 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 = (TYPE_TARGET_LONG) floatFromVal (lval) /
- (TYPE_TARGET_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 = (TYPE_TARGET_UINT) floatFromVal (lval) /
- (TYPE_TARGET_UINT) floatFromVal (rval);
+ 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) floatFromVal (lval) /
- (TYPE_TARGET_INT) floatFromVal (rval);
+ SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) ulFromVal (lval) /
+ (TYPE_TARGET_INT) ulFromVal (rval);
}
return cheapestVal (val);
}
if (SPEC_LONG (val->type))
{
if (SPEC_USIGN (val->type))
- SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) %
- (TYPE_TARGET_ULONG) 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 = (TYPE_TARGET_LONG) floatFromVal (lval) %
- (TYPE_TARGET_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 = (TYPE_TARGET_UINT) floatFromVal (lval) %
- (TYPE_TARGET_UINT) floatFromVal (rval);
+ 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) floatFromVal (lval) %
- (TYPE_TARGET_INT) floatFromVal (rval);
+ SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) ulFromVal (lval) %
+ (TYPE_TARGET_INT) ulFromVal (rval);
}
return cheapestVal (val);
}
else if (SPEC_LONG (val->type))
{
if (SPEC_USIGN (val->type))
- SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) +
- (TYPE_TARGET_ULONG) 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 = (TYPE_TARGET_LONG) floatFromVal (lval) +
- (TYPE_TARGET_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 = (TYPE_TARGET_UINT) floatFromVal (lval) +
- (TYPE_TARGET_UINT) floatFromVal (rval);
+ 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) floatFromVal (lval) +
- (TYPE_TARGET_INT) floatFromVal (rval);
+ SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) ulFromVal (lval) +
+ (TYPE_TARGET_INT) ulFromVal (rval);
}
return cheapestVal (val);
}
else if (SPEC_LONG (val->type))
{
if (SPEC_USIGN (val->type))
- SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) -
- (TYPE_TARGET_ULONG) 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 = (TYPE_TARGET_LONG) floatFromVal (lval) -
- (TYPE_TARGET_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 = (TYPE_TARGET_UINT) floatFromVal (lval) -
- (TYPE_TARGET_UINT) floatFromVal (rval);
+ 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) floatFromVal (lval) -
- (TYPE_TARGET_INT) floatFromVal (rval);
+ SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) ulFromVal (lval) -
+ (TYPE_TARGET_INT) ulFromVal (rval);
}
return cheapestVal (val);
}
'S');
SPEC_SCLS (val->etype) = S_LITERAL; /* will remain literal */
- if (getSize (val->type) * 8 <= (TYPE_TARGET_ULONG) floatFromVal (rval) &&
+ if (getSize (val->type) * 8 <= (TYPE_TARGET_ULONG) ulFromVal (rval) &&
/* left shift */
(lr ||
/* right shift and unsigned */
if (SPEC_USIGN (val->type))
{
SPEC_CVAL (val->type).v_ulong = lr ?
- (TYPE_TARGET_ULONG) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \
- (TYPE_TARGET_ULONG) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval);
+ (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 ?
- (TYPE_TARGET_LONG) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \
- (TYPE_TARGET_LONG) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval);
+ (TYPE_TARGET_LONG) ulFromVal (lval) << (TYPE_TARGET_ULONG) ulFromVal (rval) : \
+ (TYPE_TARGET_LONG) ulFromVal (lval) >> (TYPE_TARGET_ULONG) ulFromVal (rval);
}
}
else
if (SPEC_USIGN (val->type))
{
SPEC_CVAL (val->type).v_uint = lr ?
- (TYPE_TARGET_UINT) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \
- (TYPE_TARGET_UINT) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval);
+ (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) floatFromVal (lval) << (TYPE_TARGET_ULONG) floatFromVal (rval) : \
- (TYPE_TARGET_INT) floatFromVal (lval) >> (TYPE_TARGET_ULONG) floatFromVal (rval);
+ (TYPE_TARGET_INT) ulFromVal (lval) << (TYPE_TARGET_ULONG) ulFromVal (rval) : \
+ (TYPE_TARGET_INT) ulFromVal (lval) >> (TYPE_TARGET_ULONG) ulFromVal (rval);
}
}
return cheapestVal (val);
/* integrals: ignore signedness */
TYPE_TARGET_ULONG l, r;
- l = (TYPE_TARGET_ULONG) floatFromVal (lval);
- r = (TYPE_TARGET_ULONG) floatFromVal (rval);
+ 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
/* integrals: ignore signedness */
TYPE_TARGET_ULONG l, r;
- l = (TYPE_TARGET_ULONG) floatFromVal (lval);
- r = (TYPE_TARGET_ULONG) floatFromVal (rval);
+ 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
if (SPEC_LONG (val->type))
{
if (SPEC_USIGN (val->type))
- SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) &
- (TYPE_TARGET_ULONG) 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 = (TYPE_TARGET_LONG) floatFromVal (lval) &
- (TYPE_TARGET_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 = (TYPE_TARGET_UINT) floatFromVal (lval) &
- (TYPE_TARGET_UINT) floatFromVal (rval);
+ 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) floatFromVal (lval) &
- (TYPE_TARGET_INT) floatFromVal (rval);
+ SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) ulFromVal (lval) &
+ (TYPE_TARGET_INT) ulFromVal (rval);
}
break;
if (SPEC_LONG (val->type))
{
if (SPEC_USIGN (val->type))
- SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) |
- (TYPE_TARGET_ULONG) 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 = (TYPE_TARGET_LONG) floatFromVal (lval) |
- (TYPE_TARGET_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 = (TYPE_TARGET_UINT) floatFromVal (lval) |
- (TYPE_TARGET_UINT) floatFromVal (rval);
+ 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) floatFromVal (lval) | (TYPE_TARGET_INT) floatFromVal (rval);
+ (TYPE_TARGET_INT) ulFromVal (lval) | (TYPE_TARGET_INT) ulFromVal (rval);
}
break;
if (SPEC_LONG (val->type))
{
if (SPEC_USIGN (val->type))
- SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) floatFromVal (lval) ^
- (TYPE_TARGET_ULONG) 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 = (TYPE_TARGET_LONG) floatFromVal (lval) ^
- (TYPE_TARGET_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 = (TYPE_TARGET_UINT) floatFromVal (lval) ^
- (TYPE_TARGET_UINT) floatFromVal (rval);
+ 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) floatFromVal (lval) ^ (TYPE_TARGET_INT) floatFromVal (rval);
+ (TYPE_TARGET_INT) ulFromVal (lval) ^ (TYPE_TARGET_INT) ulFromVal (rval);
}
break;
}
valCastLiteral (sym_link * dtype, double fval)
{
value *val;
- TYPE_TARGET_ULONG l = (TYPE_TARGET_ULONG)fval;
+ unsigned long l = double2ul (fval);
if (!dtype)
return NULL;
/* 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 = l;
+ 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 if (SPEC_NOUN (val->etype) == V_FIXED16X16)
- SPEC_CVAL (val->etype).v_fixed16x16 = fixed16x16FromDouble( fval );
- else if (SPEC_NOUN (val->etype) == V_BIT ||
- SPEC_NOUN (val->etype) == V_SBIT)
- SPEC_CVAL (val->etype).v_uint = l ? 1 : 0;
- else if (SPEC_NOUN (val->etype) == V_BITFIELD)
- SPEC_CVAL (val->etype).v_uint = l &
- (0xffffu >> (16 - SPEC_BLEN (val->etype)));
- else if (SPEC_NOUN (val->etype) == V_CHAR) {
+ 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_UBYTE) l;
+ SPEC_CVAL (val->etype).v_uint = (TYPE_TARGET_UINT) l;
else
- SPEC_CVAL (val->etype).v_int = (TYPE_BYTE) l;
- } else {
- if (SPEC_LONG (val->etype)) {
+ 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;
+ SPEC_CVAL (val->etype).v_ulong = (TYPE_TARGET_ULONG) l;
else
- SPEC_CVAL (val->etype).v_long = (TYPE_TARGET_LONG) 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;
+ SPEC_CVAL (val->etype).v_uint = (TYPE_TARGET_UINT) l;
else
- SPEC_CVAL (val->etype).v_int = (TYPE_TARGET_INT)l;
- }
- }
+ SPEC_CVAL (val->etype).v_int = (TYPE_TARGET_INT) l;
+ }
+ }
+
return val;
}
}
if (IS_ARRAY (v->type) && IS_CHAR (v->etype))
- // yep, it's a string
+ /* yep, it's a string */
{
return DCL_ELEM (v->type);
}
}
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)
SNPRINTF (val->name, sizeof(val->name), "(%s %c %d)",
AST_SYMBOL (aexpr)->rname, op,
- getSize (type->next) * (int) AST_LIT_VALUE (cnst));
+ getSize (type->next) * AST_ULONG_VALUE (cnst));
val->type = type;
val->etype = getSpec (val->type);