![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c-aux-info.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to c-aux-info.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Generate information regarding function declarations and definitions based
2: on information stored in GCC's tree structure. This code implements the
3: -fgen-aux-info option.
4:
5: This code was written by Ron Guilmette ([email protected]).
6:
7: Copyright (C) 1989, 1991 Free Software Foundation, Inc.
8:
9: This file is part of GNU CC.
10:
11: GNU CC is free software; you can redistribute it and/or modify
12: it under the terms of the GNU General Public License as published by
13: the Free Software Foundation; either version 2, or (at your option)
14: any later version.
15:
16: GNU CC is distributed in the hope that it will be useful,
17: but WITHOUT ANY WARRANTY; without even the implied warranty of
18: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19: GNU General Public License for more details.
20:
21: You should have received a copy of the GNU General Public License
22: along with GNU CC; see the file COPYING. If not, write to
23: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
24:
25: #include <stdio.h>
26: #include <sys/param.h>
27: #include <errno.h>
28: #include "config.h"
29: #include "flags.h"
30: #include "tree.h"
31: #include "c-tree.h"
32:
33: #ifndef errno
34: extern int errno;
35: #endif
36:
37: extern char* xmalloc ();
38:
39: enum formals_style_enum {
40: ansi,
41: k_and_r_names,
42: k_and_r_decls
43: };
44: typedef enum formals_style_enum formals_style;
45:
46:
47: static char* data_type;
48:
49: static char * concat ();
50: static char * concat3 ();
51: static char * gen_formal_list_for_type ();
52: static int deserves_ellipsis ();
53: static char * gen_formal_list_for_func_def ();
54: static char * gen_type ();
55: static char * gen_decl ();
56: void gen_aux_info_record ();
57:
58: /* Virtually every UN*X system now in common use (except for pre-4.3-tahoe
59: BSD systems) now provides getcwd as called for by POSIX. Allow for
60: the few exceptions to the general rule here. */
61:
62: #if !(defined (USG) || defined (VMS))
63: extern char *getwd ();
64: #define getcwd(buf,len) getwd(buf)
65: #define GUESSPATHLEN (MAXPATHLEN + 1)
66: #else /* (defined (USG) || defined (VMS)) */
67: extern char *getcwd ();
68: /* We actually use this as a starting point, not a limit. */
69: #define GUESSPATHLEN 100
70: #endif /* (defined (USG) || defined (VMS)) */
71:
72: /* Take two strings and mash them together into a newly allocated area. */
73:
74: static char*
75: concat (s1, s2)
76: char* s1;
77: char* s2;
78: {
79: int size1, size2;
80: char* ret_val;
81:
82: if (!s1)
83: s1 = "";
84: if (!s2)
85: s2 = "";
86:
87: size1 = strlen (s1);
88: size2 = strlen (s2);
89: ret_val = xmalloc (size1 + size2 + 1);
90: strcpy (ret_val, s1);
91: strcpy (&ret_val[size1], s2);
92: return ret_val;
93: }
94:
95: /* Take three strings and mash them together into a newly allocated area. */
96:
97: static char*
98: concat3 (s1, s2, s3)
99: char* s1;
100: char* s2;
101: char* s3;
102: {
103: int size1, size2, size3;
104: char* ret_val;
105:
106: if (!s1)
107: s1 = "";
108: if (!s2)
109: s2 = "";
110: if (!s3)
111: s3 = "";
112:
113: size1 = strlen (s1);
114: size2 = strlen (s2);
115: size3 = strlen (s3);
116: ret_val = xmalloc (size1 + size2 + size3 + 1);
117: strcpy (ret_val, s1);
118: strcpy (&ret_val[size1], s2);
119: strcpy (&ret_val[size1+size2], s3);
120: return ret_val;
121: }
122:
123: /* Given a string representing an entire type or an entire declaration
124: which only lacks the actual "data-type" specifier (at its left end),
125: affix the data-type specifier to the left end of the given type
126: specification or object declaration.
127:
128: Because of C language weirdness, the data-type specifier (which normally
129: goes in at the very left end) may have to be slipped in just to the
130: right of any leading "const" or "volatile" qualifiers (there may be more
131: than one). Actually this may not be strictly necessary because it seems
132: that GCC (at least) accepts `<data-type> const foo;' and treats it the
133: same as `const <data-type> foo;' but people are accustomed to seeing
134: `const char *foo;' and *not* `char const *foo;' so we try to create types
135: that look as expected. */
136:
137: static char*
138: affix_data_type (type_or_decl)
139: char *type_or_decl;
140: {
141: char *p = type_or_decl;
142: char *qualifiers_then_data_type;
143: char saved;
144:
145: /* Skip as many leading const's or volatile's as there are. */
146:
147: for (;;)
148: {
149: if (!strncmp (p, "volatile", 8))
150: {
151: p += 9;
152: continue;
153: }
154: if (!strncmp (p, "const", 5))
155: {
156: p += 6;
157: continue;
158: }
159: break;
160: }
161:
162: /* p now points to the place where we can insert the data type. We have to
163: add a blank after the data-type of course. */
164:
165: if (p == type_or_decl)
166: return concat3 (data_type, " ", type_or_decl);
167:
168: saved = *p;
169: *p = '\0';
170: qualifiers_then_data_type = concat (type_or_decl, data_type);
171: *p = saved;
172: return concat3 (qualifiers_then_data_type, " ", p);
173: }
174:
175: /* Given a tree node which represents some "function type", generate the
176: source code version of a formal parameter list (of some given style) for
177: this function type. Return the whole formal parameter list (including
178: a pair of surrounding parens) as a string. Note that if the style
179: we are currently aiming for is non-ansi, then we just return a pair
180: of empty parens here. */
181:
182: static char*
183: gen_formal_list_for_type (fntype, style)
184: tree fntype;
185: formals_style style;
186: {
187: char* formal_list = "";
188: tree formal_type;
189:
190: if (style != ansi)
191: return "()";
192:
193: formal_type = TYPE_ARG_TYPES (fntype);
194: while (formal_type && TREE_VALUE (formal_type) != void_type_node)
195: {
196: char* this_type;
197:
198: if (*formal_list)
199: formal_list = concat (formal_list, ", ");
200:
201: this_type = gen_type ("", TREE_VALUE (formal_type), ansi);
202: formal_list =
203: (strlen (this_type))
204: ? concat (formal_list, affix_data_type (this_type))
205: : concat (formal_list, data_type);
206:
207: formal_type = TREE_CHAIN (formal_type);
208: }
209:
210: /* If we got to here, then we are trying to generate an ANSI style formal
211: parameters list.
212:
213: New style prototyped ANSI formal parameter lists should in theory always
214: contain some stuff between the opening and closing parens, even if it is
215: only "void".
216:
217: The brutal truth though is that there is lots of old K&R code out there
218: which contains declarations of "pointer-to-function" parameters and
219: these almost never have fully specified formal parameter lists associated
220: with them. That is, the pointer-to-function parameters are declared
221: with just empty parameter lists.
222:
223: In cases such as these, protoize should really insert *something* into
224: the vacant parameter lists, but what? It has no basis on which to insert
225: anything in particular.
226:
227: Here, we make life easy for protoize by trying to distinguish between
228: K&R empty parameter lists and new-style prototyped parameter lists
229: that actually contain "void". In the latter case we (obviously) want
230: to output the "void" verbatim, and that what we do. In the former case,
231: we do our best to give protoize something nice to insert.
232:
233: This "something nice" should be something that is still legal (when
234: re-compiled) but something that can clearly indicate to the user that
235: more typing information (for the parameter list) should be added (by
236: hand) at some convenient moment.
237:
238: The string chozen here is a comment with question marks in it. */
239:
240: if (!*formal_list)
241: {
242: if (TYPE_ARG_TYPES (fntype))
243: /* assert (TREE_VALUE (TYPE_ARG_TYPES (fntype)) == void_type_node); */
244: formal_list = "void";
245: else
246: formal_list = "/* ??? */";
247: }
248: else
249: {
250: /* If there were at least some parameters, and if the formals-types-list
251: petered out to a NULL (i.e. without being terminated by a
252: void_type_node) then we need to tack on an ellipsis. */
253: if (!formal_type)
254: formal_list = concat (formal_list, ", ...");
255: }
256:
257: return concat3 (" (", formal_list, ")");
258: }
259:
260: /* For the generation of an ANSI prototype for a function definition, we have
261: to look at the formal parameter list of the function's own "type" to
262: determine if the function's formal parameter list should end with an
263: ellipsis. Given a tree node, the following function will return non-zero
264: if the "function type" parameter list should end with an ellipsis. */
265:
266: static int
267: deserves_ellipsis (fntype)
268: tree fntype;
269: {
270: tree formal_type;
271:
272: formal_type = TYPE_ARG_TYPES (fntype);
273: while (formal_type && TREE_VALUE (formal_type) != void_type_node)
274: formal_type = TREE_CHAIN (formal_type);
275:
276: /* If there were at least some parameters, and if the formals-types-list
277: petered out to a NULL (i.e. without being terminated by a void_type_node)
278: then we need to tack on an ellipsis. */
279:
280: return (!formal_type && TYPE_ARG_TYPES (fntype));
281: }
282:
283: /* Generate a parameter list for a function definition (in some given style).
284:
285: Note that this routine has to be separate (and different) from the code that
286: generates the prototype parameter lists for function declarations, because
287: in the case of a function declaration, all we have to go on is a tree node
288: representing the function's own "function type". This can tell us the types
289: of all of the formal parameters for the function, but it cannot tell us the
290: actual *names* of each of the formal parameters. We need to output those
291: parameter names for each function definition.
292:
293: This routine gets a pointer to a tree node which represents the actual
294: declaration of the given function, and this DECL node has a list of formal
295: parameter (variable) declarations attached to it. These formal parameter
296: (variable) declaration nodes give us the actual names of the formal
297: parameters for the given function definition.
298:
299: This routine returns a string which is the source form for the entire
300: function formal parameter list. */
301:
302: static char*
303: gen_formal_list_for_func_def (fndecl, style)
304: tree fndecl;
305: formals_style style;
306: {
307: char* formal_list = "";
308: tree formal_decl;
309:
310: formal_decl = DECL_ARGUMENTS (fndecl);
311: while (formal_decl)
312: {
313: char *this_formal;
314:
315: if (*formal_list && ((style == ansi) || (style == k_and_r_names)))
316: formal_list = concat (formal_list, ", ");
317: this_formal = gen_decl (formal_decl, 0, style);
318: if (style == k_and_r_decls)
319: formal_list = concat3 (formal_list, this_formal, "; ");
320: else
321: formal_list = concat (formal_list, this_formal);
322: formal_decl = TREE_CHAIN (formal_decl);
323: }
324: if (style == ansi)
325: {
326: if (!DECL_ARGUMENTS (fndecl))
327: formal_list = concat (formal_list, "void");
328: if (deserves_ellipsis (TREE_TYPE (fndecl)))
329: formal_list = concat (formal_list, ", ...");
330: }
331: if ((style == ansi) || (style == k_and_r_names))
332: formal_list = concat3 (" (", formal_list, ")");
333: return formal_list;
334: }
335:
336: /* Generate a string which is the source code form for a given type (t). This
337: routine is ugly and complex because the C syntax for declarations is ugly
338: and complex. This routine is straightforward so long as *no* pointer types,
339: array types, or function types are involved.
340:
341: In the simple cases, this routine will return the (string) value which was
342: passed in as the "ret_val" argument. Usually, this starts out either as an
343: empty string, or as the name of the declared item (i.e. the formal function
344: parameter variable).
345:
346: This routine will also return with the global variable "data_type" set to
347: some string value which is the "basic" data-type of the given complete type.
348: This "data_type" string can be concatenated onto the front of the returned
349: string after this routine returns to its caller.
350:
351: In complicated cases involving pointer types, array types, or function
352: types, the C declaration syntax requires an "inside out" approach, i.e. if
353: you have a type which is a "pointer-to-function" type, you need to handle
354: the "pointer" part first, but it also has to be "innermost" (relative to
355: the declaration stuff for the "function" type). Thus, is this case, you
356: must prepend a "(*" and append a ")" to the name of the item (i.e. formal
357: variable). Then you must append and prepend the other info for the
358: "function type" part of the overall type.
359:
360: To handle the "innermost precedence" rules of complicated C declarators, we
361: do the following (in this routine). The input parameter called "ret_val"
362: is treated as a "seed". Each time gen_type is called (perhaps recursively)
363: some additional strings may be appended or prepended (or both) to the "seed"
364: string. If yet another (lower) level of the GCC tree exists for the given
365: type (as in the case of a pointer type, an array type, or a function type)
366: then the (wrapped) seed is passed to a (recursive) invocation of gen_type()
367: this recursive invocation may again "wrap" the (new) seed with yet more
368: declarator stuff, by appending, prepending (or both). By the time the
369: recursion bottoms out, the "seed value" at that point will have a value
370: which is (almost) the complete source version of the declarator (except
371: for the data_type info). Thus, this deepest "seed" value is simply passed
372: back up through all of the recursive calls until it is given (as the return
373: value) to the initial caller of the gen_type() routine. All that remains
374: to do at this point is for the initial caller to prepend the "data_type"
375: string onto the returned "seed". */
376:
377: static char*
378: gen_type (ret_val, t, style)
379: char* ret_val;
380: tree t;
381: formals_style style;
382: {
383: tree chain_p;
384:
385: if (TYPE_NAME (t) && DECL_NAME (TYPE_NAME (t)))
386: data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
387: else
388: {
389: switch (TREE_CODE (t))
390: {
391: case POINTER_TYPE:
392: if (TYPE_READONLY (t))
393: ret_val = concat ("const ", ret_val);
394: if (TYPE_VOLATILE (t))
395: ret_val = concat ("volatile ", ret_val);
396:
397: ret_val = concat ("*", ret_val);
398:
399: if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
400: ret_val = concat3 ("(", ret_val, ")");
401:
402: ret_val = gen_type (ret_val, TREE_TYPE (t), style);
403:
404: return ret_val;
405:
406: case ARRAY_TYPE:
407: ret_val = gen_type (concat (ret_val, "[]"), TREE_TYPE (t), style);
408: break;
409:
410: case FUNCTION_TYPE:
411: ret_val = gen_type (concat (ret_val, gen_formal_list_for_type (t, style)), TREE_TYPE (t), style);
412: break;
413:
414: case IDENTIFIER_NODE:
415: data_type = IDENTIFIER_POINTER (t);
416: break;
417:
418: /* The following three cases are complicated by the fact that a
419: user may do something really stupid, like creating a brand new
420: "anonymous" type specification in a formal argument list (or as
421: part of a function return type specification). For example:
422:
423: int f (enum { red, green, blue } color);
424:
425: In such cases, we have no name that we can put into the prototype
426: to represent the (anonymous) type. Thus, we have to generate the
427: whole darn type specification. Yuck! */
428:
429: case RECORD_TYPE:
430: if (TYPE_NAME (t))
431: data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
432: else
433: {
434: data_type = "";
435: chain_p = TYPE_FIELDS (t);
436: while (chain_p)
437: {
438: data_type = concat (data_type, gen_decl (chain_p, 0, ansi));
439: chain_p = TREE_CHAIN (chain_p);
440: data_type = concat (data_type, "; ");
441: }
442: data_type = concat3 ("{ ", data_type, "}");
443: }
444: data_type = concat ("struct ", data_type);
445: break;
446:
447: case UNION_TYPE:
448: if (TYPE_NAME (t))
449: data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
450: else
451: {
452: data_type = "";
453: chain_p = TYPE_FIELDS (t);
454: while (chain_p)
455: {
456: data_type = concat (data_type, gen_decl (chain_p, 0, ansi));
457: chain_p = TREE_CHAIN (chain_p);
458: data_type = concat (data_type, "; ");
459: }
460: data_type = concat3 ("{ ", data_type, "}");
461: }
462: data_type = concat ("union ", data_type);
463: break;
464:
465: case ENUMERAL_TYPE:
466: if (TYPE_NAME (t))
467: data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
468: else
469: {
470: data_type = "";
471: chain_p = TYPE_VALUES (t);
472: while (chain_p)
473: {
474: data_type = concat (data_type,
475: IDENTIFIER_POINTER (TREE_PURPOSE (chain_p)));
476: chain_p = TREE_CHAIN (chain_p);
477: if (chain_p)
478: data_type = concat (data_type, ", ");
479: }
480: data_type = concat3 ("{ ", data_type, " }");
481: }
482: data_type = concat ("enum ", data_type);
483: break;
484:
485: case TYPE_DECL:
486: data_type = IDENTIFIER_POINTER (DECL_NAME (t));
487: break;
488:
489: case INTEGER_TYPE:
490: data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
491: /* Normally, `unsigned' is part of the deal. Not so if it comes
492: with `const' or `volatile'. */
493: if (TREE_UNSIGNED (t) && (TYPE_READONLY (t) || TYPE_VOLATILE (t)))
494: data_type = concat ("unsigned ", data_type);
495: break;
496:
497: case REAL_TYPE:
498: data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
499: break;
500:
501: case VOID_TYPE:
502: data_type = "void";
503: break;
504:
505: default:
506: abort ();
507: }
508: }
509: if (TYPE_READONLY (t))
510: ret_val = concat ("const ", ret_val);
511: if (TYPE_VOLATILE (t))
512: ret_val = concat ("volatile ", ret_val);
513: return ret_val;
514: }
515:
516: /* Generate a string (source) representation of an entire entity declaration
517: (using some particular style for function types).
518:
519: The given entity may be either a variable or a function.
520:
521: If the "is_func_definition" parameter is non-zero, assume that the thing
522: we are generating a declaration for is a FUNCTION_DECL node which is
523: associated with a function definition. In this case, we can assume that
524: an attached list of DECL nodes for function formal arguments is present. */
525:
526: static char*
527: gen_decl (decl, is_func_definition, style)
528: tree decl;
529: int is_func_definition;
530: formals_style style;
531: {
532: char* ret_val;
533: char* outer_modifier = "";
534:
535: if (DECL_NAME (decl))
536: ret_val = IDENTIFIER_POINTER (DECL_NAME (decl));
537: else
538: ret_val = "";
539:
540: /* If we are just generating a list of names of formal parameters, we can
541: simply return the formal parameter name (with no typing information
542: attached to it) now. */
543:
544: if (style == k_and_r_names)
545: return ret_val;
546:
547: /* Note that for the declaration of some entity (either a function or a
548: data object, like for instance a parameter) if the entity itself was
549: declared as either const or volatile, then const and volatile properties
550: are associated with just the declaration of the entity, and *not* with
551: the `type' of the entity. Thus, for such declared entities, we have to
552: generate the qualifiers here. */
553:
554: if (TREE_THIS_VOLATILE (decl))
555: ret_val = concat ("volatile ", ret_val);
556: if (TREE_READONLY (decl))
557: ret_val = concat ("const ", ret_val);
558:
559: data_type = "";
560:
561: /* For FUNCTION_DECL nodes, there are two possible cases here. First, if
562: this FUNCTION_DECL node was generated from a function "definition", then
563: we will have a list of DECL_NODE's, one for each of the function's formal
564: parameters. In this case, we can print out not only the types of each
565: formal, but also each formal's name. In the second case, this
566: FUNCTION_DECL node came from an actual function declaration (and *not*
567: a definition). In this case, we do nothing here because the formal
568: argument type-list will be output later, when the "type" of the function
569: is added to the string we are building. Note that the ANSI-style formal
570: parameter list is considered to be a (suffix) part of the "type" of the
571: function. */
572:
573: if (TREE_CODE (decl) == FUNCTION_DECL && is_func_definition)
574: {
575: ret_val = concat (ret_val, gen_formal_list_for_func_def (decl, ansi));
576:
577: /* Since we have already added in the formals list stuff, here we don't
578: add the whole "type" of the function we are considering (which
579: would include its parameter-list info), rather, we only add in
580: the "type" of the "type" of the function, which is really just
581: the return-type of the function (and does not include the parameter
582: list info). */
583:
584: ret_val = gen_type (ret_val, TREE_TYPE (TREE_TYPE (decl)), style);
585: }
586: else
587: ret_val = gen_type (ret_val, TREE_TYPE (decl), style);
588:
589: ret_val = affix_data_type (ret_val);
590:
591: if (TREE_REGDECL (decl))
592: ret_val = concat ("register ", ret_val);
593: if (TREE_PUBLIC (decl))
594: ret_val = concat ("extern ", ret_val);
595: if (TREE_CODE (decl) == FUNCTION_DECL && !TREE_PUBLIC (decl))
596: ret_val = concat ("static ", ret_val);
597:
598: return ret_val;
599: }
600:
601: extern FILE* aux_info_file;
602:
603: /* Generate and write a new line of info to the aux-info (.X) file. This
604: routine is called once for each function declaration, and once for each
605: function definition (even the implicit ones). */
606:
607: void
608: gen_aux_info_record (fndecl, is_definition, is_implicit, is_prototyped)
609: tree fndecl;
610: int is_definition;
611: int is_implicit;
612: int is_prototyped;
613: {
614: if (flag_gen_aux_info)
615: {
616: static int compiled_from_record = 0;
617:
618: /* Each output .X file must have a header line. Write one now if we
619: have not yet done so. */
620:
621: if (! compiled_from_record++)
622: {
623: int size;
624: char *wd;
625: char *value;
626:
627: /* Read the working directory, avoiding arbitrary limit. */
628: size = GUESSPATHLEN;
629: while (1)
630: {
631: wd = (char *) xmalloc (size);
632: value = getcwd (wd, size);
633: if (value != 0 || errno != ERANGE)
634: break;
635: free (wd);
636: size *= 2;
637: }
638:
639: if (value != 0)
640: fprintf (aux_info_file, "/* compiled from: %s */\n", wd);
641: }
642:
643: /* Write the actual line of auxilliary info. */
644:
645: fprintf (aux_info_file, "/* %s:%d:%c%c */ %s;",
646: DECL_SOURCE_FILE (fndecl),
647: DECL_SOURCE_LINE (fndecl),
648: (is_implicit) ? 'I' : (is_prototyped) ? 'N' : 'O',
649: (is_definition) ? 'F' : 'C',
650: gen_decl (fndecl, is_definition, ansi));
651:
652: /* If this is an explicit function declaration, we need to also write
653: out an old-style (i.e. K&R) function header, just in case the user
654: wants to run unprotoize. */
655:
656: if (is_definition)
657: {
658: fprintf (aux_info_file, " /*%s %s*/",
659: gen_formal_list_for_func_def (fndecl, k_and_r_names),
660: gen_formal_list_for_func_def (fndecl, k_and_r_decls));
661: }
662:
663: fprintf (aux_info_file, "\n");
664: }
665: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.