Fixed processing of multi-dimensional arrays.

[splint.git] / src / ctbase.i

diff --git a/src/ctbase.i b/src/ctbase.i
index 2b30048475725b4dc7c0ad79dd039b3478e340c6..c256432cb7e972ab558318d7973a222ece092acb 100644 (file)
--- a/src/ctbase.i
+++ b/src/ctbase.i
@@ -34,13 +34,13 @@
 abst_typedef /*@null@*/ struct s_ctbase *ctbase;
 
 /*@function static bool ctuid_isAnyUserType (sef ctuid p_cid) @*/
-/*@i888@*/
+
 /*@-macrofcndecl@*/ /*@-macroparams@*/
 # define ctuid_isAnyUserType(cid) \
    ((cid) == CT_ABST || (cid) == CT_USER || (cid) == CT_NUMABST)
 /*@=macrofcndecl@*/ /*@=macroparams@*/
 
-/*@private@*/ typedef struct {
+/*:private:*/ typedef struct {
   ctkind kind;
   ctbase ctbase; 
   ctype base;     /* type I point to (or element of array) */
@@ -501,11 +501,67 @@ ctbase_unparse (ctbase c)
          return (message ("%t *", c->contents.base));
        }
     case CT_FIXEDARRAY:
-      return (message ("%t [%d]", 
-                      c->contents.farray->base, 
-                      (int) c->contents.farray->size));
+      /*
+      ** C prints out array declarations backwards, if
+      ** base is an array need to print out in reverse order.
+      */
+
+      if (ctype_isArray (c->contents.farray->base)) 
+       {
+         ctype base = c->contents.farray->base;
+         cstring res = message ("[%d]", (int) c->contents.farray->size);
+
+         while (ctype_isArray (base)) 
+           {
+             if (ctype_isFixedArray (base)) 
+               {
+                 res = message ("%q[%d]", 
+                                res, (int) ctype_getArraySize (base));
+               }
+             else
+               {
+                 res = message ("%q[]", res);
+               }
+
+             base = ctype_baseArrayPtr (base);
+           }
+
+         return (message ("%t %q", base, res));
+       } 
+      else 
+       {
+         return (message ("%t [%d]", 
+                          c->contents.farray->base, 
+                          (int) c->contents.farray->size));
+       }
     case CT_ARRAY:
-      return (message ("%t []", c->contents.base));
+      if (ctype_isArray (c->contents.base)) 
+       {
+         ctype base = c->contents.base;
+         cstring res = cstring_makeLiteral ("[]");
+
+         while (ctype_isArray (base)) 
+           {
+             if (ctype_isFixedArray (base)) 
+               {
+                 res = message ("%q[%d]", 
+                                res, (int) ctype_getArraySize (base));
+               }
+             else
+               {
+                 res = message ("%q[]", res);
+               }
+
+             base = ctype_baseArrayPtr (base);
+           }
+
+         return (message ("%t %q", base, res));
+
+       }
+      else
+       {
+         return (message ("%t []", c->contents.base));
+       }
     case CT_FCN:
       return (message ("[function (%q) returns %t]",
                       uentryList_unparseParams (c->contents.fcn->params),
@@ -1024,12 +1080,11 @@ ctbase_dump (ctbase c)
     case CT_PRIM:
       return (message ("p%d|", c->contents.prim));
     case CT_USER:
-      return (message ("s%d|", 
-                      usymtab_convertId (c->contents.tid)));
+      return (message ("s%d|", usymtab_convertTypeId (c->contents.tid)));
     case CT_ABST:
-      return (message ("a%d|", usymtab_convertId (c->contents.tid)));
+      return (message ("a%d|", usymtab_convertTypeId (c->contents.tid)));
     case CT_NUMABST:
-      return (message ("n%d|", usymtab_convertId (c->contents.tid)));
+      return (message ("n%d|", usymtab_convertTypeId (c->contents.tid)));
     case CT_PTR:
       return (message ("t%q|", ctype_dump (c->contents.base)));
     case CT_ARRAY:
@@ -1173,7 +1228,8 @@ ctbase_free (/*@only@*/ ctbase c)
          sfree (c);
          break;
        case CT_FCN:
-         /*@i32@*/ /* uentryList_free (c->contents.fcn->params); */
+         /* Cannot free params: uentryList_free (c->contents.fcn->params);  */ 
+         uentryList_freeShallow (c->contents.fcn->params);
          sfree (c);
          break;
        case CT_STRUCT:
@@ -2382,13 +2438,13 @@ ctbase_compare (ctbase c1, ctbase c2, bool strict)
     case CT_BOOL:
       return 0;
     case CT_USER:
-      return (int_compare (c1->contents.tid, c2->contents.tid));
+      return (typeId_compare (c1->contents.tid, c2->contents.tid));
     case CT_ENUMLIST:       
       return 1;
     case CT_ENUM:              /* for now, keep like abstract */
     case CT_ABST:
     case CT_NUMABST:
-      return (int_compare (c1->contents.tid, c2->contents.tid));
+      return (typeId_compare (c1->contents.tid, c2->contents.tid));
     case CT_PTR:
       return (ctype_compare (c1->contents.base, c2->contents.base));
     case CT_FIXEDARRAY:
@@ -2627,3 +2683,54 @@ bool ctbase_isBigger (ctbase ct1, ctbase ct2)
       return FALSE;
     }
 }
+
+int ctbase_getSize (ctbase ct)
+{
+  if (ct == NULL) 
+    {
+      return 0;
+    }
+  
+  switch (ct->type) 
+    {
+    case CT_UNKNOWN:
+    case CT_BOOL:
+    case CT_PRIM:
+      {
+       cprim cp = ct->contents.prim;
+       int nbits = cprim_getExpectedBits (cp);
+       return nbits;
+      }
+    case CT_USER:
+    case CT_ABST:
+    case CT_NUMABST:
+    case CT_EXPFCN:
+      {
+       return 0;
+      }
+    case CT_PTR:
+      {
+       /* Malloc returns void *, but they are bytes.  Normal void * is pointer size. */
+       if (ctype_isVoid (ct->contents.base)) 
+         {
+           return 8;
+         }
+       else
+         {
+           return ctype_getSize (ct->contents.base);
+         }
+      }
+    case CT_FIXEDARRAY: 
+    case CT_ARRAY:
+    case CT_FCN:
+    case CT_STRUCT:
+    case CT_UNION:
+    case CT_ENUM:
+    case CT_CONJ:
+      break;
+      BADDEFAULT;
+    }
+
+  return 0;
+      
+}