Merge pull request #2216 from acqn/FuncDefFix

[cc65] Type category in a function definition cannot be inherited from a typedef

src/cc65/compile.c

@@ -65,6 +65,7 @@
 #include "preproc.h"
 #include "standard.h"
 #include "staticassert.h"
+#include "typecmp.h"
 #include "symtab.h"
 
 
@@ -325,17 +326,24 @@ static void Parse (void)
         if (Sym && IsTypeFunc (Sym->Type)) {
 
             /* Function */
-            if (!comma) {
-                if (CurTok.Tok == TOK_SEMI) {
-                    /* Prototype only */
-                    NextToken ();
-                } else if (CurTok.Tok == TOK_LCURLY) {
-                    /* Parse the function body */
-                    NewFunc (Sym, FuncDef);
-
-                    /* Make sure we aren't omitting any work */
-                    CheckDeferredOpAllDone ();
+            if (CurTok.Tok == TOK_SEMI) {
+                /* Prototype only */
+                NextToken ();
+            } else if (CurTok.Tok == TOK_LCURLY) {
+                /* ISO C: The type category in a function definition cannot be
+                ** inherited from a typedef.
+                */
+                if (IsTypeFunc (Spec.Type) && TypeCmp (Sym->Type, Spec.Type).C >= TC_EQUAL) {
+                    Error ("Function cannot be defined with a typedef");
+                } else if (comma) {
+                    Error ("';' expected after top level declarator");
                 }
+
+                /* Parse the function body anyways */
+                NewFunc (Sym, FuncDef);
+
+                /* Make sure we aren't omitting any work */
+                CheckDeferredOpAllDone ();
             }
 
         } else {

test/err/bug2020-definition.c

@@ -0,0 +1,6 @@
+/* Bug #2020 - ISO/IEC 9899:1999 (E), 6.9.1 footnote 137:
+** "The intent is that the type category in a function definition cannot be inherited from a typedef"
+ */
+
+typedef void F(void);
+F c { }                 /* Should fail */

test/val/bug2020-ok.c

@@ -0,0 +1,16 @@
+/* Bug #2020 - Right cases */
+
+typedef int F(void);          // type F is "function with no parameters returning int"
+
+F f, g;                       // f and g both have type compatible with F
+int f(void) { return 0; }     // RIGHT: f has type compatible with F
+int g() { return 0; }         // RIGHT: g has type compatible with F
+F *e(void) { return 0; }      // e returns a pointer to a function
+F *((h))(void) { return 0; }  // similar: parentheses irrelevant
+int (*fp)(void);              // fp points to a function that has type F
+F *Fp;                        // Fp points to a function that has type
+
+int main(void)
+{
+    return 0;
+}