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-2015 Free Software Foundation, Inc.
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along 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"
24
25struct hook_desc { const char *doc, *type, *name, *param, *init, *docname; };
26static 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
39};
40
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.  */
44static void
45emit_findices (const char *doc, const char *hook_name)
46{
47  const char *end = strstr (doc, "\n\n");
48  const char *fcode;
49
50  while ((fcode = strstr (doc, "@Fcode{")) && (!end || fcode < end))
51    {
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;
58    }
59}
60
61/* Return an upper-case copy of IN.  */
62static char *
63upstrdup (const char *in)
64{
65  char *p, *ret = xstrdup (in);
66  for (p = ret; *p; p++)
67    *p = TOUPPER (*p);
68  return ret;
69}
70
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.  */
73struct s_hook
74{
75  char *name;
76  int pos;
77};
78
79static hashval_t
80s_hook_hash (const void *p)
81{
82  const struct s_hook *s_hook = (const struct s_hook *)p;
83  return htab_hash_string (s_hook->name);
84}
85
86static int
87s_hook_eq_p (const void *p1, const void *p2)
88{
89  return (strcmp (((const struct s_hook *) p1)->name,
90		  ((const struct s_hook *) p2)->name) == 0);
91}
92
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.  */
116static void
117emit_documentation (const char *in_fname)
118{
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;
123
124  /* Enter all the start hooks in start_hooks.  */
125  f = fopen (in_fname, "r");
126  if (!f)
127    {
128      perror ("");
129      fatal ("Couldn't open input file");
130    }
131  while (fscanf (f, "%*[^@]"), buf[0] = '\0',
132	 fscanf (f, "@%5[^ \n]", buf) != EOF)
133    {
134      void **p;
135      struct s_hook *shp;
136
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;
148    }
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++)
152    {
153      struct s_hook sh, *shp;
154      void *p;
155
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)
161	{
162	  shp = (struct s_hook *) p;
163	  if (shp->pos >= 0)
164	    fatal ("Duplicate hook %s\n", sh.name);
165	  shp->pos = i;
166	}
167      else
168	fatal ("No place specified to document hook %s\n", sh.name);
169      free (sh.name);
170    }
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)
175    {
176      perror ("");
177      fatal ("Couldn't open input file");
178    }
179  for (;;)
180    {
181      struct s_hook sh, *shp;
182      int c = getc (f);
183      char *name;
184
185      if (c == EOF)
186	break;
187      if (c != '@')
188	{
189	  putchar (c);
190	  continue;
191	}
192      buf[0] = '\0';
193      fscanf (f, "%5[^ \n]", buf);
194      if (strcmp (buf, "hook") != 0)
195	{
196	  printf ("@%s", buf);
197	  continue;
198	}
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;
205      do
206	{
207	  const char *q, *e;
208	  const char *deftype;
209	  const char *doc, *fcode, *p_end;
210
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
216	    {
217	      if (i != shp->pos)
218		printf ("\n\n");
219	      emit_findices (hook_array[i].doc, name);
220
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)
231		{
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);
243		}
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++)
249		{
250		  char *namex = upstrdup (hook_array[j].name);
251
252		  printf ("\n@%sx {%s} {%s} %s",
253			  deftype, hook_array[j].docname,
254			  hook_array[j].type, namex);
255		}
256	      if (hook_array[i].doc[0])
257		{
258		  printf ("\n");
259		  /* Print each documentation paragraph in turn.  */
260		  for (doc = hook_array[i].doc; *doc; doc = p_end)
261		    {
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);
272		    }
273		  printf ("\n@end %s", deftype);
274		}
275	    }
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);
281	}
282      while (!htab_find (start_hooks, &sh));
283      free (name);
284    }
285}
286
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.  */
291static void
292emit_init_macros (const char *docname)
293{
294  int i;
295  const int MAX_NEST = 2;
296  int print_nest, nest = 0;
297
298  for (print_nest = 0; print_nest <= MAX_NEST; print_nest++)
299    {
300      for (i = 0; i < (int) (sizeof hook_array / sizeof hook_array[0]); i++)
301	{
302	  char *name = upstrdup (hook_array[i].name);
303
304	  if (strcmp (hook_array[i].docname, docname) != 0)
305	    continue;
306
307	  if (!hook_array[i].type)
308	    {
309	      if (*name)
310		{
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);
318		}
319	      else
320		{
321		  if (nest == print_nest)
322		    printf ("  }\n");
323		  nest--;
324		}
325	      continue;
326	    }
327	  if (0 == print_nest)
328	    {
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);
332	    }
333	  if (nest == print_nest)
334	    printf ("    %s, \\\n", name);
335	}
336    }
337}
338
339int
340main (int argc, char **argv)
341{
342  progname = "genhooks";
343
344  if (argc >= 3)
345    emit_documentation (argv[2]);
346  else
347    emit_init_macros (argv[1]);
348  return 0;
349}
350