X-Git-Url: https://git.draconx.ca/gitweb/cdecl99.git/blobdiff_plain/31ac11cc668bb8ecc1317fd2e8bd79b7925bceeb..ad973d63e038f293f2b158f19b04c1582e616af0:/src/parse-decl.c

diff --git a/src/parse-decl.c b/src/parse-decl.c
index 42931a3..f00442d 100644
--- a/src/parse-decl.c
+++ b/src/parse-decl.c
@@ -1,42 +1,85 @@
 /*
- *  Parse and validate C declarations.
- *  Copyright © 2011 Nick Bowler
+ * Parse and validate C declarations.
+ * Copyright © 2011-2012, 2020-2021 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
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ * 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
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
  *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
- *  You should have received a copy of the GNU General Public License
- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
+
 #include <config.h>
 #include <stdio.h>
 #include <assert.h>
 #include <stdbool.h>
 
 #include "cdecl.h"
-#include "typemap.h"
+#include "cdecl-internal.h"
 #include "parse.h"
 #include "scan.h"
-#include "i18n.h"
-#include "normalize.h"
 
 /*
- * Determine if a declarator declares an identifier (other than a function
- * parameter).
+ * We can represent type specifiers as a bitmap, which gives us a finite
+ * list of acceptable bitmap values according to the C standard.  However,
+ * the "long" specifier is allowed to occur more than once, but only at most
+ * 2 times.  Treat it as a special case, assigning an unused bit to represent
+ * the second long.
  */
-static bool is_abstract(struct cdecl_declarator *d)
+#define MAP_LLONG_BIT 31
+#define MAP_LONG_BIT (CDECL_TYPE_LONG-CDECL_SPEC_TYPE)
+#define CDECL_TYPE_LLONG (CDECL_SPEC_TYPE+MAP_LLONG_BIT)
+
+#include "typemap.h"
+
+/*
+ * Convert the declaration specifiers to a bitmap with each bit
+ * corresponding to one specific type specifier.
+ */
+static int valid_typespec(struct cdecl_declspec *s)
 {
-	while (d->child)
-		d = d->child;
+	unsigned long map = 0;
+
+	for (struct cdecl_declspec *c = s; c; c = c->next) {
+		unsigned long bit;
+
+		if (cdecl_spec_kind(c) != CDECL_SPEC_TYPE)
+			continue;
+
+		bit = c->type - CDECL_SPEC_TYPE;
+		assert(bit < MAP_LLONG_BIT);
+		bit = 1ul << bit;
 
-	return d->type != CDECL_DECL_IDENT;
+		/* "long" special case */
+		if ((map & bit) == 1ul << MAP_LONG_BIT)
+			bit = 1ul << MAP_LLONG_BIT;
+
+		if (map & bit) {
+			if (bit == 1ul << MAP_LLONG_BIT)
+				cdecl__err(CDECL_EBADTYPE, _("too many long specifiers"));
+			else
+				cdecl__err(CDECL_EBADTYPE, _("duplicate type specifier"));
+			return false;
+		}
+		map |= bit;
+	}
+
+	if (typemap_is_valid(map))
+		return true;
+
+	if (map == 0)
+		cdecl__err(CDECL_EBADTYPE, _("no type specified"));
+	else
+		cdecl__err(CDECL_EBADTYPE, _("invalid type specified"));
+
+	return false;
 }
 
 /*
@@ -48,12 +91,10 @@ 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;
 
-	typemap = cdecl__build_typemap(specs);
-	if (typemap == -1)
+	if (!valid_typespec(specs))
 		return false;
 
 	for (struct cdecl_declspec *c = specs; c; c = c->next) {
@@ -62,23 +103,23 @@ static bool valid_declspecs(struct cdecl *decl, bool top)
 			if (c->type == CDECL_TYPE_VOID &&
 			    (d->type == CDECL_DECL_IDENT
 		             || d->type == CDECL_DECL_ARRAY)) {
-				fprintf(stderr, "invalid declaration of type void\n");
+				cdecl__err(CDECL_EBADTYPE, _("invalid declaration of type void"));
 				return false;
 			}
 			continue;
 		case CDECL_SPEC_STOR:
 			if (top && abstract) {
-				fprintf(stderr, "type names cannot have storage-class specifiers\n");
+				cdecl__err(CDECL_EBADSTOR, _("type names cannot have storage-class specifiers"));
 				return false;
 			}
 
 			if (!top && c->type != CDECL_STOR_REGISTER) {
-				fprintf(stderr, "function parameters may only have register storage\n");
+				cdecl__err(CDECL_EBADSTOR, _("function parameters may only have register storage"));
 				return false;
 			}
 
 			if (++num_storage > 1) {
-				fprintf(stderr, "too many storage-class specifiers\n");
+				cdecl__err(CDECL_EBADSTOR, _("too many storage-class specifiers"));
 				return false;
 			}
 			break;
@@ -88,18 +129,18 @@ static bool valid_declspecs(struct cdecl *decl, bool top)
 			 * pointer qualifier list, which isn't checked here.
 			 */
 			if (c->type == CDECL_QUAL_RESTRICT) {
-				fprintf(stderr, "only pointer types can be restrict-qualified.\n");
+				cdecl__err(CDECL_EBADQUAL, _("only pointer types can be restrict-qualified"));
 				return false;
 			}
 			break;
 		case CDECL_SPEC_FUNC:
 			if (abstract) {
-				fprintf(stderr, "type names cannot have function specifiers\n");
+				cdecl__err(CDECL_ENOTFUNC, _("type names cannot have function specifiers"));
 				return false;
 			}
 
 			if (!top || d->type != CDECL_DECL_FUNCTION) {
-				fprintf(stderr, "only function declarations may have function specifiers.\n");
+				cdecl__err(CDECL_ENOTFUNC, _("only function declarations can have function specifiers"));
 				return false;
 			}
 			break;
