X-Git-Url: https://git.draconx.ca/gitweb/cdecl99.git/blobdiff_plain/8b46a260a9af1e1cd07ae51924022724f73aa830..1402a14592dde378698373044afbcef9c38ec2c2:/src/explain.c diff --git a/src/explain.c b/src/explain.c index c6c7e9c..722e721 100644 --- a/src/explain.c +++ b/src/explain.c @@ -1,224 +1,154 @@ -#include -#include -#include -#include "cdecl.h" -#include "typemap.h" +/* + * Render C declarations as English. + * Copyright © 2011, 2021, 2023-2024 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 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 . + */ + +#include +#include -/* declare [ident] as [storage] [function specs] [other crap] [qualifiers] [type specs] */ +#include "cdecl.h" +#include "cdecl-internal.h" -static size_t -voutput(char *buf, size_t n, size_t off, const char *fmt, va_list ap) -{ - if (off >= n) - return vsnprintf(NULL, 0, fmt, ap); - return vsnprintf(buf+off, n-off, fmt, ap); -} +#define PRE_SPECS (CDECL_SPEC_FUNC|CDECL_SPEC_STOR) +#define POST_SPECS (CDECL_SPEC_QUAL|CDECL_SPEC_TYPE) -static size_t output(char *buf, size_t n, size_t off, const char *fmt, ...) +static void explain_specs(struct output_state *dst, struct cdecl_declspec *s, unsigned mask) { - va_list ap; - size_t ret; - - va_start(ap, fmt); - ret = voutput(buf, n, off, fmt, ap); - va_end(ap); - - return ret; + cdecl__emit(dst, cdecl__emit_specs(dst, s, mask)); } -static size_t advance(char **buf, size_t *n, size_t amount) +/* + * If declarator declares an identifier foo, then emit "foo as "; otherwise + * emit nothing. + */ +static void +explain_name(struct output_state *dst, struct cdecl_declarator *d) { - if (!amount) - return 0; + while (d->child) + d = d->child; - if (amount >= *n) { - *n = 0; - *buf = 0; - } else { - (*buf)[amount] = ' '; - if (amount + 1 >= *n) { - *buf = 0; - *n = 0; - } else { - *buf += amount + 1; - *n -= amount + 1; - } + if (d->type == CDECL_DECL_IDENT) { + cdecl__emit(dst, d->u.ident); + cdecl__emit(dst, " as "); } - - return amount + 1; } -static size_t -explain_qualifiers(char *buf, size_t n, struct cdecl_declspec *s) +/* + * For a pointer declarator, emit "[QUAL ]pointer to ", where + * QUAL is the (possibly empty) list of qualifiers. + */ +static void +explain_pointer(struct output_state *dst, struct cdecl_pointer *p) { - unsigned long qualmap = 0; - size_t ret = 0, rc = 0; - - for (struct cdecl_declspec *c = s; c; c = c->next) { - if (cdecl_spec_kind(c) != CDECL_SPEC_QUAL) - continue; - qualmap |= 1ul << (c->type & 0xff); - } - - if (qualmap & (1ul << (CDECL_QUAL_RESTRICT & 0xff))) { - ret += advance(&buf, &n, rc); - rc = snprintf(buf, n, "restrict"); - } - if (qualmap & (1ul << (CDECL_QUAL_VOLATILE & 0xff))) { - ret += advance(&buf, &n, rc); - rc = snprintf(buf, n, "volatile"); - } - if (qualmap & (1ul << (CDECL_QUAL_CONST & 0xff))) { - ret += advance(&buf, &n, rc); - rc = snprintf(buf, n, "const"); - } - - return ret + rc; + explain_specs(dst, p->qualifiers, -1); + cdecl__emit(dst, "pointer to "); } -/* Renders the type qualifiers and type specifiers in canonical form. */ -static size_t -explain_post_specs(char *buf, size_t n, struct cdecl_declspec *s) +/* + * For an array declarator, emit "[variable-length ]array [X ]of ", where + * for a variable-length array X is the (possibly omitted) identifier name, + * and for normal arrays X is the (possibly omitted) length. + */ +static void +explain_array(struct output_state *dst, struct cdecl_array *a) { - const char *tag = NULL; - unsigned long typemap; - size_t ret = 0, rc; + size_t rc = 0; - typemap = cdecl__build_typemap(s); - if (typemap == -1) - return 0; + if (a->vla) + cdecl__emit(dst, "variable-length "); + cdecl__emit(dst, "array "); - for (struct cdecl_declspec *c = s; c; c = c->next) { - if (cdecl_spec_kind(c) != CDECL_SPEC_TYPE) - continue; - - /* Valid C types have at most one identifier. */ - if (c->ident) - tag = c->ident; - } - - rc = explain_qualifiers(buf, n, s); - ret += advance(&buf, &n, rc); - - rc = snprintf(buf, n, "%s", cdecl__explain_typemap(typemap)); - if (tag) { - ret += advance(&buf, &n, rc); - rc = snprintf(buf, n, "%s", tag); + if (a->vla) { + rc = cdecl__emit(dst, a->vla); + } else { + rc = cdecl__emit_uint(dst, a->length); } - return ret + rc; + cdecl__emit(dst, " of " + !rc); } -static const char *explain_storage(unsigned spec) -{ - switch (spec) { - case CDECL_STOR_TYPEDEF: - return "typedef"; - case CDECL_STOR_EXTERN: - return "extern"; - case CDECL_STOR_STATIC: - return "static"; - case CDECL_STOR_AUTO: - return "auto"; - case CDECL_STOR_REGISTER: - return "register"; - default: - abort(); - } -} +static void +explain_declarators(struct output_state *dst, struct cdecl_declarator *decl); -/* Renders the storage-class and function specifiers in canonical form. */ -static size_t explain_pre_specs(char *buf, size_t n, struct cdecl_declspec *s) +static void explain_decl(struct output_state *dst, struct cdecl *decl) { - unsigned long funcmap = 0; - const char *storage = NULL; - size_t ret = 0; - - for (struct cdecl_declspec *c = s; c; c = c->next) { - switch (cdecl_spec_kind(c)) { - case CDECL_SPEC_FUNC: - funcmap |= 1ul << (c->type & 0xff); - break; - case CDECL_SPEC_STOR: - /* Valid C declarations have at most one - * storage-class specifier. */ - storage = explain_storage(c->type); - break; - } - } - - if (storage) - ret += output(buf, n, ret, "%s", storage); - if (funcmap & (1ul << (CDECL_FUNC_INLINE & 0xff))) - ret += output(buf, n, ret, "%.*s%s", !!ret, "", "inline"); - return ret; + explain_name(dst, decl->declarators); + explain_specs(dst, decl->specifiers, PRE_SPECS); + explain_declarators(dst, decl->declarators); + cdecl__emit_specs(dst, decl->specifiers, POST_SPECS); } -static struct cdecl_declarator *next_declarator(struct cdecl_declarator *d) +/* + * For a function declarator, emit "function [PARAM ]returning ", where + * PARAM is the (omitted in the case of an empty non-prototype identifier + * list) parameter or identifier lists enclosed in parentheses. + */ +static void +explain_function(struct output_state *dst, struct cdecl_function *f) { - switch (d->type) { - case CDECL_DECL_IDENT: - return NULL; - case CDECL_DECL_POINTER: - return d->u.pointer.declarator; - default: - abort(); - } -} + cdecl__emit(dst, "function "); -/* Renders the name of the thing being declared. */ -static size_t -explain_prologue(char *buf, size_t n, struct cdecl_declarator *d) -{ - while (d) { - if (d->type == CDECL_DECL_IDENT) - return snprintf(buf, n, "declare %s as", d->u.ident); - d = next_declarator(d); - } -} + if (f->parameters) { + struct cdecl *p; -static size_t -explain_pointer(char *buf, size_t n, struct cdecl_pointer *p) -{ - size_t ret = 0, rc; + cdecl__emit(dst, "("); + + for (p = f->parameters; p; p = p->next) { + explain_decl(dst, p); + if (p->next) + cdecl__emit(dst, ", "); + } - rc = explain_qualifiers(buf, n, p->qualifiers); - ret += advance(&buf, &n, rc); + if (f->variadic) + cdecl__emit(dst, ", ...) "); + else + cdecl__emit(dst, ") "); + } - return ret + snprintf(buf, n, "pointer to"); + cdecl__emit(dst, "returning "); } -static size_t -explain_declarators(char *buf, size_t n, struct cdecl_declarator *d) +static void +explain_declarators(struct output_state *dst, struct cdecl_declarator *d) { - size_t ret = 0, rc; - - if (d->type == CDECL_DECL_IDENT) - return 0; - - rc = explain_declarators(buf, n, next_declarator(d)); - ret += advance(&buf, &n, rc); + if (d->child) + explain_declarators(dst, d->child); switch (d->type) { case CDECL_DECL_POINTER: - return ret + explain_pointer(buf, n, &d->u.pointer); - default: - abort(); + explain_pointer(dst, &d->u.pointer); + return; + case CDECL_DECL_ARRAY: + explain_array(dst, &d->u.array); + return; + case CDECL_DECL_FUNCTION: + explain_function(dst, &d->u.function); + return; } } size_t cdecl_explain(char *buf, size_t n, struct cdecl *decl) { - size_t ret = 0, rc; - - rc = explain_prologue(buf, n, decl->declarators); - ret += advance(&buf, &n, rc); - - rc = explain_pre_specs(buf, n, decl->specifiers); - ret += advance(&buf, &n, rc); + struct output_state dst = { buf, n }; - rc = explain_declarators(buf, n, decl->declarators); - ret += advance(&buf, &n, rc); + if (cdecl_is_abstract(decl->declarators)) + cdecl__emit(&dst, "type "); + else + cdecl__emit(&dst, "declare "); - return ret + explain_post_specs(buf, n, decl->specifiers); + explain_decl(&dst, decl); + return dst.accum; }