1 /* Protoize program - Written by Ron Guilmette at the Microelectronics
2 and Computer Technology Corporation (MCC). The author's current
3 E-mail address is <rfg@ncd.com>.
5 Copyright (C) 1989, 1991 Free Software Foundation, Inc.
7 This file is part of GNU CC.
9 GNU CC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GNU CC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GNU CC; see the file COPYING. If not, write to
21 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
23 /* Any reasonable C++ compiler should have all of the same features
24 as __STDC__ plus more, so make sure that __STDC__ is defined if
25 __cplusplus is defined. */
27 #if defined(__cplusplus) && !defined(__STDC__)
29 #endif /* defined(__cplusplus) && !defined(__STDC__) */
31 #if defined (__cplusplus)
32 extern "C" { /* Start of extern "C" section. */
33 #endif /* defined(__cplusplus) */
35 /* It is incorrect to include config.h here, because this file is being
36 compiled for the target, and hence definitions concerning only the host
41 /* On a POSIX system, request definition of all the POSIX facilities. */
42 /* We use TARGET_POSIX because protoize is compiled for the target system,
43 and TARGET_POSIX is the symbol that describes it in tm.h. */
51 #include <sys/types.h>
60 #ifndef PATH_MAX /* <limits.h> defines this on most POSIX systems. */
61 #include <sys/param.h>
62 #define PATH_MAX MAXPATHLEN
63 /* Sometimes <sys/param.h> defines these macros. */
83 extern char * sys_errlist
[];
85 #if defined(TARGET_POSIX)
93 /* Systems which are compatible only with POSIX 1003.1-1988 (but *not*
94 with POSIX 1003.1-1990), e.g. Ultrix 4.2, might not have
95 const qualifiers in the prototypes in the system include files.
96 Unfortunately, this can lead to GCC issuing lots of warnings for
97 calls to the following functions. To eliminate these warnings we
98 provide the following #defines. */
100 #if (_POSIX_VERSION < 199009)
102 #define access(file,flag) access((char *)file, flag)
103 #define stat(file,pkt) stat((char *)file, pkt)
104 #define execvp(prog,argv) execvp((char *)prog, (char **)argv)
105 #define link(file1, file2) link((char *)file1, (char *)file2)
106 #define unlink(file) unlink((char *)file)
107 #define open(file, mode, flag) open((char *)file, mode, flag)
108 #define chmod(file, mode) chmod((char *)file, mode)
110 #endif /* (_POSIX_VERSION < 199009) */
112 #else /* !defined(TARGET_POSIX) */
114 #define R_OK 4 /* Test for Read permission */
115 #define W_OK 2 /* Test for Write permission */
116 #define X_OK 1 /* Test for eXecute permission */
117 #define F_OK 0 /* Test for existence of File */
122 /* Virtually every UN*X system now in common use (except for pre-4.3-tahoe
123 BSD systems) now provides getcwd as called for by POSIX. Allow for
124 the few exceptions to the general rule here. */
126 #if !(defined (USG) || defined (VMS))
127 extern char *getwd (char *);
128 #define getcwd(buf,len) getwd(buf)
129 #else /* (defined (USG) || defined (VMS)) */
130 extern char *getcwd (char *, size_t);
131 #endif /* (defined (USG) || defined (VMS)) */
133 /* Declaring stat, kill or __flsbuf with a prototype
134 causes conflicts with system headers on some systems.
135 Declaring abort causes trouble if it is a macro. */
137 extern int creat (const char *, int);
138 extern int open (const char *, int, ...);
139 extern int fprintf (FILE *, const char *, ...);
140 extern int printf (const char *, ...);
141 extern void exit (int);
142 extern void *malloc (size_t);
143 extern void *realloc (void *, size_t);
144 extern void free (void *);
145 extern int read (int, void *, size_t);
146 extern int write (int, const void *, size_t);
147 extern int close (int);
148 extern int link (const char *, const char *);
149 extern int unlink (const char *);
150 extern int fflush (FILE *);
151 extern int atoi (const char *);
152 extern int access (const char *, int);
153 extern int puts (const char *);
154 extern int fputs (const char *, FILE *);
155 extern int fputc (int, FILE *);
156 extern int execvp (const char *, char *const *);
157 extern int setjmp (jmp_buf);
158 extern void longjmp (jmp_buf, int);
160 extern char * strcat(char *, const char *);
161 extern int strcmp(const char *, const char *);
162 extern char * strcpy(char *, const char *);
163 extern size_t strlen(const char *);
164 extern int strncmp(const char *, const char *, size_t);
165 extern char * strncpy(char *, const char *, size_t);
166 extern char * strrchr(const char *, int);
168 #if !(defined (USG) || defined (VMS))
169 extern int vfork (void);
171 #endif /* !(defined (USG) || defined (VMS)) */
173 #endif /* !defined(TARGET_POSIX) */
175 #if defined (__cplusplus)
176 } /* End of extern "C" section. */
177 #endif /* defined(__cplusplus) */
179 /* Look for these where the `const' qualifier is intentionally cast aside. */
183 /* Aliases for pointers to void.
184 These were made to facilitate compilation with other compilers. */
186 typedef void * pointer_type
;
187 typedef const void * const_pointer_type
;
189 /* Define a STRINGIFY macro that's right for ANSI C. */
191 #define STRINGIFY(STRING) #STRING
193 /* POSIX systems will not have definitions for WIFEXITED or WEXITSTATUS.
194 Define them correctly and so that they work for all environments. */
197 #define WIFEXITED(status_word) ((*((int *)&status_word) & 0xff) == 0x00)
200 #define WEXITSTATUS(status_word) ((*((int *)&status_word) & 0xff00) >> 8)
202 /* Define a default place to find the SYSCALLS.X file. */
204 #ifndef STD_PROTO_DIR
205 #define STD_PROTO_DIR "/usr/local/lib"
206 #endif /* !defined(STD_PROTO_DIR) */
208 /* String to identify this version. */
210 static const char * const version_string
= "Version 1.07";
212 /* Suffix of aux_info files. */
214 static const char * const aux_info_suffix
= ".X";
216 /* String to attach to pathnames for saved versions of original files. */
218 static const char * const save_suffix
= ".save";
222 /* File name of the file which contains descriptions of standard system
223 routines. Note that we never actually do anything with this file per se,
224 but we do read in its corresponding aux_info file. */
226 static const char * const syscalls_filename
= "SYSCALLS.c";
228 /* Default place to find the above file. */
230 static const char * const default_syscalls_dir
= STD_PROTO_DIR
;
232 /* Variable to hold the complete absolutized pathname of the SYSCALLS.c.X
235 static char * syscalls_pathname
;
237 #endif /* !defined(UNPROTOIZE) */
239 /* Type of the structure that holds information about macro unexpansions. */
241 struct unexpansion_struct
{
242 const char *expanded
;
243 const char *contracted
;
245 typedef struct unexpansion_struct unexpansion
;
247 /* A table of conversions that may need to be made for some (stupid) older
248 operating systems where these types are preprocessor macros rather than
249 typedefs (as they really ought to be).
251 WARNING: The contracted forms must be as small (or smaller) as the
252 expanded forms, or else havoc will ensue. */
254 static const unexpansion unexpansions
[] = {
255 { "struct _iobuf", "FILE" },
259 /* The number of "primary" slots in the hash tables for filenames and for
260 function names. This can be as big or as small as you like, except that
261 it must be a power of two. */
263 #define HASH_TABLE_SIZE (1 << 9)
265 /* Bit mask to use when computing hash values. */
267 static const int hash_mask
= (HASH_TABLE_SIZE
- 1);
269 /* Make a table of default system include directories
270 just as it is done in cccp.c. */
272 #ifndef STANDARD_INCLUDE_DIR
273 #define STANDARD_INCLUDE_DIR "/usr/include"
276 #ifndef LOCAL_INCLUDE_DIR
277 #define LOCAL_INCLUDE_DIR "/usr/local/include"
280 struct default_include
{ char *fname
; int cplusplus
; } include_defaults
[]
281 #ifdef INCLUDE_DEFAULTS
285 /* Pick up GNU C++ specific include files. */
286 { GPLUSPLUS_INCLUDE_DIR
, 1},
287 { GCC_INCLUDE_DIR
, 0},
289 /* For cross-compilation, this dir name is generated
290 automatically in Makefile.in. */
291 { CROSS_INCLUDE_DIR
, 0 },
292 #else /* not CROSS_COMPILE */
293 { LOCAL_INCLUDE_DIR
, 0},
294 /* Some systems have an extra dir of include files. */
295 #ifdef SYSTEM_INCLUDE_DIR
296 { SYSTEM_INCLUDE_DIR
, 0},
298 #ifndef NO_STANDARD_INCLUDE_DIR
299 { STANDARD_INCLUDE_DIR
, 0},
301 #endif /* not CROSS_COMPILE */
304 #endif /* no INCLUDE_DEFAULTS */
306 /* Datatype for lists of directories or filenames. */
310 struct string_list
*next
;
313 /* List of directories in which files should be converted. */
315 struct string_list
*directory_list
;
317 /* List of file names which should not be converted.
318 A file is excluded if the end of its name, following a /,
319 matches one of the names in this list. */
321 struct string_list
*exclude_list
;
323 /* The name of the other style of variable-number-of-parameters functions
324 (i.e. the style that we want to leave unconverted because we don't yet
325 know how to convert them to this style. This string is used in warning
328 /* Also define here the string that we can search for in the parameter lists
329 taken from the .X files which will unambiguously indicate that we have
330 found a varargs style function. */
333 static const char * const other_var_style
= "stdarg";
334 #else /* !defined(UNPROTOIZE) */
335 static const char * const other_var_style
= "varargs";
336 static const char * const varargs_style_indicator
= STRINGIFY(va_alist
);
337 #endif /* !defined(UNPROTOIZE) */
339 /* The following two types are used to create hash tables. In this program,
340 there are two hash tables which are used to store and quickly lookup two
341 different classes of strings. The first type of strings stored in the
342 first hash table are absolute pathnames of files which protoize needs to
343 know about. The second type of strings (stored in the second hash table)
344 are function names. It is this second class of strings which really
345 inspired the use of the hash tables, because there may be a lot of them. */
347 typedef struct hash_table_entry_struct hash_table_entry
;
349 /* Do some typedefs so that we don't have to write "struct" so often. */
351 typedef struct def_dec_info_struct def_dec_info
;
352 typedef struct file_info_struct file_info
;
353 typedef struct f_list_chain_item_struct f_list_chain_item
;
355 /* In the struct below, note that the "_info" field has two different uses
356 depending on the type of hash table we are in (i.e. either the pathnames
357 hash table or the function names hash table). In the pathnames hash table
358 the info fields of the entries point to the file_info struct which is
359 associated with each pathname (1 per pathname). In the function names
360 hash table, the info field points to the head of a singly linked list of
361 def_dec_info entries which are all defs or decs of the function whose
362 name is pointed to by the "symbol" field. Keeping all of the defs/decs
363 for a given function name on a special list specifically for that function
364 name makes it quick and easy to find out all of the important information
365 about a given (named) function. */
367 struct hash_table_entry_struct
{
368 hash_table_entry
* hash_next
; /* -> to secondary entries */
369 const char * symbol
; /* -> to the hashed string */
371 const def_dec_info
* _ddip
;
375 #define ddip _info._ddip
376 #define fip _info._fip
378 /* Define a type specifically for our two hash tables. */
380 typedef hash_table_entry hash_table
[HASH_TABLE_SIZE
];
382 /* The following struct holds all of the important information about any
383 single pathname (e.g. file) which we need to know about. */
385 struct file_info_struct
{
386 const hash_table_entry
* hash_entry
; /* -> to associated hash entry */
387 const def_dec_info
* defs_decs
; /* -> to chain of defs/decs */
388 time_t mtime
; /* Time of last modification. */
391 /* Due to the possibility that functions may return pointers to functions,
392 (which may themselves have their own parameter lists) and due to the
393 fact that returned pointers-to-functions may be of type "pointer-to-
394 function-returning-pointer-to-function" (ad nauseum) we have to keep
395 an entire chain of ANSI style formal parameter lists for each function.
397 Normally, for any given function, there will only be one formals list
398 on the chain, but you never know.
400 Note that the head of each chain of formals lists is pointed to by the
401 `f_list_chain' field of the corresponding def_dec_info record.
403 For any given chain, the item at the head of the chain is the *leftmost*
404 parameter list seen in the actual C language function declaration. If
405 there are other members of the chain, then these are linked in left-to-right
406 order from the head of the chain. */
408 struct f_list_chain_item_struct
{
409 const f_list_chain_item
* chain_next
; /* -> to next item on chain */
410 const char * formals_list
; /* -> to formals list string */
413 /* The following struct holds all of the important information about any
414 single function definition or declaration which we need to know about.
415 Note that for unprotoize we don't need to know very much because we
416 never even create records for stuff that we don't intend to convert
417 (like for instance defs and decs which are already in old K&R format
418 and "implicit" function declarations). */
420 struct def_dec_info_struct
{
421 const def_dec_info
* next_in_file
; /* -> to rest of chain for file */
422 file_info
* file
; /* -> file_info for containing file */
423 int line
; /* source line number of def/dec */
424 const char * ansi_decl
; /* -> left end of ansi decl */
425 hash_table_entry
* hash_entry
; /* -> hash entry for function name */
426 unsigned int is_func_def
; /* = 0 means this is a declaration */
427 const def_dec_info
* next_for_func
; /* -> to rest of chain for func name */
428 unsigned int f_list_count
; /* count of formals lists we expect */
429 char prototyped
; /* = 0 means already prototyped */
431 const f_list_chain_item
* f_list_chain
; /* -> chain of formals lists */
432 const def_dec_info
* definition
; /* -> def/dec containing related def */
433 char is_static
; /* = 0 means visiblilty is "extern" */
434 char is_implicit
; /* != 0 for implicit func decl's */
435 char written
; /* != 0 means written for implicit */
436 #else /* !defined(UNPROTOIZE) */
437 const char * formal_names
; /* -> to list of names of formals */
438 const char * formal_decls
; /* -> to string of formal declartions */
439 #endif /* !defined(UNPROTOIZE) */
442 /* Pointer to the tail component of the pathname by which this program was
443 invoked. Used everywhere in error and warning messages. */
445 static const char *pname
;
447 /* Error counter. Will be non-zero if we should give up at the next convenient
450 static int errors
= 0;
453 /* ??? These comments should say what the flag mean as well as the options
456 static int version_flag
= 0; /* set by -V option */
457 static int quiet_flag
= 0; /* set by -q option */
459 static int force_flag
= 0; /* set by -f option */
461 static int nochange_flag
= 0; /* set by -n option */
462 static int nosave_flag
= 0; /* set by -N option */
463 static int keep_flag
= 0; /* set by -k option */
464 static const char ** compile_params
= 0; /* set by -c option */
466 static const char *indent_string
= " "; /* set by -i option */
467 #else /* !defined(UNPROTOIZE) */
468 static int local_flag
= 0; /* set by -l option */
469 static int global_flag
= 0; /* set by -g option */
470 static int cplusplus_flag
= 0; /* set by -C option */
471 static const char* nondefault_syscalls_dir
= 0; /* set by -B option */
472 #endif /* !defined(UNPROTOIZE) */
474 /* An index into the compile_params array where we should insert the filename
475 parameter when we are ready to exec the C compiler. A zero value indicates
476 that we have not yet called munge_compile_params(). */
478 static int filename_index
= 0;
480 /* Count of command line arguments which were "filename" arguments. */
482 static int base_source_files
= 0;
484 /* Points to a malloc'ed list of pointers to all of the filenames of base
485 source files which were specified on the command line. */
487 static const char **base_source_paths
;
489 /* Line number of the line within the current aux_info file that we
490 are currently processing. Used for error messages in case the prototypes
491 info file is corrupted somehow. */
493 static int current_aux_info_lineno
;
495 /* Pointer to the name of the source file currently being converted. */
497 static const char *convert_path
;
499 /* Pointer to relative root string (taken from aux_info file) which indicates
500 where directory the user was in when he did the compilation step that
501 produced the containing aux_info file. */
503 static const char *invocation_path
;
505 /* Pointer to the base of the input buffer that holds the original text for the
506 source file currently being converted. */
508 static const char *orig_text_base
;
510 /* Pointer to the byte just beyond the end of the input buffer that holds the
511 original text for the source file currently being converted. */
513 static const char *orig_text_limit
;
515 /* Pointer to the base of the input buffer that holds the cleaned text for the
516 source file currently being converted. */
518 static const char *clean_text_base
;
520 /* Pointer to the byte just beyond the end of the input buffer that holds the
521 cleaned text for the source file currently being converted. */
523 static const char *clean_text_limit
;
525 /* Pointer to the last byte in the cleaned text buffer that we have already
526 (virtually) copied to the output buffer (or decided to ignore). */
528 static const char * clean_read_ptr
;
530 /* Pointer to the base of the output buffer that holds the replacement text
531 for the source file currently being converted. */
533 static char *repl_text_base
;
535 /* Pointer to the byte just beyond the end of the output buffer that holds the
536 replacement text for the source file currently being converted. */
538 static char *repl_text_limit
;
540 /* Pointer to the last byte which has been stored into the output buffer.
541 The next byte to be stored should be stored just past where this points
544 static char * repl_write_ptr
;
546 /* Pointer into the cleaned text buffer for the source file we are currently
547 converting. This points to the first character of the line that we last
548 did a "seek_to_line()" to (see below). */
550 static const char *last_known_line_start
;
552 /* Number of the line (in the cleaned text buffer) that we last did a
553 "seek_to_line()" to. Will be one if we just read a new source file
554 into the cleaned text buffer. */
556 static int last_known_line_number
;
558 /* The pathnames hash table. */
560 static hash_table pathname_primary
;
562 /* The function names hash table. */
564 static hash_table function_name_primary
;
566 /* The place to keep the recovery address which is used only in cases where
567 we get hopelessly confused by something in the cleaned original text. */
569 static jmp_buf source_confusion_recovery
;
571 /* A pointer to the current directory pathname (used by abspath). */
573 static char *cwd_buffer
;
575 /* A place to save the read pointer until we are sure that an individual
576 attempt at editing will succeed. */
578 static const char * saved_clean_read_ptr
;
580 /* A place to save the write pointer until we are sure that an individual
581 attempt at editing will succeed. */
583 static char * saved_repl_write_ptr
;
585 /* Forward declaration. */
587 static const char *shortpath (const char *cwd
, const char *pathname
);
589 /* Allocate some space, but check that the allocation was successful. */
592 xmalloc (size_t byte_count
)
596 if ((rv
= malloc (byte_count
)) == NULL
)
598 fprintf (stderr
, "\n%s: fatal error: can't allocate %u more bytes of memory\n",
601 return 0; /* avoid warnings */
607 /* Reallocate some space, but check that the reallocation was successful. */
610 xrealloc (pointer_type old_space
, size_t byte_count
)
614 if ((rv
= realloc (old_space
, byte_count
)) == NULL
)
616 fprintf (stderr
, "\n%s: fatal error: can't allocate %u more bytes of memory\n",
619 return 0; /* avoid warnings */
625 /* Deallocate the area pointed to by an arbitrary pointer, but first, strip
626 the `const' qualifier from it and also make sure that the pointer value
630 xfree (const_pointer_type p
)
633 free ((NONCONST pointer_type
) p
);
636 /* Make a copy of a string INPUT with size SIZE. */
639 savestring (char *input
, int size
)
641 char *output
= (char *) xmalloc (size
+ 1);
642 strcpy (output
, input
);
646 /* More 'friendly' abort that prints the line and file.
647 config.h can #define abort fancy_abort if you like that sort of thing. */
652 fprintf (stderr
, "%s: internal abort\n", pname
);
656 /* Make a duplicate of a given string in a newly allocated area. */
659 dupstr (const char *s
)
661 return strcpy ((char *) xmalloc (strlen (s
) + 1), s
);
664 /* Make a duplicate of the first N bytes of a given string in a newly
668 dupnstr (const char *s
, size_t n
)
670 char *ret_val
= strncpy ((char *) xmalloc (n
+ 1), s
, n
);
676 /* Return a pointer to the first occurance of s2 within s1 or NULL if s2
677 does not occur within s1. Assume neither s1 nor s2 are null pointers. */
680 substr (const char *s1
, const char *const s2
)
688 for (p1
= s1
, p2
= s2
; c
= *p2
; p1
++, p2
++)
698 /* Get setup to recover in case the edit we are about to do goes awry. */
703 saved_clean_read_ptr
= clean_read_ptr
;
704 saved_repl_write_ptr
= repl_write_ptr
;
707 /* Call this routine to recover our previous state whenever something looks
708 too confusing in the source code we are trying to edit. */
711 restore_pointers (void)
713 clean_read_ptr
= saved_clean_read_ptr
;
714 repl_write_ptr
= saved_repl_write_ptr
;
717 /* Return true if the given character is a legal identifier character. */
722 return (isalnum (ch
) || (ch
== '_') || (ch
== '$'));
725 /* Give a message indicating the proper way to invoke this program and then
726 exit with non-zero status. */
732 fprintf (stderr
, "%s: usage '%s [ -VqfnkN ] [ -i <istring> ] [ pathname ... ]'\n",
733 #else /* !defined(UNPROTOIZE) */
734 fprintf (stderr
, "%s: usage '%s [ -VqfnkNlgC ] [ -B <diname> ] [ pathname ... ]'\n",
735 #endif /* !defined(UNPROTOIZE) */
740 /* Return true if the given pathname (assumed to be an absolute pathname)
741 designates a file residing anywhere beneath any one of the "system"
742 include directories. */
745 in_system_include_dir (const char *path
)
747 struct default_include
*p
;
750 abort (); /* Must be an absolutized pathname. */
752 for (p
= include_defaults
; p
->fname
; p
++)
753 if (!strncmp (path
, p
->fname
, strlen (p
->fname
))
754 && path
[strlen (p
->fname
)] == '/')
760 /* Return true if the given pathname designates a file that the user has
761 read access to and for which the user has write access to the containing
765 file_could_be_converted (const char *path
)
767 char *const dir_name
= (char *) alloca (strlen (path
) + 1);
769 if (access (path
, R_OK
))
773 char *dir_last_slash
;
775 strcpy (dir_name
, path
);
776 dir_last_slash
= strrchr (dir_name
, '/');
778 *dir_last_slash
= '\0';
780 abort (); /* Should have been an absolutized pathname. */
783 if (access (path
, W_OK
))
789 /* Return true if the given pathname designates a file that we are allowed
790 to modify. Files which we should not attempt to modify are (a) "system"
791 include files, and (b) files which the user doesn't have write access to,
792 and (c) files which reside in directories which the user doesn't have
793 write access to. Unless requested to be quiet, give warnings about
794 files that we will not try to convert for one reason or another. An
795 exception is made for "system" include files, which we never try to
796 convert and for which we don't issue the usual warnings. */
799 file_normally_convertable (const char *path
)
801 char *const dir_name
= alloca (strlen (path
) + 1);
803 if (in_system_include_dir (path
))
807 char *dir_last_slash
;
809 strcpy (dir_name
, path
);
810 dir_last_slash
= strrchr (dir_name
, '/');
812 *dir_last_slash
= '\0';
814 abort (); /* Should have been an absolutized pathname. */
817 if (access (path
, R_OK
))
820 fprintf (stderr
, "%s: warning: no read access for file `%s'\n",
821 pname
, shortpath (NULL
, path
));
825 if (access (path
, W_OK
))
828 fprintf (stderr
, "%s: warning: no write access for file `%s'\n",
829 pname
, shortpath (NULL
, path
));
833 if (access (dir_name
, W_OK
))
836 fprintf (stderr
, "%s: warning: no write access for dir containing `%s'\n",
837 pname
, shortpath (NULL
, path
));
847 /* Return true if the given file_info struct refers to the special SYSCALLS.c.X
848 file. Return false otherwise. */
851 is_syscalls_file (const file_info
*fi_p
)
853 return (substr (fi_p
->hash_entry
->symbol
, syscalls_filename
) != NULL
);
856 #endif /* !defined(UNPROTOIZE) */
858 /* Check to see if this file will need to have anything done to it on this
859 run. If there is nothing in the given file which both needs conversion
860 and for which we have the necessary stuff to do the conversion, return
861 false. Otherwise, return true.
863 Note that (for protoize) it is only valid to call this function *after*
864 the connections between declarations and definitions have all been made
865 by connect_defs_and_decs(). */
868 needs_to_be_converted (const file_info
*file_p
)
870 const def_dec_info
*ddp
;
874 if (is_syscalls_file (file_p
))
877 #endif /* !defined(UNPROTOIZE) */
879 for (ddp
= file_p
->defs_decs
; ddp
; ddp
= ddp
->next_in_file
)
885 /* ... and if we a protoizing and this function is in old style ... */
887 /* ... and if this a definition or is a decl with an associated def ... */
888 && (ddp
->is_func_def
|| (!ddp
->is_func_def
&& ddp
->definition
))
890 #else /* defined(UNPROTOIZE) */
892 /* ... and if we are unprotoizing and this function is in new style ... */
895 #endif /* defined(UNPROTOIZE) */
897 /* ... then the containing file needs converting. */
902 /* Return 1 if the file name NAME is in a directory
903 that should be converted. */
906 directory_specified_p (const char *name
)
908 struct string_list
*p
;
910 for (p
= directory_list
; p
; p
= p
->next
)
911 if (!strncmp (name
, p
->name
, strlen (p
->name
))
912 && name
[strlen (p
->name
)] == '/')
918 /* Return 1 if the file named NAME should be excluded from conversion. */
921 file_excluded_p (const char *name
)
923 struct string_list
*p
;
924 int len
= strlen (name
);
926 for (p
= exclude_list
; p
; p
= p
->next
)
927 if (!strcmp (name
+ len
- strlen (p
->name
), p
->name
)
928 && name
[len
- strlen (p
->name
) - 1] == '/')
934 /* Construct a new element of a string_list.
935 STRING is the new element value, and REST holds the remaining elements. */
937 static struct string_list
*
938 string_list_cons (char *string
, struct string_list
*rest
)
940 struct string_list
*temp
= xmalloc (sizeof (struct string_list
));
946 /* ??? The GNU convention for mentioning function args in its comments
947 is to capitalize them. So change "hash_tab_p" to HASH_TAB_P below.
948 Likewise for all the other functions. */
950 /* Given a hash table, apply some function to each node in the table. The
951 table to traverse is given as the "hash_tab_p" argument, and the
952 function to be applied to each node in the table is given as "func"
956 visit_each_hash_node (const hash_table_entry
*hash_tab_p
, void (*func
) (const hash_table_entry
*))
958 const hash_table_entry
*primary
;
960 for (primary
= hash_tab_p
; primary
< &hash_tab_p
[HASH_TABLE_SIZE
]; primary
++)
963 hash_table_entry
*second
;
966 for (second
= primary
->hash_next
; second
; second
= second
->hash_next
)
971 /* Initialize all of the fields of a new hash table entry, pointed
972 to by the "p" parameter. Note that the space to hold the entry
973 is assumed to have already been allocated before this routine is
976 static hash_table_entry
*
977 add_symbol (hash_table_entry
*p
, const char *s
)
980 p
->symbol
= dupstr (s
);
986 /* Look for a particular function name or pathname in the particular
987 hash table indicated by "hash_tab_p". If the name is not in the
988 given hash table, add it. Either way, return a pointer to the
989 hash table entry for the given name. */
991 static hash_table_entry
*
992 lookup (hash_table_entry
*hash_tab_p
, const char *search_symbol
)
995 const char *search_symbol_char_p
= search_symbol
;
998 while (*search_symbol_char_p
)
999 hash_value
+= *search_symbol_char_p
++;
1000 hash_value
&= hash_mask
;
1001 p
= &hash_tab_p
[hash_value
];
1003 return add_symbol (p
, search_symbol
);
1004 if (!strcmp (p
->symbol
, search_symbol
))
1006 while (p
->hash_next
)
1009 if (!strcmp (p
->symbol
, search_symbol
))
1012 p
->hash_next
= (hash_table_entry
*) xmalloc (sizeof (hash_table_entry
));
1014 return add_symbol (p
, search_symbol
);
1017 /* Throw a def/dec record on the junk heap.
1019 Also, since we are not using this record anymore, free up all of the
1020 stuff it pointed to. */
1023 free_def_dec (def_dec_info
*p
)
1025 xfree (p
->ansi_decl
);
1029 const f_list_chain_item
* curr
;
1030 const f_list_chain_item
* next
;
1032 for (curr
= p
->f_list_chain
; curr
; curr
= next
)
1034 next
= curr
->chain_next
;
1038 #endif /* !defined(UNPROTOIZE) */
1043 /* Unexpand as many macro symbol as we can find.
1045 If the given line must be unexpanded, make a copy of it in the heap and
1046 return a pointer to the unexpanded copy. Otherwise return NULL. */
1049 unexpand_if_needed (const char *aux_info_line
)
1051 static char *line_buf
= 0;
1052 static int line_buf_size
= 0;
1053 const unexpansion
* unexp_p
;
1054 int got_unexpanded
= 0;
1056 char *copy_p
= line_buf
;
1060 line_buf_size
= 1024;
1061 line_buf
= (char *) xmalloc (line_buf_size
);
1066 /* Make a copy of the input string in line_buf, expanding as necessary. */
1068 for (s
= aux_info_line
; *s
!= '\n'; )
1070 for (unexp_p
= unexpansions
; unexp_p
->expanded
; unexp_p
++)
1072 const char *in_p
= unexp_p
->expanded
;
1073 size_t len
= strlen (in_p
);
1075 if (*s
== *in_p
&& !strncmp (s
, in_p
, len
) && !is_id_char (s
[len
]))
1077 int size
= strlen (unexp_p
->contracted
);
1079 if (copy_p
+ size
- line_buf
>= line_buf_size
)
1081 int offset
= copy_p
- line_buf
;
1083 line_buf_size
+= size
;
1084 line_buf
= (char *) xrealloc (line_buf
, line_buf_size
);
1085 copy_p
= line_buf
+ offset
;
1087 strcpy (copy_p
, unexp_p
->contracted
);
1090 /* Assume the there will not be another replacement required
1091 within the text just replaced. */
1094 goto continue_outer
;
1097 if (copy_p
- line_buf
== line_buf_size
)
1099 int offset
= copy_p
- line_buf
;
1101 line_buf
= (char *) xrealloc (line_buf
, line_buf_size
);
1102 copy_p
= line_buf
+ offset
;
1107 if (copy_p
+ 2 - line_buf
>= line_buf_size
)
1109 int offset
= copy_p
- line_buf
;
1111 line_buf
= (char *) xrealloc (line_buf
, line_buf_size
);
1112 copy_p
= line_buf
+ offset
;
1117 return (got_unexpanded
? dupstr (line_buf
) : 0);
1120 /* Return the absolutized pathname for the given relative
1121 pathname. Note that if that pathname is already absolute, it may
1122 still be returned in a modified form because this routine also
1123 eliminates redundant slashes and single dots and eliminates double
1124 dots to get a shortest possible pathname from the given input
1125 pathname. The absolutization of relative pathnames is made by
1126 assuming that the given pathname is to be taken as relative to
1127 the first argument (cwd) or to the current directory if cwd is
1131 abspath (const char *cwd
, const char *rel_pathname
)
1133 /* Setup the current working directory as needed. */
1134 const char *cwd2
= (cwd
) ? cwd
: cwd_buffer
;
1135 char *const abs_buffer
1136 = (char *) alloca (strlen (cwd2
) + strlen (rel_pathname
) + 1);
1137 char *endp
= abs_buffer
;
1140 /* Copy the pathname (possibly preceeded by the current working
1141 directory name) into the absolutization buffer. */
1146 if (rel_pathname
[0] != '/')
1149 while (*endp
++ = *src_p
++)
1151 *(endp
-1) = '/'; /* overwrite null */
1153 src_p
= rel_pathname
;
1154 while (*endp
++ = *src_p
++)
1156 if (endp
[-1] == '/')
1160 /* Now make a copy of abs_buffer into abs_buffer, shortening the
1161 pathname (by taking out slashes and dots) as we go. */
1163 outp
= inp
= abs_buffer
;
1164 *outp
++ = *inp
++; /* copy first slash */
1169 else if (inp
[0] == '/' && outp
[-1] == '/')
1174 else if (inp
[0] == '.' && outp
[-1] == '/')
1178 else if (inp
[1] == '/')
1183 else if ((inp
[1] == '.') && (inp
[2] == 0 || inp
[2] == '/'))
1185 inp
+= (inp
[2] == '/') ? 3 : 2;
1187 while (outp
>= abs_buffer
&& *outp
!= '/')
1189 if (outp
< abs_buffer
)
1191 /* Catch cases like /.. where we try to backup to a
1192 point above the absolute root of the logical file
1195 fprintf (stderr
, "%s: fatal error: invalid pathname: %s\n",
1196 pname
, rel_pathname
);
1206 /* On exit, make sure that there is a trailing null, and make sure that
1207 the last character of the returned string is *not* a slash. */
1210 if (outp
[-1] == '/')
1213 /* Make a copy (in the heap) of the stuff left in the absolutization
1214 buffer and return a pointer to the copy. */
1216 return dupstr (abs_buffer
);
1219 /* Given a pathname (and possibly a directory name from which the pathname
1220 is relative) return a string which is the shortest possible
1221 equivalent for the corresponding full (absolutized) pathname. The
1222 shortest possible equivalent may be constructed by converting the
1223 absolutized pathname to be a relative pathname (i.e. relative to
1224 the actual current working directory). However if a relative pathname
1225 is longer, then the full absolute pathname is returned.
1229 Note that "simple-minded" conversion of any given type of pathname (either
1230 relative or absolute) may not result in a valid equivalent pathname if any
1231 subpart of the original pathname is actually a symbolic link. */
1234 shortpath (const char *cwd
, const char *pathname
)
1238 char *cwd_p
= cwd_buffer
;
1240 int unmatched_slash_count
= 0;
1242 path_p
= abspath (cwd
, pathname
);
1243 rel_buf_p
= rel_buffer
= (char *) xmalloc (strlen (path_p
) + 1);
1245 while (*cwd_p
&& (*cwd_p
== *path_p
))
1250 if (!*cwd_p
) /* whole pwd matched */
1252 if (!*path_p
) /* input *is* the current path! */
1263 while (*cwd_p
!= '/') /* backup to last slash */
1270 unmatched_slash_count
++;
1273 if (*cwd_p
++ == '/')
1274 unmatched_slash_count
++;
1275 while (unmatched_slash_count
--)
1281 while (*rel_buf_p
++ = *path_p
++)
1284 if (*(rel_buf_p
-1) == '/')
1285 *--rel_buf_p
= '\0';
1286 if (strlen (rel_buffer
) > strlen (pathname
))
1287 strcpy (rel_buffer
, pathname
);
1291 return 0; /* Prevent warnings for old versions of GCC. */
1294 /* Lookup the given pathname in the hash table for pathnames. If it is a
1295 new one, then the hash table info pointer will be null. In this case,
1296 we create a new file_info record to go with the pathname, and we initialize
1297 that record with some reasonable values. */
1300 find_file (const char *pathname
, int do_not_stat
)
1302 hash_table_entry
*hash_entry_p
;
1304 hash_entry_p
= lookup (pathname_primary
, pathname
);
1305 if (hash_entry_p
->fip
)
1306 return hash_entry_p
->fip
;
1309 struct stat stat_buf
;
1310 file_info
*file_p
= (file_info
*) xmalloc (sizeof (file_info
));
1312 /* If we cannot get status on any given source file, give a warning
1313 and then just set its time of last modification to infinity. */
1316 stat_buf
.st_mtime
= (time_t) 0;
1319 if (stat (pathname
, &stat_buf
) == -1)
1321 fprintf (stderr
, "%s: error: can't get status of `%s': %s\n",
1322 pname
, shortpath (NULL
, pathname
), sys_errlist
[errno
]);
1323 stat_buf
.st_mtime
= (time_t) -1;
1327 hash_entry_p
->fip
= file_p
;
1328 file_p
->hash_entry
= hash_entry_p
;
1329 file_p
->defs_decs
= NULL
;
1330 file_p
->mtime
= stat_buf
.st_mtime
;
1335 /* Generate a fatal error because some part of the aux_info file is
1339 aux_info_corrupted (void)
1341 fprintf (stderr
, "\n%s: fatal error: aux info file corrupted at line %d\n",
1342 pname
, current_aux_info_lineno
);
1346 /* ??? This comment is vague. Say what the condition is for. */
1347 /* Check to see that a condition is true. This is kind of like an assert(). */
1350 check_aux_info (int cond
)
1353 aux_info_corrupted ();
1356 /* Given a pointer to the closing right parenthesis for a particular formals
1357 list (in a aux_info file) find the corresponding left parenthesis and
1358 return a pointer to it. */
1361 find_corresponding_lparen (const char *p
)
1366 for (paren_depth
= 1, q
= p
-1; paren_depth
; q
--)
1381 /* Given a line from an aux info file, and a time at which the aux info
1382 file it came from was created, check to see if the item described in
1383 the line comes from a file which has been modified since the aux info
1384 file was created. If so, return non-zero, else return zero. */
1387 referenced_file_is_newer (const char *l
, time_t aux_info_mtime
)
1393 check_aux_info (l
[0] == '/');
1394 check_aux_info (l
[1] == '*');
1395 check_aux_info (l
[2] == ' ');
1398 const char *filename_start
= p
= l
+ 3;
1402 filename
= (char *) alloca ((size_t) (p
- filename_start
) + 1);
1403 strncpy (filename
, filename_start
, (size_t) (p
- filename_start
));
1404 filename
[p
-filename_start
] = '\0';
1407 /* Call find_file to find the file_info record associated with the file
1408 which contained this particular def or dec item. Note that this call
1409 may cause a new file_info record to be created if this is the first time
1410 that we have ever known about this particular file. */
1412 fi_p
= find_file (abspath (invocation_path
, filename
), 0);
1414 return (fi_p
->mtime
> aux_info_mtime
);
1417 /* Given a line of info from the aux_info file, create a new
1418 def_dec_info record to remember all of the important information about
1419 a function definition or declaration.
1421 Link this record onto the list of such records for the particular file in
1422 which it occured in proper (descending) line number order (for now).
1424 If there is an identical record already on the list for the file, throw
1425 this one away. Doing so takes care of the (useless and troublesome)
1426 duplicates which are bound to crop up due to multiple inclusions of any
1427 given individual header file.
1429 Finally, link the new def_dec record onto the list of such records
1430 pertaining to this particular function name. */
1433 save_def_or_dec (const char *l
, int is_syscalls
)
1436 const char *semicolon_p
;
1437 def_dec_info
*def_dec_p
= (def_dec_info
*) xmalloc (sizeof (def_dec_info
));
1440 def_dec_p
->written
= 0;
1441 #endif /* !defined(UNPROTOIZE) */
1443 /* Start processing the line by picking off 5 pieces of information from
1444 the left hand end of the line. These are filename, line number,
1445 new/old/implicit flag (new = ANSI prototype format), definition or
1446 declaration flag, and extern/static flag). */
1448 check_aux_info (l
[0] == '/');
1449 check_aux_info (l
[1] == '*');
1450 check_aux_info (l
[2] == ' ');
1453 const char *filename_start
= p
= l
+ 3;
1458 filename
= (char *) alloca ((size_t) (p
- filename_start
) + 1);
1459 strncpy (filename
, filename_start
, (size_t) (p
- filename_start
));
1460 filename
[p
-filename_start
] = '\0';
1462 /* Call find_file to find the file_info record associated with the file
1463 which contained this particular def or dec item. Note that this call
1464 may cause a new file_info record to be created if this is the first time
1465 that we have ever known about this particular file.
1467 Note that we started out by forcing all of the base source file pathnames
1468 (i.e. the names of the aux_info files with the .X stripped off) into the
1469 pathnames hash table, and we simultaneously setup file_info records for
1470 all of these base file pathnames (even if they may be useless later).
1471 The file_info records for all of these "base" file pathnames (properly)
1472 act as file_info records for the "original" (i.e. un-included) files
1473 which were submitted to gcc for compilation (when the -fgen-aux-info
1474 option was used). */
1476 def_dec_p
->file
= find_file (abspath (invocation_path
, filename
), is_syscalls
);
1480 const char *line_number_start
= ++p
;
1481 char line_number
[10];
1485 strncpy (line_number
, line_number_start
, (size_t) (p
- line_number_start
));
1486 line_number
[p
-line_number_start
] = '\0';
1487 def_dec_p
->line
= atoi (line_number
);
1490 /* Check that this record describes a new-style, old-style, or implicit
1491 definition or declaration. */
1493 p
++; /* Skip over the `:'. */
1494 check_aux_info ((*p
== 'N') || (*p
== 'O') || (*p
== 'I'));
1496 /* Is this a new style (ANSI prototyped) definition or declaration? */
1498 def_dec_p
->prototyped
= (*p
== 'N');
1502 /* Is this an implicit declaration? */
1504 def_dec_p
->is_implicit
= (*p
== 'I');
1506 #endif /* !defined(UNPROTOIZE) */
1510 check_aux_info ((*p
== 'C') || (*p
== 'F'));
1512 /* Is this item a function definition (F) or a declaration (C). Note that
1513 we treat item taken from the syscalls file as though they were function
1514 definitions regardless of what the stuff in the file says. */
1516 def_dec_p
->is_func_def
= ((*p
++ == 'F') || is_syscalls
);
1519 def_dec_p
->definition
= 0; /* Fill this in later if protoizing. */
1520 #endif /* !defined(UNPROTOIZE) */
1522 check_aux_info (*p
++ == ' ');
1523 check_aux_info (*p
++ == '*');
1524 check_aux_info (*p
++ == '/');
1525 check_aux_info (*p
++ == ' ');
1528 check_aux_info ((!strncmp (p
, "static", 6)) || (!strncmp (p
, "extern", 6)));
1529 #else /* !defined(UNPROTOIZE) */
1530 if (!strncmp (p
, "static", 6))
1531 def_dec_p
->is_static
= -1;
1532 else if (!strncmp (p
, "extern", 6))
1533 def_dec_p
->is_static
= 0;
1535 check_aux_info (0); /* Didn't find either `extern' or `static'. */
1536 #endif /* !defined(UNPROTOIZE) */
1539 const char *ansi_start
= p
;
1541 p
+= 6; /* Pass over the "static" or "extern". */
1543 /* We are now past the initial stuff. Search forward from here to find
1544 the terminating semicolon that should immediately follow the entire
1545 ANSI format function declaration. */
1552 /* Make a copy of the ansi declaration part of the line from the aux_info
1555 def_dec_p
->ansi_decl
1556 = dupnstr (ansi_start
, (size_t) ((semicolon_p
+1) - ansi_start
));
1559 /* Backup and point at the final right paren of the final argument list. */
1563 /* Now isolate a whole set of formal argument lists, one-by-one. Normally,
1564 there will only be one list to isolate, but there could be more. */
1566 def_dec_p
->f_list_count
= 0;
1569 def_dec_p
->f_list_chain
= NULL
;
1570 #endif /* !defined(UNPROTOIZE) */
1574 const char *left_paren_p
= find_corresponding_lparen (p
);
1577 f_list_chain_item
*cip
=
1578 (f_list_chain_item
*) xmalloc (sizeof (f_list_chain_item
));
1581 = dupnstr (left_paren_p
+ 1, (size_t) (p
- (left_paren_p
+1)));
1583 /* Add the new chain item at the head of the current list. */
1585 cip
->chain_next
= def_dec_p
->f_list_chain
;
1586 def_dec_p
->f_list_chain
= cip
;
1588 #endif /* !defined(UNPROTOIZE) */
1589 def_dec_p
->f_list_count
++;
1591 p
= left_paren_p
- 2;
1593 /* p must now point either to another right paren, or to the last
1594 character of the name of the function that was declared/defined.
1595 If p points to another right paren, then this indicates that we
1596 are dealing with multiple formals lists. In that case, there
1597 really should be another right paren preceeding this right paren. */
1602 check_aux_info (*--p
== ')');
1607 const char *past_fn
= p
+ 1;
1609 check_aux_info (*past_fn
== ' ');
1611 /* Scan leftwards over the identifier that names the function. */
1613 while (is_id_char (*p
))
1617 /* p now points to the leftmost character of the function name. */
1620 char fn_string
[past_fn
- p
+ 1];
1622 strncpy (fn_string
, p
, (size_t) (past_fn
- p
));
1623 fn_string
[past_fn
-p
] = '\0';
1624 def_dec_p
->hash_entry
= lookup (function_name_primary
, fn_string
);
1628 /* Look at all of the defs and decs for this function name that we have
1629 collected so far. If there is already one which is at the same
1630 line number in the same file, then we can discard this new def_dec_info
1633 As an extra assurance that any such pair of (nominally) identical
1634 function declarations are in fact identical, we also compare the
1635 ansi_decl parts of the lines from the aux_info files just to be on
1638 This comparison will fail if (for instance) the user was playing
1639 messy games with the preprocessor which ultimately causes one
1640 function declaration in one header file to look differently when
1641 that file is included by two (or more) other files. */
1644 const def_dec_info
*other
;
1646 for (other
= def_dec_p
->hash_entry
->ddip
; other
; other
= other
->next_for_func
)
1648 if (def_dec_p
->line
== other
->line
&& def_dec_p
->file
== other
->file
)
1650 if (strcmp (def_dec_p
->ansi_decl
, other
->ansi_decl
))
1652 fprintf (stderr
, "%s: error: declaration of function `%s' at %s(%d) takes different forms\n",
1654 def_dec_p
->hash_entry
->symbol
,
1655 def_dec_p
->file
->hash_entry
->symbol
,
1659 free_def_dec (def_dec_p
);
1667 /* If we are doing unprotoizing, we must now setup the pointers that will
1668 point to the K&R name list and to the K&R argument declarations list.
1670 Note that if this is only a function declaration, then we should not
1671 expect to find any K&R style formals list following the ANSI-style
1672 formals list. This is because GCC knows that such information is
1673 useless in the case of function declarations (function definitions
1674 are a different story however).
1676 Since we are unprotoizing, we don't need any such lists anyway.
1677 All we plan to do is to delete all characters between ()'s in any
1680 def_dec_p
->formal_names
= NULL
;
1681 def_dec_p
->formal_decls
= NULL
;
1683 if (def_dec_p
->is_func_def
)
1686 check_aux_info (*++p
== ' ');
1687 check_aux_info (*++p
== '/');
1688 check_aux_info (*++p
== '*');
1689 check_aux_info (*++p
== ' ');
1690 check_aux_info (*++p
== '(');
1693 const char *kr_names_start
= ++p
; /* Point just inside '('. */
1697 p
--; /* point to closing right paren */
1699 /* Make a copy of the K&R parameter names list. */
1701 def_dec_p
->formal_names
1702 = dupnstr (kr_names_start
, (size_t) (p
- kr_names_start
));
1705 check_aux_info (*++p
== ' ');
1708 /* p now points to the first character of the K&R style declarations
1709 list (if there is one) or to the star-slash combination that ends
1710 the comment in which such lists get embedded. */
1712 /* Make a copy of the K&R formal decls list and set the def_dec record
1715 if (*p
== '*') /* Are there no K&R declarations? */
1717 check_aux_info (*++p
== '/');
1718 def_dec_p
->formal_decls
= "";
1722 const char *kr_decls_start
= p
;
1724 while (p
[0] != '*' || p
[1] != '/')
1728 check_aux_info (*p
== ' ');
1730 def_dec_p
->formal_decls
1731 = dupnstr (kr_decls_start
, (size_t) (p
- kr_decls_start
));
1734 /* Handle a special case. If we have a function definition marked as
1735 being in "old" style, and if it's formal names list is empty, then
1736 it may actually have the string "void" in its real formals list
1737 in the original source code. Just to make sure, we will get setup
1738 to convert such things anyway.
1740 This kludge only needs to be here because of an insurmountable
1741 problem with generating .X files. */
1743 if (!def_dec_p
->prototyped
&& !*def_dec_p
->formal_names
)
1744 def_dec_p
->prototyped
= 1;
1747 /* Since we are unprotoizing, if this item is already in old (K&R) style,
1748 we can just ignore it. If that is true, throw away the itme now. */
1750 if (!def_dec_p
->prototyped
)
1752 free_def_dec (def_dec_p
);
1756 #endif /* defined(UNPROTOIZE) */
1758 /* Add this record to the head of the list of records pertaining to this
1759 particular function name. */
1761 def_dec_p
->next_for_func
= def_dec_p
->hash_entry
->ddip
;
1762 def_dec_p
->hash_entry
->ddip
= def_dec_p
;
1764 /* Add this new def_dec_info record to the sorted list of def_dec_info
1765 records for this file. Note that we don't have to worry about duplicates
1766 (caused by multiple inclusions of header files) here because we have
1767 already eliminated duplicates above. */
1769 if (!def_dec_p
->file
->defs_decs
)
1771 def_dec_p
->file
->defs_decs
= def_dec_p
;
1772 def_dec_p
->next_in_file
= NULL
;
1776 int line
= def_dec_p
->line
;
1777 const def_dec_info
*prev
= NULL
;
1778 const def_dec_info
*curr
= def_dec_p
->file
->defs_decs
;
1779 const def_dec_info
*next
= curr
->next_in_file
;
1781 while (next
&& (line
< curr
->line
))
1785 next
= next
->next_in_file
;
1787 if (line
>= curr
->line
)
1789 def_dec_p
->next_in_file
= curr
;
1791 ((NONCONST def_dec_info
*) prev
)->next_in_file
= def_dec_p
;
1793 def_dec_p
->file
->defs_decs
= def_dec_p
;
1795 else /* assert (next == NULL); */
1797 ((NONCONST def_dec_info
*) curr
)->next_in_file
= def_dec_p
;
1798 /* assert (next == NULL); */
1799 def_dec_p
->next_in_file
= next
;
1804 /* Rewrite the options list used to recompile base source files. All we are
1805 really doing here is removing -g, -O, -S, -c, and -o options, and then
1806 adding a final group of options like '-fgen-aux-info -S -o /dev/null'. */
1809 munge_compile_params (const char *params_list
)
1811 const char *temp_params
[strlen (params_list
) + 10];
1812 int param_count
= 0;
1815 temp_params
[param_count
++] = "gcc";
1818 while (isspace (*params_list
))
1822 param
= params_list
;
1823 while (*params_list
&& !isspace (*params_list
))
1825 if (param
[0] != '-')
1826 temp_params
[param_count
++]
1827 = dupnstr (param
, (size_t) (params_list
- param
));
1836 break; /* Don't copy these. */
1838 while (isspace (*params_list
))
1840 while (*params_list
&& !isspace (*params_list
))
1844 temp_params
[param_count
++]
1845 = dupnstr (param
, (size_t) (params_list
- param
));
1851 temp_params
[param_count
++] = "-fgen-aux-info";
1852 temp_params
[param_count
++] = "-S";
1853 temp_params
[param_count
++] = "-o";
1854 temp_params
[param_count
++] = "/dev/null";
1856 /* Leave room for the filename argument and a terminating null pointer. */
1858 temp_params
[filename_index
= param_count
++] = NULL
;
1859 temp_params
[param_count
++] = NULL
;
1861 /* Make a copy of the compile_params in heap space. */
1863 compile_params
= xmalloc (sizeof (char *) * (param_count
+1));
1864 memcpy (compile_params
, temp_params
, sizeof (char *) * param_count
);
1867 /* Do a recompilation for the express purpose of generating a new aux_info
1868 file to go with a specific base source file. */
1871 gen_aux_info_file (const char *base_pathname
)
1875 if (!filename_index
)
1876 munge_compile_params ("");
1878 compile_params
[filename_index
] = shortpath (NULL
, base_pathname
);
1881 fprintf (stderr
, "%s: compiling `%s'\n",
1882 pname
, compile_params
[filename_index
]);
1884 if (child_pid
= fork ())
1886 if (child_pid
== -1)
1888 fprintf (stderr
, "%s: error: could not fork process: %s\n",
1889 pname
, sys_errlist
[errno
]);
1894 /* Print out the command line that the other process is now executing. */
1900 fputs ("\t", stderr
);
1901 for (arg
= compile_params
; *arg
; arg
++)
1903 fputs (*arg
, stderr
);
1904 fputc (' ', stderr
);
1906 fputc ('\n', stderr
);
1914 if (wait (&wait_status
) == -1)
1916 fprintf (stderr
, "%s: error: wait for process failed: %s\n",
1917 pname
, sys_errlist
[errno
]);
1920 if (!WIFEXITED (wait_status
))
1922 kill (child_pid
, 9);
1925 return (WEXITSTATUS (wait_status
) == 0) ? 1 : 0;
1930 if (execvp (compile_params
[0], (char *const *) compile_params
))
1932 fprintf (stderr
, "%s: error: execvp returned: %s\n",
1933 pname
, sys_errlist
[errno
]);
1936 return 1; /* Never executed. */
1940 /* Read in all of the information contained in a single aux_info file.
1941 Save all of the important stuff for later. */
1944 process_aux_info_file (const char *base_source_pathname
, int keep_it
, int is_syscalls
)
1946 char *const aux_info_pathname
1947 = (char *) alloca (strlen (base_source_pathname
)
1948 + strlen (aux_info_suffix
) + 1);
1949 char *aux_info_base
;
1950 char *aux_info_limit
;
1951 const char *aux_info_second_line
;
1952 time_t aux_info_mtime
;
1953 size_t aux_info_size
;
1955 /* Construct the aux_info pathname from the base source pathname. */
1957 strcpy (aux_info_pathname
, base_source_pathname
);
1958 strcat (aux_info_pathname
, aux_info_suffix
);
1960 /* Check that the aux_info file exists and is readable. If it does not
1961 exist, try to create it (once only). */
1969 if (access (aux_info_pathname
, R_OK
) == -1)
1971 if (errno
== ENOENT
&& retries
== 0)
1975 fprintf (stderr
, "%s: warning: missing SYSCALLS file `%s'\n",
1976 pname
, aux_info_pathname
);
1979 if (!gen_aux_info_file (base_source_pathname
))
1986 fprintf (stderr
, "%s: error: can't read aux info file `%s': %s\n",
1987 pname
, shortpath (NULL
, aux_info_pathname
), sys_errlist
[errno
]);
1995 struct stat stat_buf
;
1997 /* Get some status information about this aux_info file. */
1999 if (stat (aux_info_pathname
, &stat_buf
) == -1)
2001 fprintf (stderr
, "%s: error: can't get status of aux info file `%s': %s\n",
2002 pname
, shortpath (NULL
, aux_info_pathname
), sys_errlist
[errno
]);
2007 /* Check on whether or not this aux_info file is zero length. If it is,
2008 then just ignore it and return. */
2010 if ((aux_info_size
= stat_buf
.st_size
) == 0)
2013 /* Get the date/time of last modification for this aux_info file and
2014 remember it. We will have to check that any source files that it
2015 contains information about are at least this old or older. */
2017 aux_info_mtime
= stat_buf
.st_mtime
;
2023 /* Open the aux_info file. */
2025 if ((aux_info_file
= open (aux_info_pathname
, O_RDONLY
, 0444 )) == -1)
2027 fprintf (stderr
, "%s: error: can't open aux info file `%s' for reading: %s\n",
2028 pname
, shortpath (NULL
, aux_info_pathname
), sys_errlist
[errno
]);
2032 /* Allocate space to hold the aux_info file in memory. */
2034 aux_info_base
= xmalloc (aux_info_size
+ 1);
2035 aux_info_limit
= aux_info_base
+ aux_info_size
;
2036 *aux_info_limit
= '\0';
2038 /* Read the aux_info file into memory. */
2040 if (read (aux_info_file
, aux_info_base
, aux_info_size
) != aux_info_size
)
2042 fprintf (stderr
, "%s: error: while reading aux info file `%s': %s\n",
2043 pname
, shortpath (NULL
, aux_info_pathname
), sys_errlist
[errno
]);
2044 free (aux_info_base
);
2045 close (aux_info_file
);
2049 /* Close the aux info file. */
2051 if (close (aux_info_file
))
2053 fprintf (stderr
, "%s: error: while closing aux info file `%s': %s\n",
2054 pname
, shortpath (NULL
, aux_info_pathname
), sys_errlist
[errno
]);
2055 free (aux_info_base
);
2056 close (aux_info_file
);
2061 /* Delete the aux_info file (unless requested not to). If the deletion
2062 fails for some reason, don't even worry about it. */
2065 if (unlink (aux_info_pathname
) == -1)
2066 fprintf (stderr
, "%s: error: can't delete aux info file `%s': %s\n",
2067 pname
, shortpath (NULL
, aux_info_pathname
), sys_errlist
[errno
]);
2069 /* Save a pointer into the first line of the aux_info file which
2070 contains the pathname of the directory from which the compiler
2071 was invoked when the associated source file was compiled.
2072 This information is used later to help create complete
2073 pathnames out of the (potentially) relative pathnames in
2074 the aux_info file. */
2077 char *p
= aux_info_base
;
2084 invocation_path
= p
; /* Save a pointer to first byte of path. */
2089 while (*p
++ != '\n')
2091 aux_info_second_line
= p
;
2096 const char *aux_info_p
;
2098 /* Do a pre-pass on the lines in the aux_info file, making sure that all
2099 of the source files referenced in there are at least as old as this
2100 aux_info file itself. If not, go back and regenerate the aux_info
2101 file anew. Don't do any of this for the syscalls file. */
2105 current_aux_info_lineno
= 2;
2107 for (aux_info_p
= aux_info_second_line
; *aux_info_p
; )
2109 if (referenced_file_is_newer (aux_info_p
, aux_info_mtime
))
2111 free (aux_info_base
);
2112 if (unlink (aux_info_pathname
) == -1)
2114 fprintf (stderr
, "%s: error: can't delete file `%s': %s\n",
2116 shortpath (NULL
, aux_info_pathname
),
2117 sys_errlist
[errno
]);
2123 /* Skip over the rest of this line to start of next line. */
2125 while (*aux_info_p
!= '\n')
2128 current_aux_info_lineno
++;
2132 /* Now do the real pass on the aux_info lines. Save their information in
2133 the in-core data base. */
2135 current_aux_info_lineno
= 2;
2137 for (aux_info_p
= aux_info_second_line
; *aux_info_p
;)
2139 char *unexpanded_line
= unexpand_if_needed (aux_info_p
);
2141 if (unexpanded_line
)
2143 save_def_or_dec (unexpanded_line
, is_syscalls
);
2144 free (unexpanded_line
);
2147 save_def_or_dec (aux_info_p
, is_syscalls
);
2149 /* Skip over the rest of this line and get to start of next line. */
2151 while (*aux_info_p
!= '\n')
2154 current_aux_info_lineno
++;
2158 free (aux_info_base
);
2163 /* Check an individual filename for a .c suffix. If the filename has this
2164 suffix, rename the file such that its suffix is changed to .C. This
2165 function implements the -C option. */
2168 rename_c_file (const hash_table_entry
*hp
)
2170 const char *pathname
= hp
->symbol
;
2171 int last_char_index
= strlen (pathname
) - 1;
2172 char *const new_pathname
= (char *) alloca (strlen (pathname
) + 1);
2174 /* Note that we don't care here if the given file was converted or not. It
2175 is possible that the given file was *not* converted, simply because there
2176 was nothing in it which actually required conversion. Even in this case,
2177 we want to do the renaming. Note that we only rename files with the .c
2180 if (pathname
[last_char_index
] != 'c' || pathname
[last_char_index
-1] != '.')
2183 strcpy (new_pathname
, pathname
);
2184 new_pathname
[last_char_index
] = 'C';
2186 if (link (pathname
, new_pathname
) == -1)
2188 fprintf (stderr
, "%s: warning: can't link file `%s' to `%s': %s\n",
2189 pname
, shortpath (NULL
, pathname
),
2190 shortpath (NULL
, new_pathname
), sys_errlist
[errno
]);
2195 if (unlink (pathname
) == -1)
2197 fprintf (stderr
, "%s: warning: can't delete file `%s': %s\n",
2198 pname
, shortpath (NULL
, pathname
), sys_errlist
[errno
]);
2204 #endif /* !defined(UNPROTOIZE) */
2206 /* Take the list of definitions and declarations attached to a particular
2207 file_info node and reverse the order of the list. This should get the
2208 list into an order such that the item with the lowest associated line
2209 number is nearest the head of the list. When these lists are originally
2210 built, they are in the opposite order. We want to traverse them in
2211 normal line number order later (i.e. lowest to highest) so reverse the
2215 reverse_def_dec_list (const hash_table_entry
*hp
)
2217 file_info
*file_p
= hp
->fip
;
2218 const def_dec_info
*prev
= NULL
;
2219 const def_dec_info
*current
= file_p
->defs_decs
;
2221 if (!( current
= file_p
->defs_decs
))
2222 return; /* no list to reverse */
2225 if (! (current
= current
->next_in_file
))
2226 return; /* can't reverse a single list element */
2228 ((NONCONST def_dec_info
*) prev
)->next_in_file
= NULL
;
2232 const def_dec_info
*next
= current
->next_in_file
;
2234 ((NONCONST def_dec_info
*) current
)->next_in_file
= prev
;
2239 file_p
->defs_decs
= prev
;
2244 /* Find the (only?) extern definition for a particular function name, starting
2245 from the head of the linked list of entries for the given name. If we
2246 cannot find an extern definition for the given function name, issue a
2247 warning and scrounge around for the next best thing, i.e. an extern
2248 function declaration with a prototype attached to it. Note that we only
2249 allow such substitutions for extern declarations and never for static
2250 declarations. That's because the only reason we allow them at all is
2251 to let un-prototyped function declarations for system-supplied library
2252 functions get their prototypes from our own extra SYSCALLS.c.X file which
2253 contains all of the correct prototypes for system functions. */
2255 static const def_dec_info
*
2256 find_extern_def (const def_dec_info
*head
, const def_dec_info
*user
)
2258 const def_dec_info
*dd_p
;
2259 const def_dec_info
*extern_def_p
= NULL
;
2260 int conflict_noted
= 0;
2262 /* Don't act too stupid here. Somebody may try to convert an entire system
2263 in one swell fwoop (rather than one program at a time, as should be done)
2264 and in that case, we may find that there are multiple extern definitions
2265 of a given function name in the entire set of source files that we are
2266 converting. If however one of these definitions resides in exactly the
2267 same source file as the reference we are trying to satisfy then in that
2268 case it would be stupid for us to fail to realize that this one definition
2269 *must* be the precise one we are looking for.
2271 To make sure that we don't miss an opportunity to make this "same file"
2272 leap of faith, we do a prescan of the list of records relating to the
2273 given function name, and we look (on this first scan) *only* for a
2274 definition of the function which is in the same file as the reference
2275 we are currently trying to satisfy. */
2277 for (dd_p
= head
; dd_p
; dd_p
= dd_p
->next_for_func
)
2278 if (dd_p
->is_func_def
&& !dd_p
->is_static
&& dd_p
->file
== user
->file
)
2281 /* Now, since we have not found a definition in the same file as the
2282 reference, we scan the list again and consider all possibilities from
2283 all files. Here we may get conflicts with the things listed in the
2284 SYSCALLS.c.X file, but if that happens it only means that the source
2285 code being converted contains its own definition of a function which
2286 could have been supplied by libc.a. In such cases, we should avoid
2287 issuing the normal warning, and defer to the definition given in the
2290 for (dd_p
= head
; dd_p
; dd_p
= dd_p
->next_for_func
)
2291 if (dd_p
->is_func_def
&& !dd_p
->is_static
)
2293 if (!extern_def_p
) /* Previous definition? */
2294 extern_def_p
= dd_p
; /* Remember the first definition found. */
2297 /* Ignore definition just found if it came from SYSCALLS.c.X. */
2299 if (is_syscalls_file (dd_p
->file
))
2302 /* Quietly replace the definition previously found with the one
2303 just found if the previous one was from SYSCALLS.c.X. */
2305 if (is_syscalls_file (extern_def_p
->file
))
2307 extern_def_p
= dd_p
;
2311 /* If we get here, then there is a conflict between two function
2312 declarations for the same function, both of which came from the
2315 if (!conflict_noted
) /* first time we noticed? */
2318 fprintf (stderr
, "%s: error: conflicting extern definitions of '%s'\n",
2319 pname
, head
->hash_entry
->symbol
);
2322 fprintf (stderr
, "%s: declarations of '%s' will not be converted\n",
2323 pname
, head
->hash_entry
->symbol
);
2324 fprintf (stderr
, "%s: conflict list for '%s' follows:\n",
2325 pname
, head
->hash_entry
->symbol
);
2326 fprintf (stderr
, "%s: %s(%d): %s\n",
2328 shortpath (NULL
, extern_def_p
->file
->hash_entry
->symbol
),
2330 extern_def_p
->ansi_decl
);
2334 fprintf (stderr
, "%s: %s(%d): %s\n",
2336 shortpath (NULL
, dd_p
->file
->hash_entry
->symbol
),
2342 /* We want to err on the side of caution, so if we found multiple conflicting
2343 definitions for the same function, treat this as being that same as if we
2344 had found no definitions (i.e. return NULL). */
2351 /* We have no definitions for this function so do the next best thing.
2352 Search for an extern declaration already in prototype form. */
2354 for (dd_p
= head
; dd_p
; dd_p
= dd_p
->next_for_func
)
2355 if (!dd_p
->is_func_def
&& !dd_p
->is_static
&& dd_p
->prototyped
)
2357 extern_def_p
= dd_p
; /* save a pointer to the definition */
2359 fprintf (stderr
, "%s: warning: using formals list from %s(%d) for function `%s'\n",
2361 shortpath (NULL
, dd_p
->file
->hash_entry
->symbol
),
2362 dd_p
->line
, dd_p
->hash_entry
->symbol
);
2366 /* Gripe about unprototyped function declarations that we found no
2367 corresponding definition (or other source of prototype information)
2370 Gripe even if the unprototyped declaration we are worried about
2371 exists in a file in one of the "system" include directories. We
2372 can gripe about these because we should have at least found a
2373 corresponding (pseudo) definition in the SYSCALLS.c.X file. If we
2374 didn't, then that means that the SYSCALLS.c.X file is missing some
2375 needed prototypes for this particular system. That is worth telling
2380 const char *file
= user
->file
->hash_entry
->symbol
;
2383 if (in_system_include_dir (file
))
2385 /* Why copy this string into `needed' at all?
2386 Why not just use user->ansi_decl without copying? */
2387 char needed
[strlen (user
->ansi_decl
) + 1];
2390 strcpy (needed
, user
->ansi_decl
);
2391 p
= (NONCONST
char *) substr (needed
, user
->hash_entry
->symbol
)
2392 + strlen (user
->hash_entry
->symbol
) + 2;
2393 strcpy (p
, "???);");
2395 fprintf (stderr
, "%s: please add `%s' to SYSCALLS (see %s(%d))\n",
2397 needed
+7, /* Don't print "extern " */
2398 shortpath (NULL
, file
),
2402 fprintf (stderr
, "%s: warning: no extern definition for `%s' (see %s(%d))\n",
2404 user
->hash_entry
->symbol
,
2405 shortpath (NULL
, file
),
2409 return extern_def_p
;
2412 /* Find the (only?) static definition for a particular function name in a
2413 given file. Here we get the function-name and the file info indirectly
2414 from the def_dec_info record pointer which is passed in. */
2416 static const def_dec_info
*
2417 find_static_definition (const def_dec_info
*user
)
2419 const def_dec_info
*head
= user
->hash_entry
->ddip
;
2420 const def_dec_info
*dd_p
;
2421 int num_static_defs
= 0;
2422 const def_dec_info
*static_def_p
= NULL
;
2424 for (dd_p
= head
; dd_p
; dd_p
= dd_p
->next_for_func
)
2425 if (dd_p
->is_func_def
&& dd_p
->is_static
&& (dd_p
->file
== user
->file
))
2427 static_def_p
= dd_p
; /* save a pointer to the definition */
2430 if (num_static_defs
== 0)
2433 fprintf (stderr
, "%s: warning: no static definition for `%s' in file `%s'\n",
2435 head
->hash_entry
->symbol
,
2436 shortpath (NULL
, user
->file
->hash_entry
->symbol
));
2438 else if (num_static_defs
> 1)
2440 fprintf (stderr
, "%s: error: multiple static defs of `%s' in file `%s'\n",
2442 head
->hash_entry
->symbol
,
2443 shortpath (NULL
, user
->file
->hash_entry
->symbol
));
2446 return static_def_p
;
2449 /* Find good prototype style formal argument lists for all of the function
2450 declarations which didn't have them before now.
2452 To do this we consider each function name one at a time. For each function
2453 name, we look at the items on the linked list of def_dec_info records for
2454 that particular name.
2456 Somewhere on this list we should find one (and only one) def_dec_info
2457 record which represents the actual function definition, and this record
2458 should have a nice formal argument list already associated with it.
2460 Thus, all we have to do is to connect up all of the other def_dec_info
2461 records for this particular function name to the special one which has
2462 the full-blown formals list.
2464 Of course it is a little more complicated than just that. See below for
2468 connect_defs_and_decs (const hash_table_entry
*hp
)
2470 const def_dec_info
*dd_p
;
2471 const def_dec_info
*extern_def_p
= NULL
;
2472 int first_extern_reference
= 1;
2474 /* Traverse the list of definitions and declarations for this particular
2475 function name. For each item on the list, if it is a function
2476 definition (either old style or new style) then GCC has already been
2477 kind enough to produce a prototype for us, and it is associated with
2478 the item already, so declare the item as its own associated "definition".
2480 Also, for each item which is only a function declaration, but which
2481 nonetheless has its own prototype already (obviously supplied by the user)
2482 declare the item as it's own definition.
2484 Note that when/if there are multiple user-supplied prototypes already
2485 present for multiple declarations of any given function, these multiple
2486 prototypes *should* all match exactly with one another and with the
2487 prototype for the actual function definition. We don't check for this
2488 here however, since we assume that the compiler must have already done
2489 this consistancy checking when it was creating the .X files. */
2491 for (dd_p
= hp
->ddip
; dd_p
; dd_p
= dd_p
->next_for_func
)
2492 if (dd_p
->prototyped
)
2493 ((NONCONST def_dec_info
*) dd_p
)->definition
= dd_p
;
2495 /* Traverse the list of definitions and declarations for this particular
2496 function name. For each item on the list, if it is an extern function
2497 declaration and if it has no associated definition yet, go try to find
2498 the matching extern definition for the declaration.
2500 When looking for the matching function definition, warn the user if we
2503 If we find more that one function definition also issue a warning.
2505 Do the search for the matching definition only once per unique function
2506 name (and only when absolutely needed) so that we can avoid putting out
2507 redundant warning messages, and so that we will only put out warning
2508 messages when there is actually a reference (i.e. a declaration) for
2509 which we need to find a matching definition. */
2511 for (dd_p
= hp
->ddip
; dd_p
; dd_p
= dd_p
->next_for_func
)
2512 if (!dd_p
->is_func_def
&& !dd_p
->is_static
&& !dd_p
->definition
)
2514 if (first_extern_reference
)
2516 extern_def_p
= find_extern_def (hp
->ddip
, dd_p
);
2517 first_extern_reference
= 0;
2519 ((NONCONST def_dec_info
*) dd_p
)->definition
= extern_def_p
;
2522 /* Traverse the list of definitions and declarations for this particular
2523 function name. For each item on the list, if it is a static function
2524 declaration and if it has no associated definition yet, go try to find
2525 the matching static definition for the declaration within the same file.
2527 When looking for the matching function definition, warn the user if we
2528 fail to find one in the same file with the declaration, and refuse to
2529 convert this kind of cross-file static function declaration. After all,
2530 this is stupid practice and should be discouraged.
2532 We don't have to worry about the possibility that there is more than one
2533 matching function definition in the given file because that would have
2534 been flagged as an error by the compiler.
2536 Do the search for the matching definition only once per unique
2537 function-name/source-file pair (and only when absolutely needed) so that
2538 we can avoid putting out redundant warning messages, and so that we will
2539 only put out warning messages when there is actually a reference (i.e. a
2540 declaration) for which we actually need to find a matching definition. */
2542 for (dd_p
= hp
->ddip
; dd_p
; dd_p
= dd_p
->next_for_func
)
2543 if (!dd_p
->is_func_def
&& dd_p
->is_static
&& !dd_p
->definition
)
2545 const def_dec_info
*dd_p2
;
2546 const def_dec_info
*static_def
;
2548 /* We have now found a single static declaration for which we need to
2549 find a matching definition. We want to minimize the work (and the
2550 number of warnings), so we will find an appropriate (matching)
2551 static definition for this declaration, and then distribute it
2552 (as the definition for) any and all other static declarations
2553 for this function name which occur within the same file, and which
2554 do not already have definitions.
2556 Note that a trick is used here to prevent subsequent attempts to
2557 call find_static_definition() for a given function-name & file
2558 if the first such call returns NULL. Essentially, we convert
2559 these NULL return values to -1, and put the -1 into the definition
2560 field for each other static declaration from the same file which
2561 does not already have an associated definition.
2562 This makes these other static declarations look like they are
2563 actually defined already when the outer loop here revisits them
2564 later on. Thus, the outer loop will skip over them. Later, we
2565 turn the -1's back to NULL's. */
2567 ((NONCONST def_dec_info
*) dd_p
)->definition
=
2568 (static_def
= find_static_definition (dd_p
))
2570 : (const def_dec_info
*) -1;
2572 for (dd_p2
= dd_p
->next_for_func
; dd_p2
; dd_p2
= dd_p2
->next_for_func
)
2573 if (!dd_p2
->is_func_def
&& dd_p2
->is_static
2574 && !dd_p2
->definition
&& (dd_p2
->file
== dd_p
->file
))
2575 ((NONCONST def_dec_info
*)dd_p2
)->definition
= dd_p
->definition
;
2578 /* Convert any dummy (-1) definitions we created in the step above back to
2579 NULL's (as they should be). */
2581 for (dd_p
= hp
->ddip
; dd_p
; dd_p
= dd_p
->next_for_func
)
2582 if (dd_p
->definition
== (def_dec_info
*) -1)
2583 ((NONCONST def_dec_info
*) dd_p
)->definition
= NULL
;
2586 #endif /* !defined(UNPROTOIZE) */
2588 /* Give a pointer into the clean text buffer, return a number which is the
2589 original source line number that the given pointer points into. */
2592 identify_lineno (const char *clean_p
)
2597 for (scan_p
= clean_text_base
; scan_p
<= clean_p
; scan_p
++)
2598 if (*scan_p
== '\n')
2603 /* Issue an error message and give up on doing this particular edit. */
2606 declare_source_confusing (const char *clean_p
)
2611 fprintf (stderr
, "%s: warning: source too confusing near %s(%d)\n",
2612 pname
, shortpath (NULL
, convert_path
), last_known_line_number
);
2614 fprintf (stderr
, "%s: warning: source too confusing at %s(%d)\n",
2615 pname
, shortpath (NULL
, convert_path
), identify_lineno (clean_p
));
2617 longjmp (source_confusion_recovery
, 1);
2620 /* Check that a condition which is expected to be true in the original source
2621 code is in fact true. If not, issue an error message and give up on
2622 converting this particular source file. */
2625 check_source (int cond
, const char *clean_p
)
2628 declare_source_confusing (clean_p
);
2631 /* If we think of the in-core cleaned text buffer as a memory mapped
2632 file (with the variable last_known_line_start acting as sort of a
2633 file pointer) then we can imagine doing "seeks" on the buffer. The
2634 following routine implements a kind of "seek" operation for the in-core
2635 (cleaned) copy of the source file. When finished, it returns a pointer to
2636 the start of a given (numbered) line in the cleaned text buffer.
2638 Note that protoize only has to "seek" in the forward direction on the
2639 in-core cleaned text file buffers, and it never needs to back up.
2641 This routine is made a little bit faster by remembering the line number
2642 (and pointer value) supplied (and returned) from the previous "seek".
2643 This prevents us from always having to start all over back at the top
2644 of the in-core cleaned buffer again. */
2647 seek_to_line (int n
)
2649 if (n
< last_known_line_number
)
2652 while (n
> last_known_line_number
)
2654 while (*last_known_line_start
!= '\n')
2655 check_source (++last_known_line_start
< clean_text_limit
, 0);
2656 last_known_line_start
++;
2657 last_known_line_number
++;
2659 return last_known_line_start
;
2662 /* Given a pointer to a character in the cleaned text buffer, return a pointer
2663 to the next non-whitepace character which follows it. */
2666 forward_to_next_token_char (const char *ptr
)
2668 for (++ptr
; isspace (*ptr
); check_source (++ptr
< clean_text_limit
, 0))
2673 /* Copy a chunk of text of length `len' and starting at `str' to the current
2674 output buffer. Note that all attempts to add stuff to the current output
2675 buffer ultimately go through here. */
2678 output_bytes (const char *str
, size_t len
)
2680 if ((repl_write_ptr
+ 1) + len
>= repl_text_limit
)
2682 size_t new_size
= (repl_text_limit
- repl_text_base
) << 1;
2683 char *new_buf
= (char *) xrealloc (repl_text_base
, new_size
);
2685 repl_write_ptr
= new_buf
+ (repl_write_ptr
- repl_text_base
);
2686 repl_text_base
= new_buf
;
2687 repl_text_limit
= new_buf
+ new_size
;
2689 memcpy (repl_write_ptr
+ 1, str
, len
);
2690 repl_write_ptr
+= len
;
2693 /* Copy all bytes (except the trailing null) of a null terminated string to
2694 the current output buffer. */
2697 output_string (const char *str
)
2699 output_bytes (str
, strlen (str
));
2702 /* Copy some characters from the original text buffer to the current output
2705 This routine takes a pointer argument `p' which is assumed to be a pointer
2706 into the cleaned text buffer. The bytes which are copied are the `original'
2707 equivalents for the set of bytes between the last value of `clean_read_ptr'
2708 and the argument value `p'.
2710 The set of bytes copied however, comes *not* from the cleaned text buffer,
2711 but rather from the direct counterparts of these bytes within the original
2714 Thus, when this function is called, some bytes from the original text
2715 buffer (which may include original comments and preprocessing directives)
2716 will be copied into the output buffer.
2718 Note that the request implide when this routine is called includes the
2719 byte pointed to by the argument pointer `p'. */
2722 output_up_to (const char *p
)
2724 size_t copy_length
= (size_t) (p
- clean_read_ptr
);
2725 const char *copy_start
= orig_text_base
+(clean_read_ptr
-clean_text_base
)+1;
2727 if (copy_length
== 0)
2730 output_bytes (copy_start
, copy_length
);
2734 /* Given a pointer to a def_dec_info record which represents some form of
2735 definition of a function (perhaps a real definition, or in lieu of that
2736 perhaps just a declaration with a full prototype) return true if this
2737 function is one which we should avoid converting. Return false
2741 other_variable_style_function (const char *ansi_header
)
2745 /* See if we have a stdarg function, or a function which has stdarg style
2746 parameters or a stdarg style return type. */
2748 return (int) substr (ansi_header
, "...");
2750 #else /* !defined(UNPROTOIZE) */
2752 /* See if we have a varargs function, or a function which has varargs style
2753 parameters or a varargs style return type. */
2756 int len
= strlen (varargs_style_indicator
);
2758 for (p
= ansi_header
; p
; )
2760 const char *candidate
;
2762 if ((candidate
= substr (p
, varargs_style_indicator
)) == 0)
2765 if (!is_id_char (candidate
[-1]) && !is_id_char (candidate
[len
]))
2771 #endif /* !defined(UNPROTOIZE) */
2774 /* Do the editing operation specifically for a function "declaration". Note
2775 that editing for function "definitions" are handled in a separate routine
2779 edit_fn_declaration (const def_dec_info
*def_dec_p
,
2780 const char *volatile clean_text_p
)
2782 const char *start_formals
;
2783 const char *end_formals
;
2784 const char *function_to_edit
= def_dec_p
->hash_entry
->symbol
;
2785 size_t func_name_len
= strlen (function_to_edit
);
2786 const char *end_of_fn_name
;
2790 const f_list_chain_item
*this_f_list_chain_item
;
2791 const def_dec_info
*definition
= def_dec_p
->definition
;
2793 /* If we are protoizing, and if we found no corresponding definition for
2794 this particular function declaration, then just leave this declaration
2795 exactly as it is. */
2800 /* If we are protoizing, and if the corresponding definition that we found
2801 for this particular function declaration defined an old style varargs
2802 function, then we want to issue a warning and just leave this function
2803 declaration unconverted. */
2805 if (other_variable_style_function (definition
->ansi_decl
))
2808 fprintf (stderr
, "%s: warning: varargs function declaration at %s(%d) not converted\n",
2810 shortpath (NULL
, def_dec_p
->file
->hash_entry
->symbol
),
2815 #endif /* !defined(UNPROTOIZE) */
2817 /* Setup here to recover from confusing source code detected during this
2818 particular "edit". */
2821 if (setjmp (source_confusion_recovery
))
2823 restore_pointers ();
2824 fprintf (stderr
, "%s: declaration of function `%s' not converted\n",
2825 pname
, function_to_edit
);
2829 /* We are editing a function declaration. The line number we did a seek to
2830 contains the comma or semicolon which follows the declaration. Our job
2831 now is to scan backwards looking for the function name. This name *must*
2832 be followed by open paren (ignoring whitespace, of course). We need to
2833 replace everything between that open paren and the corresponding closing
2834 paren. If we are protoizing, we need to insert the prototype-style
2835 formals lists. If we are unprotoizing, we need to just delete everything
2836 between the pairs of opening and closing parens. */
2838 /* First move up to the end of the line. */
2840 while (*clean_text_p
!= '\n')
2841 check_source (++clean_text_p
< clean_text_limit
, 0);
2842 clean_text_p
--; /* Point to just before the newline character. */
2844 /* Now we can scan backwards for the function name. */
2850 /* Scan leftwards until we find some character which can be
2851 part of an identifier. */
2853 while (!is_id_char (*clean_text_p
))
2854 check_source (--clean_text_p
> clean_read_ptr
, 0);
2856 /* Scan backwards until we find a char that cannot be part of an
2859 while (is_id_char (*clean_text_p
))
2860 check_source (--clean_text_p
> clean_read_ptr
, 0);
2862 /* Having found an "id break", see if the following id is the one
2863 that we are looking for. If so, then exit from this loop. */
2865 if (!strncmp (clean_text_p
+1, function_to_edit
, func_name_len
))
2867 char ch
= *(clean_text_p
+ 1 + func_name_len
);
2869 /* Must also check to see that the name in the source text
2870 ends where it should (in order to prevent bogus matches
2871 on similar but longer identifiers. */
2873 if (! is_id_char (ch
))
2874 break; /* exit from loop */
2878 /* We have now found the first perfect match for the function name in
2879 our backward search. This may or may not be the actual function
2880 name at the start of the actual function declaration (i.e. we could
2881 have easily been mislead). We will try to avoid getting fooled too
2882 often by looking forward for the open paren which should follow the
2883 identifier we just found. We ignore whitespace while hunting. If
2884 the next non-whitespace byte we see is *not* an open left paren,
2885 then we must assume that we have been fooled and we start over
2886 again accordingly. Note that there is no guarrantee, that even if
2887 we do see the open paren, that we are in the right place.
2888 Programmers do the strangest things sometimes! */
2890 end_of_fn_name
= clean_text_p
+ strlen (def_dec_p
->hash_entry
->symbol
);
2891 start_formals
= forward_to_next_token_char (end_of_fn_name
);
2893 while (*start_formals
!= '(');
2895 /* start_of_formals now points to the opening left paren which immediately
2896 follows the name of the function. */
2898 /* Note that there may be several formals lists which need to be modified
2899 due to the possibility that the return type of this function is a
2900 pointer-to-function type. If there are several formals lists, we
2901 convert them in left-to-right order here. */
2904 this_f_list_chain_item
= definition
->f_list_chain
;
2905 #endif /* !defined(UNPROTOIZE) */
2912 end_formals
= start_formals
+ 1;
2914 for (; depth
; check_source (++end_formals
< clean_text_limit
, 0))
2916 switch (*end_formals
)
2929 /* end_formals now points to the closing right paren of the formals
2930 list whose left paren is pointed to by start_formals. */
2932 /* Now, if we are protoizing, we insert the new ANSI-style formals list
2933 attached to the associated definition of this function. If however
2934 we are unprotoizing, then we simply delete any formals list which
2937 output_up_to (start_formals
);
2939 if (this_f_list_chain_item
)
2941 output_string (this_f_list_chain_item
->formals_list
);
2942 this_f_list_chain_item
= this_f_list_chain_item
->chain_next
;
2947 fprintf (stderr
, "%s: warning: too many parameter lists in declaration of `%s'\n",
2948 pname
, def_dec_p
->hash_entry
->symbol
);
2949 check_source (0, end_formals
); /* leave the declaration intact */
2951 #endif /* !defined(UNPROTOIZE) */
2952 clean_read_ptr
= end_formals
- 1;
2954 /* Now see if it looks like there may be another formals list associated
2955 with the function declaration that we are converting (following the
2956 formals list that we just converted. */
2959 const char *another_r_paren
= forward_to_next_token_char (end_formals
);
2961 if ((*another_r_paren
!= ')')
2962 || (*(start_formals
= forward_to_next_token_char (another_r_paren
)) != '('))
2965 if (this_f_list_chain_item
)
2968 fprintf (stderr
, "\n%s: warning: too few parameter lists in declaration of `%s'\n",
2969 pname
, def_dec_p
->hash_entry
->symbol
);
2970 check_source (0, start_formals
); /* leave the decl intact */
2972 #endif /* !defined(UNPROTOIZE) */
2978 /* There does appear to be yet another formals list, so loop around
2979 again, and convert it also. */
2983 /* Edit a whole group of formals lists, starting with the rightmost one
2984 from some set of formals lists. This routine is called once (from the
2985 outside) for each function declaration which is converted. It is
2986 recursive however, and it calls itself once for each remaining formal
2987 list that lies to the left of the one it was originally called to work
2988 on. Thus, a whole set gets done in right-to-left order.
2990 This routine returns non-zero if it thinks that it should not be trying
2991 to convert this particular function definition (because the name of the
2992 function doesn't match the one expected). */
2995 edit_formals_lists (const char *end_formals
, unsigned f_list_count
, const def_dec_info
*def_dec_p
)
2997 const char *start_formals
;
3000 start_formals
= end_formals
- 1;
3002 for (; depth
; check_source (--start_formals
> clean_read_ptr
, 0))
3004 switch (*start_formals
)
3016 /* start_formals now points to the opening left paren of the formals list. */
3022 const char *next_end
;
3024 /* There should be more formal lists to the left of here. */
3026 next_end
= start_formals
- 1;
3027 check_source (next_end
> clean_read_ptr
, 0);
3028 while (isspace (*next_end
))
3029 check_source (--next_end
> clean_read_ptr
, 0);
3030 check_source (*next_end
== ')', next_end
);
3031 check_source (--next_end
> clean_read_ptr
, 0);
3032 check_source (*next_end
== ')', next_end
);
3033 if (edit_formals_lists (next_end
, f_list_count
, def_dec_p
))
3037 /* Check that the function name in the header we are working on is the same
3038 as the one we would expect to find. If not, issue a warning and return
3041 if (f_list_count
== 0)
3043 const char *expected
= def_dec_p
->hash_entry
->symbol
;
3044 const char *func_name_start
;
3045 const char *func_name_limit
;
3046 size_t func_name_len
;
3048 for (func_name_limit
= start_formals
-1; isspace (*func_name_limit
); )
3049 check_source (--func_name_limit
> clean_read_ptr
, 0);
3051 for (func_name_start
= func_name_limit
++;
3052 is_id_char (*func_name_start
);
3054 check_source (func_name_start
> clean_read_ptr
, 0);
3056 func_name_len
= func_name_limit
- func_name_start
;
3057 if (func_name_len
== 0)
3058 check_source (0, func_name_start
);
3059 if (func_name_len
!= strlen (expected
)
3060 || strncmp (func_name_start
, expected
, func_name_len
))
3062 fprintf (stderr
, "%s: warning: found `%s' at %s(%d) but expected `%s'\n",
3064 dupnstr (func_name_start
, func_name_len
),
3065 shortpath (NULL
, def_dec_p
->file
->hash_entry
->symbol
),
3066 identify_lineno (func_name_start
),
3072 output_up_to (start_formals
);
3075 if (f_list_count
== 0)
3076 output_string (def_dec_p
->formal_names
);
3077 #else /* !defined(UNPROTOIZE) */
3079 unsigned f_list_depth
;
3080 const f_list_chain_item
*flci_p
= def_dec_p
->f_list_chain
;
3082 /* At this point, the current value of f_list count says how many
3083 links we have to follow through the f_list_chain to get to the
3084 particular formals list that we need to output next. */
3086 for (f_list_depth
= 0; f_list_depth
< f_list_count
; f_list_depth
++)
3087 flci_p
= flci_p
->chain_next
;
3088 output_string (flci_p
->formals_list
);
3090 #endif /* !defined(UNPROTOIZE) */
3092 clean_read_ptr
= end_formals
- 1;
3096 /* Given a pointer to a byte in the clean text buffer which points to the
3097 beginning of a line that contains a "follower" token for a function
3098 definition header, do whatever is necessary to find the right closing
3099 paren for the rightmost formals list of the function definition header.
3103 find_rightmost_formals_list (const char *clean_text_p
)
3105 const char *end_formals
;
3107 /* We are editing a function definition. The line number we did a seek
3108 to contains the first token which immediately follows the entire set of
3109 formals lists which are part of this particular function definition
3112 Our job now is to scan leftwards in the clean text looking for the
3113 right-paren which is at the end of the function header's rightmost
3116 If we ignore whitespace, this right paren should be the first one we
3117 see which is (ignoring whitespace) immediately followed either by the
3118 open curly-brace beginning the function body or by an alphabetic
3119 character (in the case where the function definition is in old (K&R)
3120 style and there are some declarations of formal parameters). */
3122 /* It is possible that the right paren we are looking for is on the
3123 current line (together with its following token). Just in case that
3124 might be true, we start out here by skipping down to the right end of
3125 the current line before starting our scan. */
3127 for (end_formals
= clean_text_p
; *end_formals
!= '\n'; end_formals
++)
3131 /* Now scan backwards while looking for the right end of the rightmost
3132 formals list associated with this function definition. */
3137 const char *l_brace_p
;
3139 /* Look leftward and try to find a right-paren. */
3141 while (*end_formals
!= ')')
3143 if (isspace (*end_formals
))
3144 while (isspace (*end_formals
))
3145 check_source (--end_formals
> clean_read_ptr
, 0);
3147 check_source (--end_formals
> clean_read_ptr
, 0);
3150 ch
= *(l_brace_p
= forward_to_next_token_char (end_formals
));
3154 /* Since we are unprotoizing an ANSI-style (prototyped) function
3155 definition, there had better not be anything (except whitespace)
3156 between the end of the ANSI formals list and the beginning of the
3157 function body (i.e. the '{'). */
3159 check_source (ch
== '{', l_brace_p
);
3162 #else /* !defined(UNPROTOIZE) */
3164 /* Since it is possible that we found a right paren before the starting
3165 '{' of the body which IS NOT the one at the end of the real K&R
3166 formals list (say for instance, we found one embedded inside one of
3167 the old K&R formal parameter declarations) we have to check to be
3168 sure that this is in fact the right paren that we were looking for.
3170 The one we were looking for *must* be followed by either a '{' or
3171 by an alphabetic character, while others *cannot* legally be followed
3172 by such characters. */
3174 if ((ch
== '{') || isalpha (ch
))
3177 /* At this point, we have found a right paren, but we know that it is
3178 not the one we were looking for, so backup one character and keep
3181 check_source (--end_formals
> clean_read_ptr
, 0);
3183 #endif /* !defined(UNPROTOIZE) */
3192 /* Insert into the output file a totally new declaration for a function
3193 which (up until now) was being called from within the current block
3194 without having been declared at any point such that the declaration
3195 was visible (i.e. in scope) at the point of the call.
3197 We need to add in explicit declarations for all such function calls
3198 in order to get the full benefit of prototype-based function call
3199 parameter type checking. */
3202 add_local_decl (const def_dec_info
*def_dec_p
, const char *clean_text_p
)
3204 const char *start_of_block
;
3205 const char *function_to_edit
= def_dec_p
->hash_entry
->symbol
;
3207 /* Don't insert new local explicit declarations unless explicitly requested
3213 /* Setup here to recover from confusing source code detected during this
3214 particular "edit". */
3217 if (setjmp (source_confusion_recovery
))
3219 restore_pointers ();
3220 fprintf (stderr
, "%s: local declaration for function `%s' not inserted\n",
3221 pname
, function_to_edit
);
3225 /* We have already done a seek to the start of the line which should
3226 contain *the* open curly brace which begins the block in which we need
3227 to insert an explicit function declaration (to replace the implicit one).
3229 Now we scan that line, starting from the left, until we find the
3230 open curly brace we are looking for. Note that there may actually be
3231 multiple open curly braces on the given line, but we will be happy
3232 with the leftmost one no matter what. */
3234 start_of_block
= clean_text_p
;
3235 while (*start_of_block
!= '{' && *start_of_block
!= '\n')
3236 check_source (++start_of_block
< clean_text_limit
, 0);
3238 /* Note that the line from the original source could possibly
3239 contain *no* open curly braces! This happens if the line contains
3240 a macro call which expands into a chunk of text which includes a
3241 block (and that block's associated open and close curly braces).
3242 In cases like this, we give up, issue a warning, and do nothing. */
3244 if (*start_of_block
!= '{')
3248 "\n%s: warning: can't add declaration of `%s' into macro call at %s(%d)\n",
3250 def_dec_p
->hash_entry
->symbol
,
3251 def_dec_p
->file
->hash_entry
->symbol
,
3256 /* Figure out what a nice (pretty) indentation would be for the new
3257 declaration we are adding. In order to do this, we must scan forward
3258 from the '{' until we find the first line which starts with some
3259 non-whitespace characters (i.e. real "token" material). */
3262 const char *ep
= forward_to_next_token_char (start_of_block
) - 1;
3265 /* Now we have ep pointing at the rightmost byte of some existing indent
3266 stuff. At least that is the hope.
3268 We can now just scan backwards and find the left end of the existing
3269 indentation string, and then copy it to the output buffer. */
3271 for (sp
= ep
; isspace (*sp
) && *sp
!= '\n'; sp
--)
3274 /* Now write out the open { which began this block, and any following
3275 trash up to and including the last byte of the existing indent that
3280 /* Now we go ahead and insert the new declaration at this point.
3282 If the definition of the given function is in the same file that we
3283 are currently editing, and if its full ANSI declaration normally
3284 would start with the keyword `extern', suppress the `extern'. */
3287 const char *decl
= def_dec_p
->definition
->ansi_decl
;
3289 if ((*decl
== 'e') && (def_dec_p
->file
== def_dec_p
->definition
->file
))
3291 output_string (decl
);
3294 /* Finally, write out a new indent string, just like the preceeding one
3295 that we found. This will typically include a newline as the first
3296 character of the indent string. */
3298 output_bytes (sp
, (size_t) (ep
- sp
) + 1);
3302 /* Given a pointer to a file_info record, and a pointer to the beginning
3303 of a line (in the clean text buffer) which is assumed to contain the
3304 first "follower" token for the first function definition header in the
3305 given file, find a good place to insert some new global function
3306 declarations (which will replace scattered and imprecise implicit ones)
3307 and then insert the new explicit declaration at that point in the file. */
3310 add_global_decls (const file_info
*file_p
, const char *clean_text_p
)
3312 const def_dec_info
*dd_p
;
3315 /* Setup here to recover from confusing source code detected during this
3316 particular "edit". */
3319 if (setjmp (source_confusion_recovery
))
3321 restore_pointers ();
3322 fprintf (stderr
, "%s: global declarations for file `%s' not inserted\n",
3323 pname
, shortpath (NULL
, file_p
->hash_entry
->symbol
));
3327 /* Start by finding a good location for adding the new explicit function
3328 declarations. To do this, we scan backwards, ignoring whitespace
3329 and comments and other junk until we find either a semicolon, or until
3330 we hit the beginning of the file. */
3332 scan_p
= find_rightmost_formals_list (clean_text_p
);
3335 if (scan_p
< clean_text_base
)
3337 check_source (scan_p
> clean_read_ptr
, 0);
3342 /* scan_p now points either to a semicolon, or to just before the start
3343 of the whole file. */
3345 /* Now scan forward for the first non-whitespace character. In theory,
3346 this should be the first character of the following function definition
3347 header. We will put in the added declarations just prior to that. */
3350 while (isspace (*scan_p
))
3354 output_up_to (scan_p
);
3356 /* Now write out full prototypes for all of the things that had been
3357 implicitly declared in this file (but only those for which we were
3358 actually able to find unique matching definitions). Avoid duplicates
3359 by marking things that we write out as we go. */
3362 int some_decls_added
= 0;
3364 for (dd_p
= file_p
->defs_decs
; dd_p
; dd_p
= dd_p
->next_in_file
)
3365 if (dd_p
->is_implicit
&& dd_p
->definition
&& !dd_p
->definition
->written
)
3367 const char *decl
= dd_p
->definition
->ansi_decl
;
3369 /* If the function for which we are inserting a declaration is
3370 actually defined later in the same file, then suppress the
3371 leading `extern' keyword (if there is one). */
3373 if (*decl
== 'e' && (dd_p
->file
== dd_p
->definition
->file
))
3376 output_string ("\n");
3377 output_string (decl
);
3378 some_decls_added
= 1;
3379 ((NONCONST def_dec_info
*) dd_p
->definition
)->written
= 1;
3381 if (some_decls_added
)
3382 output_string ("\n\n");
3385 /* Unmark all of the definitions that we just marked. */
3387 for (dd_p
= file_p
->defs_decs
; dd_p
; dd_p
= dd_p
->next_in_file
)
3388 if (dd_p
->definition
)
3389 ((NONCONST def_dec_info
*) dd_p
->definition
)->written
= 0;
3392 #endif /* !defined(UNPROTOIZE) */
3394 /* Do the editing operation specifically for a function "definition". Note
3395 that editing operations for function "declarations" are handled by a
3396 separate routine above. */
3399 edit_fn_definition (const def_dec_info
*def_dec_p
, const char *clean_text_p
)
3401 const char *end_formals
;
3402 const char *function_to_edit
= def_dec_p
->hash_entry
->symbol
;
3404 /* Setup here to recover from confusing source code detected during this
3405 particular "edit". */
3408 if (setjmp (source_confusion_recovery
))
3410 restore_pointers ();
3411 fprintf (stderr
, "%s: definition of function `%s' not converted\n",
3412 pname
, function_to_edit
);
3416 end_formals
= find_rightmost_formals_list (clean_text_p
);
3418 /* end_of_formals now points to the closing right paren of the rightmost
3419 formals list which is actually part of the `header' of the function
3420 definition that we are converting. */
3422 /* If the header of this function definition looks like it declares a
3423 function with a variable number of arguments, and if the way it does
3424 that is different from that way we would like it (i.e. varargs vs.
3425 stdarg) then issue a warning and leave the header unconverted. */
3427 if (other_variable_style_function (def_dec_p
->ansi_decl
))
3430 fprintf (stderr
, "%s: warning: %s function definition at %s(%d) not converted\n",
3433 shortpath (NULL
, def_dec_p
->file
->hash_entry
->symbol
),
3434 identify_lineno (end_formals
));
3435 output_up_to (end_formals
);
3439 if (edit_formals_lists (end_formals
, def_dec_p
->f_list_count
, def_dec_p
))
3441 restore_pointers ();
3442 fprintf (stderr
, "%s: definition of function `%s' not converted\n",
3443 pname
, function_to_edit
);
3447 /* Have to output the last right paren because this never gets flushed by
3448 edit_formals_list. */
3450 output_up_to (end_formals
);
3455 const char *semicolon_p
;
3456 const char *limit_p
;
3458 int had_newlines
= 0;
3460 /* Now write out the K&R style formal declarations, one per line. */
3462 decl_p
= def_dec_p
->formal_decls
;
3463 limit_p
= decl_p
+ strlen (decl_p
);
3464 for (;decl_p
< limit_p
; decl_p
= semicolon_p
+ 2)
3466 for (semicolon_p
= decl_p
; *semicolon_p
!= ';'; semicolon_p
++)
3468 output_string ("\n");
3469 output_string (indent_string
);
3470 output_bytes (decl_p
, (size_t) ((semicolon_p
+ 1) - decl_p
));
3473 /* If there are no newlines between the end of the formals list and the
3474 start of the body, we should insert one now. */
3476 for (scan_p
= end_formals
+1; *scan_p
!= '{'; )
3478 if (*scan_p
== '\n')
3483 check_source (++scan_p
< clean_text_limit
, 0);
3486 output_string ("\n");
3488 #else /* !defined(UNPROTOIZE) */
3489 /* If we are protoizing, there may be some flotsum & jetsum (like comments
3490 and preprocessing directives) after the old formals list but before
3491 the following { and we would like to preserve that stuff while effectively
3492 deleting the existing K&R formal parameter declarations. We do so here
3493 in a rather tricky way. Basically, we white out any stuff *except*
3494 the comments/pp-directives in the original text buffer, then, if there
3495 is anything in this area *other* than whitespace, we output it. */
3497 const char *end_formals_orig
;
3498 const char *start_body
;
3499 const char *start_body_orig
;
3501 const char *scan_orig
;
3502 int have_flotsum
= 0;
3503 int have_newlines
= 0;
3505 for (start_body
= end_formals
+ 1; *start_body
!= '{';)
3506 check_source (++start_body
< clean_text_limit
, 0);
3508 end_formals_orig
= orig_text_base
+ (end_formals
- clean_text_base
);
3509 start_body_orig
= orig_text_base
+ (start_body
- clean_text_base
);
3510 scan
= end_formals
+ 1;
3511 scan_orig
= end_formals_orig
+ 1;
3512 for (; scan
< start_body
; scan
++, scan_orig
++)
3514 if (*scan
== *scan_orig
)
3516 have_newlines
|= (*scan_orig
== '\n');
3517 /* Leave identical whitespace alone. */
3518 if (!isspace (*scan_orig
))
3519 *((NONCONST
char *)scan_orig
) = ' '; /* identical - so whiteout */
3525 output_bytes (end_formals_orig
+ 1,
3526 (size_t) (start_body_orig
- end_formals_orig
) - 1);
3529 output_string ("\n");
3531 output_string (" ");
3532 clean_read_ptr
= start_body
- 1;
3534 #endif /* !defined(UNPROTOIZE) */
3537 /* Clean up the clean text buffer. Do this by converting comments and
3538 preprocessor directives into spaces. Also convert line continuations
3539 into whitespace. Also, whiteout string and character literals. */
3542 do_cleaning (char *new_clean_text_base
, char *new_clean_text_limit
)
3545 int non_whitespace_since_newline
= 0;
3547 for (scan_p
= new_clean_text_base
; scan_p
< new_clean_text_limit
; scan_p
++)
3551 case '/': /* Handle comments. */
3552 if (scan_p
[1] != '*')
3554 non_whitespace_since_newline
= 1;
3558 while (scan_p
[1] != '/' || scan_p
[0] != '*')
3560 if (!isspace (*scan_p
))
3562 if (++scan_p
>= new_clean_text_limit
)
3569 case '#': /* Handle pp directives. */
3570 if (non_whitespace_since_newline
)
3573 while (scan_p
[1] != '\n' || scan_p
[0] == '\\')
3575 if (!isspace (*scan_p
))
3577 if (++scan_p
>= new_clean_text_limit
)
3583 case '\'': /* Handle character literals. */
3584 non_whitespace_since_newline
= 1;
3585 while (scan_p
[1] != '\'' || scan_p
[0] == '\\')
3587 if (scan_p
[0] == '\\' && !isspace (scan_p
[1]))
3589 if (!isspace (*scan_p
))
3591 if (++scan_p
>= new_clean_text_limit
)
3597 case '"': /* Handle string literals. */
3598 non_whitespace_since_newline
= 1;
3599 while (scan_p
[1] != '"' || scan_p
[0] == '\\')
3601 if (scan_p
[0] == '\\' && !isspace (scan_p
[1]))
3603 if (!isspace (*scan_p
))
3605 if (++scan_p
>= new_clean_text_limit
)
3611 case '\\': /* Handle line continuations. */
3612 if (scan_p
[1] != '\n')
3618 non_whitespace_since_newline
= 0; /* Reset. */
3627 break; /* Whitespace characters. */
3631 non_whitespace_since_newline
= 1;
3637 /* Given a pointer to the closing right parenthesis for a particular formals
3638 list (in the clean text buffer) find the corresponding left parenthesis
3639 and return a pointer to it. */
3642 careful_find_l_paren (const char *p
)
3647 for (paren_depth
= 1, q
= p
-1; paren_depth
; check_source (--q
>= clean_text_base
, 0))
3662 /* Scan the clean text buffer for cases of function definitions that we
3663 don't really know about because they were preprocessed out when the
3664 aux info files were created.
3666 In this version of protoize/unprotoize we just give a warning for each
3667 one found. A later version may be able to at least unprotoize such
3670 Note that we may easily find all function definitions simply by
3671 looking for places where there is a left paren which is (ignoring
3672 whitespace) immediately followed by either a left-brace or by an
3673 upper or lower case letter. Whenever we find this combination, we
3674 have also found a function definition header.
3676 Finding function *declarations* using syntactic clues is much harder.
3677 I will probably try to do this in a later version though. */
3680 scan_for_missed_items (const file_info
*file_p
)
3682 static const char *scan_p
;
3683 const char *limit
= clean_text_limit
- 3;
3684 static const char *backup_limit
;
3686 backup_limit
= clean_text_base
- 1;
3688 for (scan_p
= clean_text_base
; scan_p
< limit
; scan_p
++)
3692 static const char *last_r_paren
;
3693 const char *ahead_p
;
3695 last_r_paren
= scan_p
;
3697 for (ahead_p
= scan_p
+ 1; isspace (*ahead_p
); )
3698 check_source (++ahead_p
< limit
, limit
);
3700 scan_p
= ahead_p
- 1;
3702 if (isalpha (*ahead_p
) || *ahead_p
== '{')
3704 const char *last_l_paren
;
3705 const int lineno
= identify_lineno (ahead_p
);
3707 if (setjmp (source_confusion_recovery
))
3710 /* We know we have a function definition header. Now skip
3711 leftwards over all of its associated formals lists. */
3715 last_l_paren
= careful_find_l_paren (last_r_paren
);
3716 for (last_r_paren
= last_l_paren
-1; isspace (*last_r_paren
); )
3717 check_source (--last_r_paren
>= backup_limit
, backup_limit
);
3719 while (*last_r_paren
== ')');
3721 if (is_id_char (*last_r_paren
))
3723 const char *id_limit
= last_r_paren
+ 1;
3724 const char *id_start
;
3726 const def_dec_info
*dd_p
;
3728 for (id_start
= id_limit
-1; is_id_char (*id_start
); )
3729 check_source (--id_start
>= backup_limit
, backup_limit
);
3731 backup_limit
= id_start
;
3732 if ((id_length
= (size_t) (id_limit
- id_start
)) == 0)
3736 char func_name
[id_length
+ 1];
3737 static const char * const stmt_keywords
[]
3738 = { "if", "while", "for", "switch", "return", 0 };
3739 const char * const *stmt_keyword
;
3741 strncpy (func_name
, id_start
, id_length
);
3742 func_name
[id_length
] = '\0';
3744 /* We must check here to see if we are actually looking at
3745 a statement rather than an actual function call. */
3747 for (stmt_keyword
= stmt_keywords
; *stmt_keyword
; stmt_keyword
++)
3748 if (!strcmp (func_name
, *stmt_keyword
))
3752 fprintf (stderr
, "%s: found definition of `%s' at %s(%d)\n",
3755 shortpath (NULL
, file_p
->hash_entry
->symbol
),
3756 identify_lineno (id_start
));
3758 /* We really should check for a match of the function name
3759 here also, but why bother. */
3761 for (dd_p
= file_p
->defs_decs
; dd_p
; dd_p
= dd_p
->next_in_file
)
3762 if (dd_p
->is_func_def
&& dd_p
->line
== lineno
)
3765 /* If we make it here, then we did not know about this
3766 function definition. */
3768 fprintf (stderr
, "%s: warning: `%s' at %s(%d) was #if 0\n",
3771 shortpath (NULL
, file_p
->hash_entry
->symbol
),
3772 identify_lineno (id_start
));
3773 fprintf (stderr
, "%s: function definition not converted\n",
3783 /* Do all editing operations for a single source file (either a "base" file
3784 or an "include" file). To do this we read the file into memory, keep a
3785 virgin copy there, make another cleaned in-core copy of the original file
3786 (i.e. one in which all of the comments and preprocessor directives have
3787 been replaced with whitespace), then use these two in-core copies of the
3788 file to make a new edited in-core copy of the file. Finally, rename the
3789 original file (as a way of saving it), and then write the edited version
3790 of the file from core to a disk file of the same name as the original.
3792 Note that the trick of making a copy of the original sans comments &
3793 preprocessor directives make the editing a whole lot easier. */
3796 edit_file (const hash_table_entry
*hp
)
3798 struct stat stat_buf
;
3799 const file_info
*file_p
= hp
->fip
;
3800 char *new_orig_text_base
;
3801 char *new_orig_text_limit
;
3802 char *new_clean_text_base
;
3803 char *new_clean_text_limit
;
3806 int first_definition_in_file
;
3808 /* If we are not supposed to be converting this file, or if there is
3809 nothing in there which needs converting, just skip this file. */
3811 if (!needs_to_be_converted (file_p
))
3814 convert_path
= file_p
->hash_entry
->symbol
;
3816 /* Convert a file if it is in a directory where we want conversion
3817 and the file is not excluded. */
3819 if (!directory_specified_p (convert_path
)
3820 || file_excluded_p (convert_path
))
3824 /* Don't even mention "system" include files unless we are
3825 protoizing. If we are protoizing, we mention these as a
3826 gentile way of prodding the user to convert his "system"
3827 include files to prototype format. */
3828 && !in_system_include_dir (convert_path
)
3829 #endif /* defined(UNPROTOIZE) */
3831 fprintf (stderr
, "%s: file `%s' not converted\n",
3832 pname
, shortpath (NULL
, convert_path
));
3836 /* Let the user know what we are up to. */
3839 puts (shortpath (NULL
, convert_path
));
3842 fprintf (stderr
, "%s: converting file `%s'\n",
3843 pname
, shortpath (NULL
, convert_path
));
3847 /* Find out the size (in bytes) of the original file. */
3849 if (stat (convert_path
, &stat_buf
) == -1)
3851 fprintf (stderr
, "%s: error: can't get status for file `%s': %s\n",
3852 pname
, shortpath (NULL
, convert_path
), sys_errlist
[errno
]);
3855 orig_size
= stat_buf
.st_size
;
3857 /* Allocate a buffer to hold the original text. */
3859 orig_text_base
= new_orig_text_base
= (char *) xmalloc (orig_size
+ 2);
3860 orig_text_limit
= new_orig_text_limit
= new_orig_text_base
+ orig_size
;
3862 /* Allocate a buffer to hold the cleaned-up version of the original text. */
3864 clean_text_base
= new_clean_text_base
= (char *) xmalloc (orig_size
+ 2);
3865 clean_text_limit
= new_clean_text_limit
= new_clean_text_base
+ orig_size
;
3866 clean_read_ptr
= clean_text_base
- 1;
3868 /* Allocate a buffer that will hopefully be large enough to hold the entire
3869 converted output text. As an initial guess for the maximum size of the
3870 output buffer, use 125% of the size of the original + some extra. This
3871 buffer can be expanded later as needed. */
3873 repl_size
= orig_size
+ (orig_size
>> 2) + 4096;
3874 repl_text_base
= (char *) xmalloc (repl_size
+ 2);
3875 repl_text_limit
= repl_text_base
+ repl_size
- 1;
3876 repl_write_ptr
= repl_text_base
- 1;
3881 /* Open the file to be converted in READ ONLY mode. */
3883 if ((input_file
= open (convert_path
, O_RDONLY
, 0444)) == -1)
3885 fprintf (stderr
, "%s: error: can't open file `%s' for reading: %s\n",
3886 pname
, shortpath (NULL
, convert_path
), sys_errlist
[errno
]);
3890 /* Read the entire original source text file into the original text buffer
3891 in one swell fwoop. Then figure out where the end of the text is and
3892 make sure that it ends with a newline followed by a null. */
3894 if (read (input_file
, new_orig_text_base
, orig_size
) != orig_size
)
3897 fprintf (stderr
, "\n%s: error: while reading input file `%s': %s\n",
3898 pname
, shortpath (NULL
, convert_path
), sys_errlist
[errno
]);
3905 if (orig_size
== 0 || orig_text_limit
[-1] != '\n')
3907 *new_orig_text_limit
++ = '\n';
3911 /* Create the cleaned up copy of the original text. */
3913 memcpy (new_clean_text_base
, orig_text_base
,
3914 (size_t) (orig_text_limit
- orig_text_base
));
3915 do_cleaning (new_clean_text_base
, new_clean_text_limit
);
3920 size_t clean_size
= orig_text_limit
- orig_text_base
;
3921 char *const clean_path
= (char *) alloca (strlen (convert_path
) + 6 + 1);
3923 /* Open (and create) the clean file. */
3925 strcpy (clean_path
, convert_path
);
3926 strcat (clean_path
, ".clean");
3927 if ((clean_file
= creat (clean_path
, 0666)) == -1)
3929 fprintf (stderr
, "%s: error: can't create/open clean file `%s': %s\n",
3931 shortpath (NULL
, clean_path
),
3932 sys_errlist
[errno
]);
3936 /* Write the clean file. */
3938 if (write (clean_file
, new_clean_text_base
, clean_size
) != clean_size
)
3939 fprintf (stderr
, "%s: error: while writing file `%s': %s\n",
3940 pname
, shortpath (NULL
, clean_path
), sys_errlist
[errno
]);
3946 /* Do a simplified scan of the input looking for things that were not
3947 mentioned in the aux info files because of the fact that they were
3948 in a region of the source which was preprocessed-out (via #if or
3951 scan_for_missed_items (file_p
);
3953 /* Setup to do line-oriented forward seeking in the clean text buffer. */
3955 last_known_line_number
= 1;
3956 last_known_line_start
= clean_text_base
;
3958 /* Now get down to business and make all of the necessary edits. */
3961 const def_dec_info
*def_dec_p
;
3963 first_definition_in_file
= 1;
3964 def_dec_p
= file_p
->defs_decs
;
3965 for (; def_dec_p
; def_dec_p
= def_dec_p
->next_in_file
)
3967 const char *clean_text_p
= seek_to_line (def_dec_p
->line
);
3969 /* clean_text_p now points to the first character of the line which
3970 contains the `terminator' for the declaration or definition that
3971 we are about to process. */
3975 if (global_flag
&& def_dec_p
->is_func_def
&& first_definition_in_file
)
3977 add_global_decls (def_dec_p
->file
, clean_text_p
);
3978 first_definition_in_file
= 0;
3981 /* Don't edit this item if it is already in prototype format or if it
3982 is a function declaration and we have found no corresponding
3985 if (def_dec_p
->prototyped
3986 || (!def_dec_p
->is_func_def
&& !def_dec_p
->definition
))
3989 #endif /* !defined(UNPROTOIZE) */
3991 if (def_dec_p
->is_func_def
)
3992 edit_fn_definition (def_dec_p
, clean_text_p
);
3995 if (def_dec_p
->is_implicit
)
3996 add_local_decl (def_dec_p
, clean_text_p
);
3998 #endif /* !defined(UNPROTOIZE) */
3999 edit_fn_declaration (def_dec_p
, clean_text_p
);
4003 /* Finalize things. Output the last trailing part of the original text. */
4005 output_up_to (clean_text_limit
- 1);
4007 /* If this is just a test run, stop now and just deallocate the buffers. */
4011 free (new_orig_text_base
);
4012 free (new_clean_text_base
);
4013 free (repl_text_base
);
4017 /* Change the name of the original input file. This is just a quick way of
4018 saving the original file. */
4023 (char *) xmalloc (strlen (convert_path
) + strlen (save_suffix
) + 2);
4025 strcpy (new_path
, convert_path
);
4026 strcat (new_path
, save_suffix
);
4027 if (link (convert_path
, new_path
) == -1)
4029 if (errno
== EEXIST
)
4032 fprintf (stderr
, "%s: warning: file `%s' already saved in `%s'\n",
4034 shortpath (NULL
, convert_path
),
4035 shortpath (NULL
, new_path
));
4039 fprintf (stderr
, "%s: error: can't link file `%s' to `%s': %s\n",
4041 shortpath (NULL
, convert_path
),
4042 shortpath (NULL
, new_path
),
4043 sys_errlist
[errno
]);
4049 if (unlink (convert_path
) == -1)
4051 fprintf (stderr
, "%s: error: can't delete file `%s': %s\n",
4053 shortpath (NULL
, convert_path
),
4054 sys_errlist
[errno
]);
4061 /* Open (and create) the output file. */
4063 if ((output_file
= creat (convert_path
, 0666)) == -1)
4065 fprintf (stderr
, "%s: error: can't create/open output file `%s': %s\n",
4067 shortpath (NULL
, convert_path
),
4068 sys_errlist
[errno
]);
4072 /* Write the output file. */
4075 unsigned int out_size
= (repl_write_ptr
+ 1) - repl_text_base
;
4077 if (write (output_file
, repl_text_base
, out_size
) != out_size
)
4078 fprintf (stderr
, "%s: error: while writing file `%s': %s\n",
4079 pname
, shortpath (NULL
, convert_path
), sys_errlist
[errno
]);
4082 close (output_file
);
4085 /* Deallocate the conversion buffers. */
4087 free (new_orig_text_base
);
4088 free (new_clean_text_base
);
4089 free (repl_text_base
);
4091 /* Change the mode of the output file to match the original file. */
4093 if (chmod (convert_path
, stat_buf
.st_mode
) == -1)
4094 fprintf (stderr
, "%s: error: can't change mode of file `%s': %s\n",
4095 pname
, shortpath (NULL
, convert_path
), sys_errlist
[errno
]);
4097 /* Note: We would try to change the owner and group of the output file
4098 to match those of the input file here, except that may not be a good
4099 thing to do because it might be misleading. Also, it might not even
4100 be possible to do that (on BSD systems with quotas for instance). */
4103 /* Do all of the individual steps needed to do the protoization (or
4104 unprotoization) of the files referenced in the aux_info files given
4105 in the command line. */
4108 do_processing (void)
4110 const char * const *base_pp
;
4111 const char * const * const end_pps
= &base_source_paths
[base_source_files
];
4115 #endif /* !defined(UNPROTOIZE) */
4117 /* One-by-one, check (and create if necessary), open, and read all of the
4118 stuff in each aux_info file. After reading each aux_info file, the
4119 aux_info_file just read will be automatically deleted unless the
4120 keep_flag is set. */
4122 for (base_pp
= base_source_paths
; base_pp
< end_pps
; base_pp
++)
4123 process_aux_info_file (*base_pp
, keep_flag
, 0);
4127 /* Also open and read the special SYSCALLS.c aux_info file which gives us
4128 the prototypes for all of the standard system-supplied functions. */
4130 if (nondefault_syscalls_dir
)
4133 = (char *) xmalloc (strlen (nondefault_syscalls_dir
)
4134 + strlen (syscalls_filename
) + 1);
4135 strcpy (syscalls_pathname
, nondefault_syscalls_dir
);
4140 = (char *) xmalloc (strlen (default_syscalls_dir
)
4141 + strlen (syscalls_filename
) + 1);
4142 strcpy (syscalls_pathname
, default_syscalls_dir
);
4145 syscalls_len
= strlen (syscalls_pathname
);
4146 if (*(syscalls_pathname
+ syscalls_len
- 1) != '/')
4148 *(syscalls_pathname
+ syscalls_len
++) = '/';
4149 *(syscalls_pathname
+ syscalls_len
) = '\0';
4151 strcat (syscalls_pathname
, syscalls_filename
);
4153 /* Call process_aux_info_file in such a way that it does not try to
4154 delete the SYSCALLS aux_info file. */
4156 process_aux_info_file (syscalls_pathname
, 1, 1);
4158 #endif /* !defined(UNPROTOIZE) */
4160 /* When we first read in all of the information from the aux_info files
4161 we saved in it decending line number order, because that was likely to
4162 be faster. Now however, we want the chains of def & dec records to
4163 appear in ascending line number order as we get further away from the
4164 file_info record that they hang from. The following line causes all of
4165 these lists to be rearranged into ascending line number order. */
4167 visit_each_hash_node (pathname_primary
, reverse_def_dec_list
);
4171 /* Now do the "real" work. The following line causes each declaration record
4172 to be "visited". For each of these nodes, an attempt is made to match
4173 up the function declaration with a corresponding function definition,
4174 which should have a full prototype-format formals list with it. Once
4175 these match-ups are made, the conversion of the function declarations
4176 to prototype format can be made. */
4178 visit_each_hash_node (function_name_primary
, connect_defs_and_decs
);
4180 #endif /* !defined(UNPROTOIZE) */
4182 /* Now convert each file that can be converted (and needs to be). */
4184 visit_each_hash_node (pathname_primary
, edit_file
);
4188 /* If we are working in cplusplus mode, try to rename all .c files to .C
4189 files. Don't panic if some of the renames don't work. */
4191 if (cplusplus_flag
&& !nochange_flag
)
4192 visit_each_hash_node (pathname_primary
, rename_c_file
);
4194 #endif /* !defined(UNPROTOIZE) */
4197 static struct option longopts
[] =
4199 {"version", 0, 0, 'V'},
4200 {"quiet", 0, 0, 'q'},
4201 {"silent", 0, 0, 'q'},
4202 {"force", 0, 0, 'f'},
4203 {"keep", 0, 0, 'k'},
4204 {"nosave", 0, 0, 'N'},
4205 {"nochange", 0, 0, 'n'},
4206 {"compiler-options", 1, 0, 'c'},
4207 {"exclude", 1, 0, 'x'},
4208 {"directory", 1, 0, 'd'},
4210 {"indent", 1, 0, 'i'},
4212 {"local", 0, 0, 'l'},
4213 {"global", 0, 0, 'g'},
4215 {"syscalls-dir", 1, 0, 'B'},
4221 main (int argc
, char **const argv
)
4227 pname
= strrchr (argv
[0], '/');
4228 pname
= pname
? pname
+1 : argv
[0];
4230 /* Read the working directory, avoiding arbitrary limit. */
4236 cwd_buffer
= (char *) xmalloc (size
);
4237 value
= getcwd (cwd_buffer
, size
);
4238 if (value
> 0 && value
< size
)
4244 /* By default, convert the files in the current directory. */
4245 directory_list
= string_list_cons (cwd_buffer
, NULL
);
4247 while ((c
= getopt_long (argc
, argv
,
4253 longopts
, &longind
)) != EOF
)
4255 if (c
== 0) /* Long option. */
4256 c
= longopts
[longind
].val
;
4261 = string_list_cons (abspath (NULL
, optarg
), directory_list
);
4264 exclude_list
= string_list_cons (optarg
, exclude_list
);
4289 munge_compile_params (optarg
);
4293 indent_string
= optarg
;
4295 #else /* !defined(UNPROTOIZE) */
4306 nondefault_syscalls_dir
= optarg
;
4308 #endif /* !defined(UNPROTOIZE) */
4314 base_source_files
= argc
- optind
;
4316 /* Now actually make a list of the base source pathnames. */
4319 (const char **) xmalloc ((base_source_files
+ 1) * sizeof (char *));
4320 base_source_files
= 0;
4321 for (; optind
< argc
; optind
++)
4323 const char *path
= abspath (NULL
, argv
[optind
]);
4324 int len
= strlen (path
);
4326 if (path
[len
-1] == 'c' && path
[len
-2] == '.')
4327 base_source_paths
[base_source_files
++] = path
;
4330 fprintf (stderr
, "%s: input pathnames must have .c suffixes: %s\n",
4331 pname
, shortpath (NULL
, path
));
4337 /* We are only interested in the very first identifier token in the
4338 definition of `va_list', so if there is more junk after that first
4339 identifier token, delete it from the `varargs_style_indicator'. */
4343 for (cp
= varargs_style_indicator
; isalnum (*cp
) || *cp
== '_'; cp
++)
4346 varargs_style_indicator
= savestring (varargs_style_indicator
,
4347 cp
- varargs_style_indicator
);
4349 #endif /* !defined(UNPROTOIZE) */
4356 fprintf (stderr
, "%s: %s\n", pname
, version_string
);