X-Git-Url: https://git.draconx.ca/gitweb/cdecl99.git/blobdiff_plain/056280bf2e3188551539d87852ddbdaf322eae52..1402a14592dde378698373044afbcef9c38ec2c2:/src/explain.c diff --git a/src/explain.c b/src/explain.c index 4deadac..722e721 100644 --- a/src/explain.c +++ b/src/explain.c @@ -1,6 +1,6 @@ /* * Render C declarations as English. - * Copyright © 2011, 2021, 2023 Nick Bowler + * 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 @@ -17,9 +17,7 @@ */ #include -#include #include -#include #include "cdecl.h" #include "cdecl-internal.h" @@ -27,53 +25,36 @@ #define PRE_SPECS (CDECL_SPEC_FUNC|CDECL_SPEC_STOR) #define POST_SPECS (CDECL_SPEC_QUAL|CDECL_SPEC_TYPE) -static size_t explain_specs(char **dst, size_t *dstlen, struct cdecl_declspec *s, unsigned mask) +static void explain_specs(struct output_state *dst, struct cdecl_declspec *s, unsigned mask) { - size_t rc; - - rc = cdecl__explain_specs(*dst, *dstlen, s, mask); - return cdecl__advance(dst, dstlen, rc); -} - -static size_t -explain_specs_post(char **dst, size_t *dstlen, struct cdecl_declspec *s) -{ - size_t rc; - - rc = cdecl__explain_specs(*dst, *dstlen, s, POST_SPECS); - return cdecl__advance_(dst, dstlen, rc); + cdecl__emit(dst, cdecl__emit_specs(dst, s, mask)); } /* * If declarator declares an identifier foo, then emit "foo as "; otherwise * emit nothing. */ -static size_t -explain_name(char **dst, size_t *dstlen, struct cdecl_declarator *d) +static void +explain_name(struct output_state *dst, struct cdecl_declarator *d) { - size_t ret; - while (d->child) d = d->child; - if (d->type != CDECL_DECL_IDENT) - return 0; - - ret = cdecl__emit(dst, dstlen, d->u.ident); - return ret + cdecl__emit(dst, dstlen, " as "); + if (d->type == CDECL_DECL_IDENT) { + cdecl__emit(dst, d->u.ident); + cdecl__emit(dst, " as "); + } } /* * For a pointer declarator, emit "[QUAL ]pointer to ", where * QUAL is the (possibly empty) list of qualifiers. */ -static size_t -explain_pointer(char **dst, size_t *dstlen, struct cdecl_pointer *p) +static void +explain_pointer(struct output_state *dst, struct cdecl_pointer *p) { - size_t ret; - - ret = explain_specs(dst, dstlen, p->qualifiers, -1); - return ret + cdecl__emit(dst, dstlen, "pointer to "); + explain_specs(dst, p->qualifiers, -1); + cdecl__emit(dst, "pointer to "); } /* @@ -81,39 +62,33 @@ explain_pointer(char **dst, size_t *dstlen, struct cdecl_pointer *p) * for a variable-length array X is the (possibly omitted) identifier name, * and for normal arrays X is the (possibly omitted) length. */ -static size_t -explain_array(char **dst, size_t *dstlen, struct cdecl_array *a) +static void +explain_array(struct output_state *dst, struct cdecl_array *a) { - size_t ret = 0, rc = 0; + size_t rc = 0; if (a->vla) - ret += cdecl__emit(dst, dstlen, "variable-length "); - ret += cdecl__emit(dst, dstlen, "array "); + cdecl__emit(dst, "variable-length "); + cdecl__emit(dst, "array "); if (a->vla) { - rc = cdecl__emit(dst, dstlen, a->vla); - ret += rc; + rc = cdecl__emit(dst, a->vla); } else { - rc = snprintf(*dst, *dstlen, "%.0" PRIuMAX, a->length); - ret += cdecl__advance_(dst, dstlen, rc); + rc = cdecl__emit_uint(dst, a->length); } - return ret + cdecl__emit(dst, dstlen, " of " + !rc); + cdecl__emit(dst, " of " + !rc); } -static size_t -explain_declarators(char **dst, size_t *dstlen, struct cdecl_declarator *decl); +static void +explain_declarators(struct output_state *dst, struct cdecl_declarator *decl); -static size_t explain_decl(char **dst, size_t *dstlen, struct cdecl *decl) +static void explain_decl(struct output_state *dst, struct cdecl *decl) { - size_t ret; - - ret = explain_name(dst, dstlen, decl->declarators); - ret += explain_specs(dst, dstlen, decl->specifiers, PRE_SPECS); - ret += explain_declarators(dst, dstlen, decl->declarators); - ret += explain_specs_post(dst, dstlen, decl->specifiers); - - 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); } /* @@ -121,63 +96,59 @@ static size_t explain_decl(char **dst, size_t *dstlen, struct cdecl *decl) * PARAM is the (omitted in the case of an empty non-prototype identifier * list) parameter or identifier lists enclosed in parentheses. */ -static size_t -explain_function(char **dst, size_t *dstlen, struct cdecl_function *f) +static void +explain_function(struct output_state *dst, struct cdecl_function *f) { - size_t ret = 0; - - ret += cdecl__emit(dst, dstlen, "function "); + cdecl__emit(dst, "function "); if (f->parameters) { struct cdecl *p; - ret += cdecl__emit(dst, dstlen, "("); + cdecl__emit(dst, "("); for (p = f->parameters; p; p = p->next) { - ret += explain_decl(dst, dstlen, p); + explain_decl(dst, p); if (p->next) - ret += cdecl__emit(dst, dstlen, ", "); + cdecl__emit(dst, ", "); } if (f->variadic) - ret += cdecl__emit(dst, dstlen, ", ...) "); + cdecl__emit(dst, ", ...) "); else - ret += cdecl__emit(dst, dstlen, ") "); + cdecl__emit(dst, ") "); } - return ret + cdecl__emit(dst, dstlen, "returning "); + cdecl__emit(dst, "returning "); } -static size_t -explain_declarators(char **dst, size_t *dstlen, struct cdecl_declarator *d) +static void +explain_declarators(struct output_state *dst, struct cdecl_declarator *d) { - size_t ret; - - if (d->type == CDECL_DECL_IDENT || d->type == CDECL_DECL_NULL) - return 0; - - ret = explain_declarators(dst, dstlen, d->child); + if (d->child) + explain_declarators(dst, d->child); switch (d->type) { case CDECL_DECL_POINTER: - return ret + explain_pointer(dst, dstlen, &d->u.pointer); + explain_pointer(dst, &d->u.pointer); + return; case CDECL_DECL_ARRAY: - return ret + explain_array(dst, dstlen, &d->u.array); + explain_array(dst, &d->u.array); + return; case CDECL_DECL_FUNCTION: - return ret + explain_function(dst, dstlen, &d->u.function); - default: - assert(0); + explain_function(dst, &d->u.function); + return; } } size_t cdecl_explain(char *buf, size_t n, struct cdecl *decl) { - size_t ret; + struct output_state dst = { buf, n }; if (cdecl_is_abstract(decl->declarators)) - ret = cdecl__emit(&buf, &n, "type "); + cdecl__emit(&dst, "type "); else - ret = cdecl__emit(&buf, &n, "declare "); + cdecl__emit(&dst, "declare "); - return ret + explain_decl(&buf, &n, decl); + explain_decl(&dst, decl); + return dst.accum; }