[8833] | 1 | /* Generate information regarding function declarations and definitions based |
---|
| 2 | on information stored in GCC's tree structure. This code implements the |
---|
| 3 | -aux-info option. |
---|
| 4 | Copyright (C) 1989, 1991, 1994, 1995 Free Software Foundation, Inc. |
---|
| 5 | Contributed by Ron Guilmette (rfg@segfault.us.com). |
---|
| 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 |
---|
| 21 | the Free Software Foundation, 59 Temple Place - Suite 330, |
---|
| 22 | Boston, MA 02111-1307, USA. */ |
---|
| 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 | { |
---|
| 128 | if (!strncmp (p, "volatile ", 9)) |
---|
| 129 | { |
---|
| 130 | p += 9; |
---|
| 131 | continue; |
---|
| 132 | } |
---|
| 133 | if (!strncmp (p, "const ", 6)) |
---|
| 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 | |
---|
| 212 | This "something nice" should be something that is still valid (when |
---|
| 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 | |
---|
| 217 | The string chosen here is a comment with question marks in it. */ |
---|
| 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: |
---|
| 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 | } |
---|
| 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 | |
---|
| 495 | case ERROR_MARK: |
---|
| 496 | data_type = "[ERROR]"; |
---|
| 497 | break; |
---|
| 498 | |
---|
| 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 | |
---|
| 584 | if (DECL_REGISTER (decl)) |
---|
| 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 | { |
---|
| 616 | /* The first line tells which directory file names are relative to. |
---|
| 617 | Currently, -aux-info works only for files in the working |
---|
| 618 | directory, so just use a `.' as a placeholder for now. */ |
---|
| 619 | fprintf (aux_info_file, "/* compiled from: . */\n"); |
---|
| 620 | } |
---|
| 621 | |
---|
| 622 | /* Write the actual line of auxiliary info. */ |
---|
| 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 | } |
---|