Add a check to reject extra specifiers on void function parameters.

[cdecl99.git] / src / parse-decl.c

diff --git a/src/parse-decl.c b/src/parse-decl.c
index dc187c00b00c440eb5b059781b376f4e3ffdf712..45cf67fcc5f7a8323a5624bd59a83a28d5cb94bb 100644 (file)
--- a/src/parse-decl.c
+++ b/src/parse-decl.c
@@ -15,6 +15,7 @@
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+#include <config.h>
 #include <stdio.h>
 #include <assert.h>
 #include <stdbool.h>
@@ -24,18 +25,7 @@
 #include "parse.h"
 #include "scan.h"
 #include "i18n.h"
-
-/*
- * Determine if a declarator declares an identifier (other than a function
- * parameter).
- */
-static bool is_abstract(struct cdecl_declarator *d)
-{
-       while (d->child)
-               d = d->child;
-
-       return d->type != CDECL_DECL_IDENT;
-}
+#include "normalize.h"
 
 /*
  * Verify the declaration specifiers of a declaration.  If top is true, treat
@@ -46,7 +36,7 @@ static bool valid_declspecs(struct cdecl *decl, bool top)
 {
        struct cdecl_declspec *specs = decl->specifiers;
        struct cdecl_declarator *d   = decl->declarators;
-       bool abstract = is_abstract(d);
+       bool abstract = cdecl_is_abstract(d);
        unsigned num_storage = 0;
        unsigned long typemap;
 
@@ -293,21 +283,26 @@ check_parameters(struct cdecl_declarator **p, struct cdecl_declarator *d)
                if (!valid_declspecs(param, false))
                        return -1;
 
+               /* Check for "void" function parameters as a special case. */
                for (spec = param->specifiers; spec; spec = spec->next) {
-                       if (spec->type == CDECL_TYPE_VOID
-                           && param->declarators->type == CDECL_DECL_NULL)
-                               has_void = true;
+                       if (param->declarators->type != CDECL_DECL_NULL)
+                               continue;
+                       if (spec->type != CDECL_TYPE_VOID)
+                               continue;
+
+                       if (spec != param->specifiers || spec->next != NULL) {
+                               fprintf(stderr, "void parameter must not have extra specifiers\n");
+                               return -1;
+                       } else if (d->u.function.parameters->next) {
+                               fprintf(stderr, "a void parameter must stand alone\n");
+                               return -1;
+                       } else if (d->u.function.variadic) {
+                               fprintf(stderr, "variadic functions cannot have a void parameter\n");
+                               return -1;
+                       }
                }
        }
 
-       if (has_void && d->u.function.parameters->next) {
-               fprintf(stderr, "a void parameter must stand alone\n");
-               return -1;
-       } else if (has_void && d->u.function.variadic) {
-               fprintf(stderr, "variadic functions cannot have a void parameter\n");
-               return -1;
-       }
-
        return 0;
 }
 
@@ -348,6 +343,27 @@ check_arrays(struct cdecl_declarator **p, struct cdecl_declarator *d)
        return 0;
 }
 
+static int
+normalize_specs(struct cdecl_declarator **p, struct cdecl_declarator *d)
+{
+       struct cdecl_function *func;
+       struct cdecl_pointer *ptr;
+
+       switch (d->type) {
+       case CDECL_DECL_POINTER:
+               ptr = &d->u.pointer;
+               ptr->qualifiers = cdecl__normalize_specs(ptr->qualifiers);
+               break;
+       case CDECL_DECL_FUNCTION:
+               func = &d->u.function;
+               for (struct cdecl *i = func->parameters; i; i = i->next)
+                       i->specifiers = cdecl__normalize_specs(i->specifiers);
+               break;
+       }
+
+       return 0;
+}
+
 /*
  * Traverse the parse tree, calling a function on every declarator in a
  * depth-first preorder traversal.  The function is given a pointer to the
@@ -387,6 +403,7 @@ static bool forall_declarators(struct cdecl *decl,
 
 struct cdecl *cdecl_parse_decl(const char *declstr)
 {
+       struct cdecl_declspec *norm_specs;
        YY_BUFFER_STATE state;
        yyscan_t scanner;
        struct cdecl *decl;
@@ -406,7 +423,16 @@ struct cdecl *cdecl_parse_decl(const char *declstr)
        if (rc != 0)
                return NULL;
 
+       /*
+        * Since the top-level specifiers are shared between each top-level
+        * declarator, we need to normalize them once and then propagate the
+        * new specifier list.
+        */
+       norm_specs = cdecl__normalize_specs(decl->specifiers);
+
        for (struct cdecl *i = decl; i; i = i->next) {
+               i->specifiers = norm_specs;
+
                if (!forall_declarators(i, reduce_parentheses))
                        goto err;
                if (!forall_declarators(i, simplify_functions))
@@ -417,11 +443,14 @@ struct cdecl *cdecl_parse_decl(const char *declstr)
                        goto err;
                if (!forall_declarators(i, check_arrays))
                        goto err;
+               if (!forall_declarators(i, normalize_specs))
+                       goto err;
 
                if (!valid_declspecs(i, true))
                        goto err;
 
-               if (is_abstract(i->declarators) && (i != decl || i->next)) {
+               if (cdecl_is_abstract(i->declarators)
+                   && (i != decl || i->next)) {
                        fprintf(stderr, "mixing type names and declarations is not allowed\n");
                        goto err;
                }
@@ -429,7 +458,7 @@ struct cdecl *cdecl_parse_decl(const char *declstr)
 
        return decl;
 err:
-       cdecl_free(decl);
+       cdecl__free(decl);
        return NULL;
 }
 
@@ -455,12 +484,16 @@ struct cdecl *cdecl_parse_english(const char *english)
                return NULL;
 
        for (struct cdecl *i = decl; i; i = i->next) {
+               i->specifiers = cdecl__normalize_specs(i->specifiers);
+
                if (!forall_declarators(i, check_parameters))
                        goto err;
                if (!forall_declarators(i, check_rettypes))
                        goto err;
                if (!forall_declarators(i, check_arrays))
                        goto err;
+               if (!forall_declarators(i, normalize_specs))
+                       goto err;
 
                if (!valid_declspecs(i, true))
                        goto err;
@@ -468,6 +501,11 @@ struct cdecl *cdecl_parse_english(const char *english)
 
        return decl;
 err:
-       cdecl_free(decl);
+       cdecl__free(decl);
        return NULL;
 }
+
+void cdecl_free(struct cdecl *decl)
+{
+       cdecl__free(decl);
+}