@@ -128,12 +169,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.
@@ -177,6 +212,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;
 }
@@ -243,7 +280,7 @@ reduce_parentheses(struct cdecl_declarator **p, struct cdecl_declarator *d)
 		}
 
 		if (d->child->type != CDECL_DECL_NULL) {
-			fprintf(stderr, "invalid function parameter\n");
+			cdecl__err(CDECL_EBADPARAMS, _("invalid function parameter"));
 			return -1;
 		}
 
@@ -267,7 +304,7 @@ reduce_parentheses(struct cdecl_declarator **p, struct cdecl_declarator *d)
 		if (decl->type == CDECL_DECL_FUNCTION
 		    && decl->child->type == CDECL_DECL_NULL
 		    && !function_is_reducible(decl)) {
-			fprintf(stderr, "too many parentheses in function\n");
+			cdecl__err(CDECL_EBADPARAMS, _("too many parentheses in function"));
 			return -1;
 		}
 
@@ -286,7 +323,6 @@ check_parameters(struct cdecl_declarator **p, struct cdecl_declarator *d)
 {
 	struct cdecl_declspec *spec;
 	struct cdecl *param;
-	bool has_void = false;
 
 	if (d->type != CDECL_DECL_FUNCTION)
 		return 0;
@@ -295,21 +331,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) {
+				cdecl__err(CDECL_EVOIDPARAM, _("void parameter cannot have extra specifiers"));
+				return -1;
+			} else if (d->u.function.parameters->next) {
+				cdecl__err(CDECL_EVOIDPARAM, _("void parameter must stand alone"));
+				return -1;
+			} else if (d->u.function.variadic) {
+				cdecl__err(CDECL_EVOIDPARAM, _("variadic function cannot have void parameter"));
+				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;
 }
 
@@ -325,10 +366,10 @@ check_rettypes(struct cdecl_declarator **p, struct cdecl_declarator *d)
 
 	switch (d->type) {
 	case CDECL_DECL_FUNCTION:
-		fprintf(stderr, "functions cannot return functions\n");
+		cdecl__err(CDECL_EBADRETURN, _("functions cannot return functions"));
 		return -1;
 	case CDECL_DECL_ARRAY:
-		fprintf(stderr, "functions cannot return arrays\n");
+		cdecl__err(CDECL_EBADRETURN, _("functions cannot return arrays"));
 		return -1;
 	}
 
@@ -343,7 +384,7 @@ check_arrays(struct cdecl_declarator **p, struct cdecl_declarator *d)
 
 	switch (d->type) {
 	case CDECL_DECL_FUNCTION:
-		fprintf(stderr, "array members cannot be functions\n");
+		cdecl__err(CDECL_EBADARRAY, _("array members cannot be functions"));
 		return -1;
 	}
 
@@ -371,6 +412,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) {
+			cdecl__err(CDECL_EBADPOINTER, _("function pointers cannot be restrict-qualified"));
+			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
@@ -436,10 +498,12 @@ struct cdecl *cdecl_parse_decl(const char *declstr)
 	 * new specifier list.
 	 */
 	norm_specs = cdecl__normalize_specs(decl->specifiers);
-
 	for (struct cdecl *i = decl; i; i = i->next) {
 		i->specifiers = norm_specs;
+	}
 
+	/* Now perform checks and simplifications on each declarator. */
+	for (struct cdecl *i = decl; i; i = i->next) {
 		if (!forall_declarators(i, reduce_parentheses))
 			goto err;
 		if (!forall_declarators(i, simplify_functions))
@@ -452,12 +516,15 @@ 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;
 
-		if (is_abstract(i->declarators) && (i != decl || i->next)) {
-			fprintf(stderr, "mixing type names and declarations is not allowed\n");
+		if (cdecl_is_abstract(i->declarators)
+		    && (i != decl || i->next)) {
+			cdecl__err(CDECL_EBADDECL, _("mixing type names and declarations is not allowed"));
 			goto err;
 		}
 	}
@@ -500,6 +567,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;