X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCval.c;h=e520aff50004b4956ba99a54493ca600d3e09338;hb=fd94924a3d743c1c82f4b370d9401d7239172789;hp=d8271ba8dc2288a2b52a0fe7d05f998f0bff8b51;hpb=aa0ca082f440cf7b9cf126faf97e03fbbf0c0bc2;p=fw%2Fsdcc

diff --git a/src/SDCCval.c b/src/SDCCval.c
index d8271ba8..e520aff5 100644
--- a/src/SDCCval.c
+++ b/src/SDCCval.c
@@ -36,7 +36,7 @@ int cNestLevel;
 /* newValue - allocates and returns a new value        */
 /*-----------------------------------------------------------------*/
 value *
-newValue ()
+newValue (void)
 {
   value *val;
 
@@ -53,12 +53,11 @@ newiList (int type, void *ilist)
 {
   initList *nilist;
 
-
   nilist = Safe_alloc (sizeof (initList));
 
   nilist->type = type;
-  nilist->lineno = mylineno;
-  nilist->filename = currFname;
+  nilist->filename = lexFilename;
+  nilist->lineno = lexLineno;
 
   switch (type)
     {
@@ -75,7 +74,7 @@ newiList (int type, void *ilist)
 }
 
 /*------------------------------------------------------------------*/
-/* revinit   - reverses the initial values for a value  chain        */
+/* revinit   - reverses the initial values for a value chain        */
 /*------------------------------------------------------------------*/
 initList *
 revinit (initList * val)
@@ -100,19 +99,20 @@ revinit (initList * val)
 }
 
 bool
-convertIListToConstList(initList *src, literalList **lList)
+convertIListToConstList(initList *src, literalList **lList, int size)
 {
+    int cnt = 0;
     initList    *iLoop;
     literalList *head, *last, *newL;
 
     head = last = NULL;
 
-    if (!src || src->type != INIT_DEEP)
+    if (src && src->type != INIT_DEEP)
     {
         return FALSE;
     }
 
-    iLoop =  src->init.deep;
+    iLoop = src ? src->init.deep : NULL;
 
     while (iLoop)
     {
@@ -126,14 +126,19 @@ convertIListToConstList(initList *src, literalList **lList)
             return FALSE;
         }
         iLoop = iLoop->next;
+        cnt++;
+    }
+    if (!size)
+    {
+        size = cnt;
     }
 
-    // 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)
+    iLoop = src ? src->init.deep : NULL;
+    while (size--)
     {
-        double val = AST_LIT_VALUE(iLoop->init.node);
+        double val = iLoop ? AST_FLOAT_VALUE(iLoop->init.node) : 0;
 
         if (last && last->literalValue == val)
         {
@@ -156,7 +161,7 @@ convertIListToConstList(initList *src, literalList **lList)
             }
             last = newL;
         }
-        iLoop = iLoop->next;
+        iLoop = iLoop ? iLoop->next : NULL;
     }
 
     if (!head)
@@ -201,7 +206,7 @@ copyLiteralList(literalList *src)
 
 
 /*------------------------------------------------------------------*/
-/* copyIlist - copy initializer list            */
+/* copyIlist - copy initializer list                                */
 /*------------------------------------------------------------------*/
 initList *
 copyIlist (initList * src)
