Fix parsing of int (x*).

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

diff --git a/src/parse-decl.c b/src/parse-decl.c
index 5c8e6845afad1777f3f97f8e5876387fa19ae2dd..e96efb7073362ba47eda7e8c6341362cc1246980 100644 (file)
--- a/src/parse-decl.c
+++ b/src/parse-decl.c
@@ -1,6 +1,6 @@
 /*
  *  Parse and validate C declarations.
- *  Copyright © 2011 Nick Bowler
+ *  Copyright © 2011-2012, 2020 Nick Bowler
  *
  *  This program is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -116,12 +116,6 @@ static bool valid_declspecs(struct cdecl *decl, bool top)
  * if a declarator could be interpreted as something other than a function,
  * do that.
  *
- *   - The function declarator has a null child declarator.
- *   - The function declarator has exactly one parameter, and is not variadic.
- *   - The function parameter has a type specifier, and it is a typedef name.
- *   - The function parameter has no other declaration specifiers.
- *   - The function parameter does not declare an identifier.
- *
  * Since cdecl99 supports things like [*] in any context (in C, such constructs
  * are only valid in function parameter lists), we don't treat them specially
  * here.
@@ -165,6 +159,8 @@ static bool function_is_reducible(struct cdecl_declarator *d)
                return false; /* e.g. int (int) */
        if (d->u.function.parameters->specifiers->next)
                return false; /* e.g. int (size_t const) */
+       if (d->u.function.parameters->declarators->type == CDECL_DECL_POINTER)
+               return false; /* e.g. int (x *) */
 
        return true;
 }
@@ -283,21 +279,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;
 }
 
@@ -359,6 +360,27 @@ normalize_specs(struct cdecl_declarator **p, struct cdecl_declarator *d)
        return 0;
 }
 
+static int
+check_qualifiers(struct cdecl_declarator **p, struct cdecl_declarator *d)
+{
+       struct cdecl_declspec *spec;
+       struct cdecl_pointer *ptr;
+
+       if (!d->child || d->child->type != CDECL_DECL_POINTER)
+               return 0;
+
+       ptr = &d->child->u.pointer;
+       for (spec = ptr->qualifiers; spec; spec = spec->next) {
+               if (spec->type == CDECL_QUAL_RESTRICT
+                   && d->type == CDECL_DECL_FUNCTION) {
+                       fprintf(stderr, "function pointers cannot be restrict-qualified\n");
+                       return -1;
+               }
+       }
+
+       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
@@ -440,6 +462,8 @@ struct cdecl *cdecl_parse_decl(const char *declstr)
                        goto err;
                if (!forall_declarators(i, normalize_specs))
                        goto err;
+               if (!forall_declarators(i, check_qualifiers))
+                       goto err;
 
                if (!valid_declspecs(i, true))
                        goto err;
@@ -489,6 +513,8 @@ struct cdecl *cdecl_parse_english(const char *english)
                        goto err;
                if (!forall_declarators(i, normalize_specs))
                        goto err;
+               if (!forall_declarators(i, check_qualifiers))
+                       goto err;
 
                if (!valid_declspecs(i, true))
                        goto err;