projects / fw / sdcc / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
__rlrr array lacking extern
[fw/sdcc] / src / SDCCval.c
diff --git a/src/SDCCval.c b/src/SDCCval.c
index 329f51c7fd8424f30892113e95908eb0688f1637..984b82bd7216300a5d846b3f5cde603204aa8ec9 100644 (file)
--- a/src/SDCCval.c
+++ b/src/SDCCval.c
@@ -97,6 +97,107 @@ revinit (initList * val)
   return prev;
 }
 
+bool
+convertIListToConstList(initList *src, literalList **lList)
+{
+    initList    *iLoop;
+    literalList *head, *last, *newL;
+    
+    head = last = NULL;
+    
+    if (!src || src->type != INIT_DEEP)
+    {
+       return FALSE;
+    }
+    
+    iLoop =  src->init.deep;
+    
+    while (iLoop)
+    {
+       if (iLoop->type != INIT_NODE)
+       {
+           return FALSE;
+       }
+       
+       if (!IS_AST_LIT_VALUE(decorateType(resolveSymbols(iLoop->init.node))))
+       {
+           return FALSE;
+       }
+       iLoop = iLoop->next;
+    }
+    
+    // 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);
+       
+       if (last && last->literalValue == val)
+       {
+           last->count++;
+       }
+       else
+       {
+           newL = Safe_malloc(sizeof(literalList));
+           newL->literalValue = val;
+           newL->count = 1;
+           newL->next = NULL;
+           
+           if (last)
+           {
+               last->next = newL;
+           }
+           else
+           {
+               head = newL;
+           }
+           last = newL;
+       }
+       iLoop = iLoop->next;
+    }
+    
+    if (!head)    
+    {
+       return FALSE;
+    }
+    
+    *lList = head;
+    return TRUE;
+}
+
+literalList *
+copyLiteralList(literalList *src)
+{
+    literalList *head, *prev, *newL;
+    
+    head = prev = NULL;
+    
+    while (src)
+    {
+       newL = Safe_malloc(sizeof(literalList));
+       
+       newL->literalValue = src->literalValue;
+       newL->count = src->count;
+       newL->next = NULL;
+       
+       if (prev)
+       {
+           prev->next = newL;
+       }
+       else
+       {
+           head = newL;
+       }
+       prev = newL;
+       src = src->next;
+    }
+    
+    return head;
+}
+
+
+
 /*------------------------------------------------------------------*/
 /* copyIlist - copy initializer list            */
 /*------------------------------------------------------------------*/
@@ -225,7 +326,7 @@ valueFromLit (double lit)
       return constVal (buffer);
     }
 
-  sprintf (buffer, "%lf", lit);
+  sprintf (buffer, "%f", lit);
   return constFloatVal (buffer);
 }
 
@@ -309,30 +410,32 @@ 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;
-    }
-
-  // check the size and make it a short if required
-  if (sval < 256)
-    SPEC_SHORT (val->etype) = 1;
-
+    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;
-
 }
+
 /*! /fn char hexEscape(char **src)
 
     /param src Pointer to 'x' from start of hex character value
@@ -392,7 +495,7 @@ char octalEscape (char **str) {
 }
 
 /*! 
-  /fn void copyStr (char *dest, char *src)
+  /fn int copyStr (char *dest, char *src)
   
   Copies a source string to a dest buffer interpreting escape sequences
   and special characters
@@ -869,10 +972,10 @@ valDiv (value * lval, value * rval)
 
   /* create a new value */
   val = newValue ();
-  val->type = val->etype = ((floatFromVal (lval) / floatFromVal (rval)) < 256 ?
-                           newCharLink () : newIntLink ());
-  if (IS_FLOAT (lval->etype) || IS_FLOAT (rval->etype))
-    SPEC_NOUN (val->etype) = V_FLOAT;
+  val->type = val->etype = newLink();
+  val->type->class = SPECIFIER;
+  SPEC_NOUN (val->type) = (IS_FLOAT (lval->etype) ||
+                          IS_FLOAT (rval->etype) ? V_FLOAT : V_INT);
   SPEC_SCLS (val->etype) = S_LITERAL;
   SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) | SPEC_USIGN (rval->etype));
   SPEC_LONG (val->type) = (SPEC_LONG (lval->etype) | SPEC_LONG (rval->etype));
