Enable i18n in Bison.

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

diff --git a/src/parse-decl.c b/src/parse-decl.c
index c210f7cce52981d96d41bfd2eb9511a63955a49f..dc187c00b00c440eb5b059781b376f4e3ffdf712 100644 (file)
--- a/src/parse-decl.c
+++ b/src/parse-decl.c
@@ -23,6 +23,19 @@
 #include "typemap.h"
 #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;
+}
 
 /*
  * Verify the declaration specifiers of a declaration.  If top is true, treat
@@ -33,12 +46,13 @@ 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);
        unsigned num_storage = 0;
        unsigned long typemap;
 
        typemap = cdecl__build_typemap(specs);
        if (typemap == -1)
-               return -1;
+               return false;
 
        for (struct cdecl_declspec *c = specs; c; c = c->next) {
                switch (cdecl_spec_kind(c)) {
@@ -51,6 +65,11 @@ static bool valid_declspecs(struct cdecl *decl, bool top)
                        }
                        continue;
                case CDECL_SPEC_STOR:
+                       if (top && abstract) {
+                               fprintf(stderr, "type names cannot have storage-class specifiers\n");
+                               return false;
+                       }
+
                        if (!top && c->type != CDECL_STOR_REGISTER) {
                                fprintf(stderr, "function parameters may only have register storage\n");
                                return false;
@@ -72,6 +91,11 @@ static bool valid_declspecs(struct cdecl *decl, bool top)
                        }
                        break;
                case CDECL_SPEC_FUNC:
+                       if (abstract) {
+                               fprintf(stderr, "type names cannot have function specifiers\n");
+                               return false;
+                       }
+
                        if (!top || d->type != CDECL_DECL_FUNCTION) {
                                fprintf(stderr, "only function declarations may have function specifiers.\n");
                                return false;
@@ -251,6 +275,10 @@ reduce_parentheses(struct cdecl_declarator **p, struct cdecl_declarator *d)
        return 0;
 }
 
+/*
+ * Function parameters and return types have a few restrictions that are
+ * really easy to check in comparison to the above absurdity.
+ */
 static int
 check_parameters(struct cdecl_declarator **p, struct cdecl_declarator *d)
 {
@@ -283,6 +311,43 @@ check_parameters(struct cdecl_declarator **p, struct cdecl_declarator *d)
        return 0;
 }
 
+/*
+ * Functions cannot return arrays or functions.  Since the parse tree is
+ * "inside-out", we need to look for functions as the child declarator.
+ */
+static int
+check_rettypes(struct cdecl_declarator **p, struct cdecl_declarator *d)
+{
+       if (!d->child || d->child->type != CDECL_DECL_FUNCTION)
+               return 0;
+
+       switch (d->type) {
+       case CDECL_DECL_FUNCTION:
+               fprintf(stderr, "functions cannot return functions\n");
+               return -1;
+       case CDECL_DECL_ARRAY:
+               fprintf(stderr, "functions cannot return arrays\n");
+               return -1;
+       }
+
+       return 0;
+}
+
+static int
+check_arrays(struct cdecl_declarator **p, struct cdecl_declarator *d)
+{
+       if (!d->child || d->child->type != CDECL_DECL_ARRAY)
+               return 0;
+
+       switch (d->type) {
+       case CDECL_DECL_FUNCTION:
+               fprintf(stderr, "array members cannot be functions\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
@@ -323,12 +388,20 @@ static bool forall_declarators(struct cdecl *decl,
 struct cdecl *cdecl_parse_decl(const char *declstr)
 {
        YY_BUFFER_STATE state;
+       yyscan_t scanner;
        struct cdecl *decl;
        int rc;
 
-       state = yy_scan_string(declstr);
-       rc = yyparse(&decl);
-       yy_delete_buffer(state);
+       cdecl__init_i18n();
+
+       rc = cdecl__yylex_init(&scanner);
+       if (rc != 0)
+               return NULL;
+
+       state = cdecl__yy_scan_string(declstr, scanner);
+       rc = cdecl__yyparse(scanner, &decl);
+       cdecl__yy_delete_buffer(state, scanner);
+       cdecl__yylex_destroy(scanner);
 
        if (rc != 0)
                return NULL;
@@ -340,6 +413,54 @@ struct cdecl *cdecl_parse_decl(const char *declstr)
                        goto err;
                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 (!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");
+                       goto err;
+               }
+       }
+
+       return decl;
+err:
+       cdecl_free(decl);
+       return NULL;
+}
+
+struct cdecl *cdecl_parse_english(const char *english)
+{
+       YY_BUFFER_STATE state;
+       yyscan_t scanner;
+       struct cdecl *decl;
+       int rc;
+
+       cdecl__init_i18n();
+
+       rc = cdecl__yylex_init_extra(true, &scanner);
+       if (rc != 0)
+               return NULL;
+
+       state = cdecl__yy_scan_string(english, scanner);
+       rc = cdecl__yyparse(scanner, &decl);
+       cdecl__yy_delete_buffer(state, scanner);
+       cdecl__yylex_destroy(scanner);
+
+       if (rc != 0)
+               return NULL;
+
+       for (struct cdecl *i = decl; i; i = i->next) {
+               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 (!valid_declspecs(i, true))
                        goto err;