@@ -262,6 +267,8 @@ list2val (initList * val)
 ast *
 list2expr (initList * ilist)
 {
+  if (!ilist)
+    return NULL;
   if (ilist->type == INIT_DEEP)
     return list2expr (ilist->init.deep);
   return ilist->init.node;
@@ -273,30 +280,28 @@ list2expr (initList * ilist)
 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)
 {
@@ -400,7 +405,7 @@ checkConstantRange (sym_link *var, sym_link *lit, int op, bool exchangeLeftRight
         {
           if (SPEC_USIGN (var))
             {
-              TYPE_UDWORD maxVal = 0xffffffffu >> (32 - varBits);
+              TYPE_TARGET_ULONG maxVal = 0xffffffffu >> (32 - varBits);
 
               if (   litVal < 0
                   || litVal > maxVal)
@@ -409,8 +414,8 @@ checkConstantRange (sym_link *var, sym_link *lit, int op, bool exchangeLeftRight
             }
           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)
@@ -422,8 +427,8 @@ checkConstantRange (sym_link *var, sym_link *lit, int op, bool exchangeLeftRight
         {
           /* 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)
@@ -449,8 +454,8 @@ checkConstantRange (sym_link *var, sym_link *lit, int op, bool exchangeLeftRight
   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))
         {
@@ -480,7 +485,7 @@ checkConstantRange (sym_link *var, sym_link *lit, int op, bool exchangeLeftRight
             {
               /* make signed literal unsigned and
                  limit no of bits to size of return type */
-              litVal = (TYPE_UDWORD) litVal & opBitsMask;
+              litVal = (TYPE_TARGET_ULONG) double2ul (litVal) & opBitsMask;
             }
         }
       else /* SPEC_USIGN (lit) */
@@ -560,7 +565,7 @@ checkConstantRange (sym_link *var, sym_link *lit, int op, bool exchangeLeftRight
   else
     {
       /* signed operation */
-      TYPE_DWORD minVal, maxVal;
+      TYPE_TARGET_LONG minVal, maxVal;
 
       if (SPEC_USIGN (var))
         {
@@ -627,9 +632,9 @@ valueFromLit (double lit)
 {
   char buffer[50];
 
-  if ((((TYPE_DWORD) lit) - lit) == 0)
+  if ((((TYPE_TARGET_LONG) lit) - lit) == 0)
     {
-      SNPRINTF (buffer, sizeof(buffer), "%d", (TYPE_DWORD) lit);
+      SNPRINTF (buffer, sizeof(buffer), "%d", (TYPE_TARGET_LONG) lit);
       return constVal (buffer);
     }
 
@@ -641,15 +646,17 @@ valueFromLit (double lit)
 /* constFloatVal - converts a FLOAT constant to value              */
 /*-----------------------------------------------------------------*/
 value *
-constFloatVal (char *s)
+constFloatVal (const char *s)
 {
   value *val = newValue ();
   double sval;
+  char *p;
 
-  if (sscanf (s, "%lf", &sval) != 1)
+  sval = strtod(s, &p);
+  if (p == s)
     {
       werror (E_INVALID_FLOAT_CONST, s);
-      return constVal ("0");
+      return constCharVal (0);
     }
 
   val->type = val->etype = newLink (SPECIFIER);
@@ -664,15 +671,17 @@ constFloatVal (char *s)
 /* constFixed16x16Val - converts a FIXED16X16 constant to value    */
 /*-----------------------------------------------------------------*/
 value *
-constFixed16x16Val (char *s)
+constFixed16x16Val (const char *s)
 {
   value *val = newValue ();
   double sval;
+  char *p;
 
-  if (sscanf (s, "%lf", &sval) != 1)
+  sval = strtod(s, &p);
+  if (p == s)
     {
       werror (E_INVALID_FLOAT_CONST, s);
-      return constVal ("0");
+      return constCharVal (0);
     }
 
   val->type = val->etype = newLink (SPECIFIER);
@@ -686,274 +695,172 @@ constFixed16x16Val (char *s)
 /*-----------------------------------------------------------------*/
 /* constVal - converts an INTEGER constant into a cheapest value   */
 /*-----------------------------------------------------------------*/
-value *constVal (char *s)
+value *constVal (const char *s)
 {
   value *val;
-  short hex = 0, octal = 0;
+  char *p;
   double dval;
+  bool is_integral = 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;
 
-  hex = ((strchr (s, 'x') || strchr (s, 'X')) ? 1 : 0);
-
-  /* set the octal flag   */
-  if (!hex && *s == '0' && *(s + 1))
-    octal = 1;
-
   errno = 0;
-  if (hex || octal) {
-    unsigned long sval;
-    sval = strtoul (s, NULL, 0);
-    dval=sval;
-    if (errno) {
+  if (s[0] == '0')
+    {
+      if (s[1] == 'b' || s[1] == 'B')
+        dval = strtoul (s + 2, &p, 2);
+      else
+        dval = strtoul (s, &p, 0);
+      is_integral = 1;
+    }
+  else
+    dval = strtod (s, &p);
+
+  if (errno)
+    {
       dval = 4294967295.0;
       werror (W_INVALID_INT_CONST, s, dval);
     }
-  } else {
-    sscanf (s, "%lf", &dval);
-  }
 
   /* Setup the flags first */
   /* set the unsigned flag if 'uU' is found */
-  if (strchr (s, 'u') || strchr (s, 'U')) {
-    SPEC_USIGN (val->type) = 1;
-  }
+  if (strchr (p, 'u') || strchr (p, 'U'))
+    {
+      SPEC_USIGN (val->type) = 1;
+    }
 
   /* set the b_long flag if 'lL' is found */
-  if (strchr (s, 'l') || strchr (s, 'L')) {
-    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
-        SPEC_NOUN (val->type) = V_INT;
-      }
-      if (dval<-32768) { // check if we have to promote to long int
-        SPEC_LONG (val->type) = 1;
-      }
-    } else { // >=0
-      if (dval>0xff ||  /* check if we have to promote to int */
-          SPEC_USIGN (val->type)) { /* if it's unsigned, we can't use unsigned
-                                     char. After an integral promotion it will
-                                     be a signed int; this certainly isn't what
-                                     the programer wants */
-        SPEC_NOUN (val->type) = V_INT;
-      }
-      else { /* store char's always as unsigned; this helps other optimizations */
-        SPEC_USIGN (val->type) = 1;
-      }
-      if (dval>0xffff && SPEC_USIGN (val->type)) { // check if we have to promote to long
-        SPEC_LONG (val->type) = 1;
-      }
-      else if (dval>0x7fff && !SPEC_USIGN (val->type)) { // check if we have to promote to long int
-        if ((hex || octal) && /* hex or octal constants may be stored in unsigned type */
-            dval<=0xffff) {
-          SPEC_USIGN (val->type) = 1;
-        } else {
-          SPEC_LONG (val->type) = 1;
-          if (dval>0x7fffffff) {
-            SPEC_USIGN (val->type) = 1;
-          }
+  if (strchr (p, 'l') || strchr (p, 'L'))
+    {
+      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 */
+              SPEC_NOUN (val->type) = V_INT;
+            }
+          if (dval < -32768)
+            { /* check if we have to promote to long int */
+              SPEC_LONG (val->type) = 1;
+            }
+        }
+      else
+        { /* >=0 */
+          if (dval > 0xff ||  /* check if we have to promote to int */
+            SPEC_USIGN (val->type))
+            { /* if it's unsigned, we can't use unsigned
+                 char. After an integral promotion it will
+                 be a signed int; this certainly isn't what
+                 the programer wants */
+              SPEC_NOUN (val->type) = V_INT;
+            }
+          else
+            { /* store char's always as unsigned; this helps other optimizations */
+              SPEC_USIGN (val->type) = 1;
+            }
+          if (dval > 0xffff && SPEC_USIGN (val->type))
+            { /* check if we have to promote to long */
+              SPEC_LONG (val->type) = 1;
+            }
+          else if (dval > 0x7fff && !SPEC_USIGN (val->type))
+            { /* check if we have to promote to long int */
+              if (is_integral && /* integral (hex, octal and binary)  constants may be stored in unsigned type */
+                dval <= 0xffff)
+                {
+                  SPEC_USIGN (val->type) = 1;
+                }
+              else
+                {
+                  SPEC_LONG (val->type) = 1;
+                  if (dval > 0x7fffffff)
+                    {
+                      SPEC_USIGN (val->type) = 1;
+                    }
+                }
+            }
         }
-      }
     }
-  }
 
   /* check for out of range */
-  if (dval<-2147483648.0) {
-    dval = -2147483648.0;
-    werror (W_INVALID_INT_CONST, s, dval);
-  }
-  if (dval>2147483647.0 && !SPEC_USIGN (val->type)) {
-    dval = 2147483647.0;
-    werror (W_INVALID_INT_CONST, s, dval);
-  }
-  if (dval>4294967295.0) {
-    dval = 4294967295.0;
-    werror (W_INVALID_INT_CONST, s, dval);
-  }
+  if (dval < -2147483648.0)
+    {
+      dval = -2147483648.0;
+      werror (W_INVALID_INT_CONST, s, dval);
+    }
+  if (dval > 2147483647.0 && !SPEC_USIGN (val->type))
+    {
+      dval = 2147483647.0;
+      werror (W_INVALID_INT_CONST, s, dval);
+    }
+  if (dval > 4294967295.0)
+    {
+      dval = 4294967295.0;
+      werror (W_INVALID_INT_CONST, s, dval);
+    }
 
   if (SPEC_LONG (val->type))
     {
       if (SPEC_USIGN (val->type))
         {
-          SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD)dval;
+          SPEC_CVAL (val->type).v_ulong = (TYPE_TARGET_ULONG) double2ul (dval);
         }
       else
         {
-          SPEC_CVAL (val->type).v_long = (TYPE_DWORD)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_UWORD)dval;
+          SPEC_CVAL (val->type).v_uint = (TYPE_TARGET_UINT) double2ul (dval);
         }
       else
         {
-          SPEC_CVAL (val->type).v_int = (TYPE_WORD)dval;
+          SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) double2ul (dval);
         }
     }
 
   return val;
 }
 
-/*! /fn char hexEscape(char **src)
-
-    /param src Pointer to 'x' from start of hex character value
-*/
-
-unsigned char hexEscape(char **src)
+value *constCharVal (unsigned char v)
 {
-  char *s ;
-  unsigned long value ;
-
-  (*src)++ ;    /* Skip over the 'x' */
-  s = *src ;    /* Save for error detection */
+  value *val = newValue ();            /* alloc space for value   */
 
-  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                   */
-/*------------------------------------------------------------------*/
+  val->type = val->etype = newLink (SPECIFIER); /* create the specifier */
+  SPEC_SCLS (val->type) = S_LITERAL;
 
-unsigned char octalEscape (char **str) {
-  int digits;
-  unsigned value=0;
+  SPEC_NOUN (val->type) = V_CHAR;
 
-  for (digits=0; digits<3; digits++) {
-    if (**str>='0' && **str<='7') {
-      value = value*8 + (**str-'0');
-      (*str)++;
-    } else {
-      break;
-    }
-  }
-  if (digits) {
-    if (value > 255 /* || (**str>='0' && **str<='7') */ ) {
-      werror (W_ESC_SEQ_OOR_FOR_CHAR);
+  if (options.unsigned_char)
+    {
+      SPEC_USIGN (val->type) = 1;
+      SPEC_CVAL (val->type).v_uint = (unsigned char) v;
     }
-  }
-  return value;
-}
-
-/*!
-  /fn int copyStr (char *dest, char *src)
-
-  Copies a source string to a dest buffer interpreting escape sequences
-  and special characters
-
-  /param dest Buffer to receive the resultant string
-  /param src  Buffer containing the source string with escape sequecnes
-  /return Number of characters in output string
-
-*/
-
-int
-copyStr (char *dest, char *src)
-
-{
-  char *OriginalDest = dest ;
-
-  while (*src)
+  else
     {
-      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++;
+      SPEC_CVAL (val->type).v_int = (signed char) v;
     }
 
-  *dest++ = '\0';
-
-  return dest - OriginalDest ;
+  return val;
 }
 
 /*------------------------------------------------------------------*/
-/* strVal - converts a string constant to a value       */
+/* strVal - converts a string constant to a value                   */
 /*------------------------------------------------------------------*/
 value *
-strVal (char *s)
+strVal (const char *s)
 {
   value *val;
 
@@ -1060,60 +967,39 @@ copyValue (value * src)
 }
 
 /*------------------------------------------------------------------*/
-/* charVal - converts a character constant to a value       */
+/* charVal - converts a character constant to a value               */
 /*------------------------------------------------------------------*/
 value *
-charVal (char *s)
+charVal (const char *s)
 {
-  value *val;
-
-  val = newValue ();
-
-  val->type = val->etype = newLink (SPECIFIER);
-  SPEC_NOUN (val->type) = V_CHAR;
-  SPEC_USIGN(val->type) = 1;
-  SPEC_SCLS (val->type) = S_LITERAL;
-
-  s++;                          /* get rid of quotation */
+  /* get rid of quotation */
   /* if \ then special processing */
-  if (*s == '\\')
+  if (*++s == '\\')
     {
-      s++;                      /* go beyond the backslash  */
-      switch (*s)
+      switch (*++s)             /* go beyond the backslash  */
         {
         case 'n':
-          SPEC_CVAL (val->type).v_uint = '\n';
-          break;
+          return constCharVal ('\n');
         case 't':
-          SPEC_CVAL (val->type).v_uint = '\t';
-          break;
+          return constCharVal ('\t');
         case 'v':
-          SPEC_CVAL (val->type).v_uint = '\v';
-          break;
+          return constCharVal ('\v');
         case 'b':
-          SPEC_CVAL (val->type).v_uint = '\b';
-          break;
+          return constCharVal ('\b');
         case 'r':
-          SPEC_CVAL (val->type).v_uint = '\r';
-          break;
+          return constCharVal ('\r');
         case 'f':
-          SPEC_CVAL (val->type).v_uint = '\f';
-          break;
+          return constCharVal ('\f');
         case 'a':
-          SPEC_CVAL (val->type).v_uint = '\a';
-          break;
+          return constCharVal ('\a');
         case '\\':
-          SPEC_CVAL (val->type).v_uint = '\\';
-          break;
+          return constCharVal ('\\');
         case '\?':
-          SPEC_CVAL (val->type).v_uint = '\?';
-          break;
+          return constCharVal ('\?');
         case '\'':
-          SPEC_CVAL (val->type).v_uint = '\'';
-          break;
+          return constCharVal ('\'');
         case '\"':
-          SPEC_CVAL (val->type).v_uint = '\"';
-          break;
+          return constCharVal ('\"');
 
         case '0' :
         case '1' :
@@ -1123,22 +1009,17 @@ charVal (char *s)
         case '5' :
         case '6' :
         case '7' :
-          SPEC_CVAL (val->type).v_uint = octalEscape(&s);
-          break;
+          return constCharVal (octalEscape (&s));
 
         case 'x':
-          SPEC_CVAL (val->type).v_uint = hexEscape(&s) ;
-          break;
+          return constCharVal (hexEscape (&s));
 
         default:
-          SPEC_CVAL (val->type).v_uint = (unsigned char)*s;
-          break;
+           return constCharVal (*s);
         }
     }
   else                          /* not a backslash */
-    SPEC_CVAL (val->type).v_uint = (unsigned char)*s;
-
-  return val;
+    return constCharVal (*s);
 }
 
 /*------------------------------------------------------------------*/
@@ -1171,50 +1052,160 @@ floatFromVal (value * val)
   /* if it is not a specifier then we can assume that */
   /* it will be an unsigned long                      */
   if (!IS_SPEC (val->type))
-    return (double) SPEC_CVAL (val->etype).v_ulong;
+    return SPEC_CVAL (val->etype).v_ulong;
 
   if (SPEC_NOUN (val->etype) == V_FLOAT)
-    return (double) SPEC_CVAL (val->etype).v_float;
+    return SPEC_CVAL (val->etype).v_float;
 
   if (SPEC_NOUN (val->etype) == V_FIXED16X16)
-    return (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 SPEC_CVAL (val->etype).v_long;
+    }
+
+  if (SPEC_NOUN (val->etype) == V_INT)
+    {
+      if (SPEC_USIGN (val->etype))
+        return SPEC_CVAL (val->etype).v_uint;
+      else
+        return SPEC_CVAL (val->etype).v_int;
+    }
+
+  if (SPEC_NOUN (val->etype) == V_CHAR)
+    {
+      if (SPEC_USIGN (val->etype))
+        return (unsigned char) SPEC_CVAL (val->etype).v_uint;
+      else
+        return (signed char) SPEC_CVAL (val->etype).v_int;
+    }
+
+  if (IS_BITVAR(val->etype))
+    return SPEC_CVAL (val->etype).v_uint;
+
+  if (SPEC_NOUN (val->etype) == V_VOID)
+    return SPEC_CVAL (val->etype).v_ulong;
+
+  /* we are lost ! */
+  werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "floatFromVal: unknown value");
+  return 0;
+}
+
+/*------------------------------------------------------------------*/
+/* ulFromVal - value to unsigned long conversion                    */
+/*------------------------------------------------------------------*/
+unsigned long
+ulFromVal (value * val)
+{
+  if (!val)
+    return 0;
+
+  if (val->etype && SPEC_SCLS (val->etype) != S_LITERAL)
+    {
+      werror (E_CONST_EXPECTED, val->name);
+      return 0;
+    }
+
+  /* if it is not a specifier then we can assume that */
+  /* it will be an unsigned long                      */
+  if (!IS_SPEC (val->type))
+    return SPEC_CVAL (val->etype).v_ulong;
+
+  if (SPEC_NOUN (val->etype) == V_FLOAT)
+    return double2ul (SPEC_CVAL (val->etype).v_float);
+
+  if (SPEC_NOUN (val->etype) == V_FIXED16X16)
+    return double2ul (doubleFromFixed16x16 (SPEC_CVAL (val->etype).v_fixed16x16));
+
+  if (SPEC_LONG (val->etype))
+    {
+      if (SPEC_USIGN (val->etype))
+        return SPEC_CVAL (val->etype).v_ulong;
+      else
+        return SPEC_CVAL (val->etype).v_long;
+    }
+
+  if (SPEC_NOUN (val->etype) == V_INT)
+    {
+      if (SPEC_USIGN (val->etype))
+        return SPEC_CVAL (val->etype).v_uint;
+      else
+        return SPEC_CVAL (val->etype).v_int;
+    }
+
+  if (SPEC_NOUN (val->etype) == V_CHAR)
+    {
+      if (SPEC_USIGN (val->etype))
+        return (unsigned char) SPEC_CVAL (val->etype).v_uint;
       else
-        return (double) SPEC_CVAL (val->etype).v_long;
-    }
-
-  if (SPEC_NOUN (val->etype) == V_INT) {
-    if (SPEC_USIGN (val->etype))
-      return (double) SPEC_CVAL (val->etype).v_uint;
-    else
-      return (double) SPEC_CVAL (val->etype).v_int;
-  }
-
-  if (SPEC_NOUN (val->etype) == V_CHAR) {
-    if (SPEC_USIGN (val->etype))
-      return (double) (unsigned char)SPEC_CVAL (val->etype).v_uint;
-    else
-      return (double) (signed char)SPEC_CVAL (val->etype).v_int;
-  }
-
-  if (IS_BITVAR(val->etype)) {
-    return (double) SPEC_CVAL (val->etype).v_uint;
-  }
-
-  if (SPEC_NOUN (val->etype) == V_VOID) {
-    return (double) SPEC_CVAL (val->etype).v_ulong;
-  }
-
-  // we are lost !
-  werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
-          "floatFromVal: unknown value");
+        return (signed char) SPEC_CVAL (val->etype).v_int;
+    }
+
+  if (IS_BITVAR(val->etype))
+    return SPEC_CVAL (val->etype).v_uint;
+
+  if (SPEC_NOUN (val->etype) == V_VOID)
+    return SPEC_CVAL (val->etype).v_ulong;
+
+  /* we are lost ! */
+  werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "ulFromVal: unknown value");
   return 0;
 }
 
+/*-----------------------------------------------------------------*/
+/* doubleFromFixed16x16 - convert a fixed16x16 to double           */
+/*-----------------------------------------------------------------*/
+double doubleFromFixed16x16(TYPE_TARGET_ULONG value)
+{
+#if 0
+  /* This version is incorrect negative values. */
+  double tmp=0, exp=2;
+
+    tmp = (value & 0xffff0000) >> 16;
+
+    while(value) {
+      value &= 0xffff;
+      if(value & 0x8000)tmp += 1/exp;
+      exp *= 2;
+      value <<= 1;
+    }
+
+  return (tmp);
+#else
+  return ((double)(value * 1.0) / (double)(1UL << 16));
+#endif
+}
+
+TYPE_TARGET_ULONG fixed16x16FromDouble(double value)
+{
+#if 0
+  /* This version is incorrect negative values. */
+  unsigned int tmp=0, pos=16;
+  TYPE_TARGET_ULONG res;
+
+    tmp = floor( value );
+    res = tmp << 16;
+    value -= tmp;
+
+    tmp = 0;
+    while(pos--) {
+      value *= 2;
+      if(value >= 1.0)tmp |= (1 << pos);
+      value -= floor( value );
+    }
+
+    res |= tmp;
+
+  return (res);
+#else
+  return  double2ul (value * (double)(1UL << 16));
+#endif
+}
+
 /*------------------------------------------------------------------*/
 /* valUnaryPM - does the unary +/- operation on a constant          */
 /*------------------------------------------------------------------*/
@@ -1225,7 +1216,7 @@ valUnaryPM (value * val)
   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))
