From 5f8037c4cf13d825a45586e782e8d8502f7f3ec1 Mon Sep 17 00:00:00 2001 From: Richard Stallman Date: Tue, 10 Dec 1991 02:14:53 +0000 Subject: [PATCH] Initial revision From-SVN: r109 --- gcc/protoize.c | 4364 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 4364 insertions(+) create mode 100644 gcc/protoize.c diff --git a/gcc/protoize.c b/gcc/protoize.c new file mode 100644 index 00000000000..32c87d0dd67 --- /dev/null +++ b/gcc/protoize.c @@ -0,0 +1,4364 @@ +/* Protoize program - Written by Ron Guilmette at the Microelectronics + and Computer Technology Corporation (MCC). The author's current + E-mail address is . + + Copyright (C) 1989, 1991 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, 675 Mass Ave, Cambridge, MA 02139, 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 (__cplusplus) +extern "C" { /* Start of extern "C" section. */ +#endif /* defined(__cplusplus) */ + +/* It is incorrect to include config.h here, because this file is being + compiled for the target, and hence definitions concerning only the host + do not apply. */ + +#include "tm.h" + +/* On a POSIX system, request definition of all the POSIX facilities. */ +/* We use TARGET_POSIX because protoize is compiled for the target system, + and TARGET_POSIX is the symbol that describes it in tm.h. */ +#ifdef TARGET_POSIX +#define _POSIX_SOURCE +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include "gvarargs.h" +#include "getopt.h" + +#include +#ifndef PATH_MAX /* defines this on most POSIX systems. */ +#include +#define PATH_MAX MAXPATHLEN +/* Sometimes defines these macros. */ +#undef CHAR_BIT +#undef CHAR_MAX +#undef CHAR_MIN +#undef CLK_TCK +#undef INT_MAX +#undef INT_MIN +#undef LONG_MAX +#undef LONG_MIN +#undef SCHAR_MAX +#undef SCHAR_MIN +#undef SHRT_MAX +#undef SHRT_MIN +#undef UCHAR_MAX +#undef UINT_MAX +#undef ULONG_MAX +#undef USHRT_MAX +#endif + +extern int errno; +extern char * sys_errlist[]; + +#if defined(TARGET_POSIX) + +#include +#include +#include +#include +#include + +/* 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. */ + +#if (_POSIX_VERSION < 199009) + +#define access(file,flag) access((char *)file, flag) +#define stat(file,pkt) stat((char *)file, pkt) +#define execvp(prog,argv) execvp((char *)prog, (char **)argv) +#define link(file1, file2) link((char *)file1, (char *)file2) +#define unlink(file) unlink((char *)file) +#define open(file, mode, flag) open((char *)file, mode, flag) +#define chmod(file, mode) chmod((char *)file, mode) + +#endif /* (_POSIX_VERSION < 199009) */ + +#else /* !defined(TARGET_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 */ + +#define O_RDONLY 0 +#define O_WRONLY 1 + +/* Virtually every UN*X system now in common use (except for pre-4.3-tahoe + BSD systems) now provides getcwd as called for by POSIX. Allow for + the few exceptions to the general rule here. */ + +#if !(defined (USG) || defined (VMS)) +extern char *getwd (char *); +#define getcwd(buf,len) getwd(buf) +#else /* (defined (USG) || defined (VMS)) */ +extern char *getcwd (char *, size_t); +#endif /* (defined (USG) || defined (VMS)) */ + +/* Declaring stat, kill or __flsbuf with a prototype + causes conflicts with system headers on some systems. + Declaring abort causes trouble if it is a macro. */ + +extern int creat (const char *, int); +extern int open (const char *, int, ...); +extern int fprintf (FILE *, const char *, ...); +extern int printf (const char *, ...); +extern void exit (int); +extern void *malloc (size_t); +extern void *realloc (void *, size_t); +extern void free (void *); +extern int read (int, void *, size_t); +extern int write (int, const void *, size_t); +extern int close (int); +extern int link (const char *, const char *); +extern int unlink (const char *); +extern int fflush (FILE *); +extern int atoi (const char *); +extern int access (const char *, int); +extern int puts (const char *); +extern int fputs (const char *, FILE *); +extern int fputc (int, FILE *); +extern int execvp (const char *, char *const *); +extern int setjmp (jmp_buf); +extern void longjmp (jmp_buf, int); + +extern char * strcat(char *, const char *); +extern int strcmp(const char *, const char *); +extern char * strcpy(char *, const char *); +extern size_t strlen(const char *); +extern int strncmp(const char *, const char *, size_t); +extern char * strncpy(char *, const char *, size_t); +extern char * strrchr(const char *, int); + +#if !(defined (USG) || defined (VMS)) +extern int vfork (void); +#define fork vfork +#endif /* !(defined (USG) || defined (VMS)) */ + +#endif /* !defined(TARGET_POSIX) */ + +#if defined (__cplusplus) +} /* End of extern "C" section. */ +#endif /* defined(__cplusplus) */ + +/* Look for these where the `const' qualifier is intentionally cast aside. */ + +#define NONCONST + +/* Aliases for pointers to void. + These were made to facilitate compilation with other compilers. */ + +typedef void * pointer_type; +typedef const void * const_pointer_type; + +/* Define a STRINGIFY macro that's right for ANSI C. */ + +#define STRINGIFY(STRING) #STRING + +/* POSIX systems will not have definitions for WIFEXITED or WEXITSTATUS. + Define them correctly and so that they work for all environments. */ + +#undef WIFEXITED +#define WIFEXITED(status_word) ((*((int *)&status_word) & 0xff) == 0x00) + +#undef WEXITSTATUS +#define WEXITSTATUS(status_word) ((*((int *)&status_word) & 0xff00) >> 8) + +/* 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) */ + +/* String to identify this version. */ + +static const char * const version_string = "Version 1.07"; + +/* Suffix of aux_info files. */ + +static const char * const aux_info_suffix = ".X"; + +/* String to attach to pathnames 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 * const 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 pathname of the SYSCALLS.c.X + file. */ + +static char * syscalls_pathname; + +#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 { char *fname; int cplusplus; } include_defaults[] +#ifdef INCLUDE_DEFAULTS + = INCLUDE_DEFAULTS; +#else + = { + /* Pick up GNU C++ specific include files. */ + { GPLUSPLUS_INCLUDE_DIR, 1}, + { GCC_INCLUDE_DIR, 0}, +#ifdef CROSS_COMPILE + /* For cross-compilation, this dir name is generated + automatically in Makefile.in. */ + { CROSS_INCLUDE_DIR, 0 }, +#else /* not CROSS_COMPILE */ + { LOCAL_INCLUDE_DIR, 0}, + /* Some systems have an extra dir of include files. */ +#ifdef SYSTEM_INCLUDE_DIR + { SYSTEM_INCLUDE_DIR, 0}, +#endif +#ifndef NO_STANDARD_INCLUDE_DIR + { STANDARD_INCLUDE_DIR, 0}, +#endif +#endif /* not CROSS_COMPILE */ + { 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"; +static const char * const 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 pathnames 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 pathnames + hash table or the function names hash table). In the pathnames hash table + the info fields of the entries point to the file_info struct which is + associated with each pathname (1 per pathname). 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 pathname (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 visiblilty 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 declartions */ +#endif /* !defined(UNPROTOIZE) */ +}; + +/* Pointer to the tail component of the pathname 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. */ + +static int version_flag = 0; /* set by -V option */ +static int quiet_flag = 0; /* set by -q option */ +#if 0 +static int force_flag = 0; /* set by -f option */ +#endif +static int nochange_flag = 0; /* set by -n option */ +static int nosave_flag = 0; /* set by -N option */ +static int keep_flag = 0; /* set by -k option */ +static const char ** compile_params = 0; /* set by -c option */ +#ifdef UNPROTOIZE +static const char *indent_string = " "; /* set by -i option */ +#else /* !defined(UNPROTOIZE) */ +static int local_flag = 0; /* set by -l option */ +static int global_flag = 0; /* set by -g option */ +static int cplusplus_flag = 0; /* set by -C option */ +static const char* nondefault_syscalls_dir = 0; /* set by -B option */ +#endif /* !defined(UNPROTOIZE) */ + +/* An index into the compile_params array where we should insert the filename + parameter when we are ready to exec the C compiler. A zero value indicates + that we have not yet called munge_compile_params(). */ + +static int filename_index = 0; + +/* Count of command line arguments which were "filename" arguments. */ + +static int 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_paths; + +/* 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_path; + +/* 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_path; + +/* 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 pathnames hash table. */ + +static hash_table pathname_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 pathname (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 (const char *cwd, const char *pathname); + +/* Allocate some space, but check that the allocation was successful. */ + +static pointer_type +xmalloc (size_t byte_count) +{ + pointer_type rv; + + if ((rv = malloc (byte_count)) == NULL) + { + fprintf (stderr, "\n%s: fatal error: can't allocate %u more bytes of memory\n", + pname, byte_count); + exit (1); + return 0; /* avoid warnings */ + } + else + return rv; +} + +/* Reallocate some space, but check that the reallocation was successful. */ + +static pointer_type +xrealloc (pointer_type old_space, size_t byte_count) +{ + pointer_type rv; + + if ((rv = realloc (old_space, byte_count)) == NULL) + { + fprintf (stderr, "\n%s: fatal error: can't allocate %u more bytes of memory\n", + pname, byte_count); + exit (1); + 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. */ + +static void +xfree (const_pointer_type p) +{ + if (p) + free ((NONCONST pointer_type) p); +} + +/* Make a copy of a string INPUT with size SIZE. */ + +static char * +savestring (char *input, int size) +{ + char *output = (char *) xmalloc (size + 1); + strcpy (output, input); + 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 (1); +} + +/* Make a duplicate of a given string in a newly allocated area. */ + +static char * +dupstr (const char *s) +{ + return strcpy ((char *) xmalloc (strlen (s) + 1), s); +} + +/* Make a duplicate of the first N bytes of a given string in a newly + allocated area. */ + +static char * +dupnstr (const char *s, size_t n) +{ + char *ret_val = strncpy ((char *) xmalloc (n + 1), s, n); + + ret_val[n] = '\0'; + return ret_val; +} + +/* Return a pointer to the first occurance 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 (const char *s1, const char *const s2) +{ + for (; *s1 ; s1++) + { + const char *p1; + const char *p2; + char c; + + for (p1 = s1, p2 = s2; c = *p2; p1++, p2++) + if (*p1 != c) + goto outer; + return s1; +outer: + ; + } + return 0; +} + +/* Get setup to recover in case the edit we are about to do goes awry. */ + +void +save_pointers (void) +{ + 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 (void) +{ + clean_read_ptr = saved_clean_read_ptr; + repl_write_ptr = saved_repl_write_ptr; +} + +/* Return true if the given character is a legal identifier character. */ + +inline static int +is_id_char (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 (void) +{ +#ifdef UNPROTOIZE + fprintf (stderr, "%s: usage '%s [ -VqfnkN ] [ -i ] [ pathname ... ]'\n", +#else /* !defined(UNPROTOIZE) */ + fprintf (stderr, "%s: usage '%s [ -VqfnkNlgC ] [ -B ] [ pathname ... ]'\n", +#endif /* !defined(UNPROTOIZE) */ + pname, pname); + exit (1); +} + +/* Return true if the given pathname (assumed to be an absolute pathname) + designates a file residing anywhere beneath any one of the "system" + include directories. */ + +static int +in_system_include_dir (const char *path) +{ + struct default_include *p; + + if (path[0] != '/') + abort (); /* Must be an absolutized pathname. */ + + 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 pathname 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 (access (path, R_OK)) + return 0; + + { + char *dir_last_slash; + + strcpy (dir_name, path); + dir_last_slash = strrchr (dir_name, '/'); + if (dir_last_slash) + *dir_last_slash = '\0'; + else + abort (); /* Should have been an absolutized pathname. */ + } + + if (access (path, W_OK)) + return 0; + + return 1; +} + +/* Return true if the given pathname 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_convertable (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 = strrchr (dir_name, '/'); + if (dir_last_slash) + *dir_last_slash = '\0'; + else + abort (); /* Should have been an absolutized pathname. */ + } + + if (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 (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 (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 (const file_info *fi_p) +{ + return (substr (fi_p->hash_entry->symbol, syscalls_filename) != NULL); +} + +#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 (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 (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)] == '/') + return 1; + + return 0; +} + +/* Return 1 if the file named NAME should be excluded from conversion. */ + +static int +file_excluded_p (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 (char *string, struct string_list *rest) +{ + struct string_list *temp = 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 (const hash_table_entry *hash_tab_p, void (*func) (const hash_table_entry *)) +{ + 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 (hash_table_entry *p, const char *s) +{ + p->hash_next = NULL; + p->symbol = dupstr (s); + p->ddip = NULL; + p->fip = NULL; + return p; +} + +/* Look for a particular function name or pathname 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_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. */ + +inline static void +free_def_dec (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 (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 ? dupstr (line_buf) : 0); +} + +/* Return the absolutized pathname for the given relative + pathname. Note that if that pathname 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 pathname from the given input + pathname. The absolutization of relative pathnames is made by + assuming that the given pathname is to be taken as relative to + the first argument (cwd) or to the current directory if cwd is + NULL. */ + +static char * +abspath (const char *cwd, const char *rel_pathname) +{ + /* Setup the current working directory as needed. */ + const char *cwd2 = (cwd) ? cwd : cwd_buffer; + char *const abs_buffer + = (char *) alloca (strlen (cwd2) + strlen (rel_pathname) + 1); + char *endp = abs_buffer; + char *outp, *inp; + + /* Copy the pathname (possibly preceeded by the current working + directory name) into the absolutization buffer. */ + + { + const char *src_p; + + if (rel_pathname[0] != '/') + { + src_p = cwd2; + while (*endp++ = *src_p++) + continue; + *(endp-1) = '/'; /* overwrite null */ + } + src_p = rel_pathname; + while (*endp++ = *src_p++) + continue; + if (endp[-1] == '/') + *endp = '\0'; + } + + /* Now make a copy of abs_buffer into abs_buffer, shortening the + pathname (by taking out slashes and dots) as we go. */ + + outp = inp = abs_buffer; + *outp++ = *inp++; /* copy first slash */ + 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: fatal error: invalid pathname: %s\n", + pname, rel_pathname); + exit (1); + } + *++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 dupstr (abs_buffer); +} + +/* Given a pathname (and possibly a directory name from which the pathname + is relative) return a string which is the shortest possible + equivalent for the corresponding full (absolutized) pathname. The + shortest possible equivalent may be constructed by converting the + absolutized pathname to be a relative pathname (i.e. relative to + the actual current working directory). However if a relative pathname + is longer, then the full absolute pathname is returned. + + KNOWN BUG: + + Note that "simple-minded" conversion of any given type of pathname (either + relative or absolute) may not result in a valid equivalent pathname if any + subpart of the original pathname is actually a symbolic link. */ + +static const char * +shortpath (const char *cwd, const char *pathname) +{ + char *rel_buffer; + char *rel_buf_p; + char *cwd_p = cwd_buffer; + char *path_p; + int unmatched_slash_count = 0; + + path_p = abspath (cwd, pathname); + rel_buf_p = rel_buffer = (char *) xmalloc (strlen (path_p) + 1); + + while (*cwd_p && (*cwd_p == *path_p)) + { + cwd_p++; + path_p++; + } + if (!*cwd_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++; + } + while (*cwd_p) + if (*cwd_p++ == '/') + unmatched_slash_count++; + while (unmatched_slash_count--) + { + *rel_buf_p++ = '.'; + *rel_buf_p++ = '.'; + *rel_buf_p++ = '/'; + } + while (*rel_buf_p++ = *path_p++) + continue; + --rel_buf_p; + if (*(rel_buf_p-1) == '/') + *--rel_buf_p = '\0'; + if (strlen (rel_buffer) > strlen (pathname)) + strcpy (rel_buffer, pathname); + return rel_buffer; + } + /* NOTREACHED */ + return 0; /* Prevent warnings for old versions of GCC. */ +} + +/* Lookup the given pathname in the hash table for pathnames. 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 pathname, and we initialize + that record with some reasonable values. */ + +static file_info * +find_file (const char *pathname, int do_not_stat) +{ + hash_table_entry *hash_entry_p; + + hash_entry_p = lookup (pathname_primary, pathname); + 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 (stat (pathname, &stat_buf) == -1) + { + fprintf (stderr, "%s: error: can't get status of `%s': %s\n", + pname, shortpath (NULL, pathname), sys_errlist[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 (void) +{ + fprintf (stderr, "\n%s: fatal error: aux info file corrupted at line %d\n", + pname, current_aux_info_lineno); + exit (1); +} + +/* ??? 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(). */ + +inline static void +check_aux_info (int cond) +{ + if (! cond) + aux_info_corrupted (); +} + +/* Given a pointer to the closing right parenthesis for a particular formals + list (in a aux_info file) find the corresponding left parenthesis and + return a pointer to it. */ + +static const char * +find_corresponding_lparen (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 (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_path, 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 occured 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 (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 pathnames + (i.e. the names of the aux_info files with the .X stripped off) into the + pathnames hash table, and we simultaneously setup file_info records for + all of these base file pathnames (even if they may be useless later). + The file_info records for all of these "base" file pathnames (properly) + act as file_info records for the "original" (i.e. un-included) files + which were submitted to gcc for compilation (when the -fgen-aux-info + option was used). */ + + def_dec_p->file = find_file (abspath (invocation_path, 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--; + + /* 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; + +#ifndef UNPROTOIZE + def_dec_p->f_list_chain = NULL; +#endif /* !defined(UNPROTOIZE) */ + + 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 preceeding 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[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: error: declaration of function `%s' at %s(%d) takes different forms\n", + pname, + def_dec_p->hash_entry->symbol, + def_dec_p->file->hash_entry->symbol, + def_dec_p->line); + exit (1); + } + 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; + } + } +} + +/* Rewrite the options list used to recompile base source files. All we are + really doing here is removing -g, -O, -S, -c, and -o options, and then + adding a final group of options like '-fgen-aux-info -S -o /dev/null'. */ + +static void +munge_compile_params (const char *params_list) +{ + const char *temp_params[strlen (params_list) + 10]; + int param_count = 0; + const char *param; + + temp_params[param_count++] = "gcc"; + 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++] = "-fgen-aux-info"; + temp_params[param_count++] = "-S"; + temp_params[param_count++] = "-o"; + temp_params[param_count++] = "/dev/null"; + + /* Leave room for the filename argument and a terminating null pointer. */ + + temp_params[filename_index = param_count++] = NULL; + temp_params[param_count++] = NULL; + + /* Make a copy of the compile_params in heap space. */ + + compile_params = 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. */ + +static int +gen_aux_info_file (const char *base_pathname) +{ + int child_pid; + + if (!filename_index) + munge_compile_params (""); + + compile_params[filename_index] = shortpath (NULL, base_pathname); + + if (!quiet_flag) + fprintf (stderr, "%s: compiling `%s'\n", + pname, compile_params[filename_index]); + + if (child_pid = fork ()) + { + if (child_pid == -1) + { + fprintf (stderr, "%s: error: could not fork process: %s\n", + pname, sys_errlist[errno]); + return 0; + } + +#if 0 + /* Print out the command line that the other process is now executing. */ + + if (!quiet_flag) + { + const char **arg; + + fputs ("\t", stderr); + for (arg = compile_params; *arg; arg++) + { + fputs (*arg, stderr); + fputc (' ', stderr); + } + fputc ('\n', stderr); + fflush (stderr); + } +#endif /* 0 */ + + { + int wait_status; + + if (wait (&wait_status) == -1) + { + fprintf (stderr, "%s: error: wait for process failed: %s\n", + pname, sys_errlist[errno]); + return 0; + } + if (!WIFEXITED (wait_status)) + { + kill (child_pid, 9); + return 0; + } + return (WEXITSTATUS (wait_status) == 0) ? 1 : 0; + } + } + else + { + if (execvp (compile_params[0], (char *const *) compile_params)) + { + fprintf (stderr, "%s: error: execvp returned: %s\n", + pname, sys_errlist[errno]); + exit (errno); + } + return 1; /* Never executed. */ + } +} + +/* 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 (const char *base_source_pathname, int keep_it, int is_syscalls) +{ + char *const aux_info_pathname + = (char *) alloca (strlen (base_source_pathname) + + strlen (aux_info_suffix) + 1); + char *aux_info_base; + char *aux_info_limit; + const char *aux_info_second_line; + time_t aux_info_mtime; + size_t aux_info_size; + + /* Construct the aux_info pathname from the base source pathname. */ + + strcpy (aux_info_pathname, base_source_pathname); + strcat (aux_info_pathname, aux_info_suffix); + + /* Check that the aux_info file exists and is readable. If it does not + exist, try to create it (once only). */ + +start_over: ; + + { + int retries = 0; + +retry: + if (access (aux_info_pathname, R_OK) == -1) + { + if (errno == ENOENT && retries == 0) + { + if (is_syscalls) + { + fprintf (stderr, "%s: warning: missing SYSCALLS file `%s'\n", + pname, aux_info_pathname); + return; + } + if (!gen_aux_info_file (base_source_pathname)) + return; + retries++; + goto retry; + } + else + { + fprintf (stderr, "%s: error: can't read aux info file `%s': %s\n", + pname, shortpath (NULL, aux_info_pathname), sys_errlist[errno]); + errors++; + return; + } + } + } + + { + struct stat stat_buf; + + /* Get some status information about this aux_info file. */ + + if (stat (aux_info_pathname, &stat_buf) == -1) + { + fprintf (stderr, "%s: error: can't get status of aux info file `%s': %s\n", + pname, shortpath (NULL, aux_info_pathname), sys_errlist[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; + } + + { + int aux_info_file; + + /* Open the aux_info file. */ + + if ((aux_info_file = open (aux_info_pathname, O_RDONLY, 0444 )) == -1) + { + fprintf (stderr, "%s: error: can't open aux info file `%s' for reading: %s\n", + pname, shortpath (NULL, aux_info_pathname), sys_errlist[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 (read (aux_info_file, aux_info_base, aux_info_size) != aux_info_size) + { + fprintf (stderr, "%s: error: while reading aux info file `%s': %s\n", + pname, shortpath (NULL, aux_info_pathname), sys_errlist[errno]); + free (aux_info_base); + close (aux_info_file); + return; + } + + /* Close the aux info file. */ + + if (close (aux_info_file)) + { + fprintf (stderr, "%s: error: while closing aux info file `%s': %s\n", + pname, shortpath (NULL, aux_info_pathname), sys_errlist[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 (!keep_it) + if (unlink (aux_info_pathname) == -1) + fprintf (stderr, "%s: error: can't delete aux info file `%s': %s\n", + pname, shortpath (NULL, aux_info_pathname), sys_errlist[errno]); + + /* Save a pointer into the first line of the aux_info file which + contains the pathname 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 + pathnames out of the (potentially) relative pathnames in + the aux_info file. */ + + { + char *p = aux_info_base; + + while (*p != ':') + p++; + p++; + while (*p == ' ') + p++; + invocation_path = p; /* Save a pointer to first byte of path. */ + while (*p != ' ') + p++; + *p++ = '/'; + *p++ = '\0'; + while (*p++ != '\n') + continue; + aux_info_second_line = p; + } + + + { + 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); + if (unlink (aux_info_pathname) == -1) + { + fprintf (stderr, "%s: error: can't delete file `%s': %s\n", + pname, + shortpath (NULL, aux_info_pathname), + sys_errlist[errno]); + return; + } + 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); +} + +#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 (const hash_table_entry *hp) +{ + const char *pathname = hp->symbol; + int last_char_index = strlen (pathname) - 1; + char *const new_pathname = (char *) alloca (strlen (pathname) + 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 (pathname[last_char_index] != 'c' || pathname[last_char_index-1] != '.') + return; + + strcpy (new_pathname, pathname); + new_pathname[last_char_index] = 'C'; + + if (link (pathname, new_pathname) == -1) + { + fprintf (stderr, "%s: warning: can't link file `%s' to `%s': %s\n", + pname, shortpath (NULL, pathname), + shortpath (NULL, new_pathname), sys_errlist[errno]); + errors++; + return; + } + + if (unlink (pathname) == -1) + { + fprintf (stderr, "%s: warning: can't delete file `%s': %s\n", + pname, shortpath (NULL, pathname), sys_errlist[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 (const hash_table_entry *hp) +{ + file_info *file_p = hp->fip; + const def_dec_info *prev = NULL; + const def_dec_info *current = file_p->defs_decs; + + if (!( current = file_p->defs_decs)) + return; /* no list to reverse */ + + prev = current; + if (! (current = current->next_in_file)) + return; /* can't reverse a single list element */ + + ((NONCONST def_dec_info *) prev)->next_in_file = NULL; + + while (current) + { + const def_dec_info *next = current->next_in_file; + + ((NONCONST def_dec_info *) 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 (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: error: 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[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; + strcpy (p, "???);"); + + fprintf (stderr, "%s: please add `%s' to SYSCALLS (see %s(%d))\n", + pname, + needed+7, /* Don't print "extern " */ + shortpath (NULL, file), + user->line); + } + else + fprintf (stderr, "%s: warning: no extern definition for `%s' (see %s(%d))\n", + pname, + user->hash_entry->symbol, + shortpath (NULL, file), + user->line); + } + } + 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 (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: error: 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 (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 consistancy 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 (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 (const char *clean_p) +{ + if (!quiet_flag) + { + if (clean_p == 0) + fprintf (stderr, "%s: warning: source too confusing near %s(%d)\n", + pname, shortpath (NULL, convert_path), last_known_line_number); + else + fprintf (stderr, "%s: warning: source too confusing at %s(%d)\n", + pname, shortpath (NULL, convert_path), 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. */ + +inline static void +check_source (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 (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-whitepace character which follows it. */ + +static const char * +forward_to_next_token_char (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 (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 (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 implide when this routine is called includes the + byte pointed to by the argument pointer `p'. */ + +static void +output_up_to (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 (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 (int) substr (ansi_header, "..."); + +#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 (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: warning: varargs function declaration at %s(%d) not converted\n", + pname, + 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 guarrantee, 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 (const char *end_formals, unsigned 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++; + break; + } + } + start_formals++; + + /* start_formals now points to the opening left paren of the formals list. */ + + f_list_count--; + + if (f_list_count) + { + const char *next_end; + + /* There should be more formal lists to the left of here. */ + + next_end = start_formals - 1; + check_source (next_end > clean_read_ptr, 0); + while (isspace (*next_end)) + check_source (--next_end > clean_read_ptr, 0); + check_source (*next_end == ')', next_end); + check_source (--next_end > clean_read_ptr, 0); + check_source (*next_end == ')', next_end); + if (edit_formals_lists (next_end, f_list_count, def_dec_p)) + return 1; + } + + /* Check that the function name in the header we are working on is the same + as the one we would expect to find. If not, issue a warning and return + non-zero. */ + + if (f_list_count == 0) + { + const char *expected = def_dec_p->hash_entry->symbol; + const char *func_name_start; + const char *func_name_limit; + size_t func_name_len; + + for (func_name_limit = start_formals-1; isspace (*func_name_limit); ) + check_source (--func_name_limit > clean_read_ptr, 0); + + for (func_name_start = func_name_limit++; + is_id_char (*func_name_start); + func_name_start--) + check_source (func_name_start > clean_read_ptr, 0); + func_name_start++; + func_name_len = func_name_limit - func_name_start; + if (func_name_len == 0) + check_source (0, func_name_start); + if (func_name_len != strlen (expected) + || strncmp (func_name_start, expected, func_name_len)) + { + fprintf (stderr, "%s: warning: found `%s' at %s(%d) but expected `%s'\n", + pname, + dupnstr (func_name_start, func_name_len), + shortpath (NULL, def_dec_p->file->hash_entry->symbol), + identify_lineno (func_name_start), + expected); + return 1; + } + } + + output_up_to (start_formals); + +#ifdef UNPROTOIZE + if (f_list_count == 0) + output_string (def_dec_p->formal_names); +#else /* !defined(UNPROTOIZE) */ + { + unsigned f_list_depth; + const f_list_chain_item *flci_p = def_dec_p->f_list_chain; + + /* At this point, the current value of f_list count says how many + links we have to follow through the f_list_chain to get to the + particular formals list that we need to output next. */ + + for (f_list_depth = 0; f_list_depth < f_list_count; f_list_depth++) + flci_p = flci_p->chain_next; + output_string (flci_p->formals_list); + } +#endif /* !defined(UNPROTOIZE) */ + + clean_read_ptr = end_formals - 1; + return 0; +} + +/* Given a pointer to a byte in the clean text buffer which points to the + beginning of a line that contains a "follower" token for a function + definition header, do whatever is necessary to find the right closing + paren for the rightmost formals list of the function definition header. +*/ + +static const char * +find_rightmost_formals_list (const char *clean_text_p) +{ + const char *end_formals; + + /* We are editing a function definition. The line number we did a seek + to contains the first token which immediately follows the entire set of + formals lists which are part of this particular function definition + header. + + Our job now is to scan leftwards in the clean text looking for the + right-paren which is at the end of the function header's rightmost + formals list. + + If we ignore whitespace, this right paren should be the first one we + see which is (ignoring whitespace) immediately followed either by the + open curly-brace beginning the function body or by an alphabetic + character (in the case where the function definition is in old (K&R) + style and there are some declarations of formal parameters). */ + + /* It is possible that the right paren we are looking for is on the + current line (together with its following token). Just in case that + might be true, we start out here by skipping down to the right end of + the current line before starting our scan. */ + + for (end_formals = clean_text_p; *end_formals != '\n'; end_formals++) + continue; + end_formals--; + + /* Now scan backwards while looking for the right end of the rightmost + formals list associated with this function definition. */ + + for (;;) + { + char ch; + const char *l_brace_p; + + /* Look leftward and try to find a right-paren. */ + + while (*end_formals != ')') + { + if (isspace (*end_formals)) + while (isspace (*end_formals)) + check_source (--end_formals > clean_read_ptr, 0); + else + check_source (--end_formals > clean_read_ptr, 0); + } + + ch = *(l_brace_p = forward_to_next_token_char (end_formals)); + +#ifdef UNPROTOIZE + + /* Since we are unprotoizing an ANSI-style (prototyped) function + definition, there had better not be anything (except whitespace) + between the end of the ANSI formals list and the beginning of the + function body (i.e. the '{'). */ + + check_source (ch == '{', l_brace_p); + break; + +#else /* !defined(UNPROTOIZE) */ + + /* Since it is possible that we found a right paren before the starting + '{' of the body which IS NOT the one at the end of the real K&R + formals list (say for instance, we found one embedded inside one of + the old K&R formal parameter declarations) we have to check to be + sure that this is in fact the right paren that we were looking for. + + The one we were looking for *must* be followed by either a '{' or + by an alphabetic character, while others *cannot* legally be followed + by such characters. */ + + if ((ch == '{') || isalpha (ch)) + break; + + /* At this point, we have found a right paren, but we know that it is + not the one we were looking for, so backup one character and keep + looking. */ + + check_source (--end_formals > clean_read_ptr, 0); + +#endif /* !defined(UNPROTOIZE) */ + + } + + return end_formals; +} + +#ifndef UNPROTOIZE + +/* Insert into the output file a totally new declaration for a function + which (up until now) was being called from within the current block + without having been declared at any point such that the declaration + was visible (i.e. in scope) at the point of the call. + + We need to add in explicit declarations for all such function calls + in order to get the full benefit of prototype-based function call + parameter type checking. */ + +static void +add_local_decl (const def_dec_info *def_dec_p, const char *clean_text_p) +{ + const char *start_of_block; + const char *function_to_edit = def_dec_p->hash_entry->symbol; + + /* Don't insert new local explicit declarations unless explicitly requested + to do so. */ + + if (!local_flag) + return; + + /* 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: local declaration for function `%s' not inserted\n", + pname, function_to_edit); + return; + } + + /* We have already done a seek to the start of the line which should + contain *the* open curly brace which begins the block in which we need + to insert an explicit function declaration (to replace the implicit one). + + Now we scan that line, starting from the left, until we find the + open curly brace we are looking for. Note that there may actually be + multiple open curly braces on the given line, but we will be happy + with the leftmost one no matter what. */ + + start_of_block = clean_text_p; + while (*start_of_block != '{' && *start_of_block != '\n') + check_source (++start_of_block < clean_text_limit, 0); + + /* Note that the line from the original source could possibly + contain *no* open curly braces! This happens if the line contains + a macro call which expands into a chunk of text which includes a + block (and that block's associated open and close curly braces). + In cases like this, we give up, issue a warning, and do nothing. */ + + if (*start_of_block != '{') + { + if (!quiet_flag) + fprintf (stderr, + "\n%s: warning: can't add declaration of `%s' into macro call at %s(%d)\n", + pname, + def_dec_p->hash_entry->symbol, + def_dec_p->file->hash_entry->symbol, + def_dec_p->line); + return; + } + + /* Figure out what a nice (pretty) indentation would be for the new + declaration we are adding. In order to do this, we must scan forward + from the '{' until we find the first line which starts with some + non-whitespace characters (i.e. real "token" material). */ + + { + const char *ep = forward_to_next_token_char (start_of_block) - 1; + const char *sp; + + /* Now we have ep pointing at the rightmost byte of some existing indent + stuff. At least that is the hope. + + We can now just scan backwards and find the left end of the existing + indentation string, and then copy it to the output buffer. */ + + for (sp = ep; isspace (*sp) && *sp != '\n'; sp--) + continue; + + /* Now write out the open { which began this block, and any following + trash up to and including the last byte of the existing indent that + we just found. */ + + output_up_to (ep); + + /* Now we go ahead and insert the new declaration at this point. + + If the definition of the given function is in the same file that we + are currently editing, and if its full ANSI declaration normally + would start with the keyword `extern', suppress the `extern'. */ + + { + const char *decl = def_dec_p->definition->ansi_decl; + + if ((*decl == 'e') && (def_dec_p->file == def_dec_p->definition->file)) + decl += 7; + output_string (decl); + } + + /* Finally, write out a new indent string, just like the preceeding one + that we found. This will typically include a newline as the first + character of the indent string. */ + + output_bytes (sp, (size_t) (ep - sp) + 1); + } +} + +/* Given a pointer to a file_info record, and a pointer to the beginning + of a line (in the clean text buffer) which is assumed to contain the + first "follower" token for the first function definition header in the + given file, find a good place to insert some new global function + declarations (which will replace scattered and imprecise implicit ones) + and then insert the new explicit declaration at that point in the file. */ + +static void +add_global_decls (const file_info *file_p, const char *clean_text_p) +{ + const def_dec_info *dd_p; + const char *scan_p; + + /* 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: global declarations for file `%s' not inserted\n", + pname, shortpath (NULL, file_p->hash_entry->symbol)); + return; + } + + /* Start by finding a good location for adding the new explicit function + declarations. To do this, we scan backwards, ignoring whitespace + and comments and other junk until we find either a semicolon, or until + we hit the beginning of the file. */ + + scan_p = find_rightmost_formals_list (clean_text_p); + for (;; --scan_p) + { + if (scan_p < clean_text_base) + break; + check_source (scan_p > clean_read_ptr, 0); + if (*scan_p == ';') + break; + } + + /* scan_p now points either to a semicolon, or to just before the start + of the whole file. */ + + /* Now scan forward for the first non-whitespace character. In theory, + this should be the first character of the following function definition + header. We will put in the added declarations just prior to that. */ + + scan_p++; + while (isspace (*scan_p)) + scan_p++; + scan_p--; + + output_up_to (scan_p); + + /* Now write out full prototypes for all of the things that had been + implicitly declared in this file (but only those for which we were + actually able to find unique matching definitions). Avoid duplicates + by marking things that we write out as we go. */ + + { + int some_decls_added = 0; + + for (dd_p = file_p->defs_decs; dd_p; dd_p = dd_p->next_in_file) + if (dd_p->is_implicit && dd_p->definition && !dd_p->definition->written) + { + const char *decl = dd_p->definition->ansi_decl; + + /* If the function for which we are inserting a declaration is + actually defined later in the same file, then suppress the + leading `extern' keyword (if there is one). */ + + if (*decl == 'e' && (dd_p->file == dd_p->definition->file)) + decl += 7; + + output_string ("\n"); + output_string (decl); + some_decls_added = 1; + ((NONCONST def_dec_info *) dd_p->definition)->written = 1; + } + if (some_decls_added) + output_string ("\n\n"); + } + + /* Unmark all of the definitions that we just marked. */ + + for (dd_p = file_p->defs_decs; dd_p; dd_p = dd_p->next_in_file) + if (dd_p->definition) + ((NONCONST def_dec_info *) dd_p->definition)->written = 0; +} + +#endif /* !defined(UNPROTOIZE) */ + +/* Do the editing operation specifically for a function "definition". Note + that editing operations for function "declarations" are handled by a + separate routine above. */ + +static void +edit_fn_definition (const def_dec_info *def_dec_p, const char *clean_text_p) +{ + const char *end_formals; + const char *function_to_edit = def_dec_p->hash_entry->symbol; + + /* 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: definition of function `%s' not converted\n", + pname, function_to_edit); + return; + } + + end_formals = find_rightmost_formals_list (clean_text_p); + + /* end_of_formals now points to the closing right paren of the rightmost + formals list which is actually part of the `header' of the function + definition that we are converting. */ + + /* If the header of this function definition looks like it declares a + function with a variable number of arguments, and if the way it does + that is different from that way we would like it (i.e. varargs vs. + stdarg) then issue a warning and leave the header unconverted. */ + + if (other_variable_style_function (def_dec_p->ansi_decl)) + { + if (!quiet_flag) + fprintf (stderr, "%s: warning: %s function definition at %s(%d) not converted\n", + pname, + other_var_style, + shortpath (NULL, def_dec_p->file->hash_entry->symbol), + identify_lineno (end_formals)); + output_up_to (end_formals); + return; + } + + if (edit_formals_lists (end_formals, def_dec_p->f_list_count, def_dec_p)) + { + restore_pointers (); + fprintf (stderr, "%s: definition of function `%s' not converted\n", + pname, function_to_edit); + return; + } + + /* Have to output the last right paren because this never gets flushed by + edit_formals_list. */ + + output_up_to (end_formals); + +#ifdef UNPROTOIZE + { + const char *decl_p; + const char *semicolon_p; + const char *limit_p; + const char *scan_p; + int had_newlines = 0; + + /* Now write out the K&R style formal declarations, one per line. */ + + decl_p = def_dec_p->formal_decls; + limit_p = decl_p + strlen (decl_p); + for (;decl_p < limit_p; decl_p = semicolon_p + 2) + { + for (semicolon_p = decl_p; *semicolon_p != ';'; semicolon_p++) + continue; + output_string ("\n"); + output_string (indent_string); + output_bytes (decl_p, (size_t) ((semicolon_p + 1) - decl_p)); + } + + /* If there are no newlines between the end of the formals list and the + start of the body, we should insert one now. */ + + for (scan_p = end_formals+1; *scan_p != '{'; ) + { + if (*scan_p == '\n') + { + had_newlines = 1; + break; + } + check_source (++scan_p < clean_text_limit, 0); + } + if (!had_newlines) + output_string ("\n"); + } +#else /* !defined(UNPROTOIZE) */ + /* If we are protoizing, there may be some flotsum & jetsum (like comments + and preprocessing directives) after the old formals list but before + the following { and we would like to preserve that stuff while effectively + deleting the existing K&R formal parameter declarations. We do so here + in a rather tricky way. Basically, we white out any stuff *except* + the comments/pp-directives in the original text buffer, then, if there + is anything in this area *other* than whitespace, we output it. */ + { + const char *end_formals_orig; + const char *start_body; + const char *start_body_orig; + const char *scan; + const char *scan_orig; + int have_flotsum = 0; + int have_newlines = 0; + + for (start_body = end_formals + 1; *start_body != '{';) + check_source (++start_body < clean_text_limit, 0); + + end_formals_orig = orig_text_base + (end_formals - clean_text_base); + start_body_orig = orig_text_base + (start_body - clean_text_base); + scan = end_formals + 1; + scan_orig = end_formals_orig + 1; + for (; scan < start_body; scan++, scan_orig++) + { + if (*scan == *scan_orig) + { + have_newlines |= (*scan_orig == '\n'); + /* Leave identical whitespace alone. */ + if (!isspace (*scan_orig)) + *((NONCONST char *)scan_orig) = ' '; /* identical - so whiteout */ + } + else + have_flotsum = 1; + } + if (have_flotsum) + output_bytes (end_formals_orig + 1, + (size_t) (start_body_orig - end_formals_orig) - 1); + else + if (have_newlines) + output_string ("\n"); + else + output_string (" "); + clean_read_ptr = start_body - 1; + } +#endif /* !defined(UNPROTOIZE) */ +} + +/* Clean up the clean text buffer. Do this by converting comments and + preprocessor directives into spaces. Also convert line continuations + into whitespace. Also, whiteout string and character literals. */ + +static void +do_cleaning (char *new_clean_text_base, char *new_clean_text_limit) +{ + char *scan_p; + int non_whitespace_since_newline = 0; + + for (scan_p = new_clean_text_base; scan_p < new_clean_text_limit; scan_p++) + { + switch (*scan_p) + { + case '/': /* Handle comments. */ + if (scan_p[1] != '*') + goto regular; + non_whitespace_since_newline = 1; + scan_p[0] = ' '; + scan_p[1] = ' '; + scan_p += 2; + while (scan_p[1] != '/' || scan_p[0] != '*') + { + if (!isspace (*scan_p)) + *scan_p = ' '; + if (++scan_p >= new_clean_text_limit) + abort (); + } + *scan_p++ = ' '; + *scan_p = ' '; + break; + + case '#': /* Handle pp directives. */ + if (non_whitespace_since_newline) + goto regular; + *scan_p = ' '; + while (scan_p[1] != '\n' || scan_p[0] == '\\') + { + if (!isspace (*scan_p)) + *scan_p = ' '; + if (++scan_p >= new_clean_text_limit) + abort (); + } + *scan_p++ = ' '; + break; + + case '\'': /* Handle character literals. */ + non_whitespace_since_newline = 1; + while (scan_p[1] != '\'' || scan_p[0] == '\\') + { + if (scan_p[0] == '\\' && !isspace (scan_p[1])) + scan_p[1] = ' '; + if (!isspace (*scan_p)) + *scan_p = ' '; + if (++scan_p >= new_clean_text_limit) + abort (); + } + *scan_p++ = ' '; + break; + + case '"': /* Handle string literals. */ + non_whitespace_since_newline = 1; + while (scan_p[1] != '"' || scan_p[0] == '\\') + { + if (scan_p[0] == '\\' && !isspace (scan_p[1])) + scan_p[1] = ' '; + if (!isspace (*scan_p)) + *scan_p = ' '; + if (++scan_p >= new_clean_text_limit) + abort (); + } + *scan_p++ = ' '; + break; + + case '\\': /* Handle line continuations. */ + if (scan_p[1] != '\n') + goto regular; + *scan_p = ' '; + break; + + case '\n': + non_whitespace_since_newline = 0; /* Reset. */ + break; + + case ' ': + case '\v': + case '\t': + case '\r': + case '\f': + case '\b': + break; /* Whitespace characters. */ + + default: +regular: + non_whitespace_since_newline = 1; + break; + } + } +} + +/* Given a pointer to the closing right parenthesis for a particular formals + list (in the clean text buffer) find the corresponding left parenthesis + and return a pointer to it. */ + +static const char * +careful_find_l_paren (const char *p) +{ + const char *q; + int paren_depth; + + for (paren_depth = 1, q = p-1; paren_depth; check_source (--q >= clean_text_base, 0)) + { + switch (*q) + { + case ')': + paren_depth++; + break; + case '(': + paren_depth--; + break; + } + } + return ++q; +} + +/* Scan the clean text buffer for cases of function definitions that we + don't really know about because they were preprocessed out when the + aux info files were created. + + In this version of protoize/unprotoize we just give a warning for each + one found. A later version may be able to at least unprotoize such + missed items. + + Note that we may easily find all function definitions simply by + looking for places where there is a left paren which is (ignoring + whitespace) immediately followed by either a left-brace or by an + upper or lower case letter. Whenever we find this combination, we + have also found a function definition header. + + Finding function *declarations* using syntactic clues is much harder. + I will probably try to do this in a later version though. */ + +static void +scan_for_missed_items (const file_info *file_p) +{ + static const char *scan_p; + const char *limit = clean_text_limit - 3; + static const char *backup_limit; + + backup_limit = clean_text_base - 1; + + for (scan_p = clean_text_base; scan_p < limit; scan_p++) + { + if (*scan_p == ')') + { + static const char *last_r_paren; + const char *ahead_p; + + last_r_paren = scan_p; + + for (ahead_p = scan_p + 1; isspace (*ahead_p); ) + check_source (++ahead_p < limit, limit); + + scan_p = ahead_p - 1; + + if (isalpha (*ahead_p) || *ahead_p == '{') + { + const char *last_l_paren; + const int lineno = identify_lineno (ahead_p); + + if (setjmp (source_confusion_recovery)) + continue; + + /* We know we have a function definition header. Now skip + leftwards over all of its associated formals lists. */ + + do + { + last_l_paren = careful_find_l_paren (last_r_paren); + for (last_r_paren = last_l_paren-1; isspace (*last_r_paren); ) + check_source (--last_r_paren >= backup_limit, backup_limit); + } + while (*last_r_paren == ')'); + + if (is_id_char (*last_r_paren)) + { + const char *id_limit = last_r_paren + 1; + const char *id_start; + size_t id_length; + const def_dec_info *dd_p; + + for (id_start = id_limit-1; is_id_char (*id_start); ) + check_source (--id_start >= backup_limit, backup_limit); + id_start++; + backup_limit = id_start; + if ((id_length = (size_t) (id_limit - id_start)) == 0) + goto not_missed; + + { + char func_name[id_length + 1]; + static const char * const stmt_keywords[] + = { "if", "while", "for", "switch", "return", 0 }; + const char * const *stmt_keyword; + + strncpy (func_name, id_start, id_length); + func_name[id_length] = '\0'; + + /* We must check here to see if we are actually looking at + a statement rather than an actual function call. */ + + for (stmt_keyword = stmt_keywords; *stmt_keyword; stmt_keyword++) + if (!strcmp (func_name, *stmt_keyword)) + goto not_missed; + +#if 0 + fprintf (stderr, "%s: found definition of `%s' at %s(%d)\n", + pname, + func_name, + shortpath (NULL, file_p->hash_entry->symbol), + identify_lineno (id_start)); +#endif /* 0 */ + /* We really should check for a match of the function name + here also, but why bother. */ + + for (dd_p = file_p->defs_decs; dd_p; dd_p = dd_p->next_in_file) + if (dd_p->is_func_def && dd_p->line == lineno) + goto not_missed; + + /* If we make it here, then we did not know about this + function definition. */ + + fprintf (stderr, "%s: warning: `%s' at %s(%d) was #if 0\n", + pname, + func_name, + shortpath (NULL, file_p->hash_entry->symbol), + identify_lineno (id_start)); + fprintf (stderr, "%s: function definition not converted\n", + pname); + } + not_missed: ; + } + } + } + } +} + +/* Do all editing operations for a single source file (either a "base" file + or an "include" file). To do this we read the file into memory, keep a + virgin copy there, make another cleaned in-core copy of the original file + (i.e. one in which all of the comments and preprocessor directives have + been replaced with whitespace), then use these two in-core copies of the + file to make a new edited in-core copy of the file. Finally, rename the + original file (as a way of saving it), and then write the edited version + of the file from core to a disk file of the same name as the original. + + Note that the trick of making a copy of the original sans comments & + preprocessor directives make the editing a whole lot easier. */ + +static void +edit_file (const hash_table_entry *hp) +{ + struct stat stat_buf; + const file_info *file_p = hp->fip; + char *new_orig_text_base; + char *new_orig_text_limit; + char *new_clean_text_base; + char *new_clean_text_limit; + size_t orig_size; + size_t repl_size; + int first_definition_in_file; + + /* If we are not supposed to be converting this file, or if there is + nothing in there which needs converting, just skip this file. */ + + if (!needs_to_be_converted (file_p)) + return; + + convert_path = file_p->hash_entry->symbol; + + /* Convert a file if it is in a directory where we want conversion + and the file is not excluded. */ + + if (!directory_specified_p (convert_path) + || file_excluded_p (convert_path)) + { + if (!quiet_flag +#ifdef UNPROTOIZE + /* Don't even mention "system" include files unless we are + protoizing. If we are protoizing, we mention these as a + gentile way of prodding the user to convert his "system" + include files to prototype format. */ + && !in_system_include_dir (convert_path) +#endif /* defined(UNPROTOIZE) */ + ) + fprintf (stderr, "%s: file `%s' not converted\n", + pname, shortpath (NULL, convert_path)); + return; + } + + /* Let the user know what we are up to. */ + + if (nochange_flag) + puts (shortpath (NULL, convert_path)); + else + { + fprintf (stderr, "%s: converting file `%s'\n", + pname, shortpath (NULL, convert_path)); + fflush (stderr); + } + + /* Find out the size (in bytes) of the original file. */ + + if (stat (convert_path, &stat_buf) == -1) + { + fprintf (stderr, "%s: error: can't get status for file `%s': %s\n", + pname, shortpath (NULL, convert_path), sys_errlist[errno]); + return; + } + orig_size = stat_buf.st_size; + + /* Allocate a buffer to hold the original text. */ + + orig_text_base = new_orig_text_base = (char *) xmalloc (orig_size + 2); + orig_text_limit = new_orig_text_limit = new_orig_text_base + orig_size; + + /* Allocate a buffer to hold the cleaned-up version of the original text. */ + + clean_text_base = new_clean_text_base = (char *) xmalloc (orig_size + 2); + clean_text_limit = new_clean_text_limit = new_clean_text_base + orig_size; + clean_read_ptr = clean_text_base - 1; + + /* Allocate a buffer that will hopefully be large enough to hold the entire + converted output text. As an initial guess for the maximum size of the + output buffer, use 125% of the size of the original + some extra. This + buffer can be expanded later as needed. */ + + repl_size = orig_size + (orig_size >> 2) + 4096; + repl_text_base = (char *) xmalloc (repl_size + 2); + repl_text_limit = repl_text_base + repl_size - 1; + repl_write_ptr = repl_text_base - 1; + + { + int input_file; + + /* Open the file to be converted in READ ONLY mode. */ + + if ((input_file = open (convert_path, O_RDONLY, 0444)) == -1) + { + fprintf (stderr, "%s: error: can't open file `%s' for reading: %s\n", + pname, shortpath (NULL, convert_path), sys_errlist[errno]); + return; + } + + /* Read the entire original source text file into the original text buffer + in one swell fwoop. Then figure out where the end of the text is and + make sure that it ends with a newline followed by a null. */ + + if (read (input_file, new_orig_text_base, orig_size) != orig_size) + { + close (input_file); + fprintf (stderr, "\n%s: error: while reading input file `%s': %s\n", + pname, shortpath (NULL, convert_path), sys_errlist[errno]); + return; + } + + close (input_file); + } + + if (orig_size == 0 || orig_text_limit[-1] != '\n') + { + *new_orig_text_limit++ = '\n'; + orig_text_limit++; + } + + /* Create the cleaned up copy of the original text. */ + + memcpy (new_clean_text_base, orig_text_base, + (size_t) (orig_text_limit - orig_text_base)); + do_cleaning (new_clean_text_base, new_clean_text_limit); + +#if 0 + { + int clean_file; + size_t clean_size = orig_text_limit - orig_text_base; + char *const clean_path = (char *) alloca (strlen (convert_path) + 6 + 1); + + /* Open (and create) the clean file. */ + + strcpy (clean_path, convert_path); + strcat (clean_path, ".clean"); + if ((clean_file = creat (clean_path, 0666)) == -1) + { + fprintf (stderr, "%s: error: can't create/open clean file `%s': %s\n", + pname, + shortpath (NULL, clean_path), + sys_errlist[errno]); + return; + } + + /* Write the clean file. */ + + if (write (clean_file, new_clean_text_base, clean_size) != clean_size) + fprintf (stderr, "%s: error: while writing file `%s': %s\n", + pname, shortpath (NULL, clean_path), sys_errlist[errno]); + + close (clean_file); + } +#endif /* 0 */ + + /* Do a simplified scan of the input looking for things that were not + mentioned in the aux info files because of the fact that they were + in a region of the source which was preprocessed-out (via #if or + via #ifdef). */ + + scan_for_missed_items (file_p); + + /* Setup to do line-oriented forward seeking in the clean text buffer. */ + + last_known_line_number = 1; + last_known_line_start = clean_text_base; + + /* Now get down to business and make all of the necessary edits. */ + + { + const def_dec_info *def_dec_p; + + first_definition_in_file = 1; + def_dec_p = file_p->defs_decs; + for (; def_dec_p; def_dec_p = def_dec_p->next_in_file) + { + const char *clean_text_p = seek_to_line (def_dec_p->line); + + /* clean_text_p now points to the first character of the line which + contains the `terminator' for the declaration or definition that + we are about to process. */ + +#ifndef UNPROTOIZE + + if (global_flag && def_dec_p->is_func_def && first_definition_in_file) + { + add_global_decls (def_dec_p->file, clean_text_p); + first_definition_in_file = 0; + } + + /* Don't edit this item if it is already in prototype format or if it + is a function declaration and we have found no corresponding + definition. */ + + if (def_dec_p->prototyped + || (!def_dec_p->is_func_def && !def_dec_p->definition)) + continue; + +#endif /* !defined(UNPROTOIZE) */ + + if (def_dec_p->is_func_def) + edit_fn_definition (def_dec_p, clean_text_p); + else +#ifndef UNPROTOIZE + if (def_dec_p->is_implicit) + add_local_decl (def_dec_p, clean_text_p); + else +#endif /* !defined(UNPROTOIZE) */ + edit_fn_declaration (def_dec_p, clean_text_p); + } + } + + /* Finalize things. Output the last trailing part of the original text. */ + + output_up_to (clean_text_limit - 1); + + /* If this is just a test run, stop now and just deallocate the buffers. */ + + if (nochange_flag) + { + free (new_orig_text_base); + free (new_clean_text_base); + free (repl_text_base); + return; + } + + /* Change the name of the original input file. This is just a quick way of + saving the original file. */ + + if (!nosave_flag) + { + char *new_path = + (char *) xmalloc (strlen (convert_path) + strlen (save_suffix) + 2); + + strcpy (new_path, convert_path); + strcat (new_path, save_suffix); + if (link (convert_path, new_path) == -1) + { + if (errno == EEXIST) + { + if (!quiet_flag) + fprintf (stderr, "%s: warning: file `%s' already saved in `%s'\n", + pname, + shortpath (NULL, convert_path), + shortpath (NULL, new_path)); + } + else + { + fprintf (stderr, "%s: error: can't link file `%s' to `%s': %s\n", + pname, + shortpath (NULL, convert_path), + shortpath (NULL, new_path), + sys_errlist[errno]); + return; + } + } + } + + if (unlink (convert_path) == -1) + { + fprintf (stderr, "%s: error: can't delete file `%s': %s\n", + pname, + shortpath (NULL, convert_path), + sys_errlist[errno]); + return; + } + + { + int output_file; + + /* Open (and create) the output file. */ + + if ((output_file = creat (convert_path, 0666)) == -1) + { + fprintf (stderr, "%s: error: can't create/open output file `%s': %s\n", + pname, + shortpath (NULL, convert_path), + sys_errlist[errno]); + return; + } + + /* Write the output file. */ + + { + unsigned int out_size = (repl_write_ptr + 1) - repl_text_base; + + if (write (output_file, repl_text_base, out_size) != out_size) + fprintf (stderr, "%s: error: while writing file `%s': %s\n", + pname, shortpath (NULL, convert_path), sys_errlist[errno]); + } + + close (output_file); + } + + /* Deallocate the conversion buffers. */ + + free (new_orig_text_base); + free (new_clean_text_base); + free (repl_text_base); + + /* Change the mode of the output file to match the original file. */ + + if (chmod (convert_path, stat_buf.st_mode) == -1) + fprintf (stderr, "%s: error: can't change mode of file `%s': %s\n", + pname, shortpath (NULL, convert_path), sys_errlist[errno]); + + /* Note: We would try to change the owner and group of the output file + to match those of the input file here, except that may not be a good + thing to do because it might be misleading. Also, it might not even + be possible to do that (on BSD systems with quotas for instance). */ +} + +/* Do all of the individual steps needed to do the protoization (or + unprotoization) of the files referenced in the aux_info files given + in the command line. */ + +static void +do_processing (void) +{ + const char * const *base_pp; + const char * const * const end_pps = &base_source_paths[base_source_files]; + +#ifndef UNPROTOIZE + int syscalls_len; +#endif /* !defined(UNPROTOIZE) */ + + /* One-by-one, check (and create if necessary), open, and read all of the + stuff in each aux_info file. After reading each aux_info file, the + aux_info_file just read will be automatically deleted unless the + keep_flag is set. */ + + for (base_pp = base_source_paths; base_pp < end_pps; base_pp++) + process_aux_info_file (*base_pp, keep_flag, 0); + +#ifndef UNPROTOIZE + + /* Also open and read the special SYSCALLS.c aux_info file which gives us + the prototypes for all of the standard system-supplied functions. */ + + if (nondefault_syscalls_dir) + { + syscalls_pathname + = (char *) xmalloc (strlen (nondefault_syscalls_dir) + + strlen (syscalls_filename) + 1); + strcpy (syscalls_pathname, nondefault_syscalls_dir); + } + else + { + syscalls_pathname + = (char *) xmalloc (strlen (default_syscalls_dir) + + strlen (syscalls_filename) + 1); + strcpy (syscalls_pathname, default_syscalls_dir); + } + + syscalls_len = strlen (syscalls_pathname); + if (*(syscalls_pathname + syscalls_len - 1) != '/') + { + *(syscalls_pathname + syscalls_len++) = '/'; + *(syscalls_pathname + syscalls_len) = '\0'; + } + strcat (syscalls_pathname, syscalls_filename); + + /* Call process_aux_info_file in such a way that it does not try to + delete the SYSCALLS aux_info file. */ + + process_aux_info_file (syscalls_pathname, 1, 1); + +#endif /* !defined(UNPROTOIZE) */ + + /* When we first read in all of the information from the aux_info files + we saved in it decending line number order, because that was likely to + be faster. Now however, we want the chains of def & dec records to + appear in ascending line number order as we get further away from the + file_info record that they hang from. The following line causes all of + these lists to be rearranged into ascending line number order. */ + + visit_each_hash_node (pathname_primary, reverse_def_dec_list); + +#ifndef UNPROTOIZE + + /* Now do the "real" work. The following line causes each declaration record + to be "visited". For each of these nodes, an attempt is made to match + up the function declaration with a corresponding function definition, + which should have a full prototype-format formals list with it. Once + these match-ups are made, the conversion of the function declarations + to prototype format can be made. */ + + visit_each_hash_node (function_name_primary, connect_defs_and_decs); + +#endif /* !defined(UNPROTOIZE) */ + + /* Now convert each file that can be converted (and needs to be). */ + + visit_each_hash_node (pathname_primary, edit_file); + +#ifndef UNPROTOIZE + + /* If we are working in cplusplus mode, try to rename all .c files to .C + files. Don't panic if some of the renames don't work. */ + + if (cplusplus_flag && !nochange_flag) + visit_each_hash_node (pathname_primary, rename_c_file); + +#endif /* !defined(UNPROTOIZE) */ +} + +static struct option longopts[] = +{ + {"version", 0, 0, 'V'}, + {"quiet", 0, 0, 'q'}, + {"silent", 0, 0, 'q'}, + {"force", 0, 0, 'f'}, + {"keep", 0, 0, 'k'}, + {"nosave", 0, 0, 'N'}, + {"nochange", 0, 0, 'n'}, + {"compiler-options", 1, 0, 'c'}, + {"exclude", 1, 0, 'x'}, + {"directory", 1, 0, 'd'}, +#ifdef UNPROTOIZE + {"indent", 1, 0, 'i'}, +#else + {"local", 0, 0, 'l'}, + {"global", 0, 0, 'g'}, + {"c++", 0, 0, 'C'}, + {"syscalls-dir", 1, 0, 'B'}, +#endif + {0, 0, 0, 0} +}; + +int +main (int argc, char **const argv) +{ + int longind; + int c; + int size; + + pname = strrchr (argv[0], '/'); + pname = pname ? pname+1 : argv[0]; + + /* Read the working directory, avoiding arbitrary limit. */ + size = 100; + while (1) + { + int value; + + cwd_buffer = (char *) xmalloc (size); + value = getcwd (cwd_buffer, size); + if (value > 0 && value < size) + break; + free (cwd_buffer); + size *= 2; + } + + /* By default, convert the files in the current directory. */ + directory_list = string_list_cons (cwd_buffer, NULL); + + while ((c = getopt_long (argc, argv, +#ifdef UNPROTOIZE + "c:d:i:knNqVx:", +#else + "B:c:Cd:gklnNqVx:", +#endif + longopts, &longind)) != EOF) + { + if (c == 0) /* Long option. */ + c = longopts[longind].val; + switch (c) + { + case 'd': + directory_list + = string_list_cons (abspath (NULL, optarg), directory_list); + break; + case 'x': + exclude_list = string_list_cons (optarg, exclude_list); + break; + + case 'V': + version_flag = 1; + break; + case 'q': + quiet_flag = 1; + break; +#if 0 + case 'f': + force_flag = 1; + break; +#endif + case 'n': + nochange_flag = 1; + keep_flag = 1; + break; + case 'N': + nosave_flag = 1; + break; + case 'k': + keep_flag = 1; + break; + case 'c': + munge_compile_params (optarg); + break; +#ifdef UNPROTOIZE + case 'i': + indent_string = optarg; + break; +#else /* !defined(UNPROTOIZE) */ + case 'l': + local_flag = 1; + break; + case 'g': + global_flag = 1; + break; + case 'C': + cplusplus_flag = 1; + break; + case 'B': + nondefault_syscalls_dir = optarg; + break; +#endif /* !defined(UNPROTOIZE) */ + default: + usage (); + } + } + + base_source_files = argc - optind; + + /* Now actually make a list of the base source pathnames. */ + + base_source_paths = + (const char **) xmalloc ((base_source_files + 1) * sizeof (char *)); + base_source_files = 0; + for (; optind < argc; optind++) + { + const char *path = abspath (NULL, argv[optind]); + int len = strlen (path); + + if (path[len-1] == 'c' && path[len-2] == '.') + base_source_paths[base_source_files++] = path; + else + { + fprintf (stderr, "%s: input pathnames must have .c suffixes: %s\n", + pname, shortpath (NULL, path)); + errors++; + } + } + +#ifndef UNPROTOIZE + /* We are only interested in the very first identifier token in the + definition of `va_list', so if there is more junk after that first + identifier token, delete it from the `varargs_style_indicator'. */ + { + const char *cp; + + for (cp = varargs_style_indicator; isalnum (*cp) || *cp == '_'; cp++) + continue; + if (*cp != 0) + varargs_style_indicator = savestring (varargs_style_indicator, + cp - varargs_style_indicator); + } +#endif /* !defined(UNPROTOIZE) */ + + if (errors) + usage (); + else + { + if (version_flag) + fprintf (stderr, "%s: %s\n", pname, version_string); + do_processing (); + } + if (errors) + exit (1); + else + exit (0); + return 1; +} -- 2.30.2