1 /* Protoize program - Original version by Ron Guilmette (rfg@segfault.us.com).
2 Copyright (C) 1989, 92-98, 1999 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
32 /* Include getopt.h for the sake of getopt_long. */
35 /* Macro to see if the path elements match. */
36 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
37 #define IS_SAME_PATH_CHAR(a,b) (toupper (a) == toupper (b))
39 #define IS_SAME_PATH_CHAR(a,b) ((a) == (b))
42 /* Macro to see if the paths match. */
43 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
44 #define IS_SAME_PATH(a,b) (strcasecmp (a, b) == 0)
46 #define IS_SAME_PATH(a,b) (strcmp (a, b) == 0)
49 /* Suffix for renamed C++ files. */
50 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
51 #define CPLUS_FILE_SUFFIX "cc"
53 #define CPLUS_FILE_SUFFIX "C"
56 extern char *version_string
;
58 static void usage
PARAMS ((void)) ATTRIBUTE_NORETURN
;
59 static void aux_info_corrupted
PARAMS ((void)) ATTRIBUTE_NORETURN
;
60 static void declare_source_confusing
PARAMS ((const char *)) ATTRIBUTE_NORETURN
;
61 static const char *shortpath
PARAMS ((const char *, const char *));
62 extern void fancy_abort
PARAMS ((void)) ATTRIBUTE_NORETURN
;
63 static void notice
PARAMS ((const char *, ...)) ATTRIBUTE_PRINTF_1
;
64 static char *savestring
PARAMS ((const char *, unsigned int));
65 static char *dupnstr
PARAMS ((const char *, size_t));
66 static const char *substr
PARAMS ((const char *, const char * const));
67 static int safe_read
PARAMS ((int, PTR
, int));
68 static void safe_write
PARAMS ((int, PTR
, int, const char *));
69 static void save_pointers
PARAMS ((void));
70 static void restore_pointers
PARAMS ((void));
71 static int is_id_char
PARAMS ((int));
72 static int in_system_include_dir
PARAMS ((const char *));
73 static int directory_specified_p
PARAMS ((const char *));
74 static int file_excluded_p
PARAMS ((const char *));
75 static char *unexpand_if_needed
PARAMS ((const char *));
76 static char *abspath
PARAMS ((const char *, const char *));
77 static int is_abspath
PARAMS ((const char *));
78 static void check_aux_info
PARAMS ((int));
79 static const char *find_corresponding_lparen
PARAMS ((const char *));
80 static int referenced_file_is_newer
PARAMS ((const char *, time_t));
81 static void save_def_or_dec
PARAMS ((const char *, int));
82 static void munge_compile_params
PARAMS ((const char *));
83 static int gen_aux_info_file
PARAMS ((const char *));
84 static void process_aux_info_file
PARAMS ((const char *, int, int));
85 static int identify_lineno
PARAMS ((const char *));
86 static void check_source
PARAMS ((int, const char *));
87 static const char *seek_to_line
PARAMS ((int));
88 static const char *forward_to_next_token_char
PARAMS ((const char *));
89 static void output_bytes
PARAMS ((const char *, size_t));
90 static void output_string
PARAMS ((const char *));
91 static void output_up_to
PARAMS ((const char *));
92 static int other_variable_style_function
PARAMS ((const char *));
93 static const char *find_rightmost_formals_list
PARAMS ((const char *));
94 static void do_cleaning
PARAMS ((char *, const char *));
95 static const char *careful_find_l_paren
PARAMS ((const char *));
96 static void do_processing
PARAMS ((void));
98 /* Look for these where the `const' qualifier is intentionally cast aside. */
101 /* Define a default place to find the SYSCALLS.X file. */
105 #ifndef STANDARD_EXEC_PREFIX
106 #define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-lib/"
107 #endif /* !defined STANDARD_EXEC_PREFIX */
109 static const char * const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
110 static const char * const target_machine
= DEFAULT_TARGET_MACHINE
;
111 static const char * const target_version
= DEFAULT_TARGET_VERSION
;
113 #ifndef GET_ENV_PATH_LIST
114 #define GET_ENV_PATH_LIST(VAR,NAME) do { (VAR) = getenv (NAME); } while (0)
117 #endif /* !defined (UNPROTOIZE) */
119 /* Suffix of aux_info files. */
121 static const char * const aux_info_suffix
= ".X";
123 /* String to attach to filenames for saved versions of original files. */
125 static const char * const save_suffix
= ".save";
127 /* String to attach to C filenames renamed to C++. */
129 static const char * const cplus_suffix
= CPLUS_FILE_SUFFIX
;
133 /* File name of the file which contains descriptions of standard system
134 routines. Note that we never actually do anything with this file per se,
135 but we do read in its corresponding aux_info file. */
137 static const char syscalls_filename
[] = "SYSCALLS.c";
139 /* Default place to find the above file. */
141 static const char * default_syscalls_dir
;
143 /* Variable to hold the complete absolutized filename of the SYSCALLS.c.X
146 static char * syscalls_absolute_filename
;
148 #endif /* !defined (UNPROTOIZE) */
150 /* Type of the structure that holds information about macro unexpansions. */
152 struct unexpansion_struct
{
153 const char *expanded
;
154 const char *contracted
;
156 typedef struct unexpansion_struct unexpansion
;
158 /* A table of conversions that may need to be made for some (stupid) older
159 operating systems where these types are preprocessor macros rather than
160 typedefs (as they really ought to be).
162 WARNING: The contracted forms must be as small (or smaller) as the
163 expanded forms, or else havoc will ensue. */
165 static const unexpansion unexpansions
[] = {
166 { "struct _iobuf", "FILE" },
170 /* The number of "primary" slots in the hash tables for filenames and for
171 function names. This can be as big or as small as you like, except that
172 it must be a power of two. */
174 #define HASH_TABLE_SIZE (1 << 9)
176 /* Bit mask to use when computing hash values. */
178 static const int hash_mask
= (HASH_TABLE_SIZE
- 1);
180 /* Make a table of default system include directories
181 just as it is done in cccp.c. */
183 #ifndef STANDARD_INCLUDE_DIR
184 #define STANDARD_INCLUDE_DIR "/usr/include"
187 #ifndef LOCAL_INCLUDE_DIR
188 #define LOCAL_INCLUDE_DIR "/usr/local/include"
191 struct default_include
{ const char *fname
;
192 const char *component
;
193 int x1
, x2
; } include_defaults
[]
194 #ifdef INCLUDE_DEFAULTS
198 /* Pick up GNU C++ specific include files. */
199 { GPLUSPLUS_INCLUDE_DIR
, "G++", 1, 1 },
201 /* This is the dir for fixincludes. Put it just before
202 the files that we fix. */
203 { GCC_INCLUDE_DIR
, "GCC", 0, 0 },
204 /* For cross-compilation, this dir name is generated
205 automatically in Makefile.in. */
206 { CROSS_INCLUDE_DIR
, 0, 0, 0 },
207 /* This is another place that the target system's headers might be. */
208 { TOOL_INCLUDE_DIR
, "BINUTILS", 0, 0 },
209 #else /* not CROSS_COMPILE */
210 /* This should be /use/local/include and should come before
211 the fixincludes-fixed header files. */
212 { LOCAL_INCLUDE_DIR
, 0, 0, 1 },
213 /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
214 Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h. */
215 { TOOL_INCLUDE_DIR
, "BINUTILS", 0, 0 },
216 /* This is the dir for fixincludes. Put it just before
217 the files that we fix. */
218 { GCC_INCLUDE_DIR
, "GCC", 0, 0 },
219 /* Some systems have an extra dir of include files. */
220 #ifdef SYSTEM_INCLUDE_DIR
221 { SYSTEM_INCLUDE_DIR
, 0, 0, 0 },
223 { STANDARD_INCLUDE_DIR
, 0, 0, 0},
224 #endif /* not CROSS_COMPILE */
227 #endif /* no INCLUDE_DEFAULTS */
229 /* Datatype for lists of directories or filenames. */
233 struct string_list
*next
;
236 static struct string_list
*string_list_cons
PARAMS ((const char *,
237 struct string_list
*));
239 /* List of directories in which files should be converted. */
241 struct string_list
*directory_list
;
243 /* List of file names which should not be converted.
244 A file is excluded if the end of its name, following a /,
245 matches one of the names in this list. */
247 struct string_list
*exclude_list
;
249 /* The name of the other style of variable-number-of-parameters functions
250 (i.e. the style that we want to leave unconverted because we don't yet
251 know how to convert them to this style. This string is used in warning
254 /* Also define here the string that we can search for in the parameter lists
255 taken from the .X files which will unambiguously indicate that we have
256 found a varargs style function. */
259 static const char * const other_var_style
= "stdarg";
260 #else /* !defined (UNPROTOIZE) */
261 static const char * const other_var_style
= "varargs";
262 /* Note that this is a string containing the expansion of va_alist.
263 But in `main' we discard all but the first token. */
264 static const char *varargs_style_indicator
= STRINGIFY (va_alist
);
265 #endif /* !defined (UNPROTOIZE) */
267 /* The following two types are used to create hash tables. In this program,
268 there are two hash tables which are used to store and quickly lookup two
269 different classes of strings. The first type of strings stored in the
270 first hash table are absolute filenames of files which protoize needs to
271 know about. The second type of strings (stored in the second hash table)
272 are function names. It is this second class of strings which really
273 inspired the use of the hash tables, because there may be a lot of them. */
275 typedef struct hash_table_entry_struct hash_table_entry
;
277 /* Do some typedefs so that we don't have to write "struct" so often. */
279 typedef struct def_dec_info_struct def_dec_info
;
280 typedef struct file_info_struct file_info
;
281 typedef struct f_list_chain_item_struct f_list_chain_item
;
284 static int is_syscalls_file
PARAMS ((const file_info
*));
285 static void rename_c_file
PARAMS ((const hash_table_entry
*));
286 static const def_dec_info
*find_extern_def
PARAMS ((const def_dec_info
*,
287 const def_dec_info
*));
288 static const def_dec_info
*find_static_definition
PARAMS ((const def_dec_info
*));
289 static void connect_defs_and_decs
PARAMS ((const hash_table_entry
*));
290 static void add_local_decl
PARAMS ((const def_dec_info
*, const char *));
291 static void add_global_decls
PARAMS ((const file_info
*, const char *));
292 #endif /* ! UNPROTOIZE */
293 static int needs_to_be_converted
PARAMS ((const file_info
*));
294 static void visit_each_hash_node
PARAMS ((const hash_table_entry
*,
295 void (*)(const hash_table_entry
*)));
296 static hash_table_entry
*add_symbol
PARAMS ((hash_table_entry
*, const char *));
297 static hash_table_entry
*lookup
PARAMS ((hash_table_entry
*, const char *));
298 static void free_def_dec
PARAMS ((def_dec_info
*));
299 static file_info
*find_file
PARAMS ((const char *, int));
300 static void reverse_def_dec_list
PARAMS ((const hash_table_entry
*));
301 static void edit_fn_declaration
PARAMS ((const def_dec_info
*, const char *));
302 static int edit_formals_lists
PARAMS ((const char *, unsigned int,
303 const def_dec_info
*));
304 static void edit_fn_definition
PARAMS ((const def_dec_info
*, const char *));
305 static void scan_for_missed_items
PARAMS ((const file_info
*));
306 static void edit_file
PARAMS ((const hash_table_entry
*));
308 /* In the struct below, note that the "_info" field has two different uses
309 depending on the type of hash table we are in (i.e. either the filenames
310 hash table or the function names hash table). In the filenames hash table
311 the info fields of the entries point to the file_info struct which is
312 associated with each filename (1 per filename). In the function names
313 hash table, the info field points to the head of a singly linked list of
314 def_dec_info entries which are all defs or decs of the function whose
315 name is pointed to by the "symbol" field. Keeping all of the defs/decs
316 for a given function name on a special list specifically for that function
317 name makes it quick and easy to find out all of the important information
318 about a given (named) function. */
320 struct hash_table_entry_struct
{
321 hash_table_entry
* hash_next
; /* -> to secondary entries */
322 const char * symbol
; /* -> to the hashed string */
324 const def_dec_info
* _ddip
;
328 #define ddip _info._ddip
329 #define fip _info._fip
331 /* Define a type specifically for our two hash tables. */
333 typedef hash_table_entry hash_table
[HASH_TABLE_SIZE
];
335 /* The following struct holds all of the important information about any
336 single filename (e.g. file) which we need to know about. */
338 struct file_info_struct
{
339 const hash_table_entry
* hash_entry
; /* -> to associated hash entry */
340 const def_dec_info
* defs_decs
; /* -> to chain of defs/decs */
341 time_t mtime
; /* Time of last modification. */
344 /* Due to the possibility that functions may return pointers to functions,
345 (which may themselves have their own parameter lists) and due to the
346 fact that returned pointers-to-functions may be of type "pointer-to-
347 function-returning-pointer-to-function" (ad nauseum) we have to keep
348 an entire chain of ANSI style formal parameter lists for each function.
350 Normally, for any given function, there will only be one formals list
351 on the chain, but you never know.
353 Note that the head of each chain of formals lists is pointed to by the
354 `f_list_chain' field of the corresponding def_dec_info record.
356 For any given chain, the item at the head of the chain is the *leftmost*
357 parameter list seen in the actual C language function declaration. If
358 there are other members of the chain, then these are linked in left-to-right
359 order from the head of the chain. */
361 struct f_list_chain_item_struct
{
362 const f_list_chain_item
* chain_next
; /* -> to next item on chain */
363 const char * formals_list
; /* -> to formals list string */
366 /* The following struct holds all of the important information about any
367 single function definition or declaration which we need to know about.
368 Note that for unprotoize we don't need to know very much because we
369 never even create records for stuff that we don't intend to convert
370 (like for instance defs and decs which are already in old K&R format
371 and "implicit" function declarations). */
373 struct def_dec_info_struct
{
374 const def_dec_info
* next_in_file
; /* -> to rest of chain for file */
375 file_info
* file
; /* -> file_info for containing file */
376 int line
; /* source line number of def/dec */
377 const char * ansi_decl
; /* -> left end of ansi decl */
378 hash_table_entry
* hash_entry
; /* -> hash entry for function name */
379 unsigned int is_func_def
; /* = 0 means this is a declaration */
380 const def_dec_info
* next_for_func
; /* -> to rest of chain for func name */
381 unsigned int f_list_count
; /* count of formals lists we expect */
382 char prototyped
; /* = 0 means already prototyped */
384 const f_list_chain_item
* f_list_chain
; /* -> chain of formals lists */
385 const def_dec_info
* definition
; /* -> def/dec containing related def */
386 char is_static
; /* = 0 means visibility is "extern" */
387 char is_implicit
; /* != 0 for implicit func decl's */
388 char written
; /* != 0 means written for implicit */
389 #else /* !defined (UNPROTOIZE) */
390 const char * formal_names
; /* -> to list of names of formals */
391 const char * formal_decls
; /* -> to string of formal declarations */
392 #endif /* !defined (UNPROTOIZE) */
395 /* Pointer to the tail component of the filename by which this program was
396 invoked. Used everywhere in error and warning messages. */
398 static const char *pname
;
400 /* Error counter. Will be non-zero if we should give up at the next convenient
403 static int errors
= 0;
406 /* ??? These comments should say what the flag mean as well as the options
409 /* File name to use for running gcc. Allows GCC 2 to be named
410 something other than gcc. */
411 static const char *compiler_file_name
= "gcc";
413 static int version_flag
= 0; /* Print our version number. */
414 static int quiet_flag
= 0; /* Don't print messages normally. */
415 static int nochange_flag
= 0; /* Don't convert, just say what files
416 we would have converted. */
417 static int nosave_flag
= 0; /* Don't save the old version. */
418 static int keep_flag
= 0; /* Don't delete the .X files. */
419 static const char ** compile_params
= 0; /* Option string for gcc. */
421 static const char *indent_string
= " "; /* Indentation for newly
422 inserted parm decls. */
423 #else /* !defined (UNPROTOIZE) */
424 static int local_flag
= 0; /* Insert new local decls (when?). */
425 static int global_flag
= 0; /* set by -g option */
426 static int cplusplus_flag
= 0; /* Rename converted files to *.C. */
427 static const char *nondefault_syscalls_dir
= 0; /* Dir to look for
429 #endif /* !defined (UNPROTOIZE) */
431 /* An index into the compile_params array where we should insert the source
432 file name when we are ready to exec the C compiler. A zero value indicates
433 that we have not yet called munge_compile_params. */
435 static int input_file_name_index
= 0;
437 /* An index into the compile_params array where we should insert the filename
438 for the aux info file, when we run the C compiler. */
439 static int aux_info_file_name_index
= 0;
441 /* Count of command line arguments which were "filename" arguments. */
443 static int n_base_source_files
= 0;
445 /* Points to a malloc'ed list of pointers to all of the filenames of base
446 source files which were specified on the command line. */
448 static const char **base_source_filenames
;
450 /* Line number of the line within the current aux_info file that we
451 are currently processing. Used for error messages in case the prototypes
452 info file is corrupted somehow. */
454 static int current_aux_info_lineno
;
456 /* Pointer to the name of the source file currently being converted. */
458 static const char *convert_filename
;
460 /* Pointer to relative root string (taken from aux_info file) which indicates
461 where directory the user was in when he did the compilation step that
462 produced the containing aux_info file. */
464 static const char *invocation_filename
;
466 /* Pointer to the base of the input buffer that holds the original text for the
467 source file currently being converted. */
469 static const char *orig_text_base
;
471 /* Pointer to the byte just beyond the end of the input buffer that holds the
472 original text for the source file currently being converted. */
474 static const char *orig_text_limit
;
476 /* Pointer to the base of the input buffer that holds the cleaned text for the
477 source file currently being converted. */
479 static const char *clean_text_base
;
481 /* Pointer to the byte just beyond the end of the input buffer that holds the
482 cleaned text for the source file currently being converted. */
484 static const char *clean_text_limit
;
486 /* Pointer to the last byte in the cleaned text buffer that we have already
487 (virtually) copied to the output buffer (or decided to ignore). */
489 static const char * clean_read_ptr
;
491 /* Pointer to the base of the output buffer that holds the replacement text
492 for the source file currently being converted. */
494 static char *repl_text_base
;
496 /* Pointer to the byte just beyond the end of the output buffer that holds the
497 replacement text for the source file currently being converted. */
499 static char *repl_text_limit
;
501 /* Pointer to the last byte which has been stored into the output buffer.
502 The next byte to be stored should be stored just past where this points
505 static char * repl_write_ptr
;
507 /* Pointer into the cleaned text buffer for the source file we are currently
508 converting. This points to the first character of the line that we last
509 did a "seek_to_line" to (see below). */
511 static const char *last_known_line_start
;
513 /* Number of the line (in the cleaned text buffer) that we last did a
514 "seek_to_line" to. Will be one if we just read a new source file
515 into the cleaned text buffer. */
517 static int last_known_line_number
;
519 /* The filenames hash table. */
521 static hash_table filename_primary
;
523 /* The function names hash table. */
525 static hash_table function_name_primary
;
527 /* The place to keep the recovery address which is used only in cases where
528 we get hopelessly confused by something in the cleaned original text. */
530 static jmp_buf source_confusion_recovery
;
532 /* A pointer to the current directory filename (used by abspath). */
534 static char *cwd_buffer
;
536 /* A place to save the read pointer until we are sure that an individual
537 attempt at editing will succeed. */
539 static const char * saved_clean_read_ptr
;
541 /* A place to save the write pointer until we are sure that an individual
542 attempt at editing will succeed. */
544 static char * saved_repl_write_ptr
;
546 /* Translate and output an error message. */
548 notice
VPARAMS ((const char *msgid
, ...))
550 #ifndef ANSI_PROTOTYPES
555 VA_START (ap
, msgid
);
557 #ifndef ANSI_PROTOTYPES
558 msgid
= va_arg (ap
, const char *);
561 vfprintf (stderr
, _(msgid
), ap
);
566 /* Make a copy of a string INPUT with size SIZE. */
569 savestring (input
, size
)
573 char *output
= (char *) xmalloc (size
+ 1);
574 strcpy (output
, input
);
578 /* More 'friendly' abort that prints the line and file.
579 config.h can #define abort fancy_abort if you like that sort of thing. */
584 notice ("%s: internal abort\n", pname
);
585 exit (FATAL_EXIT_CODE
);
588 /* Make a duplicate of the first N bytes of a given string in a newly
596 char *ret_val
= (char *) xmalloc (n
+ 1);
598 strncpy (ret_val
, s
, n
);
603 /* Return a pointer to the first occurrence of s2 within s1 or NULL if s2
604 does not occur within s1. Assume neither s1 nor s2 are null pointers. */
609 const char *const s2
;
617 for (p1
= s1
, p2
= s2
; (c
= *p2
); p1
++, p2
++)
627 /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
628 retrying if necessary. Return the actual number of bytes read. */
631 safe_read (desc
, ptr
, len
)
638 int nchars
= read (desc
, ptr
, left
);
649 /* Arithmetic on void pointers is a gcc extention. */
650 ptr
= (char *) ptr
+ nchars
;
656 /* Write LEN bytes at PTR to descriptor DESC,
657 retrying if necessary, and treating any real error as fatal. */
660 safe_write (desc
, ptr
, len
, out_fname
)
664 const char *out_fname
;
667 int written
= write (desc
, ptr
, len
);
670 int errno_val
= errno
;
672 if (errno_val
== EINTR
)
675 notice ("%s: error writing file `%s': %s\n",
676 pname
, shortpath (NULL
, out_fname
), xstrerror (errno_val
));
679 /* Arithmetic on void pointers is a gcc extention. */
680 ptr
= (char *) ptr
+ written
;
685 /* Get setup to recover in case the edit we are about to do goes awry. */
690 saved_clean_read_ptr
= clean_read_ptr
;
691 saved_repl_write_ptr
= repl_write_ptr
;
694 /* Call this routine to recover our previous state whenever something looks
695 too confusing in the source code we are trying to edit. */
700 clean_read_ptr
= saved_clean_read_ptr
;
701 repl_write_ptr
= saved_repl_write_ptr
;
704 /* Return true if the given character is a valid identifier character. */
710 return (ISALNUM (ch
) || (ch
== '_') || (ch
== '$'));
713 /* Give a message indicating the proper way to invoke this program and then
714 exit with non-zero status. */
720 notice ("%s: usage '%s [ -VqfnkN ] [ -i <istring> ] [ filename ... ]'\n",
722 #else /* !defined (UNPROTOIZE) */
723 notice ("%s: usage '%s [ -VqfnkNlgC ] [ -B <dirname> ] [ filename ... ]'\n",
725 #endif /* !defined (UNPROTOIZE) */
726 exit (FATAL_EXIT_CODE
);
729 /* Return true if the given filename (assumed to be an absolute filename)
730 designates a file residing anywhere beneath any one of the "system"
731 include directories. */
734 in_system_include_dir (path
)
737 struct default_include
*p
;
739 if (! is_abspath (path
))
740 abort (); /* Must be an absolutized filename. */
742 for (p
= include_defaults
; p
->fname
; p
++)
743 if (!strncmp (path
, p
->fname
, strlen (p
->fname
))
744 && IS_DIR_SEPARATOR (path
[strlen (p
->fname
)]))
750 /* Return true if the given filename designates a file that the user has
751 read access to and for which the user has write access to the containing
755 file_could_be_converted (const char *path
)
757 char *const dir_name
= (char *) alloca (strlen (path
) + 1);
759 if (access (path
, R_OK
))
763 char *dir_last_slash
;
765 strcpy (dir_name
, path
);
766 dir_last_slash
= strrchr (dir_name
, DIR_SEPARATOR
);
767 #ifdef DIR_SEPARATOR_2
771 slash
= strrchr (dir_last_slash
? dir_last_slash
: dir_name
,
774 dir_last_slash
= slash
;
778 *dir_last_slash
= '\0';
780 abort (); /* Should have been an absolutized filename. */
783 if (access (path
, W_OK
))
789 /* Return true if the given filename designates a file that we are allowed
790 to modify. Files which we should not attempt to modify are (a) "system"
791 include files, and (b) files which the user doesn't have write access to,
792 and (c) files which reside in directories which the user doesn't have
793 write access to. Unless requested to be quiet, give warnings about
794 files that we will not try to convert for one reason or another. An
795 exception is made for "system" include files, which we never try to
796 convert and for which we don't issue the usual warnings. */
799 file_normally_convertible (const char *path
)
801 char *const dir_name
= alloca (strlen (path
) + 1);
803 if (in_system_include_dir (path
))
807 char *dir_last_slash
;
809 strcpy (dir_name
, path
);
810 dir_last_slash
= strrchr (dir_name
, DIR_SEPARATOR
);
811 #ifdef DIR_SEPARATOR_2
815 slash
= strrchr (dir_last_slash
? dir_last_slash
: dir_name
,
818 dir_last_slash
= slash
;
822 *dir_last_slash
= '\0';
824 abort (); /* Should have been an absolutized filename. */
827 if (access (path
, R_OK
))
830 notice ("%s: warning: no read access for file `%s'\n",
831 pname
, shortpath (NULL
, path
));
835 if (access (path
, W_OK
))
838 notice ("%s: warning: no write access for file `%s'\n",
839 pname
, shortpath (NULL
, path
));
843 if (access (dir_name
, W_OK
))
846 notice ("%s: warning: no write access for dir containing `%s'\n",
847 pname
, shortpath (NULL
, path
));
857 /* Return true if the given file_info struct refers to the special SYSCALLS.c.X
858 file. Return false otherwise. */
861 is_syscalls_file (fi_p
)
862 const file_info
*fi_p
;
864 char const *f
= fi_p
->hash_entry
->symbol
;
865 size_t fl
= strlen (f
), sysl
= sizeof (syscalls_filename
) - 1;
866 return sysl
<= fl
&& strcmp (f
+ fl
- sysl
, syscalls_filename
) == 0;
869 #endif /* !defined (UNPROTOIZE) */
871 /* Check to see if this file will need to have anything done to it on this
872 run. If there is nothing in the given file which both needs conversion
873 and for which we have the necessary stuff to do the conversion, return
874 false. Otherwise, return true.
876 Note that (for protoize) it is only valid to call this function *after*
877 the connections between declarations and definitions have all been made
878 by connect_defs_and_decs. */
881 needs_to_be_converted (file_p
)
882 const file_info
*file_p
;
884 const def_dec_info
*ddp
;
888 if (is_syscalls_file (file_p
))
891 #endif /* !defined (UNPROTOIZE) */
893 for (ddp
= file_p
->defs_decs
; ddp
; ddp
= ddp
->next_in_file
)
899 /* ... and if we a protoizing and this function is in old style ... */
901 /* ... and if this a definition or is a decl with an associated def ... */
902 && (ddp
->is_func_def
|| (!ddp
->is_func_def
&& ddp
->definition
))
904 #else /* defined (UNPROTOIZE) */
906 /* ... and if we are unprotoizing and this function is in new style ... */
909 #endif /* defined (UNPROTOIZE) */
911 /* ... then the containing file needs converting. */
916 /* Return 1 if the file name NAME is in a directory
917 that should be converted. */
920 directory_specified_p (name
)
923 struct string_list
*p
;
925 for (p
= directory_list
; p
; p
= p
->next
)
926 if (!strncmp (name
, p
->name
, strlen (p
->name
))
927 && IS_DIR_SEPARATOR (name
[strlen (p
->name
)]))
929 const char *q
= name
+ strlen (p
->name
) + 1;
931 /* If there are more slashes, it's in a subdir, so
932 this match doesn't count. */
934 if (IS_DIR_SEPARATOR (*(q
-1)))
944 /* Return 1 if the file named NAME should be excluded from conversion. */
947 file_excluded_p (name
)
950 struct string_list
*p
;
951 int len
= strlen (name
);
953 for (p
= exclude_list
; p
; p
= p
->next
)
954 if (!strcmp (name
+ len
- strlen (p
->name
), p
->name
)
955 && IS_DIR_SEPARATOR (name
[len
- strlen (p
->name
) - 1]))
961 /* Construct a new element of a string_list.
962 STRING is the new element value, and REST holds the remaining elements. */
964 static struct string_list
*
965 string_list_cons (string
, rest
)
967 struct string_list
*rest
;
969 struct string_list
*temp
970 = (struct string_list
*) xmalloc (sizeof (struct string_list
));
977 /* ??? The GNU convention for mentioning function args in its comments
978 is to capitalize them. So change "hash_tab_p" to HASH_TAB_P below.
979 Likewise for all the other functions. */
981 /* Given a hash table, apply some function to each node in the table. The
982 table to traverse is given as the "hash_tab_p" argument, and the
983 function to be applied to each node in the table is given as "func"
987 visit_each_hash_node (hash_tab_p
, func
)
988 const hash_table_entry
*hash_tab_p
;
989 void (*func
) PARAMS ((const hash_table_entry
*));
991 const hash_table_entry
*primary
;
993 for (primary
= hash_tab_p
; primary
< &hash_tab_p
[HASH_TABLE_SIZE
]; primary
++)
996 hash_table_entry
*second
;
999 for (second
= primary
->hash_next
; second
; second
= second
->hash_next
)
1004 /* Initialize all of the fields of a new hash table entry, pointed
1005 to by the "p" parameter. Note that the space to hold the entry
1006 is assumed to have already been allocated before this routine is
1009 static hash_table_entry
*
1011 hash_table_entry
*p
;
1014 p
->hash_next
= NULL
;
1015 p
->symbol
= xstrdup (s
);
1021 /* Look for a particular function name or filename in the particular
1022 hash table indicated by "hash_tab_p". If the name is not in the
1023 given hash table, add it. Either way, return a pointer to the
1024 hash table entry for the given name. */
1026 static hash_table_entry
*
1027 lookup (hash_tab_p
, search_symbol
)
1028 hash_table_entry
*hash_tab_p
;
1029 const char *search_symbol
;
1032 const char *search_symbol_char_p
= search_symbol
;
1033 hash_table_entry
*p
;
1035 while (*search_symbol_char_p
)
1036 hash_value
+= *search_symbol_char_p
++;
1037 hash_value
&= hash_mask
;
1038 p
= &hash_tab_p
[hash_value
];
1040 return add_symbol (p
, search_symbol
);
1041 if (!strcmp (p
->symbol
, search_symbol
))
1043 while (p
->hash_next
)
1046 if (!strcmp (p
->symbol
, search_symbol
))
1049 p
->hash_next
= (hash_table_entry
*) xmalloc (sizeof (hash_table_entry
));
1051 return add_symbol (p
, search_symbol
);
1054 /* Throw a def/dec record on the junk heap.
1056 Also, since we are not using this record anymore, free up all of the
1057 stuff it pointed to. */
1063 free ((NONCONST PTR
) p
->ansi_decl
);
1067 const f_list_chain_item
* curr
;
1068 const f_list_chain_item
* next
;
1070 for (curr
= p
->f_list_chain
; curr
; curr
= next
)
1072 next
= curr
->chain_next
;
1073 free ((NONCONST PTR
) curr
);
1076 #endif /* !defined (UNPROTOIZE) */
1081 /* Unexpand as many macro symbol as we can find.
1083 If the given line must be unexpanded, make a copy of it in the heap and
1084 return a pointer to the unexpanded copy. Otherwise return NULL. */
1087 unexpand_if_needed (aux_info_line
)
1088 const char *aux_info_line
;
1090 static char *line_buf
= 0;
1091 static int line_buf_size
= 0;
1092 const unexpansion
*unexp_p
;
1093 int got_unexpanded
= 0;
1095 char *copy_p
= line_buf
;
1099 line_buf_size
= 1024;
1100 line_buf
= (char *) xmalloc (line_buf_size
);
1105 /* Make a copy of the input string in line_buf, expanding as necessary. */
1107 for (s
= aux_info_line
; *s
!= '\n'; )
1109 for (unexp_p
= unexpansions
; unexp_p
->expanded
; unexp_p
++)
1111 const char *in_p
= unexp_p
->expanded
;
1112 size_t len
= strlen (in_p
);
1114 if (*s
== *in_p
&& !strncmp (s
, in_p
, len
) && !is_id_char (s
[len
]))
1116 int size
= strlen (unexp_p
->contracted
);
1118 if (copy_p
+ size
- line_buf
>= line_buf_size
)
1120 int offset
= copy_p
- line_buf
;
1122 line_buf_size
+= size
;
1123 line_buf
= (char *) xrealloc (line_buf
, line_buf_size
);
1124 copy_p
= line_buf
+ offset
;
1126 strcpy (copy_p
, unexp_p
->contracted
);
1129 /* Assume the there will not be another replacement required
1130 within the text just replaced. */
1133 goto continue_outer
;
1136 if (copy_p
- line_buf
== line_buf_size
)
1138 int offset
= copy_p
- line_buf
;
1140 line_buf
= (char *) xrealloc (line_buf
, line_buf_size
);
1141 copy_p
= line_buf
+ offset
;
1146 if (copy_p
+ 2 - line_buf
>= line_buf_size
)
1148 int offset
= copy_p
- line_buf
;
1150 line_buf
= (char *) xrealloc (line_buf
, line_buf_size
);
1151 copy_p
= line_buf
+ offset
;
1156 return (got_unexpanded
? savestring (line_buf
, copy_p
- line_buf
) : 0);
1159 /* Return 1 if pathname is absolute. */
1165 return (IS_DIR_SEPARATOR (path
[0])
1166 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1167 /* Check for disk name on MS-DOS-based systems. */
1168 || (path
[0] && path
[1] == ':' && IS_DIR_SEPARATOR (path
[2]))
1173 /* Return the absolutized filename for the given relative
1174 filename. Note that if that filename is already absolute, it may
1175 still be returned in a modified form because this routine also
1176 eliminates redundant slashes and single dots and eliminates double
1177 dots to get a shortest possible filename from the given input
1178 filename. The absolutization of relative filenames is made by
1179 assuming that the given filename is to be taken as relative to
1180 the first argument (cwd) or to the current directory if cwd is
1184 abspath (cwd
, rel_filename
)
1186 const char *rel_filename
;
1188 /* Setup the current working directory as needed. */
1189 const char *cwd2
= (cwd
) ? cwd
: cwd_buffer
;
1190 char *const abs_buffer
1191 = (char *) alloca (strlen (cwd2
) + strlen (rel_filename
) + 2);
1192 char *endp
= abs_buffer
;
1195 /* Copy the filename (possibly preceded by the current working
1196 directory name) into the absolutization buffer. */
1201 if (! is_abspath (rel_filename
))
1204 while ((*endp
++ = *src_p
++))
1206 *(endp
-1) = DIR_SEPARATOR
; /* overwrite null */
1208 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1209 else if (IS_DIR_SEPARATOR (rel_filename
[0]))
1211 /* A path starting with a directory separator is considered absolute
1212 for dos based filesystems, but it's really not -- it's just the
1213 convention used throughout GCC and it works. However, in this
1214 case, we still need to prepend the drive spec from cwd_buffer. */
1219 src_p
= rel_filename
;
1220 while ((*endp
++ = *src_p
++))
1224 /* Now make a copy of abs_buffer into abs_buffer, shortening the
1225 filename (by taking out slashes and dots) as we go. */
1227 outp
= inp
= abs_buffer
;
1228 *outp
++ = *inp
++; /* copy first slash */
1229 #if defined (apollo) || defined (_WIN32) || defined (__INTERIX)
1230 if (IS_DIR_SEPARATOR (inp
[0]))
1231 *outp
++ = *inp
++; /* copy second slash */
1237 else if (IS_DIR_SEPARATOR (inp
[0]) && IS_DIR_SEPARATOR (outp
[-1]))
1242 else if (inp
[0] == '.' && IS_DIR_SEPARATOR (outp
[-1]))
1246 else if (IS_DIR_SEPARATOR (inp
[1]))
1251 else if ((inp
[1] == '.') && (inp
[2] == 0
1252 || IS_DIR_SEPARATOR (inp
[2])))
1254 inp
+= (IS_DIR_SEPARATOR (inp
[2])) ? 3 : 2;
1256 while (outp
>= abs_buffer
&& ! IS_DIR_SEPARATOR (*outp
))
1258 if (outp
< abs_buffer
)
1260 /* Catch cases like /.. where we try to backup to a
1261 point above the absolute root of the logical file
1264 notice ("%s: invalid file name: %s\n",
1265 pname
, rel_filename
);
1266 exit (FATAL_EXIT_CODE
);
1275 /* On exit, make sure that there is a trailing null, and make sure that
1276 the last character of the returned string is *not* a slash. */
1279 if (IS_DIR_SEPARATOR (outp
[-1]))
1282 /* Make a copy (in the heap) of the stuff left in the absolutization
1283 buffer and return a pointer to the copy. */
1285 return savestring (abs_buffer
, outp
- abs_buffer
);
1288 /* Given a filename (and possibly a directory name from which the filename
1289 is relative) return a string which is the shortest possible
1290 equivalent for the corresponding full (absolutized) filename. The
1291 shortest possible equivalent may be constructed by converting the
1292 absolutized filename to be a relative filename (i.e. relative to
1293 the actual current working directory). However if a relative filename
1294 is longer, then the full absolute filename is returned.
1298 Note that "simple-minded" conversion of any given type of filename (either
1299 relative or absolute) may not result in a valid equivalent filename if any
1300 subpart of the original filename is actually a symbolic link. */
1303 shortpath (cwd
, filename
)
1305 const char *filename
;
1309 char *cwd_p
= cwd_buffer
;
1311 int unmatched_slash_count
= 0;
1312 size_t filename_len
= strlen (filename
);
1314 path_p
= abspath (cwd
, filename
);
1315 rel_buf_p
= rel_buffer
= (char *) xmalloc (filename_len
);
1317 while (*cwd_p
&& IS_SAME_PATH_CHAR (*cwd_p
, *path_p
))
1322 if (!*cwd_p
&& (!*path_p
|| IS_DIR_SEPARATOR (*path_p
)))
1324 /* whole pwd matched */
1325 if (!*path_p
) /* input *is* the current path! */
1336 while (! IS_DIR_SEPARATOR (*cwd_p
)) /* backup to last slash */
1343 unmatched_slash_count
++;
1346 /* Find out how many directory levels in cwd were *not* matched. */
1348 if (IS_DIR_SEPARATOR (*(cwd_p
-1)))
1349 unmatched_slash_count
++;
1351 /* Now we know how long the "short name" will be.
1352 Reject it if longer than the input. */
1353 if (unmatched_slash_count
* 3 + strlen (path_p
) >= filename_len
)
1356 /* For each of them, put a `../' at the beginning of the short name. */
1357 while (unmatched_slash_count
--)
1359 /* Give up if the result gets to be longer
1360 than the absolute path name. */
1361 if (rel_buffer
+ filename_len
<= rel_buf_p
+ 3)
1365 *rel_buf_p
++ = DIR_SEPARATOR
;
1368 /* Then tack on the unmatched part of the desired file's name. */
1371 if (rel_buffer
+ filename_len
<= rel_buf_p
)
1374 while ((*rel_buf_p
++ = *path_p
++));
1377 if (IS_DIR_SEPARATOR (*(rel_buf_p
-1)))
1378 *--rel_buf_p
= '\0';
1383 /* Lookup the given filename in the hash table for filenames. If it is a
1384 new one, then the hash table info pointer will be null. In this case,
1385 we create a new file_info record to go with the filename, and we initialize
1386 that record with some reasonable values. */
1388 /* FILENAME was const, but that causes a warning on AIX when calling stat.
1389 That is probably a bug in AIX, but might as well avoid the warning. */
1392 find_file (filename
, do_not_stat
)
1393 const char *filename
;
1396 hash_table_entry
*hash_entry_p
;
1398 hash_entry_p
= lookup (filename_primary
, filename
);
1399 if (hash_entry_p
->fip
)
1400 return hash_entry_p
->fip
;
1403 struct stat stat_buf
;
1404 file_info
*file_p
= (file_info
*) xmalloc (sizeof (file_info
));
1406 /* If we cannot get status on any given source file, give a warning
1407 and then just set its time of last modification to infinity. */
1410 stat_buf
.st_mtime
= (time_t) 0;
1413 if (stat (filename
, &stat_buf
) == -1)
1415 int errno_val
= errno
;
1416 notice ("%s: %s: can't get status: %s\n",
1417 pname
, shortpath (NULL
, filename
),
1418 xstrerror (errno_val
));
1419 stat_buf
.st_mtime
= (time_t) -1;
1423 hash_entry_p
->fip
= file_p
;
1424 file_p
->hash_entry
= hash_entry_p
;
1425 file_p
->defs_decs
= NULL
;
1426 file_p
->mtime
= stat_buf
.st_mtime
;
1431 /* Generate a fatal error because some part of the aux_info file is
1435 aux_info_corrupted ()
1437 notice ("\n%s: fatal error: aux info file corrupted at line %d\n",
1438 pname
, current_aux_info_lineno
);
1439 exit (FATAL_EXIT_CODE
);
1442 /* ??? This comment is vague. Say what the condition is for. */
1443 /* Check to see that a condition is true. This is kind of like an assert. */
1446 check_aux_info (cond
)
1450 aux_info_corrupted ();
1453 /* Given a pointer to the closing right parenthesis for a particular formals
1454 list (in an aux_info file) find the corresponding left parenthesis and
1455 return a pointer to it. */
1458 find_corresponding_lparen (p
)
1464 for (paren_depth
= 1, q
= p
-1; paren_depth
; q
--)
1479 /* Given a line from an aux info file, and a time at which the aux info
1480 file it came from was created, check to see if the item described in
1481 the line comes from a file which has been modified since the aux info
1482 file was created. If so, return non-zero, else return zero. */
1485 referenced_file_is_newer (l
, aux_info_mtime
)
1487 time_t aux_info_mtime
;
1493 check_aux_info (l
[0] == '/');
1494 check_aux_info (l
[1] == '*');
1495 check_aux_info (l
[2] == ' ');
1498 const char *filename_start
= p
= l
+ 3;
1501 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1502 || (*p
== ':' && *p
&& *(p
+1) && IS_DIR_SEPARATOR (*(p
+1)))
1506 filename
= (char *) alloca ((size_t) (p
- filename_start
) + 1);
1507 strncpy (filename
, filename_start
, (size_t) (p
- filename_start
));
1508 filename
[p
-filename_start
] = '\0';
1511 /* Call find_file to find the file_info record associated with the file
1512 which contained this particular def or dec item. Note that this call
1513 may cause a new file_info record to be created if this is the first time
1514 that we have ever known about this particular file. */
1516 fi_p
= find_file (abspath (invocation_filename
, filename
), 0);
1518 return (fi_p
->mtime
> aux_info_mtime
);
1521 /* Given a line of info from the aux_info file, create a new
1522 def_dec_info record to remember all of the important information about
1523 a function definition or declaration.
1525 Link this record onto the list of such records for the particular file in
1526 which it occurred in proper (descending) line number order (for now).
1528 If there is an identical record already on the list for the file, throw
1529 this one away. Doing so takes care of the (useless and troublesome)
1530 duplicates which are bound to crop up due to multiple inclusions of any
1531 given individual header file.
1533 Finally, link the new def_dec record onto the list of such records
1534 pertaining to this particular function name. */
1537 save_def_or_dec (l
, is_syscalls
)
1542 const char *semicolon_p
;
1543 def_dec_info
*def_dec_p
= (def_dec_info
*) xmalloc (sizeof (def_dec_info
));
1546 def_dec_p
->written
= 0;
1547 #endif /* !defined (UNPROTOIZE) */
1549 /* Start processing the line by picking off 5 pieces of information from
1550 the left hand end of the line. These are filename, line number,
1551 new/old/implicit flag (new = ANSI prototype format), definition or
1552 declaration flag, and extern/static flag). */
1554 check_aux_info (l
[0] == '/');
1555 check_aux_info (l
[1] == '*');
1556 check_aux_info (l
[2] == ' ');
1559 const char *filename_start
= p
= l
+ 3;
1563 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1564 || (*p
== ':' && *p
&& *(p
+1) && IS_DIR_SEPARATOR (*(p
+1)))
1568 filename
= (char *) alloca ((size_t) (p
- filename_start
) + 1);
1569 strncpy (filename
, filename_start
, (size_t) (p
- filename_start
));
1570 filename
[p
-filename_start
] = '\0';
1572 /* Call find_file to find the file_info record associated with the file
1573 which contained this particular def or dec item. Note that this call
1574 may cause a new file_info record to be created if this is the first time
1575 that we have ever known about this particular file.
1577 Note that we started out by forcing all of the base source file names
1578 (i.e. the names of the aux_info files with the .X stripped off) into the
1579 filenames hash table, and we simultaneously setup file_info records for
1580 all of these base file names (even if they may be useless later).
1581 The file_info records for all of these "base" file names (properly)
1582 act as file_info records for the "original" (i.e. un-included) files
1583 which were submitted to gcc for compilation (when the -aux-info
1584 option was used). */
1586 def_dec_p
->file
= find_file (abspath (invocation_filename
, filename
), is_syscalls
);
1590 const char *line_number_start
= ++p
;
1591 char line_number
[10];
1594 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1595 || (*p
== ':' && *p
&& *(p
+1) && IS_DIR_SEPARATOR (*(p
+1)))
1599 strncpy (line_number
, line_number_start
, (size_t) (p
- line_number_start
));
1600 line_number
[p
-line_number_start
] = '\0';
1601 def_dec_p
->line
= atoi (line_number
);
1604 /* Check that this record describes a new-style, old-style, or implicit
1605 definition or declaration. */
1607 p
++; /* Skip over the `:'. */
1608 check_aux_info ((*p
== 'N') || (*p
== 'O') || (*p
== 'I'));
1610 /* Is this a new style (ANSI prototyped) definition or declaration? */
1612 def_dec_p
->prototyped
= (*p
== 'N');
1616 /* Is this an implicit declaration? */
1618 def_dec_p
->is_implicit
= (*p
== 'I');
1620 #endif /* !defined (UNPROTOIZE) */
1624 check_aux_info ((*p
== 'C') || (*p
== 'F'));
1626 /* Is this item a function definition (F) or a declaration (C). Note that
1627 we treat item taken from the syscalls file as though they were function
1628 definitions regardless of what the stuff in the file says. */
1630 def_dec_p
->is_func_def
= ((*p
++ == 'F') || is_syscalls
);
1633 def_dec_p
->definition
= 0; /* Fill this in later if protoizing. */
1634 #endif /* !defined (UNPROTOIZE) */
1636 check_aux_info (*p
++ == ' ');
1637 check_aux_info (*p
++ == '*');
1638 check_aux_info (*p
++ == '/');
1639 check_aux_info (*p
++ == ' ');
1642 check_aux_info ((!strncmp (p
, "static", 6)) || (!strncmp (p
, "extern", 6)));
1643 #else /* !defined (UNPROTOIZE) */
1644 if (!strncmp (p
, "static", 6))
1645 def_dec_p
->is_static
= -1;
1646 else if (!strncmp (p
, "extern", 6))
1647 def_dec_p
->is_static
= 0;
1649 check_aux_info (0); /* Didn't find either `extern' or `static'. */
1650 #endif /* !defined (UNPROTOIZE) */
1653 const char *ansi_start
= p
;
1655 p
+= 6; /* Pass over the "static" or "extern". */
1657 /* We are now past the initial stuff. Search forward from here to find
1658 the terminating semicolon that should immediately follow the entire
1659 ANSI format function declaration. */
1666 /* Make a copy of the ansi declaration part of the line from the aux_info
1669 def_dec_p
->ansi_decl
1670 = dupnstr (ansi_start
, (size_t) ((semicolon_p
+1) - ansi_start
));
1672 /* Backup and point at the final right paren of the final argument list. */
1677 def_dec_p
->f_list_chain
= NULL
;
1678 #endif /* !defined (UNPROTOIZE) */
1680 while (p
!= ansi_start
&& (p
[-1] == ' ' || p
[-1] == '\t')) p
--;
1683 free_def_dec (def_dec_p
);
1688 /* Now isolate a whole set of formal argument lists, one-by-one. Normally,
1689 there will only be one list to isolate, but there could be more. */
1691 def_dec_p
->f_list_count
= 0;
1695 const char *left_paren_p
= find_corresponding_lparen (p
);
1698 f_list_chain_item
*cip
1699 = (f_list_chain_item
*) xmalloc (sizeof (f_list_chain_item
));
1702 = dupnstr (left_paren_p
+ 1, (size_t) (p
- (left_paren_p
+1)));
1704 /* Add the new chain item at the head of the current list. */
1706 cip
->chain_next
= def_dec_p
->f_list_chain
;
1707 def_dec_p
->f_list_chain
= cip
;
1709 #endif /* !defined (UNPROTOIZE) */
1710 def_dec_p
->f_list_count
++;
1712 p
= left_paren_p
- 2;
1714 /* p must now point either to another right paren, or to the last
1715 character of the name of the function that was declared/defined.
1716 If p points to another right paren, then this indicates that we
1717 are dealing with multiple formals lists. In that case, there
1718 really should be another right paren preceding this right paren. */
1723 check_aux_info (*--p
== ')');
1728 const char *past_fn
= p
+ 1;
1730 check_aux_info (*past_fn
== ' ');
1732 /* Scan leftwards over the identifier that names the function. */
1734 while (is_id_char (*p
))
1738 /* p now points to the leftmost character of the function name. */
1741 char *fn_string
= (char *) alloca (past_fn
- p
+ 1);
1743 strncpy (fn_string
, p
, (size_t) (past_fn
- p
));
1744 fn_string
[past_fn
-p
] = '\0';
1745 def_dec_p
->hash_entry
= lookup (function_name_primary
, fn_string
);
1749 /* Look at all of the defs and decs for this function name that we have
1750 collected so far. If there is already one which is at the same
1751 line number in the same file, then we can discard this new def_dec_info
1754 As an extra assurance that any such pair of (nominally) identical
1755 function declarations are in fact identical, we also compare the
1756 ansi_decl parts of the lines from the aux_info files just to be on
1759 This comparison will fail if (for instance) the user was playing
1760 messy games with the preprocessor which ultimately causes one
1761 function declaration in one header file to look differently when
1762 that file is included by two (or more) other files. */
1765 const def_dec_info
*other
;
1767 for (other
= def_dec_p
->hash_entry
->ddip
; other
; other
= other
->next_for_func
)
1769 if (def_dec_p
->line
== other
->line
&& def_dec_p
->file
== other
->file
)
1771 if (strcmp (def_dec_p
->ansi_decl
, other
->ansi_decl
))
1773 notice ("%s:%d: declaration of function `%s' takes different forms\n",
1774 def_dec_p
->file
->hash_entry
->symbol
,
1776 def_dec_p
->hash_entry
->symbol
);
1777 exit (FATAL_EXIT_CODE
);
1779 free_def_dec (def_dec_p
);
1787 /* If we are doing unprotoizing, we must now setup the pointers that will
1788 point to the K&R name list and to the K&R argument declarations list.
1790 Note that if this is only a function declaration, then we should not
1791 expect to find any K&R style formals list following the ANSI-style
1792 formals list. This is because GCC knows that such information is
1793 useless in the case of function declarations (function definitions
1794 are a different story however).
1796 Since we are unprotoizing, we don't need any such lists anyway.
1797 All we plan to do is to delete all characters between ()'s in any
1800 def_dec_p
->formal_names
= NULL
;
1801 def_dec_p
->formal_decls
= NULL
;
1803 if (def_dec_p
->is_func_def
)
1806 check_aux_info (*++p
== ' ');
1807 check_aux_info (*++p
== '/');
1808 check_aux_info (*++p
== '*');
1809 check_aux_info (*++p
== ' ');
1810 check_aux_info (*++p
== '(');
1813 const char *kr_names_start
= ++p
; /* Point just inside '('. */
1817 p
--; /* point to closing right paren */
1819 /* Make a copy of the K&R parameter names list. */
1821 def_dec_p
->formal_names
1822 = dupnstr (kr_names_start
, (size_t) (p
- kr_names_start
));
1825 check_aux_info (*++p
== ' ');
1828 /* p now points to the first character of the K&R style declarations
1829 list (if there is one) or to the star-slash combination that ends
1830 the comment in which such lists get embedded. */
1832 /* Make a copy of the K&R formal decls list and set the def_dec record
1835 if (*p
== '*') /* Are there no K&R declarations? */
1837 check_aux_info (*++p
== '/');
1838 def_dec_p
->formal_decls
= "";
1842 const char *kr_decls_start
= p
;
1844 while (p
[0] != '*' || p
[1] != '/')
1848 check_aux_info (*p
== ' ');
1850 def_dec_p
->formal_decls
1851 = dupnstr (kr_decls_start
, (size_t) (p
- kr_decls_start
));
1854 /* Handle a special case. If we have a function definition marked as
1855 being in "old" style, and if its formal names list is empty, then
1856 it may actually have the string "void" in its real formals list
1857 in the original source code. Just to make sure, we will get setup
1858 to convert such things anyway.
1860 This kludge only needs to be here because of an insurmountable
1861 problem with generating .X files. */
1863 if (!def_dec_p
->prototyped
&& !*def_dec_p
->formal_names
)
1864 def_dec_p
->prototyped
= 1;
1867 /* Since we are unprotoizing, if this item is already in old (K&R) style,
1868 we can just ignore it. If that is true, throw away the itme now. */
1870 if (!def_dec_p
->prototyped
)
1872 free_def_dec (def_dec_p
);
1876 #endif /* defined (UNPROTOIZE) */
1878 /* Add this record to the head of the list of records pertaining to this
1879 particular function name. */
1881 def_dec_p
->next_for_func
= def_dec_p
->hash_entry
->ddip
;
1882 def_dec_p
->hash_entry
->ddip
= def_dec_p
;
1884 /* Add this new def_dec_info record to the sorted list of def_dec_info
1885 records for this file. Note that we don't have to worry about duplicates
1886 (caused by multiple inclusions of header files) here because we have
1887 already eliminated duplicates above. */
1889 if (!def_dec_p
->file
->defs_decs
)
1891 def_dec_p
->file
->defs_decs
= def_dec_p
;
1892 def_dec_p
->next_in_file
= NULL
;
1896 int line
= def_dec_p
->line
;
1897 const def_dec_info
*prev
= NULL
;
1898 const def_dec_info
*curr
= def_dec_p
->file
->defs_decs
;
1899 const def_dec_info
*next
= curr
->next_in_file
;
1901 while (next
&& (line
< curr
->line
))
1905 next
= next
->next_in_file
;
1907 if (line
>= curr
->line
)
1909 def_dec_p
->next_in_file
= curr
;
1911 ((NONCONST def_dec_info
*) prev
)->next_in_file
= def_dec_p
;
1913 def_dec_p
->file
->defs_decs
= def_dec_p
;
1915 else /* assert (next == NULL); */
1917 ((NONCONST def_dec_info
*) curr
)->next_in_file
= def_dec_p
;
1918 /* assert (next == NULL); */
1919 def_dec_p
->next_in_file
= next
;
1924 /* Set up the vector COMPILE_PARAMS which is the argument list for running GCC.
1925 Also set input_file_name_index and aux_info_file_name_index
1926 to the indices of the slots where the file names should go. */
1928 /* We initialize the vector by removing -g, -O, -S, -c, and -o options,
1929 and adding '-aux-info AUXFILE -S -o /dev/null INFILE' at the end. */
1932 munge_compile_params (params_list
)
1933 const char *params_list
;
1935 /* Build up the contents in a temporary vector
1936 that is so big that to has to be big enough. */
1937 const char **temp_params
1938 = (const char **) alloca ((strlen (params_list
) + 8) * sizeof (char *));
1939 int param_count
= 0;
1942 temp_params
[param_count
++] = compiler_file_name
;
1945 while (ISSPACE ((const unsigned char)*params_list
))
1949 param
= params_list
;
1950 while (*params_list
&& !ISSPACE ((const unsigned char)*params_list
))
1952 if (param
[0] != '-')
1953 temp_params
[param_count
++]
1954 = dupnstr (param
, (size_t) (params_list
- param
));
1963 break; /* Don't copy these. */
1965 while (ISSPACE ((const unsigned char)*params_list
))
1968 && !ISSPACE ((const unsigned char)*params_list
))
1972 temp_params
[param_count
++]
1973 = dupnstr (param
, (size_t) (params_list
- param
));
1979 temp_params
[param_count
++] = "-aux-info";
1981 /* Leave room for the aux-info file name argument. */
1982 aux_info_file_name_index
= param_count
;
1983 temp_params
[param_count
++] = NULL
;
1985 temp_params
[param_count
++] = "-S";
1986 temp_params
[param_count
++] = "-o";
1987 #if defined (__MSDOS__) || (defined (_WIN32) && ! defined (__CYGWIN__) && ! defined (_UWIN))
1988 temp_params
[param_count
++] = "NUL:";
1990 temp_params
[param_count
++] = "/dev/null";
1993 /* Leave room for the input file name argument. */
1994 input_file_name_index
= param_count
;
1995 temp_params
[param_count
++] = NULL
;
1996 /* Terminate the list. */
1997 temp_params
[param_count
++] = NULL
;
1999 /* Make a copy of the compile_params in heap space. */
2002 = (const char **) xmalloc (sizeof (char *) * (param_count
+1));
2003 memcpy (compile_params
, temp_params
, sizeof (char *) * param_count
);
2006 /* Do a recompilation for the express purpose of generating a new aux_info
2007 file to go with a specific base source file.
2009 The result is a boolean indicating success. */
2012 gen_aux_info_file (base_filename
)
2013 const char *base_filename
;
2015 if (!input_file_name_index
)
2016 munge_compile_params ("");
2018 /* Store the full source file name in the argument vector. */
2019 compile_params
[input_file_name_index
] = shortpath (NULL
, base_filename
);
2020 /* Add .X to source file name to get aux-info file name. */
2021 compile_params
[aux_info_file_name_index
] =
2022 concat (compile_params
[input_file_name_index
], ".X", NULL
);
2025 notice ("%s: compiling `%s'\n",
2026 pname
, compile_params
[input_file_name_index
]);
2029 char *errmsg_fmt
, *errmsg_arg
;
2030 int wait_status
, pid
;
2032 pid
= pexecute (compile_params
[0], (char * const *) compile_params
,
2033 pname
, NULL
, &errmsg_fmt
, &errmsg_arg
,
2034 PEXECUTE_FIRST
| PEXECUTE_LAST
| PEXECUTE_SEARCH
);
2038 int errno_val
= errno
;
2039 fprintf (stderr
, "%s: ", pname
);
2040 fprintf (stderr
, errmsg_fmt
, errmsg_arg
);
2041 fprintf (stderr
, ": %s\n", xstrerror (errno_val
));
2045 pid
= pwait (pid
, &wait_status
, 0);
2048 notice ("%s: wait: %s\n", pname
, xstrerror (errno
));
2051 if (WIFSIGNALED (wait_status
))
2053 notice ("%s: subprocess got fatal signal %d\n",
2054 pname
, WTERMSIG (wait_status
));
2057 if (WIFEXITED (wait_status
))
2059 if (WEXITSTATUS (wait_status
) != 0)
2061 notice ("%s: %s exited with status %d\n",
2062 pname
, compile_params
[0], WEXITSTATUS (wait_status
));
2071 /* Read in all of the information contained in a single aux_info file.
2072 Save all of the important stuff for later. */
2075 process_aux_info_file (base_source_filename
, keep_it
, is_syscalls
)
2076 const char *base_source_filename
;
2080 size_t base_len
= strlen (base_source_filename
);
2081 char * aux_info_filename
2082 = (char *) alloca (base_len
+ strlen (aux_info_suffix
) + 1);
2083 char *aux_info_base
;
2084 char *aux_info_limit
;
2085 char *aux_info_relocated_name
;
2086 const char *aux_info_second_line
;
2087 time_t aux_info_mtime
;
2088 size_t aux_info_size
;
2091 /* Construct the aux_info filename from the base source filename. */
2093 strcpy (aux_info_filename
, base_source_filename
);
2094 strcat (aux_info_filename
, aux_info_suffix
);
2096 /* Check that the aux_info file exists and is readable. If it does not
2097 exist, try to create it (once only). */
2099 /* If file doesn't exist, set must_create.
2100 Likewise if it exists and we can read it but it is obsolete.
2101 Otherwise, report an error. */
2104 /* Come here with must_create set to 1 if file is out of date. */
2107 if (access (aux_info_filename
, R_OK
) == -1)
2109 if (errno
== ENOENT
)
2113 notice ("%s: warning: missing SYSCALLS file `%s'\n",
2114 pname
, aux_info_filename
);
2121 int errno_val
= errno
;
2122 notice ("%s: can't read aux info file `%s': %s\n",
2123 pname
, shortpath (NULL
, aux_info_filename
),
2124 xstrerror (errno_val
));
2129 #if 0 /* There is code farther down to take care of this. */
2133 stat (aux_info_file_name
, &s1
);
2134 stat (base_source_file_name
, &s2
);
2135 if (s2
.st_mtime
> s1
.st_mtime
)
2140 /* If we need a .X file, create it, and verify we can read it. */
2143 if (!gen_aux_info_file (base_source_filename
))
2148 if (access (aux_info_filename
, R_OK
) == -1)
2150 int errno_val
= errno
;
2151 notice ("%s: can't read aux info file `%s': %s\n",
2152 pname
, shortpath (NULL
, aux_info_filename
),
2153 xstrerror (errno_val
));
2160 struct stat stat_buf
;
2162 /* Get some status information about this aux_info file. */
2164 if (stat (aux_info_filename
, &stat_buf
) == -1)
2166 int errno_val
= errno
;
2167 notice ("%s: can't get status of aux info file `%s': %s\n",
2168 pname
, shortpath (NULL
, aux_info_filename
),
2169 xstrerror (errno_val
));
2174 /* Check on whether or not this aux_info file is zero length. If it is,
2175 then just ignore it and return. */
2177 if ((aux_info_size
= stat_buf
.st_size
) == 0)
2180 /* Get the date/time of last modification for this aux_info file and
2181 remember it. We will have to check that any source files that it
2182 contains information about are at least this old or older. */
2184 aux_info_mtime
= stat_buf
.st_mtime
;
2188 /* Compare mod time with the .c file; update .X file if obsolete.
2189 The code later on can fail to check the .c file
2190 if it did not directly define any functions. */
2192 if (stat (base_source_filename
, &stat_buf
) == -1)
2194 int errno_val
= errno
;
2195 notice ("%s: can't get status of aux info file `%s': %s\n",
2196 pname
, shortpath (NULL
, base_source_filename
),
2197 xstrerror (errno_val
));
2201 if (stat_buf
.st_mtime
> aux_info_mtime
)
2213 /* Open the aux_info file. */
2215 fd_flags
= O_RDONLY
;
2217 /* Use binary mode to avoid having to deal with different EOL characters. */
2218 fd_flags
|= O_BINARY
;
2220 if ((aux_info_file
= open (aux_info_filename
, fd_flags
, 0444 )) == -1)
2222 int errno_val
= errno
;
2223 notice ("%s: can't open aux info file `%s' for reading: %s\n",
2224 pname
, shortpath (NULL
, aux_info_filename
),
2225 xstrerror (errno_val
));
2229 /* Allocate space to hold the aux_info file in memory. */
2231 aux_info_base
= xmalloc (aux_info_size
+ 1);
2232 aux_info_limit
= aux_info_base
+ aux_info_size
;
2233 *aux_info_limit
= '\0';
2235 /* Read the aux_info file into memory. */
2237 if (safe_read (aux_info_file
, aux_info_base
, aux_info_size
) !=
2238 (int) aux_info_size
)
2240 int errno_val
= errno
;
2241 notice ("%s: error reading aux info file `%s': %s\n",
2242 pname
, shortpath (NULL
, aux_info_filename
),
2243 xstrerror (errno_val
));
2244 free (aux_info_base
);
2245 close (aux_info_file
);
2249 /* Close the aux info file. */
2251 if (close (aux_info_file
))
2253 int errno_val
= errno
;
2254 notice ("%s: error closing aux info file `%s': %s\n",
2255 pname
, shortpath (NULL
, aux_info_filename
),
2256 xstrerror (errno_val
));
2257 free (aux_info_base
);
2258 close (aux_info_file
);
2263 /* Delete the aux_info file (unless requested not to). If the deletion
2264 fails for some reason, don't even worry about it. */
2266 if (must_create
&& !keep_it
)
2267 if (unlink (aux_info_filename
) == -1)
2269 int errno_val
= errno
;
2270 notice ("%s: can't delete aux info file `%s': %s\n",
2271 pname
, shortpath (NULL
, aux_info_filename
),
2272 xstrerror (errno_val
));
2275 /* Save a pointer into the first line of the aux_info file which
2276 contains the filename of the directory from which the compiler
2277 was invoked when the associated source file was compiled.
2278 This information is used later to help create complete
2279 filenames out of the (potentially) relative filenames in
2280 the aux_info file. */
2283 char *p
= aux_info_base
;
2286 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2287 || (*p
== ':' && *p
&& *(p
+1) && IS_DIR_SEPARATOR (*(p
+1)))
2294 invocation_filename
= p
; /* Save a pointer to first byte of path. */
2297 *p
++ = DIR_SEPARATOR
;
2299 while (*p
++ != '\n')
2301 aux_info_second_line
= p
;
2302 aux_info_relocated_name
= 0;
2303 if (! is_abspath (invocation_filename
))
2305 /* INVOCATION_FILENAME is relative;
2306 append it to BASE_SOURCE_FILENAME's dir. */
2308 aux_info_relocated_name
= xmalloc (base_len
+ (p
-invocation_filename
));
2309 strcpy (aux_info_relocated_name
, base_source_filename
);
2310 dir_end
= strrchr (aux_info_relocated_name
, DIR_SEPARATOR
);
2311 #ifdef DIR_SEPARATOR_2
2315 slash
= strrchr (dir_end
? dir_end
: aux_info_relocated_name
,
2324 dir_end
= aux_info_relocated_name
;
2325 strcpy (dir_end
, invocation_filename
);
2326 invocation_filename
= aux_info_relocated_name
;
2332 const char *aux_info_p
;
2334 /* Do a pre-pass on the lines in the aux_info file, making sure that all
2335 of the source files referenced in there are at least as old as this
2336 aux_info file itself. If not, go back and regenerate the aux_info
2337 file anew. Don't do any of this for the syscalls file. */
2341 current_aux_info_lineno
= 2;
2343 for (aux_info_p
= aux_info_second_line
; *aux_info_p
; )
2345 if (referenced_file_is_newer (aux_info_p
, aux_info_mtime
))
2347 free (aux_info_base
);
2348 free (aux_info_relocated_name
);
2349 if (keep_it
&& unlink (aux_info_filename
) == -1)
2351 int errno_val
= errno
;
2352 notice ("%s: can't delete file `%s': %s\n",
2353 pname
, shortpath (NULL
, aux_info_filename
),
2354 xstrerror (errno_val
));
2361 /* Skip over the rest of this line to start of next line. */
2363 while (*aux_info_p
!= '\n')
2366 current_aux_info_lineno
++;
2370 /* Now do the real pass on the aux_info lines. Save their information in
2371 the in-core data base. */
2373 current_aux_info_lineno
= 2;
2375 for (aux_info_p
= aux_info_second_line
; *aux_info_p
;)
2377 char *unexpanded_line
= unexpand_if_needed (aux_info_p
);
2379 if (unexpanded_line
)
2381 save_def_or_dec (unexpanded_line
, is_syscalls
);
2382 free (unexpanded_line
);
2385 save_def_or_dec (aux_info_p
, is_syscalls
);
2387 /* Skip over the rest of this line and get to start of next line. */
2389 while (*aux_info_p
!= '\n')
2392 current_aux_info_lineno
++;
2396 free (aux_info_base
);
2397 free (aux_info_relocated_name
);
2402 /* Check an individual filename for a .c suffix. If the filename has this
2403 suffix, rename the file such that its suffix is changed to .C. This
2404 function implements the -C option. */
2408 const hash_table_entry
*hp
;
2410 const char *filename
= hp
->symbol
;
2411 int last_char_index
= strlen (filename
) - 1;
2412 char *const new_filename
= (char *) alloca (strlen (filename
)
2413 + strlen (cplus_suffix
) + 1);
2415 /* Note that we don't care here if the given file was converted or not. It
2416 is possible that the given file was *not* converted, simply because there
2417 was nothing in it which actually required conversion. Even in this case,
2418 we want to do the renaming. Note that we only rename files with the .c
2419 suffix (except for the syscalls file, which is left alone). */
2421 if (filename
[last_char_index
] != 'c' || filename
[last_char_index
-1] != '.'
2422 || IS_SAME_PATH (syscalls_absolute_filename
, filename
))
2425 strcpy (new_filename
, filename
);
2426 strcpy (&new_filename
[last_char_index
], cplus_suffix
);
2428 if (rename (filename
, new_filename
) == -1)
2430 int errno_val
= errno
;
2431 notice ("%s: warning: can't rename file `%s' to `%s': %s\n",
2432 pname
, shortpath (NULL
, filename
),
2433 shortpath (NULL
, new_filename
), xstrerror (errno_val
));
2439 #endif /* !defined (UNPROTOIZE) */
2441 /* Take the list of definitions and declarations attached to a particular
2442 file_info node and reverse the order of the list. This should get the
2443 list into an order such that the item with the lowest associated line
2444 number is nearest the head of the list. When these lists are originally
2445 built, they are in the opposite order. We want to traverse them in
2446 normal line number order later (i.e. lowest to highest) so reverse the
2450 reverse_def_dec_list (hp
)
2451 const hash_table_entry
*hp
;
2453 file_info
*file_p
= hp
->fip
;
2454 def_dec_info
*prev
= NULL
;
2455 def_dec_info
*current
= (def_dec_info
*)file_p
->defs_decs
;
2458 return; /* no list to reverse */
2461 if (! (current
= (def_dec_info
*)current
->next_in_file
))
2462 return; /* can't reverse a single list element */
2464 prev
->next_in_file
= NULL
;
2468 def_dec_info
*next
= (def_dec_info
*)current
->next_in_file
;
2470 current
->next_in_file
= prev
;
2475 file_p
->defs_decs
= prev
;
2480 /* Find the (only?) extern definition for a particular function name, starting
2481 from the head of the linked list of entries for the given name. If we
2482 cannot find an extern definition for the given function name, issue a
2483 warning and scrounge around for the next best thing, i.e. an extern
2484 function declaration with a prototype attached to it. Note that we only
2485 allow such substitutions for extern declarations and never for static
2486 declarations. That's because the only reason we allow them at all is
2487 to let un-prototyped function declarations for system-supplied library
2488 functions get their prototypes from our own extra SYSCALLS.c.X file which
2489 contains all of the correct prototypes for system functions. */
2491 static const def_dec_info
*
2492 find_extern_def (head
, user
)
2493 const def_dec_info
*head
;
2494 const def_dec_info
*user
;
2496 const def_dec_info
*dd_p
;
2497 const def_dec_info
*extern_def_p
= NULL
;
2498 int conflict_noted
= 0;
2500 /* Don't act too stupid here. Somebody may try to convert an entire system
2501 in one swell fwoop (rather than one program at a time, as should be done)
2502 and in that case, we may find that there are multiple extern definitions
2503 of a given function name in the entire set of source files that we are
2504 converting. If however one of these definitions resides in exactly the
2505 same source file as the reference we are trying to satisfy then in that
2506 case it would be stupid for us to fail to realize that this one definition
2507 *must* be the precise one we are looking for.
2509 To make sure that we don't miss an opportunity to make this "same file"
2510 leap of faith, we do a prescan of the list of records relating to the
2511 given function name, and we look (on this first scan) *only* for a
2512 definition of the function which is in the same file as the reference
2513 we are currently trying to satisfy. */
2515 for (dd_p
= head
; dd_p
; dd_p
= dd_p
->next_for_func
)
2516 if (dd_p
->is_func_def
&& !dd_p
->is_static
&& dd_p
->file
== user
->file
)
2519 /* Now, since we have not found a definition in the same file as the
2520 reference, we scan the list again and consider all possibilities from
2521 all files. Here we may get conflicts with the things listed in the
2522 SYSCALLS.c.X file, but if that happens it only means that the source
2523 code being converted contains its own definition of a function which
2524 could have been supplied by libc.a. In such cases, we should avoid
2525 issuing the normal warning, and defer to the definition given in the
2528 for (dd_p
= head
; dd_p
; dd_p
= dd_p
->next_for_func
)
2529 if (dd_p
->is_func_def
&& !dd_p
->is_static
)
2531 if (!extern_def_p
) /* Previous definition? */
2532 extern_def_p
= dd_p
; /* Remember the first definition found. */
2535 /* Ignore definition just found if it came from SYSCALLS.c.X. */
2537 if (is_syscalls_file (dd_p
->file
))
2540 /* Quietly replace the definition previously found with the one
2541 just found if the previous one was from SYSCALLS.c.X. */
2543 if (is_syscalls_file (extern_def_p
->file
))
2545 extern_def_p
= dd_p
;
2549 /* If we get here, then there is a conflict between two function
2550 declarations for the same function, both of which came from the
2553 if (!conflict_noted
) /* first time we noticed? */
2556 notice ("%s: conflicting extern definitions of '%s'\n",
2557 pname
, head
->hash_entry
->symbol
);
2560 notice ("%s: declarations of '%s' will not be converted\n",
2561 pname
, head
->hash_entry
->symbol
);
2562 notice ("%s: conflict list for '%s' follows:\n",
2563 pname
, head
->hash_entry
->symbol
);
2564 fprintf (stderr
, "%s: %s(%d): %s\n",
2566 shortpath (NULL
, extern_def_p
->file
->hash_entry
->symbol
),
2567 extern_def_p
->line
, extern_def_p
->ansi_decl
);
2571 fprintf (stderr
, "%s: %s(%d): %s\n",
2573 shortpath (NULL
, dd_p
->file
->hash_entry
->symbol
),
2574 dd_p
->line
, dd_p
->ansi_decl
);
2578 /* We want to err on the side of caution, so if we found multiple conflicting
2579 definitions for the same function, treat this as being that same as if we
2580 had found no definitions (i.e. return NULL). */
2587 /* We have no definitions for this function so do the next best thing.
2588 Search for an extern declaration already in prototype form. */
2590 for (dd_p
= head
; dd_p
; dd_p
= dd_p
->next_for_func
)
2591 if (!dd_p
->is_func_def
&& !dd_p
->is_static
&& dd_p
->prototyped
)
2593 extern_def_p
= dd_p
; /* save a pointer to the definition */
2595 notice ("%s: warning: using formals list from %s(%d) for function `%s'\n",
2597 shortpath (NULL
, dd_p
->file
->hash_entry
->symbol
),
2598 dd_p
->line
, dd_p
->hash_entry
->symbol
);
2602 /* Gripe about unprototyped function declarations that we found no
2603 corresponding definition (or other source of prototype information)
2606 Gripe even if the unprototyped declaration we are worried about
2607 exists in a file in one of the "system" include directories. We
2608 can gripe about these because we should have at least found a
2609 corresponding (pseudo) definition in the SYSCALLS.c.X file. If we
2610 didn't, then that means that the SYSCALLS.c.X file is missing some
2611 needed prototypes for this particular system. That is worth telling
2616 const char *file
= user
->file
->hash_entry
->symbol
;
2619 if (in_system_include_dir (file
))
2621 /* Why copy this string into `needed' at all?
2622 Why not just use user->ansi_decl without copying? */
2623 char *needed
= (char *) alloca (strlen (user
->ansi_decl
) + 1);
2626 strcpy (needed
, user
->ansi_decl
);
2627 p
= (NONCONST
char *) substr (needed
, user
->hash_entry
->symbol
)
2628 + strlen (user
->hash_entry
->symbol
) + 2;
2629 /* Avoid having ??? in the string. */
2635 notice ("%s: %d: `%s' used but missing from SYSCALLS\n",
2636 shortpath (NULL
, file
), user
->line
,
2637 needed
+7); /* Don't print "extern " */
2641 notice ("%s: %d: warning: no extern definition for `%s'\n",
2642 shortpath (NULL
, file
), user
->line
,
2643 user
->hash_entry
->symbol
);
2647 return extern_def_p
;
2650 /* Find the (only?) static definition for a particular function name in a
2651 given file. Here we get the function-name and the file info indirectly
2652 from the def_dec_info record pointer which is passed in. */
2654 static const def_dec_info
*
2655 find_static_definition (user
)
2656 const def_dec_info
*user
;
2658 const def_dec_info
*head
= user
->hash_entry
->ddip
;
2659 const def_dec_info
*dd_p
;
2660 int num_static_defs
= 0;
2661 const def_dec_info
*static_def_p
= NULL
;
2663 for (dd_p
= head
; dd_p
; dd_p
= dd_p
->next_for_func
)
2664 if (dd_p
->is_func_def
&& dd_p
->is_static
&& (dd_p
->file
== user
->file
))
2666 static_def_p
= dd_p
; /* save a pointer to the definition */
2669 if (num_static_defs
== 0)
2672 notice ("%s: warning: no static definition for `%s' in file `%s'\n",
2673 pname
, head
->hash_entry
->symbol
,
2674 shortpath (NULL
, user
->file
->hash_entry
->symbol
));
2676 else if (num_static_defs
> 1)
2678 notice ("%s: multiple static defs of `%s' in file `%s'\n",
2679 pname
, head
->hash_entry
->symbol
,
2680 shortpath (NULL
, user
->file
->hash_entry
->symbol
));
2683 return static_def_p
;
2686 /* Find good prototype style formal argument lists for all of the function
2687 declarations which didn't have them before now.
2689 To do this we consider each function name one at a time. For each function
2690 name, we look at the items on the linked list of def_dec_info records for
2691 that particular name.
2693 Somewhere on this list we should find one (and only one) def_dec_info
2694 record which represents the actual function definition, and this record
2695 should have a nice formal argument list already associated with it.
2697 Thus, all we have to do is to connect up all of the other def_dec_info
2698 records for this particular function name to the special one which has
2699 the full-blown formals list.
2701 Of course it is a little more complicated than just that. See below for
2705 connect_defs_and_decs (hp
)
2706 const hash_table_entry
*hp
;
2708 const def_dec_info
*dd_p
;
2709 const def_dec_info
*extern_def_p
= NULL
;
2710 int first_extern_reference
= 1;
2712 /* Traverse the list of definitions and declarations for this particular
2713 function name. For each item on the list, if it is a function
2714 definition (either old style or new style) then GCC has already been
2715 kind enough to produce a prototype for us, and it is associated with
2716 the item already, so declare the item as its own associated "definition".
2718 Also, for each item which is only a function declaration, but which
2719 nonetheless has its own prototype already (obviously supplied by the user)
2720 declare the item as its own definition.
2722 Note that when/if there are multiple user-supplied prototypes already
2723 present for multiple declarations of any given function, these multiple
2724 prototypes *should* all match exactly with one another and with the
2725 prototype for the actual function definition. We don't check for this
2726 here however, since we assume that the compiler must have already done
2727 this consistency checking when it was creating the .X files. */
2729 for (dd_p
= hp
->ddip
; dd_p
; dd_p
= dd_p
->next_for_func
)
2730 if (dd_p
->prototyped
)
2731 ((NONCONST def_dec_info
*) dd_p
)->definition
= dd_p
;
2733 /* Traverse the list of definitions and declarations for this particular
2734 function name. For each item on the list, if it is an extern function
2735 declaration and if it has no associated definition yet, go try to find
2736 the matching extern definition for the declaration.
2738 When looking for the matching function definition, warn the user if we
2741 If we find more that one function definition also issue a warning.
2743 Do the search for the matching definition only once per unique function
2744 name (and only when absolutely needed) so that we can avoid putting out
2745 redundant warning messages, and so that we will only put out warning
2746 messages when there is actually a reference (i.e. a declaration) for
2747 which we need to find a matching definition. */
2749 for (dd_p
= hp
->ddip
; dd_p
; dd_p
= dd_p
->next_for_func
)
2750 if (!dd_p
->is_func_def
&& !dd_p
->is_static
&& !dd_p
->definition
)
2752 if (first_extern_reference
)
2754 extern_def_p
= find_extern_def (hp
->ddip
, dd_p
);
2755 first_extern_reference
= 0;
2757 ((NONCONST def_dec_info
*) dd_p
)->definition
= extern_def_p
;
2760 /* Traverse the list of definitions and declarations for this particular
2761 function name. For each item on the list, if it is a static function
2762 declaration and if it has no associated definition yet, go try to find
2763 the matching static definition for the declaration within the same file.
2765 When looking for the matching function definition, warn the user if we
2766 fail to find one in the same file with the declaration, and refuse to
2767 convert this kind of cross-file static function declaration. After all,
2768 this is stupid practice and should be discouraged.
2770 We don't have to worry about the possibility that there is more than one
2771 matching function definition in the given file because that would have
2772 been flagged as an error by the compiler.
2774 Do the search for the matching definition only once per unique
2775 function-name/source-file pair (and only when absolutely needed) so that
2776 we can avoid putting out redundant warning messages, and so that we will
2777 only put out warning messages when there is actually a reference (i.e. a
2778 declaration) for which we actually need to find a matching definition. */
2780 for (dd_p
= hp
->ddip
; dd_p
; dd_p
= dd_p
->next_for_func
)
2781 if (!dd_p
->is_func_def
&& dd_p
->is_static
&& !dd_p
->definition
)
2783 const def_dec_info
*dd_p2
;
2784 const def_dec_info
*static_def
;
2786 /* We have now found a single static declaration for which we need to
2787 find a matching definition. We want to minimize the work (and the
2788 number of warnings), so we will find an appropriate (matching)
2789 static definition for this declaration, and then distribute it
2790 (as the definition for) any and all other static declarations
2791 for this function name which occur within the same file, and which
2792 do not already have definitions.
2794 Note that a trick is used here to prevent subsequent attempts to
2795 call find_static_definition for a given function-name & file
2796 if the first such call returns NULL. Essentially, we convert
2797 these NULL return values to -1, and put the -1 into the definition
2798 field for each other static declaration from the same file which
2799 does not already have an associated definition.
2800 This makes these other static declarations look like they are
2801 actually defined already when the outer loop here revisits them
2802 later on. Thus, the outer loop will skip over them. Later, we
2803 turn the -1's back to NULL's. */
2805 ((NONCONST def_dec_info
*) dd_p
)->definition
=
2806 (static_def
= find_static_definition (dd_p
))
2808 : (const def_dec_info
*) -1;
2810 for (dd_p2
= dd_p
->next_for_func
; dd_p2
; dd_p2
= dd_p2
->next_for_func
)
2811 if (!dd_p2
->is_func_def
&& dd_p2
->is_static
2812 && !dd_p2
->definition
&& (dd_p2
->file
== dd_p
->file
))
2813 ((NONCONST def_dec_info
*)dd_p2
)->definition
= dd_p
->definition
;
2816 /* Convert any dummy (-1) definitions we created in the step above back to
2817 NULL's (as they should be). */
2819 for (dd_p
= hp
->ddip
; dd_p
; dd_p
= dd_p
->next_for_func
)
2820 if (dd_p
->definition
== (def_dec_info
*) -1)
2821 ((NONCONST def_dec_info
*) dd_p
)->definition
= NULL
;
2824 #endif /* !defined (UNPROTOIZE) */
2826 /* Give a pointer into the clean text buffer, return a number which is the
2827 original source line number that the given pointer points into. */
2830 identify_lineno (clean_p
)
2831 const char *clean_p
;
2836 for (scan_p
= clean_text_base
; scan_p
<= clean_p
; scan_p
++)
2837 if (*scan_p
== '\n')
2842 /* Issue an error message and give up on doing this particular edit. */
2845 declare_source_confusing (clean_p
)
2846 const char *clean_p
;
2851 notice ("%s: %d: warning: source too confusing\n",
2852 shortpath (NULL
, convert_filename
), last_known_line_number
);
2854 notice ("%s: %d: warning: source too confusing\n",
2855 shortpath (NULL
, convert_filename
),
2856 identify_lineno (clean_p
));
2858 longjmp (source_confusion_recovery
, 1);
2861 /* Check that a condition which is expected to be true in the original source
2862 code is in fact true. If not, issue an error message and give up on
2863 converting this particular source file. */
2866 check_source (cond
, clean_p
)
2868 const char *clean_p
;
2871 declare_source_confusing (clean_p
);
2874 /* If we think of the in-core cleaned text buffer as a memory mapped
2875 file (with the variable last_known_line_start acting as sort of a
2876 file pointer) then we can imagine doing "seeks" on the buffer. The
2877 following routine implements a kind of "seek" operation for the in-core
2878 (cleaned) copy of the source file. When finished, it returns a pointer to
2879 the start of a given (numbered) line in the cleaned text buffer.
2881 Note that protoize only has to "seek" in the forward direction on the
2882 in-core cleaned text file buffers, and it never needs to back up.
2884 This routine is made a little bit faster by remembering the line number
2885 (and pointer value) supplied (and returned) from the previous "seek".
2886 This prevents us from always having to start all over back at the top
2887 of the in-core cleaned buffer again. */
2893 if (n
< last_known_line_number
)
2896 while (n
> last_known_line_number
)
2898 while (*last_known_line_start
!= '\n')
2899 check_source (++last_known_line_start
< clean_text_limit
, 0);
2900 last_known_line_start
++;
2901 last_known_line_number
++;
2903 return last_known_line_start
;
2906 /* Given a pointer to a character in the cleaned text buffer, return a pointer
2907 to the next non-whitespace character which follows it. */
2910 forward_to_next_token_char (ptr
)
2913 for (++ptr
; ISSPACE ((const unsigned char)*ptr
);
2914 check_source (++ptr
< clean_text_limit
, 0))
2919 /* Copy a chunk of text of length `len' and starting at `str' to the current
2920 output buffer. Note that all attempts to add stuff to the current output
2921 buffer ultimately go through here. */
2924 output_bytes (str
, len
)
2928 if ((repl_write_ptr
+ 1) + len
>= repl_text_limit
)
2930 size_t new_size
= (repl_text_limit
- repl_text_base
) << 1;
2931 char *new_buf
= (char *) xrealloc (repl_text_base
, new_size
);
2933 repl_write_ptr
= new_buf
+ (repl_write_ptr
- repl_text_base
);
2934 repl_text_base
= new_buf
;
2935 repl_text_limit
= new_buf
+ new_size
;
2937 memcpy (repl_write_ptr
+ 1, str
, len
);
2938 repl_write_ptr
+= len
;
2941 /* Copy all bytes (except the trailing null) of a null terminated string to
2942 the current output buffer. */
2948 output_bytes (str
, strlen (str
));
2951 /* Copy some characters from the original text buffer to the current output
2954 This routine takes a pointer argument `p' which is assumed to be a pointer
2955 into the cleaned text buffer. The bytes which are copied are the `original'
2956 equivalents for the set of bytes between the last value of `clean_read_ptr'
2957 and the argument value `p'.
2959 The set of bytes copied however, comes *not* from the cleaned text buffer,
2960 but rather from the direct counterparts of these bytes within the original
2963 Thus, when this function is called, some bytes from the original text
2964 buffer (which may include original comments and preprocessing directives)
2965 will be copied into the output buffer.
2967 Note that the request implied when this routine is called includes the
2968 byte pointed to by the argument pointer `p'. */
2974 size_t copy_length
= (size_t) (p
- clean_read_ptr
);
2975 const char *copy_start
= orig_text_base
+(clean_read_ptr
-clean_text_base
)+1;
2977 if (copy_length
== 0)
2980 output_bytes (copy_start
, copy_length
);
2984 /* Given a pointer to a def_dec_info record which represents some form of
2985 definition of a function (perhaps a real definition, or in lieu of that
2986 perhaps just a declaration with a full prototype) return true if this
2987 function is one which we should avoid converting. Return false
2991 other_variable_style_function (ansi_header
)
2992 const char *ansi_header
;
2996 /* See if we have a stdarg function, or a function which has stdarg style
2997 parameters or a stdarg style return type. */
2999 return substr (ansi_header
, "...") != 0;
3001 #else /* !defined (UNPROTOIZE) */
3003 /* See if we have a varargs function, or a function which has varargs style
3004 parameters or a varargs style return type. */
3007 int len
= strlen (varargs_style_indicator
);
3009 for (p
= ansi_header
; p
; )
3011 const char *candidate
;
3013 if ((candidate
= substr (p
, varargs_style_indicator
)) == 0)
3016 if (!is_id_char (candidate
[-1]) && !is_id_char (candidate
[len
]))
3022 #endif /* !defined (UNPROTOIZE) */
3025 /* Do the editing operation specifically for a function "declaration". Note
3026 that editing for function "definitions" are handled in a separate routine
3030 edit_fn_declaration (def_dec_p
, clean_text_p
)
3031 const def_dec_info
*def_dec_p
;
3032 const char *volatile clean_text_p
;
3034 const char *start_formals
;
3035 const char *end_formals
;
3036 const char *function_to_edit
= def_dec_p
->hash_entry
->symbol
;
3037 size_t func_name_len
= strlen (function_to_edit
);
3038 const char *end_of_fn_name
;
3042 const f_list_chain_item
*this_f_list_chain_item
;
3043 const def_dec_info
*definition
= def_dec_p
->definition
;
3045 /* If we are protoizing, and if we found no corresponding definition for
3046 this particular function declaration, then just leave this declaration
3047 exactly as it is. */
3052 /* If we are protoizing, and if the corresponding definition that we found
3053 for this particular function declaration defined an old style varargs
3054 function, then we want to issue a warning and just leave this function
3055 declaration unconverted. */
3057 if (other_variable_style_function (definition
->ansi_decl
))
3060 notice ("%s: %d: warning: varargs function declaration not converted\n",
3061 shortpath (NULL
, def_dec_p
->file
->hash_entry
->symbol
),
3066 #endif /* !defined (UNPROTOIZE) */
3068 /* Setup here to recover from confusing source code detected during this
3069 particular "edit". */
3072 if (setjmp (source_confusion_recovery
))
3074 restore_pointers ();
3075 notice ("%s: declaration of function `%s' not converted\n",
3076 pname
, function_to_edit
);
3080 /* We are editing a function declaration. The line number we did a seek to
3081 contains the comma or semicolon which follows the declaration. Our job
3082 now is to scan backwards looking for the function name. This name *must*
3083 be followed by open paren (ignoring whitespace, of course). We need to
3084 replace everything between that open paren and the corresponding closing
3085 paren. If we are protoizing, we need to insert the prototype-style
3086 formals lists. If we are unprotoizing, we need to just delete everything
3087 between the pairs of opening and closing parens. */
3089 /* First move up to the end of the line. */
3091 while (*clean_text_p
!= '\n')
3092 check_source (++clean_text_p
< clean_text_limit
, 0);
3093 clean_text_p
--; /* Point to just before the newline character. */
3095 /* Now we can scan backwards for the function name. */
3101 /* Scan leftwards until we find some character which can be
3102 part of an identifier. */
3104 while (!is_id_char (*clean_text_p
))
3105 check_source (--clean_text_p
> clean_read_ptr
, 0);
3107 /* Scan backwards until we find a char that cannot be part of an
3110 while (is_id_char (*clean_text_p
))
3111 check_source (--clean_text_p
> clean_read_ptr
, 0);
3113 /* Having found an "id break", see if the following id is the one
3114 that we are looking for. If so, then exit from this loop. */
3116 if (!strncmp (clean_text_p
+1, function_to_edit
, func_name_len
))
3118 char ch
= *(clean_text_p
+ 1 + func_name_len
);
3120 /* Must also check to see that the name in the source text
3121 ends where it should (in order to prevent bogus matches
3122 on similar but longer identifiers. */
3124 if (! is_id_char (ch
))
3125 break; /* exit from loop */
3129 /* We have now found the first perfect match for the function name in
3130 our backward search. This may or may not be the actual function
3131 name at the start of the actual function declaration (i.e. we could
3132 have easily been mislead). We will try to avoid getting fooled too
3133 often by looking forward for the open paren which should follow the
3134 identifier we just found. We ignore whitespace while hunting. If
3135 the next non-whitespace byte we see is *not* an open left paren,
3136 then we must assume that we have been fooled and we start over
3137 again accordingly. Note that there is no guarantee, that even if
3138 we do see the open paren, that we are in the right place.
3139 Programmers do the strangest things sometimes! */
3141 end_of_fn_name
= clean_text_p
+ strlen (def_dec_p
->hash_entry
->symbol
);
3142 start_formals
= forward_to_next_token_char (end_of_fn_name
);
3144 while (*start_formals
!= '(');
3146 /* start_of_formals now points to the opening left paren which immediately
3147 follows the name of the function. */
3149 /* Note that there may be several formals lists which need to be modified
3150 due to the possibility that the return type of this function is a
3151 pointer-to-function type. If there are several formals lists, we
3152 convert them in left-to-right order here. */
3155 this_f_list_chain_item
= definition
->f_list_chain
;
3156 #endif /* !defined (UNPROTOIZE) */
3163 end_formals
= start_formals
+ 1;
3165 for (; depth
; check_source (++end_formals
< clean_text_limit
, 0))
3167 switch (*end_formals
)
3180 /* end_formals now points to the closing right paren of the formals
3181 list whose left paren is pointed to by start_formals. */
3183 /* Now, if we are protoizing, we insert the new ANSI-style formals list
3184 attached to the associated definition of this function. If however
3185 we are unprotoizing, then we simply delete any formals list which
3188 output_up_to (start_formals
);
3190 if (this_f_list_chain_item
)
3192 output_string (this_f_list_chain_item
->formals_list
);
3193 this_f_list_chain_item
= this_f_list_chain_item
->chain_next
;
3198 notice ("%s: warning: too many parameter lists in declaration of `%s'\n",
3199 pname
, def_dec_p
->hash_entry
->symbol
);
3200 check_source (0, end_formals
); /* leave the declaration intact */
3202 #endif /* !defined (UNPROTOIZE) */
3203 clean_read_ptr
= end_formals
- 1;
3205 /* Now see if it looks like there may be another formals list associated
3206 with the function declaration that we are converting (following the
3207 formals list that we just converted. */
3210 const char *another_r_paren
= forward_to_next_token_char (end_formals
);
3212 if ((*another_r_paren
!= ')')
3213 || (*(start_formals
= forward_to_next_token_char (another_r_paren
)) != '('))
3216 if (this_f_list_chain_item
)
3219 notice ("\n%s: warning: too few parameter lists in declaration of `%s'\n",
3220 pname
, def_dec_p
->hash_entry
->symbol
);
3221 check_source (0, start_formals
); /* leave the decl intact */
3223 #endif /* !defined (UNPROTOIZE) */
3229 /* There does appear to be yet another formals list, so loop around
3230 again, and convert it also. */
3234 /* Edit a whole group of formals lists, starting with the rightmost one
3235 from some set of formals lists. This routine is called once (from the
3236 outside) for each function declaration which is converted. It is
3237 recursive however, and it calls itself once for each remaining formal
3238 list that lies to the left of the one it was originally called to work
3239 on. Thus, a whole set gets done in right-to-left order.
3241 This routine returns non-zero if it thinks that it should not be trying
3242 to convert this particular function definition (because the name of the
3243 function doesn't match the one expected). */
3246 edit_formals_lists (end_formals
, f_list_count
, def_dec_p
)
3247 const char *end_formals
;
3248 unsigned int f_list_count
;
3249 const def_dec_info
*def_dec_p
;
3251 const char *start_formals
;
3254 start_formals
= end_formals
- 1;
3256 for (; depth
; check_source (--start_formals
> clean_read_ptr
, 0))
3258 switch (*start_formals
)
3270 /* start_formals now points to the opening left paren of the formals list. */
3276 const char *next_end
;
3278 /* There should be more formal lists to the left of here. */
3280 next_end
= start_formals
- 1;
3281 check_source (next_end
> clean_read_ptr
, 0);
3282 while (ISSPACE ((const unsigned char)*next_end
))
3283 check_source (--next_end
> clean_read_ptr
, 0);
3284 check_source (*next_end
== ')', next_end
);
3285 check_source (--next_end
> clean_read_ptr
, 0);
3286 check_source (*next_end
== ')', next_end
);
3287 if (edit_formals_lists (next_end
, f_list_count
, def_dec_p
))
3291 /* Check that the function name in the header we are working on is the same
3292 as the one we would expect to find. If not, issue a warning and return
3295 if (f_list_count
== 0)
3297 const char *expected
= def_dec_p
->hash_entry
->symbol
;
3298 const char *func_name_start
;
3299 const char *func_name_limit
;
3300 size_t func_name_len
;
3302 for (func_name_limit
= start_formals
-1;
3303 ISSPACE ((const unsigned char)*func_name_limit
); )
3304 check_source (--func_name_limit
> clean_read_ptr
, 0);
3306 for (func_name_start
= func_name_limit
++;
3307 is_id_char (*func_name_start
);
3309 check_source (func_name_start
> clean_read_ptr
, 0);
3311 func_name_len
= func_name_limit
- func_name_start
;
3312 if (func_name_len
== 0)
3313 check_source (0, func_name_start
);
3314 if (func_name_len
!= strlen (expected
)
3315 || strncmp (func_name_start
, expected
, func_name_len
))
3317 notice ("%s: %d: warning: found `%s' but expected `%s'\n",
3318 shortpath (NULL
, def_dec_p
->file
->hash_entry
->symbol
),
3319 identify_lineno (func_name_start
),
3320 dupnstr (func_name_start
, func_name_len
),
3326 output_up_to (start_formals
);
3329 if (f_list_count
== 0)
3330 output_string (def_dec_p
->formal_names
);
3331 #else /* !defined (UNPROTOIZE) */
3333 unsigned f_list_depth
;
3334 const f_list_chain_item
*flci_p
= def_dec_p
->f_list_chain
;
3336 /* At this point, the current value of f_list count says how many
3337 links we have to follow through the f_list_chain to get to the
3338 particular formals list that we need to output next. */
3340 for (f_list_depth
= 0; f_list_depth
< f_list_count
; f_list_depth
++)
3341 flci_p
= flci_p
->chain_next
;
3342 output_string (flci_p
->formals_list
);
3344 #endif /* !defined (UNPROTOIZE) */
3346 clean_read_ptr
= end_formals
- 1;
3350 /* Given a pointer to a byte in the clean text buffer which points to
3351 the beginning of a line that contains a "follower" token for a
3352 function definition header, do whatever is necessary to find the
3353 right closing paren for the rightmost formals list of the function
3354 definition header. */
3357 find_rightmost_formals_list (clean_text_p
)
3358 const char *clean_text_p
;
3360 const char *end_formals
;
3362 /* We are editing a function definition. The line number we did a seek
3363 to contains the first token which immediately follows the entire set of
3364 formals lists which are part of this particular function definition
3367 Our job now is to scan leftwards in the clean text looking for the
3368 right-paren which is at the end of the function header's rightmost
3371 If we ignore whitespace, this right paren should be the first one we
3372 see which is (ignoring whitespace) immediately followed either by the
3373 open curly-brace beginning the function body or by an alphabetic
3374 character (in the case where the function definition is in old (K&R)
3375 style and there are some declarations of formal parameters). */
3377 /* It is possible that the right paren we are looking for is on the
3378 current line (together with its following token). Just in case that
3379 might be true, we start out here by skipping down to the right end of
3380 the current line before starting our scan. */
3382 for (end_formals
= clean_text_p
; *end_formals
!= '\n'; end_formals
++)
3388 /* Now scan backwards while looking for the right end of the rightmost
3389 formals list associated with this function definition. */
3393 const char *l_brace_p
;
3395 /* Look leftward and try to find a right-paren. */
3397 while (*end_formals
!= ')')
3399 if (ISSPACE ((unsigned char)*end_formals
))
3400 while (ISSPACE ((unsigned char)*end_formals
))
3401 check_source (--end_formals
> clean_read_ptr
, 0);
3403 check_source (--end_formals
> clean_read_ptr
, 0);
3406 ch
= *(l_brace_p
= forward_to_next_token_char (end_formals
));
3407 /* Since we are unprotoizing an ANSI-style (prototyped) function
3408 definition, there had better not be anything (except whitespace)
3409 between the end of the ANSI formals list and the beginning of the
3410 function body (i.e. the '{'). */
3412 check_source (ch
== '{', l_brace_p
);
3415 #else /* !defined (UNPROTOIZE) */
3417 /* Now scan backwards while looking for the right end of the rightmost
3418 formals list associated with this function definition. */
3423 const char *l_brace_p
;
3425 /* Look leftward and try to find a right-paren. */
3427 while (*end_formals
!= ')')
3429 if (ISSPACE ((const unsigned char)*end_formals
))
3430 while (ISSPACE ((const unsigned char)*end_formals
))
3431 check_source (--end_formals
> clean_read_ptr
, 0);
3433 check_source (--end_formals
> clean_read_ptr
, 0);
3436 ch
= *(l_brace_p
= forward_to_next_token_char (end_formals
));
3438 /* Since it is possible that we found a right paren before the starting
3439 '{' of the body which IS NOT the one at the end of the real K&R
3440 formals list (say for instance, we found one embedded inside one of
3441 the old K&R formal parameter declarations) we have to check to be
3442 sure that this is in fact the right paren that we were looking for.
3444 The one we were looking for *must* be followed by either a '{' or
3445 by an alphabetic character, while others *cannot* validly be followed
3446 by such characters. */
3448 if ((ch
== '{') || ISALPHA ((unsigned char)ch
))
3451 /* At this point, we have found a right paren, but we know that it is
3452 not the one we were looking for, so backup one character and keep
3455 check_source (--end_formals
> clean_read_ptr
, 0);
3458 #endif /* !defined (UNPROTOIZE) */
3465 /* Insert into the output file a totally new declaration for a function
3466 which (up until now) was being called from within the current block
3467 without having been declared at any point such that the declaration
3468 was visible (i.e. in scope) at the point of the call.
3470 We need to add in explicit declarations for all such function calls
3471 in order to get the full benefit of prototype-based function call
3472 parameter type checking. */
3475 add_local_decl (def_dec_p
, clean_text_p
)
3476 const def_dec_info
*def_dec_p
;
3477 const char *clean_text_p
;
3479 const char *start_of_block
;
3480 const char *function_to_edit
= def_dec_p
->hash_entry
->symbol
;
3482 /* Don't insert new local explicit declarations unless explicitly requested
3488 /* Setup here to recover from confusing source code detected during this
3489 particular "edit". */
3492 if (setjmp (source_confusion_recovery
))
3494 restore_pointers ();
3495 notice ("%s: local declaration for function `%s' not inserted\n",
3496 pname
, function_to_edit
);
3500 /* We have already done a seek to the start of the line which should
3501 contain *the* open curly brace which begins the block in which we need
3502 to insert an explicit function declaration (to replace the implicit one).
3504 Now we scan that line, starting from the left, until we find the
3505 open curly brace we are looking for. Note that there may actually be
3506 multiple open curly braces on the given line, but we will be happy
3507 with the leftmost one no matter what. */
3509 start_of_block
= clean_text_p
;
3510 while (*start_of_block
!= '{' && *start_of_block
!= '\n')
3511 check_source (++start_of_block
< clean_text_limit
, 0);
3513 /* Note that the line from the original source could possibly
3514 contain *no* open curly braces! This happens if the line contains
3515 a macro call which expands into a chunk of text which includes a
3516 block (and that block's associated open and close curly braces).
3517 In cases like this, we give up, issue a warning, and do nothing. */
3519 if (*start_of_block
!= '{')
3522 notice ("\n%s: %d: warning: can't add declaration of `%s' into macro call\n",
3523 def_dec_p
->file
->hash_entry
->symbol
, def_dec_p
->line
,
3524 def_dec_p
->hash_entry
->symbol
);
3528 /* Figure out what a nice (pretty) indentation would be for the new
3529 declaration we are adding. In order to do this, we must scan forward
3530 from the '{' until we find the first line which starts with some
3531 non-whitespace characters (i.e. real "token" material). */
3534 const char *ep
= forward_to_next_token_char (start_of_block
) - 1;
3537 /* Now we have ep pointing at the rightmost byte of some existing indent
3538 stuff. At least that is the hope.
3540 We can now just scan backwards and find the left end of the existing
3541 indentation string, and then copy it to the output buffer. */
3543 for (sp
= ep
; ISSPACE ((const unsigned char)*sp
) && *sp
!= '\n'; sp
--)
3546 /* Now write out the open { which began this block, and any following
3547 trash up to and including the last byte of the existing indent that
3552 /* Now we go ahead and insert the new declaration at this point.
3554 If the definition of the given function is in the same file that we
3555 are currently editing, and if its full ANSI declaration normally
3556 would start with the keyword `extern', suppress the `extern'. */
3559 const char *decl
= def_dec_p
->definition
->ansi_decl
;
3561 if ((*decl
== 'e') && (def_dec_p
->file
== def_dec_p
->definition
->file
))
3563 output_string (decl
);
3566 /* Finally, write out a new indent string, just like the preceding one
3567 that we found. This will typically include a newline as the first
3568 character of the indent string. */
3570 output_bytes (sp
, (size_t) (ep
- sp
) + 1);
3574 /* Given a pointer to a file_info record, and a pointer to the beginning
3575 of a line (in the clean text buffer) which is assumed to contain the
3576 first "follower" token for the first function definition header in the
3577 given file, find a good place to insert some new global function
3578 declarations (which will replace scattered and imprecise implicit ones)
3579 and then insert the new explicit declaration at that point in the file. */
3582 add_global_decls (file_p
, clean_text_p
)
3583 const file_info
*file_p
;
3584 const char *clean_text_p
;
3586 const def_dec_info
*dd_p
;
3589 /* Setup here to recover from confusing source code detected during this
3590 particular "edit". */
3593 if (setjmp (source_confusion_recovery
))
3595 restore_pointers ();
3596 notice ("%s: global declarations for file `%s' not inserted\n",
3597 pname
, shortpath (NULL
, file_p
->hash_entry
->symbol
));
3601 /* Start by finding a good location for adding the new explicit function
3602 declarations. To do this, we scan backwards, ignoring whitespace
3603 and comments and other junk until we find either a semicolon, or until
3604 we hit the beginning of the file. */
3606 scan_p
= find_rightmost_formals_list (clean_text_p
);
3609 if (scan_p
< clean_text_base
)
3611 check_source (scan_p
> clean_read_ptr
, 0);
3616 /* scan_p now points either to a semicolon, or to just before the start
3617 of the whole file. */
3619 /* Now scan forward for the first non-whitespace character. In theory,
3620 this should be the first character of the following function definition
3621 header. We will put in the added declarations just prior to that. */
3624 while (ISSPACE ((const unsigned char)*scan_p
))
3628 output_up_to (scan_p
);
3630 /* Now write out full prototypes for all of the things that had been
3631 implicitly declared in this file (but only those for which we were
3632 actually able to find unique matching definitions). Avoid duplicates
3633 by marking things that we write out as we go. */
3636 int some_decls_added
= 0;
3638 for (dd_p
= file_p
->defs_decs
; dd_p
; dd_p
= dd_p
->next_in_file
)
3639 if (dd_p
->is_implicit
&& dd_p
->definition
&& !dd_p
->definition
->written
)
3641 const char *decl
= dd_p
->definition
->ansi_decl
;
3643 /* If the function for which we are inserting a declaration is
3644 actually defined later in the same file, then suppress the
3645 leading `extern' keyword (if there is one). */
3647 if (*decl
== 'e' && (dd_p
->file
== dd_p
->definition
->file
))
3650 output_string ("\n");
3651 output_string (decl
);
3652 some_decls_added
= 1;
3653 ((NONCONST def_dec_info
*) dd_p
->definition
)->written
= 1;
3655 if (some_decls_added
)
3656 output_string ("\n\n");
3659 /* Unmark all of the definitions that we just marked. */
3661 for (dd_p
= file_p
->defs_decs
; dd_p
; dd_p
= dd_p
->next_in_file
)
3662 if (dd_p
->definition
)
3663 ((NONCONST def_dec_info
*) dd_p
->definition
)->written
= 0;
3666 #endif /* !defined (UNPROTOIZE) */
3668 /* Do the editing operation specifically for a function "definition". Note
3669 that editing operations for function "declarations" are handled by a
3670 separate routine above. */
3673 edit_fn_definition (def_dec_p
, clean_text_p
)
3674 const def_dec_info
*def_dec_p
;
3675 const char *clean_text_p
;
3677 const char *end_formals
;
3678 const char *function_to_edit
= def_dec_p
->hash_entry
->symbol
;
3680 /* Setup here to recover from confusing source code detected during this
3681 particular "edit". */
3684 if (setjmp (source_confusion_recovery
))
3686 restore_pointers ();
3687 notice ("%s: definition of function `%s' not converted\n",
3688 pname
, function_to_edit
);
3692 end_formals
= find_rightmost_formals_list (clean_text_p
);
3694 /* end_of_formals now points to the closing right paren of the rightmost
3695 formals list which is actually part of the `header' of the function
3696 definition that we are converting. */
3698 /* If the header of this function definition looks like it declares a
3699 function with a variable number of arguments, and if the way it does
3700 that is different from that way we would like it (i.e. varargs vs.
3701 stdarg) then issue a warning and leave the header unconverted. */
3703 if (other_variable_style_function (def_dec_p
->ansi_decl
))
3706 notice ("%s: %d: warning: definition of %s not converted\n",
3707 shortpath (NULL
, def_dec_p
->file
->hash_entry
->symbol
),
3708 identify_lineno (end_formals
),
3710 output_up_to (end_formals
);
3714 if (edit_formals_lists (end_formals
, def_dec_p
->f_list_count
, def_dec_p
))
3716 restore_pointers ();
3717 notice ("%s: definition of function `%s' not converted\n",
3718 pname
, function_to_edit
);
3722 /* Have to output the last right paren because this never gets flushed by
3723 edit_formals_list. */
3725 output_up_to (end_formals
);
3730 const char *semicolon_p
;
3731 const char *limit_p
;
3733 int had_newlines
= 0;
3735 /* Now write out the K&R style formal declarations, one per line. */
3737 decl_p
= def_dec_p
->formal_decls
;
3738 limit_p
= decl_p
+ strlen (decl_p
);
3739 for (;decl_p
< limit_p
; decl_p
= semicolon_p
+ 2)
3741 for (semicolon_p
= decl_p
; *semicolon_p
!= ';'; semicolon_p
++)
3743 output_string ("\n");
3744 output_string (indent_string
);
3745 output_bytes (decl_p
, (size_t) ((semicolon_p
+ 1) - decl_p
));
3748 /* If there are no newlines between the end of the formals list and the
3749 start of the body, we should insert one now. */
3751 for (scan_p
= end_formals
+1; *scan_p
!= '{'; )
3753 if (*scan_p
== '\n')
3758 check_source (++scan_p
< clean_text_limit
, 0);
3761 output_string ("\n");
3763 #else /* !defined (UNPROTOIZE) */
3764 /* If we are protoizing, there may be some flotsam & jetsam (like comments
3765 and preprocessing directives) after the old formals list but before
3766 the following { and we would like to preserve that stuff while effectively
3767 deleting the existing K&R formal parameter declarations. We do so here
3768 in a rather tricky way. Basically, we white out any stuff *except*
3769 the comments/pp-directives in the original text buffer, then, if there
3770 is anything in this area *other* than whitespace, we output it. */
3772 const char *end_formals_orig
;
3773 const char *start_body
;
3774 const char *start_body_orig
;
3776 const char *scan_orig
;
3777 int have_flotsam
= 0;
3778 int have_newlines
= 0;
3780 for (start_body
= end_formals
+ 1; *start_body
!= '{';)
3781 check_source (++start_body
< clean_text_limit
, 0);
3783 end_formals_orig
= orig_text_base
+ (end_formals
- clean_text_base
);
3784 start_body_orig
= orig_text_base
+ (start_body
- clean_text_base
);
3785 scan
= end_formals
+ 1;
3786 scan_orig
= end_formals_orig
+ 1;
3787 for (; scan
< start_body
; scan
++, scan_orig
++)
3789 if (*scan
== *scan_orig
)
3791 have_newlines
|= (*scan_orig
== '\n');
3792 /* Leave identical whitespace alone. */
3793 if (!ISSPACE ((const unsigned char)*scan_orig
))
3794 *((NONCONST
char *)scan_orig
) = ' '; /* identical - so whiteout */
3800 output_bytes (end_formals_orig
+ 1,
3801 (size_t) (start_body_orig
- end_formals_orig
) - 1);
3804 output_string ("\n");
3806 output_string (" ");
3807 clean_read_ptr
= start_body
- 1;
3809 #endif /* !defined (UNPROTOIZE) */
3812 /* Clean up the clean text buffer. Do this by converting comments and
3813 preprocessing directives into spaces. Also convert line continuations
3814 into whitespace. Also, whiteout string and character literals. */
3817 do_cleaning (new_clean_text_base
, new_clean_text_limit
)
3818 char *new_clean_text_base
;
3819 const char *new_clean_text_limit
;
3822 int non_whitespace_since_newline
= 0;
3824 for (scan_p
= new_clean_text_base
; scan_p
< new_clean_text_limit
; scan_p
++)
3828 case '/': /* Handle comments. */
3829 if (scan_p
[1] != '*')
3831 non_whitespace_since_newline
= 1;
3835 while (scan_p
[1] != '/' || scan_p
[0] != '*')
3837 if (!ISSPACE ((const unsigned char)*scan_p
))
3839 if (++scan_p
>= new_clean_text_limit
)
3846 case '#': /* Handle pp directives. */
3847 if (non_whitespace_since_newline
)
3850 while (scan_p
[1] != '\n' || scan_p
[0] == '\\')
3852 if (!ISSPACE ((const unsigned char)*scan_p
))
3854 if (++scan_p
>= new_clean_text_limit
)
3860 case '\'': /* Handle character literals. */
3861 non_whitespace_since_newline
= 1;
3862 while (scan_p
[1] != '\'' || scan_p
[0] == '\\')
3864 if (scan_p
[0] == '\\'
3865 && !ISSPACE ((const unsigned char)scan_p
[1]))
3867 if (!ISSPACE ((const unsigned char)*scan_p
))
3869 if (++scan_p
>= new_clean_text_limit
)
3875 case '"': /* Handle string literals. */
3876 non_whitespace_since_newline
= 1;
3877 while (scan_p
[1] != '"' || scan_p
[0] == '\\')
3879 if (scan_p
[0] == '\\'
3880 && !ISSPACE ((const unsigned char)scan_p
[1]))
3882 if (!ISSPACE ((const unsigned char)*scan_p
))
3884 if (++scan_p
>= new_clean_text_limit
)
3887 if (!ISSPACE ((const unsigned char)*scan_p
))
3892 case '\\': /* Handle line continuations. */
3893 if (scan_p
[1] != '\n')
3899 non_whitespace_since_newline
= 0; /* Reset. */
3908 break; /* Whitespace characters. */
3912 non_whitespace_since_newline
= 1;
3918 /* Given a pointer to the closing right parenthesis for a particular formals
3919 list (in the clean text buffer) find the corresponding left parenthesis
3920 and return a pointer to it. */
3923 careful_find_l_paren (p
)
3929 for (paren_depth
= 1, q
= p
-1; paren_depth
; check_source (--q
>= clean_text_base
, 0))
3944 /* Scan the clean text buffer for cases of function definitions that we
3945 don't really know about because they were preprocessed out when the
3946 aux info files were created.
3948 In this version of protoize/unprotoize we just give a warning for each
3949 one found. A later version may be able to at least unprotoize such
3952 Note that we may easily find all function definitions simply by
3953 looking for places where there is a left paren which is (ignoring
3954 whitespace) immediately followed by either a left-brace or by an
3955 upper or lower case letter. Whenever we find this combination, we
3956 have also found a function definition header.
3958 Finding function *declarations* using syntactic clues is much harder.
3959 I will probably try to do this in a later version though. */
3962 scan_for_missed_items (file_p
)
3963 const file_info
*file_p
;
3965 static const char *scan_p
;
3966 const char *limit
= clean_text_limit
- 3;
3967 static const char *backup_limit
;
3969 backup_limit
= clean_text_base
- 1;
3971 for (scan_p
= clean_text_base
; scan_p
< limit
; scan_p
++)
3975 static const char *last_r_paren
;
3976 const char *ahead_p
;
3978 last_r_paren
= scan_p
;
3980 for (ahead_p
= scan_p
+ 1; ISSPACE ((const unsigned char)*ahead_p
); )
3981 check_source (++ahead_p
< limit
, limit
);
3983 scan_p
= ahead_p
- 1;
3985 if (ISALPHA ((const unsigned char)*ahead_p
) || *ahead_p
== '{')
3987 const char *last_l_paren
;
3988 const int lineno
= identify_lineno (ahead_p
);
3990 if (setjmp (source_confusion_recovery
))
3993 /* We know we have a function definition header. Now skip
3994 leftwards over all of its associated formals lists. */
3998 last_l_paren
= careful_find_l_paren (last_r_paren
);
3999 for (last_r_paren
= last_l_paren
-1;
4000 ISSPACE ((const unsigned char)*last_r_paren
); )
4001 check_source (--last_r_paren
>= backup_limit
, backup_limit
);
4003 while (*last_r_paren
== ')');
4005 if (is_id_char (*last_r_paren
))
4007 const char *id_limit
= last_r_paren
+ 1;
4008 const char *id_start
;
4010 const def_dec_info
*dd_p
;
4012 for (id_start
= id_limit
-1; is_id_char (*id_start
); )
4013 check_source (--id_start
>= backup_limit
, backup_limit
);
4015 backup_limit
= id_start
;
4016 if ((id_length
= (size_t) (id_limit
- id_start
)) == 0)
4020 char *func_name
= (char *) alloca (id_length
+ 1);
4021 static const char * const stmt_keywords
[]
4022 = { "if", "else", "do", "while", "for", "switch", "case", "return", 0 };
4023 const char * const *stmt_keyword
;
4025 strncpy (func_name
, id_start
, id_length
);
4026 func_name
[id_length
] = '\0';
4028 /* We must check here to see if we are actually looking at
4029 a statement rather than an actual function call. */
4031 for (stmt_keyword
= stmt_keywords
; *stmt_keyword
; stmt_keyword
++)
4032 if (!strcmp (func_name
, *stmt_keyword
))
4036 notice ("%s: found definition of `%s' at %s(%d)\n",
4039 shortpath (NULL
, file_p
->hash_entry
->symbol
),
4040 identify_lineno (id_start
));
4042 /* We really should check for a match of the function name
4043 here also, but why bother. */
4045 for (dd_p
= file_p
->defs_decs
; dd_p
; dd_p
= dd_p
->next_in_file
)
4046 if (dd_p
->is_func_def
&& dd_p
->line
== lineno
)
4049 /* If we make it here, then we did not know about this
4050 function definition. */
4052 notice ("%s: %d: warning: `%s' excluded by preprocessing\n",
4053 shortpath (NULL
, file_p
->hash_entry
->symbol
),
4054 identify_lineno (id_start
), func_name
);
4055 notice ("%s: function definition not converted\n",
4065 /* Do all editing operations for a single source file (either a "base" file
4066 or an "include" file). To do this we read the file into memory, keep a
4067 virgin copy there, make another cleaned in-core copy of the original file
4068 (i.e. one in which all of the comments and preprocessing directives have
4069 been replaced with whitespace), then use these two in-core copies of the
4070 file to make a new edited in-core copy of the file. Finally, rename the
4071 original file (as a way of saving it), and then write the edited version
4072 of the file from core to a disk file of the same name as the original.
4074 Note that the trick of making a copy of the original sans comments &
4075 preprocessing directives make the editing a whole lot easier. */
4079 const hash_table_entry
*hp
;
4081 struct stat stat_buf
;
4082 const file_info
*file_p
= hp
->fip
;
4083 char *new_orig_text_base
;
4084 char *new_orig_text_limit
;
4085 char *new_clean_text_base
;
4086 char *new_clean_text_limit
;
4089 int first_definition_in_file
;
4091 /* If we are not supposed to be converting this file, or if there is
4092 nothing in there which needs converting, just skip this file. */
4094 if (!needs_to_be_converted (file_p
))
4097 convert_filename
= file_p
->hash_entry
->symbol
;
4099 /* Convert a file if it is in a directory where we want conversion
4100 and the file is not excluded. */
4102 if (!directory_specified_p (convert_filename
)
4103 || file_excluded_p (convert_filename
))
4107 /* Don't even mention "system" include files unless we are
4108 protoizing. If we are protoizing, we mention these as a
4109 gentle way of prodding the user to convert his "system"
4110 include files to prototype format. */
4111 && !in_system_include_dir (convert_filename
)
4112 #endif /* defined (UNPROTOIZE) */
4114 notice ("%s: `%s' not converted\n",
4115 pname
, shortpath (NULL
, convert_filename
));
4119 /* Let the user know what we are up to. */
4122 notice ("%s: would convert file `%s'\n",
4123 pname
, shortpath (NULL
, convert_filename
));
4125 notice ("%s: converting file `%s'\n",
4126 pname
, shortpath (NULL
, convert_filename
));
4129 /* Find out the size (in bytes) of the original file. */
4131 /* The cast avoids an erroneous warning on AIX. */
4132 if (stat (convert_filename
, &stat_buf
) == -1)
4134 int errno_val
= errno
;
4135 notice ("%s: can't get status for file `%s': %s\n",
4136 pname
, shortpath (NULL
, convert_filename
),
4137 xstrerror (errno_val
));
4140 orig_size
= stat_buf
.st_size
;
4142 /* Allocate a buffer to hold the original text. */
4144 orig_text_base
= new_orig_text_base
= (char *) xmalloc (orig_size
+ 2);
4145 orig_text_limit
= new_orig_text_limit
= new_orig_text_base
+ orig_size
;
4147 /* Allocate a buffer to hold the cleaned-up version of the original text. */
4149 clean_text_base
= new_clean_text_base
= (char *) xmalloc (orig_size
+ 2);
4150 clean_text_limit
= new_clean_text_limit
= new_clean_text_base
+ orig_size
;
4151 clean_read_ptr
= clean_text_base
- 1;
4153 /* Allocate a buffer that will hopefully be large enough to hold the entire
4154 converted output text. As an initial guess for the maximum size of the
4155 output buffer, use 125% of the size of the original + some extra. This
4156 buffer can be expanded later as needed. */
4158 repl_size
= orig_size
+ (orig_size
>> 2) + 4096;
4159 repl_text_base
= (char *) xmalloc (repl_size
+ 2);
4160 repl_text_limit
= repl_text_base
+ repl_size
- 1;
4161 repl_write_ptr
= repl_text_base
- 1;
4167 /* Open the file to be converted in READ ONLY mode. */
4169 fd_flags
= O_RDONLY
;
4171 /* Use binary mode to avoid having to deal with different EOL characters. */
4172 fd_flags
|= O_BINARY
;
4174 if ((input_file
= open (convert_filename
, fd_flags
, 0444)) == -1)
4176 int errno_val
= errno
;
4177 notice ("%s: can't open file `%s' for reading: %s\n",
4178 pname
, shortpath (NULL
, convert_filename
),
4179 xstrerror (errno_val
));
4183 /* Read the entire original source text file into the original text buffer
4184 in one swell fwoop. Then figure out where the end of the text is and
4185 make sure that it ends with a newline followed by a null. */
4187 if (safe_read (input_file
, new_orig_text_base
, orig_size
) !=
4190 int errno_val
= errno
;
4192 notice ("\n%s: error reading input file `%s': %s\n",
4193 pname
, shortpath (NULL
, convert_filename
),
4194 xstrerror (errno_val
));
4201 if (orig_size
== 0 || orig_text_limit
[-1] != '\n')
4203 *new_orig_text_limit
++ = '\n';
4207 /* Create the cleaned up copy of the original text. */
4209 memcpy (new_clean_text_base
, orig_text_base
,
4210 (size_t) (orig_text_limit
- orig_text_base
));
4211 do_cleaning (new_clean_text_base
, new_clean_text_limit
);
4216 size_t clean_size
= orig_text_limit
- orig_text_base
;
4217 char *const clean_filename
= (char *) alloca (strlen (convert_filename
) + 6 + 1);
4219 /* Open (and create) the clean file. */
4221 strcpy (clean_filename
, convert_filename
);
4222 strcat (clean_filename
, ".clean");
4223 if ((clean_file
= creat (clean_filename
, 0666)) == -1)
4225 int errno_val
= errno
;
4226 notice ("%s: can't create/open clean file `%s': %s\n",
4227 pname
, shortpath (NULL
, clean_filename
),
4228 xstrerror (errno_val
));
4232 /* Write the clean file. */
4234 safe_write (clean_file
, new_clean_text_base
, clean_size
, clean_filename
);
4240 /* Do a simplified scan of the input looking for things that were not
4241 mentioned in the aux info files because of the fact that they were
4242 in a region of the source which was preprocessed-out (via #if or
4245 scan_for_missed_items (file_p
);
4247 /* Setup to do line-oriented forward seeking in the clean text buffer. */
4249 last_known_line_number
= 1;
4250 last_known_line_start
= clean_text_base
;
4252 /* Now get down to business and make all of the necessary edits. */
4255 const def_dec_info
*def_dec_p
;
4257 first_definition_in_file
= 1;
4258 def_dec_p
= file_p
->defs_decs
;
4259 for (; def_dec_p
; def_dec_p
= def_dec_p
->next_in_file
)
4261 const char *clean_text_p
= seek_to_line (def_dec_p
->line
);
4263 /* clean_text_p now points to the first character of the line which
4264 contains the `terminator' for the declaration or definition that
4265 we are about to process. */
4269 if (global_flag
&& def_dec_p
->is_func_def
&& first_definition_in_file
)
4271 add_global_decls (def_dec_p
->file
, clean_text_p
);
4272 first_definition_in_file
= 0;
4275 /* Don't edit this item if it is already in prototype format or if it
4276 is a function declaration and we have found no corresponding
4279 if (def_dec_p
->prototyped
4280 || (!def_dec_p
->is_func_def
&& !def_dec_p
->definition
))
4283 #endif /* !defined (UNPROTOIZE) */
4285 if (def_dec_p
->is_func_def
)
4286 edit_fn_definition (def_dec_p
, clean_text_p
);
4289 if (def_dec_p
->is_implicit
)
4290 add_local_decl (def_dec_p
, clean_text_p
);
4292 #endif /* !defined (UNPROTOIZE) */
4293 edit_fn_declaration (def_dec_p
, clean_text_p
);
4297 /* Finalize things. Output the last trailing part of the original text. */
4299 output_up_to (clean_text_limit
- 1);
4301 /* If this is just a test run, stop now and just deallocate the buffers. */
4305 free (new_orig_text_base
);
4306 free (new_clean_text_base
);
4307 free (repl_text_base
);
4311 /* Change the name of the original input file. This is just a quick way of
4312 saving the original file. */
4317 = (char *) xmalloc (strlen (convert_filename
) + strlen (save_suffix
) + 2);
4319 strcpy (new_filename
, convert_filename
);
4320 strcat (new_filename
, save_suffix
);
4322 /* Don't overwrite existing file. */
4323 if (access (new_filename
, F_OK
) == 0)
4326 notice ("%s: warning: file `%s' already saved in `%s'\n",
4328 shortpath (NULL
, convert_filename
),
4329 shortpath (NULL
, new_filename
));
4331 else if (rename (convert_filename
, new_filename
) == -1)
4333 int errno_val
= errno
;
4334 notice ("%s: can't link file `%s' to `%s': %s\n",
4336 shortpath (NULL
, convert_filename
),
4337 shortpath (NULL
, new_filename
),
4338 xstrerror (errno_val
));
4343 if (unlink (convert_filename
) == -1)
4345 int errno_val
= errno
;
4346 /* The file may have already been renamed. */
4347 if (errno_val
!= ENOENT
)
4349 notice ("%s: can't delete file `%s': %s\n",
4350 pname
, shortpath (NULL
, convert_filename
),
4351 xstrerror (errno_val
));
4359 /* Open (and create) the output file. */
4361 if ((output_file
= creat (convert_filename
, 0666)) == -1)
4363 int errno_val
= errno
;
4364 notice ("%s: can't create/open output file `%s': %s\n",
4365 pname
, shortpath (NULL
, convert_filename
),
4366 xstrerror (errno_val
));
4370 /* Use binary mode to avoid changing the existing EOL character. */
4371 setmode (output_file
, O_BINARY
);
4374 /* Write the output file. */
4377 unsigned int out_size
= (repl_write_ptr
+ 1) - repl_text_base
;
4379 safe_write (output_file
, repl_text_base
, out_size
, convert_filename
);
4382 close (output_file
);
4385 /* Deallocate the conversion buffers. */
4387 free (new_orig_text_base
);
4388 free (new_clean_text_base
);
4389 free (repl_text_base
);
4391 /* Change the mode of the output file to match the original file. */
4393 /* The cast avoids an erroneous warning on AIX. */
4394 if (chmod (convert_filename
, stat_buf
.st_mode
) == -1)
4396 int errno_val
= errno
;
4397 notice ("%s: can't change mode of file `%s': %s\n",
4398 pname
, shortpath (NULL
, convert_filename
),
4399 xstrerror (errno_val
));
4402 /* Note: We would try to change the owner and group of the output file
4403 to match those of the input file here, except that may not be a good
4404 thing to do because it might be misleading. Also, it might not even
4405 be possible to do that (on BSD systems with quotas for instance). */
4408 /* Do all of the individual steps needed to do the protoization (or
4409 unprotoization) of the files referenced in the aux_info files given
4410 in the command line. */
4415 const char * const *base_pp
;
4416 const char * const * const end_pps
4417 = &base_source_filenames
[n_base_source_files
];
4421 #endif /* !defined (UNPROTOIZE) */
4423 /* One-by-one, check (and create if necessary), open, and read all of the
4424 stuff in each aux_info file. After reading each aux_info file, the
4425 aux_info_file just read will be automatically deleted unless the
4426 keep_flag is set. */
4428 for (base_pp
= base_source_filenames
; base_pp
< end_pps
; base_pp
++)
4429 process_aux_info_file (*base_pp
, keep_flag
, 0);
4433 /* Also open and read the special SYSCALLS.c aux_info file which gives us
4434 the prototypes for all of the standard system-supplied functions. */
4436 if (nondefault_syscalls_dir
)
4438 syscalls_absolute_filename
4439 = (char *) xmalloc (strlen (nondefault_syscalls_dir
) + 1
4440 + sizeof (syscalls_filename
));
4441 strcpy (syscalls_absolute_filename
, nondefault_syscalls_dir
);
4445 GET_ENV_PATH_LIST (default_syscalls_dir
, "GCC_EXEC_PREFIX");
4446 if (!default_syscalls_dir
)
4448 default_syscalls_dir
= standard_exec_prefix
;
4450 syscalls_absolute_filename
4451 = (char *) xmalloc (strlen (default_syscalls_dir
) + 0
4452 + strlen (target_machine
) + 1
4453 + strlen (target_version
) + 1
4454 + sizeof (syscalls_filename
));
4455 strcpy (syscalls_absolute_filename
, default_syscalls_dir
);
4456 strcat (syscalls_absolute_filename
, target_machine
);
4457 strcat (syscalls_absolute_filename
, "/");
4458 strcat (syscalls_absolute_filename
, target_version
);
4459 strcat (syscalls_absolute_filename
, "/");
4462 syscalls_len
= strlen (syscalls_absolute_filename
);
4463 if (! IS_DIR_SEPARATOR (*(syscalls_absolute_filename
+ syscalls_len
- 1)))
4465 *(syscalls_absolute_filename
+ syscalls_len
++) = DIR_SEPARATOR
;
4466 *(syscalls_absolute_filename
+ syscalls_len
) = '\0';
4468 strcat (syscalls_absolute_filename
, syscalls_filename
);
4470 /* Call process_aux_info_file in such a way that it does not try to
4471 delete the SYSCALLS aux_info file. */
4473 process_aux_info_file (syscalls_absolute_filename
, 1, 1);
4475 #endif /* !defined (UNPROTOIZE) */
4477 /* When we first read in all of the information from the aux_info files
4478 we saved in it descending line number order, because that was likely to
4479 be faster. Now however, we want the chains of def & dec records to
4480 appear in ascending line number order as we get further away from the
4481 file_info record that they hang from. The following line causes all of
4482 these lists to be rearranged into ascending line number order. */
4484 visit_each_hash_node (filename_primary
, reverse_def_dec_list
);
4488 /* Now do the "real" work. The following line causes each declaration record
4489 to be "visited". For each of these nodes, an attempt is made to match
4490 up the function declaration with a corresponding function definition,
4491 which should have a full prototype-format formals list with it. Once
4492 these match-ups are made, the conversion of the function declarations
4493 to prototype format can be made. */
4495 visit_each_hash_node (function_name_primary
, connect_defs_and_decs
);
4497 #endif /* !defined (UNPROTOIZE) */
4499 /* Now convert each file that can be converted (and needs to be). */
4501 visit_each_hash_node (filename_primary
, edit_file
);
4505 /* If we are working in cplusplus mode, try to rename all .c files to .C
4506 files. Don't panic if some of the renames don't work. */
4508 if (cplusplus_flag
&& !nochange_flag
)
4509 visit_each_hash_node (filename_primary
, rename_c_file
);
4511 #endif /* !defined (UNPROTOIZE) */
4514 static struct option longopts
[] =
4516 {"version", 0, 0, 'V'},
4517 {"file_name", 0, 0, 'p'},
4518 {"quiet", 0, 0, 'q'},
4519 {"silent", 0, 0, 'q'},
4520 {"force", 0, 0, 'f'},
4521 {"keep", 0, 0, 'k'},
4522 {"nosave", 0, 0, 'N'},
4523 {"nochange", 0, 0, 'n'},
4524 {"compiler-options", 1, 0, 'c'},
4525 {"exclude", 1, 0, 'x'},
4526 {"directory", 1, 0, 'd'},
4528 {"indent", 1, 0, 'i'},
4530 {"local", 0, 0, 'l'},
4531 {"global", 0, 0, 'g'},
4533 {"syscalls-dir", 1, 0, 'B'},
4538 extern int main
PARAMS ((int, char **const));
4547 const char *params
= "";
4549 pname
= strrchr (argv
[0], DIR_SEPARATOR
);
4550 #ifdef DIR_SEPARATOR_2
4554 slash
= strrchr (pname
? pname
: argv
[0], DIR_SEPARATOR_2
);
4559 pname
= pname
? pname
+1 : argv
[0];
4561 #ifdef HAVE_LC_MESSAGES
4562 setlocale (LC_MESSAGES
, "");
4564 (void) bindtextdomain (PACKAGE
, localedir
);
4565 (void) textdomain (PACKAGE
);
4567 cwd_buffer
= getpwd ();
4570 notice ("%s: cannot get working directory: %s\n",
4571 pname
, xstrerror(errno
));
4572 return (FATAL_EXIT_CODE
);
4575 /* By default, convert the files in the current directory. */
4576 directory_list
= string_list_cons (cwd_buffer
, NULL
);
4578 while ((c
= getopt_long (argc
, argv
,
4582 "B:c:Cd:gklnNp:qvVx:",
4584 longopts
, &longind
)) != EOF
)
4586 if (c
== 0) /* Long option. */
4587 c
= longopts
[longind
].val
;
4591 compiler_file_name
= optarg
;
4595 = string_list_cons (abspath (NULL
, optarg
), directory_list
);
4598 exclude_list
= string_list_cons (optarg
, exclude_list
);
4628 indent_string
= optarg
;
4630 #else /* !defined (UNPROTOIZE) */
4641 nondefault_syscalls_dir
= optarg
;
4643 #endif /* !defined (UNPROTOIZE) */
4649 /* Set up compile_params based on -p and -c options. */
4650 munge_compile_params (params
);
4652 n_base_source_files
= argc
- optind
;
4654 /* Now actually make a list of the base source filenames. */
4656 base_source_filenames
4657 = (const char **) xmalloc ((n_base_source_files
+ 1) * sizeof (char *));
4658 n_base_source_files
= 0;
4659 for (; optind
< argc
; optind
++)
4661 const char *path
= abspath (NULL
, argv
[optind
]);
4662 int len
= strlen (path
);
4664 if (path
[len
-1] == 'c' && path
[len
-2] == '.')
4665 base_source_filenames
[n_base_source_files
++] = path
;
4668 notice ("%s: input file names must have .c suffixes: %s\n",
4669 pname
, shortpath (NULL
, path
));
4675 /* We are only interested in the very first identifier token in the
4676 definition of `va_list', so if there is more junk after that first
4677 identifier token, delete it from the `varargs_style_indicator'. */
4681 for (cp
= varargs_style_indicator
;
4682 ISALNUM ((const unsigned char)*cp
) || *cp
== '_'; cp
++)
4685 varargs_style_indicator
= savestring (varargs_style_indicator
,
4686 cp
- varargs_style_indicator
);
4688 #endif /* !defined (UNPROTOIZE) */
4695 fprintf (stderr
, "%s: %s\n", pname
, version_string
);
4699 return (errors
? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
);