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