Added support fun for long shifts

[fw/sdcc] / src / SDCCval.c

diff --git a/src/SDCCval.c b/src/SDCCval.c
index a2c6f8e0a0616e6075b6ea691a9cf3c49af8ec03..2f5b9710076e6d14edd5cd26af3363233eb4c067 100644 (file)
--- a/src/SDCCval.c
+++ b/src/SDCCval.c
@@ -215,7 +215,7 @@ symbolVal (symbol * sym)
 /* valueFromLit - creates a value from a literal                   */
 /*-----------------------------------------------------------------*/
 value *
-valueFromLit (float lit)
+valueFromLit (double lit)
 {
   char buffer[50];
 
@@ -309,31 +309,64 @@ constVal (char *s)
   else
     sval = atol (s);
 
-
-  if (SPEC_LONG (val->type) || sval > 32768)
-    {
+  // check if we have to promote to long
+  if (SPEC_LONG (val->type) || 
+      (SPEC_USIGN(val->type) && sval>0xffff) ||
+      (!SPEC_USIGN(val->type) && ((long)sval>32767 || (long)sval<-32768))) {
       if (SPEC_USIGN (val->type))
        SPEC_CVAL (val->type).v_ulong = sval;
       else
        SPEC_CVAL (val->type).v_long = sval;
       SPEC_LONG (val->type) = 1;
+      return val;
     }
+  
+  if (SPEC_USIGN (val->type))
+    SPEC_CVAL (val->type).v_uint = sval;
   else
-    {
-      if (SPEC_USIGN (val->type))
-       SPEC_CVAL (val->type).v_uint = sval;
-      else
-       SPEC_CVAL (val->type).v_int = sval;
-    }
+    SPEC_CVAL (val->type).v_int = sval;
+  
+  
+  // check if we can make it a char
+  if ((SPEC_USIGN(val->type) && sval < 256) ||
+      (!SPEC_USIGN(val->type) && ((long)sval<127 && (long)sval>-128))) {
+    SPEC_NOUN (val->etype) = V_CHAR;
+  }
+  return val;
+}
 
-  // check the size and make it a short if required
-  if (sval < 256)
-    SPEC_SHORT (val->etype) = 1;
+/*! /fn char hexEscape(char **src)
 
-  return val;
+    /param src Pointer to 'x' from start of hex character value
+*/
 
-}
+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        */
@@ -356,17 +389,28 @@ char octalEscape (char **str) {
     if (value > 255 /* || (**str>='0' && **str<='7') */ ) {
       werror (W_ESC_SEQ_OOR_FOR_CHAR);
     }
-    (*str)--;
   }
   return value;
 }
 
-/*------------------------------------------------------------------*/
-/* copyStr - copies src to dest ignoring leading & trailing \"s     */
-/*------------------------------------------------------------------*/
-void 
+/*! 
+  /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 == '\"')
@@ -407,24 +451,13 @@ copyStr (char *dest, char *src)
            case '6':
            case '7':
              *dest++ = octalEscape(&src);
+             src-- ;
              break;
 
-           case 'x': {
-             char *s=++src;
-             unsigned long 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);
-               }
-               *dest++ = value;
-               src--;
-             }
-             break;
-           }
+           case 'x': 
+             *dest++ = hexEscape(&src) ;
+             src-- ;
+             break ;
 
            case '\\':
              *dest++ = '\\';
@@ -447,7 +480,9 @@ copyStr (char *dest, char *src)
        *dest++ = *src++;
     }
 
-  *dest = '\0';
+  *dest++ = '\0';
+
+  return dest - OriginalDest ;
 }
 
 /*------------------------------------------------------------------*/
@@ -463,14 +498,14 @@ strVal (char *s)
   /* get a declarator */
   val->type = newLink ();
   DCL_TYPE (val->type) = ARRAY;
-  DCL_ELEM (val->type) = strlen (s) - 1;
   val->type->next = val->etype = newLink ();
   val->etype->class = SPECIFIER;
   SPEC_NOUN (val->etype) = V_CHAR;
   SPEC_SCLS (val->etype) = S_LITERAL;
 
   SPEC_CVAL (val->etype).v_char = Safe_calloc (1, strlen (s) + 1);
-  copyStr (SPEC_CVAL (val->etype).v_char, s);
+  DCL_ELEM (val->type) = copyStr (SPEC_CVAL (val->etype).v_char, s);
+
   return val;
 }
 
@@ -568,6 +603,7 @@ value *
 charVal (char *s)
 {
   value *val;
+//  unsigned uValue ;
 
   val = newValue ();
 
@@ -616,13 +652,22 @@ charVal (char *s)
        case '\"':
          SPEC_CVAL (val->type).v_int = '\"';
          break;
-       case '0':
-         sscanf (s, "%o", &SPEC_CVAL (val->type).v_int);
+
+       case '0' :
+       case '1' :
+       case '2' :
+       case '3' :
+       case '4' :
+       case '5' :
+       case '6' :
+       case '7' :
+         SPEC_CVAL (val->type).v_int = octalEscape(&s);
          break;
+
        case 'x':
-         s++;                  /* go behond the 'x' */
-         sscanf (s, "%x", &SPEC_CVAL (val->type).v_int);
+         SPEC_CVAL (val->type).v_int = hexEscape(&s) ;
          break;
+
        default:
          SPEC_CVAL (val->type).v_int = *s;
          break;