]> git.draconx.ca Git - cdecl99.git/blob - src/explain.c
Split advance into two parts.
[cdecl99.git] / src / explain.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <stdarg.h>
4 #include <assert.h>
5
6 #include "cdecl.h"
7 #include "typemap.h"
8
9 /* declare [ident] as [storage] [function specs] [other crap] [qualifiers] [type specs] */
10
11 static size_t
12 voutput(char *buf, size_t n, size_t off, const char *fmt, va_list ap)
13 {
14         if (off >= n)
15                 return vsnprintf(NULL, 0, fmt, ap);
16         return vsnprintf(buf+off, n-off, fmt, ap);
17 }
18
19 static size_t output(char *buf, size_t n, size_t off, const char *fmt, ...)
20 {
21         va_list ap;
22         size_t ret;
23
24         va_start(ap, fmt);
25         ret = voutput(buf, n, off, fmt, ap);
26         va_end(ap);
27
28         return ret;
29 }
30
31 static size_t advance_(char **buf, size_t *n, size_t amount)
32 {
33         if (amount >= *n) {
34                 *n   = 0;
35                 *buf = 0;
36         } else {
37                 *buf += amount;
38                 *n   -= amount;
39         }
40
41         return amount;
42 }
43
44 static size_t advance(char **buf, size_t *n, size_t amount)
45 {
46         size_t ret, rc;
47
48         if (!amount)
49                 return 0;
50
51         ret = advance_(buf, n, amount);
52         rc = snprintf(*buf, *n, " ");
53         return ret + advance_(buf, n, rc);
54 }
55
56 static size_t
57 explain_qualifiers(char *buf, size_t n, struct cdecl_declspec *s)
58 {
59         unsigned long qualmap = 0;
60         size_t ret = 0, rc = 0;
61
62         for (struct cdecl_declspec *c = s; c; c = c->next) {
63                 if (cdecl_spec_kind(c) != CDECL_SPEC_QUAL)
64                         continue;
65                 qualmap |= 1ul << (c->type & 0xff);
66         }
67
68         if (qualmap & (1ul << (CDECL_QUAL_RESTRICT & 0xff))) {
69                 ret += advance(&buf, &n, rc);
70                 rc = snprintf(buf, n, "restrict");
71         }
72         if (qualmap & (1ul << (CDECL_QUAL_VOLATILE & 0xff))) {
73                 ret += advance(&buf, &n, rc);
74                 rc = snprintf(buf, n, "volatile");
75         }
76         if (qualmap & (1ul << (CDECL_QUAL_CONST & 0xff))) {
77                 ret += advance(&buf, &n, rc);
78                 rc = snprintf(buf, n, "const");
79         }
80
81         return ret + rc;
82 }
83
84 /* Renders the type qualifiers and type specifiers in canonical form. */
85 static size_t
86 explain_post_specs(char *buf, size_t n, struct cdecl_declspec *s)
87 {
88         const char *tag = NULL;
89         unsigned long typemap;
90         size_t ret = 0, rc;
91
92         typemap = cdecl__build_typemap(s);
93         if (typemap == -1)
94                 return 0;
95
96         for (struct cdecl_declspec *c = s; c; c = c->next) {
97                 if (cdecl_spec_kind(c) != CDECL_SPEC_TYPE)
98                         continue;
99
100                 /* Valid C types have at most one identifier. */
101                 if (c->ident)
102                         tag = c->ident;
103         }
104
105         rc = explain_qualifiers(buf, n, s);
106         ret += advance(&buf, &n, rc);
107
108         rc = snprintf(buf, n, "%s", cdecl__explain_typemap(typemap));
109         if (tag) {
110                 ret += advance(&buf, &n, rc);
111                 rc = snprintf(buf, n, "%s", tag);
112         }
113
114         return ret + rc;
115 }
116
117 static const char *explain_storage(unsigned spec)
118 {
119         switch (spec) {
120         case CDECL_STOR_TYPEDEF:
121                 return "typedef";
122         case CDECL_STOR_EXTERN:
123                 return "extern";
124         case CDECL_STOR_STATIC:
125                 return "static";
126         case CDECL_STOR_AUTO:
127                 return "auto";
128         case CDECL_STOR_REGISTER:
129                 return "register";
130         default:
131                 assert(0);
132         }
133 }
134
135 /* Renders the storage-class and function specifiers in canonical form. */
136 static size_t explain_pre_specs(char *buf, size_t n, struct cdecl_declspec *s)
137 {
138         unsigned long funcmap = 0;
139         const char *storage = NULL;
140         size_t ret = 0;
141
142         for (struct cdecl_declspec *c = s; c; c = c->next) {
143                 switch (cdecl_spec_kind(c)) {
144                 case CDECL_SPEC_FUNC:
145                         funcmap |= 1ul << (c->type & 0xff);
146                         break;
147                 case CDECL_SPEC_STOR:
148                         /* Valid C declarations have at most one
149                          * storage-class specifier. */
150                         storage = explain_storage(c->type);
151                         break;
152                 }
153         }
154
155         if (storage)
156                 ret += output(buf, n, ret, "%s", storage);
157         if (funcmap & (1ul << (CDECL_FUNC_INLINE & 0xff)))
158                 ret += output(buf, n, ret, "%.*s%s", !!ret, "", "inline");
159         return ret;
160 }
161
162 static struct cdecl_declarator *next_declarator(struct cdecl_declarator *d)
163 {
164         switch (d->type) {
165         case CDECL_DECL_IDENT:
166                 return NULL;
167         case CDECL_DECL_POINTER:
168                 return d->u.pointer.declarator;
169         case CDECL_DECL_ARRAY:
170                 return d->u.array.declarator;
171         default:
172                 assert(0);
173         }
174 }
175
176 /* Renders the name of the thing being declared. */
177 static size_t
178 explain_prologue(char *buf, size_t n, struct cdecl_declarator *d)
179 {
180         while (d) {
181                 if (d->type == CDECL_DECL_IDENT) {
182                         if (!d->u.ident)
183                                 return snprintf(buf, n, "type");
184                         return snprintf(buf, n, "declare %s as", d->u.ident);
185                 }
186                 d = next_declarator(d);
187         }
188 }
189
190 static size_t
191 explain_pointer(char *buf, size_t n, struct cdecl_pointer *p)
192 {
193         size_t ret = 0, rc;
194
195         rc = explain_qualifiers(buf, n, p->qualifiers);
196         ret += advance(&buf, &n, rc);
197
198         return ret + snprintf(buf, n, "pointer to");
199 }
200
201 static size_t
202 explain_array(char *buf, size_t n, struct cdecl_array *a)
203 {
204         size_t ret = 0, rc = 0;
205
206         if (a->vla)
207                 rc = snprintf(buf, n, "variable-length array");
208         else
209                 rc = snprintf(buf, n, "array");
210         ret += advance(&buf, &n, rc);
211
212         if (a->vla) {
213                 rc = snprintf(buf, n, "%s", a->vla);
214                 ret += advance(&buf, &n, rc);
215         } else if (a->length) {
216                 rc = snprintf(buf, n, "%ju", a->length);
217                 ret += advance(&buf, &n, rc);
218         }
219
220         return ret + snprintf(buf, n, "of");
221 }
222
223 static size_t
224 explain_declarators(char *buf, size_t n, struct cdecl_declarator *d)
225 {
226         size_t ret = 0, rc;
227
228         if (d->type == CDECL_DECL_IDENT)
229                 return 0;
230
231         rc = explain_declarators(buf, n, next_declarator(d));
232         ret += advance(&buf, &n, rc);
233
234         switch (d->type) {
235         case CDECL_DECL_POINTER:
236                 return ret + explain_pointer(buf, n, &d->u.pointer);
237         case CDECL_DECL_ARRAY:
238                 return ret + explain_array(buf, n, &d->u.array);
239         default:
240                 assert(0);
241         }
242 }
243
244 size_t cdecl_explain(char *buf, size_t n, struct cdecl *decl)
245 {
246         size_t ret = 0, rc;
247
248         rc = explain_prologue(buf, n, decl->declarators);
249         ret += advance(&buf, &n, rc);
250
251         rc = explain_pre_specs(buf, n, decl->specifiers);
252         ret += advance(&buf, &n, rc);
253
254         rc = explain_declarators(buf, n, decl->declarators);
255         ret += advance(&buf, &n, rc);
256
257         return ret + explain_post_specs(buf, n, decl->specifiers);
258 }