@@ -1340,24 +1331,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) ulFromVal (lval) *
+                                    (TYPE_TARGET_ULONG) ulFromVal (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) ulFromVal (lval) *
+                             (TYPE_TARGET_UINT) ulFromVal (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);
@@ -1387,26 +1378,25 @@ valDiv (value * lval, value * rval)
 
   if (IS_FLOAT (val->type))
     SPEC_CVAL (val->type).v_float = floatFromVal (lval) / floatFromVal (rval);
-  else
-  if (IS_FIXED16X16 (val->type))
+  else if (IS_FIXED16X16 (val->type))
     SPEC_CVAL (val->type).v_fixed16x16 = fixed16x16FromDouble( floatFromVal (lval) / floatFromVal (rval) );
   else if (SPEC_LONG (val->type))
     {
       if (SPEC_USIGN (val->type))
-        SPEC_CVAL (val->type).v_ulong = (TYPE_UDWORD) floatFromVal (lval) /
-          (TYPE_UDWORD) 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_DWORD) floatFromVal (lval) /
-          (TYPE_DWORD) 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_UWORD) floatFromVal (lval) /
-          (TYPE_UWORD) 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_WORD) floatFromVal (lval) /
-          (TYPE_WORD) floatFromVal (rval);
+        SPEC_CVAL (val->type).v_int = (TYPE_TARGET_INT) ulFromVal (lval) /
+          (TYPE_TARGET_INT) ulFromVal (rval);
     }
   return cheapestVal (val);
 }
