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