Daily bump.
[official-gcc.git] / gcc / genhooks.c
blob28bb226c232ec1db31ff842f1081586fcc76a1ed
1 /* Process target.def to create initialization macros definition in
2 target-hooks-def.h and documentation in target-hooks.texi.
3 Copyright (C) 2009-2013 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
10 version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
20 #include "bconfig.h"
21 #include "system.h"
22 #include "hashtab.h"
23 #include "errors.h"
25 struct hook_desc { const char *doc, *type, *name, *param, *init, *docname; };
26 static struct hook_desc hook_array[] = {
27 #define HOOK_VECTOR_1(NAME, FRAGMENT) \
28 { 0, 0, #NAME, 0, 0, HOOK_TYPE },
29 #define DEFHOOKPOD(NAME, DOC, TYPE, INIT) \
30 { DOC, #TYPE, HOOK_PREFIX #NAME, 0, #INIT, HOOK_TYPE },
31 #define DEFHOOK(NAME, DOC, TYPE, PARAMS, INIT) \
32 { DOC, #TYPE, HOOK_PREFIX #NAME, #PARAMS, #INIT, HOOK_TYPE },
33 #define DEFHOOK_UNDOC(NAME, DOC, TYPE, PARAMS, INIT) \
34 { "*", #TYPE, HOOK_PREFIX #NAME, #PARAMS, #INIT, HOOK_TYPE },
35 #include "target.def"
36 #include "c-family/c-target.def"
37 #include "common/common-target.def"
38 #undef DEFHOOK
41 /* For each @Fcode in the first paragraph of the documentation string DOC,
42 print an @findex directive. HOOK_NAME is the name of the hook this bit of
43 documentation pertains to. */
44 static void
45 emit_findices (const char *doc, const char *hook_name)
47 const char *end = strstr (doc, "\n\n");
48 const char *fcode;
50 while ((fcode = strstr (doc, "@Fcode{")) && (!end || fcode < end))
52 fcode += strlen ("@Fcode{");
53 doc = strchr (fcode, '}');
54 if (!doc)
55 fatal ("Malformed @Fcode for hook %s\n", hook_name);
56 printf ("@findex %.*s\n", (int) (doc - fcode), fcode);
57 doc = fcode;
61 /* Return an upper-case copy of IN. */
62 static char *
63 upstrdup (const char *in)
65 char *p, *ret = xstrdup (in);
66 for (p = ret; *p; p++)
67 *p = TOUPPER (*p);
68 return ret;
71 /* Struct for 'start hooks' which start a sequence of consecutive hooks
72 that are defined in target.def and to be documented in tm.texi. */
73 struct s_hook
75 char *name;
76 int pos;
79 static hashval_t
80 s_hook_hash (const void *p)
82 const struct s_hook *s_hook = (const struct s_hook *)p;
83 return htab_hash_string (s_hook->name);
86 static int
87 s_hook_eq_p (const void *p1, const void *p2)
89 return (strcmp (((const struct s_hook *) p1)->name,
90 ((const struct s_hook *) p2)->name) == 0);
93 /* Read the documentation file with name IN_FNAME, perform substitutions
94 to incorporate information from hook_array, and emit the result on stdout.
95 Hooks defined with DEFHOOK / DEFHOOKPOD are emitted at the place of a
96 matching @hook in the input file; if there is no matching @hook, the
97 hook is emitted after the hook that precedes it in target.def .
98 Usually, the emitted hook documentation starts with the hook
99 signature, followed by the string from the doc field.
100 The documentation is bracketed in @deftypefn / @deftypevr and a matching
101 @end.
102 While emitting the doc field, @Fcode is translated to @code, and an
103 @findex entry is added to the affected paragraph.
104 If the doc field starts with '*', the leading '*' is stripped, and the doc
105 field is otherwise emitted unaltered; no function signature/
106 @deftypefn/deftypevr/@end is emitted.
107 In particular, a doc field of "*" means not to emit any ocumentation for
108 this target.def / hook_array entry at all (there might be documentation
109 for this hook in the file named IN_FNAME, though).
110 A doc field of 0 is used to append the hook signature after the previous
111 hook's signture, so that one description can be used for a group of hooks.
112 When the doc field is "", @deftypefn/@deftypevr and the hook signature
113 is emitted, but not the matching @end. This allows all the free-form
114 documentation to be placed in IN_FNAME, to work around GPL/GFDL
115 licensing incompatibility issues. */
116 static void
117 emit_documentation (const char *in_fname)
119 int i, j;
120 char buf[1000];
121 htab_t start_hooks = htab_create (99, s_hook_hash, s_hook_eq_p, (htab_del) 0);
122 FILE *f;
124 /* Enter all the start hooks in start_hooks. */
125 f = fopen (in_fname, "r");
126 if (!f)
128 perror ("");
129 fatal ("Couldn't open input file");
131 while (fscanf (f, "%*[^@]"), buf[0] = '\0',
132 fscanf (f, "@%5[^ \n]", buf) != EOF)
134 void **p;
135 struct s_hook *shp;
137 if (strcmp (buf, "hook") != 0)
138 continue;
139 buf[0] = '\0';
140 fscanf (f, "%999s", buf);
141 shp = XNEW (struct s_hook);
142 shp->name = upstrdup (buf);
143 shp->pos = -1;
144 p = htab_find_slot (start_hooks, shp, INSERT);
145 if (*p != HTAB_EMPTY_ENTRY)
146 fatal ("Duplicate placement for hook %s\n", shp->name);
147 *(struct s_hook **) p = shp;
149 fclose (f);
150 /* For each hook in hook_array, if it is a start hook, store its position. */
151 for (i = 0; i < (int) (sizeof hook_array / sizeof hook_array[0]); i++)
153 struct s_hook sh, *shp;
154 void *p;
156 if (!hook_array[i].doc || strcmp (hook_array[i].doc, "*") == 0)
157 continue;
158 sh.name = upstrdup (hook_array[i].name);
159 p = htab_find (start_hooks, &sh);
160 if (p)
162 shp = (struct s_hook *) p;
163 if (shp->pos >= 0)
164 fatal ("Duplicate hook %s\n", sh.name);
165 shp->pos = i;
167 else
168 fatal ("No place specified to document hook %s\n", sh.name);
169 free (sh.name);
171 /* Copy input file to stdout, substituting @hook directives with the
172 corresponding hook documentation sequences. */
173 f = fopen (in_fname, "r");
174 if (!f)
176 perror ("");
177 fatal ("Couldn't open input file");
179 for (;;)
181 struct s_hook sh, *shp;
182 int c = getc (f);
183 char *name;
185 if (c == EOF)
186 break;
187 if (c != '@')
189 putchar (c);
190 continue;
192 buf[0] = '\0';
193 fscanf (f, "%5[^ \n]", buf);
194 if (strcmp (buf, "hook") != 0)
196 printf ("@%s", buf);
197 continue;
199 fscanf (f, "%999s", buf);
200 sh.name = name = upstrdup (buf);
201 shp = (struct s_hook *) htab_find (start_hooks, &sh);
202 if (!shp || shp->pos < 0)
203 fatal ("No documentation for hook %s\n", sh.name);
204 i = shp->pos;
207 const char *q, *e;
208 const char *deftype;
209 const char *doc, *fcode, *p_end;
211 /* A leading '*' means to output the documentation string without
212 further processing. */
213 if (*hook_array[i].doc == '*')
214 printf ("%s", hook_array[i].doc + 1);
215 else
217 if (i != shp->pos)
218 printf ("\n\n");
219 emit_findices (hook_array[i].doc, name);
221 /* Print header. Function-valued hooks have a parameter list,
222 unlike POD-valued ones. */
223 deftype = hook_array[i].param ? "deftypefn" : "deftypevr";
224 printf ("@%s {%s} ", deftype, hook_array[i].docname);
225 if (strchr (hook_array[i].type, ' '))
226 printf ("{%s}", hook_array[i].type);
227 else
228 printf ("%s", hook_array[i].type);
229 printf (" %s", name);
230 if (hook_array[i].param)
232 /* Print the parameter list, with the parameter names
233 enclosed in @var{}. */
234 printf (" ");
235 for (q = hook_array[i].param; (e = strpbrk (q, " *,)"));
236 q = e + 1)
237 /* Type names like 'int' are followed by a space, sometimes
238 also by '*'. 'void' should appear only in "(void)". */
239 if (*e == ' ' || *e == '*' || *q == '(')
240 printf ("%.*s", (int) (e - q + 1), q);
241 else
242 printf ("@var{%.*s}%c", (int) (e - q), q, *e);
244 /* POD-valued hooks sometimes come in groups with common
245 documentation.*/
246 for (j = i + 1;
247 j < (int) (sizeof hook_array / sizeof hook_array[0])
248 && hook_array[j].doc == 0 && hook_array[j].type; j++)
250 char *namex = upstrdup (hook_array[j].name);
252 printf ("\n@%sx {%s} {%s} %s",
253 deftype, hook_array[j].docname,
254 hook_array[j].type, namex);
256 if (hook_array[i].doc[0])
258 printf ("\n");
259 /* Print each documentation paragraph in turn. */
260 for (doc = hook_array[i].doc; *doc; doc = p_end)
262 /* Find paragraph end. */
263 p_end = strstr (doc, "\n\n");
264 p_end = (p_end ? p_end + 2 : doc + strlen (doc));
265 /* Print paragraph, emitting @Fcode as @code. */
266 for (; (fcode = strstr (doc, "@Fcode{")) && fcode < p_end;
267 doc = fcode + 2)
268 printf ("%.*s@", (int) (fcode - doc), doc);
269 printf ("%.*s", (int) (p_end - doc), doc);
270 /* Emit function indices for next paragraph. */
271 emit_findices (p_end, name);
273 printf ("\n@end %s", deftype);
276 if (++i >= (int) (sizeof hook_array / sizeof hook_array[0])
277 || !hook_array[i].doc)
278 break;
279 free (name);
280 sh.name = name = upstrdup (hook_array[i].name);
282 while (!htab_find (start_hooks, &sh));
283 free (name);
287 /* Emit #defines to stdout (this will be redirected to generate
288 target-hook-def.h) which set target hooks initializer macros
289 to their default values. These should only be emitted for hooks
290 whose type is given by DOCNAME. */
291 static void
292 emit_init_macros (const char *docname)
294 int i;
295 const int MAX_NEST = 2;
296 int print_nest, nest = 0;
298 for (print_nest = 0; print_nest <= MAX_NEST; print_nest++)
300 for (i = 0; i < (int) (sizeof hook_array / sizeof hook_array[0]); i++)
302 char *name = upstrdup (hook_array[i].name);
304 if (strcmp (hook_array[i].docname, docname) != 0)
305 continue;
307 if (!hook_array[i].type)
309 if (*name)
311 if (nest && nest == print_nest)
312 printf (" %s, \\\n", name);
313 nest++;
314 if (nest > MAX_NEST)
315 fatal ("Unexpected nesting of %s\n", name);
316 if (nest == print_nest)
317 printf ("\n#define %s \\\n { \\\n", name);
319 else
321 if (nest == print_nest)
322 printf (" }\n");
323 nest--;
325 continue;
327 if (0 == print_nest)
329 /* Output default definitions of target hooks. */
330 printf ("#ifndef %s\n#define %s %s\n#endif\n",
331 name, name, hook_array[i].init);
333 if (nest == print_nest)
334 printf (" %s, \\\n", name);
340 main (int argc, char **argv)
342 progname = "genhooks";
344 if (argc >= 3)
345 emit_documentation (argv[2]);
346 else
347 emit_init_macros (argv[1]);
348 return 0;