@@ -1430,20 +1420,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) ulFromVal (lval) %
+          (TYPE_TARGET_ULONG) ulFromVal (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) ulFromVal (lval) %
+          (TYPE_TARGET_LONG) ulFromVal (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) ulFromVal (lval) %
+          (TYPE_TARGET_UINT) ulFromVal (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) ulFromVal (lval) %
+          (TYPE_TARGET_INT) ulFromVal (rval);
     }
   return cheapestVal (val);
 }
@@ -1472,20 +1462,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) ulFromVal (lval) +
+         (TYPE_TARGET_ULONG) ulFromVal (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) ulFromVal (lval) +
+          (TYPE_TARGET_LONG) ulFromVal (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) ulFromVal (lval) +
+          (TYPE_TARGET_UINT) ulFromVal (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) ulFromVal (lval) +
+          (TYPE_TARGET_INT) ulFromVal (rval);
     }
   return cheapestVal (val);
 }
@@ -1514,20 +1504,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) ulFromVal (lval) -
+          (TYPE_TARGET_ULONG) ulFromVal (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) ulFromVal (lval) -
+          (TYPE_TARGET_LONG) ulFromVal (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) ulFromVal (lval) -
+         (TYPE_TARGET_UINT) ulFromVal (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) ulFromVal (lval) -
+         (TYPE_TARGET_INT) ulFromVal (rval);
     }
   return cheapestVal (val);
 }
