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, 2010, 2011 Free Software Foundation, Inc. 4 5 This file is part of GCC. 6 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. 11 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. 16 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" 24 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 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. */ 44 static void 45 emit_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. */ 62 static char * 63 upstrdup (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. */ 73 struct s_hook 74 { 75 char *name; 76 int pos; 77 }; 78 79 static hashval_t 80 s_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 86 static int 87 s_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 informtion 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) 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 bool found_start = false; 124 125 /* Enter all the start hooks in start_hooks. */ 126 f = fopen (in_fname, "r"); 127 if (!f) 128 { 129 perror (""); 130 fatal ("Couldn't open input file"); 131 } 132 while (fscanf (f, "%*[^@]"), buf[0] = '\0', 133 fscanf (f, "@%5[^ \n]", buf) != EOF) 134 { 135 void **p; 136 struct s_hook *shp; 137 138 if (strcmp (buf, "hook") != 0) 139 continue; 140 buf[0] = '\0'; 141 fscanf (f, "%999s", buf); 142 shp = XNEW (struct s_hook); 143 shp->name = upstrdup (buf); 144 shp->pos = -1; 145 p = htab_find_slot (start_hooks, shp, INSERT); 146 if (*p != HTAB_EMPTY_ENTRY) 147 fatal ("Duplicate placement for hook %s\n", shp->name); 148 *(struct s_hook **) p = shp; 149 } 150 fclose (f); 151 /* For each hook in hook_array, if it is a start hook, store its position. */ 152 for (i = 0; i < (int) (sizeof hook_array / sizeof hook_array[0]); i++) 153 { 154 struct s_hook sh, *shp; 155 void *p; 156 157 if (!hook_array[i].doc || strcmp (hook_array[i].doc, "*") == 0) 158 continue; 159 sh.name = upstrdup (hook_array[i].name); 160 p = htab_find (start_hooks, &sh); 161 if (p) 162 { 163 shp = (struct s_hook *) p; 164 if (shp->pos >= 0) 165 fatal ("Duplicate hook %s\n", sh.name); 166 shp->pos = i; 167 found_start = true; 168 } 169 else if (!found_start) 170 fatal ("No place specified to document hook %s\n", sh.name); 171 free (sh.name); 172 } 173 /* Copy input file to stdout, substituting @hook directives with the 174 corresponding hook documentation sequences. */ 175 f = fopen (in_fname, "r"); 176 if (!f) 177 { 178 perror (""); 179 fatal ("Couldn't open input file"); 180 } 181 for (;;) 182 { 183 struct s_hook sh, *shp; 184 int c = getc (f); 185 char *name; 186 187 if (c == EOF) 188 break; 189 if (c != '@') 190 { 191 putchar (c); 192 continue; 193 } 194 buf[0] = '\0'; 195 fscanf (f, "%5[^ \n]", buf); 196 if (strcmp (buf, "hook") != 0) 197 { 198 printf ("@%s", buf); 199 continue; 200 } 201 fscanf (f, "%999s", buf); 202 sh.name = name = upstrdup (buf); 203 shp = (struct s_hook *) htab_find (start_hooks, &sh); 204 if (!shp || shp->pos < 0) 205 fatal ("No documentation for hook %s\n", sh.name); 206 i = shp->pos; 207 do 208 { 209 const char *q, *e; 210 const char *deftype; 211 const char *doc, *fcode, *p_end; 212 213 /* A leading '*' means to output the documentation string without 214 further processing. */ 215 if (*hook_array[i].doc == '*') 216 printf ("%s", hook_array[i].doc + 1); 217 else 218 { 219 if (i != shp->pos) 220 printf ("\n\n"); 221 emit_findices (hook_array[i].doc, name); 222 223 /* Print header. Function-valued hooks have a parameter list, 224 unlike POD-valued ones. */ 225 deftype = hook_array[i].param ? "deftypefn" : "deftypevr"; 226 printf ("@%s {%s} ", deftype, hook_array[i].docname); 227 if (strchr (hook_array[i].type, ' ')) 228 printf ("{%s}", hook_array[i].type); 229 else 230 printf ("%s", hook_array[i].type); 231 printf (" %s", name); 232 if (hook_array[i].param) 233 { 234 /* Print the parameter list, with the parameter names 235 enclosed in @var{}. */ 236 printf (" "); 237 for (q = hook_array[i].param; (e = strpbrk (q, " *,)")); 238 q = e + 1) 239 /* Type names like 'int' are followed by a space, sometimes 240 also by '*'. 'void' should appear only in "(void)". */ 241 if (*e == ' ' || *e == '*' || *q == '(') 242 printf ("%.*s", (int) (e - q + 1), q); 243 else 244 printf ("@var{%.*s}%c", (int) (e - q), q, *e); 245 } 246 /* POD-valued hooks sometimes come in groups with common 247 documentation.*/ 248 for (j = i + 1; 249 j < (int) (sizeof hook_array / sizeof hook_array[0]) 250 && hook_array[j].doc == 0 && hook_array[j].type; j++) 251 { 252 char *namex = upstrdup (hook_array[j].name); 253 254 printf ("\n@%sx {%s} {%s} %s", 255 deftype, hook_array[j].docname, 256 hook_array[j].type, namex); 257 } 258 if (hook_array[i].doc[0]) 259 { 260 printf ("\n"); 261 /* Print each documentation paragraph in turn. */ 262 for (doc = hook_array[i].doc; *doc; doc = p_end) 263 { 264 /* Find paragraph end. */ 265 p_end = strstr (doc, "\n\n"); 266 p_end = (p_end ? p_end + 2 : doc + strlen (doc)); 267 /* Print paragraph, emitting @Fcode as @code. */ 268 for (; (fcode = strstr (doc, "@Fcode{")) && fcode < p_end; 269 doc = fcode + 2) 270 printf ("%.*s@", (int) (fcode - doc), doc); 271 printf ("%.*s", (int) (p_end - doc), doc); 272 /* Emit function indices for next paragraph. */ 273 emit_findices (p_end, name); 274 } 275 printf ("\n@end %s", deftype); 276 } 277 } 278 if (++i >= (int) (sizeof hook_array / sizeof hook_array[0]) 279 || !hook_array[i].doc) 280 break; 281 free (name); 282 sh.name = name = upstrdup (hook_array[i].name); 283 } 284 while (!htab_find (start_hooks, &sh)); 285 free (name); 286 } 287 } 288 289 /* Emit #defines to stdout (this will be redirected to generate 290 target-hook-def.h) which set target hooks initializer macros 291 to their default values. These should only be emitted for hooks 292 whose type is given by DOCNAME. */ 293 static void 294 emit_init_macros (const char *docname) 295 { 296 int i; 297 const int MAX_NEST = 2; 298 int print_nest, nest = 0; 299 300 for (print_nest = 0; print_nest <= MAX_NEST; print_nest++) 301 { 302 for (i = 0; i < (int) (sizeof hook_array / sizeof hook_array[0]); i++) 303 { 304 char *name = upstrdup (hook_array[i].name); 305 306 if (strcmp (hook_array[i].docname, docname) != 0) 307 continue; 308 309 if (!hook_array[i].type) 310 { 311 if (*name) 312 { 313 if (nest && nest == print_nest) 314 printf (" %s, \\\n", name); 315 nest++; 316 if (nest > MAX_NEST) 317 fatal ("Unexpected nesting of %s\n", name); 318 if (nest == print_nest) 319 printf ("\n#define %s \\\n { \\\n", name); 320 } 321 else 322 { 323 if (nest == print_nest) 324 printf (" }\n"); 325 nest--; 326 } 327 continue; 328 } 329 if (0 == print_nest) 330 { 331 /* Output default definitions of target hooks. */ 332 printf ("#ifndef %s\n#define %s %s\n#endif\n", 333 name, name, hook_array[i].init); 334 } 335 if (nest == print_nest) 336 printf (" %s, \\\n", name); 337 } 338 } 339 } 340 341 int 342 main (int argc, char **argv) 343 { 344 if (argc >= 3) 345 emit_documentation (argv[2]); 346 else 347 emit_init_macros (argv[1]); 348 return 0; 349 } 350