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. */
21 /* Any reasonable C++ compiler should have all of the same features
22 as __STDC__ plus more, so make sure that __STDC__ is defined if
23 __cplusplus is defined. */
25 #if defined(__cplusplus) && !defined(__STDC__)
27 #endif /* defined(__cplusplus) && !defined(__STDC__) */
29 #if defined(__GNUC__) || defined (__GNUG__)
30 #define VOLATILE volatile
43 /* Users are not supposed to use _POSIX_SOURCE to say the
44 system is a POSIX system. That is not what _POSIX_SOURCE means! -- rms */
45 /* If the user asked for POSIX via _POSIX_SOURCE, turn on POSIX code. */
46 #if defined(_POSIX_SOURCE) && !defined(POSIX)
51 #ifdef POSIX /* We should be able to define _POSIX_SOURCE unconditionally,
52 but some systems respond in buggy ways to it,
53 including SunOS 4.1.1. Which we don't classify as POSIX. */
54 /* In case this is a POSIX system with an ANSI C compiler,
55 ask for definition of all POSIX facilities. */
63 #if ! defined (_WIN32) || defined (__CYGWIN__) || defined (_UWIN)
64 #if defined(POSIX) || defined(CONCURRENT)
72 /* Some systems like Linux don't declare rindex if _POSIX_SOURCE is declared,
73 but it normally does declare it. This means that configure thinks we don't
74 need to declare it. Favor using strrchr if it is available. */
79 #define strrchr rindex
84 /* Include getopt.h for the sake of getopt_long.
85 We don't need the declaration of getopt, and it could conflict
86 with something from a system header file, so effectively nullify that. */
87 #define getopt getopt_loser
91 extern char *version_string;
93 /* Systems which are compatible only with POSIX 1003.1-1988 (but *not*
94 with POSIX 1003.1-1990), e.g. Ultrix 4.2, might not have
95 const qualifiers in the prototypes in the system include files.
96 Unfortunately, this can lead to GCC issuing lots of warnings for
97 calls to the following functions. To eliminate these warnings we
98 provide the following #defines. */
100 #define my_access(file,flag) access((char *)file, flag)
101 #define my_stat(file,pkt) stat((char *)file, pkt)
103 #define my_link(file1, file2) -1
105 #define my_link(file1, file2) link((char *)file1, (char *)file2)
107 #define my_unlink(file) unlink((char *)file)
108 #define my_open(file, mode, flag) open((char *)file, mode, flag)
109 #define my_chmod(file, mode) chmod((char *)file, mode)
111 extern char *getpwd ();
113 static void usage PROTO ((void)) ATTRIBUTE_NORETURN;
114 static void aux_info_corrupted PROTO ((void)) ATTRIBUTE_NORETURN;
115 static void declare_source_confusing PROTO ((const char *)) ATTRIBUTE_NORETURN;
117 /* Aliases for pointers to void.
118 These were made to facilitate compilation with old brain-dead DEC C
119 compilers which didn't properly grok `void*' types. */
121 typedef PTR pointer_type;
122 typedef const PTR const_pointer_type;
128 #else /* !defined(POSIX) */
130 /* Declaring stat or __flsbuf with a prototype
131 causes conflicts with system headers on some systems. */
133 #if 0 /* These conflict with stdio.h on some systems. */
135 extern int fprintf (FILE *, const char *, ...);
136 extern int printf (const char *, ...);
137 extern int open (const char *, int, ...);
142 extern int fflush ();
145 #ifndef fputs /* This may have been #defined by "system.h". */
148 #ifndef fputc /* some systems define this as a macro. */
151 extern int unlink ();
152 extern int access ();
154 #if 0 /* size_t from sys/types.h may fail to match GCC.
155 If so, we would get a warning from this. */
156 extern size_t strlen ()
159 #endif /* !defined (POSIX) */
161 /* Look for these where the `const' qualifier is intentionally cast aside. */
165 /* Define a default place to find the SYSCALLS.X file. */
167 #ifndef STD_PROTO_DIR
168 #define STD_PROTO_DIR "/usr/local/lib"
169 #endif /* !defined (STD_PROTO_DIR) */
171 /* Suffix of aux_info files. */
173 static const char * const aux_info_suffix = ".X";
175 /* String to attach to filenames for saved versions of original files. */
177 static const char * const save_suffix = ".save";
181 /* File name of the file which contains descriptions of standard system
182 routines. Note that we never actually do anything with this file per se,
183 but we do read in its corresponding aux_info file. */
185 static const char syscalls_filename[] = "SYSCALLS.c";
187 /* Default place to find the above file. */
189 static const char * const default_syscalls_dir = STD_PROTO_DIR;
191 /* Variable to hold the complete absolutized filename of the SYSCALLS.c.X
194 static char * syscalls_absolute_filename;
196 #endif /* !defined (UNPROTOIZE) */
198 /* Type of the structure that holds information about macro unexpansions. */
200 struct unexpansion_struct {
201 const char *expanded;
202 const char *contracted;
204 typedef struct unexpansion_struct unexpansion;
206 /* A table of conversions that may need to be made for some (stupid) older
207 operating systems where these types are preprocessor macros rather than
208 typedefs (as they really ought to be).
210 WARNING: The contracted forms must be as small (or smaller) as the
211 expanded forms, or else havoc will ensue. */
213 static const unexpansion unexpansions[] = {
214 { "struct _iobuf", "FILE" },
218 /* The number of "primary" slots in the hash tables for filenames and for
219 function names. This can be as big or as small as you like, except that
220 it must be a power of two. */
222 #define HASH_TABLE_SIZE (1 << 9)
224 /* Bit mask to use when computing hash values. */
226 static const int hash_mask = (HASH_TABLE_SIZE - 1);
228 /* Make a table of default system include directories
229 just as it is done in cccp.c. */
231 #ifndef STANDARD_INCLUDE_DIR
232 #define STANDARD_INCLUDE_DIR "/usr/include"
235 #ifndef LOCAL_INCLUDE_DIR
236 #define LOCAL_INCLUDE_DIR "/usr/local/include"
239 struct default_include { const char *fname;
240 const char *component;
241 int x1, x2; } include_defaults[]
242 #ifdef INCLUDE_DEFAULTS
246 /* Pick up GNU C++ specific include files. */
247 { GPLUSPLUS_INCLUDE_DIR, "G++", 1, 1 },
249 /* This is the dir for fixincludes. Put it just before
250 the files that we fix. */
251 { GCC_INCLUDE_DIR, "GCC", 0, 0 },
252 /* For cross-compilation, this dir name is generated
253 automatically in Makefile.in. */
254 { CROSS_INCLUDE_DIR, 0, 0, 0 },
255 /* This is another place that the target system's headers might be. */
256 { TOOL_INCLUDE_DIR, "BINUTILS", 0, 0 },
257 #else /* not CROSS_COMPILE */
258 /* This should be /use/local/include and should come before
259 the fixincludes-fixed header files. */
260 { LOCAL_INCLUDE_DIR, 0, 0, 1 },
261 /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
262 Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h. */
263 { TOOL_INCLUDE_DIR, "BINUTILS", 0, 0 },
264 /* This is the dir for fixincludes. Put it just before
265 the files that we fix. */
266 { GCC_INCLUDE_DIR, "GCC", 0, 0 },
267 /* Some systems have an extra dir of include files. */
268 #ifdef SYSTEM_INCLUDE_DIR
269 { SYSTEM_INCLUDE_DIR, 0, 0, 0 },
271 { STANDARD_INCLUDE_DIR, 0, 0, 0},
272 #endif /* not CROSS_COMPILE */
275 #endif /* no INCLUDE_DEFAULTS */
277 /* Datatype for lists of directories or filenames. */
281 struct string_list *next;
284 /* List of directories in which files should be converted. */
286 struct string_list *directory_list;
288 /* List of file names which should not be converted.
289 A file is excluded if the end of its name, following a /,
290 matches one of the names in this list. */
292 struct string_list *exclude_list;
294 /* The name of the other style of variable-number-of-parameters functions
295 (i.e. the style that we want to leave unconverted because we don't yet
296 know how to convert them to this style. This string is used in warning
299 /* Also define here the string that we can search for in the parameter lists
300 taken from the .X files which will unambiguously indicate that we have
301 found a varargs style function. */
304 static const char * const other_var_style = "stdarg";
305 #else /* !defined (UNPROTOIZE) */
306 static const char * const other_var_style = "varargs";
307 /* Note that this is a string containing the expansion of va_alist.
308 But in `main' we discard all but the first token. */
309 static const char *varargs_style_indicator = STRINGIFY (va_alist);
310 #endif /* !defined (UNPROTOIZE) */
312 /* The following two types are used to create hash tables. In this program,
313 there are two hash tables which are used to store and quickly lookup two
314 different classes of strings. The first type of strings stored in the
315 first hash table are absolute filenames of files which protoize needs to
316 know about. The second type of strings (stored in the second hash table)
317 are function names. It is this second class of strings which really
318 inspired the use of the hash tables, because there may be a lot of them. */
320 typedef struct hash_table_entry_struct hash_table_entry;
322 /* Do some typedefs so that we don't have to write "struct" so often. */
324 typedef struct def_dec_info_struct def_dec_info;
325 typedef struct file_info_struct file_info;
326 typedef struct f_list_chain_item_struct f_list_chain_item;
328 /* In the struct below, note that the "_info" field has two different uses
329 depending on the type of hash table we are in (i.e. either the filenames
330 hash table or the function names hash table). In the filenames hash table
331 the info fields of the entries point to the file_info struct which is
332 associated with each filename (1 per filename). In the function names
333 hash table, the info field points to the head of a singly linked list of
334 def_dec_info entries which are all defs or decs of the function whose
335 name is pointed to by the "symbol" field. Keeping all of the defs/decs
336 for a given function name on a special list specifically for that function
337 name makes it quick and easy to find out all of the important information
338 about a given (named) function. */
340 struct hash_table_entry_struct {
341 hash_table_entry * hash_next; /* -> to secondary entries */
342 const char * symbol; /* -> to the hashed string */
344 const def_dec_info * _ddip;
348 #define ddip _info._ddip
349 #define fip _info._fip
351 /* Define a type specifically for our two hash tables. */
353 typedef hash_table_entry hash_table[HASH_TABLE_SIZE];
355 /* The following struct holds all of the important information about any
356 single filename (e.g. file) which we need to know about. */
358 struct file_info_struct {
359 const hash_table_entry * hash_entry; /* -> to associated hash entry */
360 const def_dec_info * defs_decs; /* -> to chain of defs/decs */
361 time_t mtime; /* Time of last modification. */
364 /* Due to the possibility that functions may return pointers to functions,
365 (which may themselves have their own parameter lists) and due to the
366 fact that returned pointers-to-functions may be of type "pointer-to-
367 function-returning-pointer-to-function" (ad nauseum) we have to keep
368 an entire chain of ANSI style formal parameter lists for each function.
370 Normally, for any given function, there will only be one formals list
371 on the chain, but you never know.
373 Note that the head of each chain of formals lists is pointed to by the
374 `f_list_chain' field of the corresponding def_dec_info record.
376 For any given chain, the item at the head of the chain is the *leftmost*
377 parameter list seen in the actual C language function declaration. If
378 there are other members of the chain, then these are linked in left-to-right
379 order from the head of the chain. */
381 struct f_list_chain_item_struct {
382 const f_list_chain_item * chain_next; /* -> to next item on chain */
383 const char * formals_list; /* -> to formals list string */
386 /* The following struct holds all of the important information about any
387 single function definition or declaration which we need to know about.
388 Note that for unprotoize we don't need to know very much because we
389 never even create records for stuff that we don't intend to convert
390 (like for instance defs and decs which are already in old K&R format
391 and "implicit" function declarations). */
393 struct def_dec_info_struct {
394 const def_dec_info * next_in_file; /* -> to rest of chain for file */
395 file_info * file; /* -> file_info for containing file */
396 int line; /* source line number of def/dec */
397 const char * ansi_decl; /* -> left end of ansi decl */
398 hash_table_entry * hash_entry; /* -> hash entry for function name */
399 unsigned int is_func_def; /* = 0 means this is a declaration */
400 const def_dec_info * next_for_func; /* -> to rest of chain for func name */
401 unsigned int f_list_count; /* count of formals lists we expect */
402 char prototyped; /* = 0 means already prototyped */
404 const f_list_chain_item * f_list_chain; /* -> chain of formals lists */
405 const def_dec_info * definition; /* -> def/dec containing related def */
406 char is_static; /* = 0 means visibility is "extern" */
407 char is_implicit; /* != 0 for implicit func decl's */
408 char written; /* != 0 means written for implicit */
409 #else /* !defined (UNPROTOIZE) */
410 const char * formal_names; /* -> to list of names of formals */
411 const char * formal_decls; /* -> to string of formal declarations */
412 #endif /* !defined (UNPROTOIZE) */
415 /* Pointer to the tail component of the filename by which this program was
416 invoked. Used everywhere in error and warning messages. */
418 static const char *pname;
420 /* Error counter. Will be non-zero if we should give up at the next convenient
423 static int errors = 0;
426 /* ??? These comments should say what the flag mean as well as the options
429 /* File name to use for running gcc. Allows GCC 2 to be named
430 something other than gcc. */
431 static const char *compiler_file_name = "gcc";
433 static int version_flag = 0; /* Print our version number. */
434 static int quiet_flag = 0; /* Don't print messages normally. */
435 static int nochange_flag = 0; /* Don't convert, just say what files
436 we would have converted. */
437 static int nosave_flag = 0; /* Don't save the old version. */
438 static int keep_flag = 0; /* Don't delete the .X files. */
439 static const char ** compile_params = 0; /* Option string for gcc. */
441 static const char *indent_string = " "; /* Indentation for newly
442 inserted parm decls. */
443 #else /* !defined (UNPROTOIZE) */
444 static int local_flag = 0; /* Insert new local decls (when?). */
445 static int global_flag = 0; /* set by -g option */
446 static int cplusplus_flag = 0; /* Rename converted files to *.C. */
447 static const char *nondefault_syscalls_dir = 0; /* Dir to look for
449 #endif /* !defined (UNPROTOIZE) */
451 /* An index into the compile_params array where we should insert the source
452 file name when we are ready to exec the C compiler. A zero value indicates
453 that we have not yet called munge_compile_params. */
455 static int input_file_name_index = 0;
457 /* An index into the compile_params array where we should insert the filename
458 for the aux info file, when we run the C compiler. */
459 static int aux_info_file_name_index = 0;
461 /* Count of command line arguments which were "filename" arguments. */
463 static int n_base_source_files = 0;
465 /* Points to a malloc'ed list of pointers to all of the filenames of base
466 source files which were specified on the command line. */
468 static const char **base_source_filenames;
470 /* Line number of the line within the current aux_info file that we
471 are currently processing. Used for error messages in case the prototypes
472 info file is corrupted somehow. */
474 static int current_aux_info_lineno;
476 /* Pointer to the name of the source file currently being converted. */
478 static const char *convert_filename;
480 /* Pointer to relative root string (taken from aux_info file) which indicates
481 where directory the user was in when he did the compilation step that
482 produced the containing aux_info file. */
484 static const char *invocation_filename;
486 /* Pointer to the base of the input buffer that holds the original text for the
487 source file currently being converted. */
489 static const char *orig_text_base;
491 /* Pointer to the byte just beyond the end of the input buffer that holds the
492 original text for the source file currently being converted. */
494 static const char *orig_text_limit;
496 /* Pointer to the base of the input buffer that holds the cleaned text for the
497 source file currently being converted. */
499 static const char *clean_text_base;
501 /* Pointer to the byte just beyond the end of the input buffer that holds the
502 cleaned text for the source file currently being converted. */
504 static const char *clean_text_limit;
506 /* Pointer to the last byte in the cleaned text buffer that we have already
507 (virtually) copied to the output buffer (or decided to ignore). */
509 static const char * clean_read_ptr;
511 /* Pointer to the base of the output buffer that holds the replacement text
512 for the source file currently being converted. */
514 static char *repl_text_base;
516 /* Pointer to the byte just beyond the end of the output buffer that holds the
517 replacement text for the source file currently being converted. */
519 static char *repl_text_limit;
521 /* Pointer to the last byte which has been stored into the output buffer.
522 The next byte to be stored should be stored just past where this points
525 static char * repl_write_ptr;
527 /* Pointer into the cleaned text buffer for the source file we are currently
528 converting. This points to the first character of the line that we last
529 did a "seek_to_line" to (see below). */
531 static const char *last_known_line_start;
533 /* Number of the line (in the cleaned text buffer) that we last did a
534 "seek_to_line" to. Will be one if we just read a new source file
535 into the cleaned text buffer. */
537 static int last_known_line_number;
539 /* The filenames hash table. */
541 static hash_table filename_primary;
543 /* The function names hash table. */
545 static hash_table function_name_primary;
547 /* The place to keep the recovery address which is used only in cases where
548 we get hopelessly confused by something in the cleaned original text. */
550 static jmp_buf source_confusion_recovery;
552 /* A pointer to the current directory filename (used by abspath). */
554 static char *cwd_buffer;
556 /* A place to save the read pointer until we are sure that an individual
557 attempt at editing will succeed. */
559 static const char * saved_clean_read_ptr;
561 /* A place to save the write pointer until we are sure that an individual
562 attempt at editing will succeed. */
564 static char * saved_repl_write_ptr;
566 /* Forward declaration. */
568 static const char *shortpath ();
570 /* Translate and output an error message. */
571 static void notice PVPROTO ((const char *, ...))
574 notice VPROTO ((const char *msgid, ...))
576 #ifndef ANSI_PROTOTYPES
581 VA_START (ap, msgid);
583 #ifndef ANSI_PROTOTYPES
584 msgid = va_arg (ap, const char *);
587 vfprintf (stderr, _(msgid), ap);
604 if (e > 0 && e < sys_nerr)
605 return sys_errlist[e];
611 /* Allocate some space, but check that the allocation was successful. */
612 /* alloca.c uses this, so don't make it static. */
618 register pointer_type rv = (pointer_type) malloc (byte_count);
621 notice ("\n%s: virtual memory exceeded\n", pname);
622 exit (FATAL_EXIT_CODE);
627 /* Reallocate some space, but check that the reallocation was successful. */
630 xrealloc (old_space, byte_count)
631 pointer_type old_space;
634 register pointer_type rv;
636 rv = (pointer_type) realloc (old_space, byte_count);
638 rv = (pointer_type) malloc (byte_count);
641 notice ("\n%s: virtual memory exceeded\n", pname);
642 exit (FATAL_EXIT_CODE);
647 /* Deallocate the area pointed to by an arbitrary pointer, but first, strip
648 the `const' qualifier from it and also make sure that the pointer value
653 const_pointer_type p;
656 free ((NONCONST pointer_type) p);
659 /* Make a copy of a string INPUT with size SIZE. */
662 savestring (input, size)
666 char *output = (char *) xmalloc (size + 1);
667 strcpy (output, input);
671 /* Make a copy of the concatenation of INPUT1 and INPUT2. */
674 savestring2 (input1, size1, input2, size2)
680 char *output = (char *) xmalloc (size1 + size2 + 1);
681 strcpy (output, input1);
682 strcpy (&output[size1], input2);
686 /* More 'friendly' abort that prints the line and file.
687 config.h can #define abort fancy_abort if you like that sort of thing. */
692 notice ("%s: internal abort\n", pname);
693 exit (FATAL_EXIT_CODE);
696 /* Make a duplicate of the first N bytes of a given string in a newly
704 char *ret_val = (char *) xmalloc (n + 1);
706 strncpy (ret_val, s, n);
711 /* Return a pointer to the first occurrence of s2 within s1 or NULL if s2
712 does not occur within s1. Assume neither s1 nor s2 are null pointers. */
717 const char *const s2;
725 for (p1 = s1, p2 = s2; (c = *p2); p1++, p2++)
735 /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
736 retrying if necessary. Return the actual number of bytes read. */
739 safe_read (desc, ptr, len)
746 int nchars = read (desc, ptr, left);
763 /* Write LEN bytes at PTR to descriptor DESC,
764 retrying if necessary, and treating any real error as fatal. */
767 safe_write (desc, ptr, len, out_fname)
774 int written = write (desc, ptr, len);
777 int errno_val = errno;
779 if (errno_val == EINTR)
782 notice ("%s: error writing file `%s': %s\n",
783 pname, shortpath (NULL, out_fname), xstrerror (errno_val));
791 /* Get setup to recover in case the edit we are about to do goes awry. */
796 saved_clean_read_ptr = clean_read_ptr;
797 saved_repl_write_ptr = repl_write_ptr;
800 /* Call this routine to recover our previous state whenever something looks
801 too confusing in the source code we are trying to edit. */
806 clean_read_ptr = saved_clean_read_ptr;
807 repl_write_ptr = saved_repl_write_ptr;
810 /* Return true if the given character is a valid identifier character. */
816 return (ISALNUM (ch) || (ch == '_') || (ch == '$'));
819 /* Give a message indicating the proper way to invoke this program and then
820 exit with non-zero status. */
826 notice ("%s: usage '%s [ -VqfnkN ] [ -i <istring> ] [ filename ... ]'\n",
828 #else /* !defined (UNPROTOIZE) */
829 notice ("%s: usage '%s [ -VqfnkNlgC ] [ -B <dirname> ] [ filename ... ]'\n",
831 #endif /* !defined (UNPROTOIZE) */
832 exit (FATAL_EXIT_CODE);
835 /* Return true if the given filename (assumed to be an absolute filename)
836 designates a file residing anywhere beneath any one of the "system"
837 include directories. */
840 in_system_include_dir (path)
843 struct default_include *p;
846 abort (); /* Must be an absolutized filename. */
848 for (p = include_defaults; p->fname; p++)
849 if (!strncmp (path, p->fname, strlen (p->fname))
850 && path[strlen (p->fname)] == '/')
856 /* Return true if the given filename designates a file that the user has
857 read access to and for which the user has write access to the containing
861 file_could_be_converted (const char *path)
863 char *const dir_name = (char *) alloca (strlen (path) + 1);
865 if (my_access (path, R_OK))
869 char *dir_last_slash;
871 strcpy (dir_name, path);
872 dir_last_slash = strrchr (dir_name, '/');
874 *dir_last_slash = '\0';
876 abort (); /* Should have been an absolutized filename. */
879 if (my_access (path, W_OK))
885 /* Return true if the given filename designates a file that we are allowed
886 to modify. Files which we should not attempt to modify are (a) "system"
887 include files, and (b) files which the user doesn't have write access to,
888 and (c) files which reside in directories which the user doesn't have
889 write access to. Unless requested to be quiet, give warnings about
890 files that we will not try to convert for one reason or another. An
891 exception is made for "system" include files, which we never try to
892 convert and for which we don't issue the usual warnings. */
895 file_normally_convertible (const char *path)
897 char *const dir_name = alloca (strlen (path) + 1);
899 if (in_system_include_dir (path))
903 char *dir_last_slash;
905 strcpy (dir_name, path);
906 dir_last_slash = strrchr (dir_name, '/');
908 *dir_last_slash = '\0';
910 abort (); /* Should have been an absolutized filename. */
913 if (my_access (path, R_OK))
916 notice ("%s: warning: no read access for file `%s'\n",
917 pname, shortpath (NULL, path));
921 if (my_access (path, W_OK))
924 notice ("%s: warning: no write access for file `%s'\n",
925 pname, shortpath (NULL, path));
929 if (my_access (dir_name, W_OK))
932 notice ("%s: warning: no write access for dir containing `%s'\n",
933 pname, shortpath (NULL, path));
943 /* Return true if the given file_info struct refers to the special SYSCALLS.c.X
944 file. Return false otherwise. */
947 is_syscalls_file (fi_p)
948 const file_info *fi_p;
950 char const *f = fi_p->hash_entry->symbol;
951 size_t fl = strlen (f), sysl = sizeof (syscalls_filename) - 1;
952 return sysl <= fl && strcmp (f + fl - sysl, syscalls_filename) == 0;
955 #endif /* !defined (UNPROTOIZE) */
957 /* Check to see if this file will need to have anything done to it on this
958 run. If there is nothing in the given file which both needs conversion
959 and for which we have the necessary stuff to do the conversion, return
960 false. Otherwise, return true.
962 Note that (for protoize) it is only valid to call this function *after*
963 the connections between declarations and definitions have all been made
964 by connect_defs_and_decs. */
967 needs_to_be_converted (file_p)
968 const file_info *file_p;
970 const def_dec_info *ddp;
974 if (is_syscalls_file (file_p))
977 #endif /* !defined (UNPROTOIZE) */
979 for (ddp = file_p->defs_decs; ddp; ddp = ddp->next_in_file)
985 /* ... and if we a protoizing and this function is in old style ... */
987 /* ... and if this a definition or is a decl with an associated def ... */
988 && (ddp->is_func_def || (!ddp->is_func_def && ddp->definition))
990 #else /* defined (UNPROTOIZE) */
992 /* ... and if we are unprotoizing and this function is in new style ... */
995 #endif /* defined (UNPROTOIZE) */
997 /* ... then the containing file needs converting. */
1002 /* Return 1 if the file name NAME is in a directory
1003 that should be converted. */
1006 directory_specified_p (name)
1009 struct string_list *p;
1011 for (p = directory_list; p; p = p->next)
1012 if (!strncmp (name, p->name, strlen (p->name))
1013 && name[strlen (p->name)] == '/')
1015 const char *q = name + strlen (p->name) + 1;
1017 /* If there are more slashes, it's in a subdir, so
1018 this match doesn't count. */
1030 /* Return 1 if the file named NAME should be excluded from conversion. */
1033 file_excluded_p (name)
1036 struct string_list *p;
1037 int len = strlen (name);
1039 for (p = exclude_list; p; p = p->next)
1040 if (!strcmp (name + len - strlen (p->name), p->name)
1041 && name[len - strlen (p->name) - 1] == '/')
1047 /* Construct a new element of a string_list.
1048 STRING is the new element value, and REST holds the remaining elements. */
1050 static struct string_list *
1051 string_list_cons (string, rest)
1053 struct string_list *rest;
1055 struct string_list *temp
1056 = (struct string_list *) xmalloc (sizeof (struct string_list));
1059 temp->name = string;
1063 /* ??? The GNU convention for mentioning function args in its comments
1064 is to capitalize them. So change "hash_tab_p" to HASH_TAB_P below.
1065 Likewise for all the other functions. */
1067 /* Given a hash table, apply some function to each node in the table. The
1068 table to traverse is given as the "hash_tab_p" argument, and the
1069 function to be applied to each node in the table is given as "func"
1073 visit_each_hash_node (hash_tab_p, func)
1074 const hash_table_entry *hash_tab_p;
1077 const hash_table_entry *primary;
1079 for (primary = hash_tab_p; primary < &hash_tab_p[HASH_TABLE_SIZE]; primary++)
1080 if (primary->symbol)
1082 hash_table_entry *second;
1085 for (second = primary->hash_next; second; second = second->hash_next)
1090 /* Initialize all of the fields of a new hash table entry, pointed
1091 to by the "p" parameter. Note that the space to hold the entry
1092 is assumed to have already been allocated before this routine is
1095 static hash_table_entry *
1097 hash_table_entry *p;
1100 p->hash_next = NULL;
1101 p->symbol = savestring (s, strlen (s));
1107 /* Look for a particular function name or filename in the particular
1108 hash table indicated by "hash_tab_p". If the name is not in the
1109 given hash table, add it. Either way, return a pointer to the
1110 hash table entry for the given name. */
1112 static hash_table_entry *
1113 lookup (hash_tab_p, search_symbol)
1114 hash_table_entry *hash_tab_p;
1115 const char *search_symbol;
1118 const char *search_symbol_char_p = search_symbol;
1119 hash_table_entry *p;
1121 while (*search_symbol_char_p)
1122 hash_value += *search_symbol_char_p++;
1123 hash_value &= hash_mask;
1124 p = &hash_tab_p[hash_value];
1126 return add_symbol (p, search_symbol);
1127 if (!strcmp (p->symbol, search_symbol))
1129 while (p->hash_next)
1132 if (!strcmp (p->symbol, search_symbol))
1135 p->hash_next = (hash_table_entry *) xmalloc (sizeof (hash_table_entry));
1137 return add_symbol (p, search_symbol);
1140 /* Throw a def/dec record on the junk heap.
1142 Also, since we are not using this record anymore, free up all of the
1143 stuff it pointed to. */
1149 xfree (p->ansi_decl);
1153 const f_list_chain_item * curr;
1154 const f_list_chain_item * next;
1156 for (curr = p->f_list_chain; curr; curr = next)
1158 next = curr->chain_next;
1162 #endif /* !defined (UNPROTOIZE) */
1167 /* Unexpand as many macro symbol as we can find.
1169 If the given line must be unexpanded, make a copy of it in the heap and
1170 return a pointer to the unexpanded copy. Otherwise return NULL. */
1173 unexpand_if_needed (aux_info_line)
1174 const char *aux_info_line;
1176 static char *line_buf = 0;
1177 static int line_buf_size = 0;
1178 const unexpansion *unexp_p;
1179 int got_unexpanded = 0;
1181 char *copy_p = line_buf;
1185 line_buf_size = 1024;
1186 line_buf = (char *) xmalloc (line_buf_size);
1191 /* Make a copy of the input string in line_buf, expanding as necessary. */
1193 for (s = aux_info_line; *s != '\n'; )
1195 for (unexp_p = unexpansions; unexp_p->expanded; unexp_p++)
1197 const char *in_p = unexp_p->expanded;
1198 size_t len = strlen (in_p);
1200 if (*s == *in_p && !strncmp (s, in_p, len) && !is_id_char (s[len]))
1202 int size = strlen (unexp_p->contracted);
1204 if (copy_p + size - line_buf >= line_buf_size)
1206 int offset = copy_p - line_buf;
1208 line_buf_size += size;
1209 line_buf = (char *) xrealloc (line_buf, line_buf_size);
1210 copy_p = line_buf + offset;
1212 strcpy (copy_p, unexp_p->contracted);
1215 /* Assume the there will not be another replacement required
1216 within the text just replaced. */
1219 goto continue_outer;
1222 if (copy_p - line_buf == line_buf_size)
1224 int offset = copy_p - line_buf;
1226 line_buf = (char *) xrealloc (line_buf, line_buf_size);
1227 copy_p = line_buf + offset;
1232 if (copy_p + 2 - line_buf >= line_buf_size)
1234 int offset = copy_p - line_buf;
1236 line_buf = (char *) xrealloc (line_buf, line_buf_size);
1237 copy_p = line_buf + offset;
1242 return (got_unexpanded ? savestring (line_buf, copy_p - line_buf) : 0);
1245 /* Return the absolutized filename for the given relative
1246 filename. Note that if that filename is already absolute, it may
1247 still be returned in a modified form because this routine also
1248 eliminates redundant slashes and single dots and eliminates double
1249 dots to get a shortest possible filename from the given input
1250 filename. The absolutization of relative filenames is made by
1251 assuming that the given filename is to be taken as relative to
1252 the first argument (cwd) or to the current directory if cwd is
1256 abspath (cwd, rel_filename)
1258 const char *rel_filename;
1260 /* Setup the current working directory as needed. */
1261 const char *cwd2 = (cwd) ? cwd : cwd_buffer;
1262 char *const abs_buffer
1263 = (char *) alloca (strlen (cwd2) + strlen (rel_filename) + 2);
1264 char *endp = abs_buffer;
1267 /* Copy the filename (possibly preceded by the current working
1268 directory name) into the absolutization buffer. */
1273 if (rel_filename[0] != '/')
1276 while ((*endp++ = *src_p++))
1278 *(endp-1) = '/'; /* overwrite null */
1280 src_p = rel_filename;
1281 while ((*endp++ = *src_p++))
1285 /* Now make a copy of abs_buffer into abs_buffer, shortening the
1286 filename (by taking out slashes and dots) as we go. */
1288 outp = inp = abs_buffer;
1289 *outp++ = *inp++; /* copy first slash */
1290 #if defined (apollo) || defined (_WIN32) || defined (__INTERIX)
1292 *outp++ = *inp++; /* copy second slash */
1298 else if (inp[0] == '/' && outp[-1] == '/')
1303 else if (inp[0] == '.' && outp[-1] == '/')
1307 else if (inp[1] == '/')
1312 else if ((inp[1] == '.') && (inp[2] == 0 || inp[2] == '/'))
1314 inp += (inp[2] == '/') ? 3 : 2;
1316 while (outp >= abs_buffer && *outp != '/')
1318 if (outp < abs_buffer)
1320 /* Catch cases like /.. where we try to backup to a
1321 point above the absolute root of the logical file
1324 notice ("%s: invalid file name: %s\n",
1325 pname, rel_filename);
1326 exit (FATAL_EXIT_CODE);
1335 /* On exit, make sure that there is a trailing null, and make sure that
1336 the last character of the returned string is *not* a slash. */
1339 if (outp[-1] == '/')
1342 /* Make a copy (in the heap) of the stuff left in the absolutization
1343 buffer and return a pointer to the copy. */
1345 return savestring (abs_buffer, outp - abs_buffer);
1348 /* Given a filename (and possibly a directory name from which the filename
1349 is relative) return a string which is the shortest possible
1350 equivalent for the corresponding full (absolutized) filename. The
1351 shortest possible equivalent may be constructed by converting the
1352 absolutized filename to be a relative filename (i.e. relative to
1353 the actual current working directory). However if a relative filename
1354 is longer, then the full absolute filename is returned.
1358 Note that "simple-minded" conversion of any given type of filename (either
1359 relative or absolute) may not result in a valid equivalent filename if any
1360 subpart of the original filename is actually a symbolic link. */
1363 shortpath (cwd, filename)
1365 const char *filename;
1369 char *cwd_p = cwd_buffer;
1371 int unmatched_slash_count = 0;
1372 size_t filename_len = strlen (filename);
1374 path_p = abspath (cwd, filename);
1375 rel_buf_p = rel_buffer = (char *) xmalloc (filename_len);
1377 while (*cwd_p && (*cwd_p == *path_p))
1382 if (!*cwd_p && (!*path_p || *path_p == '/')) /* whole pwd matched */
1384 if (!*path_p) /* input *is* the current path! */
1395 while (*cwd_p != '/') /* backup to last slash */
1402 unmatched_slash_count++;
1405 /* Find out how many directory levels in cwd were *not* matched. */
1407 if (*cwd_p++ == '/')
1408 unmatched_slash_count++;
1410 /* Now we know how long the "short name" will be.
1411 Reject it if longer than the input. */
1412 if (unmatched_slash_count * 3 + strlen (path_p) >= filename_len)
1415 /* For each of them, put a `../' at the beginning of the short name. */
1416 while (unmatched_slash_count--)
1418 /* Give up if the result gets to be longer
1419 than the absolute path name. */
1420 if (rel_buffer + filename_len <= rel_buf_p + 3)
1427 /* Then tack on the unmatched part of the desired file's name. */
1430 if (rel_buffer + filename_len <= rel_buf_p)
1433 while ((*rel_buf_p++ = *path_p++));
1436 if (*(rel_buf_p-1) == '/')
1437 *--rel_buf_p = '\0';
1442 /* Lookup the given filename in the hash table for filenames. If it is a
1443 new one, then the hash table info pointer will be null. In this case,
1444 we create a new file_info record to go with the filename, and we initialize
1445 that record with some reasonable values. */
1447 /* FILENAME was const, but that causes a warning on AIX when calling stat.
1448 That is probably a bug in AIX, but might as well avoid the warning. */
1451 find_file (filename, do_not_stat)
1455 hash_table_entry *hash_entry_p;
1457 hash_entry_p = lookup (filename_primary, filename);
1458 if (hash_entry_p->fip)
1459 return hash_entry_p->fip;
1462 struct stat stat_buf;
1463 file_info *file_p = (file_info *) xmalloc (sizeof (file_info));
1465 /* If we cannot get status on any given source file, give a warning
1466 and then just set its time of last modification to infinity. */
1469 stat_buf.st_mtime = (time_t) 0;
1472 if (my_stat (filename, &stat_buf) == -1)
1474 int errno_val = errno;
1475 notice ("%s: %s: can't get status: %s\n",
1476 pname, shortpath (NULL, filename),
1477 xstrerror (errno_val));
1478 stat_buf.st_mtime = (time_t) -1;
1482 hash_entry_p->fip = file_p;
1483 file_p->hash_entry = hash_entry_p;
1484 file_p->defs_decs = NULL;
1485 file_p->mtime = stat_buf.st_mtime;
1490 /* Generate a fatal error because some part of the aux_info file is
1494 aux_info_corrupted ()
1496 notice ("\n%s: fatal error: aux info file corrupted at line %d\n",
1497 pname, current_aux_info_lineno);
1498 exit (FATAL_EXIT_CODE);
1501 /* ??? This comment is vague. Say what the condition is for. */
1502 /* Check to see that a condition is true. This is kind of like an assert. */
1505 check_aux_info (cond)
1509 aux_info_corrupted ();
1512 /* Given a pointer to the closing right parenthesis for a particular formals
1513 list (in an aux_info file) find the corresponding left parenthesis and
1514 return a pointer to it. */
1517 find_corresponding_lparen (p)
1523 for (paren_depth = 1, q = p-1; paren_depth; q--)
1538 /* Given a line from an aux info file, and a time at which the aux info
1539 file it came from was created, check to see if the item described in
1540 the line comes from a file which has been modified since the aux info
1541 file was created. If so, return non-zero, else return zero. */
1544 referenced_file_is_newer (l, aux_info_mtime)
1546 time_t aux_info_mtime;
1552 check_aux_info (l[0] == '/');
1553 check_aux_info (l[1] == '*');
1554 check_aux_info (l[2] == ' ');
1557 const char *filename_start = p = l + 3;
1561 filename = (char *) alloca ((size_t) (p - filename_start) + 1);
1562 strncpy (filename, filename_start, (size_t) (p - filename_start));
1563 filename[p-filename_start] = '\0';
1566 /* Call find_file to find the file_info record associated with the file
1567 which contained this particular def or dec item. Note that this call
1568 may cause a new file_info record to be created if this is the first time
1569 that we have ever known about this particular file. */
1571 fi_p = find_file (abspath (invocation_filename, filename), 0);
1573 return (fi_p->mtime > aux_info_mtime);
1576 /* Given a line of info from the aux_info file, create a new
1577 def_dec_info record to remember all of the important information about
1578 a function definition or declaration.
1580 Link this record onto the list of such records for the particular file in
1581 which it occurred in proper (descending) line number order (for now).
1583 If there is an identical record already on the list for the file, throw
1584 this one away. Doing so takes care of the (useless and troublesome)
1585 duplicates which are bound to crop up due to multiple inclusions of any
1586 given individual header file.
1588 Finally, link the new def_dec record onto the list of such records
1589 pertaining to this particular function name. */
1592 save_def_or_dec (l, is_syscalls)
1597 const char *semicolon_p;
1598 def_dec_info *def_dec_p = (def_dec_info *) xmalloc (sizeof (def_dec_info));
1601 def_dec_p->written = 0;
1602 #endif /* !defined (UNPROTOIZE) */
1604 /* Start processing the line by picking off 5 pieces of information from
1605 the left hand end of the line. These are filename, line number,
1606 new/old/implicit flag (new = ANSI prototype format), definition or
1607 declaration flag, and extern/static flag). */
1609 check_aux_info (l[0] == '/');
1610 check_aux_info (l[1] == '*');
1611 check_aux_info (l[2] == ' ');
1614 const char *filename_start = p = l + 3;
1619 filename = (char *) alloca ((size_t) (p - filename_start) + 1);
1620 strncpy (filename, filename_start, (size_t) (p - filename_start));
1621 filename[p-filename_start] = '\0';
1623 /* Call find_file to find the file_info record associated with the file
1624 which contained this particular def or dec item. Note that this call
1625 may cause a new file_info record to be created if this is the first time
1626 that we have ever known about this particular file.
1628 Note that we started out by forcing all of the base source file names
1629 (i.e. the names of the aux_info files with the .X stripped off) into the
1630 filenames hash table, and we simultaneously setup file_info records for
1631 all of these base file names (even if they may be useless later).
1632 The file_info records for all of these "base" file names (properly)
1633 act as file_info records for the "original" (i.e. un-included) files
1634 which were submitted to gcc for compilation (when the -aux-info
1635 option was used). */
1637 def_dec_p->file = find_file (abspath (invocation_filename, filename), is_syscalls);
1641 const char *line_number_start = ++p;
1642 char line_number[10];
1646 strncpy (line_number, line_number_start, (size_t) (p - line_number_start));
1647 line_number[p-line_number_start] = '\0';
1648 def_dec_p->line = atoi (line_number);
1651 /* Check that this record describes a new-style, old-style, or implicit
1652 definition or declaration. */
1654 p++; /* Skip over the `:'. */
1655 check_aux_info ((*p == 'N') || (*p == 'O') || (*p == 'I'));
1657 /* Is this a new style (ANSI prototyped) definition or declaration? */
1659 def_dec_p->prototyped = (*p == 'N');
1663 /* Is this an implicit declaration? */
1665 def_dec_p->is_implicit = (*p == 'I');
1667 #endif /* !defined (UNPROTOIZE) */
1671 check_aux_info ((*p == 'C') || (*p == 'F'));
1673 /* Is this item a function definition (F) or a declaration (C). Note that
1674 we treat item taken from the syscalls file as though they were function
1675 definitions regardless of what the stuff in the file says. */
1677 def_dec_p->is_func_def = ((*p++ == 'F') || is_syscalls);
1680 def_dec_p->definition = 0; /* Fill this in later if protoizing. */
1681 #endif /* !defined (UNPROTOIZE) */
1683 check_aux_info (*p++ == ' ');
1684 check_aux_info (*p++ == '*');
1685 check_aux_info (*p++ == '/');
1686 check_aux_info (*p++ == ' ');
1689 check_aux_info ((!strncmp (p, "static", 6)) || (!strncmp (p, "extern", 6)));
1690 #else /* !defined (UNPROTOIZE) */
1691 if (!strncmp (p, "static", 6))
1692 def_dec_p->is_static = -1;
1693 else if (!strncmp (p, "extern", 6))
1694 def_dec_p->is_static = 0;
1696 check_aux_info (0); /* Didn't find either `extern' or `static'. */
1697 #endif /* !defined (UNPROTOIZE) */
1700 const char *ansi_start = p;
1702 p += 6; /* Pass over the "static" or "extern". */
1704 /* We are now past the initial stuff. Search forward from here to find
1705 the terminating semicolon that should immediately follow the entire
1706 ANSI format function declaration. */
1713 /* Make a copy of the ansi declaration part of the line from the aux_info
1716 def_dec_p->ansi_decl
1717 = dupnstr (ansi_start, (size_t) ((semicolon_p+1) - ansi_start));
1719 /* Backup and point at the final right paren of the final argument list. */
1724 def_dec_p->f_list_chain = NULL;
1725 #endif /* !defined (UNPROTOIZE) */
1727 while (p != ansi_start && (p[-1] == ' ' || p[-1] == '\t')) p--;
1730 free_def_dec (def_dec_p);
1735 /* Now isolate a whole set of formal argument lists, one-by-one. Normally,
1736 there will only be one list to isolate, but there could be more. */
1738 def_dec_p->f_list_count = 0;
1742 const char *left_paren_p = find_corresponding_lparen (p);
1745 f_list_chain_item *cip
1746 = (f_list_chain_item *) xmalloc (sizeof (f_list_chain_item));
1749 = dupnstr (left_paren_p + 1, (size_t) (p - (left_paren_p+1)));
1751 /* Add the new chain item at the head of the current list. */
1753 cip->chain_next = def_dec_p->f_list_chain;
1754 def_dec_p->f_list_chain = cip;
1756 #endif /* !defined (UNPROTOIZE) */
1757 def_dec_p->f_list_count++;
1759 p = left_paren_p - 2;
1761 /* p must now point either to another right paren, or to the last
1762 character of the name of the function that was declared/defined.
1763 If p points to another right paren, then this indicates that we
1764 are dealing with multiple formals lists. In that case, there
1765 really should be another right paren preceding this right paren. */
1770 check_aux_info (*--p == ')');
1775 const char *past_fn = p + 1;
1777 check_aux_info (*past_fn == ' ');
1779 /* Scan leftwards over the identifier that names the function. */
1781 while (is_id_char (*p))
1785 /* p now points to the leftmost character of the function name. */
1788 char *fn_string = (char *) alloca (past_fn - p + 1);
1790 strncpy (fn_string, p, (size_t) (past_fn - p));
1791 fn_string[past_fn-p] = '\0';
1792 def_dec_p->hash_entry = lookup (function_name_primary, fn_string);
1796 /* Look at all of the defs and decs for this function name that we have
1797 collected so far. If there is already one which is at the same
1798 line number in the same file, then we can discard this new def_dec_info
1801 As an extra assurance that any such pair of (nominally) identical
1802 function declarations are in fact identical, we also compare the
1803 ansi_decl parts of the lines from the aux_info files just to be on
1806 This comparison will fail if (for instance) the user was playing
1807 messy games with the preprocessor which ultimately causes one
1808 function declaration in one header file to look differently when
1809 that file is included by two (or more) other files. */
1812 const def_dec_info *other;
1814 for (other = def_dec_p->hash_entry->ddip; other; other = other->next_for_func)
1816 if (def_dec_p->line == other->line && def_dec_p->file == other->file)
1818 if (strcmp (def_dec_p->ansi_decl, other->ansi_decl))
1820 notice ("%s:%d: declaration of function `%s' takes different forms\n",
1821 def_dec_p->file->hash_entry->symbol,
1823 def_dec_p->hash_entry->symbol);
1824 exit (FATAL_EXIT_CODE);
1826 free_def_dec (def_dec_p);
1834 /* If we are doing unprotoizing, we must now setup the pointers that will
1835 point to the K&R name list and to the K&R argument declarations list.
1837 Note that if this is only a function declaration, then we should not
1838 expect to find any K&R style formals list following the ANSI-style
1839 formals list. This is because GCC knows that such information is
1840 useless in the case of function declarations (function definitions
1841 are a different story however).
1843 Since we are unprotoizing, we don't need any such lists anyway.
1844 All we plan to do is to delete all characters between ()'s in any
1847 def_dec_p->formal_names = NULL;
1848 def_dec_p->formal_decls = NULL;
1850 if (def_dec_p->is_func_def)
1853 check_aux_info (*++p == ' ');
1854 check_aux_info (*++p == '/');
1855 check_aux_info (*++p == '*');
1856 check_aux_info (*++p == ' ');
1857 check_aux_info (*++p == '(');
1860 const char *kr_names_start = ++p; /* Point just inside '('. */
1864 p--; /* point to closing right paren */
1866 /* Make a copy of the K&R parameter names list. */
1868 def_dec_p->formal_names
1869 = dupnstr (kr_names_start, (size_t) (p - kr_names_start));
1872 check_aux_info (*++p == ' ');
1875 /* p now points to the first character of the K&R style declarations
1876 list (if there is one) or to the star-slash combination that ends
1877 the comment in which such lists get embedded. */
1879 /* Make a copy of the K&R formal decls list and set the def_dec record
1882 if (*p == '*') /* Are there no K&R declarations? */
1884 check_aux_info (*++p == '/');
1885 def_dec_p->formal_decls = "";
1889 const char *kr_decls_start = p;
1891 while (p[0] != '*' || p[1] != '/')
1895 check_aux_info (*p == ' ');
1897 def_dec_p->formal_decls
1898 = dupnstr (kr_decls_start, (size_t) (p - kr_decls_start));
1901 /* Handle a special case. If we have a function definition marked as
1902 being in "old" style, and if its formal names list is empty, then
1903 it may actually have the string "void" in its real formals list
1904 in the original source code. Just to make sure, we will get setup
1905 to convert such things anyway.
1907 This kludge only needs to be here because of an insurmountable
1908 problem with generating .X files. */
1910 if (!def_dec_p->prototyped && !*def_dec_p->formal_names)
1911 def_dec_p->prototyped = 1;
1914 /* Since we are unprotoizing, if this item is already in old (K&R) style,
1915 we can just ignore it. If that is true, throw away the itme now. */
1917 if (!def_dec_p->prototyped)
1919 free_def_dec (def_dec_p);
1923 #endif /* defined (UNPROTOIZE) */
1925 /* Add this record to the head of the list of records pertaining to this
1926 particular function name. */
1928 def_dec_p->next_for_func = def_dec_p->hash_entry->ddip;
1929 def_dec_p->hash_entry->ddip = def_dec_p;
1931 /* Add this new def_dec_info record to the sorted list of def_dec_info
1932 records for this file. Note that we don't have to worry about duplicates
1933 (caused by multiple inclusions of header files) here because we have
1934 already eliminated duplicates above. */
1936 if (!def_dec_p->file->defs_decs)
1938 def_dec_p->file->defs_decs = def_dec_p;
1939 def_dec_p->next_in_file = NULL;
1943 int line = def_dec_p->line;
1944 const def_dec_info *prev = NULL;
1945 const def_dec_info *curr = def_dec_p->file->defs_decs;
1946 const def_dec_info *next = curr->next_in_file;
1948 while (next && (line < curr->line))
1952 next = next->next_in_file;
1954 if (line >= curr->line)
1956 def_dec_p->next_in_file = curr;
1958 ((NONCONST def_dec_info *) prev)->next_in_file = def_dec_p;
1960 def_dec_p->file->defs_decs = def_dec_p;
1962 else /* assert (next == NULL); */
1964 ((NONCONST def_dec_info *) curr)->next_in_file = def_dec_p;
1965 /* assert (next == NULL); */
1966 def_dec_p->next_in_file = next;
1971 /* Set up the vector COMPILE_PARAMS which is the argument list for running GCC.
1972 Also set input_file_name_index and aux_info_file_name_index
1973 to the indices of the slots where the file names should go. */
1975 /* We initialize the vector by removing -g, -O, -S, -c, and -o options,
1976 and adding '-aux-info AUXFILE -S -o /dev/null INFILE' at the end. */
1979 munge_compile_params (params_list)
1980 const char *params_list;
1982 /* Build up the contents in a temporary vector
1983 that is so big that to has to be big enough. */
1984 const char **temp_params
1985 = (const char **) alloca ((strlen (params_list) + 8) * sizeof (char *));
1986 int param_count = 0;
1989 temp_params[param_count++] = compiler_file_name;
1992 while (ISSPACE ((const unsigned char)*params_list))
1996 param = params_list;
1997 while (*params_list && !ISSPACE ((const unsigned char)*params_list))
1999 if (param[0] != '-')
2000 temp_params[param_count++]
2001 = dupnstr (param, (size_t) (params_list - param));
2010 break; /* Don't copy these. */
2012 while (ISSPACE ((const unsigned char)*params_list))
2015 && !ISSPACE ((const unsigned char)*params_list))
2019 temp_params[param_count++]
2020 = dupnstr (param, (size_t) (params_list - param));
2026 temp_params[param_count++] = "-aux-info";
2028 /* Leave room for the aux-info file name argument. */
2029 aux_info_file_name_index = param_count;
2030 temp_params[param_count++] = NULL;
2032 temp_params[param_count++] = "-S";
2033 temp_params[param_count++] = "-o";
2034 temp_params[param_count++] = "/dev/null";
2036 /* Leave room for the input file name argument. */
2037 input_file_name_index = param_count;
2038 temp_params[param_count++] = NULL;
2039 /* Terminate the list. */
2040 temp_params[param_count++] = NULL;
2042 /* Make a copy of the compile_params in heap space. */
2045 = (const char **) xmalloc (sizeof (char *) * (param_count+1));
2046 memcpy (compile_params, temp_params, sizeof (char *) * param_count);
2049 /* Do a recompilation for the express purpose of generating a new aux_info
2050 file to go with a specific base source file.
2052 The result is a boolean indicating success. */
2055 gen_aux_info_file (base_filename)
2056 const char *base_filename;
2058 if (!input_file_name_index)
2059 munge_compile_params ("");
2061 /* Store the full source file name in the argument vector. */
2062 compile_params[input_file_name_index] = shortpath (NULL, base_filename);
2063 /* Add .X to source file name to get aux-info file name. */
2064 compile_params[aux_info_file_name_index]
2065 = savestring2 (compile_params[input_file_name_index],
2066 strlen (compile_params[input_file_name_index]),
2071 notice ("%s: compiling `%s'\n",
2072 pname, compile_params[input_file_name_index]);
2075 char *errmsg_fmt, *errmsg_arg;
2076 int wait_status, pid;
2077 char *temp_base = choose_temp_base ();
2079 pid = pexecute (compile_params[0], (char * const *) compile_params,
2080 pname, temp_base, &errmsg_fmt, &errmsg_arg,
2081 PEXECUTE_FIRST | PEXECUTE_LAST | PEXECUTE_SEARCH);
2085 int errno_val = errno;
2086 fprintf (stderr, "%s: ", pname);
2087 fprintf (stderr, errmsg_fmt, errmsg_arg);
2088 fprintf (stderr, ": %s\n", xstrerror (errno_val));
2092 pid = pwait (pid, &wait_status, 0);
2095 notice ("%s: wait: %s\n", pname, xstrerror (errno));
2098 if (WIFSIGNALED (wait_status))
2100 notice ("%s: subprocess got fatal signal %d\n",
2101 pname, WTERMSIG (wait_status));
2104 if (WIFEXITED (wait_status))
2106 if (WEXITSTATUS (wait_status) != 0)
2108 notice ("%s: %s exited with status %d\n",
2109 pname, compile_params[0], WEXITSTATUS (wait_status));
2118 /* Read in all of the information contained in a single aux_info file.
2119 Save all of the important stuff for later. */
2122 process_aux_info_file (base_source_filename, keep_it, is_syscalls)
2123 const char *base_source_filename;
2127 size_t base_len = strlen (base_source_filename);
2128 char * aux_info_filename
2129 = (char *) alloca (base_len + strlen (aux_info_suffix) + 1);
2130 char *aux_info_base;
2131 char *aux_info_limit;
2132 char *aux_info_relocated_name;
2133 const char *aux_info_second_line;
2134 time_t aux_info_mtime;
2135 size_t aux_info_size;
2138 /* Construct the aux_info filename from the base source filename. */
2140 strcpy (aux_info_filename, base_source_filename);
2141 strcat (aux_info_filename, aux_info_suffix);
2143 /* Check that the aux_info file exists and is readable. If it does not
2144 exist, try to create it (once only). */
2146 /* If file doesn't exist, set must_create.
2147 Likewise if it exists and we can read it but it is obsolete.
2148 Otherwise, report an error. */
2151 /* Come here with must_create set to 1 if file is out of date. */
2154 if (my_access (aux_info_filename, R_OK) == -1)
2156 if (errno == ENOENT)
2160 notice ("%s: warning: missing SYSCALLS file `%s'\n",
2161 pname, aux_info_filename);
2168 int errno_val = errno;
2169 notice ("%s: can't read aux info file `%s': %s\n",
2170 pname, shortpath (NULL, aux_info_filename),
2171 xstrerror (errno_val));
2176 #if 0 /* There is code farther down to take care of this. */
2180 stat (aux_info_file_name, &s1);
2181 stat (base_source_file_name, &s2);
2182 if (s2.st_mtime > s1.st_mtime)
2187 /* If we need a .X file, create it, and verify we can read it. */
2190 if (!gen_aux_info_file (base_source_filename))
2195 if (my_access (aux_info_filename, R_OK) == -1)
2197 int errno_val = errno;
2198 notice ("%s: can't read aux info file `%s': %s\n",
2199 pname, shortpath (NULL, aux_info_filename),
2200 xstrerror (errno_val));
2207 struct stat stat_buf;
2209 /* Get some status information about this aux_info file. */
2211 if (my_stat (aux_info_filename, &stat_buf) == -1)
2213 int errno_val = errno;
2214 notice ("%s: can't get status of aux info file `%s': %s\n",
2215 pname, shortpath (NULL, aux_info_filename),
2216 xstrerror (errno_val));
2221 /* Check on whether or not this aux_info file is zero length. If it is,
2222 then just ignore it and return. */
2224 if ((aux_info_size = stat_buf.st_size) == 0)
2227 /* Get the date/time of last modification for this aux_info file and
2228 remember it. We will have to check that any source files that it
2229 contains information about are at least this old or older. */
2231 aux_info_mtime = stat_buf.st_mtime;
2235 /* Compare mod time with the .c file; update .X file if obsolete.
2236 The code later on can fail to check the .c file
2237 if it did not directly define any functions. */
2239 if (my_stat (base_source_filename, &stat_buf) == -1)
2241 int errno_val = errno;
2242 notice ("%s: can't get status of aux info file `%s': %s\n",
2243 pname, shortpath (NULL, base_source_filename),
2244 xstrerror (errno_val));
2248 if (stat_buf.st_mtime > aux_info_mtime)
2259 /* Open the aux_info file. */
2261 if ((aux_info_file = my_open (aux_info_filename, O_RDONLY, 0444 )) == -1)
2263 int errno_val = errno;
2264 notice ("%s: can't open aux info file `%s' for reading: %s\n",
2265 pname, shortpath (NULL, aux_info_filename),
2266 xstrerror (errno_val));
2270 /* Allocate space to hold the aux_info file in memory. */
2272 aux_info_base = xmalloc (aux_info_size + 1);
2273 aux_info_limit = aux_info_base + aux_info_size;
2274 *aux_info_limit = '\0';
2276 /* Read the aux_info file into memory. */
2278 if (safe_read (aux_info_file, aux_info_base, aux_info_size) !=
2279 (int) aux_info_size)
2281 int errno_val = errno;
2282 notice ("%s: error reading aux info file `%s': %s\n",
2283 pname, shortpath (NULL, aux_info_filename),
2284 xstrerror (errno_val));
2285 free (aux_info_base);
2286 close (aux_info_file);
2290 /* Close the aux info file. */
2292 if (close (aux_info_file))
2294 int errno_val = errno;
2295 notice ("%s: error closing aux info file `%s': %s\n",
2296 pname, shortpath (NULL, aux_info_filename),
2297 xstrerror (errno_val));
2298 free (aux_info_base);
2299 close (aux_info_file);
2304 /* Delete the aux_info file (unless requested not to). If the deletion
2305 fails for some reason, don't even worry about it. */
2307 if (must_create && !keep_it)
2308 if (my_unlink (aux_info_filename) == -1)
2310 int errno_val = errno;
2311 notice ("%s: can't delete aux info file `%s': %s\n",
2312 pname, shortpath (NULL, aux_info_filename),
2313 xstrerror (errno_val));
2316 /* Save a pointer into the first line of the aux_info file which
2317 contains the filename of the directory from which the compiler
2318 was invoked when the associated source file was compiled.
2319 This information is used later to help create complete
2320 filenames out of the (potentially) relative filenames in
2321 the aux_info file. */
2324 char *p = aux_info_base;
2331 invocation_filename = p; /* Save a pointer to first byte of path. */
2336 while (*p++ != '\n')
2338 aux_info_second_line = p;
2339 aux_info_relocated_name = 0;
2340 if (invocation_filename[0] != '/')
2342 /* INVOCATION_FILENAME is relative;
2343 append it to BASE_SOURCE_FILENAME's dir. */
2345 aux_info_relocated_name = xmalloc (base_len + (p-invocation_filename));
2346 strcpy (aux_info_relocated_name, base_source_filename);
2347 dir_end = strrchr (aux_info_relocated_name, '/');
2351 dir_end = aux_info_relocated_name;
2352 strcpy (dir_end, invocation_filename);
2353 invocation_filename = aux_info_relocated_name;
2359 const char *aux_info_p;
2361 /* Do a pre-pass on the lines in the aux_info file, making sure that all
2362 of the source files referenced in there are at least as old as this
2363 aux_info file itself. If not, go back and regenerate the aux_info
2364 file anew. Don't do any of this for the syscalls file. */
2368 current_aux_info_lineno = 2;
2370 for (aux_info_p = aux_info_second_line; *aux_info_p; )
2372 if (referenced_file_is_newer (aux_info_p, aux_info_mtime))
2374 free (aux_info_base);
2375 xfree (aux_info_relocated_name);
2376 if (keep_it && my_unlink (aux_info_filename) == -1)
2378 int errno_val = errno;
2379 notice ("%s: can't delete file `%s': %s\n",
2380 pname, shortpath (NULL, aux_info_filename),
2381 xstrerror (errno_val));
2388 /* Skip over the rest of this line to start of next line. */
2390 while (*aux_info_p != '\n')
2393 current_aux_info_lineno++;
2397 /* Now do the real pass on the aux_info lines. Save their information in
2398 the in-core data base. */
2400 current_aux_info_lineno = 2;
2402 for (aux_info_p = aux_info_second_line; *aux_info_p;)
2404 char *unexpanded_line = unexpand_if_needed (aux_info_p);
2406 if (unexpanded_line)
2408 save_def_or_dec (unexpanded_line, is_syscalls);
2409 free (unexpanded_line);
2412 save_def_or_dec (aux_info_p, is_syscalls);
2414 /* Skip over the rest of this line and get to start of next line. */
2416 while (*aux_info_p != '\n')
2419 current_aux_info_lineno++;
2423 free (aux_info_base);
2424 xfree (aux_info_relocated_name);
2429 /* Check an individual filename for a .c suffix. If the filename has this
2430 suffix, rename the file such that its suffix is changed to .C. This
2431 function implements the -C option. */
2435 const hash_table_entry *hp;
2437 const char *filename = hp->symbol;
2438 int last_char_index = strlen (filename) - 1;
2439 char *const new_filename = (char *) alloca (strlen (filename) + 1);
2441 /* Note that we don't care here if the given file was converted or not. It
2442 is possible that the given file was *not* converted, simply because there
2443 was nothing in it which actually required conversion. Even in this case,
2444 we want to do the renaming. Note that we only rename files with the .c
2447 if (filename[last_char_index] != 'c' || filename[last_char_index-1] != '.')
2450 strcpy (new_filename, filename);
2451 new_filename[last_char_index] = 'C';
2453 if (my_link (filename, new_filename) == -1)
2455 int errno_val = errno;
2456 notice ("%s: warning: can't link file `%s' to `%s': %s\n",
2457 pname, shortpath (NULL, filename),
2458 shortpath (NULL, new_filename), xstrerror (errno_val));
2463 if (my_unlink (filename) == -1)
2465 int errno_val = errno;
2466 notice ("%s: warning: can't delete file `%s': %s\n",
2467 pname, shortpath (NULL, filename), xstrerror (errno_val));
2473 #endif /* !defined (UNPROTOIZE) */
2475 /* Take the list of definitions and declarations attached to a particular
2476 file_info node and reverse the order of the list. This should get the
2477 list into an order such that the item with the lowest associated line
2478 number is nearest the head of the list. When these lists are originally
2479 built, they are in the opposite order. We want to traverse them in
2480 normal line number order later (i.e. lowest to highest) so reverse the
2484 reverse_def_dec_list (hp)
2485 const hash_table_entry *hp;
2487 file_info *file_p = hp->fip;
2488 def_dec_info *prev = NULL;
2489 def_dec_info *current = (def_dec_info *)file_p->defs_decs;
2492 return; /* no list to reverse */
2495 if (! (current = (def_dec_info *)current->next_in_file))
2496 return; /* can't reverse a single list element */
2498 prev->next_in_file = NULL;
2502 def_dec_info *next = (def_dec_info *)current->next_in_file;
2504 current->next_in_file = prev;
2509 file_p->defs_decs = prev;
2514 /* Find the (only?) extern definition for a particular function name, starting
2515 from the head of the linked list of entries for the given name. If we
2516 cannot find an extern definition for the given function name, issue a
2517 warning and scrounge around for the next best thing, i.e. an extern
2518 function declaration with a prototype attached to it. Note that we only
2519 allow such substitutions for extern declarations and never for static
2520 declarations. That's because the only reason we allow them at all is
2521 to let un-prototyped function declarations for system-supplied library
2522 functions get their prototypes from our own extra SYSCALLS.c.X file which
2523 contains all of the correct prototypes for system functions. */
2525 static const def_dec_info *
2526 find_extern_def (head, user)
2527 const def_dec_info *head;
2528 const def_dec_info *user;
2530 const def_dec_info *dd_p;
2531 const def_dec_info *extern_def_p = NULL;
2532 int conflict_noted = 0;
2534 /* Don't act too stupid here. Somebody may try to convert an entire system
2535 in one swell fwoop (rather than one program at a time, as should be done)
2536 and in that case, we may find that there are multiple extern definitions
2537 of a given function name in the entire set of source files that we are
2538 converting. If however one of these definitions resides in exactly the
2539 same source file as the reference we are trying to satisfy then in that
2540 case it would be stupid for us to fail to realize that this one definition
2541 *must* be the precise one we are looking for.
2543 To make sure that we don't miss an opportunity to make this "same file"
2544 leap of faith, we do a prescan of the list of records relating to the
2545 given function name, and we look (on this first scan) *only* for a
2546 definition of the function which is in the same file as the reference
2547 we are currently trying to satisfy. */
2549 for (dd_p = head; dd_p; dd_p = dd_p->next_for_func)
2550 if (dd_p->is_func_def && !dd_p->is_static && dd_p->file == user->file)
2553 /* Now, since we have not found a definition in the same file as the
2554 reference, we scan the list again and consider all possibilities from
2555 all files. Here we may get conflicts with the things listed in the
2556 SYSCALLS.c.X file, but if that happens it only means that the source
2557 code being converted contains its own definition of a function which
2558 could have been supplied by libc.a. In such cases, we should avoid
2559 issuing the normal warning, and defer to the definition given in the
2562 for (dd_p = head; dd_p; dd_p = dd_p->next_for_func)
2563 if (dd_p->is_func_def && !dd_p->is_static)
2565 if (!extern_def_p) /* Previous definition? */
2566 extern_def_p = dd_p; /* Remember the first definition found. */
2569 /* Ignore definition just found if it came from SYSCALLS.c.X. */
2571 if (is_syscalls_file (dd_p->file))
2574 /* Quietly replace the definition previously found with the one
2575 just found if the previous one was from SYSCALLS.c.X. */
2577 if (is_syscalls_file (extern_def_p->file))
2579 extern_def_p = dd_p;
2583 /* If we get here, then there is a conflict between two function
2584 declarations for the same function, both of which came from the
2587 if (!conflict_noted) /* first time we noticed? */
2590 notice ("%s: conflicting extern definitions of '%s'\n",
2591 pname, head->hash_entry->symbol);
2594 notice ("%s: declarations of '%s' will not be converted\n",
2595 pname, head->hash_entry->symbol);
2596 notice ("%s: conflict list for '%s' follows:\n",
2597 pname, head->hash_entry->symbol);
2598 fprintf (stderr, "%s: %s(%d): %s\n",
2600 shortpath (NULL, extern_def_p->file->hash_entry->symbol),
2601 extern_def_p->line, extern_def_p->ansi_decl);
2605 fprintf (stderr, "%s: %s(%d): %s\n",
2607 shortpath (NULL, dd_p->file->hash_entry->symbol),
2608 dd_p->line, dd_p->ansi_decl);
2612 /* We want to err on the side of caution, so if we found multiple conflicting
2613 definitions for the same function, treat this as being that same as if we
2614 had found no definitions (i.e. return NULL). */
2621 /* We have no definitions for this function so do the next best thing.
2622 Search for an extern declaration already in prototype form. */
2624 for (dd_p = head; dd_p; dd_p = dd_p->next_for_func)
2625 if (!dd_p->is_func_def && !dd_p->is_static && dd_p->prototyped)
2627 extern_def_p = dd_p; /* save a pointer to the definition */
2629 notice ("%s: warning: using formals list from %s(%d) for function `%s'\n",
2631 shortpath (NULL, dd_p->file->hash_entry->symbol),
2632 dd_p->line, dd_p->hash_entry->symbol);
2636 /* Gripe about unprototyped function declarations that we found no
2637 corresponding definition (or other source of prototype information)
2640 Gripe even if the unprototyped declaration we are worried about
2641 exists in a file in one of the "system" include directories. We
2642 can gripe about these because we should have at least found a
2643 corresponding (pseudo) definition in the SYSCALLS.c.X file. If we
2644 didn't, then that means that the SYSCALLS.c.X file is missing some
2645 needed prototypes for this particular system. That is worth telling
2650 const char *file = user->file->hash_entry->symbol;
2653 if (in_system_include_dir (file))
2655 /* Why copy this string into `needed' at all?
2656 Why not just use user->ansi_decl without copying? */
2657 char *needed = (char *) alloca (strlen (user->ansi_decl) + 1);
2660 strcpy (needed, user->ansi_decl);
2661 p = (NONCONST char *) substr (needed, user->hash_entry->symbol)
2662 + strlen (user->hash_entry->symbol) + 2;
2663 /* Avoid having ??? in the string. */
2669 notice ("%s: %d: `%s' used but missing from SYSCALLS\n",
2670 shortpath (NULL, file), user->line,
2671 needed+7); /* Don't print "extern " */
2675 notice ("%s: %d: warning: no extern definition for `%s'\n",
2676 shortpath (NULL, file), user->line,
2677 user->hash_entry->symbol);
2681 return extern_def_p;
2684 /* Find the (only?) static definition for a particular function name in a
2685 given file. Here we get the function-name and the file info indirectly
2686 from the def_dec_info record pointer which is passed in. */
2688 static const def_dec_info *
2689 find_static_definition (user)
2690 const def_dec_info *user;
2692 const def_dec_info *head = user->hash_entry->ddip;
2693 const def_dec_info *dd_p;
2694 int num_static_defs = 0;
2695 const def_dec_info *static_def_p = NULL;
2697 for (dd_p = head; dd_p; dd_p = dd_p->next_for_func)
2698 if (dd_p->is_func_def && dd_p->is_static && (dd_p->file == user->file))
2700 static_def_p = dd_p; /* save a pointer to the definition */
2703 if (num_static_defs == 0)
2706 notice ("%s: warning: no static definition for `%s' in file `%s'\n",
2707 pname, head->hash_entry->symbol,
2708 shortpath (NULL, user->file->hash_entry->symbol));
2710 else if (num_static_defs > 1)
2712 notice ("%s: multiple static defs of `%s' in file `%s'\n",
2713 pname, head->hash_entry->symbol,
2714 shortpath (NULL, user->file->hash_entry->symbol));
2717 return static_def_p;
2720 /* Find good prototype style formal argument lists for all of the function
2721 declarations which didn't have them before now.
2723 To do this we consider each function name one at a time. For each function
2724 name, we look at the items on the linked list of def_dec_info records for
2725 that particular name.
2727 Somewhere on this list we should find one (and only one) def_dec_info
2728 record which represents the actual function definition, and this record
2729 should have a nice formal argument list already associated with it.
2731 Thus, all we have to do is to connect up all of the other def_dec_info
2732 records for this particular function name to the special one which has
2733 the full-blown formals list.
2735 Of course it is a little more complicated than just that. See below for
2739 connect_defs_and_decs (hp)
2740 const hash_table_entry *hp;
2742 const def_dec_info *dd_p;
2743 const def_dec_info *extern_def_p = NULL;
2744 int first_extern_reference = 1;
2746 /* Traverse the list of definitions and declarations for this particular
2747 function name. For each item on the list, if it is a function
2748 definition (either old style or new style) then GCC has already been
2749 kind enough to produce a prototype for us, and it is associated with
2750 the item already, so declare the item as its own associated "definition".
2752 Also, for each item which is only a function declaration, but which
2753 nonetheless has its own prototype already (obviously supplied by the user)
2754 declare the item as its own definition.
2756 Note that when/if there are multiple user-supplied prototypes already
2757 present for multiple declarations of any given function, these multiple
2758 prototypes *should* all match exactly with one another and with the
2759 prototype for the actual function definition. We don't check for this
2760 here however, since we assume that the compiler must have already done
2761 this consistency checking when it was creating the .X files. */
2763 for (dd_p = hp->ddip; dd_p; dd_p = dd_p->next_for_func)
2764 if (dd_p->prototyped)
2765 ((NONCONST def_dec_info *) dd_p)->definition = dd_p;
2767 /* Traverse the list of definitions and declarations for this particular
2768 function name. For each item on the list, if it is an extern function
2769 declaration and if it has no associated definition yet, go try to find
2770 the matching extern definition for the declaration.
2772 When looking for the matching function definition, warn the user if we
2775 If we find more that one function definition also issue a warning.
2777 Do the search for the matching definition only once per unique function
2778 name (and only when absolutely needed) so that we can avoid putting out
2779 redundant warning messages, and so that we will only put out warning
2780 messages when there is actually a reference (i.e. a declaration) for
2781 which we need to find a matching definition. */
2783 for (dd_p = hp->ddip; dd_p; dd_p = dd_p->next_for_func)
2784 if (!dd_p->is_func_def && !dd_p->is_static && !dd_p->definition)
2786 if (first_extern_reference)
2788 extern_def_p = find_extern_def (hp->ddip, dd_p);
2789 first_extern_reference = 0;
2791 ((NONCONST def_dec_info *) dd_p)->definition = extern_def_p;
2794 /* Traverse the list of definitions and declarations for this particular
2795 function name. For each item on the list, if it is a static function
2796 declaration and if it has no associated definition yet, go try to find
2797 the matching static definition for the declaration within the same file.
2799 When looking for the matching function definition, warn the user if we
2800 fail to find one in the same file with the declaration, and refuse to
2801 convert this kind of cross-file static function declaration. After all,
2802 this is stupid practice and should be discouraged.
2804 We don't have to worry about the possibility that there is more than one
2805 matching function definition in the given file because that would have
2806 been flagged as an error by the compiler.
2808 Do the search for the matching definition only once per unique
2809 function-name/source-file pair (and only when absolutely needed) so that
2810 we can avoid putting out redundant warning messages, and so that we will
2811 only put out warning messages when there is actually a reference (i.e. a
2812 declaration) for which we actually need to find a matching definition. */
2814 for (dd_p = hp->ddip; dd_p; dd_p = dd_p->next_for_func)
2815 if (!dd_p->is_func_def && dd_p->is_static && !dd_p->definition)
2817 const def_dec_info *dd_p2;
2818 const def_dec_info *static_def;
2820 /* We have now found a single static declaration for which we need to
2821 find a matching definition. We want to minimize the work (and the
2822 number of warnings), so we will find an appropriate (matching)
2823 static definition for this declaration, and then distribute it
2824 (as the definition for) any and all other static declarations
2825 for this function name which occur within the same file, and which
2826 do not already have definitions.
2828 Note that a trick is used here to prevent subsequent attempts to
2829 call find_static_definition for a given function-name & file
2830 if the first such call returns NULL. Essentially, we convert
2831 these NULL return values to -1, and put the -1 into the definition
2832 field for each other static declaration from the same file which
2833 does not already have an associated definition.
2834 This makes these other static declarations look like they are
2835 actually defined already when the outer loop here revisits them
2836 later on. Thus, the outer loop will skip over them. Later, we
2837 turn the -1's back to NULL's. */
2839 ((NONCONST def_dec_info *) dd_p)->definition =
2840 (static_def = find_static_definition (dd_p))
2842 : (const def_dec_info *) -1;
2844 for (dd_p2 = dd_p->next_for_func; dd_p2; dd_p2 = dd_p2->next_for_func)
2845 if (!dd_p2->is_func_def && dd_p2->is_static
2846 && !dd_p2->definition && (dd_p2->file == dd_p->file))
2847 ((NONCONST def_dec_info *)dd_p2)->definition = dd_p->definition;
2850 /* Convert any dummy (-1) definitions we created in the step above back to
2851 NULL's (as they should be). */
2853 for (dd_p = hp->ddip; dd_p; dd_p = dd_p->next_for_func)
2854 if (dd_p->definition == (def_dec_info *) -1)
2855 ((NONCONST def_dec_info *) dd_p)->definition = NULL;
2858 #endif /* !defined (UNPROTOIZE) */
2860 /* Give a pointer into the clean text buffer, return a number which is the
2861 original source line number that the given pointer points into. */
2864 identify_lineno (clean_p)
2865 const char *clean_p;
2870 for (scan_p = clean_text_base; scan_p <= clean_p; scan_p++)
2871 if (*scan_p == '\n')
2876 /* Issue an error message and give up on doing this particular edit. */
2879 declare_source_confusing (clean_p)
2880 const char *clean_p;
2885 notice ("%s: %d: warning: source too confusing\n",
2886 shortpath (NULL, convert_filename), last_known_line_number);
2888 notice ("%s: %d: warning: source too confusing\n",
2889 shortpath (NULL, convert_filename),
2890 identify_lineno (clean_p));
2892 longjmp (source_confusion_recovery, 1);
2895 /* Check that a condition which is expected to be true in the original source
2896 code is in fact true. If not, issue an error message and give up on
2897 converting this particular source file. */
2900 check_source (cond, clean_p)
2902 const char *clean_p;
2905 declare_source_confusing (clean_p);
2908 /* If we think of the in-core cleaned text buffer as a memory mapped
2909 file (with the variable last_known_line_start acting as sort of a
2910 file pointer) then we can imagine doing "seeks" on the buffer. The
2911 following routine implements a kind of "seek" operation for the in-core
2912 (cleaned) copy of the source file. When finished, it returns a pointer to
2913 the start of a given (numbered) line in the cleaned text buffer.
2915 Note that protoize only has to "seek" in the forward direction on the
2916 in-core cleaned text file buffers, and it never needs to back up.
2918 This routine is made a little bit faster by remembering the line number
2919 (and pointer value) supplied (and returned) from the previous "seek".
2920 This prevents us from always having to start all over back at the top
2921 of the in-core cleaned buffer again. */
2927 if (n < last_known_line_number)
2930 while (n > last_known_line_number)
2932 while (*last_known_line_start != '\n')
2933 check_source (++last_known_line_start < clean_text_limit, 0);
2934 last_known_line_start++;
2935 last_known_line_number++;
2937 return last_known_line_start;
2940 /* Given a pointer to a character in the cleaned text buffer, return a pointer
2941 to the next non-whitespace character which follows it. */
2944 forward_to_next_token_char (ptr)
2947 for (++ptr; ISSPACE ((const unsigned char)*ptr);
2948 check_source (++ptr < clean_text_limit, 0))
2953 /* Copy a chunk of text of length `len' and starting at `str' to the current
2954 output buffer. Note that all attempts to add stuff to the current output
2955 buffer ultimately go through here. */
2958 output_bytes (str, len)
2962 if ((repl_write_ptr + 1) + len >= repl_text_limit)
2964 size_t new_size = (repl_text_limit - repl_text_base) << 1;
2965 char *new_buf = (char *) xrealloc (repl_text_base, new_size);
2967 repl_write_ptr = new_buf + (repl_write_ptr - repl_text_base);
2968 repl_text_base = new_buf;
2969 repl_text_limit = new_buf + new_size;
2971 memcpy (repl_write_ptr + 1, str, len);
2972 repl_write_ptr += len;
2975 /* Copy all bytes (except the trailing null) of a null terminated string to
2976 the current output buffer. */
2982 output_bytes (str, strlen (str));
2985 /* Copy some characters from the original text buffer to the current output
2988 This routine takes a pointer argument `p' which is assumed to be a pointer
2989 into the cleaned text buffer. The bytes which are copied are the `original'
2990 equivalents for the set of bytes between the last value of `clean_read_ptr'
2991 and the argument value `p'.
2993 The set of bytes copied however, comes *not* from the cleaned text buffer,
2994 but rather from the direct counterparts of these bytes within the original
2997 Thus, when this function is called, some bytes from the original text
2998 buffer (which may include original comments and preprocessing directives)
2999 will be copied into the output buffer.
3001 Note that the request implied when this routine is called includes the
3002 byte pointed to by the argument pointer `p'. */
3008 size_t copy_length = (size_t) (p - clean_read_ptr);
3009 const char *copy_start = orig_text_base+(clean_read_ptr-clean_text_base)+1;
3011 if (copy_length == 0)
3014 output_bytes (copy_start, copy_length);
3018 /* Given a pointer to a def_dec_info record which represents some form of
3019 definition of a function (perhaps a real definition, or in lieu of that
3020 perhaps just a declaration with a full prototype) return true if this
3021 function is one which we should avoid converting. Return false
3025 other_variable_style_function (ansi_header)
3026 const char *ansi_header;
3030 /* See if we have a stdarg function, or a function which has stdarg style
3031 parameters or a stdarg style return type. */
3033 return substr (ansi_header, "...") != 0;
3035 #else /* !defined (UNPROTOIZE) */
3037 /* See if we have a varargs function, or a function which has varargs style
3038 parameters or a varargs style return type. */
3041 int len = strlen (varargs_style_indicator);
3043 for (p = ansi_header; p; )
3045 const char *candidate;
3047 if ((candidate = substr (p, varargs_style_indicator)) == 0)
3050 if (!is_id_char (candidate[-1]) && !is_id_char (candidate[len]))
3056 #endif /* !defined (UNPROTOIZE) */
3059 /* Do the editing operation specifically for a function "declaration". Note
3060 that editing for function "definitions" are handled in a separate routine
3064 edit_fn_declaration (def_dec_p, clean_text_p)
3065 const def_dec_info *def_dec_p;
3066 const char *volatile clean_text_p;
3068 const char *start_formals;
3069 const char *end_formals;
3070 const char *function_to_edit = def_dec_p->hash_entry->symbol;
3071 size_t func_name_len = strlen (function_to_edit);
3072 const char *end_of_fn_name;
3076 const f_list_chain_item *this_f_list_chain_item;
3077 const def_dec_info *definition = def_dec_p->definition;
3079 /* If we are protoizing, and if we found no corresponding definition for
3080 this particular function declaration, then just leave this declaration
3081 exactly as it is. */
3086 /* If we are protoizing, and if the corresponding definition that we found
3087 for this particular function declaration defined an old style varargs
3088 function, then we want to issue a warning and just leave this function
3089 declaration unconverted. */
3091 if (other_variable_style_function (definition->ansi_decl))
3094 notice ("%s: %d: warning: varargs function declaration not converted\n",
3095 shortpath (NULL, def_dec_p->file->hash_entry->symbol),
3100 #endif /* !defined (UNPROTOIZE) */
3102 /* Setup here to recover from confusing source code detected during this
3103 particular "edit". */
3106 if (setjmp (source_confusion_recovery))
3108 restore_pointers ();
3109 notice ("%s: declaration of function `%s' not converted\n",
3110 pname, function_to_edit);
3114 /* We are editing a function declaration. The line number we did a seek to
3115 contains the comma or semicolon which follows the declaration. Our job
3116 now is to scan backwards looking for the function name. This name *must*
3117 be followed by open paren (ignoring whitespace, of course). We need to
3118 replace everything between that open paren and the corresponding closing
3119 paren. If we are protoizing, we need to insert the prototype-style
3120 formals lists. If we are unprotoizing, we need to just delete everything
3121 between the pairs of opening and closing parens. */
3123 /* First move up to the end of the line. */
3125 while (*clean_text_p != '\n')
3126 check_source (++clean_text_p < clean_text_limit, 0);
3127 clean_text_p--; /* Point to just before the newline character. */
3129 /* Now we can scan backwards for the function name. */
3135 /* Scan leftwards until we find some character which can be
3136 part of an identifier. */
3138 while (!is_id_char (*clean_text_p))
3139 check_source (--clean_text_p > clean_read_ptr, 0);
3141 /* Scan backwards until we find a char that cannot be part of an
3144 while (is_id_char (*clean_text_p))
3145 check_source (--clean_text_p > clean_read_ptr, 0);
3147 /* Having found an "id break", see if the following id is the one
3148 that we are looking for. If so, then exit from this loop. */
3150 if (!strncmp (clean_text_p+1, function_to_edit, func_name_len))
3152 char ch = *(clean_text_p + 1 + func_name_len);
3154 /* Must also check to see that the name in the source text
3155 ends where it should (in order to prevent bogus matches
3156 on similar but longer identifiers. */
3158 if (! is_id_char (ch))
3159 break; /* exit from loop */
3163 /* We have now found the first perfect match for the function name in
3164 our backward search. This may or may not be the actual function
3165 name at the start of the actual function declaration (i.e. we could
3166 have easily been mislead). We will try to avoid getting fooled too
3167 often by looking forward for the open paren which should follow the
3168 identifier we just found. We ignore whitespace while hunting. If
3169 the next non-whitespace byte we see is *not* an open left paren,
3170 then we must assume that we have been fooled and we start over
3171 again accordingly. Note that there is no guarantee, that even if
3172 we do see the open paren, that we are in the right place.
3173 Programmers do the strangest things sometimes! */
3175 end_of_fn_name = clean_text_p + strlen (def_dec_p->hash_entry->symbol);
3176 start_formals = forward_to_next_token_char (end_of_fn_name);
3178 while (*start_formals != '(');
3180 /* start_of_formals now points to the opening left paren which immediately
3181 follows the name of the function. */
3183 /* Note that there may be several formals lists which need to be modified
3184 due to the possibility that the return type of this function is a
3185 pointer-to-function type. If there are several formals lists, we
3186 convert them in left-to-right order here. */
3189 this_f_list_chain_item = definition->f_list_chain;
3190 #endif /* !defined (UNPROTOIZE) */
3197 end_formals = start_formals + 1;
3199 for (; depth; check_source (++end_formals < clean_text_limit, 0))
3201 switch (*end_formals)
3214 /* end_formals now points to the closing right paren of the formals
3215 list whose left paren is pointed to by start_formals. */
3217 /* Now, if we are protoizing, we insert the new ANSI-style formals list
3218 attached to the associated definition of this function. If however
3219 we are unprotoizing, then we simply delete any formals list which
3222 output_up_to (start_formals);
3224 if (this_f_list_chain_item)
3226 output_string (this_f_list_chain_item->formals_list);
3227 this_f_list_chain_item = this_f_list_chain_item->chain_next;
3232 notice ("%s: warning: too many parameter lists in declaration of `%s'\n",
3233 pname, def_dec_p->hash_entry->symbol);
3234 check_source (0, end_formals); /* leave the declaration intact */
3236 #endif /* !defined (UNPROTOIZE) */
3237 clean_read_ptr = end_formals - 1;
3239 /* Now see if it looks like there may be another formals list associated
3240 with the function declaration that we are converting (following the
3241 formals list that we just converted. */
3244 const char *another_r_paren = forward_to_next_token_char (end_formals);
3246 if ((*another_r_paren != ')')
3247 || (*(start_formals = forward_to_next_token_char (another_r_paren)) != '('))
3250 if (this_f_list_chain_item)
3253 notice ("\n%s: warning: too few parameter lists in declaration of `%s'\n",
3254 pname, def_dec_p->hash_entry->symbol);
3255 check_source (0, start_formals); /* leave the decl intact */
3257 #endif /* !defined (UNPROTOIZE) */
3263 /* There does appear to be yet another formals list, so loop around
3264 again, and convert it also. */
3268 /* Edit a whole group of formals lists, starting with the rightmost one
3269 from some set of formals lists. This routine is called once (from the
3270 outside) for each function declaration which is converted. It is
3271 recursive however, and it calls itself once for each remaining formal
3272 list that lies to the left of the one it was originally called to work
3273 on. Thus, a whole set gets done in right-to-left order.
3275 This routine returns non-zero if it thinks that it should not be trying
3276 to convert this particular function definition (because the name of the
3277 function doesn't match the one expected). */
3280 edit_formals_lists (end_formals, f_list_count, def_dec_p)
3281 const char *end_formals;
3282 unsigned int f_list_count;
3283 const def_dec_info *def_dec_p;
3285 const char *start_formals;
3288 start_formals = end_formals - 1;
3290 for (; depth; check_source (--start_formals > clean_read_ptr, 0))
3292 switch (*start_formals)
3304 /* start_formals now points to the opening left paren of the formals list. */
3310 const char *next_end;
3312 /* There should be more formal lists to the left of here. */
3314 next_end = start_formals - 1;
3315 check_source (next_end > clean_read_ptr, 0);
3316 while (ISSPACE ((const unsigned char)*next_end))
3317 check_source (--next_end > clean_read_ptr, 0);
3318 check_source (*next_end == ')', next_end);
3319 check_source (--next_end > clean_read_ptr, 0);
3320 check_source (*next_end == ')', next_end);
3321 if (edit_formals_lists (next_end, f_list_count, def_dec_p))
3325 /* Check that the function name in the header we are working on is the same
3326 as the one we would expect to find. If not, issue a warning and return
3329 if (f_list_count == 0)
3331 const char *expected = def_dec_p->hash_entry->symbol;
3332 const char *func_name_start;
3333 const char *func_name_limit;
3334 size_t func_name_len;
3336 for (func_name_limit = start_formals-1;
3337 ISSPACE ((const unsigned char)*func_name_limit); )
3338 check_source (--func_name_limit > clean_read_ptr, 0);
3340 for (func_name_start = func_name_limit++;
3341 is_id_char (*func_name_start);
3343 check_source (func_name_start > clean_read_ptr, 0);
3345 func_name_len = func_name_limit - func_name_start;
3346 if (func_name_len == 0)
3347 check_source (0, func_name_start);
3348 if (func_name_len != strlen (expected)
3349 || strncmp (func_name_start, expected, func_name_len))
3351 notice ("%s: %d: warning: found `%s' but expected `%s'\n",
3352 shortpath (NULL, def_dec_p->file->hash_entry->symbol),
3353 identify_lineno (func_name_start),
3354 dupnstr (func_name_start, func_name_len),
3360 output_up_to (start_formals);
3363 if (f_list_count == 0)
3364 output_string (def_dec_p->formal_names);
3365 #else /* !defined (UNPROTOIZE) */
3367 unsigned f_list_depth;
3368 const f_list_chain_item *flci_p = def_dec_p->f_list_chain;
3370 /* At this point, the current value of f_list count says how many
3371 links we have to follow through the f_list_chain to get to the
3372 particular formals list that we need to output next. */
3374 for (f_list_depth = 0; f_list_depth < f_list_count; f_list_depth++)
3375 flci_p = flci_p->chain_next;
3376 output_string (flci_p->formals_list);
3378 #endif /* !defined (UNPROTOIZE) */
3380 clean_read_ptr = end_formals - 1;
3384 /* Given a pointer to a byte in the clean text buffer which points to
3385 the beginning of a line that contains a "follower" token for a
3386 function definition header, do whatever is necessary to find the
3387 right closing paren for the rightmost formals list of the function
3388 definition header. */
3391 find_rightmost_formals_list (clean_text_p)
3392 const char *clean_text_p;
3394 const char *end_formals;
3396 /* We are editing a function definition. The line number we did a seek
3397 to contains the first token which immediately follows the entire set of
3398 formals lists which are part of this particular function definition
3401 Our job now is to scan leftwards in the clean text looking for the
3402 right-paren which is at the end of the function header's rightmost
3405 If we ignore whitespace, this right paren should be the first one we
3406 see which is (ignoring whitespace) immediately followed either by the
3407 open curly-brace beginning the function body or by an alphabetic
3408 character (in the case where the function definition is in old (K&R)
3409 style and there are some declarations of formal parameters). */
3411 /* It is possible that the right paren we are looking for is on the
3412 current line (together with its following token). Just in case that
3413 might be true, we start out here by skipping down to the right end of
3414 the current line before starting our scan. */
3416 for (end_formals = clean_text_p; *end_formals != '\n'; end_formals++)
3422 /* Now scan backwards while looking for the right end of the rightmost
3423 formals list associated with this function definition. */
3427 const char *l_brace_p;
3429 /* Look leftward and try to find a right-paren. */
3431 while (*end_formals != ')')
3433 if (ISSPACE ((unsigned char)*end_formals))
3434 while (ISSPACE ((unsigned char)*end_formals))
3435 check_source (--end_formals > clean_read_ptr, 0);
3437 check_source (--end_formals > clean_read_ptr, 0);
3440 ch = *(l_brace_p = forward_to_next_token_char (end_formals));
3441 /* Since we are unprotoizing an ANSI-style (prototyped) function
3442 definition, there had better not be anything (except whitespace)
3443 between the end of the ANSI formals list and the beginning of the
3444 function body (i.e. the '{'). */
3446 check_source (ch == '{', l_brace_p);
3449 #else /* !defined (UNPROTOIZE) */
3451 /* Now scan backwards while looking for the right end of the rightmost
3452 formals list associated with this function definition. */
3457 const char *l_brace_p;
3459 /* Look leftward and try to find a right-paren. */
3461 while (*end_formals != ')')
3463 if (ISSPACE ((const unsigned char)*end_formals))
3464 while (ISSPACE ((const unsigned char)*end_formals))
3465 check_source (--end_formals > clean_read_ptr, 0);
3467 check_source (--end_formals > clean_read_ptr, 0);
3470 ch = *(l_brace_p = forward_to_next_token_char (end_formals));
3472 /* Since it is possible that we found a right paren before the starting
3473 '{' of the body which IS NOT the one at the end of the real K&R
3474 formals list (say for instance, we found one embedded inside one of
3475 the old K&R formal parameter declarations) we have to check to be
3476 sure that this is in fact the right paren that we were looking for.
3478 The one we were looking for *must* be followed by either a '{' or
3479 by an alphabetic character, while others *cannot* validly be followed
3480 by such characters. */
3482 if ((ch == '{') || ISALPHA ((unsigned char)ch))
3485 /* At this point, we have found a right paren, but we know that it is
3486 not the one we were looking for, so backup one character and keep
3489 check_source (--end_formals > clean_read_ptr, 0);
3492 #endif /* !defined (UNPROTOIZE) */
3499 /* Insert into the output file a totally new declaration for a function
3500 which (up until now) was being called from within the current block
3501 without having been declared at any point such that the declaration
3502 was visible (i.e. in scope) at the point of the call.
3504 We need to add in explicit declarations for all such function calls
3505 in order to get the full benefit of prototype-based function call
3506 parameter type checking. */
3509 add_local_decl (def_dec_p, clean_text_p)
3510 const def_dec_info *def_dec_p;
3511 const char *clean_text_p;
3513 const char *start_of_block;
3514 const char *function_to_edit = def_dec_p->hash_entry->symbol;
3516 /* Don't insert new local explicit declarations unless explicitly requested
3522 /* Setup here to recover from confusing source code detected during this
3523 particular "edit". */
3526 if (setjmp (source_confusion_recovery))
3528 restore_pointers ();
3529 notice ("%s: local declaration for function `%s' not inserted\n",
3530 pname, function_to_edit);
3534 /* We have already done a seek to the start of the line which should
3535 contain *the* open curly brace which begins the block in which we need
3536 to insert an explicit function declaration (to replace the implicit one).
3538 Now we scan that line, starting from the left, until we find the
3539 open curly brace we are looking for. Note that there may actually be
3540 multiple open curly braces on the given line, but we will be happy
3541 with the leftmost one no matter what. */
3543 start_of_block = clean_text_p;
3544 while (*start_of_block != '{' && *start_of_block != '\n')
3545 check_source (++start_of_block < clean_text_limit, 0);
3547 /* Note that the line from the original source could possibly
3548 contain *no* open curly braces! This happens if the line contains
3549 a macro call which expands into a chunk of text which includes a
3550 block (and that block's associated open and close curly braces).
3551 In cases like this, we give up, issue a warning, and do nothing. */
3553 if (*start_of_block != '{')
3556 notice ("\n%s: %d: warning: can't add declaration of `%s' into macro call\n",
3557 def_dec_p->file->hash_entry->symbol, def_dec_p->line,
3558 def_dec_p->hash_entry->symbol);
3562 /* Figure out what a nice (pretty) indentation would be for the new
3563 declaration we are adding. In order to do this, we must scan forward
3564 from the '{' until we find the first line which starts with some
3565 non-whitespace characters (i.e. real "token" material). */
3568 const char *ep = forward_to_next_token_char (start_of_block) - 1;
3571 /* Now we have ep pointing at the rightmost byte of some existing indent
3572 stuff. At least that is the hope.
3574 We can now just scan backwards and find the left end of the existing
3575 indentation string, and then copy it to the output buffer. */
3577 for (sp = ep; ISSPACE ((const unsigned char)*sp) && *sp != '\n'; sp--)
3580 /* Now write out the open { which began this block, and any following
3581 trash up to and including the last byte of the existing indent that
3586 /* Now we go ahead and insert the new declaration at this point.
3588 If the definition of the given function is in the same file that we
3589 are currently editing, and if its full ANSI declaration normally
3590 would start with the keyword `extern', suppress the `extern'. */
3593 const char *decl = def_dec_p->definition->ansi_decl;
3595 if ((*decl == 'e') && (def_dec_p->file == def_dec_p->definition->file))
3597 output_string (decl);
3600 /* Finally, write out a new indent string, just like the preceding one
3601 that we found. This will typically include a newline as the first
3602 character of the indent string. */
3604 output_bytes (sp, (size_t) (ep - sp) + 1);
3608 /* Given a pointer to a file_info record, and a pointer to the beginning
3609 of a line (in the clean text buffer) which is assumed to contain the
3610 first "follower" token for the first function definition header in the
3611 given file, find a good place to insert some new global function
3612 declarations (which will replace scattered and imprecise implicit ones)
3613 and then insert the new explicit declaration at that point in the file. */
3616 add_global_decls (file_p, clean_text_p)
3617 const file_info *file_p;
3618 const char *clean_text_p;
3620 const def_dec_info *dd_p;
3623 /* Setup here to recover from confusing source code detected during this
3624 particular "edit". */
3627 if (setjmp (source_confusion_recovery))
3629 restore_pointers ();
3630 notice ("%s: global declarations for file `%s' not inserted\n",
3631 pname, shortpath (NULL, file_p->hash_entry->symbol));
3635 /* Start by finding a good location for adding the new explicit function
3636 declarations. To do this, we scan backwards, ignoring whitespace
3637 and comments and other junk until we find either a semicolon, or until
3638 we hit the beginning of the file. */
3640 scan_p = find_rightmost_formals_list (clean_text_p);
3643 if (scan_p < clean_text_base)
3645 check_source (scan_p > clean_read_ptr, 0);
3650 /* scan_p now points either to a semicolon, or to just before the start
3651 of the whole file. */
3653 /* Now scan forward for the first non-whitespace character. In theory,
3654 this should be the first character of the following function definition
3655 header. We will put in the added declarations just prior to that. */
3658 while (ISSPACE ((const unsigned char)*scan_p))
3662 output_up_to (scan_p);
3664 /* Now write out full prototypes for all of the things that had been
3665 implicitly declared in this file (but only those for which we were
3666 actually able to find unique matching definitions). Avoid duplicates
3667 by marking things that we write out as we go. */
3670 int some_decls_added = 0;
3672 for (dd_p = file_p->defs_decs; dd_p; dd_p = dd_p->next_in_file)
3673 if (dd_p->is_implicit && dd_p->definition && !dd_p->definition->written)
3675 const char *decl = dd_p->definition->ansi_decl;
3677 /* If the function for which we are inserting a declaration is
3678 actually defined later in the same file, then suppress the
3679 leading `extern' keyword (if there is one). */
3681 if (*decl == 'e' && (dd_p->file == dd_p->definition->file))
3684 output_string ("\n");
3685 output_string (decl);
3686 some_decls_added = 1;
3687 ((NONCONST def_dec_info *) dd_p->definition)->written = 1;
3689 if (some_decls_added)
3690 output_string ("\n\n");
3693 /* Unmark all of the definitions that we just marked. */
3695 for (dd_p = file_p->defs_decs; dd_p; dd_p = dd_p->next_in_file)
3696 if (dd_p->definition)
3697 ((NONCONST def_dec_info *) dd_p->definition)->written = 0;
3700 #endif /* !defined (UNPROTOIZE) */
3702 /* Do the editing operation specifically for a function "definition". Note
3703 that editing operations for function "declarations" are handled by a
3704 separate routine above. */
3707 edit_fn_definition (def_dec_p, clean_text_p)
3708 const def_dec_info *def_dec_p;
3709 const char *clean_text_p;
3711 const char *end_formals;
3712 const char *function_to_edit = def_dec_p->hash_entry->symbol;
3714 /* Setup here to recover from confusing source code detected during this
3715 particular "edit". */
3718 if (setjmp (source_confusion_recovery))
3720 restore_pointers ();
3721 notice ("%s: definition of function `%s' not converted\n",
3722 pname, function_to_edit);
3726 end_formals = find_rightmost_formals_list (clean_text_p);
3728 /* end_of_formals now points to the closing right paren of the rightmost
3729 formals list which is actually part of the `header' of the function
3730 definition that we are converting. */
3732 /* If the header of this function definition looks like it declares a
3733 function with a variable number of arguments, and if the way it does
3734 that is different from that way we would like it (i.e. varargs vs.
3735 stdarg) then issue a warning and leave the header unconverted. */
3737 if (other_variable_style_function (def_dec_p->ansi_decl))
3740 notice ("%s: %d: warning: definition of %s not converted\n",
3741 shortpath (NULL, def_dec_p->file->hash_entry->symbol),
3742 identify_lineno (end_formals),
3744 output_up_to (end_formals);
3748 if (edit_formals_lists (end_formals, def_dec_p->f_list_count, def_dec_p))
3750 restore_pointers ();
3751 notice ("%s: definition of function `%s' not converted\n",
3752 pname, function_to_edit);
3756 /* Have to output the last right paren because this never gets flushed by
3757 edit_formals_list. */
3759 output_up_to (end_formals);
3764 const char *semicolon_p;
3765 const char *limit_p;
3767 int had_newlines = 0;
3769 /* Now write out the K&R style formal declarations, one per line. */
3771 decl_p = def_dec_p->formal_decls;
3772 limit_p = decl_p + strlen (decl_p);
3773 for (;decl_p < limit_p; decl_p = semicolon_p + 2)
3775 for (semicolon_p = decl_p; *semicolon_p != ';'; semicolon_p++)
3777 output_string ("\n");
3778 output_string (indent_string);
3779 output_bytes (decl_p, (size_t) ((semicolon_p + 1) - decl_p));
3782 /* If there are no newlines between the end of the formals list and the
3783 start of the body, we should insert one now. */
3785 for (scan_p = end_formals+1; *scan_p != '{'; )
3787 if (*scan_p == '\n')
3792 check_source (++scan_p < clean_text_limit, 0);
3795 output_string ("\n");
3797 #else /* !defined (UNPROTOIZE) */
3798 /* If we are protoizing, there may be some flotsam & jetsam (like comments
3799 and preprocessing directives) after the old formals list but before
3800 the following { and we would like to preserve that stuff while effectively
3801 deleting the existing K&R formal parameter declarations. We do so here
3802 in a rather tricky way. Basically, we white out any stuff *except*
3803 the comments/pp-directives in the original text buffer, then, if there
3804 is anything in this area *other* than whitespace, we output it. */
3806 const char *end_formals_orig;
3807 const char *start_body;
3808 const char *start_body_orig;
3810 const char *scan_orig;
3811 int have_flotsam = 0;
3812 int have_newlines = 0;
3814 for (start_body = end_formals + 1; *start_body != '{';)
3815 check_source (++start_body < clean_text_limit, 0);
3817 end_formals_orig = orig_text_base + (end_formals - clean_text_base);
3818 start_body_orig = orig_text_base + (start_body - clean_text_base);
3819 scan = end_formals + 1;
3820 scan_orig = end_formals_orig + 1;
3821 for (; scan < start_body; scan++, scan_orig++)
3823 if (*scan == *scan_orig)
3825 have_newlines |= (*scan_orig == '\n');
3826 /* Leave identical whitespace alone. */
3827 if (!ISSPACE ((const unsigned char)*scan_orig))
3828 *((NONCONST char *)scan_orig) = ' '; /* identical - so whiteout */
3834 output_bytes (end_formals_orig + 1,
3835 (size_t) (start_body_orig - end_formals_orig) - 1);
3838 output_string ("\n");
3840 output_string (" ");
3841 clean_read_ptr = start_body - 1;
3843 #endif /* !defined (UNPROTOIZE) */
3846 /* Clean up the clean text buffer. Do this by converting comments and
3847 preprocessing directives into spaces. Also convert line continuations
3848 into whitespace. Also, whiteout string and character literals. */
3851 do_cleaning (new_clean_text_base, new_clean_text_limit)
3852 char *new_clean_text_base;
3853 char *new_clean_text_limit;
3856 int non_whitespace_since_newline = 0;
3858 for (scan_p = new_clean_text_base; scan_p < new_clean_text_limit; scan_p++)
3862 case '/': /* Handle comments. */
3863 if (scan_p[1] != '*')
3865 non_whitespace_since_newline = 1;
3869 while (scan_p[1] != '/' || scan_p[0] != '*')
3871 if (!ISSPACE ((const unsigned char)*scan_p))
3873 if (++scan_p >= new_clean_text_limit)
3880 case '#': /* Handle pp directives. */
3881 if (non_whitespace_since_newline)
3884 while (scan_p[1] != '\n' || scan_p[0] == '\\')
3886 if (!ISSPACE ((const unsigned char)*scan_p))
3888 if (++scan_p >= new_clean_text_limit)
3894 case '\'': /* Handle character literals. */
3895 non_whitespace_since_newline = 1;
3896 while (scan_p[1] != '\'' || scan_p[0] == '\\')
3898 if (scan_p[0] == '\\'
3899 && !ISSPACE ((const unsigned char)scan_p[1]))
3901 if (!ISSPACE ((const unsigned char)*scan_p))
3903 if (++scan_p >= new_clean_text_limit)
3909 case '"': /* Handle string literals. */
3910 non_whitespace_since_newline = 1;
3911 while (scan_p[1] != '"' || scan_p[0] == '\\')
3913 if (scan_p[0] == '\\'
3914 && !ISSPACE ((const unsigned char)scan_p[1]))
3916 if (!ISSPACE ((const unsigned char)*scan_p))
3918 if (++scan_p >= new_clean_text_limit)
3921 if (!ISSPACE ((const unsigned char)*scan_p))
3926 case '\\': /* Handle line continuations. */
3927 if (scan_p[1] != '\n')
3933 non_whitespace_since_newline = 0; /* Reset. */
3942 break; /* Whitespace characters. */
3946 non_whitespace_since_newline = 1;
3952 /* Given a pointer to the closing right parenthesis for a particular formals
3953 list (in the clean text buffer) find the corresponding left parenthesis
3954 and return a pointer to it. */
3957 careful_find_l_paren (p)
3963 for (paren_depth = 1, q = p-1; paren_depth; check_source (--q >= clean_text_base, 0))
3978 /* Scan the clean text buffer for cases of function definitions that we
3979 don't really know about because they were preprocessed out when the
3980 aux info files were created.
3982 In this version of protoize/unprotoize we just give a warning for each
3983 one found. A later version may be able to at least unprotoize such
3986 Note that we may easily find all function definitions simply by
3987 looking for places where there is a left paren which is (ignoring
3988 whitespace) immediately followed by either a left-brace or by an
3989 upper or lower case letter. Whenever we find this combination, we
3990 have also found a function definition header.
3992 Finding function *declarations* using syntactic clues is much harder.
3993 I will probably try to do this in a later version though. */
3996 scan_for_missed_items (file_p)
3997 const file_info *file_p;
3999 static const char *scan_p;
4000 const char *limit = clean_text_limit - 3;
4001 static const char *backup_limit;
4003 backup_limit = clean_text_base - 1;
4005 for (scan_p = clean_text_base; scan_p < limit; scan_p++)
4009 static const char *last_r_paren;
4010 const char *ahead_p;
4012 last_r_paren = scan_p;
4014 for (ahead_p = scan_p + 1; ISSPACE ((const unsigned char)*ahead_p); )
4015 check_source (++ahead_p < limit, limit);
4017 scan_p = ahead_p - 1;
4019 if (ISALPHA ((const unsigned char)*ahead_p) || *ahead_p == '{')
4021 const char *last_l_paren;
4022 const int lineno = identify_lineno (ahead_p);
4024 if (setjmp (source_confusion_recovery))
4027 /* We know we have a function definition header. Now skip
4028 leftwards over all of its associated formals lists. */
4032 last_l_paren = careful_find_l_paren (last_r_paren);
4033 for (last_r_paren = last_l_paren-1;
4034 ISSPACE ((const unsigned char)*last_r_paren); )
4035 check_source (--last_r_paren >= backup_limit, backup_limit);
4037 while (*last_r_paren == ')');
4039 if (is_id_char (*last_r_paren))
4041 const char *id_limit = last_r_paren + 1;
4042 const char *id_start;
4044 const def_dec_info *dd_p;
4046 for (id_start = id_limit-1; is_id_char (*id_start); )
4047 check_source (--id_start >= backup_limit, backup_limit);
4049 backup_limit = id_start;
4050 if ((id_length = (size_t) (id_limit - id_start)) == 0)
4054 char *func_name = (char *) alloca (id_length + 1);
4055 static const char * const stmt_keywords[]
4056 = { "if", "else", "do", "while", "for", "switch", "case", "return", 0 };
4057 const char * const *stmt_keyword;
4059 strncpy (func_name, id_start, id_length);
4060 func_name[id_length] = '\0';
4062 /* We must check here to see if we are actually looking at
4063 a statement rather than an actual function call. */
4065 for (stmt_keyword = stmt_keywords; *stmt_keyword; stmt_keyword++)
4066 if (!strcmp (func_name, *stmt_keyword))
4070 notice ("%s: found definition of `%s' at %s(%d)\n",
4073 shortpath (NULL, file_p->hash_entry->symbol),
4074 identify_lineno (id_start));
4076 /* We really should check for a match of the function name
4077 here also, but why bother. */
4079 for (dd_p = file_p->defs_decs; dd_p; dd_p = dd_p->next_in_file)
4080 if (dd_p->is_func_def && dd_p->line == lineno)
4083 /* If we make it here, then we did not know about this
4084 function definition. */
4086 notice ("%s: %d: warning: `%s' excluded by preprocessing\n",
4087 shortpath (NULL, file_p->hash_entry->symbol),
4088 identify_lineno (id_start), func_name);
4089 notice ("%s: function definition not converted\n",
4099 /* Do all editing operations for a single source file (either a "base" file
4100 or an "include" file). To do this we read the file into memory, keep a
4101 virgin copy there, make another cleaned in-core copy of the original file
4102 (i.e. one in which all of the comments and preprocessing directives have
4103 been replaced with whitespace), then use these two in-core copies of the
4104 file to make a new edited in-core copy of the file. Finally, rename the
4105 original file (as a way of saving it), and then write the edited version
4106 of the file from core to a disk file of the same name as the original.
4108 Note that the trick of making a copy of the original sans comments &
4109 preprocessing directives make the editing a whole lot easier. */
4113 const hash_table_entry *hp;
4115 struct stat stat_buf;
4116 const file_info *file_p = hp->fip;
4117 char *new_orig_text_base;
4118 char *new_orig_text_limit;
4119 char *new_clean_text_base;
4120 char *new_clean_text_limit;
4123 int first_definition_in_file;
4125 /* If we are not supposed to be converting this file, or if there is
4126 nothing in there which needs converting, just skip this file. */
4128 if (!needs_to_be_converted (file_p))
4131 convert_filename = file_p->hash_entry->symbol;
4133 /* Convert a file if it is in a directory where we want conversion
4134 and the file is not excluded. */
4136 if (!directory_specified_p (convert_filename)
4137 || file_excluded_p (convert_filename))
4141 /* Don't even mention "system" include files unless we are
4142 protoizing. If we are protoizing, we mention these as a
4143 gentle way of prodding the user to convert his "system"
4144 include files to prototype format. */
4145 && !in_system_include_dir (convert_filename)
4146 #endif /* defined (UNPROTOIZE) */
4148 notice ("%s: `%s' not converted\n",
4149 pname, shortpath (NULL, convert_filename));
4153 /* Let the user know what we are up to. */
4156 notice ("%s: would convert file `%s'\n",
4157 pname, shortpath (NULL, convert_filename));
4159 notice ("%s: converting file `%s'\n",
4160 pname, shortpath (NULL, convert_filename));
4163 /* Find out the size (in bytes) of the original file. */
4165 /* The cast avoids an erroneous warning on AIX. */
4166 if (my_stat ((char *)convert_filename, &stat_buf) == -1)
4168 int errno_val = errno;
4169 notice ("%s: can't get status for file `%s': %s\n",
4170 pname, shortpath (NULL, convert_filename),
4171 xstrerror (errno_val));
4174 orig_size = stat_buf.st_size;
4176 /* Allocate a buffer to hold the original text. */
4178 orig_text_base = new_orig_text_base = (char *) xmalloc (orig_size + 2);
4179 orig_text_limit = new_orig_text_limit = new_orig_text_base + orig_size;
4181 /* Allocate a buffer to hold the cleaned-up version of the original text. */
4183 clean_text_base = new_clean_text_base = (char *) xmalloc (orig_size + 2);
4184 clean_text_limit = new_clean_text_limit = new_clean_text_base + orig_size;
4185 clean_read_ptr = clean_text_base - 1;
4187 /* Allocate a buffer that will hopefully be large enough to hold the entire
4188 converted output text. As an initial guess for the maximum size of the
4189 output buffer, use 125% of the size of the original + some extra. This
4190 buffer can be expanded later as needed. */
4192 repl_size = orig_size + (orig_size >> 2) + 4096;
4193 repl_text_base = (char *) xmalloc (repl_size + 2);
4194 repl_text_limit = repl_text_base + repl_size - 1;
4195 repl_write_ptr = repl_text_base - 1;
4200 /* Open the file to be converted in READ ONLY mode. */
4202 if ((input_file = my_open (convert_filename, O_RDONLY, 0444)) == -1)
4204 int errno_val = errno;
4205 notice ("%s: can't open file `%s' for reading: %s\n",
4206 pname, shortpath (NULL, convert_filename),
4207 xstrerror (errno_val));
4211 /* Read the entire original source text file into the original text buffer
4212 in one swell fwoop. Then figure out where the end of the text is and
4213 make sure that it ends with a newline followed by a null. */
4215 if (safe_read (input_file, new_orig_text_base, orig_size) !=
4218 int errno_val = errno;
4220 notice ("\n%s: error reading input file `%s': %s\n",
4221 pname, shortpath (NULL, convert_filename),
4222 xstrerror (errno_val));
4229 if (orig_size == 0 || orig_text_limit[-1] != '\n')
4231 *new_orig_text_limit++ = '\n';
4235 /* Create the cleaned up copy of the original text. */
4237 memcpy (new_clean_text_base, orig_text_base,
4238 (size_t) (orig_text_limit - orig_text_base));
4239 do_cleaning (new_clean_text_base, new_clean_text_limit);
4244 size_t clean_size = orig_text_limit - orig_text_base;
4245 char *const clean_filename = (char *) alloca (strlen (convert_filename) + 6 + 1);
4247 /* Open (and create) the clean file. */
4249 strcpy (clean_filename, convert_filename);
4250 strcat (clean_filename, ".clean");
4251 if ((clean_file = creat (clean_filename, 0666)) == -1)
4253 int errno_val = errno;
4254 notice ("%s: can't create/open clean file `%s': %s\n",
4255 pname, shortpath (NULL, clean_filename),
4256 xstrerror (errno_val));
4260 /* Write the clean file. */
4262 safe_write (clean_file, new_clean_text_base, clean_size, clean_filename);
4268 /* Do a simplified scan of the input looking for things that were not
4269 mentioned in the aux info files because of the fact that they were
4270 in a region of the source which was preprocessed-out (via #if or
4273 scan_for_missed_items (file_p);
4275 /* Setup to do line-oriented forward seeking in the clean text buffer. */
4277 last_known_line_number = 1;
4278 last_known_line_start = clean_text_base;
4280 /* Now get down to business and make all of the necessary edits. */
4283 const def_dec_info *def_dec_p;
4285 first_definition_in_file = 1;
4286 def_dec_p = file_p->defs_decs;
4287 for (; def_dec_p; def_dec_p = def_dec_p->next_in_file)
4289 const char *clean_text_p = seek_to_line (def_dec_p->line);
4291 /* clean_text_p now points to the first character of the line which
4292 contains the `terminator' for the declaration or definition that
4293 we are about to process. */
4297 if (global_flag && def_dec_p->is_func_def && first_definition_in_file)
4299 add_global_decls (def_dec_p->file, clean_text_p);
4300 first_definition_in_file = 0;
4303 /* Don't edit this item if it is already in prototype format or if it
4304 is a function declaration and we have found no corresponding
4307 if (def_dec_p->prototyped
4308 || (!def_dec_p->is_func_def && !def_dec_p->definition))
4311 #endif /* !defined (UNPROTOIZE) */
4313 if (def_dec_p->is_func_def)
4314 edit_fn_definition (def_dec_p, clean_text_p);
4317 if (def_dec_p->is_implicit)
4318 add_local_decl (def_dec_p, clean_text_p);
4320 #endif /* !defined (UNPROTOIZE) */
4321 edit_fn_declaration (def_dec_p, clean_text_p);
4325 /* Finalize things. Output the last trailing part of the original text. */
4327 output_up_to (clean_text_limit - 1);
4329 /* If this is just a test run, stop now and just deallocate the buffers. */
4333 free (new_orig_text_base);
4334 free (new_clean_text_base);
4335 free (repl_text_base);
4339 /* Change the name of the original input file. This is just a quick way of
4340 saving the original file. */
4345 = (char *) xmalloc (strlen (convert_filename) + strlen (save_suffix) + 2);
4347 strcpy (new_filename, convert_filename);
4348 strcat (new_filename, save_suffix);
4349 if (my_link (convert_filename, new_filename) == -1)
4351 int errno_val = errno;
4352 if (errno_val == EEXIST)
4355 notice ("%s: warning: file `%s' already saved in `%s'\n",
4357 shortpath (NULL, convert_filename),
4358 shortpath (NULL, new_filename));
4362 notice ("%s: can't link file `%s' to `%s': %s\n",
4364 shortpath (NULL, convert_filename),
4365 shortpath (NULL, new_filename),
4366 xstrerror (errno_val));
4372 if (my_unlink (convert_filename) == -1)
4374 int errno_val = errno;
4375 notice ("%s: can't delete file `%s': %s\n",
4376 pname, shortpath (NULL, convert_filename),
4377 xstrerror (errno_val));
4384 /* Open (and create) the output file. */
4386 if ((output_file = creat (convert_filename, 0666)) == -1)
4388 int errno_val = errno;
4389 notice ("%s: can't create/open output file `%s': %s\n",
4390 pname, shortpath (NULL, convert_filename),
4391 xstrerror (errno_val));
4395 /* Write the output file. */
4398 unsigned int out_size = (repl_write_ptr + 1) - repl_text_base;
4400 safe_write (output_file, repl_text_base, out_size, convert_filename);
4403 close (output_file);
4406 /* Deallocate the conversion buffers. */
4408 free (new_orig_text_base);
4409 free (new_clean_text_base);
4410 free (repl_text_base);
4412 /* Change the mode of the output file to match the original file. */
4414 /* The cast avoids an erroneous warning on AIX. */
4415 if (my_chmod ((char *)convert_filename, stat_buf.st_mode) == -1)
4417 int errno_val = errno;
4418 notice ("%s: can't change mode of file `%s': %s\n",
4419 pname, shortpath (NULL, convert_filename),
4420 xstrerror (errno_val));
4423 /* Note: We would try to change the owner and group of the output file
4424 to match those of the input file here, except that may not be a good
4425 thing to do because it might be misleading. Also, it might not even
4426 be possible to do that (on BSD systems with quotas for instance). */
4429 /* Do all of the individual steps needed to do the protoization (or
4430 unprotoization) of the files referenced in the aux_info files given
4431 in the command line. */
4436 const char * const *base_pp;
4437 const char * const * const end_pps
4438 = &base_source_filenames[n_base_source_files];
4442 #endif /* !defined (UNPROTOIZE) */
4444 /* One-by-one, check (and create if necessary), open, and read all of the
4445 stuff in each aux_info file. After reading each aux_info file, the
4446 aux_info_file just read will be automatically deleted unless the
4447 keep_flag is set. */
4449 for (base_pp = base_source_filenames; base_pp < end_pps; base_pp++)
4450 process_aux_info_file (*base_pp, keep_flag, 0);
4454 /* Also open and read the special SYSCALLS.c aux_info file which gives us
4455 the prototypes for all of the standard system-supplied functions. */
4457 if (nondefault_syscalls_dir)
4459 syscalls_absolute_filename
4460 = (char *) xmalloc (strlen (nondefault_syscalls_dir)
4461 + sizeof (syscalls_filename) + 1);
4462 strcpy (syscalls_absolute_filename, nondefault_syscalls_dir);
4466 syscalls_absolute_filename
4467 = (char *) xmalloc (strlen (default_syscalls_dir)
4468 + sizeof (syscalls_filename) + 1);
4469 strcpy (syscalls_absolute_filename, default_syscalls_dir);
4472 syscalls_len = strlen (syscalls_absolute_filename);
4473 if (*(syscalls_absolute_filename + syscalls_len - 1) != '/')
4475 *(syscalls_absolute_filename + syscalls_len++) = '/';
4476 *(syscalls_absolute_filename + syscalls_len) = '\0';
4478 strcat (syscalls_absolute_filename, syscalls_filename);
4480 /* Call process_aux_info_file in such a way that it does not try to
4481 delete the SYSCALLS aux_info file. */
4483 process_aux_info_file (syscalls_absolute_filename, 1, 1);
4485 #endif /* !defined (UNPROTOIZE) */
4487 /* When we first read in all of the information from the aux_info files
4488 we saved in it descending line number order, because that was likely to
4489 be faster. Now however, we want the chains of def & dec records to
4490 appear in ascending line number order as we get further away from the
4491 file_info record that they hang from. The following line causes all of
4492 these lists to be rearranged into ascending line number order. */
4494 visit_each_hash_node (filename_primary, reverse_def_dec_list);
4498 /* Now do the "real" work. The following line causes each declaration record
4499 to be "visited". For each of these nodes, an attempt is made to match
4500 up the function declaration with a corresponding function definition,
4501 which should have a full prototype-format formals list with it. Once
4502 these match-ups are made, the conversion of the function declarations
4503 to prototype format can be made. */
4505 visit_each_hash_node (function_name_primary, connect_defs_and_decs);
4507 #endif /* !defined (UNPROTOIZE) */
4509 /* Now convert each file that can be converted (and needs to be). */
4511 visit_each_hash_node (filename_primary, edit_file);
4515 /* If we are working in cplusplus mode, try to rename all .c files to .C
4516 files. Don't panic if some of the renames don't work. */
4518 if (cplusplus_flag && !nochange_flag)
4519 visit_each_hash_node (filename_primary, rename_c_file);
4521 #endif /* !defined (UNPROTOIZE) */
4524 static struct option longopts[] =
4526 {"version", 0, 0, 'V'},
4527 {"file_name", 0, 0, 'p'},
4528 {"quiet", 0, 0, 'q'},
4529 {"silent", 0, 0, 'q'},
4530 {"force", 0, 0, 'f'},
4531 {"keep", 0, 0, 'k'},
4532 {"nosave", 0, 0, 'N'},
4533 {"nochange", 0, 0, 'n'},
4534 {"compiler-options", 1, 0, 'c'},
4535 {"exclude", 1, 0, 'x'},
4536 {"directory", 1, 0, 'd'},
4538 {"indent", 1, 0, 'i'},
4540 {"local", 0, 0, 'l'},
4541 {"global", 0, 0, 'g'},
4543 {"syscalls-dir", 1, 0, 'B'},
4555 const char *params = "";
4557 pname = strrchr (argv[0], '/');
4558 pname = pname ? pname+1 : argv[0];
4560 #ifdef HAVE_LC_MESSAGES
4561 setlocale (LC_MESSAGES, "");
4563 (void) bindtextdomain (PACKAGE, localedir);
4564 (void) textdomain (PACKAGE);
4566 cwd_buffer = getpwd ();
4569 notice ("%s: cannot get working directory: %s\n",
4570 pname, xstrerror(errno));
4571 exit (FATAL_EXIT_CODE);
4574 /* By default, convert the files in the current directory. */
4575 directory_list = string_list_cons (cwd_buffer, NULL);
4577 while ((c = getopt_long (argc, argv,
4581 "B:c:Cd:gklnNp:qvVx:",
4583 longopts, &longind)) != EOF)
4585 if (c == 0) /* Long option. */
4586 c = longopts[longind].val;
4590 compiler_file_name = optarg;
4594 = string_list_cons (abspath (NULL, optarg), directory_list);
4597 exclude_list = string_list_cons (optarg, exclude_list);
4627 indent_string = optarg;
4629 #else /* !defined (UNPROTOIZE) */
4640 nondefault_syscalls_dir = optarg;
4642 #endif /* !defined (UNPROTOIZE) */
4648 /* Set up compile_params based on -p and -c options. */
4649 munge_compile_params (params);
4651 n_base_source_files = argc - optind;
4653 /* Now actually make a list of the base source filenames. */
4655 base_source_filenames
4656 = (const char **) xmalloc ((n_base_source_files + 1) * sizeof (char *));
4657 n_base_source_files = 0;
4658 for (; optind < argc; optind++)
4660 const char *path = abspath (NULL, argv[optind]);
4661 int len = strlen (path);
4663 if (path[len-1] == 'c' && path[len-2] == '.')
4664 base_source_filenames[n_base_source_files++] = path;
4667 notice ("%s: input file names must have .c suffixes: %s\n",
4668 pname, shortpath (NULL, path));
4674 /* We are only interested in the very first identifier token in the
4675 definition of `va_list', so if there is more junk after that first
4676 identifier token, delete it from the `varargs_style_indicator'. */
4680 for (cp = varargs_style_indicator;
4681 ISALNUM ((const unsigned char)*cp) || *cp == '_'; cp++)
4684 varargs_style_indicator = savestring (varargs_style_indicator,
4685 cp - varargs_style_indicator);
4687 #endif /* !defined (UNPROTOIZE) */
4694 fprintf (stderr, "%s: %s\n", pname, version_string);
4698 exit (errors ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);