@@ -1548,7 +1538,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) ulFromVal (rval) &&
        /* left shift */
       (lr ||
         /* right shift and unsigned */
@@ -1562,14 +1552,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) 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_DWORD) floatFromVal (lval) << (TYPE_UDWORD) floatFromVal (rval) : \
-            (TYPE_DWORD) floatFromVal (lval) >> (TYPE_UDWORD) floatFromVal (rval);
+            (TYPE_TARGET_LONG) ulFromVal (lval) << (TYPE_TARGET_ULONG) ulFromVal (rval) : \
+            (TYPE_TARGET_LONG) ulFromVal (lval) >> (TYPE_TARGET_ULONG) ulFromVal (rval);
         }
     }
   else
@@ -1577,14 +1567,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) 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_WORD) floatFromVal (lval) << (TYPE_UDWORD) floatFromVal (rval) : \
-            (TYPE_WORD) floatFromVal (lval) >> (TYPE_UDWORD) 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);
@@ -1639,10 +1629,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) 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
@@ -1651,8 +1641,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;
         }
@@ -1672,10 +1662,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) 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
@@ -1684,8 +1674,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;
         }
@@ -1716,19 +1706,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) ulFromVal (lval) &
+              (TYPE_TARGET_ULONG) ulFromVal (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) ulFromVal (lval) &
+              (TYPE_TARGET_LONG) ulFromVal (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) ulFromVal (lval) &
+              (TYPE_TARGET_UINT) ulFromVal (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) ulFromVal (lval) &
+              (TYPE_TARGET_INT) ulFromVal (rval);
         }
       break;
 
