X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Fcc65%2Fdatatype.c;h=4da5470b98b8e84c20ad2860e49a6d5b0aa3b01c;hb=8cd7b15c8b3546af94ba8dabe3bdd5d5c65246a2;hp=6e0ac1d8549c007d25222777dce7b94f416a6088;hpb=544705e6f456abaef98462d78325b4d1907bc6b0;p=cc65

diff --git a/src/cc65/datatype.c b/src/cc65/datatype.c
index 6e0ac1d85..4da5470b9 100644
--- a/src/cc65/datatype.c
+++ b/src/cc65/datatype.c
@@ -173,7 +173,7 @@ type* GetImplicitFuncType (void)
     type* T = TypeAlloc (1 + DECODE_SIZE + 2);
 
     /* Prepare the function descriptor */
-    F->Flags  = FD_IMPLICIT | FD_EMPTY | FD_ELLIPSIS;
+    F->Flags  = FD_IMPLICIT | FD_EMPTY | FD_VARIADIC;
     F->SymTab = &EmptySymTab;
     F->TagTab = &EmptySymTab;
 
@@ -230,7 +230,7 @@ void PrintType (FILE* F, const type* Type)
 /* Output translation of type array. */
 {
     type T;
-
+    unsigned long Size;
 
     /* Walk over the complete string */
     while ((T = *Type++) != T_END) {
@@ -239,57 +239,67 @@ void PrintType (FILE* F, const type* Type)
     	T = PrintTypeComp (F, T, T_QUAL_CONST, "const");
 	T = PrintTypeComp (F, T, T_QUAL_VOLATILE, "volatile");
 
-    	/* Signedness */
-    	T = PrintTypeComp (F, T, T_SIGN_SIGNED, "signed");
+    	/* Signedness. Omit the signedness specifier for long and int */
+	if ((T & T_MASK_TYPE) != T_TYPE_INT && (T & T_MASK_TYPE) != T_TYPE_LONG) {
+	    T = PrintTypeComp (F, T, T_SIGN_SIGNED, "signed");
+	}
     	T = PrintTypeComp (F, T, T_SIGN_UNSIGNED, "unsigned");
 
     	/* Now check the real type */
      	switch (T & T_MASK_TYPE) {
     	    case T_TYPE_CHAR:
-    	  	fprintf (F, "char\n");
+    	  	fprintf (F, "char");
     	  	break;
 	    case T_TYPE_SHORT:
-		fprintf (F, "short\n");
+		fprintf (F, "short");
 		break;
     	    case T_TYPE_INT:
-    	  	fprintf (F, "int\n");
+    	  	fprintf (F, "int");
     	  	break;
 	    case T_TYPE_LONG:
-		fprintf (F, "long\n");
+		fprintf (F, "long");
 		break;
 	    case T_TYPE_LONGLONG:
-		fprintf (F, "long long\n");
+		fprintf (F, "long long");
 		break;
     	    case T_TYPE_FLOAT:
-    	     	fprintf (F, "float\n");
+    	     	fprintf (F, "float");
     	     	break;
     	    case T_TYPE_DOUBLE:
-    	     	fprintf (F, "double\n");
+    	     	fprintf (F, "double");
     	     	break;
      	    case T_TYPE_VOID:
-     	  	fprintf (F, "void\n");
+     	  	fprintf (F, "void");
     	  	break;
     	    case T_TYPE_STRUCT:
-    	     	fprintf (F, "struct %s\n", ((SymEntry*) DecodePtr (Type))->Name);
+    	     	fprintf (F, "struct %s", ((SymEntry*) DecodePtr (Type))->Name);
        	     	Type += DECODE_SIZE;
 	     	break;
 	    case T_TYPE_UNION:
-	     	fprintf (F, "union %s\n", ((SymEntry*) DecodePtr (Type))->Name);
+	     	fprintf (F, "union %s", ((SymEntry*) DecodePtr (Type))->Name);
 	     	Type += DECODE_SIZE;
 	     	break;
 	    case T_TYPE_ARRAY:
-       	       	fprintf (F, "array[%lu] of ", Decode (Type));
-	     	Type += DECODE_SIZE;
-	     	break;
+		/* Recursive call */
+		PrintType (F, Type + DECODE_SIZE);
+		Size = Decode (Type);
+		if (Size == 0) {
+		    fprintf (F, "[]");
+		} else {
+		    fprintf (F, "[%lu]", Size);
+		}
+	     	return;
 	    case T_TYPE_PTR:
-	     	fprintf (F, "pointer to ");
-	     	break;
+ 		/* Recursive call */
+		PrintType (F, Type);
+		fprintf (F, "*");
+	     	return;
 	    case T_TYPE_FUNC:
 	     	fprintf (F, "function returning ");
 	     	Type += DECODE_SIZE;
 	     	break;
 	    default:
-	     	fprintf (F, "unknown type: %04X\n", T);
+	     	fprintf (F, "unknown type: %04X", T);
 	}
 
     }
@@ -297,6 +307,40 @@ void PrintType (FILE* F, const type* Type)
 
 
 
+void PrintFuncSig (FILE* F, const char* Name, type* Type)
+/* Print a function signature. */
+{
+    /* Get the function descriptor */
+    const FuncDesc* D = GetFuncDesc (Type);
+
+    /* Print a comment with the function signature */
+    PrintType (F, GetFuncReturn (Type));
+    if (D->Flags & FD_FASTCALL) {
+     	fprintf (F, " __fastcall__");
+    }
+    fprintf (F, " %s (", Name);
+
+    /* Parameters */
+    if (D->Flags & FD_VOID_PARAM) {
+ 	fprintf (F, "void");
+    } else {
+ 	unsigned I;
+ 	SymEntry* E = D->SymTab->SymHead;
+ 	for (I = 0; I < D->ParamCount; ++I) {
+ 	    if (I > 0) {
+ 		fprintf (F, ", ");
+ 	    }
+ 	    PrintType (F, E->Type);
+ 	    E = E->NextSym;
+ 	}
+    }
+
+    /* End of parameter list */
+    fprintf (F, ")");
+}
+
+
+
 void PrintRawType (FILE* F, const type* Type)
 /* Print a type string in raw format (for debugging) */
 {
@@ -476,7 +520,7 @@ unsigned TypeOf (const type* T)
 
         case T_FUNC:
 	    F = (FuncDesc*) DecodePtr (T+1);
-	    return (F->Flags & FD_ELLIPSIS)? 0 : CF_FIXARGC;
+	    return (F->Flags & FD_VARIADIC)? 0 : CF_FIXARGC;
 
         case T_STRUCT:
         case T_UNION:
@@ -654,7 +698,7 @@ int IsVariadicFunc (const type* T)
     FuncDesc* F;
     CHECK (IsTypeFunc (T));
     F = (FuncDesc*) DecodePtr (T+1);
-    return (F->Flags & FD_ELLIPSIS) != 0;
+    return (F->Flags & FD_VARIADIC) != 0;
 }
 
 
@@ -734,4 +778,21 @@ FuncDesc* GetFuncDesc (const type* T)
 
 
 
+type* GetFuncReturn (type* T)
+/* Return a pointer to the return type of a function or pointer-to-function type */
+{
+    if (T[0] == T_PTR) {
+	/* Pointer to function */
+	++T;
+    }
+
+    /* Be sure it's a function type */
+    CHECK (T[0] == T_FUNC);
+
+    /* Return a pointer to the return type */
+    return T + 1 + DECODE_SIZE;
+
+}
+
+