#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 ret;
-
- ret = cdecl__emit_specs(dst, dstlen, s, mask);
- return ret + cdecl__emit(dst, dstlen, " " + !ret);
-}
-
-static size_t
-explain_specs_post(char **dst, size_t *dstlen, struct cdecl_declspec *s)
-{
- return cdecl__emit_specs(dst, dstlen, s, POST_SPECS);
+ 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 ");
}
/*
* 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 = snprintf(dst->dst, dst->dstlen, "%.0" PRIuMAX, a->length);
+ cdecl__advance(dst, rc);
}
- 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);
}
/*
* 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;
+ return;
- ret = explain_declarators(dst, dstlen, 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);
+ explain_function(dst, &d->u.function);
+ return;
default:
assert(0);
}
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;
}