| /* Protoize program - Original version by Ron Guilmette (rfg@segfault.us.com). |
| Copyright (C) 1989, 92-96, 1997 Free Software Foundation, Inc. |
| |
| This file is part of GNU CC. |
| |
| GNU CC is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU CC is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU CC; see the file COPYING. If not, write to |
| the Free Software Foundation, 59 Temple Place - Suite 330, |
| Boston, MA 02111-1307, USA. */ |
| |
| /* Any reasonable C++ compiler should have all of the same features |
| as __STDC__ plus more, so make sure that __STDC__ is defined if |
| __cplusplus is defined. */ |
| |
| #if defined(__cplusplus) && !defined(__STDC__) |
| #define __STDC__ 1 |
| #endif /* defined(__cplusplus) && !defined(__STDC__) */ |
| |
| #if defined(__GNUC__) || defined (__GNUG__) |
| #define VOLATILE volatile |
| #else |
| #define VOLATILE |
| #endif |
| |
| #ifndef __STDC__ |
| #define const |
| #define volatile |
| #endif |
| |
| #include "config.h" |
| |
| #if 0 |
| /* Users are not supposed to use _POSIX_SOURCE to say the |
| system is a POSIX system. That is not what _POSIX_SOURCE means! -- rms */ |
| /* If the user asked for POSIX via _POSIX_SOURCE, turn on POSIX code. */ |
| #if defined(_POSIX_SOURCE) && !defined(POSIX) |
| #define POSIX |
| #endif |
| #endif /* 0 */ |
| |
| #ifdef POSIX /* We should be able to define _POSIX_SOURCE unconditionally, |
| but some systems respond in buggy ways to it, |
| including SunOS 4.1.1. Which we don't classify as POSIX. */ |
| /* In case this is a POSIX system with an ANSI C compiler, |
| ask for definition of all POSIX facilities. */ |
| #undef _POSIX_SOURCE |
| #define _POSIX_SOURCE |
| #endif |
| |
| #ifdef HAVE_VARARGS_H |
| #include <varargs.h> |
| #else |
| #ifdef HAVE_SYS_VARARGS_H |
| #include <sys/varargs.h> |
| #endif |
| #endif |
| |
| /* On some systems stdio.h includes stdarg.h; |
| we must bring in varargs.h first. */ |
| #include <stdio.h> |
| #include <ctype.h> |
| #include <errno.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #if ! defined (_WIN32) || defined (__CYGWIN32__) |
| #if defined(POSIX) || defined(CONCURRENT) |
| #include <dirent.h> |
| #else |
| #include <sys/dir.h> |
| #endif |
| #endif |
| #include <setjmp.h> |
| |
| #include "gansidecl.h" |
| |
| /* Include getopt.h for the sake of getopt_long. |
| We don't need the declaration of getopt, and it could conflict |
| with something from a system header file, so effectively nullify that. */ |
| #define getopt getopt_loser |
| #include "getopt.h" |
| #undef getopt |
| |
| #ifndef errno |
| extern int errno; |
| #endif |
| |
| #ifndef HAVE_STRERROR |
| extern int sys_nerr; |
| extern char *sys_errlist[]; |
| #else |
| extern char *strerror(); |
| #endif |
| |
| extern char *version_string; |
| |
| /* Systems which are compatible only with POSIX 1003.1-1988 (but *not* |
| with POSIX 1003.1-1990), e.g. Ultrix 4.2, might not have |
| const qualifiers in the prototypes in the system include files. |
| Unfortunately, this can lead to GCC issuing lots of warnings for |
| calls to the following functions. To eliminate these warnings we |
| provide the following #defines. */ |
| |
| #define my_access(file,flag) access((char *)file, flag) |
| #define my_stat(file,pkt) stat((char *)file, pkt) |
| #define my_link(file1, file2) link((char *)file1, (char *)file2) |
| #define my_unlink(file) unlink((char *)file) |
| #define my_open(file, mode, flag) open((char *)file, mode, flag) |
| #define my_chmod(file, mode) chmod((char *)file, mode) |
| |
| extern char *getpwd (); |
| |
| extern char *choose_temp_base PROTO ((void)); |
| |
| extern int pexecute PROTO ((const char *, char * const *, const char *, |
| const char *, char **, char **, int)); |
| extern int pwait PROTO ((int, int *, int)); |
| /* Flag arguments to pexecute. */ |
| #define PEXECUTE_FIRST 1 |
| #define PEXECUTE_LAST 2 |
| #define PEXECUTE_SEARCH 4 |
| |
| /* Aliases for pointers to void. |
| These were made to facilitate compilation with old brain-dead DEC C |
| compilers which didn't properly grok `void*' types. */ |
| |
| #ifdef __STDC__ |
| typedef void * pointer_type; |
| typedef const void * const_pointer_type; |
| #else |
| typedef char * pointer_type; |
| typedef char * const_pointer_type; |
| #endif |
| |
| #if defined(POSIX) |
| |
| #include <stdlib.h> |
| #include <unistd.h> |
| #include <signal.h> |
| #include <fcntl.h> |
| #include <sys/wait.h> |
| |
| #else /* !defined(POSIX) */ |
| |
| #define R_OK 4 /* Test for Read permission */ |
| #define W_OK 2 /* Test for Write permission */ |
| #define X_OK 1 /* Test for eXecute permission */ |
| #define F_OK 0 /* Test for existence of File */ |
| |
| #ifndef O_RDONLY |
| #define O_RDONLY 0 |
| #endif |
| |
| #ifndef O_WRONLY |
| #define O_WRONLY 1 |
| #endif |
| |
| #ifndef WIFSIGNALED |
| #define WIFSIGNALED(S) (((S) & 0xff) != 0 && ((S) & 0xff) != 0x7f) |
| #endif |
| #ifndef WTERMSIG |
| #define WTERMSIG(S) ((S) & 0x7f) |
| #endif |
| #ifndef WIFEXITED |
| #define WIFEXITED(S) (((S) & 0xff) == 0) |
| #endif |
| #ifndef WEXITSTATUS |
| #define WEXITSTATUS(S) (((S) & 0xff00) >> 8) |
| #endif |
| |
| /* Declaring stat or __flsbuf with a prototype |
| causes conflicts with system headers on some systems. */ |
| |
| #ifndef abort |
| typedef void voidfn (); |
| extern VOLATILE voidfn abort; |
| #endif |
| extern int creat (); |
| #if 0 /* These conflict with stdio.h on some systems. */ |
| extern int fprintf (FILE *, const char *, ...); |
| extern int printf (const char *, ...); |
| extern int open (const char *, int, ...); |
| #endif /* 0 */ |
| extern void exit (); |
| extern void free (); |
| extern int read (); |
| extern int write (); |
| extern int close (); |
| extern int fflush (); |
| extern int atoi (); |
| extern int puts (); |
| extern int fputs (); |
| extern int fputc (); |
| #if !defined(_WIN32) |
| extern int link (); |
| #endif |
| extern int unlink (); |
| extern int access (); |
| |
| #if 0 /* size_t from sys/types.h may fail to match GCC. |
| If so, we would get a warning from this. */ |
| extern size_t strlen () |
| #endif |
| |
| /* Fork is not declared because the declaration caused a conflict |
| on the HPPA. */ |
| #if !(defined (USG) || defined (VMS)) |
| #define fork vfork |
| #endif /* (defined (USG) || defined (VMS)) */ |
| |
| #endif /* !defined (POSIX) */ |
| |
| extern char *rindex (); |
| |
| /* Look for these where the `const' qualifier is intentionally cast aside. */ |
| |
| #define NONCONST |
| |
| /* Define a STRINGIFY macro that's right for ANSI or traditional C. */ |
| |
| #ifdef __STDC__ |
| #define STRINGIFY(STRING) #STRING |
| #else |
| #define STRINGIFY(STRING) "STRING" |
| #endif |
| |
| /* Define a default place to find the SYSCALLS.X file. */ |
| |
| #ifndef STD_PROTO_DIR |
| #define STD_PROTO_DIR "/usr/local/lib" |
| #endif /* !defined (STD_PROTO_DIR) */ |
| |
| /* Suffix of aux_info files. */ |
| |
| static const char * const aux_info_suffix = ".X"; |
| |
| /* String to attach to filenames for saved versions of original files. */ |
| |
| static const char * const save_suffix = ".save"; |
| |
| #ifndef UNPROTOIZE |
| |
| /* File name of the file which contains descriptions of standard system |
| routines. Note that we never actually do anything with this file per se, |
| but we do read in its corresponding aux_info file. */ |
| |
| static const char syscalls_filename[] = "SYSCALLS.c"; |
| |
| /* Default place to find the above file. */ |
| |
| static const char * const default_syscalls_dir = STD_PROTO_DIR; |
| |
| /* Variable to hold the complete absolutized filename of the SYSCALLS.c.X |
| file. */ |
| |
| static char * syscalls_absolute_filename; |
| |
| #endif /* !defined (UNPROTOIZE) */ |
| |
| /* Type of the structure that holds information about macro unexpansions. */ |
| |
| struct unexpansion_struct { |
| const char *expanded; |
| const char *contracted; |
| }; |
| typedef struct unexpansion_struct unexpansion; |
| |
| /* A table of conversions that may need to be made for some (stupid) older |
| operating systems where these types are preprocessor macros rather than |
| typedefs (as they really ought to be). |
| |
| WARNING: The contracted forms must be as small (or smaller) as the |
| expanded forms, or else havoc will ensue. */ |
| |
| static const unexpansion unexpansions[] = { |
| { "struct _iobuf", "FILE" }, |
| { 0, 0 } |
| }; |
| |
| /* The number of "primary" slots in the hash tables for filenames and for |
| function names. This can be as big or as small as you like, except that |
| it must be a power of two. */ |
| |
| #define HASH_TABLE_SIZE (1 << 9) |
| |
| /* Bit mask to use when computing hash values. */ |
| |
| static const int hash_mask = (HASH_TABLE_SIZE - 1); |
| |
| /* Make a table of default system include directories |
| just as it is done in cccp.c. */ |
| |
| #ifndef STANDARD_INCLUDE_DIR |
| #define STANDARD_INCLUDE_DIR "/usr/include" |
| #endif |
| |
| #ifndef LOCAL_INCLUDE_DIR |
| #define LOCAL_INCLUDE_DIR "/usr/local/include" |
| #endif |
| |
| struct default_include { const char *fname; int x1, x2; } include_defaults[] |
| #ifdef INCLUDE_DEFAULTS |
| = INCLUDE_DEFAULTS; |
| #else |
| = { |
| /* Pick up GNU C++ specific include files. */ |
| { GPLUSPLUS_INCLUDE_DIR, 1, 1 }, |
| #ifdef CROSS_COMPILE |
| /* This is the dir for fixincludes. Put it just before |
| the files that we fix. */ |
| { GCC_INCLUDE_DIR, 0, 0 }, |
| /* For cross-compilation, this dir name is generated |
| automatically in Makefile.in. */ |
| { CROSS_INCLUDE_DIR, 0, 0 }, |
| /* This is another place that the target system's headers might be. */ |
| { TOOL_INCLUDE_DIR, 0, 0 }, |
| #else /* not CROSS_COMPILE */ |
| /* This should be /use/local/include and should come before |
| the fixincludes-fixed header files. */ |
| { LOCAL_INCLUDE_DIR, 0, 1 }, |
| /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here. |
| Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h. */ |
| { TOOL_INCLUDE_DIR, 0, 0 }, |
| /* This is the dir for fixincludes. Put it just before |
| the files that we fix. */ |
| { GCC_INCLUDE_DIR, 0, 0 }, |
| /* Some systems have an extra dir of include files. */ |
| #ifdef SYSTEM_INCLUDE_DIR |
| { SYSTEM_INCLUDE_DIR, 0, 0 }, |
| #endif |
| { STANDARD_INCLUDE_DIR, 0, 0}, |
| #endif /* not CROSS_COMPILE */ |
| { 0, 0, 0} |
| }; |
| #endif /* no INCLUDE_DEFAULTS */ |
| |
| /* Datatype for lists of directories or filenames. */ |
| struct string_list |
| { |
| char *name; |
| struct string_list *next; |
| }; |
| |
| /* List of directories in which files should be converted. */ |
| |
| struct string_list *directory_list; |
| |
| /* List of file names which should not be converted. |
| A file is excluded if the end of its name, following a /, |
| matches one of the names in this list. */ |
| |
| struct string_list *exclude_list; |
| |
| /* The name of the other style of variable-number-of-parameters functions |
| (i.e. the style that we want to leave unconverted because we don't yet |
| know how to convert them to this style. This string is used in warning |
| messages. */ |
| |
| /* Also define here the string that we can search for in the parameter lists |
| taken from the .X files which will unambiguously indicate that we have |
| found a varargs style function. */ |
| |
| #ifdef UNPROTOIZE |
| static const char * const other_var_style = "stdarg"; |
| #else /* !defined (UNPROTOIZE) */ |
| static const char * const other_var_style = "varargs"; |
| /* Note that this is a string containing the expansion of va_alist. |
| But in `main' we discard all but the first token. */ |
| static const char *varargs_style_indicator = STRINGIFY (va_alist); |
| #endif /* !defined (UNPROTOIZE) */ |
| |
| /* The following two types are used to create hash tables. In this program, |
| there are two hash tables which are used to store and quickly lookup two |
| different classes of strings. The first type of strings stored in the |
| first hash table are absolute filenames of files which protoize needs to |
| know about. The second type of strings (stored in the second hash table) |
| are function names. It is this second class of strings which really |
| inspired the use of the hash tables, because there may be a lot of them. */ |
| |
| typedef struct hash_table_entry_struct hash_table_entry; |
| |
| /* Do some typedefs so that we don't have to write "struct" so often. */ |
| |
| typedef struct def_dec_info_struct def_dec_info; |
| typedef struct file_info_struct file_info; |
| typedef struct f_list_chain_item_struct f_list_chain_item; |
| |
| /* In the struct below, note that the "_info" field has two different uses |
| depending on the type of hash table we are in (i.e. either the filenames |
| hash table or the function names hash table). In the filenames hash table |
| the info fields of the entries point to the file_info struct which is |
| associated with each filename (1 per filename). In the function names |
| hash table, the info field points to the head of a singly linked list of |
| def_dec_info entries which are all defs or decs of the function whose |
| name is pointed to by the "symbol" field. Keeping all of the defs/decs |
| for a given function name on a special list specifically for that function |
| name makes it quick and easy to find out all of the important information |
| about a given (named) function. */ |
| |
| struct hash_table_entry_struct { |
| hash_table_entry * hash_next; /* -> to secondary entries */ |
| const char * symbol; /* -> to the hashed string */ |
| union { |
| const def_dec_info * _ddip; |
| file_info * _fip; |
| } _info; |
| }; |
| #define ddip _info._ddip |
| #define fip _info._fip |
| |
| /* Define a type specifically for our two hash tables. */ |
| |
| typedef hash_table_entry hash_table[HASH_TABLE_SIZE]; |
| |
| /* The following struct holds all of the important information about any |
| single filename (e.g. file) which we need to know about. */ |
| |
| struct file_info_struct { |
| const hash_table_entry * hash_entry; /* -> to associated hash entry */ |
| const def_dec_info * defs_decs; /* -> to chain of defs/decs */ |
| time_t mtime; /* Time of last modification. */ |
| }; |
| |
| /* Due to the possibility that functions may return pointers to functions, |
| (which may themselves have their own parameter lists) and due to the |
| fact that returned pointers-to-functions may be of type "pointer-to- |
| function-returning-pointer-to-function" (ad nauseum) we have to keep |
| an entire chain of ANSI style formal parameter lists for each function. |
| |
| Normally, for any given function, there will only be one formals list |
| on the chain, but you never know. |
| |
| Note that the head of each chain of formals lists is pointed to by the |
| `f_list_chain' field of the corresponding def_dec_info record. |
| |
| For any given chain, the item at the head of the chain is the *leftmost* |
| parameter list seen in the actual C language function declaration. If |
| there are other members of the chain, then these are linked in left-to-right |
| order from the head of the chain. */ |
| |
| struct f_list_chain_item_struct { |
| const f_list_chain_item * chain_next; /* -> to next item on chain */ |
| const char * formals_list; /* -> to formals list string */ |
| }; |
| |
| /* The following struct holds all of the important information about any |
| single function definition or declaration which we need to know about. |
| Note that for unprotoize we don't need to know very much because we |
| never even create records for stuff that we don't intend to convert |
| (like for instance defs and decs which are already in old K&R format |
| and "implicit" function declarations). */ |
| |
| struct def_dec_info_struct { |
| const def_dec_info * next_in_file; /* -> to rest of chain for file */ |
| file_info * file; /* -> file_info for containing file */ |
| int line; /* source line number of def/dec */ |
| const char * ansi_decl; /* -> left end of ansi decl */ |
| hash_table_entry * hash_entry; /* -> hash entry for function name */ |
| unsigned int is_func_def; /* = 0 means this is a declaration */ |
| const def_dec_info * next_for_func; /* -> to rest of chain for func name */ |
| unsigned int f_list_count; /* count of formals lists we expect */ |
| char prototyped; /* = 0 means already prototyped */ |
| #ifndef UNPROTOIZE |
| const f_list_chain_item * f_list_chain; /* -> chain of formals lists */ |
| const def_dec_info * definition; /* -> def/dec containing related def */ |
| char is_static; /* = 0 means visibility is "extern" */ |
| char is_implicit; /* != 0 for implicit func decl's */ |
| char written; /* != 0 means written for implicit */ |
| #else /* !defined (UNPROTOIZE) */ |
| const char * formal_names; /* -> to list of names of formals */ |
| const char * formal_decls; /* -> to string of formal declarations */ |
| #endif /* !defined (UNPROTOIZE) */ |
| }; |
| |
| /* Pointer to the tail component of the filename by which this program was |
| invoked. Used everywhere in error and warning messages. */ |
| |
| static const char *pname; |
| |
| /* Error counter. Will be non-zero if we should give up at the next convenient |
| stopping point. */ |
| |
| static int errors = 0; |
| |
| /* Option flags. */ |
| /* ??? These comments should say what the flag mean as well as the options |
| that set them. */ |
| |
| /* File name to use for running gcc. Allows GCC 2 to be named |
| something other than gcc. */ |
| static const char *compiler_file_name = "gcc"; |
| |
| static int version_flag = 0; /* Print our version number. */ |
| static int quiet_flag = 0; /* Don't print messages normally. */ |
| static int nochange_flag = 0; /* Don't convert, just say what files |
| we would have converted. */ |
| static int nosave_flag = 0; /* Don't save the old version. */ |
| static int keep_flag = 0; /* Don't delete the .X files. */ |
| static const char ** compile_params = 0; /* Option string for gcc. */ |
| #ifdef UNPROTOIZE |
| static const char *indent_string = " "; /* Indentation for newly |
| inserted parm decls. */ |
| #else /* !defined (UNPROTOIZE) */ |
| static int local_flag = 0; /* Insert new local decls (when?). */ |
| static int global_flag = 0; /* set by -g option */ |
| static int cplusplus_flag = 0; /* Rename converted files to *.C. */ |
| static const char *nondefault_syscalls_dir = 0; /* Dir to look for |
| SYSCALLS.c.X in. */ |
| #endif /* !defined (UNPROTOIZE) */ |
| |
| /* An index into the compile_params array where we should insert the source |
| file name when we are ready to exec the C compiler. A zero value indicates |
| that we have not yet called munge_compile_params. */ |
| |
| static int input_file_name_index = 0; |
| |
| /* An index into the compile_params array where we should insert the filename |
| for the aux info file, when we run the C compiler. */ |
| static int aux_info_file_name_index = 0; |
| |
| /* Count of command line arguments which were "filename" arguments. */ |
| |
| static int n_base_source_files = 0; |
| |
| /* Points to a malloc'ed list of pointers to all of the filenames of base |
| source files which were specified on the command line. */ |
| |
| static const char **base_source_filenames; |
| |
| /* Line number of the line within the current aux_info file that we |
| are currently processing. Used for error messages in case the prototypes |
| info file is corrupted somehow. */ |
| |
| static int current_aux_info_lineno; |
| |
| /* Pointer to the name of the source file currently being converted. */ |
| |
| static const char *convert_filename; |
| |
| /* Pointer to relative root string (taken from aux_info file) which indicates |
| where directory the user was in when he did the compilation step that |
| produced the containing aux_info file. */ |
| |
| static const char *invocation_filename; |
| |
| /* Pointer to the base of the input buffer that holds the original text for the |
| source file currently being converted. */ |
| |
| static const char *orig_text_base; |
| |
| /* Pointer to the byte just beyond the end of the input buffer that holds the |
| original text for the source file currently being converted. */ |
| |
| static const char *orig_text_limit; |
| |
| /* Pointer to the base of the input buffer that holds the cleaned text for the |
| source file currently being converted. */ |
| |
| static const char *clean_text_base; |
| |
| /* Pointer to the byte just beyond the end of the input buffer that holds the |
| cleaned text for the source file currently being converted. */ |
| |
| static const char *clean_text_limit; |
| |
| /* Pointer to the last byte in the cleaned text buffer that we have already |
| (virtually) copied to the output buffer (or decided to ignore). */ |
| |
| static const char * clean_read_ptr; |
| |
| /* Pointer to the base of the output buffer that holds the replacement text |
| for the source file currently being converted. */ |
| |
| static char *repl_text_base; |
| |
| /* Pointer to the byte just beyond the end of the output buffer that holds the |
| replacement text for the source file currently being converted. */ |
| |
| static char *repl_text_limit; |
| |
| /* Pointer to the last byte which has been stored into the output buffer. |
| The next byte to be stored should be stored just past where this points |
| to. */ |
| |
| static char * repl_write_ptr; |
| |
| /* Pointer into the cleaned text buffer for the source file we are currently |
| converting. This points to the first character of the line that we last |
| did a "seek_to_line" to (see below). */ |
| |
| static const char *last_known_line_start; |
| |
| /* Number of the line (in the cleaned text buffer) that we last did a |
| "seek_to_line" to. Will be one if we just read a new source file |
| into the cleaned text buffer. */ |
| |
| static int last_known_line_number; |
| |
| /* The filenames hash table. */ |
| |
| static hash_table filename_primary; |
| |
| /* The function names hash table. */ |
| |
| static hash_table function_name_primary; |
| |
| /* The place to keep the recovery address which is used only in cases where |
| we get hopelessly confused by something in the cleaned original text. */ |
| |
| static jmp_buf source_confusion_recovery; |
| |
| /* A pointer to the current directory filename (used by abspath). */ |
| |
| static char *cwd_buffer; |
| |
| /* A place to save the read pointer until we are sure that an individual |
| attempt at editing will succeed. */ |
| |
| static const char * saved_clean_read_ptr; |
| |
| /* A place to save the write pointer until we are sure that an individual |
| attempt at editing will succeed. */ |
| |
| static char * saved_repl_write_ptr; |
| |
| /* Forward declaration. */ |
| |
| static const char *shortpath (); |
| |
| char * |
| my_strerror(e) |
| int e; |
| { |
| |
| #ifdef HAVE_STRERROR |
| return strerror(e); |
| |
| #else |
| |
| static char buffer[30]; |
| if (!e) |
| return ""; |
| |
| if (e > 0 && e < sys_nerr) |
| return sys_errlist[e]; |
| |
| sprintf (buffer, "Unknown error %d", e); |
| return buffer; |
| #endif |
| } |
| |
| /* Allocate some space, but check that the allocation was successful. */ |
| /* alloca.c uses this, so don't make it static. */ |
| |
| pointer_type |
| xmalloc (byte_count) |
| size_t byte_count; |
| { |
| pointer_type rv; |
| |
| rv = (pointer_type) malloc (byte_count); |
| if (rv == NULL) |
| { |
| fprintf (stderr, "\n%s: virtual memory exceeded\n", pname); |
| exit (FATAL_EXIT_CODE); |
| return 0; /* avoid warnings */ |
| } |
| else |
| return rv; |
| } |
| |
| /* Reallocate some space, but check that the reallocation was successful. */ |
| |
| pointer_type |
| xrealloc (old_space, byte_count) |
| pointer_type old_space; |
| size_t byte_count; |
| { |
| pointer_type rv; |
| |
| rv = (pointer_type) realloc (old_space, byte_count); |
| if (rv == NULL) |
| { |
| fprintf (stderr, "\n%s: virtual memory exceeded\n", pname); |
| exit (FATAL_EXIT_CODE); |
| return 0; /* avoid warnings */ |
| } |
| else |
| return rv; |
| } |
| |
| /* Deallocate the area pointed to by an arbitrary pointer, but first, strip |
| the `const' qualifier from it and also make sure that the pointer value |
| is non-null. */ |
| |
| void |
| xfree (p) |
| const_pointer_type p; |
| { |
| if (p) |
| free ((NONCONST pointer_type) p); |
| } |
| |
| /* Make a copy of a string INPUT with size SIZE. */ |
| |
| static char * |
| savestring (input, size) |
| const char *input; |
| unsigned int size; |
| { |
| char *output = (char *) xmalloc (size + 1); |
| strcpy (output, input); |
| return output; |
| } |
| |
| /* Make a copy of the concatenation of INPUT1 and INPUT2. */ |
| |
| static char * |
| savestring2 (input1, size1, input2, size2) |
| const char *input1; |
| unsigned int size1; |
| const char *input2; |
| unsigned int size2; |
| { |
| char *output = (char *) xmalloc (size1 + size2 + 1); |
| strcpy (output, input1); |
| strcpy (&output[size1], input2); |
| return output; |
| } |
| |
| /* More 'friendly' abort that prints the line and file. |
| config.h can #define abort fancy_abort if you like that sort of thing. */ |
| |
| void |
| fancy_abort () |
| { |
| fprintf (stderr, "%s: internal abort\n", pname); |
| exit (FATAL_EXIT_CODE); |
| } |
| |
| /* Make a duplicate of the first N bytes of a given string in a newly |
| allocated area. */ |
| |
| static char * |
| dupnstr (s, n) |
| const char *s; |
| size_t n; |
| { |
| char *ret_val = (char *) xmalloc (n + 1); |
| |
| strncpy (ret_val, s, n); |
| ret_val[n] = '\0'; |
| return ret_val; |
| } |
| |
| /* Return a pointer to the first occurrence of s2 within s1 or NULL if s2 |
| does not occur within s1. Assume neither s1 nor s2 are null pointers. */ |
| |
| static const char * |
| substr (s1, s2) |
| const char *s1; |
| const char *const s2; |
| { |
| for (; *s1 ; s1++) |
| { |
| const char *p1; |
| const char *p2; |
| int c; |
| |
| for (p1 = s1, p2 = s2; c = *p2; p1++, p2++) |
| if (*p1 != c) |
| goto outer; |
| return s1; |
| outer: |
| ; |
| } |
| return 0; |
| } |
| |
| /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME, |
| retrying if necessary. Return the actual number of bytes read. */ |
| |
| static int |
| safe_read (desc, ptr, len) |
| int desc; |
| char *ptr; |
| int len; |
| { |
| int left = len; |
| while (left > 0) { |
| int nchars = read (desc, ptr, left); |
| if (nchars < 0) |
| { |
| #ifdef EINTR |
| if (errno == EINTR) |
| continue; |
| #endif |
| return nchars; |
| } |
| if (nchars == 0) |
| break; |
| ptr += nchars; |
| left -= nchars; |
| } |
| return len - left; |
| } |
| |
| /* Write LEN bytes at PTR to descriptor DESC, |
| retrying if necessary, and treating any real error as fatal. */ |
| |
| static void |
| safe_write (desc, ptr, len, out_fname) |
| int desc; |
| char *ptr; |
| int len; |
| char *out_fname; |
| { |
| while (len > 0) { |
| int written = write (desc, ptr, len); |
| if (written < 0) |
| { |
| #ifdef EINTR |
| if (errno == EINTR) |
| continue; |
| #endif |
| fprintf (stderr, "%s: error writing file `%s': %s\n", |
| pname, shortpath (NULL, out_fname), my_strerror(errno)); |
| return; |
| } |
| ptr += written; |
| len -= written; |
| } |
| } |
| |
| /* Get setup to recover in case the edit we are about to do goes awry. */ |
| |
| void |
| save_pointers () |
| { |
| saved_clean_read_ptr = clean_read_ptr; |
| saved_repl_write_ptr = repl_write_ptr; |
| } |
| |
| /* Call this routine to recover our previous state whenever something looks |
| too confusing in the source code we are trying to edit. */ |
| |
| void |
| restore_pointers () |
| { |
| clean_read_ptr = saved_clean_read_ptr; |
| repl_write_ptr = saved_repl_write_ptr; |
| } |
| |
| /* Return true if the given character is a valid identifier character. */ |
| |
| static int |
| is_id_char (ch) |
| char ch; |
| { |
| return (isalnum (ch) || (ch == '_') || (ch == '$')); |
| } |
| |
| /* Give a message indicating the proper way to invoke this program and then |
| exit with non-zero status. */ |
| |
| static void |
| usage () |
| { |
| #ifdef UNPROTOIZE |
| fprintf (stderr, "%s: usage '%s [ -VqfnkN ] [ -i <istring> ] [ filename ... ]'\n", |
| pname, pname); |
| #else /* !defined (UNPROTOIZE) */ |
| fprintf (stderr, "%s: usage '%s [ -VqfnkNlgC ] [ -B <dirname> ] [ filename ... ]'\n", |
| pname, pname); |
| #endif /* !defined (UNPROTOIZE) */ |
| exit (FATAL_EXIT_CODE); |
| } |
| |
| /* Return true if the given filename (assumed to be an absolute filename) |
| designates a file residing anywhere beneath any one of the "system" |
| include directories. */ |
| |
| static int |
| in_system_include_dir (path) |
| const char *path; |
| { |
| struct default_include *p; |
| |
| if (path[0] != '/') |
| abort (); /* Must be an absolutized filename. */ |
| |
| for (p = include_defaults; p->fname; p++) |
| if (!strncmp (path, p->fname, strlen (p->fname)) |
| && path[strlen (p->fname)] == '/') |
| return 1; |
| return 0; |
| } |
| |
| #if 0 |
| /* Return true if the given filename designates a file that the user has |
| read access to and for which the user has write access to the containing |
| directory. */ |
| |
| static int |
| file_could_be_converted (const char *path) |
| { |
| char *const dir_name = (char *) alloca (strlen (path) + 1); |
| |
| if (my_access (path, R_OK)) |
| return 0; |
| |
| { |
| char *dir_last_slash; |
| |
| strcpy (dir_name, path); |
| dir_last_slash = rindex (dir_name, '/'); |
| if (dir_last_slash) |
| *dir_last_slash = '\0'; |
| else |
| abort (); /* Should have been an absolutized filename. */ |
| } |
| |
| if (my_access (path, W_OK)) |
| return 0; |
| |
| return 1; |
| } |
| |
| /* Return true if the given filename designates a file that we are allowed |
| to modify. Files which we should not attempt to modify are (a) "system" |
| include files, and (b) files which the user doesn't have write access to, |
| and (c) files which reside in directories which the user doesn't have |
| write access to. Unless requested to be quiet, give warnings about |
| files that we will not try to convert for one reason or another. An |
| exception is made for "system" include files, which we never try to |
| convert and for which we don't issue the usual warnings. */ |
| |
| static int |
| file_normally_convertible (const char *path) |
| { |
| char *const dir_name = alloca (strlen (path) + 1); |
| |
| if (in_system_include_dir (path)) |
| return 0; |
| |
| { |
| char *dir_last_slash; |
| |
| strcpy (dir_name, path); |
| dir_last_slash = rindex (dir_name, '/'); |
| if (dir_last_slash) |
| *dir_last_slash = '\0'; |
| else |
| abort (); /* Should have been an absolutized filename. */ |
| } |
| |
| if (my_access (path, R_OK)) |
| { |
| if (!quiet_flag) |
| fprintf (stderr, "%s: warning: no read access for file `%s'\n", |
| pname, shortpath (NULL, path)); |
| return 0; |
| } |
| |
| if (my_access (path, W_OK)) |
| { |
| if (!quiet_flag) |
| fprintf (stderr, "%s: warning: no write access for file `%s'\n", |
| pname, shortpath (NULL, path)); |
| return 0; |
| } |
| |
| if (my_access (dir_name, W_OK)) |
| { |
| if (!quiet_flag) |
| fprintf (stderr, "%s: warning: no write access for dir containing `%s'\n", |
| pname, shortpath (NULL, path)); |
| return 0; |
| } |
| |
| return 1; |
| } |
| #endif /* 0 */ |
| |
| #ifndef UNPROTOIZE |
| |
| /* Return true if the given file_info struct refers to the special SYSCALLS.c.X |
| file. Return false otherwise. */ |
| |
| static int |
| is_syscalls_file (fi_p) |
| const file_info *fi_p; |
| { |
| char const *f = fi_p->hash_entry->symbol; |
| size_t fl = strlen (f), sysl = sizeof (syscalls_filename) - 1; |
| return sysl <= fl && strcmp (f + fl - sysl, syscalls_filename) == 0; |
| } |
| |
| #endif /* !defined (UNPROTOIZE) */ |
| |
| /* Check to see if this file will need to have anything done to it on this |
| run. If there is nothing in the given file which both needs conversion |
| and for which we have the necessary stuff to do the conversion, return |
| false. Otherwise, return true. |
| |
| Note that (for protoize) it is only valid to call this function *after* |
| the connections between declarations and definitions have all been made |
| by connect_defs_and_decs. */ |
| |
| static int |
| needs_to_be_converted (file_p) |
| const file_info *file_p; |
| { |
| const def_dec_info *ddp; |
| |
| #ifndef UNPROTOIZE |
| |
| if (is_syscalls_file (file_p)) |
| return 0; |
| |
| #endif /* !defined (UNPROTOIZE) */ |
| |
| for (ddp = file_p->defs_decs; ddp; ddp = ddp->next_in_file) |
| |
| if ( |
| |
| #ifndef UNPROTOIZE |
| |
| /* ... and if we a protoizing and this function is in old style ... */ |
| !ddp->prototyped |
| /* ... and if this a definition or is a decl with an associated def ... */ |
| && (ddp->is_func_def || (!ddp->is_func_def && ddp->definition)) |
| |
| #else /* defined (UNPROTOIZE) */ |
| |
| /* ... and if we are unprotoizing and this function is in new style ... */ |
| ddp->prototyped |
| |
| #endif /* defined (UNPROTOIZE) */ |
| ) |
| /* ... then the containing file needs converting. */ |
| return -1; |
| return 0; |
| } |
| |
| /* Return 1 if the file name NAME is in a directory |
| that should be converted. */ |
| |
| static int |
| directory_specified_p (name) |
| const char *name; |
| { |
| struct string_list *p; |
| |
| for (p = directory_list; p; p = p->next) |
| if (!strncmp (name, p->name, strlen (p->name)) |
| && name[strlen (p->name)] == '/') |
| { |
| const char *q = name + strlen (p->name) + 1; |
| |
| /* If there are more slashes, it's in a subdir, so |
| this match doesn't count. */ |
| while (*q) |
| if (*q++ == '/') |
| goto lose; |
| return 1; |
| |
| lose: ; |
| } |
| |
| return 0; |
| } |
| |
| /* Return 1 if the file named NAME should be excluded from conversion. */ |
| |
| static int |
| file_excluded_p (name) |
| const char *name; |
| { |
| struct string_list *p; |
| int len = strlen (name); |
| |
| for (p = exclude_list; p; p = p->next) |
| if (!strcmp (name + len - strlen (p->name), p->name) |
| && name[len - strlen (p->name) - 1] == '/') |
| return 1; |
| |
| return 0; |
| } |
| |
| /* Construct a new element of a string_list. |
| STRING is the new element value, and REST holds the remaining elements. */ |
| |
| static struct string_list * |
| string_list_cons (string, rest) |
| char *string; |
| struct string_list *rest; |
| { |
| struct string_list *temp |
| = (struct string_list *) xmalloc (sizeof (struct string_list)); |
| |
| temp->next = rest; |
| temp->name = string; |
| return temp; |
| } |
| |
| /* ??? The GNU convention for mentioning function args in its comments |
| is to capitalize them. So change "hash_tab_p" to HASH_TAB_P below. |
| Likewise for all the other functions. */ |
| |
| /* Given a hash table, apply some function to each node in the table. The |
| table to traverse is given as the "hash_tab_p" argument, and the |
| function to be applied to each node in the table is given as "func" |
| argument. */ |
| |
| static void |
| visit_each_hash_node (hash_tab_p, func) |
| const hash_table_entry *hash_tab_p; |
| void (*func)(); |
| { |
| const hash_table_entry *primary; |
| |
| for (primary = hash_tab_p; primary < &hash_tab_p[HASH_TABLE_SIZE]; primary++) |
| if (primary->symbol) |
| { |
| hash_table_entry *second; |
| |
| (*func)(primary); |
| for (second = primary->hash_next; second; second = second->hash_next) |
| (*func) (second); |
| } |
| } |
| |
| /* Initialize all of the fields of a new hash table entry, pointed |
| to by the "p" parameter. Note that the space to hold the entry |
| is assumed to have already been allocated before this routine is |
| called. */ |
| |
| static hash_table_entry * |
| add_symbol (p, s) |
| hash_table_entry *p; |
| const char *s; |
| { |
| p->hash_next = NULL; |
| p->symbol = savestring (s, strlen (s)); |
| p->ddip = NULL; |
| p->fip = NULL; |
| return p; |
| } |
| |
| /* Look for a particular function name or filename in the particular |
| hash table indicated by "hash_tab_p". If the name is not in the |
| given hash table, add it. Either way, return a pointer to the |
| hash table entry for the given name. */ |
| |
| static hash_table_entry * |
| lookup (hash_tab_p, search_symbol) |
| hash_table_entry *hash_tab_p; |
| const char *search_symbol; |
| { |
| int hash_value = 0; |
| const char *search_symbol_char_p = search_symbol; |
| hash_table_entry *p; |
| |
| while (*search_symbol_char_p) |
| hash_value += *search_symbol_char_p++; |
| hash_value &= hash_mask; |
| p = &hash_tab_p[hash_value]; |
| if (! p->symbol) |
| return add_symbol (p, search_symbol); |
| if (!strcmp (p->symbol, search_symbol)) |
| return p; |
| while (p->hash_next) |
| { |
| p = p->hash_next; |
| if (!strcmp (p->symbol, search_symbol)) |
| return p; |
| } |
| p->hash_next = (hash_table_entry *) xmalloc (sizeof (hash_table_entry)); |
| p = p->hash_next; |
| return add_symbol (p, search_symbol); |
| } |
| |
| /* Throw a def/dec record on the junk heap. |
| |
| Also, since we are not using this record anymore, free up all of the |
| stuff it pointed to. */ |
| |
| static void |
| free_def_dec (p) |
| def_dec_info *p; |
| { |
| xfree (p->ansi_decl); |
| |
| #ifndef UNPROTOIZE |
| { |
| const f_list_chain_item * curr; |
| const f_list_chain_item * next; |
| |
| for (curr = p->f_list_chain; curr; curr = next) |
| { |
| next = curr->chain_next; |
| xfree (curr); |
| } |
| } |
| #endif /* !defined (UNPROTOIZE) */ |
| |
| xfree (p); |
| } |
| |
| /* Unexpand as many macro symbol as we can find. |
| |
| If the given line must be unexpanded, make a copy of it in the heap and |
| return a pointer to the unexpanded copy. Otherwise return NULL. */ |
| |
| static char * |
| unexpand_if_needed (aux_info_line) |
| const char *aux_info_line; |
| { |
| static char *line_buf = 0; |
| static int line_buf_size = 0; |
| const unexpansion *unexp_p; |
| int got_unexpanded = 0; |
| const char *s; |
| char *copy_p = line_buf; |
| |
| if (line_buf == 0) |
| { |
| line_buf_size = 1024; |
| line_buf = (char *) xmalloc (line_buf_size); |
| } |
| |
| copy_p = line_buf; |
| |
| /* Make a copy of the input string in line_buf, expanding as necessary. */ |
| |
| for (s = aux_info_line; *s != '\n'; ) |
| { |
| for (unexp_p = unexpansions; unexp_p->expanded; unexp_p++) |
| { |
| const char *in_p = unexp_p->expanded; |
| size_t len = strlen (in_p); |
| |
| if (*s == *in_p && !strncmp (s, in_p, len) && !is_id_char (s[len])) |
| { |
| int size = strlen (unexp_p->contracted); |
| got_unexpanded = 1; |
| if (copy_p + size - line_buf >= line_buf_size) |
| { |
| int offset = copy_p - line_buf; |
| line_buf_size *= 2; |
| line_buf_size += size; |
| line_buf = (char *) xrealloc (line_buf, line_buf_size); |
| copy_p = line_buf + offset; |
| } |
| strcpy (copy_p, unexp_p->contracted); |
| copy_p += size; |
| |
| /* Assume the there will not be another replacement required |
| within the text just replaced. */ |
| |
| s += len; |
| goto continue_outer; |
| } |
| } |
| if (copy_p - line_buf == line_buf_size) |
| { |
| int offset = copy_p - line_buf; |
| line_buf_size *= 2; |
| line_buf = (char *) xrealloc (line_buf, line_buf_size); |
| copy_p = line_buf + offset; |
| } |
| *copy_p++ = *s++; |
| continue_outer: ; |
| } |
| if (copy_p + 2 - line_buf >= line_buf_size) |
| { |
| int offset = copy_p - line_buf; |
| line_buf_size *= 2; |
| line_buf = (char *) xrealloc (line_buf, line_buf_size); |
| copy_p = line_buf + offset; |
| } |
| *copy_p++ = '\n'; |
| *copy_p = '\0'; |
| |
| return (got_unexpanded ? savestring (line_buf, copy_p - line_buf) : 0); |
| } |
| |
| /* Return the absolutized filename for the given relative |
| filename. Note that if that filename is already absolute, it may |
| still be returned in a modified form because this routine also |
| eliminates redundant slashes and single dots and eliminates double |
| dots to get a shortest possible filename from the given input |
| filename. The absolutization of relative filenames is made by |
| assuming that the given filename is to be taken as relative to |
| the first argument (cwd) or to the current directory if cwd is |
| NULL. */ |
| |
| static char * |
| abspath (cwd, rel_filename) |
| const char *cwd; |
| const char *rel_filename; |
| { |
| /* Setup the current working directory as needed. */ |
| const char *cwd2 = (cwd) ? cwd : cwd_buffer; |
| char *const abs_buffer |
| = (char *) alloca (strlen (cwd2) + strlen (rel_filename) + 2); |
| char *endp = abs_buffer; |
| char *outp, *inp; |
| |
| /* Copy the filename (possibly preceded by the current working |
| directory name) into the absolutization buffer. */ |
| |
| { |
| const char *src_p; |
| |
| if (rel_filename[0] != '/') |
| { |
| src_p = cwd2; |
| while (*endp++ = *src_p++) |
| continue; |
| *(endp-1) = '/'; /* overwrite null */ |
| } |
| src_p = rel_filename; |
| while (*endp++ = *src_p++) |
| continue; |
| } |
| |
| /* Now make a copy of abs_buffer into abs_buffer, shortening the |
| filename (by taking out slashes and dots) as we go. */ |
| |
| outp = inp = abs_buffer; |
| *outp++ = *inp++; /* copy first slash */ |
| #ifdef apollo |
| if (inp[0] == '/') |
| *outp++ = *inp++; /* copy second slash */ |
| #endif |
| for (;;) |
| { |
| if (!inp[0]) |
| break; |
| else if (inp[0] == '/' && outp[-1] == '/') |
| { |
| inp++; |
| continue; |
| } |
| else if (inp[0] == '.' && outp[-1] == '/') |
| { |
| if (!inp[1]) |
| break; |
| else if (inp[1] == '/') |
| { |
| inp += 2; |
| continue; |
| } |
| else if ((inp[1] == '.') && (inp[2] == 0 || inp[2] == '/')) |
| { |
| inp += (inp[2] == '/') ? 3 : 2; |
| outp -= 2; |
| while (outp >= abs_buffer && *outp != '/') |
| outp--; |
| if (outp < abs_buffer) |
| { |
| /* Catch cases like /.. where we try to backup to a |
| point above the absolute root of the logical file |
| system. */ |
| |
| fprintf (stderr, "%s: invalid file name: %s\n", |
| pname, rel_filename); |
| exit (FATAL_EXIT_CODE); |
| } |
| *++outp = '\0'; |
| continue; |
| } |
| } |
| *outp++ = *inp++; |
| } |
| |
| /* On exit, make sure that there is a trailing null, and make sure that |
| the last character of the returned string is *not* a slash. */ |
| |
| *outp = '\0'; |
| if (outp[-1] == '/') |
| *--outp = '\0'; |
| |
| /* Make a copy (in the heap) of the stuff left in the absolutization |
| buffer and return a pointer to the copy. */ |
| |
| return savestring (abs_buffer, outp - abs_buffer); |
| } |
| |
| /* Given a filename (and possibly a directory name from which the filename |
| is relative) return a string which is the shortest possible |
| equivalent for the corresponding full (absolutized) filename. The |
| shortest possible equivalent may be constructed by converting the |
| absolutized filename to be a relative filename (i.e. relative to |
| the actual current working directory). However if a relative filename |
| is longer, then the full absolute filename is returned. |
| |
| KNOWN BUG: |
| |
| Note that "simple-minded" conversion of any given type of filename (either |
| relative or absolute) may not result in a valid equivalent filename if any |
| subpart of the original filename is actually a symbolic link. */ |
| |
| static const char * |
| shortpath (cwd, filename) |
| const char *cwd; |
| const char *filename; |
| { |
| char *rel_buffer; |
| char *rel_buf_p; |
| char *cwd_p = cwd_buffer; |
| char *path_p; |
| int unmatched_slash_count = 0; |
| size_t filename_len = strlen (filename); |
| |
| path_p = abspath (cwd, filename); |
| rel_buf_p = rel_buffer = (char *) xmalloc (filename_len); |
| |
| while (*cwd_p && (*cwd_p == *path_p)) |
| { |
| cwd_p++; |
| path_p++; |
| } |
| if (!*cwd_p && (!*path_p || *path_p == '/')) /* whole pwd matched */ |
| { |
| if (!*path_p) /* input *is* the current path! */ |
| return "."; |
| else |
| return ++path_p; |
| } |
| else |
| { |
| if (*path_p) |
| { |
| --cwd_p; |
| --path_p; |
| while (*cwd_p != '/') /* backup to last slash */ |
| { |
| --cwd_p; |
| --path_p; |
| } |
| cwd_p++; |
| path_p++; |
| unmatched_slash_count++; |
| } |
| |
| /* Find out how many directory levels in cwd were *not* matched. */ |
| while (*cwd_p) |
| if (*cwd_p++ == '/') |
| unmatched_slash_count++; |
| |
| /* Now we know how long the "short name" will be. |
| Reject it if longer than the input. */ |
| if (unmatched_slash_count * 3 + strlen (path_p) >= filename_len) |
| return filename; |
| |
| /* For each of them, put a `../' at the beginning of the short name. */ |
| while (unmatched_slash_count--) |
| { |
| /* Give up if the result gets to be longer |
| than the absolute path name. */ |
| if (rel_buffer + filename_len <= rel_buf_p + 3) |
| return filename; |
| *rel_buf_p++ = '.'; |
| *rel_buf_p++ = '.'; |
| *rel_buf_p++ = '/'; |
| } |
| |
| /* Then tack on the unmatched part of the desired file's name. */ |
| do |
| { |
| if (rel_buffer + filename_len <= rel_buf_p) |
| return filename; |
| } |
| while (*rel_buf_p++ = *path_p++); |
| |
| --rel_buf_p; |
| if (*(rel_buf_p-1) == '/') |
| *--rel_buf_p = '\0'; |
| return rel_buffer; |
| } |
| } |
| |
| /* Lookup the given filename in the hash table for filenames. If it is a |
| new one, then the hash table info pointer will be null. In this case, |
| we create a new file_info record to go with the filename, and we initialize |
| that record with some reasonable values. */ |
| |
| /* FILENAME was const, but that causes a warning on AIX when calling stat. |
| That is probably a bug in AIX, but might as well avoid the warning. */ |
| |
| static file_info * |
| find_file (filename, do_not_stat) |
| char *filename; |
| int do_not_stat; |
| { |
| hash_table_entry *hash_entry_p; |
| |
| hash_entry_p = lookup (filename_primary, filename); |
| if (hash_entry_p->fip) |
| return hash_entry_p->fip; |
| else |
| { |
| struct stat stat_buf; |
| file_info *file_p = (file_info *) xmalloc (sizeof (file_info)); |
| |
| /* If we cannot get status on any given source file, give a warning |
| and then just set its time of last modification to infinity. */ |
| |
| if (do_not_stat) |
| stat_buf.st_mtime = (time_t) 0; |
| else |
| { |
| if (my_stat (filename, &stat_buf) == -1) |
| { |
| fprintf (stderr, "%s: %s: can't get status: %s\n", |
| pname, shortpath (NULL, filename), my_strerror(errno)); |
| stat_buf.st_mtime = (time_t) -1; |
| } |
| } |
| |
| hash_entry_p->fip = file_p; |
| file_p->hash_entry = hash_entry_p; |
| file_p->defs_decs = NULL; |
| file_p->mtime = stat_buf.st_mtime; |
| return file_p; |
| } |
| } |
| |
| /* Generate a fatal error because some part of the aux_info file is |
| messed up. */ |
| |
| static void |
| aux_info_corrupted () |
| { |
| fprintf (stderr, "\n%s: fatal error: aux info file corrupted at line %d\n", |
| pname, current_aux_info_lineno); |
| exit (FATAL_EXIT_CODE); |
| } |
| |
| /* ??? This comment is vague. Say what the condition is for. */ |
| /* Check to see that a condition is true. This is kind of like an assert. */ |
| |
| static void |
| check_aux_info (cond) |
| int cond; |
| { |
| if (! cond) |
| aux_info_corrupted (); |
| } |
| |
| /* Given a pointer to the closing right parenthesis for a particular formals |
| list (in an aux_info file) find the corresponding left parenthesis and |
| return a pointer to it. */ |
| |
| static const char * |
| find_corresponding_lparen (p) |
| const char *p; |
| { |
| const char *q; |
| int paren_depth; |
| |
| for (paren_depth = 1, q = p-1; paren_depth; q--) |
| { |
| switch (*q) |
| { |
| case ')': |
| paren_depth++; |
| break; |
| case '(': |
| paren_depth--; |
| break; |
| } |
| } |
| return ++q; |
| } |
| |
| /* Given a line from an aux info file, and a time at which the aux info |
| file it came from was created, check to see if the item described in |
| the line comes from a file which has been modified since the aux info |
| file was created. If so, return non-zero, else return zero. */ |
| |
| static int |
| referenced_file_is_newer (l, aux_info_mtime) |
| const char *l; |
| time_t aux_info_mtime; |
| { |
| const char *p; |
| file_info *fi_p; |
| char *filename; |
| |
| check_aux_info (l[0] == '/'); |
| check_aux_info (l[1] == '*'); |
| check_aux_info (l[2] == ' '); |
| |
| { |
| const char *filename_start = p = l + 3; |
| |
| while (*p != ':') |
| p++; |
| filename = (char *) alloca ((size_t) (p - filename_start) + 1); |
| strncpy (filename, filename_start, (size_t) (p - filename_start)); |
| filename[p-filename_start] = '\0'; |
| } |
| |
| /* Call find_file to find the file_info record associated with the file |
| which contained this particular def or dec item. Note that this call |
| may cause a new file_info record to be created if this is the first time |
| that we have ever known about this particular file. */ |
| |
| fi_p = find_file (abspath (invocation_filename, filename), 0); |
| |
| return (fi_p->mtime > aux_info_mtime); |
| } |
| |
| /* Given a line of info from the aux_info file, create a new |
| def_dec_info record to remember all of the important information about |
| a function definition or declaration. |
| |
| Link this record onto the list of such records for the particular file in |
| which it occurred in proper (descending) line number order (for now). |
| |
| If there is an identical record already on the list for the file, throw |
| this one away. Doing so takes care of the (useless and troublesome) |
| duplicates which are bound to crop up due to multiple inclusions of any |
| given individual header file. |
| |
| Finally, link the new def_dec record onto the list of such records |
| pertaining to this particular function name. */ |
| |
| static void |
| save_def_or_dec (l, is_syscalls) |
| const char *l; |
| int is_syscalls; |
| { |
| const char *p; |
| const char *semicolon_p; |
| def_dec_info *def_dec_p = (def_dec_info *) xmalloc (sizeof (def_dec_info)); |
| |
| #ifndef UNPROTOIZE |
| def_dec_p->written = 0; |
| #endif /* !defined (UNPROTOIZE) */ |
| |
| /* Start processing the line by picking off 5 pieces of information from |
| the left hand end of the line. These are filename, line number, |
| new/old/implicit flag (new = ANSI prototype format), definition or |
| declaration flag, and extern/static flag). */ |
| |
| check_aux_info (l[0] == '/'); |
| check_aux_info (l[1] == '*'); |
| check_aux_info (l[2] == ' '); |
| |
| { |
| const char *filename_start = p = l + 3; |
| char *filename; |
| |
| while (*p != ':') |
| p++; |
| filename = (char *) alloca ((size_t) (p - filename_start) + 1); |
| strncpy (filename, filename_start, (size_t) (p - filename_start)); |
| filename[p-filename_start] = '\0'; |
| |
| /* Call find_file to find the file_info record associated with the file |
| which contained this particular def or dec item. Note that this call |
| may cause a new file_info record to be created if this is the first time |
| that we have ever known about this particular file. |
| |
| Note that we started out by forcing all of the base source file names |
| (i.e. the names of the aux_info files with the .X stripped off) into the |
| filenames hash table, and we simultaneously setup file_info records for |
| all of these base file names (even if they may be useless later). |
| The file_info records for all of these "base" file names (properly) |
| act as file_info records for the "original" (i.e. un-included) files |
| which were submitted to gcc for compilation (when the -aux-info |
| option was used). */ |
| |
| def_dec_p->file = find_file (abspath (invocation_filename, filename), is_syscalls); |
| } |
| |
| { |
| const char *line_number_start = ++p; |
| char line_number[10]; |
| |
| while (*p != ':') |
| p++; |
| strncpy (line_number, line_number_start, (size_t) (p - line_number_start)); |
| line_number[p-line_number_start] = '\0'; |
| def_dec_p->line = atoi (line_number); |
| } |
| |
| /* Check that this record describes a new-style, old-style, or implicit |
| definition or declaration. */ |
| |
| p++; /* Skip over the `:'. */ |
| check_aux_info ((*p == 'N') || (*p == 'O') || (*p == 'I')); |
| |
| /* Is this a new style (ANSI prototyped) definition or declaration? */ |
| |
| def_dec_p->prototyped = (*p == 'N'); |
| |
| #ifndef UNPROTOIZE |
| |
| /* Is this an implicit declaration? */ |
| |
| def_dec_p->is_implicit = (*p == 'I'); |
| |
| #endif /* !defined (UNPROTOIZE) */ |
| |
| p++; |
| |
| check_aux_info ((*p == 'C') || (*p == 'F')); |
| |
| /* Is this item a function definition (F) or a declaration (C). Note that |
| we treat item taken from the syscalls file as though they were function |
| definitions regardless of what the stuff in the file says. */ |
| |
| def_dec_p->is_func_def = ((*p++ == 'F') || is_syscalls); |
| |
| #ifndef UNPROTOIZE |
| def_dec_p->definition = 0; /* Fill this in later if protoizing. */ |
| #endif /* !defined (UNPROTOIZE) */ |
| |
| check_aux_info (*p++ == ' '); |
| check_aux_info (*p++ == '*'); |
| check_aux_info (*p++ == '/'); |
| check_aux_info (*p++ == ' '); |
| |
| #ifdef UNPROTOIZE |
| check_aux_info ((!strncmp (p, "static", 6)) || (!strncmp (p, "extern", 6))); |
| #else /* !defined (UNPROTOIZE) */ |
| if (!strncmp (p, "static", 6)) |
| def_dec_p->is_static = -1; |
| else if (!strncmp (p, "extern", 6)) |
| def_dec_p->is_static = 0; |
| else |
| check_aux_info (0); /* Didn't find either `extern' or `static'. */ |
| #endif /* !defined (UNPROTOIZE) */ |
| |
| { |
| const char *ansi_start = p; |
| |
| p += 6; /* Pass over the "static" or "extern". */ |
| |
| /* We are now past the initial stuff. Search forward from here to find |
| the terminating semicolon that should immediately follow the entire |
| ANSI format function declaration. */ |
| |
| while (*++p != ';') |
| continue; |
| |
| semicolon_p = p; |
| |
| /* Make a copy of the ansi declaration part of the line from the aux_info |
| file. */ |
| |
| def_dec_p->ansi_decl |
| = dupnstr (ansi_start, (size_t) ((semicolon_p+1) - ansi_start)); |
| |
| /* Backup and point at the final right paren of the final argument list. */ |
| |
| p--; |
| |
| #ifndef UNPROTOIZE |
| def_dec_p->f_list_chain = NULL; |
| #endif /* !defined (UNPROTOIZE) */ |
| |
| while (p != ansi_start && (p[-1] == ' ' || p[-1] == '\t')) p--; |
| if (*p != ')') |
| { |
| free_def_dec (def_dec_p); |
| return; |
| } |
| } |
| |
| /* Now isolate a whole set of formal argument lists, one-by-one. Normally, |
| there will only be one list to isolate, but there could be more. */ |
| |
| def_dec_p->f_list_count = 0; |
| |
| for (;;) |
| { |
| const char *left_paren_p = find_corresponding_lparen (p); |
| #ifndef UNPROTOIZE |
| { |
| f_list_chain_item *cip |
| = (f_list_chain_item *) xmalloc (sizeof (f_list_chain_item)); |
| |
| cip->formals_list |
| = dupnstr (left_paren_p + 1, (size_t) (p - (left_paren_p+1))); |
| |
| /* Add the new chain item at the head of the current list. */ |
| |
| cip->chain_next = def_dec_p->f_list_chain; |
| def_dec_p->f_list_chain = cip; |
| } |
| #endif /* !defined (UNPROTOIZE) */ |
| def_dec_p->f_list_count++; |
| |
| p = left_paren_p - 2; |
| |
| /* p must now point either to another right paren, or to the last |
| character of the name of the function that was declared/defined. |
| If p points to another right paren, then this indicates that we |
| are dealing with multiple formals lists. In that case, there |
| really should be another right paren preceding this right paren. */ |
| |
| if (*p != ')') |
| break; |
| else |
| check_aux_info (*--p == ')'); |
| } |
| |
| |
| { |
| const char *past_fn = p + 1; |
| |
| check_aux_info (*past_fn == ' '); |
| |
| /* Scan leftwards over the identifier that names the function. */ |
| |
| while (is_id_char (*p)) |
| p--; |
| p++; |
| |
| /* p now points to the leftmost character of the function name. */ |
| |
| { |
| char *fn_string = (char *) alloca (past_fn - p + 1); |
| |
| strncpy (fn_string, p, (size_t) (past_fn - p)); |
| fn_string[past_fn-p] = '\0'; |
| def_dec_p->hash_entry = lookup (function_name_primary, fn_string); |
| } |
| } |
| |
| /* Look at all of the defs and decs for this function name that we have |
| collected so far. If there is already one which is at the same |
| line number in the same file, then we can discard this new def_dec_info |
| record. |
| |
| As an extra assurance that any such pair of (nominally) identical |
| function declarations are in fact identical, we also compare the |
| ansi_decl parts of the lines from the aux_info files just to be on |
| the safe side. |
| |
| This comparison will fail if (for instance) the user was playing |
| messy games with the preprocessor which ultimately causes one |
| function declaration in one header file to look differently when |
| that file is included by two (or more) other files. */ |
| |
| { |
| const def_dec_info *other; |
| |
| for (other = def_dec_p->hash_entry->ddip; other; other = other->next_for_func) |
| { |
| if (def_dec_p->line == other->line && def_dec_p->file == other->file) |
| { |
| if (strcmp (def_dec_p->ansi_decl, other->ansi_decl)) |
| { |
| fprintf (stderr, "%s:%d: declaration of function `%s' takes different forms\n", |
| def_dec_p->file->hash_entry->symbol, |
| def_dec_p->line, |
| def_dec_p->hash_entry->symbol); |
| exit (FATAL_EXIT_CODE); |
| } |
| free_def_dec (def_dec_p); |
| return; |
| } |
| } |
| } |
| |
| #ifdef UNPROTOIZE |
| |
| /* If we are doing unprotoizing, we must now setup the pointers that will |
| point to the K&R name list and to the K&R argument declarations list. |
| |
| Note that if this is only a function declaration, then we should not |
| expect to find any K&R style formals list following the ANSI-style |
| formals list. This is because GCC knows that such information is |
| useless in the case of function declarations (function definitions |
| are a different story however). |
| |
| Since we are unprotoizing, we don't need any such lists anyway. |
| All we plan to do is to delete all characters between ()'s in any |
| case. */ |
| |
| def_dec_p->formal_names = NULL; |
| def_dec_p->formal_decls = NULL; |
| |
| if (def_dec_p->is_func_def) |
| { |
| p = semicolon_p; |
| check_aux_info (*++p == ' '); |
| check_aux_info (*++p == '/'); |
| check_aux_info (*++p == '*'); |
| check_aux_info (*++p == ' '); |
| check_aux_info (*++p == '('); |
| |
| { |
| const char *kr_names_start = ++p; /* Point just inside '('. */ |
| |
| while (*p++ != ')') |
| continue; |
| p--; /* point to closing right paren */ |
| |
| /* Make a copy of the K&R parameter names list. */ |
| |
| def_dec_p->formal_names |
| = dupnstr (kr_names_start, (size_t) (p - kr_names_start)); |
| } |
| |
| check_aux_info (*++p == ' '); |
| p++; |
| |
| /* p now points to the first character of the K&R style declarations |
| list (if there is one) or to the star-slash combination that ends |
| the comment in which such lists get embedded. */ |
| |
| /* Make a copy of the K&R formal decls list and set the def_dec record |
| to point to it. */ |
| |
| if (*p == '*') /* Are there no K&R declarations? */ |
| { |
| check_aux_info (*++p == '/'); |
| def_dec_p->formal_decls = ""; |
| } |
| else |
| { |
| const char *kr_decls_start = p; |
| |
| while (p[0] != '*' || p[1] != '/') |
| p++; |
| p--; |
| |
| check_aux_info (*p == ' '); |
| |
| def_dec_p->formal_decls |
| = dupnstr (kr_decls_start, (size_t) (p - kr_decls_start)); |
| } |
| |
| /* Handle a special case. If we have a function definition marked as |
| being in "old" style, and if it's formal names list is empty, then |
| it may actually have the string "void" in its real formals list |
| in the original source code. Just to make sure, we will get setup |
| to convert such things anyway. |
| |
| This kludge only needs to be here because of an insurmountable |
| problem with generating .X files. */ |
| |
| if (!def_dec_p->prototyped && !*def_dec_p->formal_names) |
| def_dec_p->prototyped = 1; |
| } |
| |
| /* Since we are unprotoizing, if this item is already in old (K&R) style, |
| we can just ignore it. If that is true, throw away the itme now. */ |
| |
| if (!def_dec_p->prototyped) |
| { |
| free_def_dec (def_dec_p); |
| return; |
| } |
| |
| #endif /* defined (UNPROTOIZE) */ |
| |
| /* Add this record to the head of the list of records pertaining to this |
| particular function name. */ |
| |
| def_dec_p->next_for_func = def_dec_p->hash_entry->ddip; |
| def_dec_p->hash_entry->ddip = def_dec_p; |
| |
| /* Add this new def_dec_info record to the sorted list of def_dec_info |
| records for this file. Note that we don't have to worry about duplicates |
| (caused by multiple inclusions of header files) here because we have |
| already eliminated duplicates above. */ |
| |
| if (!def_dec_p->file->defs_decs) |
| { |
| def_dec_p->file->defs_decs = def_dec_p; |
| def_dec_p->next_in_file = NULL; |
| } |
| else |
| { |
| int line = def_dec_p->line; |
| const def_dec_info *prev = NULL; |
| const def_dec_info *curr = def_dec_p->file->defs_decs; |
| const def_dec_info *next = curr->next_in_file; |
| |
| while (next && (line < curr->line)) |
| { |
| prev = curr; |
| curr = next; |
| next = next->next_in_file; |
| } |
| if (line >= curr->line) |
| { |
| def_dec_p->next_in_file = curr; |
| if (prev) |
| ((NONCONST def_dec_info *) prev)->next_in_file = def_dec_p; |
| else |
| def_dec_p->file->defs_decs = def_dec_p; |
| } |
| else /* assert (next == NULL); */ |
| { |
| ((NONCONST def_dec_info *) curr)->next_in_file = def_dec_p; |
| /* assert (next == NULL); */ |
| def_dec_p->next_in_file = next; |
| } |
| } |
| } |
| |
| /* Set up the vector COMPILE_PARAMS which is the argument list for running GCC. |
| Also set input_file_name_index and aux_info_file_name_index |
| to the indices of the slots where the file names should go. */ |
| |
| /* We initialize the vector by removing -g, -O, -S, -c, and -o options, |
| and adding '-aux-info AUXFILE -S -o /dev/null INFILE' at the end. */ |
| |
| static void |
| munge_compile_params (params_list) |
| const char *params_list; |
| { |
| /* Build up the contents in a temporary vector |
| that is so big that to has to be big enough. */ |
| const char **temp_params |
| = (const char **) alloca ((strlen (params_list) + 8) * sizeof (char *)); |
| int param_count = 0; |
| const char *param; |
| |
| temp_params[param_count++] = compiler_file_name; |
| for (;;) |
| { |
| while (isspace (*params_list)) |
| params_list++; |
| if (!*params_list) |
| break; |
| param = params_list; |
| while (*params_list && !isspace (*params_list)) |
| params_list++; |
| if (param[0] != '-') |
| temp_params[param_count++] |
| = dupnstr (param, (size_t) (params_list - param)); |
| else |
| { |
| switch (param[1]) |
| { |
| case 'g': |
| case 'O': |
| case 'S': |
| case 'c': |
| break; /* Don't copy these. */ |
| case 'o': |
| while (isspace (*params_list)) |
| params_list++; |
| while (*params_list && !isspace (*params_list)) |
| params_list++; |
| break; |
| default: |
| temp_params[param_count++] |
| = dupnstr (param, (size_t) (params_list - param)); |
| } |
| } |
| if (!*params_list) |
| break; |
| } |
| temp_params[param_count++] = "-aux-info"; |
| |
| /* Leave room for the aux-info file name argument. */ |
| aux_info_file_name_index = param_count; |
| temp_params[param_count++] = NULL; |
| |
| temp_params[param_count++] = "-S"; |
| temp_params[param_count++] = "-o"; |
| temp_params[param_count++] = "/dev/null"; |
| |
| /* Leave room for the input file name argument. */ |
| input_file_name_index = param_count; |
| temp_params[param_count++] = NULL; |
| /* Terminate the list. */ |
| temp_params[param_count++] = NULL; |
| |
| /* Make a copy of the compile_params in heap space. */ |
| |
| compile_params |
| = (const char **) xmalloc (sizeof (char *) * (param_count+1)); |
| memcpy (compile_params, temp_params, sizeof (char *) * param_count); |
| } |
| |
| /* Do a recompilation for the express purpose of generating a new aux_info |
| file to go with a specific base source file. |
| |
| The result is a boolean indicating success. */ |
| |
| static int |
| gen_aux_info_file (base_filename) |
| const char *base_filename; |
| { |
| if (!input_file_name_index) |
| munge_compile_params (""); |
| |
| /* Store the full source file name in the argument vector. */ |
| compile_params[input_file_name_index] = shortpath (NULL, base_filename); |
| /* Add .X to source file name to get aux-info file name. */ |
| compile_params[aux_info_file_name_index] |
| = savestring2 (compile_params[input_file_name_index], |
| strlen (compile_params[input_file_name_index]), |
| ".X", |
| 2); |
| |
| if (!quiet_flag) |
| fprintf (stderr, "%s: compiling `%s'\n", |
| pname, compile_params[input_file_name_index]); |
| |
| { |
| char *errmsg_fmt, *errmsg_arg; |
| int wait_status, pid; |
| char *temp_base = choose_temp_base (); |
| |
| pid = pexecute (compile_params[0], (char * const *) compile_params, |
| pname, temp_base, &errmsg_fmt, &errmsg_arg, |
| PEXECUTE_FIRST | PEXECUTE_LAST | PEXECUTE_SEARCH); |
| |
| if (pid == -1) |
| { |
| int errno_val = errno; |
| fprintf (stderr, "%s: ", pname); |
| fprintf (stderr, errmsg_fmt, errmsg_arg); |
| fprintf (stderr, ": %s\n", my_strerror (errno_val)); |
| return 0; |
| } |
| |
| pid = pwait (pid, &wait_status, 0); |
| if (pid == -1) |
| { |
| fprintf (stderr, "%s: wait: %s\n", pname, my_strerror (errno)); |
| return 0; |
| } |
| if (WIFSIGNALED (wait_status)) |
| { |
| fprintf (stderr, "%s: subprocess got fatal signal %d\n", |
| pname, WTERMSIG (wait_status)); |
| return 0; |
| } |
| if (WIFEXITED (wait_status)) |
| { |
| if (WEXITSTATUS (wait_status) != 0) |
| { |
| fprintf (stderr, "%s: %s exited with status %d\n", |
| pname, compile_params[0], WEXITSTATUS (wait_status)); |
| return 0; |
| } |
| return 1; |
| } |
| abort (); |
| } |
| } |
| |
| /* Read in all of the information contained in a single aux_info file. |
| Save all of the important stuff for later. */ |
| |
| static void |
| process_aux_info_file (base_source_filename, keep_it, is_syscalls) |
| const char *base_source_filename; |
| int keep_it; |
| int is_syscalls; |
| { |
| size_t base_len = strlen (base_source_filename); |
| char * aux_info_filename |
| = (char *) alloca (base_len + strlen (aux_info_suffix) + 1); |
| char *aux_info_base; |
| char *aux_info_limit; |
| char *aux_info_relocated_name; |
| const char *aux_info_second_line; |
| time_t aux_info_mtime; |
| size_t aux_info_size; |
| int must_create; |
| |
| /* Construct the aux_info filename from the base source filename. */ |
| |
| strcpy (aux_info_filename, base_source_filename); |
| strcat (aux_info_filename, aux_info_suffix); |
| |
| /* Check that the aux_info file exists and is readable. If it does not |
| exist, try to create it (once only). */ |
| |
| /* If file doesn't exist, set must_create. |
| Likewise if it exists and we can read it but it is obsolete. |
| Otherwise, report an error. */ |
| must_create = 0; |
| |
| /* Come here with must_create set to 1 if file is out of date. */ |
| start_over: ; |
| |
| if (my_access (aux_info_filename, R_OK) == -1) |
| { |
| if (errno == ENOENT) |
| { |
| if (is_syscalls) |
| { |
| fprintf (stderr, "%s: warning: missing SYSCALLS file `%s'\n", |
| pname, aux_info_filename); |
| return; |
| } |
| must_create = 1; |
| } |
| else |
| { |
| fprintf (stderr, "%s: can't read aux info file `%s': %s\n", |
| pname, shortpath (NULL, aux_info_filename), |
| my_strerror(errno)); |
| errors++; |
| return; |
| } |
| } |
| #if 0 /* There is code farther down to take care of this. */ |
| else |
| { |
| struct stat s1, s2; |
| stat (aux_info_file_name, &s1); |
| stat (base_source_file_name, &s2); |
| if (s2.st_mtime > s1.st_mtime) |
| must_create = 1; |
| } |
| #endif /* 0 */ |
| |
| /* If we need a .X file, create it, and verify we can read it. */ |
| if (must_create) |
| { |
| if (!gen_aux_info_file (base_source_filename)) |
| { |
| errors++; |
| return; |
| } |
| if (my_access (aux_info_filename, R_OK) == -1) |
| { |
| fprintf (stderr, "%s: can't read aux info file `%s': %s\n", |
| pname, shortpath (NULL, aux_info_filename), |
| my_strerror(errno)); |
| errors++; |
| return; |
| } |
| } |
| |
| { |
| struct stat stat_buf; |
| |
| /* Get some status information about this aux_info file. */ |
| |
| if (my_stat (aux_info_filename, &stat_buf) == -1) |
| { |
| fprintf (stderr, "%s: can't get status of aux info file `%s': %s\n", |
| pname, shortpath (NULL, aux_info_filename), |
| my_strerror(errno)); |
| errors++; |
| return; |
| } |
| |
| /* Check on whether or not this aux_info file is zero length. If it is, |
| then just ignore it and return. */ |
| |
| if ((aux_info_size = stat_buf.st_size) == 0) |
| return; |
| |
| /* Get the date/time of last modification for this aux_info file and |
| remember it. We will have to check that any source files that it |
| contains information about are at least this old or older. */ |
| |
| aux_info_mtime = stat_buf.st_mtime; |
| |
| if (!is_syscalls) |
| { |
| /* Compare mod time with the .c file; update .X file if obsolete. |
| The code later on can fail to check the .c file |
| if it did not directly define any functions. */ |
| |
| if (my_stat (base_source_filename, &stat_buf) == -1) |
| { |
| fprintf (stderr, "%s: can't get status of aux info file `%s': %s\n", |
| pname, shortpath (NULL, base_source_filename), |
| my_strerror(errno)); |
| errors++; |
| return; |
| } |
| if (stat_buf.st_mtime > aux_info_mtime) |
| { |
| must_create = 1; |
| goto start_over; |
| } |
| } |
| } |
| |
| { |
| int aux_info_file; |
| |
| /* Open the aux_info file. */ |
| |
| if ((aux_info_file = my_open (aux_info_filename, O_RDONLY, 0444 )) == -1) |
| { |
| fprintf (stderr, "%s: can't open aux info file `%s' for reading: %s\n", |
| pname, shortpath (NULL, aux_info_filename), |
| my_strerror(errno)); |
| return; |
| } |
| |
| /* Allocate space to hold the aux_info file in memory. */ |
| |
| aux_info_base = xmalloc (aux_info_size + 1); |
| aux_info_limit = aux_info_base + aux_info_size; |
| *aux_info_limit = '\0'; |
| |
| /* Read the aux_info file into memory. */ |
| |
| if (safe_read (aux_info_file, aux_info_base, aux_info_size) != aux_info_size) |
| { |
| fprintf (stderr, "%s: error reading aux info file `%s': %s\n", |
| pname, shortpath (NULL, aux_info_filename), |
| my_strerror(errno)); |
| free (aux_info_base); |
| close (aux_info_file); |
| return; |
| } |
| |
| /* Close the aux info file. */ |
| |
| if (close (aux_info_file)) |
| { |
| fprintf (stderr, "%s: error closing aux info file `%s': %s\n", |
| pname, shortpath (NULL, aux_info_filename), |
| my_strerror(errno)); |
| free (aux_info_base); |
| close (aux_info_file); |
| return; |
| } |
| } |
| |
| /* Delete the aux_info file (unless requested not to). If the deletion |
| fails for some reason, don't even worry about it. */ |
| |
| if (must_create && !keep_it) |
| if (my_unlink (aux_info_filename) == -1) |
| fprintf (stderr, "%s: can't delete aux info file `%s': %s\n", |
| pname, shortpath (NULL, aux_info_filename), |
| my_strerror(errno)); |
| |
| /* Save a pointer into the first line of the aux_info file which |
| contains the filename of the directory from which the compiler |
| was invoked when the associated source file was compiled. |
| This information is used later to help create complete |
| filenames out of the (potentially) relative filenames in |
| the aux_info file. */ |
| |
| { |
| char *p = aux_info_base; |
| |
| while (*p != ':') |
| p++; |
| p++; |
| while (*p == ' ') |
| p++; |
| invocation_filename = p; /* Save a pointer to first byte of path. */ |
| while (*p != ' ') |
| p++; |
| *p++ = '/'; |
| *p++ = '\0'; |
| while (*p++ != '\n') |
| continue; |
| aux_info_second_line = p; |
| aux_info_relocated_name = 0; |
| if (invocation_filename[0] != '/') |
| { |
| /* INVOCATION_FILENAME is relative; |
| append it to BASE_SOURCE_FILENAME's dir. */ |
| char *dir_end; |
| aux_info_relocated_name = xmalloc (base_len + (p-invocation_filename)); |
| strcpy (aux_info_relocated_name, base_source_filename); |
| dir_end = rindex (aux_info_relocated_name, '/'); |
| if (dir_end) |
| dir_end++; |
| else |
| dir_end = aux_info_relocated_name; |
| strcpy (dir_end, invocation_filename); |
| invocation_filename = aux_info_relocated_name; |
| } |
| } |
| |
| |
| { |
| const char *aux_info_p; |
| |
| /* Do a pre-pass on the lines in the aux_info file, making sure that all |
| of the source files referenced in there are at least as old as this |
| aux_info file itself. If not, go back and regenerate the aux_info |
| file anew. Don't do any of this for the syscalls file. */ |
| |
| if (!is_syscalls) |
| { |
| current_aux_info_lineno = 2; |
| |
| for (aux_info_p = aux_info_second_line; *aux_info_p; ) |
| { |
| if (referenced_file_is_newer (aux_info_p, aux_info_mtime)) |
| { |
| free (aux_info_base); |
| xfree (aux_info_relocated_name); |
| if (keep_it && my_unlink (aux_info_filename) == -1) |
| { |
| fprintf (stderr, "%s: can't delete file `%s': %s\n", |
| pname, shortpath (NULL, aux_info_filename), |
| my_strerror(errno)); |
| return; |
| } |
| must_create = 1; |
| goto start_over; |
| } |
| |
| /* Skip over the rest of this line to start of next line. */ |
| |
| while (*aux_info_p != '\n') |
| aux_info_p++; |
| aux_info_p++; |
| current_aux_info_lineno++; |
| } |
| } |
| |
| /* Now do the real pass on the aux_info lines. Save their information in |
| the in-core data base. */ |
| |
| current_aux_info_lineno = 2; |
| |
| for (aux_info_p = aux_info_second_line; *aux_info_p;) |
| { |
| char *unexpanded_line = unexpand_if_needed (aux_info_p); |
| |
| if (unexpanded_line) |
| { |
| save_def_or_dec (unexpanded_line, is_syscalls); |
| free (unexpanded_line); |
| } |
| else |
| save_def_or_dec (aux_info_p, is_syscalls); |
| |
| /* Skip over the rest of this line and get to start of next line. */ |
| |
| while (*aux_info_p != '\n') |
| aux_info_p++; |
| aux_info_p++; |
| current_aux_info_lineno++; |
| } |
| } |
| |
| free (aux_info_base); |
| xfree (aux_info_relocated_name); |
| } |
| |
| #ifndef UNPROTOIZE |
| |
| /* Check an individual filename for a .c suffix. If the filename has this |
| suffix, rename the file such that its suffix is changed to .C. This |
| function implements the -C option. */ |
| |
| static void |
| rename_c_file (hp) |
| const hash_table_entry *hp; |
| { |
| const char *filename = hp->symbol; |
| int last_char_index = strlen (filename) - 1; |
| char *const new_filename = (char *) alloca (strlen (filename) + 1); |
| |
| /* Note that we don't care here if the given file was converted or not. It |
| is possible that the given file was *not* converted, simply because there |
| was nothing in it which actually required conversion. Even in this case, |
| we want to do the renaming. Note that we only rename files with the .c |
| suffix. */ |
| |
| if (filename[last_char_index] != 'c' || filename[last_char_index-1] != '.') |
| return; |
| |
| strcpy (new_filename, filename); |
| new_filename[last_char_index] = 'C'; |
| |
| if (my_link (filename, new_filename) == -1) |
| { |
| fprintf (stderr, "%s: warning: can't link file `%s' to `%s': %s\n", |
| pname, shortpath (NULL, filename), |
| shortpath (NULL, new_filename), my_strerror(errno)); |
| errors++; |
| return; |
| } |
| |
| if (my_unlink (filename) == -1) |
| { |
| fprintf (stderr, "%s: warning: can't delete file `%s': %s\n", |
| pname, shortpath (NULL, filename), my_strerror(errno)); |
| errors++; |
| return; |
| } |
| } |
| |
| #endif /* !defined (UNPROTOIZE) */ |
| |
| /* Take the list of definitions and declarations attached to a particular |
| file_info node and reverse the order of the list. This should get the |
| list into an order such that the item with the lowest associated line |
| number is nearest the head of the list. When these lists are originally |
| built, they are in the opposite order. We want to traverse them in |
| normal line number order later (i.e. lowest to highest) so reverse the |
| order here. */ |
| |
| static void |
| reverse_def_dec_list (hp) |
| const hash_table_entry *hp; |
| { |
| file_info *file_p = hp->fip; |
| def_dec_info *prev = NULL; |
| def_dec_info *current = (def_dec_info *)file_p->defs_decs; |
| |
| if (!current) |
| return; /* no list to reverse */ |
| |
| prev = current; |
| if (! (current = (def_dec_info *)current->next_in_file)) |
| return; /* can't reverse a single list element */ |
| |
| prev->next_in_file = NULL; |
| |
| while (current) |
| { |
| def_dec_info *next = (def_dec_info *)current->next_in_file; |
| |
| current->next_in_file = prev; |
| prev = current; |
| current = next; |
| } |
| |
| file_p->defs_decs = prev; |
| } |
| |
| #ifndef UNPROTOIZE |
| |
| /* Find the (only?) extern definition for a particular function name, starting |
| from the head of the linked list of entries for the given name. If we |
| cannot find an extern definition for the given function name, issue a |
| warning and scrounge around for the next best thing, i.e. an extern |
| function declaration with a prototype attached to it. Note that we only |
| allow such substitutions for extern declarations and never for static |
| declarations. That's because the only reason we allow them at all is |
| to let un-prototyped function declarations for system-supplied library |
| functions get their prototypes from our own extra SYSCALLS.c.X file which |
| contains all of the correct prototypes for system functions. */ |
| |
| static const def_dec_info * |
| find_extern_def (head, user) |
| const def_dec_info *head; |
| const def_dec_info *user; |
| { |
| const def_dec_info *dd_p; |
| const def_dec_info *extern_def_p = NULL; |
| int conflict_noted = 0; |
| |
| /* Don't act too stupid here. Somebody may try to convert an entire system |
| in one swell fwoop (rather than one program at a time, as should be done) |
| and in that case, we may find that there are multiple extern definitions |
| of a given function name in the entire set of source files that we are |
| converting. If however one of these definitions resides in exactly the |
| same source file as the reference we are trying to satisfy then in that |
| case it would be stupid for us to fail to realize that this one definition |
| *must* be the precise one we are looking for. |
| |
| To make sure that we don't miss an opportunity to make this "same file" |
| leap of faith, we do a prescan of the list of records relating to the |
| given function name, and we look (on this first scan) *only* for a |
| definition of the function which is in the same file as the reference |
| we are currently trying to satisfy. */ |
| |
| for (dd_p = head; dd_p; dd_p = dd_p->next_for_func) |
| if (dd_p->is_func_def && !dd_p->is_static && dd_p->file == user->file) |
| return dd_p; |
| |
| /* Now, since we have not found a definition in the same file as the |
| reference, we scan the list again and consider all possibilities from |
| all files. Here we may get conflicts with the things listed in the |
| SYSCALLS.c.X file, but if that happens it only means that the source |
| code being converted contains its own definition of a function which |
| could have been supplied by libc.a. In such cases, we should avoid |
| issuing the normal warning, and defer to the definition given in the |
| user's own code. */ |
| |
| for (dd_p = head; dd_p; dd_p = dd_p->next_for_func) |
| if (dd_p->is_func_def && !dd_p->is_static) |
| { |
| if (!extern_def_p) /* Previous definition? */ |
| extern_def_p = dd_p; /* Remember the first definition found. */ |
| else |
| { |
| /* Ignore definition just found if it came from SYSCALLS.c.X. */ |
| |
| if (is_syscalls_file (dd_p->file)) |
| continue; |
| |
| /* Quietly replace the definition previously found with the one |
| just found if the previous one was from SYSCALLS.c.X. */ |
| |
| if (is_syscalls_file (extern_def_p->file)) |
| { |
| extern_def_p = dd_p; |
| continue; |
| } |
| |
| /* If we get here, then there is a conflict between two function |
| declarations for the same function, both of which came from the |
| user's own code. */ |
| |
| if (!conflict_noted) /* first time we noticed? */ |
| { |
| conflict_noted = 1; |
| fprintf (stderr, "%s: conflicting extern definitions of '%s'\n", |
| pname, head->hash_entry->symbol); |
| if (!quiet_flag) |
| { |
| fprintf (stderr, "%s: declarations of '%s' will not be converted\n", |
| pname, head->hash_entry->symbol); |
| fprintf (stderr, "%s: conflict list for '%s' follows:\n", |
| pname, head->hash_entry->symbol); |
| fprintf (stderr, "%s: %s(%d): %s\n", |
| pname, |
| shortpath (NULL, extern_def_p->file->hash_entry->symbol), |
| extern_def_p->line, extern_def_p->ansi_decl); |
| } |
| } |
| if (!quiet_flag) |
| fprintf (stderr, "%s: %s(%d): %s\n", |
| pname, |
| shortpath (NULL, dd_p->file->hash_entry->symbol), |
| dd_p->line, dd_p->ansi_decl); |
| } |
| } |
| |
| /* We want to err on the side of caution, so if we found multiple conflicting |
| definitions for the same function, treat this as being that same as if we |
| had found no definitions (i.e. return NULL). */ |
| |
| if (conflict_noted) |
| return NULL; |
| |
| if (!extern_def_p) |
| { |
| /* We have no definitions for this function so do the next best thing. |
| Search for an extern declaration already in prototype form. */ |
| |
| for (dd_p = head; dd_p; dd_p = dd_p->next_for_func) |
| if (!dd_p->is_func_def && !dd_p->is_static && dd_p->prototyped) |
| { |
| extern_def_p = dd_p; /* save a pointer to the definition */ |
| if (!quiet_flag) |
| fprintf (stderr, "%s: warning: using formals list from %s(%d) for function `%s'\n", |
| pname, |
| shortpath (NULL, dd_p->file->hash_entry->symbol), |
| dd_p->line, dd_p->hash_entry->symbol); |
| break; |
| } |
| |
| /* Gripe about unprototyped function declarations that we found no |
| corresponding definition (or other source of prototype information) |
| for. |
| |
| Gripe even if the unprototyped declaration we are worried about |
| exists in a file in one of the "system" include directories. We |
| can gripe about these because we should have at least found a |
| corresponding (pseudo) definition in the SYSCALLS.c.X file. If we |
| didn't, then that means that the SYSCALLS.c.X file is missing some |
| needed prototypes for this particular system. That is worth telling |
| the user about! */ |
| |
| if (!extern_def_p) |
| { |
| const char *file = user->file->hash_entry->symbol; |
| |
| if (!quiet_flag) |
| if (in_system_include_dir (file)) |
| { |
| /* Why copy this string into `needed' at all? |
| Why not just use user->ansi_decl without copying? */ |
| char *needed = (char *) alloca (strlen (user->ansi_decl) + 1); |
| char *p; |
| |
| strcpy (needed, user->ansi_decl); |
| p = (NONCONST char *) substr (needed, user->hash_entry->symbol) |
| + strlen (user->hash_entry->symbol) + 2; |
| /* Avoid having ??? in the string. */ |
| *p++ = '?'; |
| *p++ = '?'; |
| *p++ = '?'; |
| strcpy (p, ");"); |
| |
| fprintf (stderr, "%s: %d: `%s' used but missing from SYSCALLS\n", |
| shortpath (NULL, file), user->line, |
| needed+7); /* Don't print "extern " */ |
| } |
| #if 0 |
| else |
| fprintf (stderr, "%s: %d: warning: no extern definition for `%s'\n", |
| shortpath (NULL, file), user->line, |
| user->hash_entry->symbol); |
| #endif |
| } |
| } |
| return extern_def_p; |
| } |
| |
| /* Find the (only?) static definition for a particular function name in a |
| given file. Here we get the function-name and the file info indirectly |
| from the def_dec_info record pointer which is passed in. */ |
| |
| static const def_dec_info * |
| find_static_definition (user) |
| const def_dec_info *user; |
| { |
| const def_dec_info *head = user->hash_entry->ddip; |
| const def_dec_info *dd_p; |
| int num_static_defs = 0; |
| const def_dec_info *static_def_p = NULL; |
| |
| for (dd_p = head; dd_p; dd_p = dd_p->next_for_func) |
| if (dd_p->is_func_def && dd_p->is_static && (dd_p->file == user->file)) |
| { |
| static_def_p = dd_p; /* save a pointer to the definition */ |
| num_static_defs++; |
| } |
| if (num_static_defs == 0) |
| { |
| if (!quiet_flag) |
| fprintf (stderr, "%s: warning: no static definition for `%s' in file `%s'\n", |
| pname, head->hash_entry->symbol, |
| shortpath (NULL, user->file->hash_entry->symbol)); |
| } |
| else if (num_static_defs > 1) |
| { |
| fprintf (stderr, "%s: multiple static defs of `%s' in file `%s'\n", |
| pname, head->hash_entry->symbol, |
| shortpath (NULL, user->file->hash_entry->symbol)); |
| return NULL; |
| } |
| return static_def_p; |
| } |
| |
| /* Find good prototype style formal argument lists for all of the function |
| declarations which didn't have them before now. |
| |
| To do this we consider each function name one at a time. For each function |
| name, we look at the items on the linked list of def_dec_info records for |
| that particular name. |
| |
| Somewhere on this list we should find one (and only one) def_dec_info |
| record which represents the actual function definition, and this record |
| should have a nice formal argument list already associated with it. |
| |
| Thus, all we have to do is to connect up all of the other def_dec_info |
| records for this particular function name to the special one which has |
| the full-blown formals list. |
| |
| Of course it is a little more complicated than just that. See below for |
| more details. */ |
| |
| static void |
| connect_defs_and_decs (hp) |
| const hash_table_entry *hp; |
| { |
| const def_dec_info *dd_p; |
| const def_dec_info *extern_def_p = NULL; |
| int first_extern_reference = 1; |
| |
| /* Traverse the list of definitions and declarations for this particular |
| function name. For each item on the list, if it is a function |
| definition (either old style or new style) then GCC has already been |
| kind enough to produce a prototype for us, and it is associated with |
| the item already, so declare the item as its own associated "definition". |
| |
| Also, for each item which is only a function declaration, but which |
| nonetheless has its own prototype already (obviously supplied by the user) |
| declare the item as it's own definition. |
| |
| Note that when/if there are multiple user-supplied prototypes already |
| present for multiple declarations of any given function, these multiple |
| prototypes *should* all match exactly with one another and with the |
| prototype for the actual function definition. We don't check for this |
| here however, since we assume that the compiler must have already done |
| this consistency checking when it was creating the .X files. */ |
| |
| for (dd_p = hp->ddip; dd_p; dd_p = dd_p->next_for_func) |
| if (dd_p->prototyped) |
| ((NONCONST def_dec_info *) dd_p)->definition = dd_p; |
| |
| /* Traverse the list of definitions and declarations for this particular |
| function name. For each item on the list, if it is an extern function |
| declaration and if it has no associated definition yet, go try to find |
| the matching extern definition for the declaration. |
| |
| When looking for the matching function definition, warn the user if we |
| fail to find one. |
| |
| If we find more that one function definition also issue a warning. |
| |
| Do the search for the matching definition only once per unique function |
| name (and only when absolutely needed) so that we can avoid putting out |
| redundant warning messages, and so that we will only put out warning |
| messages when there is actually a reference (i.e. a declaration) for |
| which we need to find a matching definition. */ |
| |
| for (dd_p = hp->ddip; dd_p; dd_p = dd_p->next_for_func) |
| if (!dd_p->is_func_def && !dd_p->is_static && !dd_p->definition) |
| { |
| if (first_extern_reference) |
| { |
| extern_def_p = find_extern_def (hp->ddip, dd_p); |
| first_extern_reference = 0; |
| } |
| ((NONCONST def_dec_info *) dd_p)->definition = extern_def_p; |
| } |
| |
| /* Traverse the list of definitions and declarations for this particular |
| function name. For each item on the list, if it is a static function |
| declaration and if it has no associated definition yet, go try to find |
| the matching static definition for the declaration within the same file. |
| |
| When looking for the matching function definition, warn the user if we |
| fail to find one in the same file with the declaration, and refuse to |
| convert this kind of cross-file static function declaration. After all, |
| this is stupid practice and should be discouraged. |
| |
| We don't have to worry about the possibility that there is more than one |
| matching function definition in the given file because that would have |
| been flagged as an error by the compiler. |
| |
| Do the search for the matching definition only once per unique |
| function-name/source-file pair (and only when absolutely needed) so that |
| we can avoid putting out redundant warning messages, and so that we will |
| only put out warning messages when there is actually a reference (i.e. a |
| declaration) for which we actually need to find a matching definition. */ |
| |
| for (dd_p = hp->ddip; dd_p; dd_p = dd_p->next_for_func) |
| if (!dd_p->is_func_def && dd_p->is_static && !dd_p->definition) |
| { |
| const def_dec_info *dd_p2; |
| const def_dec_info *static_def; |
| |
| /* We have now found a single static declaration for which we need to |
| find a matching definition. We want to minimize the work (and the |
| number of warnings), so we will find an appropriate (matching) |
| static definition for this declaration, and then distribute it |
| (as the definition for) any and all other static declarations |
| for this function name which occur within the same file, and which |
| do not already have definitions. |
| |
| Note that a trick is used here to prevent subsequent attempts to |
| call find_static_definition for a given function-name & file |
| if the first such call returns NULL. Essentially, we convert |
| these NULL return values to -1, and put the -1 into the definition |
| field for each other static declaration from the same file which |
| does not already have an associated definition. |
| This makes these other static declarations look like they are |
| actually defined already when the outer loop here revisits them |
| later on. Thus, the outer loop will skip over them. Later, we |
| turn the -1's back to NULL's. */ |
| |
| ((NONCONST def_dec_info *) dd_p)->definition = |
| (static_def = find_static_definition (dd_p)) |
| ? static_def |
| : (const def_dec_info *) -1; |
| |
| for (dd_p2 = dd_p->next_for_func; dd_p2; dd_p2 = dd_p2->next_for_func) |
| if (!dd_p2->is_func_def && dd_p2->is_static |
| && !dd_p2->definition && (dd_p2->file == dd_p->file)) |
| ((NONCONST def_dec_info *)dd_p2)->definition = dd_p->definition; |
| } |
| |
| /* Convert any dummy (-1) definitions we created in the step above back to |
| NULL's (as they should be). */ |
| |
| for (dd_p = hp->ddip; dd_p; dd_p = dd_p->next_for_func) |
| if (dd_p->definition == (def_dec_info *) -1) |
| ((NONCONST def_dec_info *) dd_p)->definition = NULL; |
| } |
| |
| #endif /* !defined (UNPROTOIZE) */ |
| |
| /* Give a pointer into the clean text buffer, return a number which is the |
| original source line number that the given pointer points into. */ |
| |
| static int |
| identify_lineno (clean_p) |
| const char *clean_p; |
| { |
| int line_num = 1; |
| const char *scan_p; |
| |
| for (scan_p = clean_text_base; scan_p <= clean_p; scan_p++) |
| if (*scan_p == '\n') |
| line_num++; |
| return line_num; |
| } |
| |
| /* Issue an error message and give up on doing this particular edit. */ |
| |
| static void |
| declare_source_confusing (clean_p) |
| const char *clean_p; |
| { |
| if (!quiet_flag) |
| { |
| if (clean_p == 0) |
| fprintf (stderr, "%s: %d: warning: source too confusing\n", |
| shortpath (NULL, convert_filename), last_known_line_number); |
| else |
| fprintf (stderr, "%s: %d: warning: source too confusing\n", |
| shortpath (NULL, convert_filename), |
| identify_lineno (clean_p)); |
| } |
| longjmp (source_confusion_recovery, 1); |
| } |
| |
| /* Check that a condition which is expected to be true in the original source |
| code is in fact true. If not, issue an error message and give up on |
| converting this particular source file. */ |
| |
| static void |
| check_source (cond, clean_p) |
| int cond; |
| const char *clean_p; |
| { |
| if (!cond) |
| declare_source_confusing (clean_p); |
| } |
| |
| /* If we think of the in-core cleaned text buffer as a memory mapped |
| file (with the variable last_known_line_start acting as sort of a |
| file pointer) then we can imagine doing "seeks" on the buffer. The |
| following routine implements a kind of "seek" operation for the in-core |
| (cleaned) copy of the source file. When finished, it returns a pointer to |
| the start of a given (numbered) line in the cleaned text buffer. |
| |
| Note that protoize only has to "seek" in the forward direction on the |
| in-core cleaned text file buffers, and it never needs to back up. |
| |
| This routine is made a little bit faster by remembering the line number |
| (and pointer value) supplied (and returned) from the previous "seek". |
| This prevents us from always having to start all over back at the top |
| of the in-core cleaned buffer again. */ |
| |
| static const char * |
| seek_to_line (n) |
| int n; |
| { |
| if (n < last_known_line_number) |
| abort (); |
| |
| while (n > last_known_line_number) |
| { |
| while (*last_known_line_start != '\n') |
| check_source (++last_known_line_start < clean_text_limit, 0); |
| last_known_line_start++; |
| last_known_line_number++; |
| } |
| return last_known_line_start; |
| } |
| |
| /* Given a pointer to a character in the cleaned text buffer, return a pointer |
| to the next non-whitespace character which follows it. */ |
| |
| static const char * |
| forward_to_next_token_char (ptr) |
| const char *ptr; |
| { |
| for (++ptr; isspace (*ptr); check_source (++ptr < clean_text_limit, 0)) |
| continue; |
| return ptr; |
| } |
| |
| /* Copy a chunk of text of length `len' and starting at `str' to the current |
| output buffer. Note that all attempts to add stuff to the current output |
| buffer ultimately go through here. */ |
| |
| static void |
| output_bytes (str, len) |
| const char *str; |
| size_t len; |
| { |
| if ((repl_write_ptr + 1) + len >= repl_text_limit) |
| { |
| size_t new_size = (repl_text_limit - repl_text_base) << 1; |
| char *new_buf = (char *) xrealloc (repl_text_base, new_size); |
| |
| repl_write_ptr = new_buf + (repl_write_ptr - repl_text_base); |
| repl_text_base = new_buf; |
| repl_text_limit = new_buf + new_size; |
| } |
| memcpy (repl_write_ptr + 1, str, len); |
| repl_write_ptr += len; |
| } |
| |
| /* Copy all bytes (except the trailing null) of a null terminated string to |
| the current output buffer. */ |
| |
| static void |
| output_string (str) |
| const char *str; |
| { |
| output_bytes (str, strlen (str)); |
| } |
| |
| /* Copy some characters from the original text buffer to the current output |
| buffer. |
| |
| This routine takes a pointer argument `p' which is assumed to be a pointer |
| into the cleaned text buffer. The bytes which are copied are the `original' |
| equivalents for the set of bytes between the last value of `clean_read_ptr' |
| and the argument value `p'. |
| |
| The set of bytes copied however, comes *not* from the cleaned text buffer, |
| but rather from the direct counterparts of these bytes within the original |
| text buffer. |
| |
| Thus, when this function is called, some bytes from the original text |
| buffer (which may include original comments and preprocessing directives) |
| will be copied into the output buffer. |
| |
| Note that the request implied when this routine is called includes the |
| byte pointed to by the argument pointer `p'. */ |
| |
| static void |
| output_up_to (p) |
| const char *p; |
| { |
| size_t copy_length = (size_t) (p - clean_read_ptr); |
| const char *copy_start = orig_text_base+(clean_read_ptr-clean_text_base)+1; |
| |
| if (copy_length == 0) |
| return; |
| |
| output_bytes (copy_start, copy_length); |
| clean_read_ptr = p; |
| } |
| |
| /* Given a pointer to a def_dec_info record which represents some form of |
| definition of a function (perhaps a real definition, or in lieu of that |
| perhaps just a declaration with a full prototype) return true if this |
| function is one which we should avoid converting. Return false |
| otherwise. */ |
| |
| static int |
| other_variable_style_function (ansi_header) |
| const char *ansi_header; |
| { |
| #ifdef UNPROTOIZE |
| |
| /* See if we have a stdarg function, or a function which has stdarg style |
| parameters or a stdarg style return type. */ |
| |
| return substr (ansi_header, "...") != 0; |
| |
| #else /* !defined (UNPROTOIZE) */ |
| |
| /* See if we have a varargs function, or a function which has varargs style |
| parameters or a varargs style return type. */ |
| |
| const char *p; |
| int len = strlen (varargs_style_indicator); |
| |
| for (p = ansi_header; p; ) |
| { |
| const char *candidate; |
| |
| if ((candidate = substr (p, varargs_style_indicator)) == 0) |
| return 0; |
| else |
| if (!is_id_char (candidate[-1]) && !is_id_char (candidate[len])) |
| return 1; |
| else |
| p = candidate + 1; |
| } |
| return 0; |
| #endif /* !defined (UNPROTOIZE) */ |
| } |
| |
| /* Do the editing operation specifically for a function "declaration". Note |
| that editing for function "definitions" are handled in a separate routine |
| below. */ |
| |
| static void |
| edit_fn_declaration (def_dec_p, clean_text_p) |
| const def_dec_info *def_dec_p; |
| const char *volatile clean_text_p; |
| { |
| const char *start_formals; |
| const char *end_formals; |
| const char *function_to_edit = def_dec_p->hash_entry->symbol; |
| size_t func_name_len = strlen (function_to_edit); |
| const char *end_of_fn_name; |
| |
| #ifndef UNPROTOIZE |
| |
| const f_list_chain_item *this_f_list_chain_item; |
| const def_dec_info *definition = def_dec_p->definition; |
| |
| /* If we are protoizing, and if we found no corresponding definition for |
| this particular function declaration, then just leave this declaration |
| exactly as it is. */ |
| |
| if (!definition) |
| return; |
| |
| /* If we are protoizing, and if the corresponding definition that we found |
| for this particular function declaration defined an old style varargs |
| function, then we want to issue a warning and just leave this function |
| declaration unconverted. */ |
| |
| if (other_variable_style_function (definition->ansi_decl)) |
| { |
| if (!quiet_flag) |
| fprintf (stderr, "%s: %d: warning: varargs function declaration not converted\n", |
| shortpath (NULL, def_dec_p->file->hash_entry->symbol), |
| def_dec_p->line); |
| return; |
| } |
| |
| #endif /* !defined (UNPROTOIZE) */ |
| |
| /* Setup here to recover from confusing source code detected during this |
| particular "edit". */ |
| |
| save_pointers (); |
| if (setjmp (source_confusion_recovery)) |
| { |
| restore_pointers (); |
| fprintf (stderr, "%s: declaration of function `%s' not converted\n", |
| pname, function_to_edit); |
| return; |
| } |
| |
| /* We are editing a function declaration. The line number we did a seek to |
| contains the comma or semicolon which follows the declaration. Our job |
| now is to scan backwards looking for the function name. This name *must* |
| be followed by open paren (ignoring whitespace, of course). We need to |
| replace everything between that open paren and the corresponding closing |
| paren. If we are protoizing, we need to insert the prototype-style |
| formals lists. If we are unprotoizing, we need to just delete everything |
| between the pairs of opening and closing parens. */ |
| |
| /* First move up to the end of the line. */ |
| |
| while (*clean_text_p != '\n') |
| check_source (++clean_text_p < clean_text_limit, 0); |
| clean_text_p--; /* Point to just before the newline character. */ |
| |
| /* Now we can scan backwards for the function name. */ |
| |
| do |
| { |
| for (;;) |
| { |
| /* Scan leftwards until we find some character which can be |
| part of an identifier. */ |
| |
| while (!is_id_char (*clean_text_p)) |
| check_source (--clean_text_p > clean_read_ptr, 0); |
| |
| /* Scan backwards until we find a char that cannot be part of an |
| identifier. */ |
| |
| while (is_id_char (*clean_text_p)) |
| check_source (--clean_text_p > clean_read_ptr, 0); |
| |
| /* Having found an "id break", see if the following id is the one |
| that we are looking for. If so, then exit from this loop. */ |
| |
| if (!strncmp (clean_text_p+1, function_to_edit, func_name_len)) |
| { |
| char ch = *(clean_text_p + 1 + func_name_len); |
| |
| /* Must also check to see that the name in the source text |
| ends where it should (in order to prevent bogus matches |
| on similar but longer identifiers. */ |
| |
| if (! is_id_char (ch)) |
| break; /* exit from loop */ |
| } |
| } |
| |
| /* We have now found the first perfect match for the function name in |
| our backward search. This may or may not be the actual function |
| name at the start of the actual function declaration (i.e. we could |
| have easily been mislead). We will try to avoid getting fooled too |
| often by looking forward for the open paren which should follow the |
| identifier we just found. We ignore whitespace while hunting. If |
| the next non-whitespace byte we see is *not* an open left paren, |
| then we must assume that we have been fooled and we start over |
| again accordingly. Note that there is no guarantee, that even if |
| we do see the open paren, that we are in the right place. |
| Programmers do the strangest things sometimes! */ |
| |
| end_of_fn_name = clean_text_p + strlen (def_dec_p->hash_entry->symbol); |
| start_formals = forward_to_next_token_char (end_of_fn_name); |
| } |
| while (*start_formals != '('); |
| |
| /* start_of_formals now points to the opening left paren which immediately |
| follows the name of the function. */ |
| |
| /* Note that there may be several formals lists which need to be modified |
| due to the possibility that the return type of this function is a |
| pointer-to-function type. If there are several formals lists, we |
| convert them in left-to-right order here. */ |
| |
| #ifndef UNPROTOIZE |
| this_f_list_chain_item = definition->f_list_chain; |
| #endif /* !defined (UNPROTOIZE) */ |
| |
| for (;;) |
| { |
| { |
| int depth; |
| |
| end_formals = start_formals + 1; |
| depth = 1; |
| for (; depth; check_source (++end_formals < clean_text_limit, 0)) |
| { |
| switch (*end_formals) |
| { |
| case '(': |
| depth++; |
| break; |
| case ')': |
| depth--; |
| break; |
| } |
| } |
| end_formals--; |
| } |
| |
| /* end_formals now points to the closing right paren of the formals |
| list whose left paren is pointed to by start_formals. */ |
| |
| /* Now, if we are protoizing, we insert the new ANSI-style formals list |
| attached to the associated definition of this function. If however |
| we are unprotoizing, then we simply delete any formals list which |
| may be present. */ |
| |
| output_up_to (start_formals); |
| #ifndef UNPROTOIZE |
| if (this_f_list_chain_item) |
| { |
| output_string (this_f_list_chain_item->formals_list); |
| this_f_list_chain_item = this_f_list_chain_item->chain_next; |
| } |
| else |
| { |
| if (!quiet_flag) |
| fprintf (stderr, "%s: warning: too many parameter lists in declaration of `%s'\n", |
| pname, def_dec_p->hash_entry->symbol); |
| check_source (0, end_formals); /* leave the declaration intact */ |
| } |
| #endif /* !defined (UNPROTOIZE) */ |
| clean_read_ptr = end_formals - 1; |
| |
| /* Now see if it looks like there may be another formals list associated |
| with the function declaration that we are converting (following the |
| formals list that we just converted. */ |
| |
| { |
| const char *another_r_paren = forward_to_next_token_char (end_formals); |
| |
| if ((*another_r_paren != ')') |
| || (*(start_formals = forward_to_next_token_char (another_r_paren)) != '(')) |
| { |
| #ifndef UNPROTOIZE |
| if (this_f_list_chain_item) |
| { |
| if (!quiet_flag) |
| fprintf (stderr, "\n%s: warning: too few parameter lists in declaration of `%s'\n", |
| pname, def_dec_p->hash_entry->symbol); |
| check_source (0, start_formals); /* leave the decl intact */ |
| } |
| #endif /* !defined (UNPROTOIZE) */ |
| break; |
| |
| } |
| } |
| |
| /* There does appear to be yet another formals list, so loop around |
| again, and convert it also. */ |
| } |
| } |
| |
| /* Edit a whole group of formals lists, starting with the rightmost one |
| from some set of formals lists. This routine is called once (from the |
| outside) for each function declaration which is converted. It is |
| recursive however, and it calls itself once for each remaining formal |
| list that lies to the left of the one it was originally called to work |
| on. Thus, a whole set gets done in right-to-left order. |
| |
| This routine returns non-zero if it thinks that it should not be trying |
| to convert this particular function definition (because the name of the |
| function doesn't match the one expected). */ |
| |
| static int |
| edit_formals_lists (end_formals, f_list_count, def_dec_p) |
| const char *end_formals; |
| unsigned int f_list_count; |
| const def_dec_info *def_dec_p; |
| { |
| const char *start_formals; |
| int depth; |
| |
| start_formals = end_formals - 1; |
| depth = 1; |
| for (; depth; check_source (--start_formals > clean_read_ptr, 0)) |
| { |
| switch (*start_formals) |
| { |
| case '(': |
| depth--; |
| break; |
| case ')': |
| depth++; |
| |