X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Fcc65%2Fdatatype.c;h=282385ed7e211c34173ff7dae4609f006ea80aa3;hb=73dfa23c987d8a7f1154801b85c171f9e01dcd58;hp=6aad02ea36ef65381cff0a3ef87df890be64a535;hpb=872c2b445358e9f848c6f356a7b67d4edef98dd9;p=cc65

diff --git a/src/cc65/datatype.c b/src/cc65/datatype.c
index 6aad02ea3..282385ed7 100644
--- a/src/cc65/datatype.c
+++ b/src/cc65/datatype.c
@@ -6,9 +6,9 @@
 /*                                                                           */
 /*                                                                           */
 /*                                                                           */
-/* (C) 1998-2002 Ullrich von Bassewitz                                       */
-/*               Wacholderweg 14                                             */
-/*               D-70597 Stuttgart                                           */
+/* (C) 1998-2003 Ullrich von Bassewitz                                       */
+/*               Römerstrasse 52                                             */
+/*               D-70794 Filderstadt                                         */
 /* EMail:        uz@musoftware.de                                            */
 /*                                                                           */
 /*                                                                           */
@@ -342,6 +342,9 @@ void PrintFuncSig (FILE* F, const char* Name, type* Type)
  	    if (I > 0) {
  		fprintf (F, ", ");
  	    }
+            if (SymIsRegVar (E)) {
+                fprintf (F, "register ");
+            }
  	    PrintType (F, E->Type);
  	    E = E->NextSym;
  	}
@@ -365,7 +368,7 @@ void PrintRawType (FILE* F, const type* Type)
 
 
 void Encode (type* Type, unsigned long Val)
-/* Encode p[0] and p[1] so that neither p[0] nore p[1] is zero */
+/* Encode Val into the given type string */
 {
     int I;
     for (I = 0; I < DECODE_SIZE; ++I) {
@@ -422,18 +425,11 @@ void CopyEncode (const type* Source, type* Target)
 
 
 
-type UnqualifiedType (type T)
-/* Return the unqalified type */
-{
-    return (T & ~T_MASK_QUAL);
-}
-
-
-
 unsigned SizeOf (const type* T)
 /* Compute size of object represented by type array. */
 {
     SymEntry* Entry;
+    long      ElementCount;
 
     switch (UnqualifiedType (T[0])) {
 
@@ -442,38 +438,50 @@ unsigned SizeOf (const type* T)
 
 	case T_SCHAR:
 	case T_UCHAR:
-	    return 1;
+	    return SIZEOF_CHAR;
 
        	case T_SHORT:
     	case T_USHORT:
+            return SIZEOF_SHORT;
+
     	case T_INT:
 	case T_UINT:
+            return SIZEOF_INT;
+
 	case T_PTR:
 	case T_FUNC:	/* Maybe pointer to function */
-	    return 2;
+	    return SIZEOF_PTR;
 
         case T_LONG:
     	case T_ULONG:
-	    return 4;
+	    return SIZEOF_LONG;
 
 	case T_LONGLONG:
 	case T_ULONGLONG:
-	    return 8;
+	    return SIZEOF_LONGLONG;
 
         case T_ENUM:
-	    return 2;
+	    return SIZEOF_INT;
 
 	case T_FLOAT:
+            return SIZEOF_FLOAT;
+
 	case T_DOUBLE:
-	    return 4;
+	    return SIZEOF_DOUBLE;
 
 	case T_STRUCT:
 	case T_UNION:
-       	    Entry = (SymEntry*) DecodePtr (T+1);
+       	    Entry = DecodePtr (T+1);
        	    return Entry->V.S.Size;
 
 	case T_ARRAY:
-	    return (Decode (T+ 1) * SizeOf (T + DECODE_SIZE + 1));
+            ElementCount = GetElementCount (T);
+            if (ElementCount < 0) {
+                /* Array with unspecified size */
+                return 0;
+            } else {
+	        return ElementCount * SizeOf (T + DECODE_SIZE + 1);
+            }
 
     	default:
 	    Internal ("Unknown type in SizeOf: %04X", *T);
@@ -509,7 +517,7 @@ unsigned CheckedSizeOf (const type* T)
     unsigned Size = SizeOf (T);
     if (Size == 0) {
         Error ("Size of data type is unknown");
-        Size = 1;
+        Size = SIZEOF_CHAR;     /* Don't return zero */
     }
     return Size;
 }
@@ -525,7 +533,7 @@ unsigned CheckedPSizeOf (const type* T)
     unsigned Size = PSizeOf (T);
     if (Size == 0) {
         Error ("Size of data type is unknown");
-        Size = 1;
+        Size = SIZEOF_CHAR;     /* Don't return zero */
     }
     return Size;
 }
@@ -563,7 +571,7 @@ unsigned TypeOf (const type* T)
        	    return CF_LONG | CF_UNSIGNED;
 
         case T_FUNC:
-	    F = (FuncDesc*) DecodePtr (T+1);
+	    F = DecodePtr (T+1);
 	    return (F->Flags & FD_VARIADIC)? 0 : CF_FIXARGC;
 
         case T_STRUCT:
@@ -597,6 +605,18 @@ type* Indirect (type* T)
 
 
 
+type* ArrayToPtr (const type* T)
+/* Convert an array to a pointer to it's first element */
+{
+    /* Function must only be called for an array */
+    CHECK ((T[0] & T_MASK_TYPE) == T_TYPE_ARRAY);
+
+    /* Return pointer to first element */
+    return PointerTo (T + DECODE_SIZE + 1);
+}
+
+
+
 int IsClassInt (const type* T)
 /* Return true if this is an integer type */
 {
@@ -675,42 +695,6 @@ int IsVariadicFunc (const type* T)
 
 
 
-type GetType (const type* T)
-/* Get the raw type */
-{
-    PRECONDITION (T[0] != T_END);
-    return (T[0] & T_MASK_TYPE);
-}
-
-
-
-type GetClass (const type* T)
-/* Get the class of a type string */
-{
-    PRECONDITION (T[0] != T_END);
-    return (T[0] & T_MASK_CLASS);
-}
-
-
-
-type GetSignedness (const type* T)
-/* Get the sign of a type */
-{
-    PRECONDITION (T[0] != T_END);
-    return (T[0] & T_MASK_SIGN);
-}
-
-
-
-type GetSizeModifier (const type* T)
-/* Get the size modifier of a type */
-{
-    PRECONDITION (T[0] != T_END);
-    return (T[0] & T_MASK_SIZE);
-}
-
-
-
 type GetQualifier (const type* T)
 /* Get the qualifier from the given type string */
 {
@@ -737,7 +721,7 @@ FuncDesc* GetFuncDesc (const type* T)
     CHECK (T[0] == T_FUNC);
 
     /* Decode the function descriptor and return it */
-    return (FuncDesc*) DecodePtr (T+1);
+    return DecodePtr (T+1);
 }
 
 
@@ -760,3 +744,23 @@ type* GetFuncReturn (type* T)
 
 
 
+long GetElementCount (const type* T)
+/* Get the element count of the array specified in T (which must be of
+ * array type).
+ */
+{
+    CHECK (IsTypeArray (T));
+    return (unsigned) Decode (T+1);
+}
+
+
+
+type* GetElementType (type* T)
+/* Return the element type of the given array type. */
+{
+    CHECK (IsTypeArray (T));
+    return T + DECODE_SIZE + 1;
+}
+
+
+