![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to protoize.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to protoize.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Protoize program - Original version by Ron Guilmette at MCC.
2:
3: Copyright (C) 1989, 1992 Free Software Foundation, Inc.
4:
5: This file is part of GNU CC.
6:
7: GNU CC is free software; you can redistribute it and/or modify
8: it under the terms of the GNU General Public License as published by
9: the Free Software Foundation; either version 2, or (at your option)
10: any later version.
11:
12: GNU CC is distributed in the hope that it will be useful,
13: but WITHOUT ANY WARRANTY; without even the implied warranty of
14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: GNU General Public License for more details.
16:
17: You should have received a copy of the GNU General Public License
18: along with GNU CC; see the file COPYING. If not, write to
19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20:
21: /* Any reasonable C++ compiler should have all of the same features
22: as __STDC__ plus more, so make sure that __STDC__ is defined if
23: __cplusplus is defined. */
24:
25: #if defined(__cplusplus) && !defined(__STDC__)
26: #define __STDC__ 1
27: #endif /* defined(__cplusplus) && !defined(__STDC__) */
28:
29: #if defined(__GNUC__) || defined (__GNUG__)
30: #define VOLATILE volatile
31: #else
32: #define VOLATILE
33: #endif
34:
35: #ifndef __STDC__
36: #define const
37: #define volatile
38: #endif
39:
40: #include "config.h"
41:
42: #if 0
43: /* Users are not supposed to use _POSIX_SOURCE to say the
44: system is a POSIX system. That is not what _POSIX_SOURCE means! -- rms */
45: /* If the user asked for POSIX via _POSIX_SOURCE, turn on POSIX code. */
46: #if defined(_POSIX_SOURCE) && !defined(POSIX)
47: #define POSIX
48: #endif
49: #endif /* 0 */
50:
51: #ifdef POSIX /* We should be able to define _POSIX_SOURCE unconditionally,
52: but some systems respond in buggy ways to it,
53: including SunOS 4.1.1. Which we don't classify as POSIX. */
54: /* In case this is a POSIX system with an ANSI C compiler,
55: ask for definition of all POSIX facilities. */
56: #undef _POSIX_SOURCE
57: #define _POSIX_SOURCE
58: #endif
59:
60: #include "gvarargs.h"
61: /* On some systems stdio.h includes stdarg.h;
62: we must bring in gvarargs.h first. */
63: #include <stdio.h>
64: #include <ctype.h>
65: #include <errno.h>
66: #include <sys/types.h>
67: #include <sys/stat.h>
68: #ifdef POSIX
69: #include <dirent.h>
70: #else
71: #include <sys/dir.h>
72: #endif
73: #include <setjmp.h>
74:
75: /* Include getopt.h for the sake of getopt_long.
76: We don't need the declaration of getopt, and it could conflict
77: with something from a system header file, so effectively nullify that. */
78: #define getopt getopt_loser
79: #include "getopt.h"
80: #undef getopt
81:
82: extern int errno;
83: #if defined(bsd4_4)
84: extern const char *const sys_errlist[];
85: #else
86: extern char *sys_errlist[];
87: #endif
88: extern char *version_string;
89:
90: /* Systems which are compatible only with POSIX 1003.1-1988 (but *not*
91: with POSIX 1003.1-1990), e.g. Ultrix 4.2, might not have
92: const qualifiers in the prototypes in the system include files.
93: Unfortunately, this can lead to GCC issuing lots of warnings for
94: calls to the following functions. To eliminate these warnings we
95: provide the following #defines. */
96:
97: #define my_access(file,flag) access((char *)file, flag)
98: #define my_stat(file,pkt) stat((char *)file, pkt)
99: #define my_execvp(prog,argv) execvp((char *)prog, (char **)argv)
100: #define my_link(file1, file2) link((char *)file1, (char *)file2)
101: #define my_unlink(file) unlink((char *)file)
102: #define my_open(file, mode, flag) open((char *)file, mode, flag)
103: #define my_chmod(file, mode) chmod((char *)file, mode)
104:
105: extern char *getpwd ();
106:
107: /* Aliases for pointers to void.
108: These were made to facilitate compilation with old brain-dead DEC C
109: compilers which didn't properly grok `void*' types. */
110:
111: #ifdef __STDC__
112: typedef void * pointer_type;
113: typedef const void * const_pointer_type;
114: #else
115: typedef char * pointer_type;
116: typedef char * const_pointer_type;
117: #endif
118:
119: #if defined(POSIX)
120:
121: #include <stdlib.h>
122: #include <unistd.h>
123: #include <signal.h>
124: #include <fcntl.h>
125:
126: #else /* !defined(POSIX) */
127:
128: #define R_OK 4 /* Test for Read permission */
129: #define W_OK 2 /* Test for Write permission */
130: #define X_OK 1 /* Test for eXecute permission */
131: #define F_OK 0 /* Test for existence of File */
132:
133: #define O_RDONLY 0
134: #define O_WRONLY 1
135:
136: /* Declaring stat or __flsbuf with a prototype
137: causes conflicts with system headers on some systems. */
138:
139: #ifndef abort
140: typedef void voidfn ();
141: extern VOLATILE voidfn abort;
142: #endif
143: extern int kill ();
144: extern int creat ();
145: #if 0 /* These conflict with stdio.h on some systems. */
146: extern int fprintf (FILE *, const char *, ...);
147: extern int printf (const char *, ...);
148: extern int open (const char *, int, ...);
149: #endif /* 0 */
150: extern void exit ();
151: extern void free ();
152: extern int read ();
153: extern int write ();
154: extern int close ();
155: extern int fflush ();
156: extern int atoi ();
157: extern int puts ();
158: extern int fputs ();
159: extern int fputc ();
160: extern int link ();
161: extern int unlink ();
162: extern int access ();
163: extern int execvp ();
164: /* In 2.6, try deleting these decls entirely since setjmp.h should
165: take care of them. */
166: #ifndef __NeXT__
167: #ifndef setjmp
168: extern int setjmp ();
169: #endif
170: #ifndef longjmp
171: extern void longjmp ();
172: #endif
173: #endif
174:
175: #if 0 /* size_t from sys/types.h may fail to match GCC.
176: If so, we would get a warning from this. */
177: extern size_t strlen ()
178: #endif
179:
180: /* Fork is not declared because the declaration caused a conflict
181: on the HPPA. */
182: #if !(defined (USG) || defined (VMS))
183: #define fork vfork
184: #endif /* (defined (USG) || defined (VMS)) */
185:
186: #endif /* !defined (POSIX) */
187:
188: extern char *rindex ();
189:
190: /* Look for these where the `const' qualifier is intentionally cast aside. */
191:
192: #define NONCONST
193:
194: /* Define a STRINGIFY macro that's right for ANSI or traditional C. */
195:
196: #ifdef __STDC__
197: #define STRINGIFY(STRING) #STRING
198: #else
199: #define STRINGIFY(STRING) "STRING"
200: #endif
201:
202: /* Define a default place to find the SYSCALLS.X file. */
203:
204: #ifndef STD_PROTO_DIR
205: #define STD_PROTO_DIR "/usr/local/lib"
206: #endif /* !defined (STD_PROTO_DIR) */
207:
208: /* Suffix of aux_info files. */
209:
210: static const char * const aux_info_suffix = ".X";
211:
212: /* String to attach to filenames for saved versions of original files. */
213:
214: static const char * const save_suffix = ".save";
215:
216: #ifndef UNPROTOIZE
217:
218: /* File name of the file which contains descriptions of standard system
219: routines. Note that we never actually do anything with this file per se,
220: but we do read in its corresponding aux_info file. */
221:
222: static const char syscalls_filename[] = "SYSCALLS.c";
223:
224: /* Default place to find the above file. */
225:
226: static const char * const default_syscalls_dir = STD_PROTO_DIR;
227:
228: /* Variable to hold the complete absolutized filename of the SYSCALLS.c.X
229: file. */
230:
231: static char * syscalls_absolute_filename;
232:
233: #endif /* !defined (UNPROTOIZE) */
234:
235: /* Type of the structure that holds information about macro unexpansions. */
236:
237: struct unexpansion_struct {
238: const char *expanded;
239: const char *contracted;
240: };
241: typedef struct unexpansion_struct unexpansion;
242:
243: /* A table of conversions that may need to be made for some (stupid) older
244: operating systems where these types are preprocessor macros rather than
245: typedefs (as they really ought to be).
246:
247: WARNING: The contracted forms must be as small (or smaller) as the
248: expanded forms, or else havoc will ensue. */
249:
250: static const unexpansion unexpansions[] = {
251: { "struct _iobuf", "FILE" },
252: { 0, 0 }
253: };
254:
255: /* The number of "primary" slots in the hash tables for filenames and for
256: function names. This can be as big or as small as you like, except that
257: it must be a power of two. */
258:
259: #define HASH_TABLE_SIZE (1 << 9)
260:
261: /* Bit mask to use when computing hash values. */
262:
263: static const int hash_mask = (HASH_TABLE_SIZE - 1);
264:
265: /* Make a table of default system include directories
266: just as it is done in cccp.c. */
267:
268: #ifndef STANDARD_INCLUDE_DIR
269: #define STANDARD_INCLUDE_DIR "/usr/include"
270: #endif
271:
272: #ifndef LOCAL_INCLUDE_DIR
273: #define LOCAL_INCLUDE_DIR "/usr/local/include"
274: #endif
275:
276: struct default_include { const char *fname; int cplusplus; } include_defaults[]
277: #ifdef INCLUDE_DEFAULTS
278: = INCLUDE_DEFAULTS;
279: #else
280: = {
281: /* Pick up GNU C++ specific include files. */
282: { GPLUSPLUS_INCLUDE_DIR, 1},
283: #ifdef CROSS_COMPILE
284: /* This is the dir for fixincludes. Put it just before
285: the files that we fix. */
286: { GCC_INCLUDE_DIR, 0},
287: /* For cross-compilation, this dir name is generated
288: automatically in Makefile.in. */
289: { CROSS_INCLUDE_DIR, 0 },
290: /* This is another place that the target system's headers might be. */
291: { TOOL_INCLUDE_DIR, 0},
292: #else /* not CROSS_COMPILE */
293: /* This should be /use/local/include and should come before
294: the fixincludes-fixed header files. */
295: { LOCAL_INCLUDE_DIR, 0},
296: /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
297: Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h. */
298: { TOOL_INCLUDE_DIR, 0},
299: /* This is the dir for fixincludes. Put it just before
300: the files that we fix. */
301: { GCC_INCLUDE_DIR, 0},
302: /* Some systems have an extra dir of include files. */
303: #ifdef SYSTEM_INCLUDE_DIR
304: { SYSTEM_INCLUDE_DIR, 0},
305: #endif
306: { STANDARD_INCLUDE_DIR, 0},
307: #endif /* not CROSS_COMPILE */
308: { 0, 0}
309: };
310: #endif /* no INCLUDE_DEFAULTS */
311:
312: /* Datatype for lists of directories or filenames. */
313: struct string_list
314: {
315: char *name;
316: struct string_list *next;
317: };
318:
319: /* List of directories in which files should be converted. */
320:
321: struct string_list *directory_list;
322:
323: /* List of file names which should not be converted.
324: A file is excluded if the end of its name, following a /,
325: matches one of the names in this list. */
326:
327: struct string_list *exclude_list;
328:
329: /* The name of the other style of variable-number-of-parameters functions
330: (i.e. the style that we want to leave unconverted because we don't yet
331: know how to convert them to this style. This string is used in warning
332: messages. */
333:
334: /* Also define here the string that we can search for in the parameter lists
335: taken from the .X files which will unambiguously indicate that we have
336: found a varargs style function. */
337:
338: #ifdef UNPROTOIZE
339: static const char * const other_var_style = "stdarg";
340: #else /* !defined (UNPROTOIZE) */
341: static const char * const other_var_style = "varargs";
342: /* Note that this is a string containing the expansion of va_alist.
343: But in `main' we discard all but the first token. */
344: static const char *varargs_style_indicator = STRINGIFY (va_alist);
345: #endif /* !defined (UNPROTOIZE) */
346:
347: /* The following two types are used to create hash tables. In this program,
348: there are two hash tables which are used to store and quickly lookup two
349: different classes of strings. The first type of strings stored in the
350: first hash table are absolute filenames of files which protoize needs to
351: know about. The second type of strings (stored in the second hash table)
352: are function names. It is this second class of strings which really
353: inspired the use of the hash tables, because there may be a lot of them. */
354:
355: typedef struct hash_table_entry_struct hash_table_entry;
356:
357: /* Do some typedefs so that we don't have to write "struct" so often. */
358:
359: typedef struct def_dec_info_struct def_dec_info;
360: typedef struct file_info_struct file_info;
361: typedef struct f_list_chain_item_struct f_list_chain_item;
362:
363: /* In the struct below, note that the "_info" field has two different uses
364: depending on the type of hash table we are in (i.e. either the filenames
365: hash table or the function names hash table). In the filenames hash table
366: the info fields of the entries point to the file_info struct which is
367: associated with each filename (1 per filename). In the function names
368: hash table, the info field points to the head of a singly linked list of
369: def_dec_info entries which are all defs or decs of the function whose
370: name is pointed to by the "symbol" field. Keeping all of the defs/decs
371: for a given function name on a special list specifically for that function
372: name makes it quick and easy to find out all of the important information
373: about a given (named) function. */
374:
375: struct hash_table_entry_struct {
376: hash_table_entry * hash_next; /* -> to secondary entries */
377: const char * symbol; /* -> to the hashed string */
378: union {
379: const def_dec_info * _ddip;
380: file_info * _fip;
381: } _info;
382: };
383: #define ddip _info._ddip
384: #define fip _info._fip
385:
386: /* Define a type specifically for our two hash tables. */
387:
388: typedef hash_table_entry hash_table[HASH_TABLE_SIZE];
389:
390: /* The following struct holds all of the important information about any
391: single filename (e.g. file) which we need to know about. */
392:
393: struct file_info_struct {
394: const hash_table_entry * hash_entry; /* -> to associated hash entry */
395: const def_dec_info * defs_decs; /* -> to chain of defs/decs */
396: time_t mtime; /* Time of last modification. */
397: };
398:
399: /* Due to the possibility that functions may return pointers to functions,
400: (which may themselves have their own parameter lists) and due to the
401: fact that returned pointers-to-functions may be of type "pointer-to-
402: function-returning-pointer-to-function" (ad nauseum) we have to keep
403: an entire chain of ANSI style formal parameter lists for each function.
404:
405: Normally, for any given function, there will only be one formals list
406: on the chain, but you never know.
407:
408: Note that the head of each chain of formals lists is pointed to by the
409: `f_list_chain' field of the corresponding def_dec_info record.
410:
411: For any given chain, the item at the head of the chain is the *leftmost*
412: parameter list seen in the actual C language function declaration. If
413: there are other members of the chain, then these are linked in left-to-right
414: order from the head of the chain. */
415:
416: struct f_list_chain_item_struct {
417: const f_list_chain_item * chain_next; /* -> to next item on chain */
418: const char * formals_list; /* -> to formals list string */
419: };
420:
421: /* The following struct holds all of the important information about any
422: single function definition or declaration which we need to know about.
423: Note that for unprotoize we don't need to know very much because we
424: never even create records for stuff that we don't intend to convert
425: (like for instance defs and decs which are already in old K&R format
426: and "implicit" function declarations). */
427:
428: struct def_dec_info_struct {
429: const def_dec_info * next_in_file; /* -> to rest of chain for file */
430: file_info * file; /* -> file_info for containing file */
431: int line; /* source line number of def/dec */
432: const char * ansi_decl; /* -> left end of ansi decl */
433: hash_table_entry * hash_entry; /* -> hash entry for function name */
434: unsigned int is_func_def; /* = 0 means this is a declaration */
435: const def_dec_info * next_for_func; /* -> to rest of chain for func name */
436: unsigned int f_list_count; /* count of formals lists we expect */
437: char prototyped; /* = 0 means already prototyped */
438: #ifndef UNPROTOIZE
439: const f_list_chain_item * f_list_chain; /* -> chain of formals lists */
440: const def_dec_info * definition; /* -> def/dec containing related def */
441: char is_static; /* = 0 means visibility is "extern" */
442: char is_implicit; /* != 0 for implicit func decl's */
443: char written; /* != 0 means written for implicit */
444: #else /* !defined (UNPROTOIZE) */
445: const char * formal_names; /* -> to list of names of formals */
446: const char * formal_decls; /* -> to string of formal declarations */
447: #endif /* !defined (UNPROTOIZE) */
448: };
449:
450: /* Pointer to the tail component of the filename by which this program was
451: invoked. Used everywhere in error and warning messages. */
452:
453: static const char *pname;
454:
455: /* Error counter. Will be non-zero if we should give up at the next convenient
456: stopping point. */
457:
458: static int errors = 0;
459:
460: /* Option flags. */
461: /* ??? These comments should say what the flag mean as well as the options
462: that set them. */
463:
464: /* File name to use for running gcc. Allows GCC 2 to be named
465: something other than gcc. */
466: static const char *compiler_file_name = "gcc";
467:
468: static int version_flag = 0; /* Print our version number. */
469: static int quiet_flag = 0; /* Don't print messages normally. */
470: static int nochange_flag = 0; /* Don't convert, just say what files
471: we would have converted. */
472: static int nosave_flag = 0; /* Don't save the old version. */
473: static int keep_flag = 0; /* Don't delete the .X files. */
474: static const char ** compile_params = 0; /* Option string for gcc. */
475: #ifdef UNPROTOIZE
476: static const char *indent_string = " "; /* Indentation for newly
477: inserted parm decls. */
478: #else /* !defined (UNPROTOIZE) */
479: static int local_flag = 0; /* Insert new local decls (when?). */
480: static int global_flag = 0; /* set by -g option */
481: static int cplusplus_flag = 0; /* Rename converted files to *.C. */
482: static const char* nondefault_syscalls_dir = 0; /* Dir to look for
483: SYSCALLS.c.X in. */
484: #endif /* !defined (UNPROTOIZE) */
485:
486: /* An index into the compile_params array where we should insert the source
487: file name when we are ready to exec the C compiler. A zero value indicates
488: that we have not yet called munge_compile_params. */
489:
490: static int input_file_name_index = 0;
491:
492: /* An index into the compile_params array where we should insert the filename
493: for the aux info file, when we run the C compiler. */
494: static int aux_info_file_name_index = 0;
495:
496: /* Count of command line arguments which were "filename" arguments. */
497:
498: static int n_base_source_files = 0;
499:
500: /* Points to a malloc'ed list of pointers to all of the filenames of base
501: source files which were specified on the command line. */
502:
503: static const char **base_source_filenames;
504:
505: /* Line number of the line within the current aux_info file that we
506: are currently processing. Used for error messages in case the prototypes
507: info file is corrupted somehow. */
508:
509: static int current_aux_info_lineno;
510:
511: /* Pointer to the name of the source file currently being converted. */
512:
513: static const char *convert_filename;
514:
515: /* Pointer to relative root string (taken from aux_info file) which indicates
516: where directory the user was in when he did the compilation step that
517: produced the containing aux_info file. */
518:
519: static const char *invocation_filename;
520:
521: /* Pointer to the base of the input buffer that holds the original text for the
522: source file currently being converted. */
523:
524: static const char *orig_text_base;
525:
526: /* Pointer to the byte just beyond the end of the input buffer that holds the
527: original text for the source file currently being converted. */
528:
529: static const char *orig_text_limit;
530:
531: /* Pointer to the base of the input buffer that holds the cleaned text for the
532: source file currently being converted. */
533:
534: static const char *clean_text_base;
535:
536: /* Pointer to the byte just beyond the end of the input buffer that holds the
537: cleaned text for the source file currently being converted. */
538:
539: static const char *clean_text_limit;
540:
541: /* Pointer to the last byte in the cleaned text buffer that we have already
542: (virtually) copied to the output buffer (or decided to ignore). */
543:
544: static const char * clean_read_ptr;
545:
546: /* Pointer to the base of the output buffer that holds the replacement text
547: for the source file currently being converted. */
548:
549: static char *repl_text_base;
550:
551: /* Pointer to the byte just beyond the end of the output buffer that holds the
552: replacement text for the source file currently being converted. */
553:
554: static char *repl_text_limit;
555:
556: /* Pointer to the last byte which has been stored into the output buffer.
557: The next byte to be stored should be stored just past where this points
558: to. */
559:
560: static char * repl_write_ptr;
561:
562: /* Pointer into the cleaned text buffer for the source file we are currently
563: converting. This points to the first character of the line that we last
564: did a "seek_to_line" to (see below). */
565:
566: static const char *last_known_line_start;
567:
568: /* Number of the line (in the cleaned text buffer) that we last did a
569: "seek_to_line" to. Will be one if we just read a new source file
570: into the cleaned text buffer. */
571:
572: static int last_known_line_number;
573:
574: /* The filenames hash table. */
575:
576: static hash_table filename_primary;
577:
578: /* The function names hash table. */
579:
580: static hash_table function_name_primary;
581:
582: /* The place to keep the recovery address which is used only in cases where
583: we get hopelessly confused by something in the cleaned original text. */
584:
585: static jmp_buf source_confusion_recovery;
586:
587: /* A pointer to the current directory filename (used by abspath). */
588:
589: static char *cwd_buffer;
590:
591: /* A place to save the read pointer until we are sure that an individual
592: attempt at editing will succeed. */
593:
594: static const char * saved_clean_read_ptr;
595:
596: /* A place to save the write pointer until we are sure that an individual
597: attempt at editing will succeed. */
598:
599: static char * saved_repl_write_ptr;
600:
601: /* Forward declaration. */
602:
603: static const char *shortpath ();
604:
605: /* Allocate some space, but check that the allocation was successful. */
606: /* alloca.c uses this, so don't make it static. */
607:
608: pointer_type
609: xmalloc (byte_count)
610: size_t byte_count;
611: {
612: pointer_type rv;
613:
614: rv = (pointer_type) malloc (byte_count);
615: if (rv == NULL)
616: {
617: fprintf (stderr, "\n%s: virtual memory exceeded\n", pname);
618: exit (1);
619: return 0; /* avoid warnings */
620: }
621: else
622: return rv;
623: }
624:
625: /* Reallocate some space, but check that the reallocation was successful. */
626:
627: pointer_type
628: xrealloc (old_space, byte_count)
629: pointer_type old_space;
630: size_t byte_count;
631: {
632: pointer_type rv;
633:
634: rv = (pointer_type) realloc (old_space, byte_count);
635: if (rv == NULL)
636: {
637: fprintf (stderr, "\n%s: virtual memory exceeded\n", pname);
638: exit (1);
639: return 0; /* avoid warnings */
640: }
641: else
642: return rv;
643: }
644:
645: /* Deallocate the area pointed to by an arbitrary pointer, but first, strip
646: the `const' qualifier from it and also make sure that the pointer value
647: is non-null. */
648:
649: void
650: xfree (p)
651: const_pointer_type p;
652: {
653: if (p)
654: free ((NONCONST pointer_type) p);
655: }
656:
657: /* Make a copy of a string INPUT with size SIZE. */
658:
659: static char *
660: savestring (input, size)
661: const char *input;
662: unsigned int size;
663: {
664: char *output = (char *) xmalloc (size + 1);
665: strcpy (output, input);
666: return output;
667: }
668:
669: /* Make a copy of the concatenation of INPUT1 and INPUT2. */
670:
671: static char *
672: savestring2 (input1, size1, input2, size2)
673: const char *input1;
674: unsigned int size1;
675: const char *input2;
676: unsigned int size2;
677: {
678: char *output = (char *) xmalloc (size1 + size2 + 1);
679: strcpy (output, input1);
680: strcpy (&output[size1], input2);
681: return output;
682: }
683:
684: /* More 'friendly' abort that prints the line and file.
685: config.h can #define abort fancy_abort if you like that sort of thing. */
686:
687: void
688: fancy_abort ()
689: {
690: fprintf (stderr, "%s: internal abort\n", pname);
691: exit (1);
692: }
693:
694: /* Make a duplicate of the first N bytes of a given string in a newly
695: allocated area. */
696:
697: static char *
698: dupnstr (s, n)
699: const char *s;
700: size_t n;
701: {
702: char *ret_val = (char *) xmalloc (n + 1);
703:
704: strncpy (ret_val, s, n);
705: ret_val[n] = '\0';
706: return ret_val;
707: }
708:
709: /* Return a pointer to the first occurrence of s2 within s1 or NULL if s2
710: does not occur within s1. Assume neither s1 nor s2 are null pointers. */
711:
712: static const char *
713: substr (s1, s2)
714: const char *s1;
715: const char *const s2;
716: {
717: for (; *s1 ; s1++)
718: {
719: const char *p1;
720: const char *p2;
721: int c;
722:
723: for (p1 = s1, p2 = s2; c = *p2; p1++, p2++)
724: if (*p1 != c)
725: goto outer;
726: return s1;
727: outer:
728: ;
729: }
730: return 0;
731: }
732:
733: /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
734: retrying if necessary. Return the actual number of bytes read. */
735:
736: static int
737: safe_read (desc, ptr, len)
738: int desc;
739: char *ptr;
740: int len;
741: {
742: int left = len;
743: while (left > 0) {
744: int nchars = read (desc, ptr, left);
745: if (nchars < 0)
746: {
747: #ifdef EINTR
748: if (errno == EINTR)
749: continue;
750: #endif
751: return nchars;
752: }
753: if (nchars == 0)
754: break;
755: ptr += nchars;
756: left -= nchars;
757: }
758: return len - left;
759: }
760:
761: /* Write LEN bytes at PTR to descriptor DESC,
762: retrying if necessary, and treating any real error as fatal. */
763:
764: static void
765: safe_write (desc, ptr, len, out_fname)
766: int desc;
767: char *ptr;
768: int len;
769: char *out_fname;
770: {
771: while (len > 0) {
772: int written = write (desc, ptr, len);
773: if (written < 0)
774: {
775: #ifdef EINTR
776: if (errno == EINTR)
777: continue;
778: #endif
779: fprintf (stderr, "%s: error writing file `%s': %s\n",
780: pname, shortpath (NULL, out_fname), sys_errlist[errno]);
781: return;
782: }
783: ptr += written;
784: len -= written;
785: }
786: }
787:
788: /* Get setup to recover in case the edit we are about to do goes awry. */
789:
790: void
791: save_pointers ()
792: {
793: saved_clean_read_ptr = clean_read_ptr;
794: saved_repl_write_ptr = repl_write_ptr;
795: }
796:
797: /* Call this routine to recover our previous state whenever something looks
798: too confusing in the source code we are trying to edit. */
799:
800: void
801: restore_pointers ()
802: {
803: clean_read_ptr = saved_clean_read_ptr;
804: repl_write_ptr = saved_repl_write_ptr;
805: }
806:
807: /* Return true if the given character is a legal identifier character. */
808:
809: static int
810: is_id_char (ch)
811: char ch;
812: {
813: return (isalnum (ch) || (ch == '_') || (ch == '$'));
814: }
815:
816: /* Give a message indicating the proper way to invoke this program and then
817: exit with non-zero status. */
818:
819: static void
820: usage ()
821: {
822: #ifdef UNPROTOIZE
823: fprintf (stderr, "%s: usage '%s [ -VqfnkN ] [ -i <istring> ] [ filename ... ]'\n",
824: pname, pname);
825: #else /* !defined (UNPROTOIZE) */
826: fprintf (stderr, "%s: usage '%s [ -VqfnkNlgC ] [ -B <diname> ] [ filename ... ]'\n",
827: pname, pname);
828: #endif /* !defined (UNPROTOIZE) */
829: exit (1);
830: }
831:
832: /* Return true if the given filename (assumed to be an absolute filename)
833: designates a file residing anywhere beneath any one of the "system"
834: include directories. */
835:
836: static int
837: in_system_include_dir (path)
838: const char *path;
839: {
840: struct default_include *p;
841:
842: if (path[0] != '/')
843: abort (); /* Must be an absolutized filename. */
844:
845: for (p = include_defaults; p->fname; p++)
846: if (!strncmp (path, p->fname, strlen (p->fname))
847: && path[strlen (p->fname)] == '/')
848: return 1;
849: return 0;
850: }
851:
852: #if 0
853: /* Return true if the given filename designates a file that the user has
854: read access to and for which the user has write access to the containing
855: directory. */
856:
857: static int
858: file_could_be_converted (const char *path)
859: {
860: char *const dir_name = (char *) alloca (strlen (path) + 1);
861:
862: if (my_access (path, R_OK))
863: return 0;
864:
865: {
866: char *dir_last_slash;
867:
868: strcpy (dir_name, path);
869: dir_last_slash = rindex (dir_name, '/');
870: if (dir_last_slash)
871: *dir_last_slash = '\0';
872: else
873: abort (); /* Should have been an absolutized filename. */
874: }
875:
876: if (my_access (path, W_OK))
877: return 0;
878:
879: return 1;
880: }
881:
882: /* Return true if the given filename designates a file that we are allowed
883: to modify. Files which we should not attempt to modify are (a) "system"
884: include files, and (b) files which the user doesn't have write access to,
885: and (c) files which reside in directories which the user doesn't have
886: write access to. Unless requested to be quiet, give warnings about
887: files that we will not try to convert for one reason or another. An
888: exception is made for "system" include files, which we never try to
889: convert and for which we don't issue the usual warnings. */
890:
891: static int
892: file_normally_convertible (const char *path)
893: {
894: char *const dir_name = alloca (strlen (path) + 1);
895:
896: if (in_system_include_dir (path))
897: return 0;
898:
899: {
900: char *dir_last_slash;
901:
902: strcpy (dir_name, path);
903: dir_last_slash = rindex (dir_name, '/');
904: if (dir_last_slash)
905: *dir_last_slash = '\0';
906: else
907: abort (); /* Should have been an absolutized filename. */
908: }
909:
910: if (my_access (path, R_OK))
911: {
912: if (!quiet_flag)
913: fprintf (stderr, "%s: warning: no read access for file `%s'\n",
914: pname, shortpath (NULL, path));
915: return 0;
916: }
917:
918: if (my_access (path, W_OK))
919: {
920: if (!quiet_flag)
921: fprintf (stderr, "%s: warning: no write access for file `%s'\n",
922: pname, shortpath (NULL, path));
923: return 0;
924: }
925:
926: if (my_access (dir_name, W_OK))
927: {
928: if (!quiet_flag)
929: fprintf (stderr, "%s: warning: no write access for dir containing `%s'\n",
930: pname, shortpath (NULL, path));
931: return 0;
932: }
933:
934: return 1;
935: }
936: #endif /* 0 */
937:
938: #ifndef UNPROTOIZE
939:
940: /* Return true if the given file_info struct refers to the special SYSCALLS.c.X
941: file. Return false otherwise. */
942:
943: static int
944: is_syscalls_file (fi_p)
945: const file_info *fi_p;
946: {
947: char const *f = fi_p->hash_entry->symbol;
948: size_t fl = strlen (f), sysl = sizeof (syscalls_filename) - 1;
949: return sysl <= fl && strcmp (f + fl - sysl, syscalls_filename) == 0;
950: }
951:
952: #endif /* !defined (UNPROTOIZE) */
953:
954: /* Check to see if this file will need to have anything done to it on this
955: run. If there is nothing in the given file which both needs conversion
956: and for which we have the necessary stuff to do the conversion, return
957: false. Otherwise, return true.
958:
959: Note that (for protoize) it is only valid to call this function *after*
960: the connections between declarations and definitions have all been made
961: by connect_defs_and_decs. */
962:
963: static int
964: needs_to_be_converted (file_p)
965: const file_info *file_p;
966: {
967: const def_dec_info *ddp;
968:
969: #ifndef UNPROTOIZE
970:
971: if (is_syscalls_file (file_p))
972: return 0;
973:
974: #endif /* !defined (UNPROTOIZE) */
975:
976: for (ddp = file_p->defs_decs; ddp; ddp = ddp->next_in_file)
977:
978: if (
979:
980: #ifndef UNPROTOIZE
981:
982: /* ... and if we a protoizing and this function is in old style ... */
983: !ddp->prototyped
984: /* ... and if this a definition or is a decl with an associated def ... */
985: && (ddp->is_func_def || (!ddp->is_func_def && ddp->definition))
986:
987: #else /* defined (UNPROTOIZE) */
988:
989: /* ... and if we are unprotoizing and this function is in new style ... */
990: ddp->prototyped
991:
992: #endif /* defined (UNPROTOIZE) */
993: )
994: /* ... then the containing file needs converting. */
995: return -1;
996: return 0;
997: }
998:
999: /* Return 1 if the file name NAME is in a directory
1000: that should be converted. */
1001:
1002: static int
1003: directory_specified_p (name)
1004: const char *name;
1005: {
1006: struct string_list *p;
1007:
1008: for (p = directory_list; p; p = p->next)
1009: if (!strncmp (name, p->name, strlen (p->name))
1010: && name[strlen (p->name)] == '/')
1011: {
1012: const char *q = name + strlen (p->name) + 1;
1013:
1014: /* If there are more slashes, it's in a subdir, so
1015: this match doesn't count. */
1016: while (*q)
1017: if (*q++ == '/')
1018: goto lose;
1019: return 1;
1020:
1021: lose: ;
1022: }
1023:
1024: return 0;
1025: }
1026:
1027: /* Return 1 if the file named NAME should be excluded from conversion. */
1028:
1029: static int
1030: file_excluded_p (name)
1031: const char *name;
1032: {
1033: struct string_list *p;
1034: int len = strlen (name);
1035:
1036: for (p = exclude_list; p; p = p->next)
1037: if (!strcmp (name + len - strlen (p->name), p->name)
1038: && name[len - strlen (p->name) - 1] == '/')
1039: return 1;
1040:
1041: return 0;
1042: }
1043:
1044: /* Construct a new element of a string_list.
1045: STRING is the new element value, and REST holds the remaining elements. */
1046:
1047: static struct string_list *
1048: string_list_cons (string, rest)
1049: char *string;
1050: struct string_list *rest;
1051: {
1052: struct string_list *temp
1053: = (struct string_list *) xmalloc (sizeof (struct string_list));
1054:
1055: temp->next = rest;
1056: temp->name = string;
1057: return temp;
1058: }
1059:
1060: /* ??? The GNU convention for mentioning function args in its comments
1061: is to capitalize them. So change "hash_tab_p" to HASH_TAB_P below.
1062: Likewise for all the other functions. */
1063:
1064: /* Given a hash table, apply some function to each node in the table. The
1065: table to traverse is given as the "hash_tab_p" argument, and the
1066: function to be applied to each node in the table is given as "func"
1067: argument. */
1068:
1069: static void
1070: visit_each_hash_node (hash_tab_p, func)
1071: const hash_table_entry *hash_tab_p;
1072: void (*func)();
1073: {
1074: const hash_table_entry *primary;
1075:
1076: for (primary = hash_tab_p; primary < &hash_tab_p[HASH_TABLE_SIZE]; primary++)
1077: if (primary->symbol)
1078: {
1079: hash_table_entry *second;
1080:
1081: (*func)(primary);
1082: for (second = primary->hash_next; second; second = second->hash_next)
1083: (*func) (second);
1084: }
1085: }
1086:
1087: /* Initialize all of the fields of a new hash table entry, pointed
1088: to by the "p" parameter. Note that the space to hold the entry
1089: is assumed to have already been allocated before this routine is
1090: called. */
1091:
1092: static hash_table_entry *
1093: add_symbol (p, s)
1094: hash_table_entry *p;
1095: const char *s;
1096: {
1097: p->hash_next = NULL;
1098: p->symbol = savestring (s, strlen (s));
1099: p->ddip = NULL;
1100: p->fip = NULL;
1101: return p;
1102: }
1103:
1104: /* Look for a particular function name or filename in the particular
1105: hash table indicated by "hash_tab_p". If the name is not in the
1106: given hash table, add it. Either way, return a pointer to the
1107: hash table entry for the given name. */
1108:
1109: static hash_table_entry *
1110: lookup (hash_tab_p, search_symbol)
1111: hash_table_entry *hash_tab_p;
1112: const char *search_symbol;
1113: {
1114: int hash_value = 0;
1115: const char *search_symbol_char_p = search_symbol;
1116: hash_table_entry *p;
1117:
1118: while (*search_symbol_char_p)
1119: hash_value += *search_symbol_char_p++;
1120: hash_value &= hash_mask;
1121: p = &hash_tab_p[hash_value];
1122: if (! p->symbol)
1123: return add_symbol (p, search_symbol);
1124: if (!strcmp (p->symbol, search_symbol))
1125: return p;
1126: while (p->hash_next)
1127: {
1128: p = p->hash_next;
1129: if (!strcmp (p->symbol, search_symbol))
1130: return p;
1131: }
1132: p->hash_next = (hash_table_entry *) xmalloc (sizeof (hash_table_entry));
1133: p = p->hash_next;
1134: return add_symbol (p, search_symbol);
1135: }
1136:
1137: /* Throw a def/dec record on the junk heap.
1138:
1139: Also, since we are not using this record anymore, free up all of the
1140: stuff it pointed to. */
1141:
1142: static void
1143: free_def_dec (p)
1144: def_dec_info *p;
1145: {
1146: xfree (p->ansi_decl);
1147:
1148: #ifndef UNPROTOIZE
1149: {
1150: const f_list_chain_item * curr;
1151: const f_list_chain_item * next;
1152:
1153: for (curr = p->f_list_chain; curr; curr = next)
1154: {
1155: next = curr->chain_next;
1156: xfree (curr);
1157: }
1158: }
1159: #endif /* !defined (UNPROTOIZE) */
1160:
1161: xfree (p);
1162: }
1163:
1164: /* Unexpand as many macro symbol as we can find.
1165:
1166: If the given line must be unexpanded, make a copy of it in the heap and
1167: return a pointer to the unexpanded copy. Otherwise return NULL. */
1168:
1169: static char *
1170: unexpand_if_needed (aux_info_line)
1171: const char *aux_info_line;
1172: {
1173: static char *line_buf = 0;
1174: static int line_buf_size = 0;
1175: const unexpansion* unexp_p;
1176: int got_unexpanded = 0;
1177: const char *s;
1178: char *copy_p = line_buf;
1179:
1180: if (line_buf == 0)
1181: {
1182: line_buf_size = 1024;
1183: line_buf = (char *) xmalloc (line_buf_size);
1184: }
1185:
1186: copy_p = line_buf;
1187:
1188: /* Make a copy of the input string in line_buf, expanding as necessary. */
1189:
1190: for (s = aux_info_line; *s != '\n'; )
1191: {
1192: for (unexp_p = unexpansions; unexp_p->expanded; unexp_p++)
1193: {
1194: const char *in_p = unexp_p->expanded;
1195: size_t len = strlen (in_p);
1196:
1197: if (*s == *in_p && !strncmp (s, in_p, len) && !is_id_char (s[len]))
1198: {
1199: int size = strlen (unexp_p->contracted);
1200: got_unexpanded = 1;
1201: if (copy_p + size - line_buf >= line_buf_size)
1202: {
1203: int offset = copy_p - line_buf;
1204: line_buf_size *= 2;
1205: line_buf_size += size;
1206: line_buf = (char *) xrealloc (line_buf, line_buf_size);
1207: copy_p = line_buf + offset;
1208: }
1209: strcpy (copy_p, unexp_p->contracted);
1210: copy_p += size;
1211:
1212: /* Assume the there will not be another replacement required
1213: within the text just replaced. */
1214:
1215: s += len;
1216: goto continue_outer;
1217: }
1218: }
1219: if (copy_p - line_buf == line_buf_size)
1220: {
1221: int offset = copy_p - line_buf;
1222: line_buf_size *= 2;
1223: line_buf = (char *) xrealloc (line_buf, line_buf_size);
1224: copy_p = line_buf + offset;
1225: }
1226: *copy_p++ = *s++;
1227: continue_outer: ;
1228: }
1229: if (copy_p + 2 - line_buf >= line_buf_size)
1230: {
1231: int offset = copy_p - line_buf;
1232: line_buf_size *= 2;
1233: line_buf = (char *) xrealloc (line_buf, line_buf_size);
1234: copy_p = line_buf + offset;
1235: }
1236: *copy_p++ = '\n';
1237: *copy_p = '\0';
1238:
1239: return (got_unexpanded ? savestring (line_buf, copy_p - line_buf) : 0);
1240: }
1241:
1242: /* Return the absolutized filename for the given relative
1243: filename. Note that if that filename is already absolute, it may
1244: still be returned in a modified form because this routine also
1245: eliminates redundant slashes and single dots and eliminates double
1246: dots to get a shortest possible filename from the given input
1247: filename. The absolutization of relative filenames is made by
1248: assuming that the given filename is to be taken as relative to
1249: the first argument (cwd) or to the current directory if cwd is
1250: NULL. */
1251:
1252: static char *
1253: abspath (cwd, rel_filename)
1254: const char *cwd;
1255: const char *rel_filename;
1256: {
1257: /* Setup the current working directory as needed. */
1258: const char *cwd2 = (cwd) ? cwd : cwd_buffer;
1259: char *const abs_buffer
1260: = (char *) alloca (strlen (cwd2) + strlen (rel_filename) + 2);
1261: char *endp = abs_buffer;
1262: char *outp, *inp;
1263:
1264: /* Copy the filename (possibly preceded by the current working
1265: directory name) into the absolutization buffer. */
1266:
1267: {
1268: const char *src_p;
1269:
1270: if (rel_filename[0] != '/')
1271: {
1272: src_p = cwd2;
1273: while (*endp++ = *src_p++)
1274: continue;
1275: *(endp-1) = '/'; /* overwrite null */
1276: }
1277: src_p = rel_filename;
1278: while (*endp++ = *src_p++)
1279: continue;
1280: }
1281:
1282: /* Now make a copy of abs_buffer into abs_buffer, shortening the
1283: filename (by taking out slashes and dots) as we go. */
1284:
1285: outp = inp = abs_buffer;
1286: *outp++ = *inp++; /* copy first slash */
1287: #ifdef apollo
1288: if (inp[0] == '/')
1289: *outp++ = *inp++; /* copy second slash */
1290: #endif
1291: for (;;)
1292: {
1293: if (!inp[0])
1294: break;
1295: else if (inp[0] == '/' && outp[-1] == '/')
1296: {
1297: inp++;
1298: continue;
1299: }
1300: else if (inp[0] == '.' && outp[-1] == '/')
1301: {
1302: if (!inp[1])
1303: break;
1304: else if (inp[1] == '/')
1305: {
1306: inp += 2;
1307: continue;
1308: }
1309: else if ((inp[1] == '.') && (inp[2] == 0 || inp[2] == '/'))
1310: {
1311: inp += (inp[2] == '/') ? 3 : 2;
1312: outp -= 2;
1313: while (outp >= abs_buffer && *outp != '/')
1314: outp--;
1315: if (outp < abs_buffer)
1316: {
1317: /* Catch cases like /.. where we try to backup to a
1318: point above the absolute root of the logical file
1319: system. */
1320:
1321: fprintf (stderr, "%s: invalid file name: %s\n",
1322: pname, rel_filename);
1323: exit (1);
1324: }
1325: *++outp = '\0';
1326: continue;
1327: }
1328: }
1329: *outp++ = *inp++;
1330: }
1331:
1332: /* On exit, make sure that there is a trailing null, and make sure that
1333: the last character of the returned string is *not* a slash. */
1334:
1335: *outp = '\0';
1336: if (outp[-1] == '/')
1337: *--outp = '\0';
1338:
1339: /* Make a copy (in the heap) of the stuff left in the absolutization
1340: buffer and return a pointer to the copy. */
1341:
1342: return savestring (abs_buffer, outp - abs_buffer);
1343: }
1344:
1345: /* Given a filename (and possibly a directory name from which the filename
1346: is relative) return a string which is the shortest possible
1347: equivalent for the corresponding full (absolutized) filename. The
1348: shortest possible equivalent may be constructed by converting the
1349: absolutized filename to be a relative filename (i.e. relative to
1350: the actual current working directory). However if a relative filename
1351: is longer, then the full absolute filename is returned.
1352:
1353: KNOWN BUG:
1354:
1355: Note that "simple-minded" conversion of any given type of filename (either
1356: relative or absolute) may not result in a valid equivalent filename if any
1357: subpart of the original filename is actually a symbolic link. */
1358:
1359: static const char *
1360: shortpath (cwd, filename)
1361: const char *cwd;
1362: const char *filename;
1363: {
1364: char *rel_buffer;
1365: char *rel_buf_p;
1366: char *cwd_p = cwd_buffer;
1367: char *path_p;
1368: int unmatched_slash_count = 0;
1369: size_t filename_len = strlen (filename);
1370:
1371: path_p = abspath (cwd, filename);
1372: rel_buf_p = rel_buffer = (char *) xmalloc (filename_len);
1373:
1374: while (*cwd_p && (*cwd_p == *path_p))
1375: {
1376: cwd_p++;
1377: path_p++;
1378: }
1379: if (!*cwd_p && (!*path_p || *path_p == '/')) /* whole pwd matched */
1380: {
1381: if (!*path_p) /* input *is* the current path! */
1382: return ".";
1383: else
1384: return ++path_p;
1385: }
1386: else
1387: {
1388: if (*path_p)
1389: {
1390: --cwd_p;
1391: --path_p;
1392: while (*cwd_p != '/') /* backup to last slash */
1393: {
1394: --cwd_p;
1395: --path_p;
1396: }
1397: cwd_p++;
1398: path_p++;
1399: unmatched_slash_count++;
1400: }
1401:
1402: /* Find out how many directory levels in cwd were *not* matched. */
1403: while (*cwd_p)
1404: if (*cwd_p++ == '/')
1405: unmatched_slash_count++;
1406:
1407: /* Now we know how long the "short name" will be.
1408: Reject it if longer than the input. */
1409: if (unmatched_slash_count * 3 + strlen (path_p) >= filename_len)
1410: return filename;
1411:
1412: /* For each of them, put a `../' at the beginning of the short name. */
1413: while (unmatched_slash_count--)
1414: {
1415: /* Give up if the result gets to be longer
1416: than the absolute path name. */
1417: if (rel_buffer + filename_len <= rel_buf_p + 3)
1418: return filename;
1419: *rel_buf_p++ = '.';
1420: *rel_buf_p++ = '.';
1421: *rel_buf_p++ = '/';
1422: }
1423:
1424: /* Then tack on the unmatched part of the desired file's name. */
1425: do
1426: {
1427: if (rel_buffer + filename_len <= rel_buf_p)
1428: return filename;
1429: }
1430: while (*rel_buf_p++ = *path_p++);
1431:
1432: --rel_buf_p;
1433: if (*(rel_buf_p-1) == '/')
1434: *--rel_buf_p = '\0';
1435: return rel_buffer;
1436: }
1437: }
1438:
1439: /* Lookup the given filename in the hash table for filenames. If it is a
1440: new one, then the hash table info pointer will be null. In this case,
1441: we create a new file_info record to go with the filename, and we initialize
1442: that record with some reasonable values. */
1443:
1444: /* FILENAME was const, but that causes a warning on AIX when calling stat.
1445: That is probably a bug in AIX, but might as well avoid the warning. */
1446:
1447: static file_info *
1448: find_file (filename, do_not_stat)
1449: char *filename;
1450: int do_not_stat;
1451: {
1452: hash_table_entry *hash_entry_p;
1453:
1454: hash_entry_p = lookup (filename_primary, filename);
1455: if (hash_entry_p->fip)
1456: return hash_entry_p->fip;
1457: else
1458: {
1459: struct stat stat_buf;
1460: file_info *file_p = (file_info *) xmalloc (sizeof (file_info));
1461:
1462: /* If we cannot get status on any given source file, give a warning
1463: and then just set its time of last modification to infinity. */
1464:
1465: if (do_not_stat)
1466: stat_buf.st_mtime = (time_t) 0;
1467: else
1468: {
1469: if (my_stat (filename, &stat_buf) == -1)
1470: {
1471: fprintf (stderr, "%s: %s: can't get status: %s\n",
1472: pname, shortpath (NULL, filename), sys_errlist[errno]);
1473: stat_buf.st_mtime = (time_t) -1;
1474: }
1475: }
1476:
1477: hash_entry_p->fip = file_p;
1478: file_p->hash_entry = hash_entry_p;
1479: file_p->defs_decs = NULL;
1480: file_p->mtime = stat_buf.st_mtime;
1481: return file_p;
1482: }
1483: }
1484:
1485: /* Generate a fatal error because some part of the aux_info file is
1486: messed up. */
1487:
1488: static void
1489: aux_info_corrupted ()
1490: {
1491: fprintf (stderr, "\n%s: fatal error: aux info file corrupted at line %d\n",
1492: pname, current_aux_info_lineno);
1493: exit (1);
1494: }
1495:
1496: /* ??? This comment is vague. Say what the condition is for. */
1497: /* Check to see that a condition is true. This is kind of like an assert. */
1498:
1499: static void
1500: check_aux_info (cond)
1501: int cond;
1502: {
1503: if (! cond)
1504: aux_info_corrupted ();
1505: }
1506:
1507: /* Given a pointer to the closing right parenthesis for a particular formals
1508: list (in an aux_info file) find the corresponding left parenthesis and
1509: return a pointer to it. */
1510:
1511: static const char *
1512: find_corresponding_lparen (p)
1513: const char *p;
1514: {
1515: const char *q;
1516: int paren_depth;
1517:
1518: for (paren_depth = 1, q = p-1; paren_depth; q--)
1519: {
1520: switch (*q)
1521: {
1522: case ')':
1523: paren_depth++;
1524: break;
1525: case '(':
1526: paren_depth--;
1527: break;
1528: }
1529: }
1530: return ++q;
1531: }
1532:
1533: /* Given a line from an aux info file, and a time at which the aux info
1534: file it came from was created, check to see if the item described in
1535: the line comes from a file which has been modified since the aux info
1536: file was created. If so, return non-zero, else return zero. */
1537:
1538: static int
1539: referenced_file_is_newer (l, aux_info_mtime)
1540: const char *l;
1541: time_t aux_info_mtime;
1542: {
1543: const char *p;
1544: file_info *fi_p;
1545: char *filename;
1546:
1547: check_aux_info (l[0] == '/');
1548: check_aux_info (l[1] == '*');
1549: check_aux_info (l[2] == ' ');
1550:
1551: {
1552: const char *filename_start = p = l + 3;
1553:
1554: while (*p != ':')
1555: p++;
1556: filename = (char *) alloca ((size_t) (p - filename_start) + 1);
1557: strncpy (filename, filename_start, (size_t) (p - filename_start));
1558: filename[p-filename_start] = '\0';
1559: }
1560:
1561: /* Call find_file to find the file_info record associated with the file
1562: which contained this particular def or dec item. Note that this call
1563: may cause a new file_info record to be created if this is the first time
1564: that we have ever known about this particular file. */
1565:
1566: fi_p = find_file (abspath (invocation_filename, filename), 0);
1567:
1568: return (fi_p->mtime > aux_info_mtime);
1569: }
1570:
1571: /* Given a line of info from the aux_info file, create a new
1572: def_dec_info record to remember all of the important information about
1573: a function definition or declaration.
1574:
1575: Link this record onto the list of such records for the particular file in
1576: which it occurred in proper (descending) line number order (for now).
1577:
1578: If there is an identical record already on the list for the file, throw
1579: this one away. Doing so takes care of the (useless and troublesome)
1580: duplicates which are bound to crop up due to multiple inclusions of any
1581: given individual header file.
1582:
1583: Finally, link the new def_dec record onto the list of such records
1584: pertaining to this particular function name. */
1585:
1586: static void
1587: save_def_or_dec (l, is_syscalls)
1588: const char *l;
1589: int is_syscalls;
1590: {
1591: const char *p;
1592: const char *semicolon_p;
1593: def_dec_info *def_dec_p = (def_dec_info *) xmalloc (sizeof (def_dec_info));
1594:
1595: #ifndef UNPROTOIZE
1596: def_dec_p->written = 0;
1597: #endif /* !defined (UNPROTOIZE) */
1598:
1599: /* Start processing the line by picking off 5 pieces of information from
1600: the left hand end of the line. These are filename, line number,
1601: new/old/implicit flag (new = ANSI prototype format), definition or
1602: declaration flag, and extern/static flag). */
1603:
1604: check_aux_info (l[0] == '/');
1605: check_aux_info (l[1] == '*');
1606: check_aux_info (l[2] == ' ');
1607:
1608: {
1609: const char *filename_start = p = l + 3;
1610: char *filename;
1611:
1612: while (*p != ':')
1613: p++;
1614: filename = (char *) alloca ((size_t) (p - filename_start) + 1);
1615: strncpy (filename, filename_start, (size_t) (p - filename_start));
1616: filename[p-filename_start] = '\0';
1617:
1618: /* Call find_file to find the file_info record associated with the file
1619: which contained this particular def or dec item. Note that this call
1620: may cause a new file_info record to be created if this is the first time
1621: that we have ever known about this particular file.
1622:
1623: Note that we started out by forcing all of the base source file names
1624: (i.e. the names of the aux_info files with the .X stripped off) into the
1625: filenames hash table, and we simultaneously setup file_info records for
1626: all of these base file names (even if they may be useless later).
1627: The file_info records for all of these "base" file names (properly)
1628: act as file_info records for the "original" (i.e. un-included) files
1629: which were submitted to gcc for compilation (when the -aux-info
1630: option was used). */
1631:
1632: def_dec_p->file = find_file (abspath (invocation_filename, filename), is_syscalls);
1633: }
1634:
1635: {
1636: const char *line_number_start = ++p;
1637: char line_number[10];
1638:
1639: while (*p != ':')
1640: p++;
1641: strncpy (line_number, line_number_start, (size_t) (p - line_number_start));
1642: line_number[p-line_number_start] = '\0';
1643: def_dec_p->line = atoi (line_number);
1644: }
1645:
1646: /* Check that this record describes a new-style, old-style, or implicit
1647: definition or declaration. */
1648:
1649: p++; /* Skip over the `:'. */
1650: check_aux_info ((*p == 'N') || (*p == 'O') || (*p == 'I'));
1651:
1652: /* Is this a new style (ANSI prototyped) definition or declaration? */
1653:
1654: def_dec_p->prototyped = (*p == 'N');
1655:
1656: #ifndef UNPROTOIZE
1657:
1658: /* Is this an implicit declaration? */
1659:
1660: def_dec_p->is_implicit = (*p == 'I');
1661:
1662: #endif /* !defined (UNPROTOIZE) */
1663:
1664: p++;
1665:
1666: check_aux_info ((*p == 'C') || (*p == 'F'));
1667:
1668: /* Is this item a function definition (F) or a declaration (C). Note that
1669: we treat item taken from the syscalls file as though they were function
1670: definitions regardless of what the stuff in the file says. */
1671:
1672: def_dec_p->is_func_def = ((*p++ == 'F') || is_syscalls);
1673:
1674: #ifndef UNPROTOIZE
1675: def_dec_p->definition = 0; /* Fill this in later if protoizing. */
1676: #endif /* !defined (UNPROTOIZE) */
1677:
1678: check_aux_info (*p++ == ' ');
1679: check_aux_info (*p++ == '*');
1680: check_aux_info (*p++ == '/');
1681: check_aux_info (*p++ == ' ');
1682:
1683: #ifdef UNPROTOIZE
1684: check_aux_info ((!strncmp (p, "static", 6)) || (!strncmp (p, "extern", 6)));
1685: #else /* !defined (UNPROTOIZE) */
1686: if (!strncmp (p, "static", 6))
1687: def_dec_p->is_static = -1;
1688: else if (!strncmp (p, "extern", 6))
1689: def_dec_p->is_static = 0;
1690: else
1691: check_aux_info (0); /* Didn't find either `extern' or `static'. */
1692: #endif /* !defined (UNPROTOIZE) */
1693:
1694: {
1695: const char *ansi_start = p;
1696:
1697: p += 6; /* Pass over the "static" or "extern". */
1698:
1699: /* We are now past the initial stuff. Search forward from here to find
1700: the terminating semicolon that should immediately follow the entire
1701: ANSI format function declaration. */
1702:
1703: while (*++p != ';')
1704: continue;
1705:
1706: semicolon_p = p;
1707:
1708: /* Make a copy of the ansi declaration part of the line from the aux_info
1709: file. */
1710:
1711: def_dec_p->ansi_decl
1712: = dupnstr (ansi_start, (size_t) ((semicolon_p+1) - ansi_start));
1713:
1714: /* Backup and point at the final right paren of the final argument list. */
1715:
1716: p--;
1717:
1718: #ifndef UNPROTOIZE
1719: def_dec_p->f_list_chain = NULL;
1720: #endif /* !defined (UNPROTOIZE) */
1721:
1722: while (p != ansi_start && (p[-1] == ' ' || p[-1] == '\t')) p--;
1723: if (*p != ')')
1724: {
1725: free_def_dec (def_dec_p);
1726: return;
1727: }
1728: }
1729:
1730: /* Now isolate a whole set of formal argument lists, one-by-one. Normally,
1731: there will only be one list to isolate, but there could be more. */
1732:
1733: def_dec_p->f_list_count = 0;
1734:
1735: for (;;)
1736: {
1737: const char *left_paren_p = find_corresponding_lparen (p);
1738: #ifndef UNPROTOIZE
1739: {
1740: f_list_chain_item *cip =
1741: (f_list_chain_item *) xmalloc (sizeof (f_list_chain_item));
1742:
1743: cip->formals_list
1744: = dupnstr (left_paren_p + 1, (size_t) (p - (left_paren_p+1)));
1745:
1746: /* Add the new chain item at the head of the current list. */
1747:
1748: cip->chain_next = def_dec_p->f_list_chain;
1749: def_dec_p->f_list_chain = cip;
1750: }
1751: #endif /* !defined (UNPROTOIZE) */
1752: def_dec_p->f_list_count++;
1753:
1754: p = left_paren_p - 2;
1755:
1756: /* p must now point either to another right paren, or to the last
1757: character of the name of the function that was declared/defined.
1758: If p points to another right paren, then this indicates that we
1759: are dealing with multiple formals lists. In that case, there
1760: really should be another right paren preceding this right paren. */
1761:
1762: if (*p != ')')
1763: break;
1764: else
1765: check_aux_info (*--p == ')');
1766: }
1767:
1768:
1769: {
1770: const char *past_fn = p + 1;
1771:
1772: check_aux_info (*past_fn == ' ');
1773:
1774: /* Scan leftwards over the identifier that names the function. */
1775:
1776: while (is_id_char (*p))
1777: p--;
1778: p++;
1779:
1780: /* p now points to the leftmost character of the function name. */
1781:
1782: {
1783: char *fn_string = (char *) alloca (past_fn - p + 1);
1784:
1785: strncpy (fn_string, p, (size_t) (past_fn - p));
1786: fn_string[past_fn-p] = '\0';
1787: def_dec_p->hash_entry = lookup (function_name_primary, fn_string);
1788: }
1789: }
1790:
1791: /* Look at all of the defs and decs for this function name that we have
1792: collected so far. If there is already one which is at the same
1793: line number in the same file, then we can discard this new def_dec_info
1794: record.
1795:
1796: As an extra assurance that any such pair of (nominally) identical
1797: function declarations are in fact identical, we also compare the
1798: ansi_decl parts of the lines from the aux_info files just to be on
1799: the safe side.
1800:
1801: This comparison will fail if (for instance) the user was playing
1802: messy games with the preprocessor which ultimately causes one
1803: function declaration in one header file to look differently when
1804: that file is included by two (or more) other files. */
1805:
1806: {
1807: const def_dec_info *other;
1808:
1809: for (other = def_dec_p->hash_entry->ddip; other; other = other->next_for_func)
1810: {
1811: if (def_dec_p->line == other->line && def_dec_p->file == other->file)
1812: {
1813: if (strcmp (def_dec_p->ansi_decl, other->ansi_decl))
1814: {
1815: fprintf (stderr, "%s:%d: declaration of function `%s' takes different forms\n",
1816: def_dec_p->file->hash_entry->symbol,
1817: def_dec_p->line,
1818: def_dec_p->hash_entry->symbol);
1819: exit (1);
1820: }
1821: free_def_dec (def_dec_p);
1822: return;
1823: }
1824: }
1825: }
1826:
1827: #ifdef UNPROTOIZE
1828:
1829: /* If we are doing unprotoizing, we must now setup the pointers that will
1830: point to the K&R name list and to the K&R argument declarations list.
1831:
1832: Note that if this is only a function declaration, then we should not
1833: expect to find any K&R style formals list following the ANSI-style
1834: formals list. This is because GCC knows that such information is
1835: useless in the case of function declarations (function definitions
1836: are a different story however).
1837:
1838: Since we are unprotoizing, we don't need any such lists anyway.
1839: All we plan to do is to delete all characters between ()'s in any
1840: case. */
1841:
1842: def_dec_p->formal_names = NULL;
1843: def_dec_p->formal_decls = NULL;
1844:
1845: if (def_dec_p->is_func_def)
1846: {
1847: p = semicolon_p;
1848: check_aux_info (*++p == ' ');
1849: check_aux_info (*++p == '/');
1850: check_aux_info (*++p == '*');
1851: check_aux_info (*++p == ' ');
1852: check_aux_info (*++p == '(');
1853:
1854: {
1855: const char *kr_names_start = ++p; /* Point just inside '('. */
1856:
1857: while (*p++ != ')')
1858: continue;
1859: p--; /* point to closing right paren */
1860:
1861: /* Make a copy of the K&R parameter names list. */
1862:
1863: def_dec_p->formal_names
1864: = dupnstr (kr_names_start, (size_t) (p - kr_names_start));
1865: }
1866:
1867: check_aux_info (*++p == ' ');
1868: p++;
1869:
1870: /* p now points to the first character of the K&R style declarations
1871: list (if there is one) or to the star-slash combination that ends
1872: the comment in which such lists get embedded. */
1873:
1874: /* Make a copy of the K&R formal decls list and set the def_dec record
1875: to point to it. */
1876:
1877: if (*p == '*') /* Are there no K&R declarations? */
1878: {
1879: check_aux_info (*++p == '/');
1880: def_dec_p->formal_decls = "";
1881: }
1882: else
1883: {
1884: const char *kr_decls_start = p;
1885:
1886: while (p[0] != '*' || p[1] != '/')
1887: p++;
1888: p--;
1889:
1890: check_aux_info (*p == ' ');
1891:
1892: def_dec_p->formal_decls
1893: = dupnstr (kr_decls_start, (size_t) (p - kr_decls_start));
1894: }
1895:
1896: /* Handle a special case. If we have a function definition marked as
1897: being in "old" style, and if it's formal names list is empty, then
1898: it may actually have the string "void" in its real formals list
1899: in the original source code. Just to make sure, we will get setup
1900: to convert such things anyway.
1901:
1902: This kludge only needs to be here because of an insurmountable
1903: problem with generating .X files. */
1904:
1905: if (!def_dec_p->prototyped && !*def_dec_p->formal_names)
1906: def_dec_p->prototyped = 1;
1907: }
1908:
1909: /* Since we are unprotoizing, if this item is already in old (K&R) style,
1910: we can just ignore it. If that is true, throw away the itme now. */
1911:
1912: if (!def_dec_p->prototyped)
1913: {
1914: free_def_dec (def_dec_p);
1915: return;
1916: }
1917:
1918: #endif /* defined (UNPROTOIZE) */
1919:
1920: /* Add this record to the head of the list of records pertaining to this
1921: particular function name. */
1922:
1923: def_dec_p->next_for_func = def_dec_p->hash_entry->ddip;
1924: def_dec_p->hash_entry->ddip = def_dec_p;
1925:
1926: /* Add this new def_dec_info record to the sorted list of def_dec_info
1927: records for this file. Note that we don't have to worry about duplicates
1928: (caused by multiple inclusions of header files) here because we have
1929: already eliminated duplicates above. */
1930:
1931: if (!def_dec_p->file->defs_decs)
1932: {
1933: def_dec_p->file->defs_decs = def_dec_p;
1934: def_dec_p->next_in_file = NULL;
1935: }
1936: else
1937: {
1938: int line = def_dec_p->line;
1939: const def_dec_info *prev = NULL;
1940: const def_dec_info *curr = def_dec_p->file->defs_decs;
1941: const def_dec_info *next = curr->next_in_file;
1942:
1943: while (next && (line < curr->line))
1944: {
1945: prev = curr;
1946: curr = next;
1947: next = next->next_in_file;
1948: }
1949: if (line >= curr->line)
1950: {
1951: def_dec_p->next_in_file = curr;
1952: if (prev)
1953: ((NONCONST def_dec_info *) prev)->next_in_file = def_dec_p;
1954: else
1955: def_dec_p->file->defs_decs = def_dec_p;
1956: }
1957: else /* assert (next == NULL); */
1958: {
1959: ((NONCONST def_dec_info *) curr)->next_in_file = def_dec_p;
1960: /* assert (next == NULL); */
1961: def_dec_p->next_in_file = next;
1962: }
1963: }
1964: }
1965:
1966: /* Set up the vector COMPILE_PARAMS which is the argument list for running GCC.
1967: Also set input_file_name_index and aux_info_file_name_index
1968: to the indices of the slots where the file names should go. */
1969:
1970: /* We initialize the vector by removing -g, -O, -S, -c, and -o options,
1971: and adding '-aux-info AUXFILE -S -o /dev/null INFILE' at the end. */
1972:
1973: static void
1974: munge_compile_params (params_list)
1975: const char *params_list;
1976: {
1977: /* Build up the contents in a temporary vector
1978: that is so big that to has to be big enough. */
1979: const char **temp_params
1980: = (const char **) alloca ((strlen (params_list) + 8) * sizeof (char *));
1981: int param_count = 0;
1982: const char *param;
1983:
1984: temp_params[param_count++] = compiler_file_name;
1985: for (;;)
1986: {
1987: while (isspace (*params_list))
1988: params_list++;
1989: if (!*params_list)
1990: break;
1991: param = params_list;
1992: while (*params_list && !isspace (*params_list))
1993: params_list++;
1994: if (param[0] != '-')
1995: temp_params[param_count++]
1996: = dupnstr (param, (size_t) (params_list - param));
1997: else
1998: {
1999: switch (param[1])
2000: {
2001: case 'g':
2002: case 'O':
2003: case 'S':
2004: case 'c':
2005: break; /* Don't copy these. */
2006: case 'o':
2007: while (isspace (*params_list))
2008: params_list++;
2009: while (*params_list && !isspace (*params_list))
2010: params_list++;
2011: break;
2012: default:
2013: temp_params[param_count++]
2014: = dupnstr (param, (size_t) (params_list - param));
2015: }
2016: }
2017: if (!*params_list)
2018: break;
2019: }
2020: temp_params[param_count++] = "-aux-info";
2021:
2022: /* Leave room for the aux-info file name argument. */
2023: aux_info_file_name_index = param_count;
2024: temp_params[param_count++] = NULL;
2025:
2026: temp_params[param_count++] = "-S";
2027: temp_params[param_count++] = "-o";
2028: temp_params[param_count++] = "/dev/null";
2029:
2030: /* Leave room for the input file name argument. */
2031: input_file_name_index = param_count;
2032: temp_params[param_count++] = NULL;
2033: /* Terminate the list. */
2034: temp_params[param_count++] = NULL;
2035:
2036: /* Make a copy of the compile_params in heap space. */
2037:
2038: compile_params
2039: = (const char **) xmalloc (sizeof (char *) * (param_count+1));
2040: memcpy (compile_params, temp_params, sizeof (char *) * param_count);
2041: }
2042:
2043: /* Do a recompilation for the express purpose of generating a new aux_info
2044: file to go with a specific base source file. */
2045:
2046: static int
2047: gen_aux_info_file (base_filename)
2048: const char *base_filename;
2049: {
2050: int child_pid;
2051:
2052: if (!input_file_name_index)
2053: munge_compile_params ("");
2054:
2055: /* Store the full source file name in the argument vector. */
2056: compile_params[input_file_name_index] = shortpath (NULL, base_filename);
2057: /* Add .X to source file name to get aux-info file name. */
2058: compile_params[aux_info_file_name_index]
2059: = savestring2 (compile_params[input_file_name_index],
2060: strlen (compile_params[input_file_name_index]),
2061: ".X",
2062: 2);
2063:
2064: if (!quiet_flag)
2065: fprintf (stderr, "%s: compiling `%s'\n",
2066: pname, compile_params[input_file_name_index]);
2067:
2068: if (child_pid = fork ())
2069: {
2070: if (child_pid == -1)
2071: {
2072: fprintf (stderr, "%s: could not fork process: %s\n",
2073: pname, sys_errlist[errno]);
2074: return 0;
2075: }
2076:
2077: #if 0
2078: /* Print out the command line that the other process is now executing. */
2079:
2080: if (!quiet_flag)
2081: {
2082: const char **arg;
2083:
2084: fputs ("\t", stderr);
2085: for (arg = compile_params; *arg; arg++)
2086: {
2087: fputs (*arg, stderr);
2088: fputc (' ', stderr);
2089: }
2090: fputc ('\n', stderr);
2091: fflush (stderr);
2092: }
2093: #endif /* 0 */
2094:
2095: {
2096: int wait_status;
2097:
2098: if (wait (&wait_status) == -1)
2099: {
2100: fprintf (stderr, "%s: wait failed: %s\n",
2101: pname, sys_errlist[errno]);
2102: return 0;
2103: }
2104: if ((wait_status & 0x7F) != 0)
2105: {
2106: fprintf (stderr, "%s: subprocess got fatal signal %d",
2107: pname, (wait_status & 0x7F));
2108: return 0;
2109: }
2110: if (((wait_status & 0xFF00) >> 8) != 0)
2111: {
2112: fprintf (stderr, "%s: %s exited with status %d\n",
2113: pname, base_filename, ((wait_status & 0xFF00) >> 8));
2114: return 0;
2115: }
2116: return 1;
2117: }
2118: }
2119: else
2120: {
2121: if (my_execvp (compile_params[0], (char *const *) compile_params))
2122: {
2123: int e = errno, f = fileno (stderr);
2124: write (f, pname, strlen (pname));
2125: write (f, ": ", 2);
2126: write (f, compile_params[0], strlen (compile_params[0]));
2127: write (f, ": ", 2);
2128: write (f, sys_errlist[e], strlen (sys_errlist[e]));
2129: write (f, "\n", 1);
2130: _exit (1);
2131: }
2132: return 1; /* Never executed. */
2133: }
2134: }
2135:
2136: /* Read in all of the information contained in a single aux_info file.
2137: Save all of the important stuff for later. */
2138:
2139: static void
2140: process_aux_info_file (base_source_filename, keep_it, is_syscalls)
2141: const char *base_source_filename;
2142: int keep_it;
2143: int is_syscalls;
2144: {
2145: size_t base_len = strlen (base_source_filename);
2146: char * aux_info_filename
2147: = (char *) alloca (base_len + strlen (aux_info_suffix) + 1);
2148: char *aux_info_base;
2149: char *aux_info_limit;
2150: char *aux_info_relocated_name;
2151: const char *aux_info_second_line;
2152: time_t aux_info_mtime;
2153: size_t aux_info_size;
2154: int must_create;
2155:
2156: /* Construct the aux_info filename from the base source filename. */
2157:
2158: strcpy (aux_info_filename, base_source_filename);
2159: strcat (aux_info_filename, aux_info_suffix);
2160:
2161: /* Check that the aux_info file exists and is readable. If it does not
2162: exist, try to create it (once only). */
2163:
2164: /* If file doesn't exist, set must_create.
2165: Likewise if it exists and we can read it but it is obsolete.
2166: Otherwise, report an error. */
2167: must_create = 0;
2168:
2169: /* Come here with must_create set to 1 if file is out of date. */
2170: start_over: ;
2171:
2172: if (my_access (aux_info_filename, R_OK) == -1)
2173: {
2174: if (errno == ENOENT)
2175: {
2176: if (is_syscalls)
2177: {
2178: fprintf (stderr, "%s: warning: missing SYSCALLS file `%s'\n",
2179: pname, aux_info_filename);
2180: return;
2181: }
2182: must_create = 1;
2183: }
2184: else
2185: {
2186: fprintf (stderr, "%s: can't read aux info file `%s': %s\n",
2187: pname, shortpath (NULL, aux_info_filename),
2188: sys_errlist[errno]);
2189: errors++;
2190: return;
2191: }
2192: }
2193: #if 0 /* There is code farther down to take care of this. */
2194: else
2195: {
2196: struct stat s1, s2;
2197: stat (aux_info_file_name, &s1);
2198: stat (base_source_file_name, &s2);
2199: if (s2.st_mtime > s1.st_mtime)
2200: must_create = 1;
2201: }
2202: #endif /* 0 */
2203:
2204: /* If we need a .X file, create it, and verify we can read it. */
2205: if (must_create)
2206: {
2207: if (!gen_aux_info_file (base_source_filename))
2208: {
2209: errors++;
2210: return;
2211: }
2212: if (my_access (aux_info_filename, R_OK) == -1)
2213: {
2214: fprintf (stderr, "%s: can't read aux info file `%s': %s\n",
2215: pname, shortpath (NULL, aux_info_filename),
2216: sys_errlist[errno]);
2217: errors++;
2218: return;
2219: }
2220: }
2221:
2222: {
2223: struct stat stat_buf;
2224:
2225: /* Get some status information about this aux_info file. */
2226:
2227: if (my_stat (aux_info_filename, &stat_buf) == -1)
2228: {
2229: fprintf (stderr, "%s: can't get status of aux info file `%s': %s\n",
2230: pname, shortpath (NULL, aux_info_filename),
2231: sys_errlist[errno]);
2232: errors++;
2233: return;
2234: }
2235:
2236: /* Check on whether or not this aux_info file is zero length. If it is,
2237: then just ignore it and return. */
2238:
2239: if ((aux_info_size = stat_buf.st_size) == 0)
2240: return;
2241:
2242: /* Get the date/time of last modification for this aux_info file and
2243: remember it. We will have to check that any source files that it
2244: contains information about are at least this old or older. */
2245:
2246: aux_info_mtime = stat_buf.st_mtime;
2247:
2248: if (!is_syscalls)
2249: {
2250: /* Compare mod time with the .c file; update .X file if obsolete.
2251: The code later on can fail to check the .c file
2252: if it did not directly define any functions. */
2253:
2254: if (my_stat (base_source_filename, &stat_buf) == -1)
2255: {
2256: fprintf (stderr, "%s: can't get status of aux info file `%s': %s\n",
2257: pname, shortpath (NULL, base_source_filename),
2258: sys_errlist[errno]);
2259: errors++;
2260: return;
2261: }
2262: if (stat_buf.st_mtime > aux_info_mtime)
2263: {
2264: must_create = 1;
2265: goto start_over;
2266: }
2267: }
2268: }
2269:
2270: {
2271: int aux_info_file;
2272:
2273: /* Open the aux_info file. */
2274:
2275: if ((aux_info_file = my_open (aux_info_filename, O_RDONLY, 0444 )) == -1)
2276: {
2277: fprintf (stderr, "%s: can't open aux info file `%s' for reading: %s\n",
2278: pname, shortpath (NULL, aux_info_filename),
2279: sys_errlist[errno]);
2280: return;
2281: }
2282:
2283: /* Allocate space to hold the aux_info file in memory. */
2284:
2285: aux_info_base = xmalloc (aux_info_size + 1);
2286: aux_info_limit = aux_info_base + aux_info_size;
2287: *aux_info_limit = '\0';
2288:
2289: /* Read the aux_info file into memory. */
2290:
2291: if (safe_read (aux_info_file, aux_info_base, aux_info_size) != aux_info_size)
2292: {
2293: fprintf (stderr, "%s: error reading aux info file `%s': %s\n",
2294: pname, shortpath (NULL, aux_info_filename),
2295: sys_errlist[errno]);
2296: free (aux_info_base);
2297: close (aux_info_file);
2298: return;
2299: }
2300:
2301: /* Close the aux info file. */
2302:
2303: if (close (aux_info_file))
2304: {
2305: fprintf (stderr, "%s: error closing aux info file `%s': %s\n",
2306: pname, shortpath (NULL, aux_info_filename),
2307: sys_errlist[errno]);
2308: free (aux_info_base);
2309: close (aux_info_file);
2310: return;
2311: }
2312: }
2313:
2314: /* Delete the aux_info file (unless requested not to). If the deletion
2315: fails for some reason, don't even worry about it. */
2316:
2317: if (must_create && !keep_it)
2318: if (my_unlink (aux_info_filename) == -1)
2319: fprintf (stderr, "%s: can't delete aux info file `%s': %s\n",
2320: pname, shortpath (NULL, aux_info_filename),
2321: sys_errlist[errno]);
2322:
2323: /* Save a pointer into the first line of the aux_info file which
2324: contains the filename of the directory from which the compiler
2325: was invoked when the associated source file was compiled.
2326: This information is used later to help create complete
2327: filenames out of the (potentially) relative filenames in
2328: the aux_info file. */
2329:
2330: {
2331: char *p = aux_info_base;
2332:
2333: while (*p != ':')
2334: p++;
2335: p++;
2336: while (*p == ' ')
2337: p++;
2338: invocation_filename = p; /* Save a pointer to first byte of path. */
2339: while (*p != ' ')
2340: p++;
2341: *p++ = '/';
2342: *p++ = '\0';
2343: while (*p++ != '\n')
2344: continue;
2345: aux_info_second_line = p;
2346: aux_info_relocated_name = 0;
2347: if (invocation_filename[0] != '/')
2348: {
2349: /* INVOCATION_FILENAME is relative;
2350: append it to BASE_SOURCE_FILENAME's dir. */
2351: char *dir_end;
2352: aux_info_relocated_name = xmalloc (base_len + (p-invocation_filename));
2353: strcpy (aux_info_relocated_name, base_source_filename);
2354: dir_end = rindex (aux_info_relocated_name, '/');
2355: if (dir_end)
2356: dir_end++;
2357: else
2358: dir_end = aux_info_relocated_name;
2359: strcpy (dir_end, invocation_filename);
2360: invocation_filename = aux_info_relocated_name;
2361: }
2362: }
2363:
2364:
2365: {
2366: const char *aux_info_p;
2367:
2368: /* Do a pre-pass on the lines in the aux_info file, making sure that all
2369: of the source files referenced in there are at least as old as this
2370: aux_info file itself. If not, go back and regenerate the aux_info
2371: file anew. Don't do any of this for the syscalls file. */
2372:
2373: if (!is_syscalls)
2374: {
2375: current_aux_info_lineno = 2;
2376:
2377: for (aux_info_p = aux_info_second_line; *aux_info_p; )
2378: {
2379: if (referenced_file_is_newer (aux_info_p, aux_info_mtime))
2380: {
2381: free (aux_info_base);
2382: xfree (aux_info_relocated_name);
2383: if (keep_it && my_unlink (aux_info_filename) == -1)
2384: {
2385: fprintf (stderr, "%s: can't delete file `%s': %s\n",
2386: pname, shortpath (NULL, aux_info_filename),
2387: sys_errlist[errno]);
2388: return;
2389: }
2390: goto start_over;
2391: }
2392:
2393: /* Skip over the rest of this line to start of next line. */
2394:
2395: while (*aux_info_p != '\n')
2396: aux_info_p++;
2397: aux_info_p++;
2398: current_aux_info_lineno++;
2399: }
2400: }
2401:
2402: /* Now do the real pass on the aux_info lines. Save their information in
2403: the in-core data base. */
2404:
2405: current_aux_info_lineno = 2;
2406:
2407: for (aux_info_p = aux_info_second_line; *aux_info_p;)
2408: {
2409: char *unexpanded_line = unexpand_if_needed (aux_info_p);
2410:
2411: if (unexpanded_line)
2412: {
2413: save_def_or_dec (unexpanded_line, is_syscalls);
2414: free (unexpanded_line);
2415: }
2416: else
2417: save_def_or_dec (aux_info_p, is_syscalls);
2418:
2419: /* Skip over the rest of this line and get to start of next line. */
2420:
2421: while (*aux_info_p != '\n')
2422: aux_info_p++;
2423: aux_info_p++;
2424: current_aux_info_lineno++;
2425: }
2426: }
2427:
2428: free (aux_info_base);
2429: xfree (aux_info_relocated_name);
2430: }
2431:
2432: #ifndef UNPROTOIZE
2433:
2434: /* Check an individual filename for a .c suffix. If the filename has this
2435: suffix, rename the file such that its suffix is changed to .C. This
2436: function implements the -C option. */
2437:
2438: static void
2439: rename_c_file (hp)
2440: const hash_table_entry *hp;
2441: {
2442: const char *filename = hp->symbol;
2443: int last_char_index = strlen (filename) - 1;
2444: char *const new_filename = (char *) alloca (strlen (filename) + 1);
2445:
2446: /* Note that we don't care here if the given file was converted or not. It
2447: is possible that the given file was *not* converted, simply because there
2448: was nothing in it which actually required conversion. Even in this case,
2449: we want to do the renaming. Note that we only rename files with the .c
2450: suffix. */
2451:
2452: if (filename[last_char_index] != 'c' || filename[last_char_index-1] != '.')
2453: return;
2454:
2455: strcpy (new_filename, filename);
2456: new_filename[last_char_index] = 'C';
2457:
2458: if (my_link (filename, new_filename) == -1)
2459: {
2460: fprintf (stderr, "%s: warning: can't link file `%s' to `%s': %s\n",
2461: pname, shortpath (NULL, filename),
2462: shortpath (NULL, new_filename), sys_errlist[errno]);
2463: errors++;
2464: return;
2465: }
2466:
2467: if (my_unlink (filename) == -1)
2468: {
2469: fprintf (stderr, "%s: warning: can't delete file `%s': %s\n",
2470: pname, shortpath (NULL, filename), sys_errlist[errno]);
2471: errors++;
2472: return;
2473: }
2474: }
2475:
2476: #endif /* !defined (UNPROTOIZE) */
2477:
2478: /* Take the list of definitions and declarations attached to a particular
2479: file_info node and reverse the order of the list. This should get the
2480: list into an order such that the item with the lowest associated line
2481: number is nearest the head of the list. When these lists are originally
2482: built, they are in the opposite order. We want to traverse them in
2483: normal line number order later (i.e. lowest to highest) so reverse the
2484: order here. */
2485:
2486: static void
2487: reverse_def_dec_list (hp)
2488: const hash_table_entry *hp;
2489: {
2490: file_info *file_p = hp->fip;
2491: const def_dec_info *prev = NULL;
2492: const def_dec_info *current = file_p->defs_decs;
2493:
2494: if (!( current = file_p->defs_decs))
2495: return; /* no list to reverse */
2496:
2497: prev = current;
2498: if (! (current = current->next_in_file))
2499: return; /* can't reverse a single list element */
2500:
2501: ((NONCONST def_dec_info *) prev)->next_in_file = NULL;
2502:
2503: while (current)
2504: {
2505: const def_dec_info *next = current->next_in_file;
2506:
2507: ((NONCONST def_dec_info *) current)->next_in_file = prev;
2508: prev = current;
2509: current = next;
2510: }
2511:
2512: file_p->defs_decs = prev;
2513: }
2514:
2515: #ifndef UNPROTOIZE
2516:
2517: /* Find the (only?) extern definition for a particular function name, starting
2518: from the head of the linked list of entries for the given name. If we
2519: cannot find an extern definition for the given function name, issue a
2520: warning and scrounge around for the next best thing, i.e. an extern
2521: function declaration with a prototype attached to it. Note that we only
2522: allow such substitutions for extern declarations and never for static
2523: declarations. That's because the only reason we allow them at all is
2524: to let un-prototyped function declarations for system-supplied library
2525: functions get their prototypes from our own extra SYSCALLS.c.X file which
2526: contains all of the correct prototypes for system functions. */
2527:
2528: static const def_dec_info *
2529: find_extern_def (head, user)
2530: const def_dec_info *head;
2531: const def_dec_info *user;
2532: {
2533: const def_dec_info *dd_p;
2534: const def_dec_info *extern_def_p = NULL;
2535: int conflict_noted = 0;
2536:
2537: /* Don't act too stupid here. Somebody may try to convert an entire system
2538: in one swell fwoop (rather than one program at a time, as should be done)
2539: and in that case, we may find that there are multiple extern definitions
2540: of a given function name in the entire set of source files that we are
2541: converting. If however one of these definitions resides in exactly the
2542: same source file as the reference we are trying to satisfy then in that
2543: case it would be stupid for us to fail to realize that this one definition
2544: *must* be the precise one we are looking for.
2545:
2546: To make sure that we don't miss an opportunity to make this "same file"
2547: leap of faith, we do a prescan of the list of records relating to the
2548: given function name, and we look (on this first scan) *only* for a
2549: definition of the function which is in the same file as the reference
2550: we are currently trying to satisfy. */
2551:
2552: for (dd_p = head; dd_p; dd_p = dd_p->next_for_func)
2553: if (dd_p->is_func_def && !dd_p->is_static && dd_p->file == user->file)
2554: return dd_p;
2555:
2556: /* Now, since we have not found a definition in the same file as the
2557: reference, we scan the list again and consider all possibilities from
2558: all files. Here we may get conflicts with the things listed in the
2559: SYSCALLS.c.X file, but if that happens it only means that the source
2560: code being converted contains its own definition of a function which
2561: could have been supplied by libc.a. In such cases, we should avoid
2562: issuing the normal warning, and defer to the definition given in the
2563: user's own code. */
2564:
2565: for (dd_p = head; dd_p; dd_p = dd_p->next_for_func)
2566: if (dd_p->is_func_def && !dd_p->is_static)
2567: {
2568: if (!extern_def_p) /* Previous definition? */
2569: extern_def_p = dd_p; /* Remember the first definition found. */
2570: else
2571: {
2572: /* Ignore definition just found if it came from SYSCALLS.c.X. */
2573:
2574: if (is_syscalls_file (dd_p->file))
2575: continue;
2576:
2577: /* Quietly replace the definition previously found with the one
2578: just found if the previous one was from SYSCALLS.c.X. */
2579:
2580: if (is_syscalls_file (extern_def_p->file))
2581: {
2582: extern_def_p = dd_p;
2583: continue;
2584: }
2585:
2586: /* If we get here, then there is a conflict between two function
2587: declarations for the same function, both of which came from the
2588: user's own code. */
2589:
2590: if (!conflict_noted) /* first time we noticed? */
2591: {
2592: conflict_noted = 1;
2593: fprintf (stderr, "%s: conflicting extern definitions of '%s'\n",
2594: pname, head->hash_entry->symbol);
2595: if (!quiet_flag)
2596: {
2597: fprintf (stderr, "%s: declarations of '%s' will not be converted\n",
2598: pname, head->hash_entry->symbol);
2599: fprintf (stderr, "%s: conflict list for '%s' follows:\n",
2600: pname, head->hash_entry->symbol);
2601: fprintf (stderr, "%s: %s(%d): %s\n",
2602: pname,
2603: shortpath (NULL, extern_def_p->file->hash_entry->symbol),
2604: extern_def_p->line, extern_def_p->ansi_decl);
2605: }
2606: }
2607: if (!quiet_flag)
2608: fprintf (stderr, "%s: %s(%d): %s\n",
2609: pname,
2610: shortpath (NULL, dd_p->file->hash_entry->symbol),
2611: dd_p->line, dd_p->ansi_decl);
2612: }
2613: }
2614:
2615: /* We want to err on the side of caution, so if we found multiple conflicting
2616: definitions for the same function, treat this as being that same as if we
2617: had found no definitions (i.e. return NULL). */
2618:
2619: if (conflict_noted)
2620: return NULL;
2621:
2622: if (!extern_def_p)
2623: {
2624: /* We have no definitions for this function so do the next best thing.
2625: Search for an extern declaration already in prototype form. */
2626:
2627: for (dd_p = head; dd_p; dd_p = dd_p->next_for_func)
2628: if (!dd_p->is_func_def && !dd_p->is_static && dd_p->prototyped)
2629: {
2630: extern_def_p = dd_p; /* save a pointer to the definition */
2631: if (!quiet_flag)
2632: fprintf (stderr, "%s: warning: using formals list from %s(%d) for function `%s'\n",
2633: pname,
2634: shortpath (NULL, dd_p->file->hash_entry->symbol),
2635: dd_p->line, dd_p->hash_entry->symbol);
2636: break;
2637: }
2638:
2639: /* Gripe about unprototyped function declarations that we found no
2640: corresponding definition (or other source of prototype information)
2641: for.
2642:
2643: Gripe even if the unprototyped declaration we are worried about
2644: exists in a file in one of the "system" include directories. We
2645: can gripe about these because we should have at least found a
2646: corresponding (pseudo) definition in the SYSCALLS.c.X file. If we
2647: didn't, then that means that the SYSCALLS.c.X file is missing some
2648: needed prototypes for this particular system. That is worth telling
2649: the user about! */
2650:
2651: if (!extern_def_p)
2652: {
2653: const char *file = user->file->hash_entry->symbol;
2654:
2655: if (!quiet_flag)
2656: if (in_system_include_dir (file))
2657: {
2658: /* Why copy this string into `needed' at all?
2659: Why not just use user->ansi_decl without copying? */
2660: char *needed = (char *) alloca (strlen (user->ansi_decl) + 1);
2661: char *p;
2662:
2663: strcpy (needed, user->ansi_decl);
2664: p = (NONCONST char *) substr (needed, user->hash_entry->symbol)
2665: + strlen (user->hash_entry->symbol) + 2;
2666: /* Avoid having ??? in the string. */
2667: *p++ = '?';
2668: *p++ = '?';
2669: *p++ = '?';
2670: strcpy (p, ");");
2671:
2672: fprintf (stderr, "%s: %d: `%s' used but missing from SYSCALLS\n",
2673: shortpath (NULL, file), user->line,
2674: needed+7); /* Don't print "extern " */
2675: }
2676: #if 0
2677: else
2678: fprintf (stderr, "%s: %d: warning: no extern definition for `%s'\n",
2679: shortpath (NULL, file), user->line,
2680: user->hash_entry->symbol);
2681: #endif
2682: }
2683: }
2684: return extern_def_p;
2685: }
2686:
2687: /* Find the (only?) static definition for a particular function name in a
2688: given file. Here we get the function-name and the file info indirectly
2689: from the def_dec_info record pointer which is passed in. */
2690:
2691: static const def_dec_info *
2692: find_static_definition (user)
2693: const def_dec_info *user;
2694: {
2695: const def_dec_info *head = user->hash_entry->ddip;
2696: const def_dec_info *dd_p;
2697: int num_static_defs = 0;
2698: const def_dec_info *static_def_p = NULL;
2699:
2700: for (dd_p = head; dd_p; dd_p = dd_p->next_for_func)
2701: if (dd_p->is_func_def && dd_p->is_static && (dd_p->file == user->file))
2702: {
2703: static_def_p = dd_p; /* save a pointer to the definition */
2704: num_static_defs++;
2705: }
2706: if (num_static_defs == 0)
2707: {
2708: if (!quiet_flag)
2709: fprintf (stderr, "%s: warning: no static definition for `%s' in file `%s'\n",
2710: pname, head->hash_entry->symbol,
2711: shortpath (NULL, user->file->hash_entry->symbol));
2712: }
2713: else if (num_static_defs > 1)
2714: {
2715: fprintf (stderr, "%s: multiple static defs of `%s' in file `%s'\n",
2716: pname, head->hash_entry->symbol,
2717: shortpath (NULL, user->file->hash_entry->symbol));
2718: return NULL;
2719: }
2720: return static_def_p;
2721: }
2722:
2723: /* Find good prototype style formal argument lists for all of the function
2724: declarations which didn't have them before now.
2725:
2726: To do this we consider each function name one at a time. For each function
2727: name, we look at the items on the linked list of def_dec_info records for
2728: that particular name.
2729:
2730: Somewhere on this list we should find one (and only one) def_dec_info
2731: record which represents the actual function definition, and this record
2732: should have a nice formal argument list already associated with it.
2733:
2734: Thus, all we have to do is to connect up all of the other def_dec_info
2735: records for this particular function name to the special one which has
2736: the full-blown formals list.
2737:
2738: Of course it is a little more complicated than just that. See below for
2739: more details. */
2740:
2741: static void
2742: connect_defs_and_decs (hp)
2743: const hash_table_entry *hp;
2744: {
2745: const def_dec_info *dd_p;
2746: const def_dec_info *extern_def_p = NULL;
2747: int first_extern_reference = 1;
2748:
2749: /* Traverse the list of definitions and declarations for this particular
2750: function name. For each item on the list, if it is a function
2751: definition (either old style or new style) then GCC has already been
2752: kind enough to produce a prototype for us, and it is associated with
2753: the item already, so declare the item as its own associated "definition".
2754:
2755: Also, for each item which is only a function declaration, but which
2756: nonetheless has its own prototype already (obviously supplied by the user)
2757: declare the item as it's own definition.
2758:
2759: Note that when/if there are multiple user-supplied prototypes already
2760: present for multiple declarations of any given function, these multiple
2761: prototypes *should* all match exactly with one another and with the
2762: prototype for the actual function definition. We don't check for this
2763: here however, since we assume that the compiler must have already done
2764: this consistency checking when it was creating the .X files. */
2765:
2766: for (dd_p = hp->ddip; dd_p; dd_p = dd_p->next_for_func)
2767: if (dd_p->prototyped)
2768: ((NONCONST def_dec_info *) dd_p)->definition = dd_p;
2769:
2770: /* Traverse the list of definitions and declarations for this particular
2771: function name. For each item on the list, if it is an extern function
2772: declaration and if it has no associated definition yet, go try to find
2773: the matching extern definition for the declaration.
2774:
2775: When looking for the matching function definition, warn the user if we
2776: fail to find one.
2777:
2778: If we find more that one function definition also issue a warning.
2779:
2780: Do the search for the matching definition only once per unique function
2781: name (and only when absolutely needed) so that we can avoid putting out
2782: redundant warning messages, and so that we will only put out warning
2783: messages when there is actually a reference (i.e. a declaration) for
2784: which we need to find a matching definition. */
2785:
2786: for (dd_p = hp->ddip; dd_p; dd_p = dd_p->next_for_func)
2787: if (!dd_p->is_func_def && !dd_p->is_static && !dd_p->definition)
2788: {
2789: if (first_extern_reference)
2790: {
2791: extern_def_p = find_extern_def (hp->ddip, dd_p);
2792: first_extern_reference = 0;
2793: }
2794: ((NONCONST def_dec_info *) dd_p)->definition = extern_def_p;
2795: }
2796:
2797: /* Traverse the list of definitions and declarations for this particular
2798: function name. For each item on the list, if it is a static function
2799: declaration and if it has no associated definition yet, go try to find
2800: the matching static definition for the declaration within the same file.
2801:
2802: When looking for the matching function definition, warn the user if we
2803: fail to find one in the same file with the declaration, and refuse to
2804: convert this kind of cross-file static function declaration. After all,
2805: this is stupid practice and should be discouraged.
2806:
2807: We don't have to worry about the possibility that there is more than one
2808: matching function definition in the given file because that would have
2809: been flagged as an error by the compiler.
2810:
2811: Do the search for the matching definition only once per unique
2812: function-name/source-file pair (and only when absolutely needed) so that
2813: we can avoid putting out redundant warning messages, and so that we will
2814: only put out warning messages when there is actually a reference (i.e. a
2815: declaration) for which we actually need to find a matching definition. */
2816:
2817: for (dd_p = hp->ddip; dd_p; dd_p = dd_p->next_for_func)
2818: if (!dd_p->is_func_def && dd_p->is_static && !dd_p->definition)
2819: {
2820: const def_dec_info *dd_p2;
2821: const def_dec_info *static_def;
2822:
2823: /* We have now found a single static declaration for which we need to
2824: find a matching definition. We want to minimize the work (and the
2825: number of warnings), so we will find an appropriate (matching)
2826: static definition for this declaration, and then distribute it
2827: (as the definition for) any and all other static declarations
2828: for this function name which occur within the same file, and which
2829: do not already have definitions.
2830:
2831: Note that a trick is used here to prevent subsequent attempts to
2832: call find_static_definition for a given function-name & file
2833: if the first such call returns NULL. Essentially, we convert
2834: these NULL return values to -1, and put the -1 into the definition
2835: field for each other static declaration from the same file which
2836: does not already have an associated definition.
2837: This makes these other static declarations look like they are
2838: actually defined already when the outer loop here revisits them
2839: later on. Thus, the outer loop will skip over them. Later, we
2840: turn the -1's back to NULL's. */
2841:
2842: ((NONCONST def_dec_info *) dd_p)->definition =
2843: (static_def = find_static_definition (dd_p))
2844: ? static_def
2845: : (const def_dec_info *) -1;
2846:
2847: for (dd_p2 = dd_p->next_for_func; dd_p2; dd_p2 = dd_p2->next_for_func)
2848: if (!dd_p2->is_func_def && dd_p2->is_static
2849: && !dd_p2->definition && (dd_p2->file == dd_p->file))
2850: ((NONCONST def_dec_info *)dd_p2)->definition = dd_p->definition;
2851: }
2852:
2853: /* Convert any dummy (-1) definitions we created in the step above back to
2854: NULL's (as they should be). */
2855:
2856: for (dd_p = hp->ddip; dd_p; dd_p = dd_p->next_for_func)
2857: if (dd_p->definition == (def_dec_info *) -1)
2858: ((NONCONST def_dec_info *) dd_p)->definition = NULL;
2859: }
2860:
2861: #endif /* !defined (UNPROTOIZE) */
2862:
2863: /* Give a pointer into the clean text buffer, return a number which is the
2864: original source line number that the given pointer points into. */
2865:
2866: static int
2867: identify_lineno (clean_p)
2868: const char *clean_p;
2869: {
2870: int line_num = 1;
2871: const char *scan_p;
2872:
2873: for (scan_p = clean_text_base; scan_p <= clean_p; scan_p++)
2874: if (*scan_p == '\n')
2875: line_num++;
2876: return line_num;
2877: }
2878:
2879: /* Issue an error message and give up on doing this particular edit. */
2880:
2881: static void
2882: declare_source_confusing (clean_p)
2883: const char *clean_p;
2884: {
2885: if (!quiet_flag)
2886: {
2887: if (clean_p == 0)
2888: fprintf (stderr, "%s: %d: warning: source too confusing\n",
2889: shortpath (NULL, convert_filename), last_known_line_number);
2890: else
2891: fprintf (stderr, "%s: %d: warning: source too confusing\n",
2892: shortpath (NULL, convert_filename),
2893: identify_lineno (clean_p));
2894: }
2895: longjmp (source_confusion_recovery, 1);
2896: }
2897:
2898: /* Check that a condition which is expected to be true in the original source
2899: code is in fact true. If not, issue an error message and give up on
2900: converting this particular source file. */
2901:
2902: static void
2903: check_source (cond, clean_p)
2904: int cond;
2905: const char *clean_p;
2906: {
2907: if (!cond)
2908: declare_source_confusing (clean_p);
2909: }
2910:
2911: /* If we think of the in-core cleaned text buffer as a memory mapped
2912: file (with the variable last_known_line_start acting as sort of a
2913: file pointer) then we can imagine doing "seeks" on the buffer. The
2914: following routine implements a kind of "seek" operation for the in-core
2915: (cleaned) copy of the source file. When finished, it returns a pointer to
2916: the start of a given (numbered) line in the cleaned text buffer.
2917:
2918: Note that protoize only has to "seek" in the forward direction on the
2919: in-core cleaned text file buffers, and it never needs to back up.
2920:
2921: This routine is made a little bit faster by remembering the line number
2922: (and pointer value) supplied (and returned) from the previous "seek".
2923: This prevents us from always having to start all over back at the top
2924: of the in-core cleaned buffer again. */
2925:
2926: static const char *
2927: seek_to_line (n)
2928: int n;
2929: {
2930: if (n < last_known_line_number)
2931: abort ();
2932:
2933: while (n > last_known_line_number)
2934: {
2935: while (*last_known_line_start != '\n')
2936: check_source (++last_known_line_start < clean_text_limit, 0);
2937: last_known_line_start++;
2938: last_known_line_number++;
2939: }
2940: return last_known_line_start;
2941: }
2942:
2943: /* Given a pointer to a character in the cleaned text buffer, return a pointer
2944: to the next non-whitepace character which follows it. */
2945:
2946: static const char *
2947: forward_to_next_token_char (ptr)
2948: const char *ptr;
2949: {
2950: for (++ptr; isspace (*ptr); check_source (++ptr < clean_text_limit, 0))
2951: continue;
2952: return ptr;
2953: }
2954:
2955: /* Copy a chunk of text of length `len' and starting at `str' to the current
2956: output buffer. Note that all attempts to add stuff to the current output
2957: buffer ultimately go through here. */
2958:
2959: static void
2960: output_bytes (str, len)
2961: const char *str;
2962: size_t len;
2963: {
2964: if ((repl_write_ptr + 1) + len >= repl_text_limit)
2965: {
2966: size_t new_size = (repl_text_limit - repl_text_base) << 1;
2967: char *new_buf = (char *) xrealloc (repl_text_base, new_size);
2968:
2969: repl_write_ptr = new_buf + (repl_write_ptr - repl_text_base);
2970: repl_text_base = new_buf;
2971: repl_text_limit = new_buf + new_size;
2972: }
2973: memcpy (repl_write_ptr + 1, str, len);
2974: repl_write_ptr += len;
2975: }
2976:
2977: /* Copy all bytes (except the trailing null) of a null terminated string to
2978: the current output buffer. */
2979:
2980: static void
2981: output_string (str)
2982: const char *str;
2983: {
2984: output_bytes (str, strlen (str));
2985: }
2986:
2987: /* Copy some characters from the original text buffer to the current output
2988: buffer.
2989:
2990: This routine takes a pointer argument `p' which is assumed to be a pointer
2991: into the cleaned text buffer. The bytes which are copied are the `original'
2992: equivalents for the set of bytes between the last value of `clean_read_ptr'
2993: and the argument value `p'.
2994:
2995: The set of bytes copied however, comes *not* from the cleaned text buffer,
2996: but rather from the direct counterparts of these bytes within the original
2997: text buffer.
2998:
2999: Thus, when this function is called, some bytes from the original text
3000: buffer (which may include original comments and preprocessing directives)
3001: will be copied into the output buffer.
3002:
3003: Note that the request implide when this routine is called includes the
3004: byte pointed to by the argument pointer `p'. */
3005:
3006: static void
3007: output_up_to (p)
3008: const char *p;
3009: {
3010: size_t copy_length = (size_t) (p - clean_read_ptr);
3011: const char *copy_start = orig_text_base+(clean_read_ptr-clean_text_base)+1;
3012:
3013: if (copy_length == 0)
3014: return;
3015:
3016: output_bytes (copy_start, copy_length);
3017: clean_read_ptr = p;
3018: }
3019:
3020: /* Given a pointer to a def_dec_info record which represents some form of
3021: definition of a function (perhaps a real definition, or in lieu of that
3022: perhaps just a declaration with a full prototype) return true if this
3023: function is one which we should avoid converting. Return false
3024: otherwise. */
3025:
3026: static int
3027: other_variable_style_function (ansi_header)
3028: const char *ansi_header;
3029: {
3030: #ifdef UNPROTOIZE
3031:
3032: /* See if we have a stdarg function, or a function which has stdarg style
3033: parameters or a stdarg style return type. */
3034:
3035: return substr (ansi_header, "...") != 0;
3036:
3037: #else /* !defined (UNPROTOIZE) */
3038:
3039: /* See if we have a varargs function, or a function which has varargs style
3040: parameters or a varargs style return type. */
3041:
3042: const char *p;
3043: int len = strlen (varargs_style_indicator);
3044:
3045: for (p = ansi_header; p; )
3046: {
3047: const char *candidate;
3048:
3049: if ((candidate = substr (p, varargs_style_indicator)) == 0)
3050: return 0;
3051: else
3052: if (!is_id_char (candidate[-1]) && !is_id_char (candidate[len]))
3053: return 1;
3054: else
3055: p = candidate + 1;
3056: }
3057: return 0;
3058: #endif /* !defined (UNPROTOIZE) */
3059: }
3060:
3061: /* Do the editing operation specifically for a function "declaration". Note
3062: that editing for function "definitions" are handled in a separate routine
3063: below. */
3064:
3065: static void
3066: edit_fn_declaration (def_dec_p, clean_text_p)
3067: const def_dec_info *def_dec_p;
3068: const char *volatile clean_text_p;
3069: {
3070: const char *start_formals;
3071: const char *end_formals;
3072: const char *function_to_edit = def_dec_p->hash_entry->symbol;
3073: size_t func_name_len = strlen (function_to_edit);
3074: const char *end_of_fn_name;
3075:
3076: #ifndef UNPROTOIZE
3077:
3078: const f_list_chain_item *this_f_list_chain_item;
3079: const def_dec_info *definition = def_dec_p->definition;
3080:
3081: /* If we are protoizing, and if we found no corresponding definition for
3082: this particular function declaration, then just leave this declaration
3083: exactly as it is. */
3084:
3085: if (!definition)
3086: return;
3087:
3088: /* If we are protoizing, and if the corresponding definition that we found
3089: for this particular function declaration defined an old style varargs
3090: function, then we want to issue a warning and just leave this function
3091: declaration unconverted. */
3092:
3093: if (other_variable_style_function (definition->ansi_decl))
3094: {
3095: if (!quiet_flag)
3096: fprintf (stderr, "%s: %d: warning: varargs function declaration not converted\n",
3097: shortpath (NULL, def_dec_p->file->hash_entry->symbol),
3098: def_dec_p->line);
3099: return;
3100: }
3101:
3102: #endif /* !defined (UNPROTOIZE) */
3103:
3104: /* Setup here to recover from confusing source code detected during this
3105: particular "edit". */
3106:
3107: save_pointers ();
3108: if (setjmp (source_confusion_recovery))
3109: {
3110: restore_pointers ();
3111: fprintf (stderr, "%s: declaration of function `%s' not converted\n",
3112: pname, function_to_edit);
3113: return;
3114: }
3115:
3116: /* We are editing a function declaration. The line number we did a seek to
3117: contains the comma or semicolon which follows the declaration. Our job
3118: now is to scan backwards looking for the function name. This name *must*
3119: be followed by open paren (ignoring whitespace, of course). We need to
3120: replace everything between that open paren and the corresponding closing
3121: paren. If we are protoizing, we need to insert the prototype-style
3122: formals lists. If we are unprotoizing, we need to just delete everything
3123: between the pairs of opening and closing parens. */
3124:
3125: /* First move up to the end of the line. */
3126:
3127: while (*clean_text_p != '\n')
3128: check_source (++clean_text_p < clean_text_limit, 0);
3129: clean_text_p--; /* Point to just before the newline character. */
3130:
3131: /* Now we can scan backwards for the function name. */
3132:
3133: do
3134: {
3135: for (;;)
3136: {
3137: /* Scan leftwards until we find some character which can be
3138: part of an identifier. */
3139:
3140: while (!is_id_char (*clean_text_p))
3141: check_source (--clean_text_p > clean_read_ptr, 0);
3142:
3143: /* Scan backwards until we find a char that cannot be part of an
3144: identifier. */
3145:
3146: while (is_id_char (*clean_text_p))
3147: check_source (--clean_text_p > clean_read_ptr, 0);
3148:
3149: /* Having found an "id break", see if the following id is the one
3150: that we are looking for. If so, then exit from this loop. */
3151:
3152: if (!strncmp (clean_text_p+1, function_to_edit, func_name_len))
3153: {
3154: char ch = *(clean_text_p + 1 + func_name_len);
3155:
3156: /* Must also check to see that the name in the source text
3157: ends where it should (in order to prevent bogus matches
3158: on similar but longer identifiers. */
3159:
3160: if (! is_id_char (ch))
3161: break; /* exit from loop */
3162: }
3163: }
3164:
3165: /* We have now found the first perfect match for the function name in
3166: our backward search. This may or may not be the actual function
3167: name at the start of the actual function declaration (i.e. we could
3168: have easily been mislead). We will try to avoid getting fooled too
3169: often by looking forward for the open paren which should follow the
3170: identifier we just found. We ignore whitespace while hunting. If
3171: the next non-whitespace byte we see is *not* an open left paren,
3172: then we must assume that we have been fooled and we start over
3173: again accordingly. Note that there is no guarantee, that even if
3174: we do see the open paren, that we are in the right place.
3175: Programmers do the strangest things sometimes! */
3176:
3177: end_of_fn_name = clean_text_p + strlen (def_dec_p->hash_entry->symbol);
3178: start_formals = forward_to_next_token_char (end_of_fn_name);
3179: }
3180: while (*start_formals != '(');
3181:
3182: /* start_of_formals now points to the opening left paren which immediately
3183: follows the name of the function. */
3184:
3185: /* Note that there may be several formals lists which need to be modified
3186: due to the possibility that the return type of this function is a
3187: pointer-to-function type. If there are several formals lists, we
3188: convert them in left-to-right order here. */
3189:
3190: #ifndef UNPROTOIZE
3191: this_f_list_chain_item = definition->f_list_chain;
3192: #endif /* !defined (UNPROTOIZE) */
3193:
3194: for (;;)
3195: {
3196: {
3197: int depth;
3198:
3199: end_formals = start_formals + 1;
3200: depth = 1;
3201: for (; depth; check_source (++end_formals < clean_text_limit, 0))
3202: {
3203: switch (*end_formals)
3204: {
3205: case '(':
3206: depth++;
3207: break;
3208: case ')':
3209: depth--;
3210: break;
3211: }
3212: }
3213: end_formals--;
3214: }
3215:
3216: /* end_formals now points to the closing right paren of the formals
3217: list whose left paren is pointed to by start_formals. */
3218:
3219: /* Now, if we are protoizing, we insert the new ANSI-style formals list
3220: attached to the associated definition of this function. If however
3221: we are unprotoizing, then we simply delete any formals list which
3222: may be present. */
3223:
3224: output_up_to (start_formals);
3225: #ifndef UNPROTOIZE
3226: if (this_f_list_chain_item)
3227: {
3228: output_string (this_f_list_chain_item->formals_list);
3229: this_f_list_chain_item = this_f_list_chain_item->chain_next;
3230: }
3231: else
3232: {
3233: if (!quiet_flag)
3234: fprintf (stderr, "%s: warning: too many parameter lists in declaration of `%s'\n",
3235: pname, def_dec_p->hash_entry->symbol);
3236: check_source (0, end_formals); /* leave the declaration intact */
3237: }
3238: #endif /* !defined (UNPROTOIZE) */
3239: clean_read_ptr = end_formals - 1;
3240:
3241: /* Now see if it looks like there may be another formals list associated
3242: with the function declaration that we are converting (following the
3243: formals list that we just converted. */
3244:
3245: {
3246: const char *another_r_paren = forward_to_next_token_char (end_formals);
3247:
3248: if ((*another_r_paren != ')')
3249: || (*(start_formals = forward_to_next_token_char (another_r_paren)) != '('))
3250: {
3251: #ifndef UNPROTOIZE
3252: if (this_f_list_chain_item)
3253: {
3254: if (!quiet_flag)
3255: fprintf (stderr, "\n%s: warning: too few parameter lists in declaration of `%s'\n",
3256: pname, def_dec_p->hash_entry->symbol);
3257: check_source (0, start_formals); /* leave the decl intact */
3258: }
3259: #endif /* !defined (UNPROTOIZE) */
3260: break;
3261:
3262: }
3263: }
3264:
3265: /* There does appear to be yet another formals list, so loop around
3266: again, and convert it also. */
3267: }
3268: }
3269:
3270: /* Edit a whole group of formals lists, starting with the rightmost one
3271: from some set of formals lists. This routine is called once (from the
3272: outside) for each function declaration which is converted. It is
3273: recursive however, and it calls itself once for each remaining formal
3274: list that lies to the left of the one it was originally called to work
3275: on. Thus, a whole set gets done in right-to-left order.
3276:
3277: This routine returns non-zero if it thinks that it should not be trying
3278: to convert this particular function definition (because the name of the
3279: function doesn't match the one expected). */
3280:
3281: static int
3282: edit_formals_lists (end_formals, f_list_count, def_dec_p)
3283: const char *end_formals;
3284: unsigned int f_list_count;
3285: const def_dec_info *def_dec_p;
3286: {
3287: const char *start_formals;
3288: int depth;
3289:
3290: start_formals = end_formals - 1;
3291: depth = 1;
3292: for (; depth; check_source (--start_formals > clean_read_ptr, 0))
3293: {
3294: switch (*start_formals)
3295: {
3296: case '(':
3297: depth--;
3298: break;
3299: case ')':
3300: depth++;
3301: break;
3302: }
3303: }
3304: start_formals++;
3305:
3306: /* start_formals now points to the opening left paren of the formals list. */
3307:
3308: f_list_count--;
3309:
3310: if (f_list_count)
3311: {
3312: const char *next_end;
3313:
3314: /* There should be more formal lists to the left of here. */
3315:
3316: next_end = start_formals - 1;
3317: check_source (next_end > clean_read_ptr, 0);
3318: while (isspace (*next_end))
3319: check_source (--next_end > clean_read_ptr, 0);
3320: check_source (*next_end == ')', next_end);
3321: check_source (--next_end > clean_read_ptr, 0);
3322: check_source (*next_end == ')', next_end);
3323: if (edit_formals_lists (next_end, f_list_count, def_dec_p))
3324: return 1;
3325: }
3326:
3327: /* Check that the function name in the header we are working on is the same
3328: as the one we would expect to find. If not, issue a warning and return
3329: non-zero. */
3330:
3331: if (f_list_count == 0)
3332: {
3333: const char *expected = def_dec_p->hash_entry->symbol;
3334: const char *func_name_start;
3335: const char *func_name_limit;
3336: size_t func_name_len;
3337:
3338: for (func_name_limit = start_formals-1; isspace (*func_name_limit); )
3339: check_source (--func_name_limit > clean_read_ptr, 0);
3340:
3341: for (func_name_start = func_name_limit++;
3342: is_id_char (*func_name_start);
3343: func_name_start--)
3344: check_source (func_name_start > clean_read_ptr, 0);
3345: func_name_start++;
3346: func_name_len = func_name_limit - func_name_start;
3347: if (func_name_len == 0)
3348: check_source (0, func_name_start);
3349: if (func_name_len != strlen (expected)
3350: || strncmp (func_name_start, expected, func_name_len))
3351: {
3352: fprintf (stderr, "%s: %d: warning: found `%s' but expected `%s'\n",
3353: shortpath (NULL, def_dec_p->file->hash_entry->symbol),
3354: identify_lineno (func_name_start),
3355: dupnstr (func_name_start, func_name_len),
3356: expected);
3357: return 1;
3358: }
3359: }
3360:
3361: output_up_to (start_formals);
3362:
3363: #ifdef UNPROTOIZE
3364: if (f_list_count == 0)
3365: output_string (def_dec_p->formal_names);
3366: #else /* !defined (UNPROTOIZE) */
3367: {
3368: unsigned f_list_depth;
3369: const f_list_chain_item *flci_p = def_dec_p->f_list_chain;
3370:
3371: /* At this point, the current value of f_list count says how many
3372: links we have to follow through the f_list_chain to get to the
3373: particular formals list that we need to output next. */
3374:
3375: for (f_list_depth = 0; f_list_depth < f_list_count; f_list_depth++)
3376: flci_p = flci_p->chain_next;
3377: output_string (flci_p->formals_list);
3378: }
3379: #endif /* !defined (UNPROTOIZE) */
3380:
3381: clean_read_ptr = end_formals - 1;
3382: return 0;
3383: }
3384:
3385: /* Given a pointer to a byte in the clean text buffer which points to the
3386: beginning of a line that contains a "follower" token for a function
3387: definition header, do whatever is necessary to find the right closing
3388: paren for the rightmost formals list of the function definition header.
3389: */
3390:
3391: static const char *
3392: find_rightmost_formals_list (clean_text_p)
3393: const char *clean_text_p;
3394: {
3395: const char *end_formals;
3396:
3397: /* We are editing a function definition. The line number we did a seek
3398: to contains the first token which immediately follows the entire set of
3399: formals lists which are part of this particular function definition
3400: header.
3401:
3402: Our job now is to scan leftwards in the clean text looking for the
3403: right-paren which is at the end of the function header's rightmost
3404: formals list.
3405:
3406: If we ignore whitespace, this right paren should be the first one we
3407: see which is (ignoring whitespace) immediately followed either by the
3408: open curly-brace beginning the function body or by an alphabetic
3409: character (in the case where the function definition is in old (K&R)
3410: style and there are some declarations of formal parameters). */
3411:
3412: /* It is possible that the right paren we are looking for is on the
3413: current line (together with its following token). Just in case that
3414: might be true, we start out here by skipping down to the right end of
3415: the current line before starting our scan. */
3416:
3417: for (end_formals = clean_text_p; *end_formals != '\n'; end_formals++)
3418: continue;
3419: end_formals--;
3420:
3421: #ifdef UNPROTOIZE
3422:
3423: /* Now scan backwards while looking for the right end of the rightmost
3424: formals list associated with this function definition. */
3425:
3426: {
3427: char ch;
3428: const char *l_brace_p;
3429:
3430: /* Look leftward and try to find a right-paren. */
3431:
3432: while (*end_formals != ')')
3433: {
3434: if (isspace (*end_formals))
3435: while (isspace (*end_formals))
3436: check_source (--end_formals > clean_read_ptr, 0);
3437: else
3438: check_source (--end_formals > clean_read_ptr, 0);
3439: }
3440:
3441: ch = *(l_brace_p = forward_to_next_token_char (end_formals));
3442: /* Since we are unprotoizing an ANSI-style (prototyped) function
3443: definition, there had better not be anything (except whitespace)
3444: between the end of the ANSI formals list and the beginning of the
3445: function body (i.e. the '{'). */
3446:
3447: check_source (ch == '{', l_brace_p);
3448: }
3449:
3450: #else /* !defined (UNPROTOIZE) */
3451:
3452: /* Now scan backwards while looking for the right end of the rightmost
3453: formals list associated with this function definition. */
3454:
3455: while (1)
3456: {
3457: char ch;
3458: const char *l_brace_p;
3459:
3460: /* Look leftward and try to find a right-paren. */
3461:
3462: while (*end_formals != ')')
3463: {
3464: if (isspace (*end_formals))
3465: while (isspace (*end_formals))
3466: check_source (--end_formals > clean_read_ptr, 0);
3467: else
3468: check_source (--end_formals > clean_read_ptr, 0);
3469: }
3470:
3471: ch = *(l_brace_p = forward_to_next_token_char (end_formals));
3472:
3473: /* Since it is possible that we found a right paren before the starting
3474: '{' of the body which IS NOT the one at the end of the real K&R
3475: formals list (say for instance, we found one embedded inside one of
3476: the old K&R formal parameter declarations) we have to check to be
3477: sure that this is in fact the right paren that we were looking for.
3478:
3479: The one we were looking for *must* be followed by either a '{' or
3480: by an alphabetic character, while others *cannot* legally be followed
3481: by such characters. */
3482:
3483: if ((ch == '{') || isalpha (ch))
3484: break;
3485:
3486: /* At this point, we have found a right paren, but we know that it is
3487: not the one we were looking for, so backup one character and keep
3488: looking. */
3489:
3490: check_source (--end_formals > clean_read_ptr, 0);
3491: }
3492:
3493: #endif /* !defined (UNPROTOIZE) */
3494:
3495: return end_formals;
3496: }
3497:
3498: #ifndef UNPROTOIZE
3499:
3500: /* Insert into the output file a totally new declaration for a function
3501: which (up until now) was being called from within the current block
3502: without having been declared at any point such that the declaration
3503: was visible (i.e. in scope) at the point of the call.
3504:
3505: We need to add in explicit declarations for all such function calls
3506: in order to get the full benefit of prototype-based function call
3507: parameter type checking. */
3508:
3509: static void
3510: add_local_decl (def_dec_p, clean_text_p)
3511: const def_dec_info *def_dec_p;
3512: const char *clean_text_p;
3513: {
3514: const char *start_of_block;
3515: const char *function_to_edit = def_dec_p->hash_entry->symbol;
3516:
3517: /* Don't insert new local explicit declarations unless explicitly requested
3518: to do so. */
3519:
3520: if (!local_flag)
3521: return;
3522:
3523: /* Setup here to recover from confusing source code detected during this
3524: particular "edit". */
3525:
3526: save_pointers ();
3527: if (setjmp (source_confusion_recovery))
3528: {
3529: restore_pointers ();
3530: fprintf (stderr, "%s: local declaration for function `%s' not inserted\n",
3531: pname, function_to_edit);
3532: return;
3533: }
3534:
3535: /* We have already done a seek to the start of the line which should
3536: contain *the* open curly brace which begins the block in which we need
3537: to insert an explicit function declaration (to replace the implicit one).
3538:
3539: Now we scan that line, starting from the left, until we find the
3540: open curly brace we are looking for. Note that there may actually be
3541: multiple open curly braces on the given line, but we will be happy
3542: with the leftmost one no matter what. */
3543:
3544: start_of_block = clean_text_p;
3545: while (*start_of_block != '{' && *start_of_block != '\n')
3546: check_source (++start_of_block < clean_text_limit, 0);
3547:
3548: /* Note that the line from the original source could possibly
3549: contain *no* open curly braces! This happens if the line contains
3550: a macro call which expands into a chunk of text which includes a
3551: block (and that block's associated open and close curly braces).
3552: In cases like this, we give up, issue a warning, and do nothing. */
3553:
3554: if (*start_of_block != '{')
3555: {
3556: if (!quiet_flag)
3557: fprintf (stderr,
3558: "\n%s: %d: warning: can't add declaration of `%s' into macro call\n",
3559: def_dec_p->file->hash_entry->symbol, def_dec_p->line,
3560: def_dec_p->hash_entry->symbol);
3561: return;
3562: }
3563:
3564: /* Figure out what a nice (pretty) indentation would be for the new
3565: declaration we are adding. In order to do this, we must scan forward
3566: from the '{' until we find the first line which starts with some
3567: non-whitespace characters (i.e. real "token" material). */
3568:
3569: {
3570: const char *ep = forward_to_next_token_char (start_of_block) - 1;
3571: const char *sp;
3572:
3573: /* Now we have ep pointing at the rightmost byte of some existing indent
3574: stuff. At least that is the hope.
3575:
3576: We can now just scan backwards and find the left end of the existing
3577: indentation string, and then copy it to the output buffer. */
3578:
3579: for (sp = ep; isspace (*sp) && *sp != '\n'; sp--)
3580: continue;
3581:
3582: /* Now write out the open { which began this block, and any following
3583: trash up to and including the last byte of the existing indent that
3584: we just found. */
3585:
3586: output_up_to (ep);
3587:
3588: /* Now we go ahead and insert the new declaration at this point.
3589:
3590: If the definition of the given function is in the same file that we
3591: are currently editing, and if its full ANSI declaration normally
3592: would start with the keyword `extern', suppress the `extern'. */
3593:
3594: {
3595: const char *decl = def_dec_p->definition->ansi_decl;
3596:
3597: if ((*decl == 'e') && (def_dec_p->file == def_dec_p->definition->file))
3598: decl += 7;
3599: output_string (decl);
3600: }
3601:
3602: /* Finally, write out a new indent string, just like the preceding one
3603: that we found. This will typically include a newline as the first
3604: character of the indent string. */
3605:
3606: output_bytes (sp, (size_t) (ep - sp) + 1);
3607: }
3608: }
3609:
3610: /* Given a pointer to a file_info record, and a pointer to the beginning
3611: of a line (in the clean text buffer) which is assumed to contain the
3612: first "follower" token for the first function definition header in the
3613: given file, find a good place to insert some new global function
3614: declarations (which will replace scattered and imprecise implicit ones)
3615: and then insert the new explicit declaration at that point in the file. */
3616:
3617: static void
3618: add_global_decls (file_p, clean_text_p)
3619: const file_info *file_p;
3620: const char *clean_text_p;
3621: {
3622: const def_dec_info *dd_p;
3623: const char *scan_p;
3624:
3625: /* Setup here to recover from confusing source code detected during this
3626: particular "edit". */
3627:
3628: save_pointers ();
3629: if (setjmp (source_confusion_recovery))
3630: {
3631: restore_pointers ();
3632: fprintf (stderr, "%s: global declarations for file `%s' not inserted\n",
3633: pname, shortpath (NULL, file_p->hash_entry->symbol));
3634: return;
3635: }
3636:
3637: /* Start by finding a good location for adding the new explicit function
3638: declarations. To do this, we scan backwards, ignoring whitespace
3639: and comments and other junk until we find either a semicolon, or until
3640: we hit the beginning of the file. */
3641:
3642: scan_p = find_rightmost_formals_list (clean_text_p);
3643: for (;; --scan_p)
3644: {
3645: if (scan_p < clean_text_base)
3646: break;
3647: check_source (scan_p > clean_read_ptr, 0);
3648: if (*scan_p == ';')
3649: break;
3650: }
3651:
3652: /* scan_p now points either to a semicolon, or to just before the start
3653: of the whole file. */
3654:
3655: /* Now scan forward for the first non-whitespace character. In theory,
3656: this should be the first character of the following function definition
3657: header. We will put in the added declarations just prior to that. */
3658:
3659: scan_p++;
3660: while (isspace (*scan_p))
3661: scan_p++;
3662: scan_p--;
3663:
3664: output_up_to (scan_p);
3665:
3666: /* Now write out full prototypes for all of the things that had been
3667: implicitly declared in this file (but only those for which we were
3668: actually able to find unique matching definitions). Avoid duplicates
3669: by marking things that we write out as we go. */
3670:
3671: {
3672: int some_decls_added = 0;
3673:
3674: for (dd_p = file_p->defs_decs; dd_p; dd_p = dd_p->next_in_file)
3675: if (dd_p->is_implicit && dd_p->definition && !dd_p->definition->written)
3676: {
3677: const char *decl = dd_p->definition->ansi_decl;
3678:
3679: /* If the function for which we are inserting a declaration is
3680: actually defined later in the same file, then suppress the
3681: leading `extern' keyword (if there is one). */
3682:
3683: if (*decl == 'e' && (dd_p->file == dd_p->definition->file))
3684: decl += 7;
3685:
3686: output_string ("\n");
3687: output_string (decl);
3688: some_decls_added = 1;
3689: ((NONCONST def_dec_info *) dd_p->definition)->written = 1;
3690: }
3691: if (some_decls_added)
3692: output_string ("\n\n");
3693: }
3694:
3695: /* Unmark all of the definitions that we just marked. */
3696:
3697: for (dd_p = file_p->defs_decs; dd_p; dd_p = dd_p->next_in_file)
3698: if (dd_p->definition)
3699: ((NONCONST def_dec_info *) dd_p->definition)->written = 0;
3700: }
3701:
3702: #endif /* !defined (UNPROTOIZE) */
3703:
3704: /* Do the editing operation specifically for a function "definition". Note
3705: that editing operations for function "declarations" are handled by a
3706: separate routine above. */
3707:
3708: static void
3709: edit_fn_definition (def_dec_p, clean_text_p)
3710: const def_dec_info *def_dec_p;
3711: const char *clean_text_p;
3712: {
3713: const char *end_formals;
3714: const char *function_to_edit = def_dec_p->hash_entry->symbol;
3715:
3716: /* Setup here to recover from confusing source code detected during this
3717: particular "edit". */
3718:
3719: save_pointers ();
3720: if (setjmp (source_confusion_recovery))
3721: {
3722: restore_pointers ();
3723: fprintf (stderr, "%s: definition of function `%s' not converted\n",
3724: pname, function_to_edit);
3725: return;
3726: }
3727:
3728: end_formals = find_rightmost_formals_list (clean_text_p);
3729:
3730: /* end_of_formals now points to the closing right paren of the rightmost
3731: formals list which is actually part of the `header' of the function
3732: definition that we are converting. */
3733:
3734: /* If the header of this function definition looks like it declares a
3735: function with a variable number of arguments, and if the way it does
3736: that is different from that way we would like it (i.e. varargs vs.
3737: stdarg) then issue a warning and leave the header unconverted. */
3738:
3739: if (other_variable_style_function (def_dec_p->ansi_decl))
3740: {
3741: if (!quiet_flag)
3742: fprintf (stderr, "%s: %d: warning: definition of %s not converted\n",
3743: shortpath (NULL, def_dec_p->file->hash_entry->symbol),
3744: identify_lineno (end_formals),
3745: other_var_style);
3746: output_up_to (end_formals);
3747: return;
3748: }
3749:
3750: if (edit_formals_lists (end_formals, def_dec_p->f_list_count, def_dec_p))
3751: {
3752: restore_pointers ();
3753: fprintf (stderr, "%s: definition of function `%s' not converted\n",
3754: pname, function_to_edit);
3755: return;
3756: }
3757:
3758: /* Have to output the last right paren because this never gets flushed by
3759: edit_formals_list. */
3760:
3761: output_up_to (end_formals);
3762:
3763: #ifdef UNPROTOIZE
3764: {
3765: const char *decl_p;
3766: const char *semicolon_p;
3767: const char *limit_p;
3768: const char *scan_p;
3769: int had_newlines = 0;
3770:
3771: /* Now write out the K&R style formal declarations, one per line. */
3772:
3773: decl_p = def_dec_p->formal_decls;
3774: limit_p = decl_p + strlen (decl_p);
3775: for (;decl_p < limit_p; decl_p = semicolon_p + 2)
3776: {
3777: for (semicolon_p = decl_p; *semicolon_p != ';'; semicolon_p++)
3778: continue;
3779: output_string ("\n");
3780: output_string (indent_string);
3781: output_bytes (decl_p, (size_t) ((semicolon_p + 1) - decl_p));
3782: }
3783:
3784: /* If there are no newlines between the end of the formals list and the
3785: start of the body, we should insert one now. */
3786:
3787: for (scan_p = end_formals+1; *scan_p != '{'; )
3788: {
3789: if (*scan_p == '\n')
3790: {
3791: had_newlines = 1;
3792: break;
3793: }
3794: check_source (++scan_p < clean_text_limit, 0);
3795: }
3796: if (!had_newlines)
3797: output_string ("\n");
3798: }
3799: #else /* !defined (UNPROTOIZE) */
3800: /* If we are protoizing, there may be some flotsum & jetsum (like comments
3801: and preprocessing directives) after the old formals list but before
3802: the following { and we would like to preserve that stuff while effectively
3803: deleting the existing K&R formal parameter declarations. We do so here
3804: in a rather tricky way. Basically, we white out any stuff *except*
3805: the comments/pp-directives in the original text buffer, then, if there
3806: is anything in this area *other* than whitespace, we output it. */
3807: {
3808: const char *end_formals_orig;
3809: const char *start_body;
3810: const char *start_body_orig;
3811: const char *scan;
3812: const char *scan_orig;
3813: int have_flotsum = 0;
3814: int have_newlines = 0;
3815:
3816: for (start_body = end_formals + 1; *start_body != '{';)
3817: check_source (++start_body < clean_text_limit, 0);
3818:
3819: end_formals_orig = orig_text_base + (end_formals - clean_text_base);
3820: start_body_orig = orig_text_base + (start_body - clean_text_base);
3821: scan = end_formals + 1;
3822: scan_orig = end_formals_orig + 1;
3823: for (; scan < start_body; scan++, scan_orig++)
3824: {
3825: if (*scan == *scan_orig)
3826: {
3827: have_newlines |= (*scan_orig == '\n');
3828: /* Leave identical whitespace alone. */
3829: if (!isspace (*scan_orig))
3830: *((NONCONST char *)scan_orig) = ' '; /* identical - so whiteout */
3831: }
3832: else
3833: have_flotsum = 1;
3834: }
3835: if (have_flotsum)
3836: output_bytes (end_formals_orig + 1,
3837: (size_t) (start_body_orig - end_formals_orig) - 1);
3838: else
3839: if (have_newlines)
3840: output_string ("\n");
3841: else
3842: output_string (" ");
3843: clean_read_ptr = start_body - 1;
3844: }
3845: #endif /* !defined (UNPROTOIZE) */
3846: }
3847:
3848: /* Clean up the clean text buffer. Do this by converting comments and
3849: preprocessor directives into spaces. Also convert line continuations
3850: into whitespace. Also, whiteout string and character literals. */
3851:
3852: static void
3853: do_cleaning (new_clean_text_base, new_clean_text_limit)
3854: char *new_clean_text_base;
3855: char *new_clean_text_limit;
3856: {
3857: char *scan_p;
3858: int non_whitespace_since_newline = 0;
3859:
3860: for (scan_p = new_clean_text_base; scan_p < new_clean_text_limit; scan_p++)
3861: {
3862: switch (*scan_p)
3863: {
3864: case '/': /* Handle comments. */
3865: if (scan_p[1] != '*')
3866: goto regular;
3867: non_whitespace_since_newline = 1;
3868: scan_p[0] = ' ';
3869: scan_p[1] = ' ';
3870: scan_p += 2;
3871: while (scan_p[1] != '/' || scan_p[0] != '*')
3872: {
3873: if (!isspace (*scan_p))
3874: *scan_p = ' ';
3875: if (++scan_p >= new_clean_text_limit)
3876: abort ();
3877: }
3878: *scan_p++ = ' ';
3879: *scan_p = ' ';
3880: break;
3881:
3882: case '#': /* Handle pp directives. */
3883: if (non_whitespace_since_newline)
3884: goto regular;
3885: *scan_p = ' ';
3886: while (scan_p[1] != '\n' || scan_p[0] == '\\')
3887: {
3888: if (!isspace (*scan_p))
3889: *scan_p = ' ';
3890: if (++scan_p >= new_clean_text_limit)
3891: abort ();
3892: }
3893: *scan_p++ = ' ';
3894: break;
3895:
3896: case '\'': /* Handle character literals. */
3897: non_whitespace_since_newline = 1;
3898: while (scan_p[1] != '\'' || scan_p[0] == '\\')
3899: {
3900: if (scan_p[0] == '\\' && !isspace (scan_p[1]))
3901: scan_p[1] = ' ';
3902: if (!isspace (*scan_p))
3903: *scan_p = ' ';
3904: if (++scan_p >= new_clean_text_limit)
3905: abort ();
3906: }
3907: *scan_p++ = ' ';
3908: break;
3909:
3910: case '"': /* Handle string literals. */
3911: non_whitespace_since_newline = 1;
3912: while (scan_p[1] != '"' || scan_p[0] == '\\')
3913: {
3914: if (scan_p[0] == '\\' && !isspace (scan_p[1]))
3915: scan_p[1] = ' ';
3916: if (!isspace (*scan_p))
3917: *scan_p = ' ';
3918: if (++scan_p >= new_clean_text_limit)
3919: abort ();
3920: }
3921: *scan_p++ = ' ';
3922: break;
3923:
3924: case '\\': /* Handle line continuations. */
3925: if (scan_p[1] != '\n')
3926: goto regular;
3927: *scan_p = ' ';
3928: break;
3929:
3930: case '\n':
3931: non_whitespace_since_newline = 0; /* Reset. */
3932: break;
3933:
3934: case ' ':
3935: case '\v':
3936: case '\t':
3937: case '\r':
3938: case '\f':
3939: case '\b':
3940: break; /* Whitespace characters. */
3941:
3942: default:
3943: regular:
3944: non_whitespace_since_newline = 1;
3945: break;
3946: }
3947: }
3948: }
3949:
3950: /* Given a pointer to the closing right parenthesis for a particular formals
3951: list (in the clean text buffer) find the corresponding left parenthesis
3952: and return a pointer to it. */
3953:
3954: static const char *
3955: careful_find_l_paren (p)
3956: const char *p;
3957: {
3958: const char *q;
3959: int paren_depth;
3960:
3961: for (paren_depth = 1, q = p-1; paren_depth; check_source (--q >= clean_text_base, 0))
3962: {
3963: switch (*q)
3964: {
3965: case ')':
3966: paren_depth++;
3967: break;
3968: case '(':
3969: paren_depth--;
3970: break;
3971: }
3972: }
3973: return ++q;
3974: }
3975:
3976: /* Scan the clean text buffer for cases of function definitions that we
3977: don't really know about because they were preprocessed out when the
3978: aux info files were created.
3979:
3980: In this version of protoize/unprotoize we just give a warning for each
3981: one found. A later version may be able to at least unprotoize such
3982: missed items.
3983:
3984: Note that we may easily find all function definitions simply by
3985: looking for places where there is a left paren which is (ignoring
3986: whitespace) immediately followed by either a left-brace or by an
3987: upper or lower case letter. Whenever we find this combination, we
3988: have also found a function definition header.
3989:
3990: Finding function *declarations* using syntactic clues is much harder.
3991: I will probably try to do this in a later version though. */
3992:
3993: static void
3994: scan_for_missed_items (file_p)
3995: const file_info *file_p;
3996: {
3997: static const char *scan_p;
3998: const char *limit = clean_text_limit - 3;
3999: static const char *backup_limit;
4000:
4001: backup_limit = clean_text_base - 1;
4002:
4003: for (scan_p = clean_text_base; scan_p < limit; scan_p++)
4004: {
4005: if (*scan_p == ')')
4006: {
4007: static const char *last_r_paren;
4008: const char *ahead_p;
4009:
4010: last_r_paren = scan_p;
4011:
4012: for (ahead_p = scan_p + 1; isspace (*ahead_p); )
4013: check_source (++ahead_p < limit, limit);
4014:
4015: scan_p = ahead_p - 1;
4016:
4017: if (isalpha (*ahead_p) || *ahead_p == '{')
4018: {
4019: const char *last_l_paren;
4020: const int lineno = identify_lineno (ahead_p);
4021:
4022: if (setjmp (source_confusion_recovery))
4023: continue;
4024:
4025: /* We know we have a function definition header. Now skip
4026: leftwards over all of its associated formals lists. */
4027:
4028: do
4029: {
4030: last_l_paren = careful_find_l_paren (last_r_paren);
4031: for (last_r_paren = last_l_paren-1; isspace (*last_r_paren); )
4032: check_source (--last_r_paren >= backup_limit, backup_limit);
4033: }
4034: while (*last_r_paren == ')');
4035:
4036: if (is_id_char (*last_r_paren))
4037: {
4038: const char *id_limit = last_r_paren + 1;
4039: const char *id_start;
4040: size_t id_length;
4041: const def_dec_info *dd_p;
4042:
4043: for (id_start = id_limit-1; is_id_char (*id_start); )
4044: check_source (--id_start >= backup_limit, backup_limit);
4045: id_start++;
4046: backup_limit = id_start;
4047: if ((id_length = (size_t) (id_limit - id_start)) == 0)
4048: goto not_missed;
4049:
4050: {
4051: char *func_name = (char *) alloca (id_length + 1);
4052: static const char * const stmt_keywords[]
4053: = { "if", "else", "do", "while", "for", "switch", "case", "return", 0 };
4054: const char * const *stmt_keyword;
4055:
4056: strncpy (func_name, id_start, id_length);
4057: func_name[id_length] = '\0';
4058:
4059: /* We must check here to see if we are actually looking at
4060: a statement rather than an actual function call. */
4061:
4062: for (stmt_keyword = stmt_keywords; *stmt_keyword; stmt_keyword++)
4063: if (!strcmp (func_name, *stmt_keyword))
4064: goto not_missed;
4065:
4066: #if 0
4067: fprintf (stderr, "%s: found definition of `%s' at %s(%d)\n",
4068: pname,
4069: func_name,
4070: shortpath (NULL, file_p->hash_entry->symbol),
4071: identify_lineno (id_start));
4072: #endif /* 0 */
4073: /* We really should check for a match of the function name
4074: here also, but why bother. */
4075:
4076: for (dd_p = file_p->defs_decs; dd_p; dd_p = dd_p->next_in_file)
4077: if (dd_p->is_func_def && dd_p->line == lineno)
4078: goto not_missed;
4079:
4080: /* If we make it here, then we did not know about this
4081: function definition. */
4082:
4083: fprintf (stderr, "%s: %d: warning: `%s' excluded by preprocessing\n",
4084: shortpath (NULL, file_p->hash_entry->symbol),
4085: identify_lineno (id_start), func_name);
4086: fprintf (stderr, "%s: function definition not converted\n",
4087: pname);
4088: }
4089: not_missed: ;
4090: }
4091: }
4092: }
4093: }
4094: }
4095:
4096: /* Do all editing operations for a single source file (either a "base" file
4097: or an "include" file). To do this we read the file into memory, keep a
4098: virgin copy there, make another cleaned in-core copy of the original file
4099: (i.e. one in which all of the comments and preprocessor directives have
4100: been replaced with whitespace), then use these two in-core copies of the
4101: file to make a new edited in-core copy of the file. Finally, rename the
4102: original file (as a way of saving it), and then write the edited version
4103: of the file from core to a disk file of the same name as the original.
4104:
4105: Note that the trick of making a copy of the original sans comments &
4106: preprocessor directives make the editing a whole lot easier. */
4107:
4108: static void
4109: edit_file (hp)
4110: const hash_table_entry *hp;
4111: {
4112: struct stat stat_buf;
4113: const file_info *file_p = hp->fip;
4114: char *new_orig_text_base;
4115: char *new_orig_text_limit;
4116: char *new_clean_text_base;
4117: char *new_clean_text_limit;
4118: size_t orig_size;
4119: size_t repl_size;
4120: int first_definition_in_file;
4121:
4122: /* If we are not supposed to be converting this file, or if there is
4123: nothing in there which needs converting, just skip this file. */
4124:
4125: if (!needs_to_be_converted (file_p))
4126: return;
4127:
4128: convert_filename = file_p->hash_entry->symbol;
4129:
4130: /* Convert a file if it is in a directory where we want conversion
4131: and the file is not excluded. */
4132:
4133: if (!directory_specified_p (convert_filename)
4134: || file_excluded_p (convert_filename))
4135: {
4136: if (!quiet_flag
4137: #ifdef UNPROTOIZE
4138: /* Don't even mention "system" include files unless we are
4139: protoizing. If we are protoizing, we mention these as a
4140: gentle way of prodding the user to convert his "system"
4141: include files to prototype format. */
4142: && !in_system_include_dir (convert_filename)
4143: #endif /* defined (UNPROTOIZE) */
4144: )
4145: fprintf (stderr, "%s: `%s' not converted\n",
4146: pname, shortpath (NULL, convert_filename));
4147: return;
4148: }
4149:
4150: /* Let the user know what we are up to. */
4151:
4152: if (nochange_flag)
4153: fprintf (stderr, "%s: would convert file `%s'\n",
4154: pname, shortpath (NULL, convert_filename));
4155: else
4156: fprintf (stderr, "%s: converting file `%s'\n",
4157: pname, shortpath (NULL, convert_filename));
4158: fflush (stderr);
4159:
4160: /* Find out the size (in bytes) of the original file. */
4161:
4162: /* The cast avoids an erroneous warning on AIX. */
4163: if (my_stat ((char *)convert_filename, &stat_buf) == -1)
4164: {
4165: fprintf (stderr, "%s: can't get status for file `%s': %s\n",
4166: pname, shortpath (NULL, convert_filename), sys_errlist[errno]);
4167: return;
4168: }
4169: orig_size = stat_buf.st_size;
4170:
4171: /* Allocate a buffer to hold the original text. */
4172:
4173: orig_text_base = new_orig_text_base = (char *) xmalloc (orig_size + 2);
4174: orig_text_limit = new_orig_text_limit = new_orig_text_base + orig_size;
4175:
4176: /* Allocate a buffer to hold the cleaned-up version of the original text. */
4177:
4178: clean_text_base = new_clean_text_base = (char *) xmalloc (orig_size + 2);
4179: clean_text_limit = new_clean_text_limit = new_clean_text_base + orig_size;
4180: clean_read_ptr = clean_text_base - 1;
4181:
4182: /* Allocate a buffer that will hopefully be large enough to hold the entire
4183: converted output text. As an initial guess for the maximum size of the
4184: output buffer, use 125% of the size of the original + some extra. This
4185: buffer can be expanded later as needed. */
4186:
4187: repl_size = orig_size + (orig_size >> 2) + 4096;
4188: repl_text_base = (char *) xmalloc (repl_size + 2);
4189: repl_text_limit = repl_text_base + repl_size - 1;
4190: repl_write_ptr = repl_text_base - 1;
4191:
4192: {
4193: int input_file;
4194:
4195: /* Open the file to be converted in READ ONLY mode. */
4196:
4197: if ((input_file = my_open (convert_filename, O_RDONLY, 0444)) == -1)
4198: {
4199: fprintf (stderr, "%s: can't open file `%s' for reading: %s\n",
4200: pname, shortpath (NULL, convert_filename),
4201: sys_errlist[errno]);
4202: return;
4203: }
4204:
4205: /* Read the entire original source text file into the original text buffer
4206: in one swell fwoop. Then figure out where the end of the text is and
4207: make sure that it ends with a newline followed by a null. */
4208:
4209: if (safe_read (input_file, new_orig_text_base, orig_size) != orig_size)
4210: {
4211: close (input_file);
4212: fprintf (stderr, "\n%s: error reading input file `%s': %s\n",
4213: pname, shortpath (NULL, convert_filename),
4214: sys_errlist[errno]);
4215: return;
4216: }
4217:
4218: close (input_file);
4219: }
4220:
4221: if (orig_size == 0 || orig_text_limit[-1] != '\n')
4222: {
4223: *new_orig_text_limit++ = '\n';
4224: orig_text_limit++;
4225: }
4226:
4227: /* Create the cleaned up copy of the original text. */
4228:
4229: memcpy (new_clean_text_base, orig_text_base,
4230: (size_t) (orig_text_limit - orig_text_base));
4231: do_cleaning (new_clean_text_base, new_clean_text_limit);
4232:
4233: #if 0
4234: {
4235: int clean_file;
4236: size_t clean_size = orig_text_limit - orig_text_base;
4237: char *const clean_filename = (char *) alloca (strlen (convert_filename) + 6 + 1);
4238:
4239: /* Open (and create) the clean file. */
4240:
4241: strcpy (clean_filename, convert_filename);
4242: strcat (clean_filename, ".clean");
4243: if ((clean_file = creat (clean_filename, 0666)) == -1)
4244: {
4245: fprintf (stderr, "%s: can't create/open clean file `%s': %s\n",
4246: pname, shortpath (NULL, clean_filename),
4247: sys_errlist[errno]);
4248: return;
4249: }
4250:
4251: /* Write the clean file. */
4252:
4253: safe_write (clean_file, new_clean_text_base, clean_size, clean_filename);
4254:
4255: close (clean_file);
4256: }
4257: #endif /* 0 */
4258:
4259: /* Do a simplified scan of the input looking for things that were not
4260: mentioned in the aux info files because of the fact that they were
4261: in a region of the source which was preprocessed-out (via #if or
4262: via #ifdef). */
4263:
4264: scan_for_missed_items (file_p);
4265:
4266: /* Setup to do line-oriented forward seeking in the clean text buffer. */
4267:
4268: last_known_line_number = 1;
4269: last_known_line_start = clean_text_base;
4270:
4271: /* Now get down to business and make all of the necessary edits. */
4272:
4273: {
4274: const def_dec_info *def_dec_p;
4275:
4276: first_definition_in_file = 1;
4277: def_dec_p = file_p->defs_decs;
4278: for (; def_dec_p; def_dec_p = def_dec_p->next_in_file)
4279: {
4280: const char *clean_text_p = seek_to_line (def_dec_p->line);
4281:
4282: /* clean_text_p now points to the first character of the line which
4283: contains the `terminator' for the declaration or definition that
4284: we are about to process. */
4285:
4286: #ifndef UNPROTOIZE
4287:
4288: if (global_flag && def_dec_p->is_func_def && first_definition_in_file)
4289: {
4290: add_global_decls (def_dec_p->file, clean_text_p);
4291: first_definition_in_file = 0;
4292: }
4293:
4294: /* Don't edit this item if it is already in prototype format or if it
4295: is a function declaration and we have found no corresponding
4296: definition. */
4297:
4298: if (def_dec_p->prototyped
4299: || (!def_dec_p->is_func_def && !def_dec_p->definition))
4300: continue;
4301:
4302: #endif /* !defined (UNPROTOIZE) */
4303:
4304: if (def_dec_p->is_func_def)
4305: edit_fn_definition (def_dec_p, clean_text_p);
4306: else
4307: #ifndef UNPROTOIZE
4308: if (def_dec_p->is_implicit)
4309: add_local_decl (def_dec_p, clean_text_p);
4310: else
4311: #endif /* !defined (UNPROTOIZE) */
4312: edit_fn_declaration (def_dec_p, clean_text_p);
4313: }
4314: }
4315:
4316: /* Finalize things. Output the last trailing part of the original text. */
4317:
4318: output_up_to (clean_text_limit - 1);
4319:
4320: /* If this is just a test run, stop now and just deallocate the buffers. */
4321:
4322: if (nochange_flag)
4323: {
4324: free (new_orig_text_base);
4325: free (new_clean_text_base);
4326: free (repl_text_base);
4327: return;
4328: }
4329:
4330: /* Change the name of the original input file. This is just a quick way of
4331: saving the original file. */
4332:
4333: if (!nosave_flag)
4334: {
4335: char *new_filename =
4336: (char *) xmalloc (strlen (convert_filename) + strlen (save_suffix) + 2);
4337:
4338: strcpy (new_filename, convert_filename);
4339: strcat (new_filename, save_suffix);
4340: if (my_link (convert_filename, new_filename) == -1)
4341: {
4342: if (errno == EEXIST)
4343: {
4344: if (!quiet_flag)
4345: fprintf (stderr, "%s: warning: file `%s' already saved in `%s'\n",
4346: pname,
4347: shortpath (NULL, convert_filename),
4348: shortpath (NULL, new_filename));
4349: }
4350: else
4351: {
4352: fprintf (stderr, "%s: can't link file `%s' to `%s': %s\n",
4353: pname,
4354: shortpath (NULL, convert_filename),
4355: shortpath (NULL, new_filename),
4356: sys_errlist[errno]);
4357: return;
4358: }
4359: }
4360: }
4361:
4362: if (my_unlink (convert_filename) == -1)
4363: {
4364: fprintf (stderr, "%s: can't delete file `%s': %s\n",
4365: pname, shortpath (NULL, convert_filename), sys_errlist[errno]);
4366: return;
4367: }
4368:
4369: {
4370: int output_file;
4371:
4372: /* Open (and create) the output file. */
4373:
4374: if ((output_file = creat (convert_filename, 0666)) == -1)
4375: {
4376: fprintf (stderr, "%s: can't create/open output file `%s': %s\n",
4377: pname, shortpath (NULL, convert_filename),
4378: sys_errlist[errno]);
4379: return;
4380: }
4381:
4382: /* Write the output file. */
4383:
4384: {
4385: unsigned int out_size = (repl_write_ptr + 1) - repl_text_base;
4386:
4387: safe_write (output_file, repl_text_base, out_size, convert_filename);
4388: }
4389:
4390: close (output_file);
4391: }
4392:
4393: /* Deallocate the conversion buffers. */
4394:
4395: free (new_orig_text_base);
4396: free (new_clean_text_base);
4397: free (repl_text_base);
4398:
4399: /* Change the mode of the output file to match the original file. */
4400:
4401: /* The cast avoids an erroneous warning on AIX. */
4402: if (my_chmod ((char *)convert_filename, stat_buf.st_mode) == -1)
4403: fprintf (stderr, "%s: can't change mode of file `%s': %s\n",
4404: pname, shortpath (NULL, convert_filename), sys_errlist[errno]);
4405:
4406: /* Note: We would try to change the owner and group of the output file
4407: to match those of the input file here, except that may not be a good
4408: thing to do because it might be misleading. Also, it might not even
4409: be possible to do that (on BSD systems with quotas for instance). */
4410: }
4411:
4412: /* Do all of the individual steps needed to do the protoization (or
4413: unprotoization) of the files referenced in the aux_info files given
4414: in the command line. */
4415:
4416: static void
4417: do_processing ()
4418: {
4419: const char * const *base_pp;
4420: const char * const * const end_pps
4421: = &base_source_filenames[n_base_source_files];
4422:
4423: #ifndef UNPROTOIZE
4424: int syscalls_len;
4425: #endif /* !defined (UNPROTOIZE) */
4426:
4427: /* One-by-one, check (and create if necessary), open, and read all of the
4428: stuff in each aux_info file. After reading each aux_info file, the
4429: aux_info_file just read will be automatically deleted unless the
4430: keep_flag is set. */
4431:
4432: for (base_pp = base_source_filenames; base_pp < end_pps; base_pp++)
4433: process_aux_info_file (*base_pp, keep_flag, 0);
4434:
4435: #ifndef UNPROTOIZE
4436:
4437: /* Also open and read the special SYSCALLS.c aux_info file which gives us
4438: the prototypes for all of the standard system-supplied functions. */
4439:
4440: if (nondefault_syscalls_dir)
4441: {
4442: syscalls_absolute_filename
4443: = (char *) xmalloc (strlen (nondefault_syscalls_dir)
4444: + sizeof (syscalls_filename) + 1);
4445: strcpy (syscalls_absolute_filename, nondefault_syscalls_dir);
4446: }
4447: else
4448: {
4449: syscalls_absolute_filename
4450: = (char *) xmalloc (strlen (default_syscalls_dir)
4451: + sizeof (syscalls_filename) + 1);
4452: strcpy (syscalls_absolute_filename, default_syscalls_dir);
4453: }
4454:
4455: syscalls_len = strlen (syscalls_absolute_filename);
4456: if (*(syscalls_absolute_filename + syscalls_len - 1) != '/')
4457: {
4458: *(syscalls_absolute_filename + syscalls_len++) = '/';
4459: *(syscalls_absolute_filename + syscalls_len) = '\0';
4460: }
4461: strcat (syscalls_absolute_filename, syscalls_filename);
4462:
4463: /* Call process_aux_info_file in such a way that it does not try to
4464: delete the SYSCALLS aux_info file. */
4465:
4466: process_aux_info_file (syscalls_absolute_filename, 1, 1);
4467:
4468: #endif /* !defined (UNPROTOIZE) */
4469:
4470: /* When we first read in all of the information from the aux_info files
4471: we saved in it descending line number order, because that was likely to
4472: be faster. Now however, we want the chains of def & dec records to
4473: appear in ascending line number order as we get further away from the
4474: file_info record that they hang from. The following line causes all of
4475: these lists to be rearranged into ascending line number order. */
4476:
4477: visit_each_hash_node (filename_primary, reverse_def_dec_list);
4478:
4479: #ifndef UNPROTOIZE
4480:
4481: /* Now do the "real" work. The following line causes each declaration record
4482: to be "visited". For each of these nodes, an attempt is made to match
4483: up the function declaration with a corresponding function definition,
4484: which should have a full prototype-format formals list with it. Once
4485: these match-ups are made, the conversion of the function declarations
4486: to prototype format can be made. */
4487:
4488: visit_each_hash_node (function_name_primary, connect_defs_and_decs);
4489:
4490: #endif /* !defined (UNPROTOIZE) */
4491:
4492: /* Now convert each file that can be converted (and needs to be). */
4493:
4494: visit_each_hash_node (filename_primary, edit_file);
4495:
4496: #ifndef UNPROTOIZE
4497:
4498: /* If we are working in cplusplus mode, try to rename all .c files to .C
4499: files. Don't panic if some of the renames don't work. */
4500:
4501: if (cplusplus_flag && !nochange_flag)
4502: visit_each_hash_node (filename_primary, rename_c_file);
4503:
4504: #endif /* !defined (UNPROTOIZE) */
4505: }
4506:
4507: static struct option longopts[] =
4508: {
4509: {"version", 0, 0, 'V'},
4510: {"file_name", 0, 0, 'p'},
4511: {"quiet", 0, 0, 'q'},
4512: {"silent", 0, 0, 'q'},
4513: {"force", 0, 0, 'f'},
4514: {"keep", 0, 0, 'k'},
4515: {"nosave", 0, 0, 'N'},
4516: {"nochange", 0, 0, 'n'},
4517: {"compiler-options", 1, 0, 'c'},
4518: {"exclude", 1, 0, 'x'},
4519: {"directory", 1, 0, 'd'},
4520: #ifdef UNPROTOIZE
4521: {"indent", 1, 0, 'i'},
4522: #else
4523: {"local", 0, 0, 'l'},
4524: {"global", 0, 0, 'g'},
4525: {"c++", 0, 0, 'C'},
4526: {"syscalls-dir", 1, 0, 'B'},
4527: #endif
4528: {0, 0, 0, 0}
4529: };
4530:
4531: int
4532: main (argc, argv)
4533: int argc;
4534: char **const argv;
4535: {
4536: int longind;
4537: int c;
4538: const char *params = "";
4539:
4540: pname = rindex (argv[0], '/');
4541: pname = pname ? pname+1 : argv[0];
4542:
4543: cwd_buffer = getpwd ();
4544: if (!cwd_buffer)
4545: {
4546: fprintf (stderr, "%s: cannot get working directory: %s\n",
4547: pname, sys_errlist[errno]);
4548: exit (1);
4549: }
4550:
4551: /* By default, convert the files in the current directory. */
4552: directory_list = string_list_cons (cwd_buffer, NULL);
4553:
4554: while ((c = getopt_long (argc, argv,
4555: #ifdef UNPROTOIZE
4556: "c:d:i:knNp:qvVx:",
4557: #else
4558: "B:c:Cd:gklnNp:qvVx:",
4559: #endif
4560: longopts, &longind)) != EOF)
4561: {
4562: if (c == 0) /* Long option. */
4563: c = longopts[longind].val;
4564: switch (c)
4565: {
4566: case 'p':
4567: compiler_file_name = optarg;
4568: break;
4569: case 'd':
4570: directory_list
4571: = string_list_cons (abspath (NULL, optarg), directory_list);
4572: break;
4573: case 'x':
4574: exclude_list = string_list_cons (optarg, exclude_list);
4575: break;
4576:
4577: case 'v':
4578: case 'V':
4579: version_flag = 1;
4580: break;
4581: case 'q':
4582: quiet_flag = 1;
4583: break;
4584: #if 0
4585: case 'f':
4586: force_flag = 1;
4587: break;
4588: #endif
4589: case 'n':
4590: nochange_flag = 1;
4591: keep_flag = 1;
4592: break;
4593: case 'N':
4594: nosave_flag = 1;
4595: break;
4596: case 'k':
4597: keep_flag = 1;
4598: break;
4599: case 'c':
4600: params = optarg;
4601: break;
4602: #ifdef UNPROTOIZE
4603: case 'i':
4604: indent_string = optarg;
4605: break;
4606: #else /* !defined (UNPROTOIZE) */
4607: case 'l':
4608: local_flag = 1;
4609: break;
4610: case 'g':
4611: global_flag = 1;
4612: break;
4613: case 'C':
4614: cplusplus_flag = 1;
4615: break;
4616: case 'B':
4617: nondefault_syscalls_dir = optarg;
4618: break;
4619: #endif /* !defined (UNPROTOIZE) */
4620: default:
4621: usage ();
4622: }
4623: }
4624:
4625: /* Set up compile_params based on -p and -c options. */
4626: munge_compile_params (params);
4627:
4628: n_base_source_files = argc - optind;
4629:
4630: /* Now actually make a list of the base source filenames. */
4631:
4632: base_source_filenames =
4633: (const char **) xmalloc ((n_base_source_files + 1) * sizeof (char *));
4634: n_base_source_files = 0;
4635: for (; optind < argc; optind++)
4636: {
4637: const char *path = abspath (NULL, argv[optind]);
4638: int len = strlen (path);
4639:
4640: if (path[len-1] == 'c' && path[len-2] == '.')
4641: base_source_filenames[n_base_source_files++] = path;
4642: else
4643: {
4644: fprintf (stderr, "%s: input file names must have .c suffixes: %s\n",
4645: pname, shortpath (NULL, path));
4646: errors++;
4647: }
4648: }
4649:
4650: #ifndef UNPROTOIZE
4651: /* We are only interested in the very first identifier token in the
4652: definition of `va_list', so if there is more junk after that first
4653: identifier token, delete it from the `varargs_style_indicator'. */
4654: {
4655: const char *cp;
4656:
4657: for (cp = varargs_style_indicator; isalnum (*cp) || *cp == '_'; cp++)
4658: continue;
4659: if (*cp != 0)
4660: varargs_style_indicator = savestring (varargs_style_indicator,
4661: cp - varargs_style_indicator);
4662: }
4663: #endif /* !defined (UNPROTOIZE) */
4664:
4665: if (errors)
4666: usage ();
4667: else
4668: {
4669: if (version_flag)
4670: fprintf (stderr, "%s: %s\n", pname, version_string);
4671: do_processing ();
4672: }
4673: if (errors)
4674: exit (1);
4675: else
4676: exit (0);
4677: return 1;
4678: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.