@@ -892,12 +995,22 @@ valDiv (value * lval, value * rval)
        }
       else
        {
-         if (SPEC_USIGN (val->type))
+         if (SPEC_USIGN (val->type)) {
            SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) /
              (unsigned) floatFromVal (rval);
-         else
+           if (/* IS_CHAR (lval->etype) && IS_CHAR (rval->etype) && */
+               (SPEC_CVAL (val->type).v_uint <=255)) {
+             SPEC_NOUN (val->type) = V_CHAR;
+           }
+         } else {
            SPEC_CVAL (val->type).v_int = (int) floatFromVal (lval) /
              (int) floatFromVal (rval);
+           if (/* IS_CHAR (lval->etype) && IS_CHAR (rval->etype) && */
+               (SPEC_CVAL (val->type).v_int >=-128) &&
+               (SPEC_CVAL (val->type).v_int <=127)) {
+             SPEC_NOUN (val->type) = V_CHAR;
+           }
+         }
        }
     }
   return val;
@@ -931,12 +1044,22 @@ valMod (value * lval, value * rval)
     }
   else
     {
-      if (SPEC_USIGN (val->type))
+      if (SPEC_USIGN (val->type)) {
        SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) %
          (unsigned) floatFromVal (rval);
-      else
+       if (/* IS_CHAR (lval->etype) && IS_CHAR (rval->etype) && */
+           (SPEC_CVAL (val->type).v_uint <=255)) {
+         SPEC_NOUN (val->type) = V_CHAR;
+       }
+      } else {
        SPEC_CVAL (val->type).v_int = (unsigned) floatFromVal (lval) %
          (unsigned) floatFromVal (rval);
+       if (/* IS_CHAR (lval->etype) && IS_CHAR (rval->etype) && */
+           (SPEC_CVAL (val->type).v_int >=-128) &&
+           (SPEC_CVAL (val->type).v_int <=127)) {
+         SPEC_NOUN (val->type) = V_CHAR;
+       }
+      }
     }
 
   return val;
@@ -975,12 +1098,22 @@ valPlus (value * lval, value * rval)
        }
       else
        {
-         if (SPEC_USIGN (val->type))
+         if (SPEC_USIGN (val->type)) {
            SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) +
              (unsigned) floatFromVal (rval);
-         else
+           if (/* IS_CHAR (lval->etype) && IS_CHAR (rval->etype) && */
+               (SPEC_CVAL (val->type).v_uint <=255)) {
+             SPEC_NOUN (val->type) = V_CHAR;
+           }
+         } else {
            SPEC_CVAL (val->type).v_int = (int) floatFromVal (lval) +
              (int) floatFromVal (rval);
+           if (/* IS_CHAR (lval->etype) && IS_CHAR (rval->etype) && */
+               (SPEC_CVAL (val->type).v_int >=-128) &&
+               (SPEC_CVAL (val->type).v_int <=127)) {
+             SPEC_NOUN (val->type) = V_CHAR;
+           }
+         }
        }
     }
   return val;
@@ -1010,20 +1143,32 @@ valMinus (value * lval, value * rval)
     {
       if (SPEC_LONG (val->type))
        {
-         if (SPEC_USIGN (val->type))
-           SPEC_CVAL (val->type).v_ulong = (unsigned long) floatFromVal (lval) -
+         if (SPEC_USIGN (val->type)) {
+           SPEC_CVAL (val->type).v_ulong = 
+             (unsigned long) floatFromVal (lval) -
              (unsigned long) floatFromVal (rval);
-         else
+         } else {
            SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) -
              (long) floatFromVal (rval);
+         }
        }
       else
        {
-         if (SPEC_USIGN (val->type))
+         if (SPEC_USIGN (val->type)) {
            SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) -
              (unsigned) floatFromVal (rval);
-         else
+           if (/* IS_CHAR (lval->etype) && IS_CHAR (rval->etype) && */
+               (SPEC_CVAL (val->type).v_uint <=255)) {
+             SPEC_NOUN (val->type) = V_CHAR;
+           }
+         } else {
            SPEC_CVAL (val->type).v_int = (int) floatFromVal (lval) - (int) floatFromVal (rval);
+           if (/* IS_CHAR (lval->etype) && IS_CHAR (rval->etype) && */
+               (SPEC_CVAL (val->type).v_int >=-128) &&
+               (SPEC_CVAL (val->type).v_int <=127)) {
+             SPEC_NOUN (val->type) = V_CHAR;
+           }
+         }
        }
     }
   return val;
@@ -1039,54 +1184,42 @@ valShift (value * lval, value * rval, int lr)
 
   /* create a new value */
   val = newValue ();