@@ -1736,20 +1727,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) ulFromVal (lval) |
+              (TYPE_TARGET_ULONG) ulFromVal (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) ulFromVal (lval) |
+              (TYPE_TARGET_LONG) ulFromVal (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) ulFromVal (lval) |
+              (TYPE_TARGET_UINT) ulFromVal (rval);
           else
             SPEC_CVAL (val->type).v_int =
-              (TYPE_WORD) floatFromVal (lval) | (TYPE_WORD) floatFromVal (rval);
+              (TYPE_TARGET_INT) ulFromVal (lval) | (TYPE_TARGET_INT) ulFromVal (rval);
         }
 
       break;
@@ -1758,20 +1749,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) ulFromVal (lval) ^
+              (TYPE_TARGET_ULONG) ulFromVal (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) ulFromVal (lval) ^
+              (TYPE_TARGET_LONG) ulFromVal (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) ulFromVal (lval) ^
+              (TYPE_TARGET_UINT) ulFromVal (rval);
           else
             SPEC_CVAL (val->type).v_int =
-              (TYPE_WORD) floatFromVal (lval) ^ (TYPE_WORD) floatFromVal (rval);
+              (TYPE_TARGET_INT) ulFromVal (lval) ^ (TYPE_TARGET_INT) ulFromVal (rval);
         }
       break;
     }
@@ -1816,7 +1807,7 @@ value *
 valCastLiteral (sym_link * dtype, double fval)
 {
   value *val;
-  TYPE_UDWORD l = (TYPE_UDWORD)fval;
+  unsigned long l = double2ul (fval);
 
   if (!dtype)
     return NULL;
@@ -1833,39 +1824,59 @@ valCastLiteral (sym_link * dtype, double fval)
 
   /* 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_UDWORD) l;
+            SPEC_CVAL (val->etype).v_ulong = (TYPE_TARGET_ULONG) l;
           else
-              SPEC_CVAL (val->etype).v_long = (TYPE_DWORD) 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_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;
 }
 
@@ -1896,7 +1907,7 @@ getNelements (sym_link * type, initList * ilist)
         }
 
       if (IS_ARRAY (v->type) && IS_CHAR (v->etype))
-        // yep, it's a string
+        /* yep, it's a string */
         {
           return DCL_ELEM (v->type);
         }
@@ -1954,7 +1965,7 @@ valForArray (ast * arrExpr)
     }
 
   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)
@@ -2060,7 +2071,7 @@ valForCastAggr (ast * aexpr, sym_link * type, ast * cnst, int op)
 
   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);