Constants < 256 are char's, not short int's

[fw/sdcc] / src / SDCCval.c

diff --git a/src/SDCCval.c b/src/SDCCval.c
index e70b7931b0a81203d8f84bae962653ba119517d6..c197f817a803e9a5bcfd6e5bdfb3a307196e2a0e 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];
 
@@ -326,21 +326,89 @@ constVal (char *s)
        SPEC_CVAL (val->type).v_int = sval;
     }
 
-  // check the size and make it a short if required
+  // check the size and make it a char if possible
   if (sval < 256)
-    SPEC_SHORT (val->etype) = 1;
+    SPEC_NOUN (val->etype) = V_CHAR;
 
   return val;
 
 }
+/*! /fn char hexEscape(char **src)
 
+    /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;
+}
 /*------------------------------------------------------------------*/
-/* copyStr - copies src to dest ignoring leading & trailing \"s     */
+/* 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                   */
 /*------------------------------------------------------------------*/
-void 
+
+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)
+
 {
-  unsigned int x;
+  char *OriginalDest = dest ;
+
   while (*src)
     {
       if (*src == '\"')
@@ -371,22 +439,24 @@ copyStr (char *dest, char *src)
            case 'a':
              *dest++ = '\a';
              break;
+
            case '0':
-             /* embedded octal or hex constant */
-             if (*(src + 1) == 'x' ||
-                 *(src + 1) == 'X')
-               {
-                 x = strtol (src, &src, 16);
-                 *dest++ = x;
-               }
-             else
-               {
-                 /* must be octal */
-                 x = strtol (src, &src, 8);
-                 *dest++ = x;
-               }
+           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;
@@ -408,7 +478,9 @@ copyStr (char *dest, char *src)
        *dest++ = *src++;
     }
 
-  *dest = '\0';
+  *dest++ = '\0';
+
+  return dest - OriginalDest ;
 }
 
 /*------------------------------------------------------------------*/
@@ -424,14 +496,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;
 }
 
@@ -529,6 +601,7 @@ value *
 charVal (char *s)
 {
   value *val;
+//  unsigned uValue ;
 
   val = newValue ();
 
@@ -577,13 +650,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;