-  val->type = val->etype = newLink ();
-  val->type->class = SPECIFIER;
-  SPEC_NOUN (val->type) = V_INT;       /* type is int */
+  val->type = val->etype = newIntLink ();
   SPEC_SCLS (val->type) = S_LITERAL;   /* will remain literal */
   SPEC_USIGN (val->type) = (SPEC_USIGN (lval->etype) | SPEC_USIGN (rval->etype));
   SPEC_LONG (val->type) = (SPEC_LONG (lval->etype) | SPEC_LONG (rval->etype));
 
-  if (lr)
+  if (SPEC_LONG (val->type))
     {
-      if (SPEC_LONG (val->type))
-       {
-         if (SPEC_USIGN (val->type))
-           SPEC_CVAL (val->type).v_ulong = (unsigned long) floatFromVal (lval) <<
-             (unsigned long) floatFromVal (rval);
-         else
-           SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) <<
-             (long) floatFromVal (rval);
-       }
+      if (SPEC_USIGN (val->type))
+       SPEC_CVAL (val->type).v_ulong = lr ? 
+         (unsigned long) floatFromVal (lval) << (unsigned long) floatFromVal (rval) : \
+         (unsigned long) floatFromVal (lval) >> (unsigned long) floatFromVal (rval);
       else
-       {
-         if (SPEC_USIGN (val->type))
-           SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) <<
-             (unsigned) floatFromVal (rval);
-         else
-           SPEC_CVAL (val->type).v_int = (int) floatFromVal (lval) <<
-             (int) floatFromVal (rval);
-       }
+       SPEC_CVAL (val->type).v_long = lr ?
+         (long) floatFromVal (lval) << (long) floatFromVal (rval) : \
+         (long) floatFromVal (lval) >> (long) floatFromVal (rval);
     }
   else
     {
-      if (SPEC_LONG (val->type))
-       {
-         if (SPEC_USIGN (val->type))
-           SPEC_CVAL (val->type).v_ulong = (unsigned long) floatFromVal (lval) >>
-             (unsigned long) floatFromVal (rval);
-         else
-           SPEC_CVAL (val->type).v_long = (long) floatFromVal (lval) >>
-             (long) floatFromVal (rval);
+      if (SPEC_USIGN (val->type)) {
+       SPEC_CVAL (val->type).v_uint = lr ? 
+         (unsigned) floatFromVal (lval) << (unsigned) floatFromVal (rval) :\
+         (unsigned) floatFromVal (lval) >> (unsigned) floatFromVal (rval);
+       if (/* IS_CHAR (lval->etype) && IS_CHAR (rval->etype) && */
+           (SPEC_CVAL (val->type).v_uint <=255)) {
+         SPEC_NOUN (val->type) = V_CHAR;
        }
-      else
-       {
-         if (SPEC_USIGN (val->type))
-           SPEC_CVAL (val->type).v_uint = (unsigned) floatFromVal (lval) >>
-             (unsigned) floatFromVal (rval);
-         else
-           SPEC_CVAL (val->type).v_int = (int) floatFromVal (lval) >>
-             (int) floatFromVal (rval);
+      } else {
+       SPEC_CVAL (val->type).v_int = lr ?
+         (int) floatFromVal (lval) << (int) floatFromVal (rval) : \
+         (int) floatFromVal (lval) >> (int) floatFromVal (rval);
+       if (/* IS_CHAR (lval->etype) && IS_CHAR (rval->etype) && */
+           (SPEC_CVAL (val->type).v_int >=-128) &&
+           (SPEC_CVAL (val->type).v_int <=127)) {
+         SPEC_NOUN (val->type) = V_CHAR;
        }
+      }
     }
 
   return val;
@@ -1309,7 +1442,7 @@ getNelements (sym_link * type, initList * ilist)
     ilist = ilist->init.deep;
 
   /* if type is a character array and there is only one
-     initialiser then get the length of the string */
+     (string) initialiser then get the length of the string */
   if (IS_ARRAY (type) && IS_CHAR (etype) && !ilist->next)
     {
       ast *iast = ilist->init.node;
@@ -1319,12 +1452,12 @@ getNelements (sym_link * type, initList * ilist)
          werror (E_INIT_WRONG);
          return 0;
        }
-      if (!IS_ARRAY (v->type) || !IS_CHAR (v->etype))
+
+      if (IS_ARRAY (v->type) && IS_CHAR (v->etype))
+       // yep, it's a string
        {
-         werror (E_INIT_WRONG);
-         return 0;
+         return DCL_ELEM (v->type);
        }
-      return DCL_ELEM (v->type);
     }
 
   i = 0;
SDCC with magic sdcdb for TeleMetrum