X-Git-Url: https://git.draconx.ca/gitweb/cdecl99.git/blobdiff_plain/41c2e3966f76d174d28d016aa5dba44f2ac8eb53..0876ef2649dfc1d1c1fe86a0d56e9506806b37b9:/src/parse-decl.c diff --git a/src/parse-decl.c b/src/parse-decl.c index bedd30e..dc187c0 100644 --- a/src/parse-decl.c +++ b/src/parse-decl.c @@ -23,20 +23,36 @@ #include "typemap.h" #include "parse.h" #include "scan.h" +#include "i18n.h" /* - * Verify the declaration specifiers of a declaration. + * Determine if a declarator declares an identifier (other than a function + * parameter). */ -static bool valid_declspecs(struct cdecl *decl) +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 + * this as a top-level declaration. Otherwise, treat this as a function + * parameter (which carries additional constraints). + */ +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)) { @@ -49,6 +65,16 @@ static bool valid_declspecs(struct cdecl *decl) } 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; + } + if (++num_storage > 1) { fprintf(stderr, "too many storage-class specifiers\n"); return false; @@ -65,11 +91,16 @@ static bool valid_declspecs(struct cdecl *decl) } break; case CDECL_SPEC_FUNC: - /* - * We don't support functions yet. - */ - fprintf(stderr, "only function declarations may have function specifiers.\n"); - return false; + 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; + } + break; default: assert(0); } @@ -244,6 +275,79 @@ 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) +{ + struct cdecl_declspec *spec; + struct cdecl *param; + bool has_void = false; + + if (d->type != CDECL_DECL_FUNCTION) + return 0; + + for (param = d->u.function.parameters; param; param = param->next) { + if (!valid_declspecs(param, false)) + return -1; + + for (spec = param->specifiers; spec; spec = spec->next) { + if (spec->type == CDECL_TYPE_VOID + && param->declarators->type == CDECL_DECL_NULL) + has_void = true; + } + } + + 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; +} + +/* + * 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 @@ -284,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; @@ -299,8 +411,58 @@ struct cdecl *cdecl_parse_decl(const char *declstr) goto err; if (!forall_declarators(i, simplify_functions)) 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)) + if (!valid_declspecs(i, true)) goto err; }