![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cccp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to cccp.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 ! root 1: /* C Compatible Compiler Preprocessor (CCCP) ! 2: Copyright (C) 1986, 1987, 1989, 1992, 1993 Free Software Foundation, Inc. ! 3: Written by Paul Rubin, June 1986 ! 4: Adapted to ANSI C, Richard Stallman, Jan 1987 ! 5: ! 6: This program is free software; you can redistribute it and/or modify it ! 7: under the terms of the GNU General Public License as published by the ! 8: Free Software Foundation; either version 2, or (at your option) any ! 9: later version. ! 10: ! 11: This program is distributed in the hope that it will be useful, ! 12: but WITHOUT ANY WARRANTY; without even the implied warranty of ! 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 14: GNU General Public License for more details. ! 15: ! 16: You should have received a copy of the GNU General Public License ! 17: along with this program; if not, write to the Free Software ! 18: Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. ! 19: ! 20: In other words, you are welcome to use, share and improve this program. ! 21: You are forbidden to forbid anyone else to use, share and improve ! 22: what you give them. Help stamp out software-hoarding! */ ! 23: ! 24: typedef unsigned char U_CHAR; ! 25: ! 26: #ifdef EMACS ! 27: #define NO_SHORTNAMES ! 28: #include "../src/config.h" ! 29: #ifdef open ! 30: #undef open ! 31: #undef read ! 32: #undef write ! 33: #endif /* open */ ! 34: #endif /* EMACS */ ! 35: ! 36: /* The macro EMACS is defined when cpp is distributed as part of Emacs, ! 37: for the sake of machines with limited C compilers. */ ! 38: #ifndef EMACS ! 39: #include "config.h" ! 40: #endif /* not EMACS */ ! 41: ! 42: #ifndef STANDARD_INCLUDE_DIR ! 43: #define STANDARD_INCLUDE_DIR "/usr/include" ! 44: #endif ! 45: ! 46: #ifndef LOCAL_INCLUDE_DIR ! 47: #define LOCAL_INCLUDE_DIR "/usr/local/include" ! 48: #endif ! 49: ! 50: #if 0 /* We can't get ptrdiff_t, so I arranged not to need PTR_INT_TYPE. */ ! 51: #ifdef __STDC__ ! 52: #define PTR_INT_TYPE ptrdiff_t ! 53: #else ! 54: #define PTR_INT_TYPE long ! 55: #endif ! 56: #endif /* 0 */ ! 57: ! 58: #include "pcp.h" ! 59: ! 60: #ifndef STDC_VALUE ! 61: #define STDC_VALUE 1 ! 62: #endif ! 63: ! 64: /* By default, colon separates directories in a path. */ ! 65: #ifndef PATH_SEPARATOR ! 66: #define PATH_SEPARATOR ':' ! 67: #endif ! 68: ! 69: /* In case config.h defines these. */ ! 70: #undef bcopy ! 71: #undef bzero ! 72: #undef bcmp ! 73: ! 74: #include <sys/types.h> ! 75: #include <sys/stat.h> ! 76: #include <ctype.h> ! 77: #include <stdio.h> ! 78: #include <signal.h> ! 79: ! 80: #ifndef VMS ! 81: #ifndef USG ! 82: #include <sys/time.h> /* for __DATE__ and __TIME__ */ ! 83: #include <sys/resource.h> ! 84: #else ! 85: #include <time.h> ! 86: #include <fcntl.h> ! 87: #endif /* USG */ ! 88: #endif /* not VMS */ ! 89: ! 90: /* This defines "errno" properly for VMS, and gives us EACCES. */ ! 91: #include <errno.h> ! 92: ! 93: /* VMS-specific definitions */ ! 94: #ifdef VMS ! 95: #include <time.h> ! 96: #include <perror.h> /* This defines sys_errlist/sys_nerr properly */ ! 97: #include <descrip.h> ! 98: #define O_RDONLY 0 /* Open arg for Read/Only */ ! 99: #define O_WRONLY 1 /* Open arg for Write/Only */ ! 100: #define read(fd,buf,size) VMS_read (fd,buf,size) ! 101: #define write(fd,buf,size) VMS_write (fd,buf,size) ! 102: #define open(fname,mode,prot) VMS_open (fname,mode,prot) ! 103: #define fopen(fname,mode) VMS_fopen (fname,mode) ! 104: #define freopen(fname,mode,ofile) VMS_freopen (fname,mode,ofile) ! 105: #define strncat(dst,src,cnt) VMS_strncat (dst,src,cnt) ! 106: static char * VMS_strncat (); ! 107: static int VMS_read (); ! 108: static int VMS_write (); ! 109: static int VMS_open (); ! 110: static FILE * VMS_fopen (); ! 111: static FILE * VMS_freopen (); ! 112: static void hack_vms_include_specification (); ! 113: typedef struct { unsigned :16, :16, :16; } vms_ino_t; ! 114: #define ino_t vms_ino_t ! 115: #define INCLUDE_LEN_FUDGE 10 /* leave room for VMS syntax conversion */ ! 116: #ifdef __GNUC__ ! 117: #define BSTRING /* VMS/GCC supplies the bstring routines */ ! 118: #endif /* __GNUC__ */ ! 119: #endif /* VMS */ ! 120: ! 121: extern char *index (); ! 122: extern char *rindex (); ! 123: ! 124: #ifndef O_RDONLY ! 125: #define O_RDONLY 0 ! 126: #endif ! 127: ! 128: #undef MIN ! 129: #undef MAX ! 130: #define MIN(X,Y) ((X) < (Y) ? (X) : (Y)) ! 131: #define MAX(X,Y) ((X) > (Y) ? (X) : (Y)) ! 132: ! 133: /* Find the largest host integer type and set its size and type. */ ! 134: ! 135: #ifndef HOST_BITS_PER_WIDE_INT ! 136: ! 137: #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT ! 138: #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG ! 139: #define HOST_WIDE_INT long ! 140: #else ! 141: #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT ! 142: #define HOST_WIDE_INT int ! 143: #endif ! 144: ! 145: #endif ! 146: ! 147: #ifndef S_ISREG ! 148: #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG) ! 149: #endif ! 150: ! 151: #ifndef S_ISDIR ! 152: #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR) ! 153: #endif ! 154: ! 155: /* Define a generic NULL if one hasn't already been defined. */ ! 156: ! 157: #ifndef NULL ! 158: #define NULL 0 ! 159: #endif ! 160: ! 161: #ifndef GENERIC_PTR ! 162: #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__) ! 163: #define GENERIC_PTR void * ! 164: #else ! 165: #define GENERIC_PTR char * ! 166: #endif ! 167: #endif ! 168: ! 169: #ifndef NULL_PTR ! 170: #define NULL_PTR ((GENERIC_PTR)0) ! 171: #endif ! 172: ! 173: #ifndef INCLUDE_LEN_FUDGE ! 174: #define INCLUDE_LEN_FUDGE 0 ! 175: #endif ! 176: ! 177: /* Forward declarations. */ ! 178: ! 179: char *xmalloc (); ! 180: void error (); ! 181: void warning (); ! 182: ! 183: /* External declarations. */ ! 184: ! 185: extern char *getenv (); ! 186: extern FILE *fdopen (); ! 187: extern char *version_string; ! 188: extern struct tm *localtime (); ! 189: extern int sys_nerr; ! 190: #if defined(bsd4_4) ! 191: extern const char *const sys_errlist[]; ! 192: #else ! 193: extern char *sys_errlist[]; ! 194: #endif ! 195: extern int parse_escape (); ! 196: ! 197: #ifndef errno ! 198: extern int errno; ! 199: #endif ! 200: ! 201: /* Forward declarations. */ ! 202: ! 203: struct directive; ! 204: struct file_buf; ! 205: struct arglist; ! 206: struct argdata; ! 207: ! 208: #if defined(USG) || defined(VMS) ! 209: #ifndef BSTRING ! 210: void bcopy (); ! 211: void bzero (); ! 212: int bcmp (); ! 213: #endif ! 214: #endif ! 215: ! 216: /* These functions are declared to return int instead of void since they ! 217: are going to be placed in a table and some old compilers have trouble with ! 218: pointers to functions returning void. */ ! 219: ! 220: static int do_define (); ! 221: static int do_line (); ! 222: static int do_include (); ! 223: static int do_undef (); ! 224: static int do_error (); ! 225: static int do_pragma (); ! 226: static int do_ident (); ! 227: static int do_if (); ! 228: static int do_xifdef (); ! 229: static int do_else (); ! 230: static int do_elif (); ! 231: static int do_endif (); ! 232: static int do_sccs (); ! 233: static int do_once (); ! 234: static int do_assert (); ! 235: static int do_unassert (); ! 236: static int do_warning (); ! 237: ! 238: static void add_import (); ! 239: static void append_include_chain (); ! 240: static void deps_output (); ! 241: static void make_undef (); ! 242: static void make_definition (); ! 243: static void make_assertion (); ! 244: static void path_include (); ! 245: static void initialize_builtins (); ! 246: static void initialize_char_syntax (); ! 247: static void dump_arg_n (); ! 248: static void dump_defn_1 (); ! 249: static void delete_macro (); ! 250: static void trigraph_pcp (); ! 251: static void rescan (); ! 252: static void finclude (); ! 253: static void validate_else (); ! 254: static int comp_def_part (); ! 255: static void error_from_errno (); ! 256: static void error_with_line (); ! 257: void pedwarn (); ! 258: void pedwarn_with_line (); ! 259: static void pedwarn_with_file_and_line (); ! 260: static void fatal (); ! 261: void fancy_abort (); ! 262: static void pfatal_with_name (); ! 263: static void perror_with_name (); ! 264: static void pipe_closed (); ! 265: static void print_containing_files (); ! 266: static int lookup_import (); ! 267: static int redundant_include_p (); ! 268: static is_system_include (); ! 269: static int check_preconditions (); ! 270: static void pcfinclude (); ! 271: static void pcstring_used (); ! 272: static void write_output (); ! 273: static int check_macro_name (); ! 274: static int compare_defs (); ! 275: static int compare_token_lists (); ! 276: static int eval_if_expression (); ! 277: static int discard_comments (); ! 278: static int change_newlines (); ! 279: static int line_for_error (); ! 280: static int hashf (); ! 281: static int file_size_and_mode (); ! 282: ! 283: static struct arglist *read_token_list (); ! 284: static void free_token_list (); ! 285: ! 286: static struct hashnode *install (); ! 287: struct hashnode *lookup (); ! 288: ! 289: static struct assertion_hashnode *assertion_install (); ! 290: static struct assertion_hashnode *assertion_lookup (); ! 291: ! 292: static char *xrealloc (); ! 293: static char *xcalloc (); ! 294: static char *savestring (); ! 295: ! 296: static void delete_assertion (); ! 297: static void macroexpand (); ! 298: static void dump_all_macros (); ! 299: static void conditional_skip (); ! 300: static void skip_if_group (); ! 301: static void output_line_command (); ! 302: ! 303: #ifdef NEXT_SEMANTICS ! 304: /* convert rtf */ ! 305: static void buf_convert_rtf (); ! 306: static const char * rtf_to_ascii (); ! 307: #endif ! 308: ! 309: /* Last arg to output_line_command. */ ! 310: enum file_change_code {same_file, enter_file, leave_file}; ! 311: ! 312: static int grow_outbuf (); ! 313: static int handle_directive (); ! 314: static void memory_full (); ! 315: ! 316: static U_CHAR *macarg1 (); ! 317: static char *macarg (); ! 318: ! 319: static U_CHAR *skip_to_end_of_comment (); ! 320: static U_CHAR *skip_quoted_string (); ! 321: static U_CHAR *skip_paren_group (); ! 322: static char *quote_string (); ! 323: ! 324: static char *check_precompiled (); ! 325: /* static struct macrodef create_definition (); [moved below] */ ! 326: static void dump_single_macro (); ! 327: static void output_dots (); ! 328: ! 329: #ifndef FAILURE_EXIT_CODE ! 330: #define FAILURE_EXIT_CODE 33 /* gnu cc command understands this */ ! 331: #endif ! 332: ! 333: #ifndef SUCCESS_EXIT_CODE ! 334: #define SUCCESS_EXIT_CODE 0 /* 0 means success on Unix. */ ! 335: #endif ! 336: ! 337: /* Name under which this program was invoked. */ ! 338: ! 339: static char *progname; ! 340: ! 341: /* Nonzero means use extra default include directories for C++. */ ! 342: ! 343: static int cplusplus; ! 344: ! 345: /* Nonzero means handle cplusplus style comments */ ! 346: ! 347: static int cplusplus_comments; ! 348: ! 349: /* Nonzero means handle #import, for objective C. */ ! 350: ! 351: static int objc; ! 352: ! 353: /* Nonzero means this is an assembly file, and allow ! 354: unknown directives, which could be comments. */ ! 355: ! 356: static int lang_asm; ! 357: ! 358: /* Current maximum length of directory names in the search path ! 359: for include files. (Altered as we get more of them.) */ ! 360: ! 361: static int max_include_len; ! 362: ! 363: /* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */ ! 364: ! 365: static int lint = 0; ! 366: ! 367: /* Nonzero means copy comments into the output file. */ ! 368: ! 369: static int put_out_comments = 0; ! 370: ! 371: /* Nonzero means don't process the ANSI trigraph sequences. */ ! 372: ! 373: static int no_trigraphs = 0; ! 374: ! 375: /* Nonzero means print the names of included files rather than ! 376: the preprocessed output. 1 means just the #include "...", ! 377: 2 means #include <...> as well. */ ! 378: ! 379: static int print_deps = 0; ! 380: ! 381: /* Nonzero means print names of header files (-H). */ ! 382: ! 383: static int print_include_names = 0; ! 384: ! 385: /* Nonzero means don't output line number information. */ ! 386: ! 387: static int no_line_commands; ! 388: ! 389: /* dump_only means inhibit output of the preprocessed text ! 390: and instead output the definitions of all user-defined ! 391: macros in a form suitable for use as input to cccp. ! 392: dump_names means pass #define and the macro name through to output. ! 393: dump_definitions means pass the whole definition (plus #define) through ! 394: */ ! 395: ! 396: static enum {dump_none, dump_only, dump_names, dump_definitions} ! 397: dump_macros = dump_none; ! 398: ! 399: /* Nonzero means pass all #define and #undef directives which we actually ! 400: process through to the output stream. This feature is used primarily ! 401: to allow cc1 to record the #defines and #undefs for the sake of ! 402: debuggers which understand about preprocessor macros, but it may ! 403: also be useful with -E to figure out how symbols are defined, and ! 404: where they are defined. */ ! 405: static int debug_output = 0; ! 406: ! 407: /* Nonzero indicates special processing used by the pcp program. The ! 408: special effects of this mode are: ! 409: ! 410: Inhibit all macro expansion, except those inside #if directives. ! 411: ! 412: Process #define directives normally, and output their contents ! 413: to the output file. ! 414: ! 415: Output preconditions to pcp_outfile indicating all the relevant ! 416: preconditions for use of this file in a later cpp run. ! 417: */ ! 418: static FILE *pcp_outfile; ! 419: ! 420: /* Nonzero means we are inside an IF during a -pcp run. In this mode ! 421: macro expansion is done, and preconditions are output for all macro ! 422: uses requiring them. */ ! 423: static int pcp_inside_if; ! 424: ! 425: /* Nonzero means never to include precompiled files. ! 426: This is 1 since there's no way now to make precompiled files, ! 427: so it's not worth testing for them. */ ! 428: static int no_precomp = 1; ! 429: ! 430: /* Nonzero means give all the error messages the ANSI standard requires. */ ! 431: ! 432: int pedantic; ! 433: ! 434: /* Nonzero means try to make failure to fit ANSI C an error. */ ! 435: ! 436: static int pedantic_errors; ! 437: ! 438: /* Nonzero means don't print warning messages. -w. */ ! 439: ! 440: static int inhibit_warnings = 0; ! 441: ! 442: /* Nonzero means warn if slash-star appears in a comment. */ ! 443: ! 444: static int warn_comments; ! 445: ! 446: /* Nonzero means warn if a macro argument is (or would be) ! 447: stringified with -traditional. */ ! 448: ! 449: static int warn_stringify; ! 450: ! 451: /* Nonzero means warn if there are any trigraphs. */ ! 452: ! 453: static int warn_trigraphs; ! 454: ! 455: /* Nonzero means warn if #import is used. */ ! 456: ! 457: #ifdef NEXT_OBJC_RUNTIME ! 458: static int warn_import = 0; ! 459: #else ! 460: static int warn_import = 1; ! 461: #endif ! 462: ! 463: /* Nonzero means turn warnings into errors. */ ! 464: ! 465: static int warnings_are_errors; ! 466: ! 467: /* Nonzero means try to imitate old fashioned non-ANSI preprocessor. */ ! 468: ! 469: int traditional; ! 470: ! 471: /* Nonzero causes output not to be done, ! 472: but directives such as #define that have side effects ! 473: are still obeyed. */ ! 474: ! 475: static int no_output; ! 476: ! 477: #ifdef NEXT_SEMANTICS ! 478: /* Nonzero causes input not to have rtf codes stripped before ! 479: further processing. */ ! 480: ! 481: static int no_rtf = 0; ! 482: #endif ! 483: ! 484: /* Nonzero means that we have finished processing the command line options. ! 485: This flag is used to decide whether or not to issue certain errors ! 486: and/or warnings. */ ! 487: ! 488: static int done_initializing = 0; ! 489: ! 490: /* Line where a newline was first seen in a string constant. */ ! 491: ! 492: static int multiline_string_line = 0; ! 493: ! 494: /* I/O buffer structure. ! 495: The `fname' field is nonzero for source files and #include files ! 496: and for the dummy text used for -D and -U. ! 497: It is zero for rescanning results of macro expansion ! 498: and for expanding macro arguments. */ ! 499: #define INPUT_STACK_MAX 400 ! 500: static struct file_buf { ! 501: char *fname; ! 502: /* Filename specified with #line command. */ ! 503: char *nominal_fname; ! 504: /* Record where in the search path this file was found. ! 505: For #include_next. */ ! 506: struct file_name_list *dir; ! 507: int lineno; ! 508: int length; ! 509: U_CHAR *buf; ! 510: U_CHAR *bufp; ! 511: /* Macro that this level is the expansion of. ! 512: Included so that we can reenable the macro ! 513: at the end of this level. */ ! 514: struct hashnode *macro; ! 515: /* Value of if_stack at start of this file. ! 516: Used to prohibit unmatched #endif (etc) in an include file. */ ! 517: struct if_stack *if_stack; ! 518: /* Object to be freed at end of input at this level. */ ! 519: U_CHAR *free_ptr; ! 520: /* True if this is a header file included using <FILENAME>. */ ! 521: char system_header_p; ! 522: } instack[INPUT_STACK_MAX]; ! 523: ! 524: static int last_error_tick; /* Incremented each time we print it. */ ! 525: static int input_file_stack_tick; /* Incremented when the status changes. */ ! 526: ! 527: /* Current nesting level of input sources. ! 528: `instack[indepth]' is the level currently being read. */ ! 529: static int indepth = -1; ! 530: #define CHECK_DEPTH(code) \ ! 531: if (indepth >= (INPUT_STACK_MAX - 1)) \ ! 532: { \ ! 533: error_with_line (line_for_error (instack[indepth].lineno), \ ! 534: "macro or `#include' recursion too deep"); \ ! 535: code; \ ! 536: } ! 537: ! 538: /* Current depth in #include directives that use <...>. */ ! 539: static int system_include_depth = 0; ! 540: ! 541: typedef struct file_buf FILE_BUF; ! 542: ! 543: /* The output buffer. Its LENGTH field is the amount of room allocated ! 544: for the buffer, not the number of chars actually present. To get ! 545: that, subtract outbuf.buf from outbuf.bufp. */ ! 546: ! 547: #define OUTBUF_SIZE 10 /* initial size of output buffer */ ! 548: static FILE_BUF outbuf; ! 549: ! 550: /* Grow output buffer OBUF points at ! 551: so it can hold at least NEEDED more chars. */ ! 552: ! 553: #define check_expand(OBUF, NEEDED) \ ! 554: (((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED)) \ ! 555: ? grow_outbuf ((OBUF), (NEEDED)) : 0) ! 556: ! 557: struct file_name_list ! 558: { ! 559: struct file_name_list *next; ! 560: char *fname; ! 561: /* If the following is nonzero, it is a macro name. ! 562: Don't include the file again if that macro is defined. */ ! 563: U_CHAR *control_macro; ! 564: /* If the following is nonzero, it is a C-language system include ! 565: directory. */ ! 566: int c_system_include_path; ! 567: }; ! 568: ! 569: /* #include "file" looks in source file dir, then stack. */ ! 570: /* #include <file> just looks in the stack. */ ! 571: /* cplusplus = 0 -> C. cplusplus = 1 -> C++. cplusplus = 2 -> nothing */ ! 572: /* -I directories are added to the end, then the defaults are added. */ ! 573: static struct default_include { char *fname; int cplusplus; } include_defaults_array[] ! 574: #ifdef INCLUDE_DEFAULTS ! 575: = INCLUDE_DEFAULTS; ! 576: #else ! 577: = { ! 578: /* Pick up GNU C++ specific include files. */ ! 579: { GPLUSPLUS_INCLUDE_DIR, 1}, ! 580: #ifdef CROSS_COMPILE ! 581: /* This is the dir for fixincludes. Put it just before ! 582: the files that we fix. */ ! 583: { GCC_INCLUDE_DIR, 0}, ! 584: /* For cross-compilation, this dir name is generated ! 585: automatically in Makefile.in. */ ! 586: { CROSS_INCLUDE_DIR, 0 }, ! 587: /* This is another place that the target system's headers might be. */ ! 588: { TOOL_INCLUDE_DIR, 0}, ! 589: #else /* not CROSS_COMPILE */ ! 590: /* This should be /use/local/include and should come before ! 591: the fixincludes-fixed header files. */ ! 592: { LOCAL_INCLUDE_DIR, 0}, ! 593: /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here. ! 594: Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h. */ ! 595: { TOOL_INCLUDE_DIR, 0}, ! 596: /* This is the dir for fixincludes. Put it just before ! 597: the files that we fix. */ ! 598: { GCC_INCLUDE_DIR, 0}, ! 599: /* Some systems have an extra dir of include files. */ ! 600: #ifdef SYSTEM_INCLUDE_DIR ! 601: { SYSTEM_INCLUDE_DIR, 0}, ! 602: #endif ! 603: { STANDARD_INCLUDE_DIR, 0}, ! 604: #endif /* not CROSS_COMPILE */ ! 605: { 0, 0} ! 606: }; ! 607: #endif /* no INCLUDE_DEFAULTS */ ! 608: ! 609: /* The code looks at the defaults through this pointer, rather than through ! 610: the constant structure above. This pointer gets changed if an environment ! 611: variable specifies other defaults. */ ! 612: static struct default_include *include_defaults = include_defaults_array; ! 613: ! 614: static struct file_name_list *include = 0; /* First dir to search */ ! 615: /* First dir to search for <file> */ ! 616: /* This is the first element to use for #include <...>. ! 617: If it is 0, use the entire chain for such includes. */ ! 618: static struct file_name_list *first_bracket_include = 0; ! 619: /* This is the first element in the chain that corresponds to ! 620: a directory of system header files. */ ! 621: static struct file_name_list *first_system_include = 0; ! 622: static struct file_name_list *last_include = 0; /* Last in chain */ ! 623: ! 624: /* Chain of include directories to put at the end of the other chain. */ ! 625: static struct file_name_list *after_include = 0; ! 626: static struct file_name_list *last_after_include = 0; /* Last in chain */ ! 627: ! 628: /* List of included files that contained #pragma once. */ ! 629: static struct file_name_list *dont_repeat_files = 0; ! 630: ! 631: /* List of other included files. ! 632: If ->control_macro if nonzero, the file had a #ifndef ! 633: around the entire contents, and ->control_macro gives the macro name. */ ! 634: static struct file_name_list *all_include_files = 0; ! 635: ! 636: /* Directory prefix that should replace `/usr' in the standard ! 637: include file directories. */ ! 638: static char *include_prefix; ! 639: ! 640: /* Global list of strings read in from precompiled files. This list ! 641: is kept in the order the strings are read in, with new strings being ! 642: added at the end through stringlist_tailp. We use this list to output ! 643: the strings at the end of the run. ! 644: */ ! 645: static STRINGDEF *stringlist; ! 646: static STRINGDEF **stringlist_tailp = &stringlist; ! 647: ! 648: ! 649: /* Structure returned by create_definition */ ! 650: typedef struct macrodef MACRODEF; ! 651: struct macrodef ! 652: { ! 653: struct definition *defn; ! 654: U_CHAR *symnam; ! 655: int symlen; ! 656: }; ! 657: ! 658: static struct macrodef create_definition (); ! 659: ! 660: ! 661: /* Structure allocated for every #define. For a simple replacement ! 662: such as ! 663: #define foo bar , ! 664: nargs = -1, the `pattern' list is null, and the expansion is just ! 665: the replacement text. Nargs = 0 means a functionlike macro with no args, ! 666: e.g., ! 667: #define getchar() getc (stdin) . ! 668: When there are args, the expansion is the replacement text with the ! 669: args squashed out, and the reflist is a list describing how to ! 670: build the output from the input: e.g., "3 chars, then the 1st arg, ! 671: then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg". ! 672: The chars here come from the expansion. Whatever is left of the ! 673: expansion after the last arg-occurrence is copied after that arg. ! 674: Note that the reflist can be arbitrarily long--- ! 675: its length depends on the number of times the arguments appear in ! 676: the replacement text, not how many args there are. Example: ! 677: #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and ! 678: pattern list ! 679: { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL } ! 680: where (x, y) means (nchars, argno). */ ! 681: ! 682: typedef struct definition DEFINITION; ! 683: struct definition { ! 684: int nargs; ! 685: int length; /* length of expansion string */ ! 686: int predefined; /* True if the macro was builtin or */ ! 687: /* came from the command line */ ! 688: U_CHAR *expansion; ! 689: int line; /* Line number of definition */ ! 690: char *file; /* File of definition */ ! 691: char rest_args; /* Nonzero if last arg. absorbs the rest */ ! 692: struct reflist { ! 693: struct reflist *next; ! 694: char stringify; /* nonzero if this arg was preceded by a ! 695: # operator. */ ! 696: char raw_before; /* Nonzero if a ## operator before arg. */ ! 697: char raw_after; /* Nonzero if a ## operator after arg. */ ! 698: char rest_args; /* Nonzero if this arg. absorbs the rest */ ! 699: int nchars; /* Number of literal chars to copy before ! 700: this arg occurrence. */ ! 701: int argno; /* Number of arg to substitute (origin-0) */ ! 702: } *pattern; ! 703: union { ! 704: /* Names of macro args, concatenated in reverse order ! 705: with comma-space between them. ! 706: The only use of this is that we warn on redefinition ! 707: if this differs between the old and new definitions. */ ! 708: U_CHAR *argnames; ! 709: } args; ! 710: }; ! 711: ! 712: /* different kinds of things that can appear in the value field ! 713: of a hash node. Actually, this may be useless now. */ ! 714: union hashval { ! 715: int ival; ! 716: char *cpval; ! 717: DEFINITION *defn; ! 718: KEYDEF *keydef; ! 719: }; ! 720: ! 721: /* ! 722: * special extension string that can be added to the last macro argument to ! 723: * allow it to absorb the "rest" of the arguments when expanded. Ex: ! 724: * #define wow(a, b...) process (b, a, b) ! 725: * { wow (1, 2, 3); } -> { process (2, 3, 1, 2, 3); } ! 726: * { wow (one, two); } -> { process (two, one, two); } ! 727: * if this "rest_arg" is used with the concat token '##' and if it is not ! 728: * supplied then the token attached to with ## will not be outputted. Ex: ! 729: * #define wow (a, b...) process (b ## , a, ## b) ! 730: * { wow (1, 2); } -> { process (2, 1, 2); } ! 731: * { wow (one); } -> { process (one); { ! 732: */ ! 733: static char rest_extension[] = "..."; ! 734: #define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1) ! 735: ! 736: /* The structure of a node in the hash table. The hash table ! 737: has entries for all tokens defined by #define commands (type T_MACRO), ! 738: plus some special tokens like __LINE__ (these each have their own ! 739: type, and the appropriate code is run when that type of node is seen. ! 740: It does not contain control words like "#define", which are recognized ! 741: by a separate piece of code. */ ! 742: ! 743: /* different flavors of hash nodes --- also used in keyword table */ ! 744: enum node_type { ! 745: T_DEFINE = 1, /* the `#define' keyword */ ! 746: T_INCLUDE, /* the `#include' keyword */ ! 747: T_INCLUDE_NEXT, /* the `#include_next' keyword */ ! 748: T_IMPORT, /* the `#import' keyword */ ! 749: T_IFDEF, /* the `#ifdef' keyword */ ! 750: T_IFNDEF, /* the `#ifndef' keyword */ ! 751: T_IF, /* the `#if' keyword */ ! 752: T_ELSE, /* `#else' */ ! 753: T_PRAGMA, /* `#pragma' */ ! 754: T_ELIF, /* `#elif' */ ! 755: T_UNDEF, /* `#undef' */ ! 756: T_LINE, /* `#line' */ ! 757: T_ERROR, /* `#error' */ ! 758: T_WARNING, /* `#warning' */ ! 759: T_ENDIF, /* `#endif' */ ! 760: T_SCCS, /* `#sccs', used on system V. */ ! 761: T_IDENT, /* `#ident', used on system V. */ ! 762: T_ASSERT, /* `#assert', taken from system V. */ ! 763: T_UNASSERT, /* `#unassert', taken from system V. */ ! 764: T_SPECLINE, /* special symbol `__LINE__' */ ! 765: T_DATE, /* `__DATE__' */ ! 766: T_FILE, /* `__FILE__' */ ! 767: T_BASE_FILE, /* `__BASE_FILE__' */ ! 768: T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */ ! 769: T_VERSION, /* `__VERSION__' */ ! 770: T_SIZE_TYPE, /* `__SIZE_TYPE__' */ ! 771: T_PTRDIFF_TYPE, /* `__PTRDIFF_TYPE__' */ ! 772: T_WCHAR_TYPE, /* `__WCHAR_TYPE__' */ ! 773: T_USER_LABEL_PREFIX_TYPE, /* `__USER_LABEL_PREFIX__' */ ! 774: T_REGISTER_PREFIX_TYPE, /* `__REGISTER_PREFIX__' */ ! 775: T_TIME, /* `__TIME__' */ ! 776: T_CONST, /* Constant value, used by `__STDC__' */ ! 777: T_MACRO, /* macro defined by `#define' */ ! 778: T_DISABLED, /* macro temporarily turned off for rescan */ ! 779: T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */ ! 780: T_PCSTRING, /* precompiled string (hashval is KEYDEF *) */ ! 781: T_UNUSED /* Used for something not defined. */ ! 782: }; ! 783: ! 784: struct hashnode { ! 785: struct hashnode *next; /* double links for easy deletion */ ! 786: struct hashnode *prev; ! 787: struct hashnode **bucket_hdr; /* also, a back pointer to this node's hash ! 788: chain is kept, in case the node is the head ! 789: of the chain and gets deleted. */ ! 790: enum node_type type; /* type of special token */ ! 791: int length; /* length of token, for quick comparison */ ! 792: U_CHAR *name; /* the actual name */ ! 793: union hashval value; /* pointer to expansion, or whatever */ ! 794: }; ! 795: ! 796: typedef struct hashnode HASHNODE; ! 797: ! 798: /* Some definitions for the hash table. The hash function MUST be ! 799: computed as shown in hashf () below. That is because the rescan ! 800: loop computes the hash value `on the fly' for most tokens, ! 801: in order to avoid the overhead of a lot of procedure calls to ! 802: the hashf () function. Hashf () only exists for the sake of ! 803: politeness, for use when speed isn't so important. */ ! 804: ! 805: #define HASHSIZE 1403 ! 806: static HASHNODE *hashtab[HASHSIZE]; ! 807: #define HASHSTEP(old, c) ((old << 2) + c) ! 808: #define MAKE_POS(v) (v & 0x7fffffff) /* make number positive */ ! 809: ! 810: /* Symbols to predefine. */ ! 811: ! 812: #ifdef CPP_PREDEFINES ! 813: static char *predefs = CPP_PREDEFINES; ! 814: #else ! 815: static char *predefs = ""; ! 816: #endif ! 817: ! 818: /* We let tm.h override the types used here, to handle trivial differences ! 819: such as the choice of unsigned int or long unsigned int for size_t. ! 820: When machines start needing nontrivial differences in the size type, ! 821: it would be best to do something here to figure out automatically ! 822: from other information what type to use. */ ! 823: ! 824: /* The string value for __size_type__. */ ! 825: ! 826: #ifndef SIZE_TYPE ! 827: #define SIZE_TYPE "long unsigned int" ! 828: #endif ! 829: ! 830: /* The string value for __ptrdiff_type__. */ ! 831: ! 832: #ifndef PTRDIFF_TYPE ! 833: #define PTRDIFF_TYPE "long int" ! 834: #endif ! 835: ! 836: /* The string value for __wchar_type__. */ ! 837: ! 838: #ifndef WCHAR_TYPE ! 839: #define WCHAR_TYPE "int" ! 840: #endif ! 841: ! 842: /* The string value for __USER_LABEL_PREFIX__ */ ! 843: ! 844: #ifndef USER_LABEL_PREFIX ! 845: #define USER_LABEL_PREFIX "" ! 846: #endif ! 847: ! 848: /* The string value for __REGISTER_PREFIX__ */ ! 849: ! 850: #ifndef REGISTER_PREFIX ! 851: #define REGISTER_PREFIX "" ! 852: #endif ! 853: ! 854: /* In the definition of a #assert name, this structure forms ! 855: a list of the individual values asserted. ! 856: Each value is itself a list of "tokens". ! 857: These are strings that are compared by name. */ ! 858: ! 859: struct tokenlist_list { ! 860: struct tokenlist_list *next; ! 861: struct arglist *tokens; ! 862: }; ! 863: ! 864: struct assertion_hashnode { ! 865: struct assertion_hashnode *next; /* double links for easy deletion */ ! 866: struct assertion_hashnode *prev; ! 867: /* also, a back pointer to this node's hash ! 868: chain is kept, in case the node is the head ! 869: of the chain and gets deleted. */ ! 870: struct assertion_hashnode **bucket_hdr; ! 871: int length; /* length of token, for quick comparison */ ! 872: U_CHAR *name; /* the actual name */ ! 873: /* List of token-sequences. */ ! 874: struct tokenlist_list *value; ! 875: }; ! 876: ! 877: typedef struct assertion_hashnode ASSERTION_HASHNODE; ! 878: ! 879: /* Some definitions for the hash table. The hash function MUST be ! 880: computed as shown in hashf below. That is because the rescan ! 881: loop computes the hash value `on the fly' for most tokens, ! 882: in order to avoid the overhead of a lot of procedure calls to ! 883: the hashf function. hashf only exists for the sake of ! 884: politeness, for use when speed isn't so important. */ ! 885: ! 886: #define ASSERTION_HASHSIZE 37 ! 887: static ASSERTION_HASHNODE *assertion_hashtab[ASSERTION_HASHSIZE]; ! 888: ! 889: /* Nonzero means inhibit macroexpansion of what seem to be ! 890: assertion tests, in rescan. For #if. */ ! 891: static int assertions_flag; ! 892: ! 893: /* `struct directive' defines one #-directive, including how to handle it. */ ! 894: ! 895: struct directive { ! 896: int length; /* Length of name */ ! 897: int (*func)(); /* Function to handle directive */ ! 898: char *name; /* Name of directive */ ! 899: enum node_type type; /* Code which describes which directive. */ ! 900: char angle_brackets; /* Nonzero => <...> is special. */ ! 901: char traditional_comments; /* Nonzero: keep comments if -traditional. */ ! 902: char pass_thru; /* Copy preprocessed directive to output file. */ ! 903: }; ! 904: ! 905: /* Here is the actual list of #-directives, most-often-used first. */ ! 906: ! 907: static struct directive directive_table[] = { ! 908: { 6, do_define, "define", T_DEFINE, 0, 1}, ! 909: { 2, do_if, "if", T_IF}, ! 910: { 5, do_xifdef, "ifdef", T_IFDEF}, ! 911: { 6, do_xifdef, "ifndef", T_IFNDEF}, ! 912: { 5, do_endif, "endif", T_ENDIF}, ! 913: { 4, do_else, "else", T_ELSE}, ! 914: { 4, do_elif, "elif", T_ELIF}, ! 915: { 4, do_line, "line", T_LINE}, ! 916: { 7, do_include, "include", T_INCLUDE, 1}, ! 917: { 12, do_include, "include_next", T_INCLUDE_NEXT, 1}, ! 918: { 6, do_include, "import", T_IMPORT, 1}, ! 919: { 5, do_undef, "undef", T_UNDEF}, ! 920: { 5, do_error, "error", T_ERROR}, ! 921: { 7, do_warning, "warning", T_WARNING}, ! 922: #ifdef SCCS_DIRECTIVE ! 923: { 4, do_sccs, "sccs", T_SCCS}, ! 924: #endif ! 925: { 6, do_pragma, "pragma", T_PRAGMA, 0, 0, 1}, ! 926: { 5, do_ident, "ident", T_IDENT}, ! 927: { 6, do_assert, "assert", T_ASSERT}, ! 928: { 8, do_unassert, "unassert", T_UNASSERT}, ! 929: { -1, 0, "", T_UNUSED}, ! 930: }; ! 931: ! 932: /* When a directive handler is called, ! 933: this points to the # that started the directive. */ ! 934: U_CHAR *directive_start; ! 935: ! 936: /* table to tell if char can be part of a C identifier. */ ! 937: U_CHAR is_idchar[256]; ! 938: /* table to tell if char can be first char of a c identifier. */ ! 939: U_CHAR is_idstart[256]; ! 940: /* table to tell if c is horizontal space. */ ! 941: U_CHAR is_hor_space[256]; ! 942: /* table to tell if c is horizontal or vertical space. */ ! 943: static U_CHAR is_space[256]; ! 944: ! 945: #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0) ! 946: #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0) ! 947: ! 948: static int errors = 0; /* Error counter for exit code */ ! 949: ! 950: /* Name of output file, for error messages. */ ! 951: static char *out_fname; ! 952: ! 953: /* Zero means dollar signs are punctuation. ! 954: -$ stores 0; -traditional may store 1. Default is 1 for VMS, 0 otherwise. ! 955: This must be 0 for correct processing of this ANSI C program: ! 956: #define foo(a) #a ! 957: #define lose(b) foo (b) ! 958: #define test$ ! 959: lose (test) */ ! 960: static int dollars_in_ident; ! 961: #ifndef DOLLARS_IN_IDENTIFIERS ! 962: #define DOLLARS_IN_IDENTIFIERS 1 ! 963: #endif ! 964: ! 965: static FILE_BUF expand_to_temp_buffer (); ! 966: ! 967: static DEFINITION *collect_expansion (); ! 968: ! 969: /* Stack of conditionals currently in progress ! 970: (including both successful and failing conditionals). */ ! 971: ! 972: struct if_stack { ! 973: struct if_stack *next; /* for chaining to the next stack frame */ ! 974: char *fname; /* copied from input when frame is made */ ! 975: int lineno; /* similarly */ ! 976: int if_succeeded; /* true if a leg of this if-group ! 977: has been passed through rescan */ ! 978: U_CHAR *control_macro; /* For #ifndef at start of file, ! 979: this is the macro name tested. */ ! 980: enum node_type type; /* type of last directive seen in this group */ ! 981: }; ! 982: typedef struct if_stack IF_STACK_FRAME; ! 983: static IF_STACK_FRAME *if_stack = NULL; ! 984: ! 985: /* Buffer of -M output. */ ! 986: static char *deps_buffer; ! 987: ! 988: /* Number of bytes allocated in above. */ ! 989: static int deps_allocated_size; ! 990: ! 991: /* Number of bytes used. */ ! 992: static int deps_size; ! 993: ! 994: /* Number of bytes since the last newline. */ ! 995: static int deps_column; ! 996: ! 997: /* Nonzero means -I- has been seen, ! 998: so don't look for #include "foo" the source-file directory. */ ! 999: static int ignore_srcdir; ! 1000: ! 1001: /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME, ! 1002: retrying if necessary. Return the actual number of bytes read. */ ! 1003: ! 1004: static int ! 1005: safe_read (desc, ptr, len) ! 1006: int desc; ! 1007: char *ptr; ! 1008: int len; ! 1009: { ! 1010: int left = len; ! 1011: while (left > 0) { ! 1012: int nchars = read (desc, ptr, left); ! 1013: if (nchars < 0) ! 1014: { ! 1015: #ifdef EINTR ! 1016: if (errno == EINTR) ! 1017: continue; ! 1018: #endif ! 1019: return nchars; ! 1020: } ! 1021: if (nchars == 0) ! 1022: break; ! 1023: ptr += nchars; ! 1024: left -= nchars; ! 1025: } ! 1026: return len - left; ! 1027: } ! 1028: ! 1029: /* Write LEN bytes at PTR to descriptor DESC, ! 1030: retrying if necessary, and treating any real error as fatal. */ ! 1031: ! 1032: static void ! 1033: safe_write (desc, ptr, len) ! 1034: int desc; ! 1035: char *ptr; ! 1036: int len; ! 1037: { ! 1038: while (len > 0) { ! 1039: int written = write (desc, ptr, len); ! 1040: if (written < 0) ! 1041: { ! 1042: #ifdef EINTR ! 1043: if (errno == EINTR) ! 1044: continue; ! 1045: #endif ! 1046: pfatal_with_name (out_fname); ! 1047: } ! 1048: ptr += written; ! 1049: len -= written; ! 1050: } ! 1051: } ! 1052: ! 1053: int ! 1054: main (argc, argv) ! 1055: int argc; ! 1056: char **argv; ! 1057: { ! 1058: int st_mode; ! 1059: long st_size; ! 1060: char *in_fname; ! 1061: char *p; ! 1062: int f, i; ! 1063: FILE_BUF *fp; ! 1064: char **pend_files = (char **) xmalloc (argc * sizeof (char *)); ! 1065: char **pend_defs = (char **) xmalloc (argc * sizeof (char *)); ! 1066: char **pend_undefs = (char **) xmalloc (argc * sizeof (char *)); ! 1067: char **pend_assertions = (char **) xmalloc (argc * sizeof (char *)); ! 1068: char **pend_includes = (char **) xmalloc (argc * sizeof (char *)); ! 1069: ! 1070: /* Record the option used with each element of pend_assertions. ! 1071: This is preparation for supporting more than one option for making ! 1072: an assertion. */ ! 1073: char **pend_assertion_options = (char **) xmalloc (argc * sizeof (char *)); ! 1074: int inhibit_predefs = 0; ! 1075: int no_standard_includes = 0; ! 1076: int no_standard_cplusplus_includes = 0; ! 1077: int missing_newline = 0; ! 1078: ! 1079: /* Non-0 means don't output the preprocessed program. */ ! 1080: int inhibit_output = 0; ! 1081: /* Non-0 means -v, so print the full set of include dirs. */ ! 1082: int verbose = 0; ! 1083: ! 1084: /* File name which deps are being written to. ! 1085: This is 0 if deps are being written to stdout. */ ! 1086: char *deps_file = 0; ! 1087: /* Fopen file mode to open deps_file with. */ ! 1088: char *deps_mode = "a"; ! 1089: /* Stream on which to print the dependency information. */ ! 1090: FILE *deps_stream = 0; ! 1091: /* Target-name to write with the dependency information. */ ! 1092: char *deps_target = 0; ! 1093: ! 1094: #ifdef RLIMIT_STACK ! 1095: /* Get rid of any avoidable limit on stack size. */ ! 1096: { ! 1097: struct rlimit rlim; ! 1098: ! 1099: /* Set the stack limit huge so that alloca (particularly stringtab ! 1100: * in dbxread.c) does not fail. */ ! 1101: getrlimit (RLIMIT_STACK, &rlim); ! 1102: rlim.rlim_cur = rlim.rlim_max; ! 1103: setrlimit (RLIMIT_STACK, &rlim); ! 1104: } ! 1105: #endif /* RLIMIT_STACK defined */ ! 1106: ! 1107: #ifdef SIGPIPE ! 1108: signal (SIGPIPE, pipe_closed); ! 1109: #endif ! 1110: ! 1111: p = argv[0] + strlen (argv[0]); ! 1112: while (p != argv[0] && p[-1] != '/') --p; ! 1113: progname = p; ! 1114: ! 1115: #ifdef VMS ! 1116: { ! 1117: /* Remove directories from PROGNAME. */ ! 1118: char *s; ! 1119: ! 1120: progname = savestring (argv[0]); ! 1121: ! 1122: if (!(s = rindex (progname, ']'))) ! 1123: s = rindex (progname, ':'); ! 1124: if (s) ! 1125: strcpy (progname, s+1); ! 1126: if (s = rindex (progname, '.')) ! 1127: *s = '\0'; ! 1128: } ! 1129: #endif ! 1130: ! 1131: in_fname = NULL; ! 1132: out_fname = NULL; ! 1133: ! 1134: /* Initialize is_idchar to allow $. */ ! 1135: dollars_in_ident = 1; ! 1136: initialize_char_syntax (); ! 1137: dollars_in_ident = DOLLARS_IN_IDENTIFIERS > 0; ! 1138: ! 1139: no_line_commands = 0; ! 1140: no_trigraphs = 1; ! 1141: dump_macros = dump_none; ! 1142: no_output = 0; ! 1143: cplusplus = 0; ! 1144: #ifdef NeXT ! 1145: cplusplus_comments = 1; ! 1146: #else ! 1147: cplusplus_comments = 0; ! 1148: #endif ! 1149: ! 1150: bzero (pend_files, argc * sizeof (char *)); ! 1151: bzero (pend_defs, argc * sizeof (char *)); ! 1152: bzero (pend_undefs, argc * sizeof (char *)); ! 1153: bzero (pend_assertions, argc * sizeof (char *)); ! 1154: bzero (pend_includes, argc * sizeof (char *)); ! 1155: ! 1156: /* Process switches and find input file name. */ ! 1157: ! 1158: for (i = 1; i < argc; i++) { ! 1159: if (argv[i][0] != '-') { ! 1160: if (out_fname != NULL) ! 1161: fatal ("Usage: %s [switches] input output", argv[0]); ! 1162: else if (in_fname != NULL) ! 1163: out_fname = argv[i]; ! 1164: else ! 1165: in_fname = argv[i]; ! 1166: } else { ! 1167: switch (argv[i][1]) { ! 1168: #ifdef NeXT ! 1169: case 'a': ! 1170: if (!strcmp (argv[i], "-arch")) /* ignore -arch <archname> */ ! 1171: i++; ! 1172: break; ! 1173: #endif ! 1174: ! 1175: case 'c': ! 1176: if (! strcmp (argv[i], "-c++-comments")) ! 1177: cplusplus_comments = 1; ! 1178: break; ! 1179: ! 1180: case 'i': ! 1181: if (!strcmp (argv[i], "-include")) { ! 1182: if (i + 1 == argc) ! 1183: fatal ("Filename missing after `-include' option"); ! 1184: else ! 1185: pend_includes[i] = argv[i+1], i++; ! 1186: } ! 1187: else if (!strcmp (argv[i], "-imacros")) { ! 1188: if (i + 1 == argc) ! 1189: fatal ("Filename missing after `-imacros' option"); ! 1190: else ! 1191: pend_files[i] = argv[i+1], i++; ! 1192: } ! 1193: else if (!strcmp (argv[i], "-iprefix")) { ! 1194: if (i + 1 == argc) ! 1195: fatal ("Filename missing after `-iprefix' option"); ! 1196: else ! 1197: include_prefix = argv[++i]; ! 1198: } ! 1199: /* Add directory to end of path for includes, ! 1200: with the default prefix at the front of its name. */ ! 1201: else if (!strcmp (argv[i], "-iwithprefix")) { ! 1202: struct file_name_list *dirtmp; ! 1203: char *prefix; ! 1204: ! 1205: if (include_prefix != 0) ! 1206: prefix = include_prefix; ! 1207: else { ! 1208: prefix = savestring (GCC_INCLUDE_DIR); ! 1209: /* Remove the `include' from /usr/local/lib/gcc.../include. */ ! 1210: if (!strcmp (prefix + strlen (prefix) - 8, "/include")) ! 1211: prefix[strlen (prefix) - 7] = 0; ! 1212: } ! 1213: ! 1214: dirtmp = (struct file_name_list *) ! 1215: xmalloc (sizeof (struct file_name_list)); ! 1216: dirtmp->next = 0; /* New one goes on the end */ ! 1217: dirtmp->control_macro = 0; ! 1218: dirtmp->c_system_include_path = 0; ! 1219: if (i + 1 == argc) ! 1220: fatal ("Directory name missing after `-iwithprefix' option"); ! 1221: ! 1222: dirtmp->fname = (char *) xmalloc (strlen (argv[i+1]) ! 1223: + strlen (prefix) + 1); ! 1224: strcpy (dirtmp->fname, prefix); ! 1225: strcat (dirtmp->fname, argv[++i]); ! 1226: ! 1227: if (after_include == 0) ! 1228: after_include = dirtmp; ! 1229: else ! 1230: last_after_include->next = dirtmp; ! 1231: last_after_include = dirtmp; /* Tail follows the last one */ ! 1232: } ! 1233: /* Add directory to main path for includes, ! 1234: with the default prefix at the front of its name. */ ! 1235: else if (!strcmp (argv[i], "-iwithprefixbefore")) { ! 1236: struct file_name_list *dirtmp; ! 1237: char *prefix; ! 1238: ! 1239: if (include_prefix != 0) ! 1240: prefix = include_prefix; ! 1241: else { ! 1242: prefix = savestring (GCC_INCLUDE_DIR); ! 1243: /* Remove the `include' from /usr/local/lib/gcc.../include. */ ! 1244: if (!strcmp (prefix + strlen (prefix) - 8, "/include")) ! 1245: prefix[strlen (prefix) - 7] = 0; ! 1246: } ! 1247: ! 1248: dirtmp = (struct file_name_list *) ! 1249: xmalloc (sizeof (struct file_name_list)); ! 1250: dirtmp->next = 0; /* New one goes on the end */ ! 1251: dirtmp->control_macro = 0; ! 1252: dirtmp->c_system_include_path = 0; ! 1253: if (i + 1 == argc) ! 1254: fatal ("Directory name missing after `-iwithprefixbefore' option"); ! 1255: ! 1256: dirtmp->fname = (char *) xmalloc (strlen (argv[i+1]) ! 1257: + strlen (prefix) + 1); ! 1258: strcpy (dirtmp->fname, prefix); ! 1259: strcat (dirtmp->fname, argv[++i]); ! 1260: ! 1261: append_include_chain (dirtmp, dirtmp); ! 1262: } ! 1263: /* Add directory to end of path for includes. */ ! 1264: else if (!strcmp (argv[i], "-idirafter")) { ! 1265: struct file_name_list *dirtmp; ! 1266: ! 1267: dirtmp = (struct file_name_list *) ! 1268: xmalloc (sizeof (struct file_name_list)); ! 1269: dirtmp->next = 0; /* New one goes on the end */ ! 1270: dirtmp->control_macro = 0; ! 1271: dirtmp->c_system_include_path = 0; ! 1272: if (i + 1 == argc) ! 1273: fatal ("Directory name missing after `-idirafter' option"); ! 1274: else ! 1275: dirtmp->fname = argv[++i]; ! 1276: ! 1277: if (after_include == 0) ! 1278: after_include = dirtmp; ! 1279: else ! 1280: last_after_include->next = dirtmp; ! 1281: last_after_include = dirtmp; /* Tail follows the last one */ ! 1282: } ! 1283: #ifdef NEXT_OBJC_RUNTIME ! 1284: else if (argv[i][2] != 0) ! 1285: pend_files[i] = argv[i] + 2; ! 1286: else if (i + 1 == argc) ! 1287: fatal ("Filename missing after -i option"); ! 1288: else ! 1289: pend_files[i] = argv[i+1], i++; ! 1290: #endif ! 1291: break; ! 1292: ! 1293: case 'o': ! 1294: if (out_fname != NULL) ! 1295: fatal ("Output filename specified twice"); ! 1296: if (i + 1 == argc) ! 1297: fatal ("Filename missing after -o option"); ! 1298: out_fname = argv[++i]; ! 1299: if (!strcmp (out_fname, "-")) ! 1300: out_fname = ""; ! 1301: break; ! 1302: ! 1303: case 'p': ! 1304: if (!strcmp (argv[i], "-pedantic")) ! 1305: pedantic = 1; ! 1306: else if (!strcmp (argv[i], "-pedantic-errors")) { ! 1307: pedantic = 1; ! 1308: pedantic_errors = 1; ! 1309: } else if (!strcmp (argv[i], "-pcp")) { ! 1310: char *pcp_fname = argv[++i]; ! 1311: pcp_outfile = ! 1312: ((pcp_fname[0] != '-' || pcp_fname[1] != '\0') ! 1313: ? fopen (pcp_fname, "w") ! 1314: : fdopen (dup (fileno (stdout)), "w")); ! 1315: if (pcp_outfile == 0) ! 1316: pfatal_with_name (pcp_fname); ! 1317: no_precomp = 1; ! 1318: } ! 1319: break; ! 1320: ! 1321: case 't': ! 1322: if (!strcmp (argv[i], "-traditional")) { ! 1323: traditional = 1; ! 1324: if (dollars_in_ident > 0) ! 1325: dollars_in_ident = 1; ! 1326: } else if (!strcmp (argv[i], "-trigraphs")) { ! 1327: no_trigraphs = 0; ! 1328: } ! 1329: break; ! 1330: ! 1331: #ifdef NeXT ! 1332: case 's': ! 1333: if (!strcmp (argv[i], "-smart")) ! 1334: /* ignore */; ! 1335: break; ! 1336: #endif ! 1337: ! 1338: case 'l': ! 1339: if (! strcmp (argv[i], "-lang-c")) ! 1340: cplusplus = 0, objc = 0; ! 1341: if (! strcmp (argv[i], "-lang-c++")) ! 1342: cplusplus = 1, cplusplus_comments = 1, objc = 0; ! 1343: if (! strcmp (argv[i], "-lang-objc")) ! 1344: objc = 1, cplusplus_comments = 1, cplusplus = 0; ! 1345: if (! strcmp (argv[i], "-lang-objc++")) ! 1346: objc = 1, cplusplus_comments = 1, cplusplus = 1; ! 1347: if (! strcmp (argv[i], "-lang-asm")) ! 1348: lang_asm = 1; ! 1349: if (! strcmp (argv[i], "-lint")) ! 1350: lint = 1; ! 1351: break; ! 1352: ! 1353: case '+': ! 1354: cplusplus = 1, cplusplus_comments = 1; ! 1355: break; ! 1356: ! 1357: case 'w': ! 1358: inhibit_warnings = 1; ! 1359: break; ! 1360: ! 1361: case 'W': ! 1362: if (!strcmp (argv[i], "-Wtrigraphs")) ! 1363: warn_trigraphs = 1; ! 1364: else if (!strcmp (argv[i], "-Wno-trigraphs")) ! 1365: warn_trigraphs = 0; ! 1366: else if (!strcmp (argv[i], "-Wcomment")) ! 1367: warn_comments = 1; ! 1368: else if (!strcmp (argv[i], "-Wno-comment")) ! 1369: warn_comments = 0; ! 1370: else if (!strcmp (argv[i], "-Wcomments")) ! 1371: warn_comments = 1; ! 1372: else if (!strcmp (argv[i], "-Wno-comments")) ! 1373: warn_comments = 0; ! 1374: else if (!strcmp (argv[i], "-Wtraditional")) ! 1375: warn_stringify = 1; ! 1376: else if (!strcmp (argv[i], "-Wno-traditional")) ! 1377: warn_stringify = 0; ! 1378: else if (!strcmp (argv[i], "-Wimport")) ! 1379: warn_import = 1; ! 1380: else if (!strcmp (argv[i], "-Wno-import")) ! 1381: warn_import = 0; ! 1382: else if (!strcmp (argv[i], "-Werror")) ! 1383: warnings_are_errors = 1; ! 1384: else if (!strcmp (argv[i], "-Wno-error")) ! 1385: warnings_are_errors = 0; ! 1386: else if (!strcmp (argv[i], "-Wall")) ! 1387: { ! 1388: warn_trigraphs = 1; ! 1389: warn_comments = 1; ! 1390: } ! 1391: break; ! 1392: ! 1393: case 'M': ! 1394: if (!strcmp (argv[i], "-M")) ! 1395: print_deps = 2; ! 1396: else if (!strcmp (argv[i], "-MM")) ! 1397: print_deps = 1; ! 1398: else if (!strcmp (argv[i], "-MD")) ! 1399: print_deps = 2; ! 1400: else if (!strcmp (argv[i], "-MMD")) ! 1401: print_deps = 1; ! 1402: /* For -MD and -MMD options, write deps on file named by next arg. */ ! 1403: if (!strcmp (argv[i], "-MD") ! 1404: || !strcmp (argv[i], "-MMD")) { ! 1405: i++; ! 1406: deps_file = argv[i]; ! 1407: deps_mode = "w"; ! 1408: } else { ! 1409: /* For -M and -MM, write deps on standard output ! 1410: and suppress the usual output. */ ! 1411: deps_stream = stdout; ! 1412: inhibit_output = 1; ! 1413: } ! 1414: break; ! 1415: ! 1416: case 'd': ! 1417: { ! 1418: char *p = argv[i] + 2; ! 1419: char c; ! 1420: while (c = *p++) { ! 1421: /* Arg to -d specifies what parts of macros to dump */ ! 1422: switch (c) { ! 1423: case 'M': ! 1424: dump_macros = dump_only; ! 1425: no_output = 1; ! 1426: break; ! 1427: case 'N': ! 1428: dump_macros = dump_names; ! 1429: break; ! 1430: case 'D': ! 1431: dump_macros = dump_definitions; ! 1432: break; ! 1433: } ! 1434: } ! 1435: } ! 1436: break; ! 1437: ! 1438: case 'g': ! 1439: if (argv[i][2] == '3') ! 1440: debug_output = 1; ! 1441: break; ! 1442: ! 1443: case 'v': ! 1444: fprintf (stderr, "GNU CPP version %s", version_string); ! 1445: #ifdef TARGET_VERSION ! 1446: TARGET_VERSION; ! 1447: #endif ! 1448: fprintf (stderr, "\n"); ! 1449: verbose = 1; ! 1450: break; ! 1451: ! 1452: case 'H': ! 1453: print_include_names = 1; ! 1454: break; ! 1455: ! 1456: case 'D': ! 1457: { ! 1458: char *p, *p1; ! 1459: ! 1460: if (argv[i][2] != 0) ! 1461: p = argv[i] + 2; ! 1462: else if (i + 1 == argc) ! 1463: fatal ("Macro name missing after -D option"); ! 1464: else ! 1465: p = argv[++i]; ! 1466: ! 1467: pend_defs[i] = p; ! 1468: } ! 1469: break; ! 1470: ! 1471: case 'A': ! 1472: { ! 1473: char *p, *p1; ! 1474: ! 1475: if (argv[i][2] != 0) ! 1476: p = argv[i] + 2; ! 1477: else if (i + 1 == argc) ! 1478: fatal ("Assertion missing after -A option"); ! 1479: else ! 1480: p = argv[++i]; ! 1481: ! 1482: if (!strcmp (p, "-")) { ! 1483: /* -A- eliminates all predefined macros and assertions. ! 1484: Let's include also any that were specified earlier ! 1485: on the command line. That way we can get rid of any ! 1486: that were passed automatically in from GCC. */ ! 1487: int j; ! 1488: inhibit_predefs = 1; ! 1489: for (j = 0; j < i; j++) ! 1490: pend_defs[j] = pend_assertions[j] = 0; ! 1491: } else { ! 1492: pend_assertions[i] = p; ! 1493: pend_assertion_options[i] = "-A"; ! 1494: } ! 1495: } ! 1496: break; ! 1497: ! 1498: case 'U': /* JF #undef something */ ! 1499: if (argv[i][2] != 0) ! 1500: pend_undefs[i] = argv[i] + 2; ! 1501: else if (i + 1 == argc) ! 1502: fatal ("Macro name missing after -U option"); ! 1503: else ! 1504: pend_undefs[i] = argv[i+1], i++; ! 1505: break; ! 1506: ! 1507: case 'C': ! 1508: put_out_comments = 1; ! 1509: break; ! 1510: ! 1511: case 'E': /* -E comes from cc -E; ignore it. */ ! 1512: break; ! 1513: ! 1514: case 'P': ! 1515: no_line_commands = 1; ! 1516: break; ! 1517: ! 1518: case '$': /* Don't include $ in identifiers. */ ! 1519: dollars_in_ident = 0; ! 1520: break; ! 1521: ! 1522: case 'I': /* Add directory to path for includes. */ ! 1523: { ! 1524: struct file_name_list *dirtmp; ! 1525: ! 1526: if (! ignore_srcdir && !strcmp (argv[i] + 2, "-")) { ! 1527: ignore_srcdir = 1; ! 1528: /* Don't use any preceding -I directories for #include <...>. */ ! 1529: first_bracket_include = 0; ! 1530: } ! 1531: else { ! 1532: dirtmp = (struct file_name_list *) ! 1533: xmalloc (sizeof (struct file_name_list)); ! 1534: dirtmp->next = 0; /* New one goes on the end */ ! 1535: dirtmp->control_macro = 0; ! 1536: dirtmp->c_system_include_path = 0; ! 1537: if (argv[i][2] != 0) ! 1538: dirtmp->fname = argv[i] + 2; ! 1539: else if (i + 1 == argc) ! 1540: fatal ("Directory name missing after -I option"); ! 1541: else ! 1542: dirtmp->fname = argv[++i]; ! 1543: append_include_chain (dirtmp, dirtmp); ! 1544: } ! 1545: } ! 1546: break; ! 1547: ! 1548: case 'n': ! 1549: if (!strcmp (argv[i], "-nostdinc")) ! 1550: /* -nostdinc causes no default include directories. ! 1551: You must specify all include-file directories with -I. */ ! 1552: no_standard_includes = 1; ! 1553: else if (!strcmp (argv[i], "-nostdinc++")) ! 1554: /* -nostdinc++ causes no default C++-specific include directories. */ ! 1555: no_standard_cplusplus_includes = 1; ! 1556: else if (!strcmp (argv[i], "-noprecomp")) ! 1557: no_precomp = 1; ! 1558: if (!strcmp (argv[i], "-no-c++-comments")) ! 1559: cplusplus_comments = 0; ! 1560: break; ! 1561: ! 1562: break; ! 1563: ! 1564: case 'u': ! 1565: /* Sun compiler passes undocumented switch "-undef". ! 1566: Let's assume it means to inhibit the predefined symbols. */ ! 1567: inhibit_predefs = 1; ! 1568: break; ! 1569: ! 1570: case '\0': /* JF handle '-' as file name meaning stdin or stdout */ ! 1571: if (in_fname == NULL) { ! 1572: in_fname = ""; ! 1573: break; ! 1574: } else if (out_fname == NULL) { ! 1575: out_fname = ""; ! 1576: break; ! 1577: } /* else fall through into error */ ! 1578: ! 1579: default: ! 1580: fatal ("Invalid option `%s'", argv[i]); ! 1581: } ! 1582: } ! 1583: } ! 1584: ! 1585: /* Add dirs from CPATH after dirs from -I. */ ! 1586: /* There seems to be confusion about what CPATH should do, ! 1587: so for the moment it is not documented. */ ! 1588: /* Some people say that CPATH should replace the standard include dirs, ! 1589: but that seems pointless: it comes before them, so it overrides them ! 1590: anyway. */ ! 1591: p = (char *) getenv ("CPATH"); ! 1592: if (p != 0 && ! no_standard_includes) ! 1593: path_include (p); ! 1594: ! 1595: /* Now that dollars_in_ident is known, initialize is_idchar. */ ! 1596: initialize_char_syntax (); ! 1597: ! 1598: /* Initialize output buffer */ ! 1599: ! 1600: outbuf.buf = (U_CHAR *) xmalloc (OUTBUF_SIZE); ! 1601: outbuf.bufp = outbuf.buf; ! 1602: outbuf.length = OUTBUF_SIZE; ! 1603: ! 1604: /* Do partial setup of input buffer for the sake of generating ! 1605: early #line directives (when -g is in effect). */ ! 1606: ! 1607: fp = &instack[++indepth]; ! 1608: if (in_fname == NULL) ! 1609: in_fname = ""; ! 1610: fp->nominal_fname = fp->fname = in_fname; ! 1611: fp->lineno = 0; ! 1612: ! 1613: /* Install __LINE__, etc. Must follow initialize_char_syntax ! 1614: and option processing. */ ! 1615: initialize_builtins (fp, &outbuf); ! 1616: ! 1617: /* Do standard #defines and assertions ! 1618: that identify system and machine type. */ ! 1619: ! 1620: if (!inhibit_predefs) { ! 1621: char *p = (char *) alloca (strlen (predefs) + 1); ! 1622: strcpy (p, predefs); ! 1623: while (*p) { ! 1624: char *q; ! 1625: while (*p == ' ' || *p == '\t') ! 1626: p++; ! 1627: /* Handle -D options. */ ! 1628: if (p[0] == '-' && p[1] == 'D') { ! 1629: q = &p[2]; ! 1630: while (*p && *p != ' ' && *p != '\t') ! 1631: p++; ! 1632: if (*p != 0) ! 1633: *p++= 0; ! 1634: if (debug_output) ! 1635: output_line_command (fp, &outbuf, 0, same_file); ! 1636: make_definition (q, &outbuf); ! 1637: while (*p == ' ' || *p == '\t') ! 1638: p++; ! 1639: } else if (p[0] == '-' && p[1] == 'A') { ! 1640: /* Handle -A options (assertions). */ ! 1641: char *assertion; ! 1642: char *past_name; ! 1643: char *value; ! 1644: char *past_value; ! 1645: char *termination; ! 1646: int save_char; ! 1647: ! 1648: assertion = &p[2]; ! 1649: past_name = assertion; ! 1650: /* Locate end of name. */ ! 1651: while (*past_name && *past_name != ' ' ! 1652: && *past_name != '\t' && *past_name != '(') ! 1653: past_name++; ! 1654: /* Locate `(' at start of value. */ ! 1655: value = past_name; ! 1656: while (*value && (*value == ' ' || *value == '\t')) ! 1657: value++; ! 1658: if (*value++ != '(') ! 1659: abort (); ! 1660: while (*value && (*value == ' ' || *value == '\t')) ! 1661: value++; ! 1662: past_value = value; ! 1663: /* Locate end of value. */ ! 1664: while (*past_value && *past_value != ' ' ! 1665: && *past_value != '\t' && *past_value != ')') ! 1666: past_value++; ! 1667: termination = past_value; ! 1668: while (*termination && (*termination == ' ' || *termination == '\t')) ! 1669: termination++; ! 1670: if (*termination++ != ')') ! 1671: abort (); ! 1672: if (*termination && *termination != ' ' && *termination != '\t') ! 1673: abort (); ! 1674: /* Temporarily null-terminate the value. */ ! 1675: save_char = *termination; ! 1676: *termination = '\0'; ! 1677: /* Install the assertion. */ ! 1678: make_assertion ("-A", assertion); ! 1679: *termination = (char) save_char; ! 1680: p = termination; ! 1681: while (*p == ' ' || *p == '\t') ! 1682: p++; ! 1683: } else { ! 1684: abort (); ! 1685: } ! 1686: } ! 1687: } ! 1688: ! 1689: /* Now handle the command line options. */ ! 1690: ! 1691: /* Do -U's, -D's and -A's in the order they were seen. */ ! 1692: for (i = 1; i < argc; i++) { ! 1693: if (pend_undefs[i]) { ! 1694: if (debug_output) ! 1695: output_line_command (fp, &outbuf, 0, same_file); ! 1696: make_undef (pend_undefs[i], &outbuf); ! 1697: } ! 1698: if (pend_defs[i]) { ! 1699: if (debug_output) ! 1700: output_line_command (fp, &outbuf, 0, same_file); ! 1701: make_definition (pend_defs[i], &outbuf); ! 1702: } ! 1703: if (pend_assertions[i]) ! 1704: make_assertion (pend_assertion_options[i], pend_assertions[i]); ! 1705: } ! 1706: ! 1707: done_initializing = 1; ! 1708: ! 1709: { /* read the appropriate environment variable and if it exists ! 1710: replace include_defaults with the listed path. */ ! 1711: char *epath = 0; ! 1712: switch ((objc << 1) + cplusplus) ! 1713: { ! 1714: case 0: ! 1715: epath = getenv ("C_INCLUDE_PATH"); ! 1716: break; ! 1717: case 1: ! 1718: epath = getenv ("CPLUS_INCLUDE_PATH"); ! 1719: break; ! 1720: case 2: ! 1721: epath = getenv ("OBJC_INCLUDE_PATH"); ! 1722: break; ! 1723: case 3: ! 1724: epath = getenv ("OBJCPLUS_INCLUDE_PATH"); ! 1725: break; ! 1726: } ! 1727: /* If the environment var for this language is set, ! 1728: add to the default list of include directories. */ ! 1729: if (epath) { ! 1730: char *nstore = (char *) alloca (strlen (epath) + 2); ! 1731: int num_dirs; ! 1732: char *startp, *endp; ! 1733: ! 1734: for (num_dirs = 1, startp = epath; *startp; startp++) ! 1735: if (*startp == PATH_SEPARATOR) ! 1736: num_dirs++; ! 1737: include_defaults ! 1738: = (struct default_include *) xmalloc ((num_dirs ! 1739: * sizeof (struct default_include)) ! 1740: + sizeof (include_defaults_array)); ! 1741: startp = endp = epath; ! 1742: num_dirs = 0; ! 1743: while (1) { ! 1744: /* Handle cases like c:/usr/lib:d:/gcc/lib */ ! 1745: if ((*endp == PATH_SEPARATOR ! 1746: #if 0 /* Obsolete, now that we use semicolons as the path separator. */ ! 1747: #ifdef __MSDOS__ ! 1748: && (endp-startp != 1 || !isalpha (*startp)) ! 1749: #endif ! 1750: #endif ! 1751: ) ! 1752: || *endp == 0) { ! 1753: strncpy (nstore, startp, endp-startp); ! 1754: if (endp == startp) ! 1755: strcpy (nstore, "."); ! 1756: else ! 1757: nstore[endp-startp] = '\0'; ! 1758: ! 1759: include_defaults[num_dirs].fname = savestring (nstore); ! 1760: include_defaults[num_dirs].cplusplus = cplusplus; ! 1761: num_dirs++; ! 1762: if (*endp == '\0') ! 1763: break; ! 1764: endp = startp = endp + 1; ! 1765: } else ! 1766: endp++; ! 1767: } ! 1768: /* Put the usual defaults back in at the end. */ ! 1769: bcopy (include_defaults_array, &include_defaults[num_dirs], ! 1770: sizeof (include_defaults_array)); ! 1771: } ! 1772: } ! 1773: ! 1774: first_system_include = 0; ! 1775: /* Unless -fnostdinc, ! 1776: tack on the standard include file dirs to the specified list */ ! 1777: if (!no_standard_includes) { ! 1778: struct default_include *p = include_defaults; ! 1779: char *specd_prefix = include_prefix; ! 1780: char *default_prefix = savestring (GCC_INCLUDE_DIR); ! 1781: int default_len = 0; ! 1782: /* Remove the `include' from /usr/local/lib/gcc.../include. */ ! 1783: if (!strcmp (default_prefix + strlen (default_prefix) - 8, "/include")) { ! 1784: default_len = strlen (default_prefix) - 7; ! 1785: default_prefix[default_len] = 0; ! 1786: } ! 1787: /* Search "translated" versions of GNU directories. ! 1788: These have /usr/local/lib/gcc... replaced by specd_prefix. */ ! 1789: if (specd_prefix != 0 && default_len != 0) ! 1790: for (p = include_defaults; p->fname; p++) { ! 1791: /* Some standard dirs are only for C++. */ ! 1792: if ((p->cplusplus != 1) ! 1793: || (cplusplus && !no_standard_cplusplus_includes)) ! 1794: { ! 1795: /* Does this dir start with the prefix? */ ! 1796: if (!strncmp (p->fname, default_prefix, default_len)) { ! 1797: /* Yes; change prefix and add to search list. */ ! 1798: struct file_name_list *new ! 1799: = (struct file_name_list *) xmalloc (sizeof (struct file_name_list)); ! 1800: int this_len = strlen (specd_prefix) + strlen (p->fname) - default_len; ! 1801: char *str = (char *) xmalloc (this_len + 1); ! 1802: strcpy (str, specd_prefix); ! 1803: strcat (str, p->fname + default_len); ! 1804: new->fname = str; ! 1805: new->control_macro = 0; ! 1806: new->c_system_include_path = (p->cplusplus == 0); ! 1807: append_include_chain (new, new); ! 1808: if (first_system_include == 0) ! 1809: first_system_include = new; ! 1810: } ! 1811: } ! 1812: } ! 1813: /* Search ordinary names for GNU include directories. */ ! 1814: for (p = include_defaults; p->fname; p++) { ! 1815: /* Some standard dirs are only for C++. */ ! 1816: if ((p->cplusplus != 1) ! 1817: || (cplusplus && !no_standard_cplusplus_includes)) ! 1818: { ! 1819: struct file_name_list *new ! 1820: = (struct file_name_list *) xmalloc (sizeof (struct file_name_list)); ! 1821: new->control_macro = 0; ! 1822: new->c_system_include_path = (p->cplusplus == 0); ! 1823: new->fname = p->fname; ! 1824: append_include_chain (new, new); ! 1825: if (first_system_include == 0) ! 1826: first_system_include = new; ! 1827: } ! 1828: } ! 1829: } ! 1830: ! 1831: /* Tack the after_include chain at the end of the include chain. */ ! 1832: append_include_chain (after_include, last_after_include); ! 1833: if (first_system_include == 0) ! 1834: first_system_include = after_include; ! 1835: ! 1836: /* With -v, print the list of dirs to search. */ ! 1837: if (verbose) { ! 1838: struct file_name_list *p; ! 1839: fprintf (stderr, "#include \"...\" search starts here:\n"); ! 1840: for (p = include; p; p = p->next) { ! 1841: if (p == first_bracket_include) ! 1842: fprintf (stderr, "#include <...> search starts here:\n"); ! 1843: fprintf (stderr, " %s\n", p->fname); ! 1844: } ! 1845: fprintf (stderr, "End of search list.\n"); ! 1846: } ! 1847: ! 1848: /* Scan the -imacros files before the main input. ! 1849: Much like #including them, but with no_output set ! 1850: so that only their macro definitions matter. */ ! 1851: ! 1852: no_output++; ! 1853: for (i = 1; i < argc; i++) ! 1854: if (pend_files[i]) { ! 1855: int fd = open (pend_files[i], O_RDONLY, 0666); ! 1856: if (fd < 0) { ! 1857: perror_with_name (pend_files[i]); ! 1858: return FAILURE_EXIT_CODE; ! 1859: } ! 1860: finclude (fd, pend_files[i], &outbuf, 0, NULL_PTR); ! 1861: } ! 1862: no_output--; ! 1863: ! 1864: /* Copy the entire contents of the main input file into ! 1865: the stacked input buffer previously allocated for it. */ ! 1866: ! 1867: /* JF check for stdin */ ! 1868: if (in_fname == NULL || *in_fname == 0) { ! 1869: in_fname = ""; ! 1870: f = 0; ! 1871: } else if ((f = open (in_fname, O_RDONLY, 0666)) < 0) ! 1872: goto perror; ! 1873: ! 1874: /* Either of two environment variables can specify output of deps. ! 1875: Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET", ! 1876: where OUTPUT_FILE is the file to write deps info to ! 1877: and DEPS_TARGET is the target to mention in the deps. */ ! 1878: ! 1879: if (print_deps == 0 ! 1880: && (getenv ("SUNPRO_DEPENDENCIES") != 0 ! 1881: || getenv ("DEPENDENCIES_OUTPUT") != 0)) { ! 1882: char *spec = getenv ("DEPENDENCIES_OUTPUT"); ! 1883: char *s; ! 1884: char *output_file; ! 1885: ! 1886: if (spec == 0) { ! 1887: spec = getenv ("SUNPRO_DEPENDENCIES"); ! 1888: print_deps = 2; ! 1889: } ! 1890: else ! 1891: print_deps = 1; ! 1892: ! 1893: s = spec; ! 1894: /* Find the space before the DEPS_TARGET, if there is one. */ ! 1895: /* This should use index. (mrs) */ ! 1896: while (*s != 0 && *s != ' ') s++; ! 1897: if (*s != 0) { ! 1898: deps_target = s + 1; ! 1899: output_file = (char *) xmalloc (s - spec + 1); ! 1900: bcopy (spec, output_file, s - spec); ! 1901: output_file[s - spec] = 0; ! 1902: } ! 1903: else { ! 1904: deps_target = 0; ! 1905: output_file = spec; ! 1906: } ! 1907: ! 1908: deps_file = output_file; ! 1909: deps_mode = "a"; ! 1910: } ! 1911: ! 1912: /* For -M, print the expected object file name ! 1913: as the target of this Make-rule. */ ! 1914: if (print_deps) { ! 1915: deps_allocated_size = 200; ! 1916: deps_buffer = (char *) xmalloc (deps_allocated_size); ! 1917: deps_buffer[0] = 0; ! 1918: deps_size = 0; ! 1919: deps_column = 0; ! 1920: ! 1921: if (deps_target) { ! 1922: deps_output (deps_target, 0); ! 1923: deps_output (":", 0); ! 1924: } else if (*in_fname == 0) ! 1925: deps_output ("-: ", 0); ! 1926: else { ! 1927: int len; ! 1928: char *p = in_fname; ! 1929: char *p1 = p; ! 1930: /* Discard all directory prefixes from P. */ ! 1931: while (*p1) { ! 1932: if (*p1 == '/') ! 1933: p = p1 + 1; ! 1934: p1++; ! 1935: } ! 1936: /* Output P, but remove known suffixes. */ ! 1937: len = strlen (p); ! 1938: if (p[len - 2] == '.' && p[len - 1] == 'c') ! 1939: deps_output (p, len - 2); ! 1940: else if (p[len - 2] == '.' && p[len - 1] == 'C') ! 1941: deps_output (p, len - 2); ! 1942: else if (p[len - 3] == '.' ! 1943: && p[len - 2] == 'c' ! 1944: && p[len - 1] == 'c') ! 1945: deps_output (p, len - 3); ! 1946: else if (p[len - 4] == '.' ! 1947: && p[len - 3] == 'c' ! 1948: && p[len - 2] == 'x' ! 1949: && p[len - 1] == 'x') ! 1950: deps_output (p, len - 4); ! 1951: else if (p[len - 2] == '.' && p[len - 1] == 's') ! 1952: deps_output (p, len - 2); ! 1953: else if (p[len - 2] == '.' && p[len - 1] == 'S') ! 1954: deps_output (p, len - 2); ! 1955: else if (p[len - 2] == '.' && p[len - 1] == 'm') ! 1956: deps_output (p, len - 2); ! 1957: else ! 1958: deps_output (p, 0); ! 1959: /* Supply our own suffix. */ ! 1960: #ifndef VMS ! 1961: deps_output (".o : ", 0); ! 1962: #else ! 1963: deps_output (".obj : ", 0); ! 1964: #endif ! 1965: deps_output (in_fname, 0); ! 1966: deps_output (" ", 0); ! 1967: } ! 1968: } ! 1969: ! 1970: file_size_and_mode (f, &st_mode, &st_size); ! 1971: fp->nominal_fname = fp->fname = in_fname; ! 1972: fp->lineno = 1; ! 1973: fp->system_header_p = 0; ! 1974: /* JF all this is mine about reading pipes and ttys */ ! 1975: if (! S_ISREG (st_mode)) { ! 1976: /* Read input from a file that is not a normal disk file. ! 1977: We cannot preallocate a buffer with the correct size, ! 1978: so we must read in the file a piece at the time and make it bigger. */ ! 1979: int size; ! 1980: int bsize; ! 1981: int cnt; ! 1982: U_CHAR *bufp; ! 1983: ! 1984: bsize = 2000; ! 1985: size = 0; ! 1986: fp->buf = (U_CHAR *) xmalloc (bsize + 2); ! 1987: bufp = fp->buf; ! 1988: for (;;) { ! 1989: cnt = safe_read (f, bufp, bsize - size); ! 1990: if (cnt < 0) goto perror; /* error! */ ! 1991: if (cnt == 0) break; /* End of file */ ! 1992: size += cnt; ! 1993: bufp += cnt; ! 1994: if (bsize == size) { /* Buffer is full! */ ! 1995: bsize *= 2; ! 1996: fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2); ! 1997: bufp = fp->buf + size; /* May have moved */ ! 1998: } ! 1999: } ! 2000: fp->length = size; ! 2001: } else { ! 2002: /* Read a file whose size we can determine in advance. ! 2003: For the sake of VMS, st_size is just an upper bound. */ ! 2004: long i; ! 2005: fp->length = 0; ! 2006: fp->buf = (U_CHAR *) xmalloc (st_size + 2); ! 2007: ! 2008: while (st_size > 0) { ! 2009: i = safe_read (f, fp->buf + fp->length, st_size); ! 2010: if (i <= 0) { ! 2011: if (i == 0) break; ! 2012: goto perror; ! 2013: } ! 2014: fp->length += i; ! 2015: st_size -= i; ! 2016: } ! 2017: } ! 2018: fp->bufp = fp->buf; ! 2019: fp->if_stack = if_stack; ! 2020: ! 2021: /* Make sure data ends with a newline. And put a null after it. */ ! 2022: ! 2023: if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n') ! 2024: /* Backslash-newline at end is not good enough. */ ! 2025: || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) { ! 2026: fp->buf[fp->length++] = '\n'; ! 2027: missing_newline = 1; ! 2028: } ! 2029: fp->buf[fp->length] = '\0'; ! 2030: ! 2031: /* Unless inhibited, convert trigraphs in the input. */ ! 2032: ! 2033: if (!no_trigraphs) ! 2034: trigraph_pcp (fp); ! 2035: ! 2036: #ifdef NEXT_SEMANTICS ! 2037: if (!no_rtf) ! 2038: buf_convert_rtf (fp); ! 2039: #endif ! 2040: ! 2041: /* Now that we know the input file is valid, open the output. */ ! 2042: ! 2043: if (!out_fname || !strcmp (out_fname, "")) ! 2044: out_fname = "stdout"; ! 2045: else if (! freopen (out_fname, "w", stdout)) ! 2046: pfatal_with_name (out_fname); ! 2047: ! 2048: output_line_command (fp, &outbuf, 0, same_file); ! 2049: ! 2050: /* Scan the -include files before the main input. */ ! 2051: ! 2052: for (i = 1; i < argc; i++) ! 2053: if (pend_includes[i]) { ! 2054: int fd = open (pend_includes[i], O_RDONLY, 0666); ! 2055: if (fd < 0) { ! 2056: perror_with_name (pend_includes[i]); ! 2057: return FAILURE_EXIT_CODE; ! 2058: } ! 2059: finclude (fd, pend_includes[i], &outbuf, 0, NULL_PTR); ! 2060: } ! 2061: ! 2062: /* Scan the input, processing macros and directives. */ ! 2063: ! 2064: rescan (&outbuf, 0); ! 2065: ! 2066: if (missing_newline) ! 2067: fp->lineno--; ! 2068: ! 2069: if (pedantic && missing_newline) ! 2070: pedwarn ("file does not end in newline"); ! 2071: ! 2072: /* Now we have processed the entire input ! 2073: Write whichever kind of output has been requested. */ ! 2074: ! 2075: if (dump_macros == dump_only) ! 2076: dump_all_macros (); ! 2077: else if (! inhibit_output) { ! 2078: write_output (); ! 2079: } ! 2080: ! 2081: if (print_deps) { ! 2082: /* Don't actually write the deps file if compilation has failed. */ ! 2083: if (errors == 0) { ! 2084: if (deps_file && ! (deps_stream = fopen (deps_file, deps_mode))) ! 2085: pfatal_with_name (deps_file); ! 2086: fputs (deps_buffer, deps_stream); ! 2087: putc ('\n', deps_stream); ! 2088: if (deps_file) { ! 2089: if (ferror (deps_stream) || fclose (deps_stream) != 0) ! 2090: fatal ("I/O error on output"); ! 2091: } ! 2092: } ! 2093: } ! 2094: ! 2095: if (pcp_outfile && pcp_outfile != stdout ! 2096: && (ferror (pcp_outfile) || fclose (pcp_outfile) != 0)) ! 2097: fatal ("I/O error on `-pcp' output"); ! 2098: ! 2099: if (ferror (stdout) || fclose (stdout) != 0) ! 2100: fatal ("I/O error on output"); ! 2101: ! 2102: if (errors) ! 2103: exit (FAILURE_EXIT_CODE); ! 2104: exit (SUCCESS_EXIT_CODE); ! 2105: ! 2106: perror: ! 2107: pfatal_with_name (in_fname); ! 2108: return 0; ! 2109: } ! 2110: ! 2111: /* Given a colon-separated list of file names PATH, ! 2112: add all the names to the search path for include files. */ ! 2113: ! 2114: static void ! 2115: path_include (path) ! 2116: char *path; ! 2117: { ! 2118: char *p; ! 2119: ! 2120: p = path; ! 2121: ! 2122: if (*p) ! 2123: while (1) { ! 2124: char *q = p; ! 2125: char *name; ! 2126: struct file_name_list *dirtmp; ! 2127: ! 2128: /* Find the end of this name. */ ! 2129: while (*q != 0 && *q != PATH_SEPARATOR) q++; ! 2130: if (p == q) { ! 2131: /* An empty name in the path stands for the current directory. */ ! 2132: name = (char *) xmalloc (2); ! 2133: name[0] = '.'; ! 2134: name[1] = 0; ! 2135: } else { ! 2136: /* Otherwise use the directory that is named. */ ! 2137: name = (char *) xmalloc (q - p + 1); ! 2138: bcopy (p, name, q - p); ! 2139: name[q - p] = 0; ! 2140: } ! 2141: ! 2142: dirtmp = (struct file_name_list *) ! 2143: xmalloc (sizeof (struct file_name_list)); ! 2144: dirtmp->next = 0; /* New one goes on the end */ ! 2145: dirtmp->control_macro = 0; ! 2146: dirtmp->c_system_include_path = 0; ! 2147: dirtmp->fname = name; ! 2148: append_include_chain (dirtmp, dirtmp); ! 2149: ! 2150: /* Advance past this name. */ ! 2151: p = q; ! 2152: if (*p == 0) ! 2153: break; ! 2154: /* Skip the colon. */ ! 2155: p++; ! 2156: } ! 2157: } ! 2158: ! 2159: /* Pre-C-Preprocessor to translate ANSI trigraph idiocy in BUF ! 2160: before main CCCP processing. Name `pcp' is also in honor of the ! 2161: drugs the trigraph designers must have been on. ! 2162: ! 2163: Using an extra pass through the buffer takes a little extra time, ! 2164: but is infinitely less hairy than trying to handle trigraphs inside ! 2165: strings, etc. everywhere, and also makes sure that trigraphs are ! 2166: only translated in the top level of processing. */ ! 2167: ! 2168: static void ! 2169: trigraph_pcp (buf) ! 2170: FILE_BUF *buf; ! 2171: { ! 2172: register U_CHAR c, *fptr, *bptr, *sptr; ! 2173: int len; ! 2174: ! 2175: fptr = bptr = sptr = buf->buf; ! 2176: while ((sptr = (U_CHAR *) index (sptr, '?')) != NULL) { ! 2177: if (*++sptr != '?') ! 2178: continue; ! 2179: switch (*++sptr) { ! 2180: case '=': ! 2181: c = '#'; ! 2182: break; ! 2183: case '(': ! 2184: c = '['; ! 2185: break; ! 2186: case '/': ! 2187: c = '\\'; ! 2188: break; ! 2189: case ')': ! 2190: c = ']'; ! 2191: break; ! 2192: case '\'': ! 2193: c = '^'; ! 2194: break; ! 2195: case '<': ! 2196: c = '{'; ! 2197: break; ! 2198: case '!': ! 2199: c = '|'; ! 2200: break; ! 2201: case '>': ! 2202: c = '}'; ! 2203: break; ! 2204: case '-': ! 2205: c = '~'; ! 2206: break; ! 2207: case '?': ! 2208: sptr--; ! 2209: continue; ! 2210: default: ! 2211: continue; ! 2212: } ! 2213: len = sptr - fptr - 2; ! 2214: if (bptr != fptr && len > 0) ! 2215: bcopy (fptr, bptr, len); /* BSD doc says bcopy () works right ! 2216: for overlapping strings. In ANSI ! 2217: C, this will be memmove (). */ ! 2218: bptr += len; ! 2219: *bptr++ = c; ! 2220: fptr = ++sptr; ! 2221: } ! 2222: len = buf->length - (fptr - buf->buf); ! 2223: if (bptr != fptr && len > 0) ! 2224: bcopy (fptr, bptr, len); ! 2225: buf->length -= fptr - bptr; ! 2226: buf->buf[buf->length] = '\0'; ! 2227: if (warn_trigraphs && fptr != bptr) ! 2228: warning ("%d trigraph(s) encountered", (fptr - bptr) / 2); ! 2229: } ! 2230: ! 2231: /* Move all backslash-newline pairs out of embarrassing places. ! 2232: Exchange all such pairs following BP ! 2233: with any potentially-embarrassing characters that follow them. ! 2234: Potentially-embarrassing characters are / and * ! 2235: (because a backslash-newline inside a comment delimiter ! 2236: would cause it not to be recognized). */ ! 2237: ! 2238: static void ! 2239: newline_fix (bp) ! 2240: U_CHAR *bp; ! 2241: { ! 2242: register U_CHAR *p = bp; ! 2243: register int count = 0; ! 2244: ! 2245: /* First count the backslash-newline pairs here. */ ! 2246: ! 2247: while (1) { ! 2248: if (p[0] == '\\') { ! 2249: if (p[1] == '\n') ! 2250: p += 2, count++; ! 2251: else if (p[1] == '\r' && p[2] == '\n') ! 2252: p += 3, count++; ! 2253: else ! 2254: break; ! 2255: } else ! 2256: break; ! 2257: } ! 2258: ! 2259: /* What follows the backslash-newlines is not embarrassing. */ ! 2260: ! 2261: if (count == 0 || (*p != '/' && *p != '*')) ! 2262: return; ! 2263: ! 2264: /* Copy all potentially embarrassing characters ! 2265: that follow the backslash-newline pairs ! 2266: down to where the pairs originally started. */ ! 2267: ! 2268: while (*p == '*' || *p == '/') ! 2269: *bp++ = *p++; ! 2270: ! 2271: /* Now write the same number of pairs after the embarrassing chars. */ ! 2272: while (count-- > 0) { ! 2273: *bp++ = '\\'; ! 2274: *bp++ = '\n'; ! 2275: } ! 2276: } ! 2277: ! 2278: /* Like newline_fix but for use within a directive-name. ! 2279: Move any backslash-newlines up past any following symbol constituents. */ ! 2280: ! 2281: static void ! 2282: name_newline_fix (bp) ! 2283: U_CHAR *bp; ! 2284: { ! 2285: register U_CHAR *p = bp; ! 2286: register int count = 0; ! 2287: ! 2288: /* First count the backslash-newline pairs here. */ ! 2289: while (1) { ! 2290: if (p[0] == '\\') { ! 2291: if (p[1] == '\n') ! 2292: p += 2, count++; ! 2293: else if (p[1] == '\r' && p[2] == '\n') ! 2294: p += 3, count++; ! 2295: else ! 2296: break; ! 2297: } else ! 2298: break; ! 2299: } ! 2300: ! 2301: /* What follows the backslash-newlines is not embarrassing. */ ! 2302: ! 2303: if (count == 0 || !is_idchar[*p]) ! 2304: return; ! 2305: ! 2306: /* Copy all potentially embarrassing characters ! 2307: that follow the backslash-newline pairs ! 2308: down to where the pairs originally started. */ ! 2309: ! 2310: while (is_idchar[*p]) ! 2311: *bp++ = *p++; ! 2312: ! 2313: /* Now write the same number of pairs after the embarrassing chars. */ ! 2314: while (count-- > 0) { ! 2315: *bp++ = '\\'; ! 2316: *bp++ = '\n'; ! 2317: } ! 2318: } ! 2319: ! 2320: /* Look for lint commands in comments. ! 2321: ! 2322: When we come in here, ibp points into a comment. Limit is as one expects. ! 2323: scan within the comment -- it should start, after lwsp, with a lint command. ! 2324: If so that command is returned as a (constant) string. ! 2325: ! 2326: Upon return, any arg will be pointed to with argstart and will be ! 2327: arglen long. Note that we don't parse that arg since it will just ! 2328: be printed out again. ! 2329: */ ! 2330: ! 2331: static char * ! 2332: get_lintcmd (ibp, limit, argstart, arglen, cmdlen) ! 2333: register U_CHAR *ibp; ! 2334: register U_CHAR *limit; ! 2335: U_CHAR **argstart; /* point to command arg */ ! 2336: int *arglen, *cmdlen; /* how long they are */ ! 2337: { ! 2338: long linsize; ! 2339: register U_CHAR *numptr; /* temp for arg parsing */ ! 2340: ! 2341: *arglen = 0; ! 2342: ! 2343: SKIP_WHITE_SPACE (ibp); ! 2344: ! 2345: if (ibp >= limit) return NULL; ! 2346: ! 2347: linsize = limit - ibp; ! 2348: ! 2349: /* Oh, I wish C had lexical functions... hell, I'll just open-code the set */ ! 2350: if ((linsize >= 10) && !strncmp (ibp, "NOTREACHED", 10)) { ! 2351: *cmdlen = 10; ! 2352: return "NOTREACHED"; ! 2353: } ! 2354: if ((linsize >= 8) && !strncmp (ibp, "ARGSUSED", 8)) { ! 2355: *cmdlen = 8; ! 2356: return "ARGSUSED"; ! 2357: } ! 2358: if ((linsize >= 11) && !strncmp (ibp, "LINTLIBRARY", 11)) { ! 2359: *cmdlen = 11; ! 2360: return "LINTLIBRARY"; ! 2361: } ! 2362: if ((linsize >= 7) && !strncmp (ibp, "VARARGS", 7)) { ! 2363: *cmdlen = 7; ! 2364: ibp += 7; linsize -= 7; ! 2365: if ((linsize == 0) || ! isdigit (*ibp)) return "VARARGS"; ! 2366: ! 2367: /* OK, read a number */ ! 2368: for (numptr = *argstart = ibp; (numptr < limit) && isdigit (*numptr); ! 2369: numptr++); ! 2370: *arglen = numptr - *argstart; ! 2371: return "VARARGS"; ! 2372: } ! 2373: return NULL; ! 2374: } ! 2375: ! 2376: /* ! 2377: * The main loop of the program. ! 2378: * ! 2379: * Read characters from the input stack, transferring them to the ! 2380: * output buffer OP. ! 2381: * ! 2382: * Macros are expanded and push levels on the input stack. ! 2383: * At the end of such a level it is popped off and we keep reading. ! 2384: * At the end of any other kind of level, we return. ! 2385: * #-directives are handled, except within macros. ! 2386: * ! 2387: * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input ! 2388: * and insert them when appropriate. This is set while scanning macro ! 2389: * arguments before substitution. It is zero when scanning for final output. ! 2390: * There are three types of Newline markers: ! 2391: * * Newline - follows a macro name that was not expanded ! 2392: * because it appeared inside an expansion of the same macro. ! 2393: * This marker prevents future expansion of that identifier. ! 2394: * When the input is rescanned into the final output, these are deleted. ! 2395: * These are also deleted by ## concatenation. ! 2396: * * Newline Space (or Newline and any other whitespace character) ! 2397: * stands for a place that tokens must be separated or whitespace ! 2398: * is otherwise desirable, but where the ANSI standard specifies there ! 2399: * is no whitespace. This marker turns into a Space (or whichever other ! 2400: * whitespace char appears in the marker) in the final output, ! 2401: * but it turns into nothing in an argument that is stringified with #. ! 2402: * Such stringified arguments are the only place where the ANSI standard ! 2403: * specifies with precision that whitespace may not appear. ! 2404: * ! 2405: * During this function, IP->bufp is kept cached in IBP for speed of access. ! 2406: * Likewise, OP->bufp is kept in OBP. Before calling a subroutine ! 2407: * IBP, IP and OBP must be copied back to memory. IP and IBP are ! 2408: * copied back with the RECACHE macro. OBP must be copied back from OP->bufp ! 2409: * explicitly, and before RECACHE, since RECACHE uses OBP. ! 2410: */ ! 2411: ! 2412: static void ! 2413: rescan (op, output_marks) ! 2414: FILE_BUF *op; ! 2415: int output_marks; ! 2416: { ! 2417: /* Character being scanned in main loop. */ ! 2418: register U_CHAR c; ! 2419: ! 2420: /* Length of pending accumulated identifier. */ ! 2421: register int ident_length = 0; ! 2422: ! 2423: /* Hash code of pending accumulated identifier. */ ! 2424: register int hash = 0; ! 2425: ! 2426: /* Current input level (&instack[indepth]). */ ! 2427: FILE_BUF *ip; ! 2428: ! 2429: /* Pointer for scanning input. */ ! 2430: register U_CHAR *ibp; ! 2431: ! 2432: /* Pointer to end of input. End of scan is controlled by LIMIT. */ ! 2433: register U_CHAR *limit; ! 2434: ! 2435: /* Pointer for storing output. */ ! 2436: register U_CHAR *obp; ! 2437: ! 2438: /* REDO_CHAR is nonzero if we are processing an identifier ! 2439: after backing up over the terminating character. ! 2440: Sometimes we process an identifier without backing up over ! 2441: the terminating character, if the terminating character ! 2442: is not special. Backing up is done so that the terminating character ! 2443: will be dispatched on again once the identifier is dealt with. */ ! 2444: int redo_char = 0; ! 2445: ! 2446: /* 1 if within an identifier inside of which a concatenation ! 2447: marker (Newline -) has been seen. */ ! 2448: int concatenated = 0; ! 2449: ! 2450: /* While scanning a comment or a string constant, ! 2451: this records the line it started on, for error messages. */ ! 2452: int start_line; ! 2453: ! 2454: /* Record position of last `real' newline. */ ! 2455: U_CHAR *beg_of_line; ! 2456: ! 2457: /* Pop the innermost input stack level, assuming it is a macro expansion. */ ! 2458: ! 2459: #define POPMACRO \ ! 2460: do { ip->macro->type = T_MACRO; \ ! 2461: if (ip->free_ptr) free (ip->free_ptr); \ ! 2462: --indepth; } while (0) ! 2463: ! 2464: /* Reload `rescan's local variables that describe the current ! 2465: level of the input stack. */ ! 2466: ! 2467: #define RECACHE \ ! 2468: do { ip = &instack[indepth]; \ ! 2469: ibp = ip->bufp; \ ! 2470: limit = ip->buf + ip->length; \ ! 2471: op->bufp = obp; \ ! 2472: check_expand (op, limit - ibp); \ ! 2473: beg_of_line = 0; \ ! 2474: obp = op->bufp; } while (0) ! 2475: ! 2476: if (no_output && instack[indepth].fname != 0) ! 2477: skip_if_group (&instack[indepth], 1); ! 2478: ! 2479: obp = op->bufp; ! 2480: RECACHE; ! 2481: ! 2482: beg_of_line = ibp; ! 2483: ! 2484: /* Our caller must always put a null after the end of ! 2485: the input at each input stack level. */ ! 2486: if (*limit != 0) ! 2487: abort (); ! 2488: ! 2489: while (1) { ! 2490: c = *ibp++; ! 2491: *obp++ = c; ! 2492: ! 2493: switch (c) { ! 2494: case '\\': ! 2495: if (ibp >= limit) ! 2496: break; ! 2497: if (*ibp == '\n') { ! 2498: /* Always merge lines ending with backslash-newline, ! 2499: even in middle of identifier. */ ! 2500: ++ibp; ! 2501: ++ip->lineno; ! 2502: --obp; /* remove backslash from obuf */ ! 2503: break; ! 2504: } ! 2505: /* Otherwise, backslash suppresses specialness of following char, ! 2506: so copy it here to prevent the switch from seeing it. ! 2507: But first get any pending identifier processed. */ ! 2508: if (ident_length > 0) ! 2509: goto specialchar; ! 2510: *obp++ = *ibp++; ! 2511: break; ! 2512: ! 2513: case '#': ! 2514: if (assertions_flag) { ! 2515: /* Copy #foo (bar lose) without macro expansion. */ ! 2516: SKIP_WHITE_SPACE (ibp); ! 2517: while (is_idchar[*ibp]) ! 2518: *obp++ = *ibp++; ! 2519: SKIP_WHITE_SPACE (ibp); ! 2520: if (*ibp == '(') { ! 2521: ip->bufp = ibp; ! 2522: skip_paren_group (ip); ! 2523: bcopy (ibp, obp, ip->bufp - ibp); ! 2524: obp += ip->bufp - ibp; ! 2525: ibp = ip->bufp; ! 2526: } ! 2527: } ! 2528: ! 2529: /* If this is expanding a macro definition, don't recognize ! 2530: preprocessor directives. */ ! 2531: if (ip->macro != 0) ! 2532: goto randomchar; ! 2533: /* If this is expand_into_temp_buffer, recognize them ! 2534: only after an actual newline at this level, ! 2535: not at the beginning of the input level. */ ! 2536: if (ip->fname == 0 && beg_of_line == ip->buf) ! 2537: goto randomchar; ! 2538: if (ident_length) ! 2539: goto specialchar; ! 2540: ! 2541: ! 2542: /* # keyword: a # must be first nonblank char on the line */ ! 2543: if (beg_of_line == 0) ! 2544: goto randomchar; ! 2545: { ! 2546: U_CHAR *bp; ! 2547: ! 2548: /* Scan from start of line, skipping whitespace, comments ! 2549: and backslash-newlines, and see if we reach this #. ! 2550: If not, this # is not special. */ ! 2551: bp = beg_of_line; ! 2552: /* If -traditional, require # to be at beginning of line. */ ! 2553: if (!traditional) ! 2554: while (1) { ! 2555: if (is_hor_space[*bp]) ! 2556: bp++; ! 2557: else if (*bp == '\\' && bp[1] == '\n') ! 2558: bp += 2; ! 2559: else if (*bp == '/' && bp[1] == '*') { ! 2560: bp += 2; ! 2561: while (!(*bp == '*' && bp[1] == '/')) ! 2562: bp++; ! 2563: bp += 2; ! 2564: } ! 2565: else if (cplusplus_comments && *bp == '/' && bp[1] == '/') { ! 2566: bp += 2; ! 2567: while (*bp++ != '\n') ; ! 2568: } ! 2569: else break; ! 2570: } ! 2571: if (bp + 1 != ibp) ! 2572: goto randomchar; ! 2573: } ! 2574: ! 2575: /* This # can start a directive. */ ! 2576: ! 2577: --obp; /* Don't copy the '#' */ ! 2578: ! 2579: ip->bufp = ibp; ! 2580: op->bufp = obp; ! 2581: if (! handle_directive (ip, op)) { ! 2582: #ifdef USE_C_ALLOCA ! 2583: alloca (0); ! 2584: #endif ! 2585: /* Not a known directive: treat it as ordinary text. ! 2586: IP, OP, IBP, etc. have not been changed. */ ! 2587: if (no_output && instack[indepth].fname) { ! 2588: /* If not generating expanded output, ! 2589: what we do with ordinary text is skip it. ! 2590: Discard everything until next # directive. */ ! 2591: skip_if_group (&instack[indepth], 1); ! 2592: RECACHE; ! 2593: beg_of_line = ibp; ! 2594: break; ! 2595: } ! 2596: ++obp; /* Copy the '#' after all */ ! 2597: /* Don't expand an identifier that could be a macro directive. ! 2598: (Section 3.8.3 of the ANSI C standard) */ ! 2599: SKIP_WHITE_SPACE (ibp); ! 2600: if (is_idstart[*ibp]) ! 2601: { ! 2602: *obp++ = *ibp++; ! 2603: while (is_idchar[*ibp]) ! 2604: *obp++ = *ibp++; ! 2605: } ! 2606: goto randomchar; ! 2607: } ! 2608: #ifdef USE_C_ALLOCA ! 2609: alloca (0); ! 2610: #endif ! 2611: /* A # directive has been successfully processed. */ ! 2612: /* If not generating expanded output, ignore everything until ! 2613: next # directive. */ ! 2614: if (no_output && instack[indepth].fname) ! 2615: skip_if_group (&instack[indepth], 1); ! 2616: obp = op->bufp; ! 2617: RECACHE; ! 2618: beg_of_line = ibp; ! 2619: break; ! 2620: ! 2621: case '\"': /* skip quoted string */ ! 2622: case '\'': ! 2623: /* A single quoted string is treated like a double -- some ! 2624: programs (e.g., troff) are perverse this way */ ! 2625: ! 2626: if (ident_length) ! 2627: goto specialchar; ! 2628: ! 2629: start_line = ip->lineno; ! 2630: ! 2631: /* Skip ahead to a matching quote. */ ! 2632: ! 2633: while (1) { ! 2634: if (ibp >= limit) { ! 2635: if (ip->macro != 0) { ! 2636: /* try harder: this string crosses a macro expansion boundary. ! 2637: This can happen naturally if -traditional. ! 2638: Otherwise, only -D can make a macro with an unmatched quote. */ ! 2639: POPMACRO; ! 2640: RECACHE; ! 2641: continue; ! 2642: } ! 2643: if (!traditional) { ! 2644: error_with_line (line_for_error (start_line), ! 2645: "unterminated string or character constant"); ! 2646: error_with_line (multiline_string_line, ! 2647: "possible real start of unterminated constant"); ! 2648: multiline_string_line = 0; ! 2649: } ! 2650: break; ! 2651: } ! 2652: *obp++ = *ibp; ! 2653: switch (*ibp++) { ! 2654: case '\n': ! 2655: ++ip->lineno; ! 2656: ++op->lineno; ! 2657: /* Traditionally, end of line ends a string constant with no error. ! 2658: So exit the loop and record the new line. */ ! 2659: if (traditional) { ! 2660: beg_of_line = ibp; ! 2661: goto while2end; ! 2662: } ! 2663: if (c == '\'') { ! 2664: error_with_line (line_for_error (start_line), ! 2665: "unterminated character constant"); ! 2666: goto while2end; ! 2667: } ! 2668: if (pedantic && multiline_string_line == 0) { ! 2669: pedwarn_with_line (line_for_error (start_line), ! 2670: "string constant runs past end of line"); ! 2671: } ! 2672: if (multiline_string_line == 0) ! 2673: multiline_string_line = ip->lineno - 1; ! 2674: break; ! 2675: ! 2676: case '\\': ! 2677: if (ibp >= limit) ! 2678: break; ! 2679: if (*ibp == '\n') { ! 2680: /* Backslash newline is replaced by nothing at all, ! 2681: but keep the line counts correct. */ ! 2682: --obp; ! 2683: ++ibp; ! 2684: ++ip->lineno; ! 2685: } else { ! 2686: /* ANSI stupidly requires that in \\ the second \ ! 2687: is *not* prevented from combining with a newline. */ ! 2688: while (*ibp == '\\' && ibp[1] == '\n') { ! 2689: ibp += 2; ! 2690: ++ip->lineno; ! 2691: } ! 2692: *obp++ = *ibp++; ! 2693: } ! 2694: break; ! 2695: ! 2696: case '\"': ! 2697: case '\'': ! 2698: if (ibp[-1] == c) ! 2699: goto while2end; ! 2700: break; ! 2701: } ! 2702: } ! 2703: while2end: ! 2704: break; ! 2705: ! 2706: case '/': ! 2707: if (*ibp == '\\' && ibp[1] == '\n') ! 2708: newline_fix (ibp); ! 2709: ! 2710: if (*ibp != '*' ! 2711: && !(cplusplus_comments && *ibp == '/')) ! 2712: goto randomchar; ! 2713: if (ip->macro != 0) ! 2714: goto randomchar; ! 2715: if (ident_length) ! 2716: goto specialchar; ! 2717: ! 2718: if (*ibp == '/') { ! 2719: /* C++ style comment... */ ! 2720: start_line = ip->lineno; ! 2721: ! 2722: --ibp; /* Back over the slash */ ! 2723: --obp; ! 2724: ! 2725: /* Comments are equivalent to spaces. */ ! 2726: if (! put_out_comments) ! 2727: *obp++ = ' '; ! 2728: else { ! 2729: /* must fake up a comment here */ ! 2730: *obp++ = '/'; ! 2731: *obp++ = '/'; ! 2732: } ! 2733: { ! 2734: U_CHAR *before_bp = ibp+2; ! 2735: ! 2736: while (ibp < limit) { ! 2737: if (*ibp++ == '\n') { ! 2738: ibp--; ! 2739: if (put_out_comments) { ! 2740: bcopy (before_bp, obp, ibp - before_bp); ! 2741: obp += ibp - before_bp; ! 2742: } ! 2743: break; ! 2744: } ! 2745: } ! 2746: break; ! 2747: } ! 2748: } ! 2749: ! 2750: /* Ordinary C comment. Skip it, optionally copying it to output. */ ! 2751: ! 2752: start_line = ip->lineno; ! 2753: ! 2754: ++ibp; /* Skip the star. */ ! 2755: ! 2756: /* If this cpp is for lint, we peek inside the comments: */ ! 2757: if (lint) { ! 2758: U_CHAR *argbp; ! 2759: int cmdlen, arglen; ! 2760: char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen); ! 2761: ! 2762: if (lintcmd != NULL) { ! 2763: /* I believe it is always safe to emit this newline: */ ! 2764: obp[-1] = '\n'; ! 2765: bcopy ("#pragma lint ", obp, 13); ! 2766: obp += 13; ! 2767: bcopy (lintcmd, obp, cmdlen); ! 2768: obp += cmdlen; ! 2769: ! 2770: if (arglen != 0) { ! 2771: *(obp++) = ' '; ! 2772: bcopy (argbp, obp, arglen); ! 2773: obp += arglen; ! 2774: } ! 2775: ! 2776: /* OK, now bring us back to the state we were in before we entered ! 2777: this branch. We need #line b/c the newline for the pragma ! 2778: could fuck things up. */ ! 2779: output_line_command (ip, op, 0, same_file); ! 2780: *(obp++) = ' '; /* just in case, if comments are copied thru */ ! 2781: *(obp++) = '/'; ! 2782: } ! 2783: } ! 2784: ! 2785: /* Comments are equivalent to spaces. ! 2786: Note that we already output the slash; we might not want it. ! 2787: For -traditional, a comment is equivalent to nothing. */ ! 2788: if (! put_out_comments) { ! 2789: if (traditional) ! 2790: obp--; ! 2791: else ! 2792: obp[-1] = ' '; ! 2793: } ! 2794: else ! 2795: *obp++ = '*'; ! 2796: ! 2797: { ! 2798: U_CHAR *before_bp = ibp; ! 2799: ! 2800: while (ibp < limit) { ! 2801: switch (*ibp++) { ! 2802: case '/': ! 2803: if (warn_comments && ibp < limit && *ibp == '*') ! 2804: warning ("`/*' within comment"); ! 2805: break; ! 2806: case '*': ! 2807: if (*ibp == '\\' && ibp[1] == '\n') ! 2808: newline_fix (ibp); ! 2809: if (ibp >= limit || *ibp == '/') ! 2810: goto comment_end; ! 2811: break; ! 2812: case '\n': ! 2813: ++ip->lineno; ! 2814: /* Copy the newline into the output buffer, in order to ! 2815: avoid the pain of a #line every time a multiline comment ! 2816: is seen. */ ! 2817: if (!put_out_comments) ! 2818: *obp++ = '\n'; ! 2819: ++op->lineno; ! 2820: } ! 2821: } ! 2822: comment_end: ! 2823: ! 2824: if (ibp >= limit) ! 2825: error_with_line (line_for_error (start_line), ! 2826: "unterminated comment"); ! 2827: else { ! 2828: ibp++; ! 2829: if (put_out_comments) { ! 2830: bcopy (before_bp, obp, ibp - before_bp); ! 2831: obp += ibp - before_bp; ! 2832: } ! 2833: } ! 2834: } ! 2835: break; ! 2836: ! 2837: case '$': ! 2838: if (!dollars_in_ident) ! 2839: goto randomchar; ! 2840: goto letter; ! 2841: ! 2842: case '0': case '1': case '2': case '3': case '4': ! 2843: case '5': case '6': case '7': case '8': case '9': ! 2844: /* If digit is not part of identifier, it starts a number, ! 2845: which means that following letters are not an identifier. ! 2846: "0x5" does not refer to an identifier "x5". ! 2847: So copy all alphanumerics that follow without accumulating ! 2848: as an identifier. Periods also, for sake of "3.e7". */ ! 2849: ! 2850: if (ident_length == 0) { ! 2851: while (ibp < limit) { ! 2852: while (ibp < limit && ibp[0] == '\\' && ibp[1] == '\n') { ! 2853: ++ip->lineno; ! 2854: ibp += 2; ! 2855: } ! 2856: c = *ibp++; ! 2857: /* ".." terminates a preprocessing number. This is useless for C ! 2858: code but useful for preprocessing other things. */ ! 2859: if (!isalnum (c) && (c != '.' || *ibp == '.') && c != '_') { ! 2860: --ibp; ! 2861: break; ! 2862: } ! 2863: *obp++ = c; ! 2864: /* A sign can be part of a preprocessing number ! 2865: if it follows an e. */ ! 2866: if (c == 'e' || c == 'E') { ! 2867: while (ibp < limit && ibp[0] == '\\' && ibp[1] == '\n') { ! 2868: ++ip->lineno; ! 2869: ibp += 2; ! 2870: } ! 2871: if (ibp < limit && (*ibp == '+' || *ibp == '-')) { ! 2872: *obp++ = *ibp++; ! 2873: /* But traditional C does not let the token go past the sign. */ ! 2874: if (traditional) ! 2875: break; ! 2876: } ! 2877: } ! 2878: } ! 2879: break; ! 2880: } ! 2881: /* fall through */ ! 2882: ! 2883: case '_': ! 2884: case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': ! 2885: case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': ! 2886: case 'm': case 'n': case 'o': case 'p': case 'q': case 'r': ! 2887: case 's': case 't': case 'u': case 'v': case 'w': case 'x': ! 2888: case 'y': case 'z': ! 2889: case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': ! 2890: case 'G': case 'H': case 'I': case 'J': case 'K': case 'L': ! 2891: case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': ! 2892: case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': ! 2893: case 'Y': case 'Z': ! 2894: letter: ! 2895: ident_length++; ! 2896: /* Compute step of hash function, to avoid a proc call on every token */ ! 2897: hash = HASHSTEP (hash, c); ! 2898: break; ! 2899: ! 2900: case '\n': ! 2901: if (ip->fname == 0 && *ibp == '-') { ! 2902: /* Newline - inhibits expansion of preceding token. ! 2903: If expanding a macro arg, we keep the newline -. ! 2904: In final output, it is deleted. ! 2905: We recognize Newline - in macro bodies and macro args. */ ! 2906: if (! concatenated) { ! 2907: ident_length = 0; ! 2908: hash = 0; ! 2909: } ! 2910: ibp++; ! 2911: if (!output_marks) { ! 2912: obp--; ! 2913: } else { ! 2914: /* If expanding a macro arg, keep the newline -. */ ! 2915: *obp++ = '-'; ! 2916: } ! 2917: break; ! 2918: } ! 2919: ! 2920: /* If reprocessing a macro expansion, newline is a special marker. */ ! 2921: else if (ip->macro != 0) { ! 2922: /* Newline White is a "funny space" to separate tokens that are ! 2923: supposed to be separate but without space between. ! 2924: Here White means any whitespace character. ! 2925: Newline - marks a recursive macro use that is not ! 2926: supposed to be expandable. */ ! 2927: ! 2928: if (is_space[*ibp]) { ! 2929: /* Newline Space does not prevent expansion of preceding token ! 2930: so expand the preceding token and then come back. */ ! 2931: if (ident_length > 0) ! 2932: goto specialchar; ! 2933: ! 2934: /* If generating final output, newline space makes a space. */ ! 2935: if (!output_marks) { ! 2936: obp[-1] = *ibp++; ! 2937: /* And Newline Newline makes a newline, so count it. */ ! 2938: if (obp[-1] == '\n') ! 2939: op->lineno++; ! 2940: } else { ! 2941: /* If expanding a macro arg, keep the newline space. ! 2942: If the arg gets stringified, newline space makes nothing. */ ! 2943: *obp++ = *ibp++; ! 2944: } ! 2945: } else abort (); /* Newline followed by something random? */ ! 2946: break; ! 2947: } ! 2948: ! 2949: /* If there is a pending identifier, handle it and come back here. */ ! 2950: if (ident_length > 0) ! 2951: goto specialchar; ! 2952: ! 2953: beg_of_line = ibp; ! 2954: ! 2955: /* Update the line counts and output a #line if necessary. */ ! 2956: ++ip->lineno; ! 2957: ++op->lineno; ! 2958: if (ip->lineno != op->lineno) { ! 2959: op->bufp = obp; ! 2960: output_line_command (ip, op, 1, same_file); ! 2961: check_expand (op, ip->length - (ip->bufp - ip->buf)); ! 2962: obp = op->bufp; ! 2963: } ! 2964: break; ! 2965: ! 2966: /* Come here either after (1) a null character that is part of the input ! 2967: or (2) at the end of the input, because there is a null there. */ ! 2968: case 0: ! 2969: if (ibp <= limit) ! 2970: /* Our input really contains a null character. */ ! 2971: goto randomchar; ! 2972: ! 2973: /* At end of a macro-expansion level, pop it and read next level. */ ! 2974: if (ip->macro != 0) { ! 2975: obp--; ! 2976: ibp--; ! 2977: /* If traditional, and we have an identifier that ends here, ! 2978: process it now, so we get the right error for recursion. */ ! 2979: if (traditional && ident_length ! 2980: && ! is_idchar[*instack[indepth - 1].bufp]) { ! 2981: redo_char = 1; ! 2982: goto randomchar; ! 2983: } ! 2984: POPMACRO; ! 2985: RECACHE; ! 2986: break; ! 2987: } ! 2988: ! 2989: /* If we don't have a pending identifier, ! 2990: return at end of input. */ ! 2991: if (ident_length == 0) { ! 2992: obp--; ! 2993: ibp--; ! 2994: op->bufp = obp; ! 2995: ip->bufp = ibp; ! 2996: goto ending; ! 2997: } ! 2998: ! 2999: /* If we do have a pending identifier, just consider this null ! 3000: a special character and arrange to dispatch on it again. ! 3001: The second time, IDENT_LENGTH will be zero so we will return. */ ! 3002: ! 3003: /* Fall through */ ! 3004: ! 3005: specialchar: ! 3006: ! 3007: /* Handle the case of a character such as /, ', " or null ! 3008: seen following an identifier. Back over it so that ! 3009: after the identifier is processed the special char ! 3010: will be dispatched on again. */ ! 3011: ! 3012: ibp--; ! 3013: obp--; ! 3014: redo_char = 1; ! 3015: ! 3016: default: ! 3017: ! 3018: randomchar: ! 3019: ! 3020: if (ident_length > 0) { ! 3021: register HASHNODE *hp; ! 3022: ! 3023: /* We have just seen an identifier end. If it's a macro, expand it. ! 3024: ! 3025: IDENT_LENGTH is the length of the identifier ! 3026: and HASH is its hash code. ! 3027: ! 3028: The identifier has already been copied to the output, ! 3029: so if it is a macro we must remove it. ! 3030: ! 3031: If REDO_CHAR is 0, the char that terminated the identifier ! 3032: has been skipped in the output and the input. ! 3033: OBP-IDENT_LENGTH-1 points to the identifier. ! 3034: If the identifier is a macro, we must back over the terminator. ! 3035: ! 3036: If REDO_CHAR is 1, the terminating char has already been ! 3037: backed over. OBP-IDENT_LENGTH points to the identifier. */ ! 3038: ! 3039: if (!pcp_outfile || pcp_inside_if) { ! 3040: startagain: ! 3041: for (hp = hashtab[MAKE_POS (hash) % HASHSIZE]; hp != NULL; ! 3042: hp = hp->next) { ! 3043: ! 3044: if (hp->length == ident_length) { ! 3045: int obufp_before_macroname; ! 3046: int op_lineno_before_macroname; ! 3047: register int i = ident_length; ! 3048: register U_CHAR *p = hp->name; ! 3049: register U_CHAR *q = obp - i; ! 3050: int disabled; ! 3051: ! 3052: if (! redo_char) ! 3053: q--; ! 3054: ! 3055: do { /* All this to avoid a strncmp () */ ! 3056: if (*p++ != *q++) ! 3057: goto hashcollision; ! 3058: } while (--i); ! 3059: ! 3060: /* We found a use of a macro name. ! 3061: see if the context shows it is a macro call. */ ! 3062: ! 3063: /* Back up over terminating character if not already done. */ ! 3064: if (! redo_char) { ! 3065: ibp--; ! 3066: obp--; ! 3067: } ! 3068: ! 3069: /* Save this as a displacement from the beginning of the output ! 3070: buffer. We can not save this as a position in the output ! 3071: buffer, because it may get realloc'ed by RECACHE. */ ! 3072: obufp_before_macroname = (obp - op->buf) - ident_length; ! 3073: op_lineno_before_macroname = op->lineno; ! 3074: ! 3075: if (hp->type == T_PCSTRING) { ! 3076: pcstring_used (hp); /* Mark the definition of this key ! 3077: as needed, ensuring that it ! 3078: will be output. */ ! 3079: break; /* Exit loop, since the key cannot have a ! 3080: definition any longer. */ ! 3081: } ! 3082: ! 3083: /* Record whether the macro is disabled. */ ! 3084: disabled = hp->type == T_DISABLED; ! 3085: ! 3086: /* This looks like a macro ref, but if the macro was disabled, ! 3087: just copy its name and put in a marker if requested. */ ! 3088: ! 3089: if (disabled) { ! 3090: #if 0 ! 3091: /* This error check caught useful cases such as ! 3092: #define foo(x,y) bar (x (y,0), y) ! 3093: foo (foo, baz) */ ! 3094: if (traditional) ! 3095: error ("recursive use of macro `%s'", hp->name); ! 3096: #endif ! 3097: ! 3098: if (output_marks) { ! 3099: check_expand (op, limit - ibp + 2); ! 3100: *obp++ = '\n'; ! 3101: *obp++ = '-'; ! 3102: } ! 3103: break; ! 3104: } ! 3105: ! 3106: /* If macro wants an arglist, verify that a '(' follows. ! 3107: first skip all whitespace, copying it to the output ! 3108: after the macro name. Then, if there is no '(', ! 3109: decide this is not a macro call and leave things that way. */ ! 3110: if ((hp->type == T_MACRO || hp->type == T_DISABLED) ! 3111: && hp->value.defn->nargs >= 0) ! 3112: { ! 3113: U_CHAR *old_ibp = ibp; ! 3114: U_CHAR *old_obp = obp; ! 3115: int old_iln = ip->lineno; ! 3116: int old_oln = op->lineno; ! 3117: ! 3118: while (1) { ! 3119: /* Scan forward over whitespace, copying it to the output. */ ! 3120: if (ibp == limit && ip->macro != 0) { ! 3121: POPMACRO; ! 3122: RECACHE; ! 3123: old_ibp = ibp; ! 3124: old_obp = obp; ! 3125: old_iln = ip->lineno; ! 3126: old_oln = op->lineno; ! 3127: } ! 3128: /* A comment: copy it unchanged or discard it. */ ! 3129: else if (*ibp == '/' && ibp+1 != limit && ibp[1] == '*') { ! 3130: if (put_out_comments) { ! 3131: *obp++ = '/'; ! 3132: *obp++ = '*'; ! 3133: } else if (! traditional) { ! 3134: *obp++ = ' '; ! 3135: } ! 3136: ibp += 2; ! 3137: while (ibp + 1 != limit ! 3138: && !(ibp[0] == '*' && ibp[1] == '/')) { ! 3139: /* We need not worry about newline-marks, ! 3140: since they are never found in comments. */ ! 3141: if (*ibp == '\n') { ! 3142: /* Newline in a file. Count it. */ ! 3143: ++ip->lineno; ! 3144: ++op->lineno; ! 3145: } ! 3146: if (put_out_comments) ! 3147: *obp++ = *ibp++; ! 3148: else ! 3149: ibp++; ! 3150: } ! 3151: ibp += 2; ! 3152: if (put_out_comments) { ! 3153: *obp++ = '*'; ! 3154: *obp++ = '/'; ! 3155: } ! 3156: } ! 3157: else if (is_space[*ibp]) { ! 3158: *obp++ = *ibp++; ! 3159: if (ibp[-1] == '\n') { ! 3160: if (ip->macro == 0) { ! 3161: /* Newline in a file. Count it. */ ! 3162: ++ip->lineno; ! 3163: ++op->lineno; ! 3164: } else if (!output_marks) { ! 3165: /* A newline mark, and we don't want marks ! 3166: in the output. If it is newline-hyphen, ! 3167: discard it entirely. Otherwise, it is ! 3168: newline-whitechar, so keep the whitechar. */ ! 3169: obp--; ! 3170: if (*ibp == '-') ! 3171: ibp++; ! 3172: else { ! 3173: if (*ibp == '\n') ! 3174: ++op->lineno; ! 3175: *obp++ = *ibp++; ! 3176: } ! 3177: } else { ! 3178: /* A newline mark; copy both chars to the output. */ ! 3179: *obp++ = *ibp++; ! 3180: } ! 3181: } ! 3182: } ! 3183: else break; ! 3184: } ! 3185: if (*ibp != '(') { ! 3186: /* It isn't a macro call. ! 3187: Put back the space that we just skipped. */ ! 3188: ibp = old_ibp; ! 3189: obp = old_obp; ! 3190: ip->lineno = old_iln; ! 3191: op->lineno = old_oln; ! 3192: /* Exit the for loop. */ ! 3193: break; ! 3194: } ! 3195: } ! 3196: ! 3197: /* This is now known to be a macro call. ! 3198: Discard the macro name from the output, ! 3199: along with any following whitespace just copied. */ ! 3200: obp = op->buf + obufp_before_macroname; ! 3201: op->lineno = op_lineno_before_macroname; ! 3202: ! 3203: /* Prevent accidental token-pasting with a character ! 3204: before the macro call. */ ! 3205: if (!traditional && obp != op->buf ! 3206: && (obp[-1] == '-' || obp[1] == '+' || obp[1] == '&' ! 3207: || obp[-1] == '|' || obp[1] == '<' || obp[1] == '>')) { ! 3208: /* If we are expanding a macro arg, make a newline marker ! 3209: to separate the tokens. If we are making real output, ! 3210: a plain space will do. */ ! 3211: if (output_marks) ! 3212: *obp++ = '\n'; ! 3213: *obp++ = ' '; ! 3214: } ! 3215: ! 3216: /* Expand the macro, reading arguments as needed, ! 3217: and push the expansion on the input stack. */ ! 3218: ip->bufp = ibp; ! 3219: op->bufp = obp; ! 3220: macroexpand (hp, op); ! 3221: ! 3222: /* Reexamine input stack, since macroexpand has pushed ! 3223: a new level on it. */ ! 3224: obp = op->bufp; ! 3225: RECACHE; ! 3226: break; ! 3227: } ! 3228: hashcollision: ! 3229: ; ! 3230: } /* End hash-table-search loop */ ! 3231: } ! 3232: ident_length = hash = 0; /* Stop collecting identifier */ ! 3233: redo_char = 0; ! 3234: concatenated = 0; ! 3235: } /* End if (ident_length > 0) */ ! 3236: } /* End switch */ ! 3237: } /* End per-char loop */ ! 3238: ! 3239: /* Come here to return -- but first give an error message ! 3240: if there was an unterminated successful conditional. */ ! 3241: ending: ! 3242: if (if_stack != ip->if_stack) { ! 3243: char *str; ! 3244: switch (if_stack->type) { ! 3245: case T_IF: ! 3246: str = "if"; ! 3247: break; ! 3248: case T_IFDEF: ! 3249: str = "ifdef"; ! 3250: break; ! 3251: case T_IFNDEF: ! 3252: str = "ifndef"; ! 3253: break; ! 3254: case T_ELSE: ! 3255: str = "else"; ! 3256: break; ! 3257: case T_ELIF: ! 3258: str = "elif"; ! 3259: break; ! 3260: } ! 3261: error_with_line (line_for_error (if_stack->lineno), ! 3262: "unterminated `#%s' conditional", str); ! 3263: } ! 3264: if_stack = ip->if_stack; ! 3265: } ! 3266: ! 3267: /* ! 3268: * Rescan a string into a temporary buffer and return the result ! 3269: * as a FILE_BUF. Note this function returns a struct, not a pointer. ! 3270: * ! 3271: * OUTPUT_MARKS nonzero means keep Newline markers found in the input ! 3272: * and insert such markers when appropriate. See `rescan' for details. ! 3273: * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately ! 3274: * before substitution; it is 0 for other uses. ! 3275: */ ! 3276: static FILE_BUF ! 3277: expand_to_temp_buffer (buf, limit, output_marks, assertions) ! 3278: U_CHAR *buf, *limit; ! 3279: int output_marks, assertions; ! 3280: { ! 3281: register FILE_BUF *ip; ! 3282: FILE_BUF obuf; ! 3283: int length = limit - buf; ! 3284: U_CHAR *buf1; ! 3285: int odepth = indepth; ! 3286: int save_assertions_flag = assertions_flag; ! 3287: ! 3288: assertions_flag = assertions; ! 3289: ! 3290: if (length < 0) ! 3291: abort (); ! 3292: ! 3293: /* Set up the input on the input stack. */ ! 3294: ! 3295: buf1 = (U_CHAR *) alloca (length + 1); ! 3296: { ! 3297: register U_CHAR *p1 = buf; ! 3298: register U_CHAR *p2 = buf1; ! 3299: ! 3300: while (p1 != limit) ! 3301: *p2++ = *p1++; ! 3302: } ! 3303: buf1[length] = 0; ! 3304: ! 3305: /* Set up to receive the output. */ ! 3306: ! 3307: obuf.length = length * 2 + 100; /* Usually enough. Why be stingy? */ ! 3308: obuf.bufp = obuf.buf = (U_CHAR *) xmalloc (obuf.length); ! 3309: obuf.fname = 0; ! 3310: obuf.macro = 0; ! 3311: obuf.free_ptr = 0; ! 3312: ! 3313: CHECK_DEPTH ({return obuf;}); ! 3314: ! 3315: ++indepth; ! 3316: ! 3317: ip = &instack[indepth]; ! 3318: ip->fname = 0; ! 3319: ip->nominal_fname = 0; ! 3320: ip->system_header_p = 0; ! 3321: ip->macro = 0; ! 3322: ip->free_ptr = 0; ! 3323: ip->length = length; ! 3324: ip->buf = ip->bufp = buf1; ! 3325: ip->if_stack = if_stack; ! 3326: ! 3327: ip->lineno = obuf.lineno = 1; ! 3328: ! 3329: /* Scan the input, create the output. */ ! 3330: rescan (&obuf, output_marks); ! 3331: ! 3332: /* Pop input stack to original state. */ ! 3333: --indepth; ! 3334: ! 3335: if (indepth != odepth) ! 3336: abort (); ! 3337: ! 3338: /* Record the output. */ ! 3339: obuf.length = obuf.bufp - obuf.buf; ! 3340: ! 3341: assertions_flag = save_assertions_flag; ! 3342: return obuf; ! 3343: } ! 3344: ! 3345: /* ! 3346: * Process a # directive. Expects IP->bufp to point after the '#', as in ! 3347: * `#define foo bar'. Passes to the command handler ! 3348: * (do_define, do_include, etc.): the addresses of the 1st and ! 3349: * last chars of the command (starting immediately after the # ! 3350: * keyword), plus op and the keyword table pointer. If the command ! 3351: * contains comments it is copied into a temporary buffer sans comments ! 3352: * and the temporary buffer is passed to the command handler instead. ! 3353: * Likewise for backslash-newlines. ! 3354: * ! 3355: * Returns nonzero if this was a known # directive. ! 3356: * Otherwise, returns zero, without advancing the input pointer. ! 3357: */ ! 3358: ! 3359: static int ! 3360: handle_directive (ip, op) ! 3361: FILE_BUF *ip, *op; ! 3362: { ! 3363: register U_CHAR *bp, *cp; ! 3364: register struct directive *kt; ! 3365: register int ident_length; ! 3366: U_CHAR *resume_p; ! 3367: ! 3368: /* Nonzero means we must copy the entire command ! 3369: to get rid of comments or backslash-newlines. */ ! 3370: int copy_command = 0; ! 3371: ! 3372: U_CHAR *ident, *after_ident; ! 3373: ! 3374: bp = ip->bufp; ! 3375: ! 3376: /* Record where the directive started. do_xifdef needs this. */ ! 3377: directive_start = bp - 1; ! 3378: ! 3379: /* Skip whitespace and \-newline. */ ! 3380: while (1) { ! 3381: if (is_hor_space[*bp]) { ! 3382: if ((*bp == '\f' || *bp == '\v') && pedantic) ! 3383: pedwarn ("%s in preprocessing directive", ! 3384: *bp == '\f' ? "formfeed" : "vertical tab"); ! 3385: bp++; ! 3386: } else if (*bp == '/' && bp[1] == '*') { ! 3387: ip->bufp = bp; ! 3388: skip_to_end_of_comment (ip, &ip->lineno, 0); ! 3389: bp = ip->bufp; ! 3390: } else if (*bp == '\\' && bp[1] == '\n') { ! 3391: bp += 2; ip->lineno++; ! 3392: } else break; ! 3393: } ! 3394: ! 3395: /* Now find end of directive name. ! 3396: If we encounter a backslash-newline, exchange it with any following ! 3397: symbol-constituents so that we end up with a contiguous name. */ ! 3398: ! 3399: cp = bp; ! 3400: while (1) { ! 3401: if (is_idchar[*cp]) ! 3402: cp++; ! 3403: else { ! 3404: if (*cp == '\\' && cp[1] == '\n') ! 3405: name_newline_fix (cp); ! 3406: if (is_idchar[*cp]) ! 3407: cp++; ! 3408: else break; ! 3409: } ! 3410: } ! 3411: ident_length = cp - bp; ! 3412: ident = bp; ! 3413: after_ident = cp; ! 3414: ! 3415: /* A line of just `#' becomes blank. */ ! 3416: ! 3417: if (ident_length == 0 && *after_ident == '\n') { ! 3418: ip->bufp = after_ident; ! 3419: return 1; ! 3420: } ! 3421: ! 3422: if (ident_length == 0 || !is_idstart[*ident]) { ! 3423: U_CHAR *p = ident; ! 3424: while (is_idchar[*p]) { ! 3425: if (*p < '0' || *p > '9') ! 3426: break; ! 3427: p++; ! 3428: } ! 3429: /* Handle # followed by a line number. */ ! 3430: if (p != ident && !is_idchar[*p]) { ! 3431: static struct directive line_directive_table[] = { ! 3432: { 4, do_line, "line", T_LINE}, ! 3433: }; ! 3434: if (pedantic) ! 3435: pedwarn ("`#' followed by integer"); ! 3436: after_ident = ident; ! 3437: kt = line_directive_table; ! 3438: goto old_linenum; ! 3439: } ! 3440: ! 3441: /* Avoid error for `###' and similar cases unless -pedantic. */ ! 3442: if (p == ident) { ! 3443: while (*p == '#' || is_hor_space[*p]) p++; ! 3444: if (*p == '\n') { ! 3445: if (pedantic && !lang_asm) ! 3446: warning ("invalid preprocessor directive"); ! 3447: return 0; ! 3448: } ! 3449: } ! 3450: ! 3451: if (!lang_asm) ! 3452: error ("invalid preprocessor directive name"); ! 3453: ! 3454: return 0; ! 3455: } ! 3456: ! 3457: /* ! 3458: * Decode the keyword and call the appropriate expansion ! 3459: * routine, after moving the input pointer up to the next line. ! 3460: */ ! 3461: for (kt = directive_table; kt->length > 0; kt++) { ! 3462: if (kt->length == ident_length && !strncmp (kt->name, ident, ident_length)) { ! 3463: register U_CHAR *buf; ! 3464: register U_CHAR *limit; ! 3465: int unterminated; ! 3466: int junk; ! 3467: int *already_output; ! 3468: ! 3469: /* Nonzero means do not delete comments within the directive. ! 3470: #define needs this when -traditional. */ ! 3471: int keep_comments; ! 3472: ! 3473: old_linenum: ! 3474: ! 3475: limit = ip->buf + ip->length; ! 3476: unterminated = 0; ! 3477: already_output = 0; ! 3478: keep_comments = traditional && kt->traditional_comments; ! 3479: #ifndef NEXT_OBJC_RUNTIME ! 3480: /* #import is defined only in Objective C, or when on the NeXT. */ ! 3481: if (kt->type == T_IMPORT && !(objc || lookup ("__NeXT__", -1, -1))) ! 3482: break; ! 3483: #endif ! 3484: ! 3485: /* Find the end of this command (first newline not backslashed ! 3486: and not in a string or comment). ! 3487: Set COPY_COMMAND if the command must be copied ! 3488: (it contains a backslash-newline or a comment). */ ! 3489: ! 3490: buf = bp = after_ident; ! 3491: while (bp < limit) { ! 3492: register U_CHAR c = *bp++; ! 3493: switch (c) { ! 3494: case '\\': ! 3495: if (bp < limit) { ! 3496: if (*bp == '\n') { ! 3497: ip->lineno++; ! 3498: copy_command = 1; ! 3499: } ! 3500: bp++; ! 3501: } ! 3502: break; ! 3503: ! 3504: case '\'': ! 3505: case '\"': ! 3506: bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, ©_command, &unterminated); ! 3507: /* Don't bother calling the directive if we already got an error ! 3508: message due to unterminated string. Skip everything and pretend ! 3509: we called the directive. */ ! 3510: if (unterminated) { ! 3511: if (traditional) { ! 3512: /* Traditional preprocessing permits unterminated strings. */ ! 3513: ip->bufp = bp; ! 3514: goto endloop1; ! 3515: } ! 3516: ip->bufp = bp; ! 3517: return 1; ! 3518: } ! 3519: break; ! 3520: ! 3521: /* <...> is special for #include. */ ! 3522: case '<': ! 3523: if (!kt->angle_brackets) ! 3524: break; ! 3525: while (*bp && *bp != '>') bp++; ! 3526: break; ! 3527: ! 3528: case '/': ! 3529: if (*bp == '\\' && bp[1] == '\n') ! 3530: newline_fix (bp); ! 3531: if (*bp == '*' ! 3532: || (cplusplus_comments && *bp == '/')) { ! 3533: U_CHAR *obp = bp - 1; ! 3534: ip->bufp = bp + 1; ! 3535: skip_to_end_of_comment (ip, &ip->lineno, 0); ! 3536: bp = ip->bufp; ! 3537: /* No need to copy the command because of a comment at the end; ! 3538: just don't include the comment in the directive. */ ! 3539: if (bp == limit || *bp == '\n') { ! 3540: bp = obp; ! 3541: goto endloop1; ! 3542: } ! 3543: /* Don't remove the comments if -traditional. */ ! 3544: if (! keep_comments) ! 3545: copy_command++; ! 3546: } ! 3547: break; ! 3548: ! 3549: case '\f': ! 3550: case '\v': ! 3551: if (pedantic) ! 3552: pedwarn ("%s in preprocessing directive", ! 3553: c == '\f' ? "formfeed" : "vertical tab"); ! 3554: break; ! 3555: ! 3556: case '\n': ! 3557: --bp; /* Point to the newline */ ! 3558: ip->bufp = bp; ! 3559: goto endloop1; ! 3560: } ! 3561: } ! 3562: ip->bufp = bp; ! 3563: ! 3564: endloop1: ! 3565: resume_p = ip->bufp; ! 3566: /* BP is the end of the directive. ! 3567: RESUME_P is the next interesting data after the directive. ! 3568: A comment may come between. */ ! 3569: ! 3570: /* If a directive should be copied through, and -E was given, ! 3571: pass it through before removing comments. */ ! 3572: if (!no_output && kt->pass_thru && put_out_comments) { ! 3573: int len; ! 3574: ! 3575: /* Output directive name. */ ! 3576: check_expand (op, kt->length + 2); ! 3577: /* Make sure # is at the start of a line */ ! 3578: if (op->bufp > op->buf && op->bufp[-1] != '\n') { ! 3579: op->lineno++; ! 3580: *op->bufp++ = '\n'; ! 3581: } ! 3582: *op->bufp++ = '#'; ! 3583: bcopy (kt->name, op->bufp, kt->length); ! 3584: op->bufp += kt->length; ! 3585: ! 3586: /* Output arguments. */ ! 3587: len = (bp - buf); ! 3588: check_expand (op, len); ! 3589: bcopy (buf, op->bufp, len); ! 3590: op->bufp += len; ! 3591: /* Take account of any (escaped) newlines just output. */ ! 3592: while (--len >= 0) ! 3593: if (buf[len] == '\n') ! 3594: op->lineno++; ! 3595: ! 3596: already_output = &junk; ! 3597: } /* Don't we need a newline or #line? */ ! 3598: ! 3599: if (copy_command) { ! 3600: register U_CHAR *xp = buf; ! 3601: /* Need to copy entire command into temp buffer before dispatching */ ! 3602: ! 3603: cp = (U_CHAR *) alloca (bp - buf + 5); /* room for cmd plus ! 3604: some slop */ ! 3605: buf = cp; ! 3606: ! 3607: /* Copy to the new buffer, deleting comments ! 3608: and backslash-newlines (and whitespace surrounding the latter). */ ! 3609: ! 3610: while (xp < bp) { ! 3611: register U_CHAR c = *xp++; ! 3612: *cp++ = c; ! 3613: ! 3614: switch (c) { ! 3615: case '\n': ! 3616: abort (); /* A bare newline should never part of the line. */ ! 3617: break; ! 3618: ! 3619: /* <...> is special for #include. */ ! 3620: case '<': ! 3621: if (!kt->angle_brackets) ! 3622: break; ! 3623: while (xp < bp && c != '>') { ! 3624: c = *xp++; ! 3625: if (c == '\\' && xp < bp && *xp == '\n') ! 3626: xp++; ! 3627: else ! 3628: *cp++ = c; ! 3629: } ! 3630: break; ! 3631: ! 3632: case '\\': ! 3633: if (*xp == '\n') { ! 3634: xp++; ! 3635: cp--; ! 3636: if (cp != buf && is_space[cp[-1]]) { ! 3637: while (cp != buf && is_space[cp[-1]]) cp--; ! 3638: cp++; ! 3639: SKIP_WHITE_SPACE (xp); ! 3640: } else if (is_space[*xp]) { ! 3641: *cp++ = *xp++; ! 3642: SKIP_WHITE_SPACE (xp); ! 3643: } ! 3644: } else { ! 3645: *cp++ = *xp++; ! 3646: } ! 3647: break; ! 3648: ! 3649: case '\'': ! 3650: case '\"': ! 3651: { ! 3652: register U_CHAR *bp1 ! 3653: = skip_quoted_string (xp - 1, bp, ip->lineno, ! 3654: NULL_PTR, NULL_PTR, NULL_PTR); ! 3655: while (xp != bp1) ! 3656: if (*xp == '\\') { ! 3657: if (*++xp != '\n') ! 3658: *cp++ = '\\'; ! 3659: else ! 3660: xp++; ! 3661: } else ! 3662: *cp++ = *xp++; ! 3663: } ! 3664: break; ! 3665: ! 3666: case '/': ! 3667: if (*xp == '*' ! 3668: || (cplusplus_comments && *xp == '/')) { ! 3669: ip->bufp = xp + 1; ! 3670: /* If we already copied the command through, ! 3671: already_output != 0 prevents outputting comment now. */ ! 3672: skip_to_end_of_comment (ip, already_output, 0); ! 3673: if (keep_comments) ! 3674: while (xp != ip->bufp) ! 3675: *cp++ = *xp++; ! 3676: /* Delete or replace the slash. */ ! 3677: else if (traditional) ! 3678: cp--; ! 3679: else ! 3680: cp[-1] = ' '; ! 3681: xp = ip->bufp; ! 3682: } ! 3683: } ! 3684: } ! 3685: ! 3686: /* Null-terminate the copy. */ ! 3687: ! 3688: *cp = 0; ! 3689: } else ! 3690: cp = bp; ! 3691: ! 3692: ip->bufp = resume_p; ! 3693: ! 3694: /* Some directives should be written out for cc1 to process, ! 3695: just as if they were not defined. And sometimes we're copying ! 3696: definitions through. */ ! 3697: ! 3698: if (!no_output && already_output == 0 ! 3699: && (kt->pass_thru ! 3700: || (kt->type == T_DEFINE ! 3701: && (dump_macros == dump_names ! 3702: || dump_macros == dump_definitions)))) { ! 3703: int len; ! 3704: ! 3705: /* Output directive name. */ ! 3706: check_expand (op, kt->length + 1); ! 3707: *op->bufp++ = '#'; ! 3708: bcopy (kt->name, op->bufp, kt->length); ! 3709: op->bufp += kt->length; ! 3710: ! 3711: if (kt->pass_thru || dump_macros == dump_definitions) { ! 3712: /* Output arguments. */ ! 3713: len = (cp - buf); ! 3714: check_expand (op, len); ! 3715: bcopy (buf, op->bufp, len); ! 3716: op->bufp += len; ! 3717: } else if (kt->type == T_DEFINE && dump_macros == dump_names) { ! 3718: U_CHAR *xp = buf; ! 3719: U_CHAR *yp; ! 3720: SKIP_WHITE_SPACE (xp); ! 3721: yp = xp; ! 3722: while (is_idchar[*xp]) xp++; ! 3723: len = (xp - yp); ! 3724: check_expand (op, len + 1); ! 3725: *op->bufp++ = ' '; ! 3726: bcopy (yp, op->bufp, len); ! 3727: op->bufp += len; ! 3728: } ! 3729: } /* Don't we need a newline or #line? */ ! 3730: ! 3731: /* Call the appropriate command handler. buf now points to ! 3732: either the appropriate place in the input buffer, or to ! 3733: the temp buffer if it was necessary to make one. cp ! 3734: points to the first char after the contents of the (possibly ! 3735: copied) command, in either case. */ ! 3736: (*kt->func) (buf, cp, op, kt); ! 3737: check_expand (op, ip->length - (ip->bufp - ip->buf)); ! 3738: ! 3739: return 1; ! 3740: } ! 3741: } ! 3742: ! 3743: /* It is deliberate that we don't warn about undefined directives. ! 3744: That is the responsibility of cc1. */ ! 3745: return 0; ! 3746: } ! 3747: ! 3748: static struct tm * ! 3749: timestamp () ! 3750: { ! 3751: static struct tm *timebuf; ! 3752: if (!timebuf) { ! 3753: time_t t = time (0); ! 3754: timebuf = localtime (&t); ! 3755: } ! 3756: return timebuf; ! 3757: } ! 3758: ! 3759: static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", ! 3760: "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", ! 3761: }; ! 3762: ! 3763: /* ! 3764: * expand things like __FILE__. Place the expansion into the output ! 3765: * buffer *without* rescanning. ! 3766: */ ! 3767: ! 3768: static void ! 3769: special_symbol (hp, op) ! 3770: HASHNODE *hp; ! 3771: FILE_BUF *op; ! 3772: { ! 3773: char *buf; ! 3774: int i, len; ! 3775: int true_indepth; ! 3776: FILE_BUF *ip = NULL; ! 3777: struct tm *timebuf; ! 3778: ! 3779: int paren = 0; /* For special `defined' keyword */ ! 3780: ! 3781: if (pcp_outfile && pcp_inside_if ! 3782: && hp->type != T_SPEC_DEFINED && hp->type != T_CONST) ! 3783: error ("Predefined macro `%s' used inside `#if' during precompilation", ! 3784: hp->name); ! 3785: ! 3786: for (i = indepth; i >= 0; i--) ! 3787: if (instack[i].fname != NULL) { ! 3788: ip = &instack[i]; ! 3789: break; ! 3790: } ! 3791: if (ip == NULL) { ! 3792: error ("cccp error: not in any file?!"); ! 3793: return; /* the show must go on */ ! 3794: } ! 3795: ! 3796: switch (hp->type) { ! 3797: case T_FILE: ! 3798: case T_BASE_FILE: ! 3799: { ! 3800: char *string; ! 3801: if (hp->type == T_FILE) ! 3802: string = ip->nominal_fname; ! 3803: else ! 3804: string = instack[0].nominal_fname; ! 3805: ! 3806: if (string) ! 3807: { ! 3808: buf = (char *) alloca (3 + 4 * strlen (string)); ! 3809: quote_string (buf, string); ! 3810: } ! 3811: else ! 3812: buf = "\"\""; ! 3813: ! 3814: break; ! 3815: } ! 3816: ! 3817: case T_INCLUDE_LEVEL: ! 3818: true_indepth = 0; ! 3819: for (i = indepth; i >= 0; i--) ! 3820: if (instack[i].fname != NULL) ! 3821: true_indepth++; ! 3822: ! 3823: buf = (char *) alloca (8); /* Eight bytes ought to be more than enough */ ! 3824: sprintf (buf, "%d", true_indepth - 1); ! 3825: break; ! 3826: ! 3827: case T_VERSION: ! 3828: buf = (char *) alloca (3 + strlen (version_string)); ! 3829: sprintf (buf, "\"%s\"", version_string); ! 3830: break; ! 3831: ! 3832: #ifndef NO_BUILTIN_SIZE_TYPE ! 3833: case T_SIZE_TYPE: ! 3834: buf = (char *) alloca (3 + strlen (SIZE_TYPE)); ! 3835: sprintf (buf, "%s", SIZE_TYPE); ! 3836: break; ! 3837: #endif ! 3838: ! 3839: #ifndef NO_BUILTIN_PTRDIFF_TYPE ! 3840: case T_PTRDIFF_TYPE: ! 3841: buf = (char *) alloca (3 + strlen (PTRDIFF_TYPE)); ! 3842: sprintf (buf, "%s", PTRDIFF_TYPE); ! 3843: break; ! 3844: #endif ! 3845: ! 3846: case T_WCHAR_TYPE: ! 3847: buf = (char *) alloca (3 + strlen (WCHAR_TYPE)); ! 3848: sprintf (buf, "%s", WCHAR_TYPE); ! 3849: break; ! 3850: ! 3851: case T_USER_LABEL_PREFIX_TYPE: ! 3852: buf = (char *) alloca (3 + strlen (USER_LABEL_PREFIX)); ! 3853: sprintf (buf, "%s", USER_LABEL_PREFIX); ! 3854: break; ! 3855: ! 3856: case T_REGISTER_PREFIX_TYPE: ! 3857: buf = (char *) alloca (3 + strlen (REGISTER_PREFIX)); ! 3858: sprintf (buf, "%s", REGISTER_PREFIX); ! 3859: break; ! 3860: ! 3861: case T_CONST: ! 3862: buf = (char *) alloca (4 * sizeof (int)); ! 3863: sprintf (buf, "%d", hp->value.ival); ! 3864: if (pcp_inside_if && pcp_outfile) ! 3865: /* Output a precondition for this macro use */ ! 3866: fprintf (pcp_outfile, "#define %s %d\n", hp->name, hp->value.ival); ! 3867: break; ! 3868: ! 3869: case T_SPECLINE: ! 3870: buf = (char *) alloca (10); ! 3871: sprintf (buf, "%d", ip->lineno); ! 3872: break; ! 3873: ! 3874: case T_DATE: ! 3875: case T_TIME: ! 3876: buf = (char *) alloca (20); ! 3877: timebuf = timestamp (); ! 3878: if (hp->type == T_DATE) ! 3879: sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon], ! 3880: timebuf->tm_mday, timebuf->tm_year + 1900); ! 3881: else ! 3882: sprintf (buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min, ! 3883: timebuf->tm_sec); ! 3884: break; ! 3885: ! 3886: case T_SPEC_DEFINED: ! 3887: buf = " 0 "; /* Assume symbol is not defined */ ! 3888: ip = &instack[indepth]; ! 3889: SKIP_WHITE_SPACE (ip->bufp); ! 3890: if (*ip->bufp == '(') { ! 3891: paren++; ! 3892: ip->bufp++; /* Skip over the paren */ ! 3893: SKIP_WHITE_SPACE (ip->bufp); ! 3894: } ! 3895: ! 3896: if (!is_idstart[*ip->bufp]) ! 3897: goto oops; ! 3898: if (hp = lookup (ip->bufp, -1, -1)) { ! 3899: if (pcp_outfile && pcp_inside_if ! 3900: && hp->value.defn->predefined) ! 3901: /* Output a precondition for this macro use. */ ! 3902: fprintf (pcp_outfile, "#define %s\n", hp->name); ! 3903: buf = " 1 "; ! 3904: } ! 3905: else ! 3906: if (pcp_outfile && pcp_inside_if) { ! 3907: /* Output a precondition for this macro use */ ! 3908: U_CHAR *cp = ip->bufp; ! 3909: fprintf (pcp_outfile, "#undef "); ! 3910: while (is_idchar[*cp]) /* Ick! */ ! 3911: fputc (*cp++, pcp_outfile); ! 3912: putc ('\n', pcp_outfile); ! 3913: } ! 3914: while (is_idchar[*ip->bufp]) ! 3915: ++ip->bufp; ! 3916: SKIP_WHITE_SPACE (ip->bufp); ! 3917: if (paren) { ! 3918: if (*ip->bufp != ')') ! 3919: goto oops; ! 3920: ++ip->bufp; ! 3921: } ! 3922: break; ! 3923: ! 3924: oops: ! 3925: ! 3926: error ("`defined' without an identifier"); ! 3927: break; ! 3928: ! 3929: default: ! 3930: error ("cccp error: invalid special hash type"); /* time for gdb */ ! 3931: abort (); ! 3932: } ! 3933: len = strlen (buf); ! 3934: check_expand (op, len); ! 3935: bcopy (buf, op->bufp, len); ! 3936: op->bufp += len; ! 3937: ! 3938: return; ! 3939: } ! 3940: ! 3941: ! 3942: /* Routines to handle #directives */ ! 3943: ! 3944: /* Handle #include and #import. ! 3945: This function expects to see "fname" or <fname> on the input. */ ! 3946: ! 3947: static int ! 3948: do_include (buf, limit, op, keyword) ! 3949: U_CHAR *buf, *limit; ! 3950: FILE_BUF *op; ! 3951: struct directive *keyword; ! 3952: { ! 3953: int importing = (keyword->type == T_IMPORT); ! 3954: int skip_dirs = (keyword->type == T_INCLUDE_NEXT); ! 3955: #ifdef NEXT_OBJC_RUNTIME ! 3956: static int import_warning = 1; ! 3957: #else ! 3958: static int import_warning = 0; ! 3959: #endif ! 3960: char *fname; /* Dynamically allocated fname buffer */ ! 3961: char *pcftry; ! 3962: char *pcfname; ! 3963: U_CHAR *fbeg, *fend; /* Beginning and end of fname */ ! 3964: ! 3965: struct file_name_list *search_start = include; /* Chain of dirs to search */ ! 3966: struct file_name_list dsp[1]; /* First in chain, if #include "..." */ ! 3967: struct file_name_list *searchptr = 0; ! 3968: int flen; ! 3969: ! 3970: int f; /* file number */ ! 3971: ! 3972: int retried = 0; /* Have already tried macro ! 3973: expanding the include line*/ ! 3974: FILE_BUF trybuf; /* It got expanded into here */ ! 3975: int angle_brackets = 0; /* 0 for "...", 1 for <...> */ ! 3976: int pcf = -1; ! 3977: char *pcfbuf; ! 3978: int pcfbuflimit; ! 3979: int pcfnum; ! 3980: #ifdef NEXT_OBJC_RUNTIME ! 3981: U_CHAR *partial = NULL; ! 3982: int plen = 0; ! 3983: #endif ! 3984: f= -1; /* JF we iz paranoid! */ ! 3985: ! 3986: if (importing && warn_import && !inhibit_warnings ! 3987: && !instack[indepth].system_header_p && !import_warning) { ! 3988: import_warning = 1; ! 3989: warning ("using `#import' is not recommended"); ! 3990: fprintf (stderr, "The fact that a certain header file need not be processed more than once\n"); ! 3991: fprintf (stderr, "should be indicated in the header file, not where it is used.\n"); ! 3992: fprintf (stderr, "The best way to do this is with a conditional of this form:\n\n"); ! 3993: fprintf (stderr, " #ifndef _FOO_H_INCLUDED\n"); ! 3994: fprintf (stderr, " #define _FOO_H_INCLUDED\n"); ! 3995: fprintf (stderr, " ... <real contents of file> ...\n"); ! 3996: fprintf (stderr, " #endif /* Not _FOO_H_INCLUDED */\n\n"); ! 3997: fprintf (stderr, "Then users can use `#include' any number of times.\n"); ! 3998: fprintf (stderr, "GNU C automatically avoids processing the file more than once\n"); ! 3999: fprintf (stderr, "when it is equipped with such a conditional.\n"); ! 4000: } ! 4001: ! 4002: get_filename: ! 4003: ! 4004: fbeg = buf; ! 4005: SKIP_WHITE_SPACE (fbeg); ! 4006: /* Discard trailing whitespace so we can easily see ! 4007: if we have parsed all the significant chars we were given. */ ! 4008: while (limit != fbeg && is_hor_space[limit[-1]]) limit--; ! 4009: ! 4010: switch (*fbeg++) { ! 4011: case '\"': ! 4012: { ! 4013: FILE_BUF *fp; ! 4014: /* Copy the operand text, concatenating the strings. */ ! 4015: { ! 4016: U_CHAR *fin = fbeg; ! 4017: fbeg = (U_CHAR *) alloca (limit - fbeg + 1); ! 4018: fend = fbeg; ! 4019: while (fin != limit) { ! 4020: while (fin != limit && *fin != '\"') ! 4021: *fend++ = *fin++; ! 4022: fin++; ! 4023: if (fin == limit) ! 4024: break; ! 4025: /* If not at the end, there had better be another string. */ ! 4026: /* Skip just horiz space, and don't go past limit. */ ! 4027: while (fin != limit && is_hor_space[*fin]) fin++; ! 4028: if (fin != limit && *fin == '\"') ! 4029: fin++; ! 4030: else ! 4031: goto fail; ! 4032: } ! 4033: } ! 4034: *fend = 0; ! 4035: ! 4036: /* We have "filename". Figure out directory this source ! 4037: file is coming from and put it on the front of the list. */ ! 4038: ! 4039: /* If -I- was specified, don't search current dir, only spec'd ones. */ ! 4040: if (ignore_srcdir) break; ! 4041: ! 4042: for (fp = &instack[indepth]; fp >= instack; fp--) ! 4043: { ! 4044: int n; ! 4045: char *ep,*nam; ! 4046: ! 4047: if ((nam = fp->nominal_fname) != NULL) { ! 4048: /* Found a named file. Figure out dir of the file, ! 4049: and put it in front of the search list. */ ! 4050: dsp[0].next = search_start; ! 4051: search_start = dsp; ! 4052: #ifndef VMS ! 4053: ep = rindex (nam, '/'); ! 4054: #else /* VMS */ ! 4055: ep = rindex (nam, ']'); ! 4056: if (ep == NULL) ep = rindex (nam, '>'); ! 4057: if (ep == NULL) ep = rindex (nam, ':'); ! 4058: if (ep != NULL) ep++; ! 4059: #endif /* VMS */ ! 4060: if (ep != NULL) { ! 4061: n = ep - nam; ! 4062: dsp[0].fname = (char *) alloca (n + 1); ! 4063: strncpy (dsp[0].fname, nam, n); ! 4064: dsp[0].fname[n] = '\0'; ! 4065: if (n + INCLUDE_LEN_FUDGE > max_include_len) ! 4066: max_include_len = n + INCLUDE_LEN_FUDGE; ! 4067: } else { ! 4068: dsp[0].fname = 0; /* Current directory */ ! 4069: } ! 4070: break; ! 4071: } ! 4072: } ! 4073: break; ! 4074: } ! 4075: ! 4076: case '<': ! 4077: fend = fbeg; ! 4078: while (fend != limit && *fend != '>') fend++; ! 4079: if (*fend == '>' && fend + 1 == limit) { ! 4080: angle_brackets = 1; ! 4081: /* If -I-, start with the first -I dir after the -I-. */ ! 4082: if (first_bracket_include) ! 4083: search_start = first_bracket_include; ! 4084: break; ! 4085: } ! 4086: goto fail; ! 4087: ! 4088: default: ! 4089: fail: ! 4090: if (retried) { ! 4091: error ("`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name); ! 4092: return 0; ! 4093: } else { ! 4094: trybuf = expand_to_temp_buffer (buf, limit, 0, 0); ! 4095: buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1); ! 4096: bcopy (trybuf.buf, buf, trybuf.bufp - trybuf.buf); ! 4097: limit = buf + (trybuf.bufp - trybuf.buf); ! 4098: free (trybuf.buf); ! 4099: retried++; ! 4100: goto get_filename; ! 4101: } ! 4102: } ! 4103: ! 4104: /* For #include_next, skip in the search path ! 4105: past the dir in which the containing file was found. */ ! 4106: if (skip_dirs) { ! 4107: FILE_BUF *fp; ! 4108: for (fp = &instack[indepth]; fp >= instack; fp--) ! 4109: if (fp->fname != NULL) { ! 4110: /* fp->dir is null if the containing file was specified ! 4111: with an absolute file name. In that case, don't skip anything. */ ! 4112: if (fp->dir) ! 4113: search_start = fp->dir->next; ! 4114: break; ! 4115: } ! 4116: } ! 4117: ! 4118: flen = fend - fbeg; ! 4119: ! 4120: if (flen == 0) ! 4121: { ! 4122: error ("empty file name in `#%s'", keyword->name); ! 4123: return 0; ! 4124: } ! 4125: ! 4126: /* Allocate this permanently, because it gets stored in the definitions ! 4127: of macros. */ ! 4128: fname = (char *) xmalloc (max_include_len + flen + 2); ! 4129: /* + 2 above for slash and terminating null. */ ! 4130: ! 4131: /* If specified file name is absolute, just open it. */ ! 4132: ! 4133: if (*fbeg == '/') { ! 4134: strncpy (fname, fbeg, flen); ! 4135: fname[flen] = 0; ! 4136: if (redundant_include_p (fname)) ! 4137: return 0; ! 4138: if (importing) ! 4139: f = lookup_import (fname); ! 4140: else ! 4141: f = open (fname, O_RDONLY, 0666); ! 4142: if (f == -2) ! 4143: return 0; /* Already included this file */ ! 4144: } else { ! 4145: /* Search directory path, trying to open the file. ! 4146: Copy each filename tried into FNAME. */ ! 4147: ! 4148: for (searchptr = search_start; searchptr; searchptr = searchptr->next) { ! 4149: if (searchptr->fname) { ! 4150: /* The empty string in a search path is ignored. ! 4151: This makes it possible to turn off entirely ! 4152: a standard piece of the list. */ ! 4153: if (searchptr->fname[0] == 0) ! 4154: continue; ! 4155: strcpy (fname, searchptr->fname); ! 4156: strcat (fname, "/"); ! 4157: fname[strlen (fname) + flen] = 0; ! 4158: } else { ! 4159: fname[0] = 0; ! 4160: } ! 4161: strncat (fname, fbeg, flen); ! 4162: #ifdef VMS ! 4163: /* Change this 1/2 Unix 1/2 VMS file specification into a ! 4164: full VMS file specification */ ! 4165: if (searchptr->fname && (searchptr->fname[0] != 0)) { ! 4166: /* Fix up the filename */ ! 4167: hack_vms_include_specification (fname); ! 4168: } else { ! 4169: /* This is a normal VMS filespec, so use it unchanged. */ ! 4170: strncpy (fname, fbeg, flen); ! 4171: fname[flen] = 0; ! 4172: } ! 4173: #endif /* VMS */ ! 4174: if (importing) ! 4175: f = lookup_import (fname); ! 4176: else ! 4177: f = open (fname, O_RDONLY, 0666); ! 4178: if (f == -2) ! 4179: return 0; /* Already included this file */ ! 4180: #ifdef EACCES ! 4181: else if (f == -1 && errno == EACCES) ! 4182: warning ("Header file %s exists, but is not readable", fname); ! 4183: #endif ! 4184: if (redundant_include_p (fname)) { ! 4185: close (f); ! 4186: return 0; ! 4187: } ! 4188: if (f >= 0) ! 4189: break; ! 4190: } ! 4191: } ! 4192: ! 4193: if (f < 0) { ! 4194: /* A file that was not found. */ ! 4195: ! 4196: strncpy (fname, fbeg, flen); ! 4197: fname[flen] = 0; ! 4198: /* If -M was specified, and this header file won't be added to the ! 4199: dependency list, then don't count this as an error, because we can ! 4200: still produce correct output. Otherwise, we can't produce correct ! 4201: output, because there may be dependencies we need inside the missing ! 4202: file, and we don't know what directory this missing file exists in. */ ! 4203: if (print_deps ! 4204: && (print_deps <= (angle_brackets || (system_include_depth > 0)))) ! 4205: warning ("No include path in which to find %s", fname); ! 4206: else if (search_start) ! 4207: error_from_errno (fname); ! 4208: else ! 4209: error ("No include path in which to find %s", fname); ! 4210: } else { ! 4211: struct stat stat_f; ! 4212: ! 4213: /* Check to see if this include file is a once-only include file. ! 4214: If so, give up. */ ! 4215: ! 4216: struct file_name_list* ptr; ! 4217: ! 4218: for (ptr = dont_repeat_files; ptr; ptr = ptr->next) { ! 4219: if (!strcmp (ptr->fname, fname)) { ! 4220: close (f); ! 4221: return 0; /* This file was once'd. */ ! 4222: } ! 4223: } ! 4224: ! 4225: for (ptr = all_include_files; ptr; ptr = ptr->next) { ! 4226: if (!strcmp (ptr->fname, fname)) ! 4227: break; /* This file was included before. */ ! 4228: } ! 4229: ! 4230: if (ptr == 0) { ! 4231: /* This is the first time for this file. */ ! 4232: /* Add it to list of files included. */ ! 4233: ! 4234: ptr = (struct file_name_list *) xmalloc (sizeof (struct file_name_list)); ! 4235: ptr->control_macro = 0; ! 4236: ptr->c_system_include_path = 0; ! 4237: ptr->next = all_include_files; ! 4238: all_include_files = ptr; ! 4239: ptr->fname = savestring (fname); ! 4240: ! 4241: /* For -M, add this file to the dependencies. */ ! 4242: if (print_deps > (angle_brackets || (system_include_depth > 0))) { ! 4243: deps_output ("", 0); ! 4244: deps_output (fname, 0); ! 4245: deps_output (" ", 0); ! 4246: } ! 4247: } ! 4248: ! 4249: /* Handle -H option. */ ! 4250: if (print_include_names) { ! 4251: output_dots (stderr, indepth); ! 4252: fprintf (stderr, "%s\n", fname); ! 4253: } ! 4254: ! 4255: if (angle_brackets) ! 4256: system_include_depth++; ! 4257: ! 4258: /* Actually process the file. */ ! 4259: add_import (f, fname); /* Record file on "seen" list for #import. */ ! 4260: ! 4261: pcftry = (char *) alloca (strlen (fname) + 30); ! 4262: pcfbuf = 0; ! 4263: pcfnum = 0; ! 4264: ! 4265: fstat (f, &stat_f); ! 4266: ! 4267: if (!no_precomp) ! 4268: do { ! 4269: sprintf (pcftry, "%s%d", fname, pcfnum++); ! 4270: ! 4271: pcf = open (pcftry, O_RDONLY, 0666); ! 4272: if (pcf != -1) ! 4273: { ! 4274: struct stat s; ! 4275: ! 4276: fstat (pcf, &s); ! 4277: if (bcmp (&stat_f.st_ino, &s.st_ino, sizeof (s.st_ino)) ! 4278: || stat_f.st_dev != s.st_dev) ! 4279: { ! 4280: pcfbuf = check_precompiled (pcf, fname, &pcfbuflimit); ! 4281: /* Don't need it any more. */ ! 4282: close (pcf); ! 4283: } ! 4284: else ! 4285: { ! 4286: /* Don't need it at all. */ ! 4287: close (pcf); ! 4288: break; ! 4289: } ! 4290: } ! 4291: } while (pcf != -1 && !pcfbuf); ! 4292: ! 4293: /* Actually process the file */ ! 4294: if (pcfbuf) { ! 4295: pcfname = xmalloc (strlen (pcftry) + 1); ! 4296: strcpy (pcfname, pcftry); ! 4297: pcfinclude (pcfbuf, pcfbuflimit, fname, op); ! 4298: } ! 4299: else ! 4300: finclude (f, fname, op, is_system_include (fname), searchptr); ! 4301: ! 4302: if (angle_brackets) ! 4303: system_include_depth--; ! 4304: } ! 4305: return 0; ! 4306: } ! 4307: ! 4308: /* Return nonzero if there is no need to include file NAME ! 4309: because it has already been included and it contains a conditional ! 4310: to make a repeated include do nothing. */ ! 4311: ! 4312: static int ! 4313: redundant_include_p (name) ! 4314: char *name; ! 4315: { ! 4316: struct file_name_list *l = all_include_files; ! 4317: for (; l; l = l->next) ! 4318: if (! strcmp (name, l->fname) ! 4319: && l->control_macro ! 4320: && lookup (l->control_macro, -1, -1)) ! 4321: return 1; ! 4322: return 0; ! 4323: } ! 4324: ! 4325: /* Return nonzero if the given FILENAME is an absolute pathname which ! 4326: designates a file within one of the known "system" include file ! 4327: directories. We assume here that if the given FILENAME looks like ! 4328: it is the name of a file which resides either directly in a "system" ! 4329: include file directory, or within any subdirectory thereof, then the ! 4330: given file must be a "system" include file. This function tells us ! 4331: if we should suppress pedantic errors/warnings for the given FILENAME. ! 4332: ! 4333: The value is 2 if the file is a C-language system header file ! 4334: for which C++ should (on most systems) assume `extern "C"'. */ ! 4335: ! 4336: static int ! 4337: is_system_include (filename) ! 4338: register char *filename; ! 4339: { ! 4340: struct file_name_list *searchptr; ! 4341: ! 4342: for (searchptr = first_system_include; searchptr; ! 4343: searchptr = searchptr->next) ! 4344: if (searchptr->fname) { ! 4345: register char *sys_dir = searchptr->fname; ! 4346: register unsigned length = strlen (sys_dir); ! 4347: ! 4348: if (! strncmp (sys_dir, filename, length) && filename[length] == '/') ! 4349: { ! 4350: #ifdef GO_IF_CPLUSPLUS_INCLUDE_NAME ! 4351: char *name = filename+length; ! 4352: GO_IF_CPLUSPLUS_INCLUDE_NAME (name, cplusfile); ! 4353: #endif ! 4354: if (searchptr->c_system_include_path) ! 4355: { ! 4356: return 2; ! 4357: } ! 4358: ! 4359: cplusfile: ! 4360: return 1; ! 4361: } ! 4362: } ! 4363: return 0; ! 4364: } ! 4365: ! 4366: /* Process the contents of include file FNAME, already open on descriptor F, ! 4367: with output to OP. ! 4368: SYSTEM_HEADER_P is 1 if this file resides in any one of the known ! 4369: "system" include directories (as decided by the `is_system_include' ! 4370: function above). ! 4371: DIRPTR is the link in the dir path through which this file was found, ! 4372: or 0 if the file name was absolute. */ ! 4373: ! 4374: static void ! 4375: finclude (f, fname, op, system_header_p, dirptr) ! 4376: int f; ! 4377: char *fname; ! 4378: FILE_BUF *op; ! 4379: int system_header_p; ! 4380: struct file_name_list *dirptr; ! 4381: { ! 4382: int st_mode; ! 4383: long st_size; ! 4384: long i; ! 4385: FILE_BUF *fp; /* For input stack frame */ ! 4386: int missing_newline = 0; ! 4387: ! 4388: CHECK_DEPTH (return;); ! 4389: ! 4390: if (file_size_and_mode (f, &st_mode, &st_size) < 0) ! 4391: { ! 4392: perror_with_name (fname); ! 4393: close (f); ! 4394: return; ! 4395: } ! 4396: ! 4397: fp = &instack[indepth + 1]; ! 4398: bzero (fp, sizeof (FILE_BUF)); ! 4399: fp->nominal_fname = fp->fname = fname; ! 4400: fp->length = 0; ! 4401: fp->lineno = 1; ! 4402: fp->if_stack = if_stack; ! 4403: fp->system_header_p = system_header_p; ! 4404: fp->dir = dirptr; ! 4405: ! 4406: if (S_ISREG (st_mode)) { ! 4407: fp->buf = (U_CHAR *) xmalloc (st_size + 2); ! 4408: fp->bufp = fp->buf; ! 4409: ! 4410: /* Read the file contents, knowing that st_size is an upper bound ! 4411: on the number of bytes we can read. */ ! 4412: while (st_size > 0) { ! 4413: i = safe_read (f, fp->buf + fp->length, st_size); ! 4414: if (i <= 0) { ! 4415: if (i == 0) break; ! 4416: goto nope; ! 4417: } ! 4418: fp->length += i; ! 4419: st_size -= i; ! 4420: } ! 4421: } ! 4422: else if (S_ISDIR (st_mode)) { ! 4423: error ("directory `%s' specified in #include", fname); ! 4424: close (f); ! 4425: return; ! 4426: } else { ! 4427: /* Cannot count its file size before reading. ! 4428: First read the entire file into heap and ! 4429: copy them into buffer on stack. */ ! 4430: ! 4431: U_CHAR *bufp; ! 4432: U_CHAR *basep; ! 4433: int bsize = 2000; ! 4434: ! 4435: st_size = 0; ! 4436: basep = (U_CHAR *) xmalloc (bsize + 2); ! 4437: fp->buf = basep; /* So it will get freed, on error. */ ! 4438: bufp = basep; ! 4439: ! 4440: for (;;) { ! 4441: i = safe_read (f, bufp, bsize - st_size); ! 4442: if (i < 0) ! 4443: goto nope; /* error! */ ! 4444: if (i == 0) ! 4445: break; /* End of file */ ! 4446: st_size += i; ! 4447: bufp += i; ! 4448: if (bsize == st_size) { /* Buffer is full! */ ! 4449: bsize *= 2; ! 4450: basep = (U_CHAR *) xrealloc (basep, bsize + 2); ! 4451: fp->buf = basep; ! 4452: bufp = basep + st_size; /* May have moved */ ! 4453: } ! 4454: } ! 4455: fp->bufp = fp->buf; ! 4456: fp->length = st_size; ! 4457: } ! 4458: ! 4459: if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n') ! 4460: /* Backslash-newline at end is not good enough. */ ! 4461: || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) { ! 4462: fp->buf[fp->length++] = '\n'; ! 4463: missing_newline = 1; ! 4464: } ! 4465: fp->buf[fp->length] = '\0'; ! 4466: ! 4467: /* Close descriptor now, so nesting does not use lots of descriptors. */ ! 4468: close (f); ! 4469: ! 4470: /* Must do this before calling trigraph_pcp, so that the correct file name ! 4471: will be printed in warning messages. */ ! 4472: ! 4473: indepth++; ! 4474: input_file_stack_tick++; ! 4475: ! 4476: if (!no_trigraphs) ! 4477: trigraph_pcp (fp); ! 4478: ! 4479: #ifdef NEXT_SEMANTICS ! 4480: if (!no_rtf) ! 4481: buf_convert_rtf (fp); ! 4482: #endif ! 4483: ! 4484: output_line_command (fp, op, 0, enter_file); ! 4485: rescan (op, 0); ! 4486: ! 4487: if (missing_newline) ! 4488: fp->lineno--; ! 4489: ! 4490: if (pedantic && missing_newline) ! 4491: pedwarn ("file does not end in newline"); ! 4492: ! 4493: indepth--; ! 4494: input_file_stack_tick++; ! 4495: output_line_command (&instack[indepth], op, 0, leave_file); ! 4496: free (fp->buf); ! 4497: return; ! 4498: ! 4499: nope: ! 4500: ! 4501: perror_with_name (fname); ! 4502: close (f); ! 4503: free (fp->buf); ! 4504: } ! 4505: ! 4506: /* Record that inclusion of the file named FILE ! 4507: should be controlled by the macro named MACRO_NAME. ! 4508: This means that trying to include the file again ! 4509: will do something if that macro is defined. */ ! 4510: ! 4511: static void ! 4512: record_control_macro (file, macro_name) ! 4513: char *file; ! 4514: U_CHAR *macro_name; ! 4515: { ! 4516: struct file_name_list *new; ! 4517: ! 4518: for (new = all_include_files; new; new = new->next) { ! 4519: if (!strcmp (new->fname, file)) { ! 4520: new->control_macro = macro_name; ! 4521: return; ! 4522: } ! 4523: } ! 4524: ! 4525: /* If the file is not in all_include_files, something's wrong. */ ! 4526: abort (); ! 4527: } ! 4528: ! 4529: /* Maintain and search list of included files, for #import. */ ! 4530: ! 4531: #define IMPORT_HASH_SIZE 31 ! 4532: ! 4533: struct import_file { ! 4534: char *name; ! 4535: ino_t inode; ! 4536: dev_t dev; ! 4537: struct import_file *next; ! 4538: }; ! 4539: ! 4540: /* Hash table of files already included with #include or #import. */ ! 4541: ! 4542: static struct import_file *import_hash_table[IMPORT_HASH_SIZE]; ! 4543: ! 4544: /* Hash a file name for import_hash_table. */ ! 4545: ! 4546: static int ! 4547: import_hash (f) ! 4548: char *f; ! 4549: { ! 4550: int val = 0; ! 4551: ! 4552: while (*f) val += *f++; ! 4553: return (val%IMPORT_HASH_SIZE); ! 4554: } ! 4555: ! 4556: /* Search for file FILENAME in import_hash_table. ! 4557: Return -2 if found, either a matching name or a matching inode. ! 4558: Otherwise, open the file and return a file descriptor if successful ! 4559: or -1 if unsuccessful. */ ! 4560: ! 4561: static int ! 4562: lookup_import (filename) ! 4563: char *filename; ! 4564: { ! 4565: struct import_file *i; ! 4566: int h; ! 4567: int hashval; ! 4568: struct stat sb; ! 4569: int fd; ! 4570: ! 4571: hashval = import_hash (filename); ! 4572: ! 4573: /* Attempt to find file in list of already included files */ ! 4574: i = import_hash_table[hashval]; ! 4575: ! 4576: while (i) { ! 4577: if (!strcmp (filename, i->name)) ! 4578: return -2; /* return found */ ! 4579: i = i->next; ! 4580: } ! 4581: /* Open it and try a match on inode/dev */ ! 4582: fd = open (filename, O_RDONLY, 0666); ! 4583: if (fd < 0) ! 4584: return fd; ! 4585: fstat (fd, &sb); ! 4586: for (h = 0; h < IMPORT_HASH_SIZE; h++) { ! 4587: i = import_hash_table[h]; ! 4588: while (i) { ! 4589: /* Compare the inode and the device. ! 4590: Supposedly on some systems the inode is not a scalar. */ ! 4591: if (!bcmp (&i->inode, &sb.st_ino, sizeof (sb.st_ino)) ! 4592: && i->dev == sb.st_dev) { ! 4593: close (fd); ! 4594: return -2; /* return found */ ! 4595: } ! 4596: i = i->next; ! 4597: } ! 4598: } ! 4599: return fd; /* Not found, return open file */ ! 4600: } ! 4601: ! 4602: /* Add the file FNAME, open on descriptor FD, to import_hash_table. */ ! 4603: ! 4604: static void ! 4605: add_import (fd, fname) ! 4606: int fd; ! 4607: char *fname; ! 4608: { ! 4609: struct import_file *i; ! 4610: int hashval; ! 4611: struct stat sb; ! 4612: ! 4613: hashval = import_hash (fname); ! 4614: fstat (fd, &sb); ! 4615: i = (struct import_file *)xmalloc (sizeof (struct import_file)); ! 4616: i->name = (char *)xmalloc (strlen (fname)+1); ! 4617: strcpy (i->name, fname); ! 4618: bcopy (&sb.st_ino, &i->inode, sizeof (sb.st_ino)); ! 4619: i->dev = sb.st_dev; ! 4620: i->next = import_hash_table[hashval]; ! 4621: import_hash_table[hashval] = i; ! 4622: } ! 4623: ! 4624: /* Load the specified precompiled header into core, and verify its ! 4625: preconditions. PCF indicates the file descriptor to read, which must ! 4626: be a regular file. FNAME indicates the file name of the original ! 4627: header. *LIMIT will be set to an address one past the end of the file. ! 4628: If the preconditions of the file are not satisfied, the buffer is ! 4629: freed and we return 0. If the preconditions are satisfied, return ! 4630: the address of the buffer following the preconditions. The buffer, in ! 4631: this case, should never be freed because various pieces of it will ! 4632: be referred to until all precompiled strings are output at the end of ! 4633: the run. ! 4634: */ ! 4635: static char * ! 4636: check_precompiled (pcf, fname, limit) ! 4637: int pcf; ! 4638: char *fname; ! 4639: char **limit; ! 4640: { ! 4641: int st_mode; ! 4642: long st_size; ! 4643: int length = 0; ! 4644: char *buf; ! 4645: char *dollar_loc; ! 4646: int i; ! 4647: char *cp; ! 4648: ! 4649: if (pcp_outfile) ! 4650: return 0; ! 4651: ! 4652: if (file_size_and_mode (pcf, &st_mode, &st_size) < 0) ! 4653: return 0; ! 4654: ! 4655: if (S_ISREG (st_mode)) ! 4656: { ! 4657: buf = xmalloc (st_size + 2); ! 4658: while (st_size > 0) ! 4659: { ! 4660: i = safe_read (pcf, buf + length, st_size); ! 4661: if (i < 0) ! 4662: goto nope; ! 4663: if (i == 0) ! 4664: break; ! 4665: length += i; ! 4666: st_size -= i; ! 4667: } ! 4668: } ! 4669: else ! 4670: abort (); ! 4671: ! 4672: if (length > 0 && buf[length-1] != '\n') ! 4673: buf[length++] = '\n'; ! 4674: buf[length] = '\0'; ! 4675: ! 4676: *limit = buf + length; ! 4677: ! 4678: /* File is in core. Check the preconditions. */ ! 4679: if (!check_preconditions (buf)) ! 4680: goto nope; ! 4681: for (cp = buf; *cp; cp++) ! 4682: ; ! 4683: #ifdef DEBUG_PCP ! 4684: fprintf (stderr, "Using preinclude %s\n", fname); ! 4685: #endif ! 4686: return cp + 1; ! 4687: ! 4688: nope: ! 4689: #ifdef DEBUG_PCP ! 4690: fprintf (stderr, "Cannot use preinclude %s\n", fname); ! 4691: #endif ! 4692: free (buf); ! 4693: return 0; ! 4694: } ! 4695: ! 4696: /* PREC (null terminated) points to the preconditions of a ! 4697: precompiled header. These are a series of #define and #undef ! 4698: lines which must match the current contents of the hash ! 4699: table. */ ! 4700: static int ! 4701: check_preconditions (prec) ! 4702: char *prec; ! 4703: { ! 4704: MACRODEF mdef; ! 4705: char *lineend; ! 4706: ! 4707: while (*prec) { ! 4708: lineend = (char *) index (prec, '\n'); ! 4709: ! 4710: if (*prec++ != '#') { ! 4711: error ("Bad format encountered while reading precompiled file"); ! 4712: return 0; ! 4713: } ! 4714: if (!strncmp (prec, "define", 6)) { ! 4715: HASHNODE *hp; ! 4716: ! 4717: prec += 6; ! 4718: mdef = create_definition (prec, lineend, NULL_PTR); ! 4719: ! 4720: if (mdef.defn == 0) ! 4721: abort (); ! 4722: ! 4723: if ((hp = lookup (mdef.symnam, mdef.symlen, -1)) == NULL ! 4724: || (hp->type != T_MACRO && hp->type != T_CONST) ! 4725: || (hp->type == T_MACRO ! 4726: && !compare_defs (mdef.defn, hp->value.defn) ! 4727: && (mdef.defn->length != 2 ! 4728: || mdef.defn->expansion[0] != '\n' ! 4729: || mdef.defn->expansion[1] != ' '))) ! 4730: return 0; ! 4731: } else if (!strncmp (prec, "undef", 5)) { ! 4732: char *name; ! 4733: int len; ! 4734: ! 4735: prec += 5; ! 4736: while (is_hor_space[(U_CHAR) *prec]) ! 4737: prec++; ! 4738: name = prec; ! 4739: while (is_idchar[(U_CHAR) *prec]) ! 4740: prec++; ! 4741: len = prec - name; ! 4742: ! 4743: if (lookup (name, len, -1)) ! 4744: return 0; ! 4745: } else { ! 4746: error ("Bad format encountered while reading precompiled file"); ! 4747: return 0; ! 4748: } ! 4749: prec = lineend + 1; ! 4750: } ! 4751: /* They all passed successfully */ ! 4752: return 1; ! 4753: } ! 4754: ! 4755: /* Process the main body of a precompiled file. BUF points to the ! 4756: string section of the file, following the preconditions. LIMIT is one ! 4757: character past the end. NAME is the name of the file being read ! 4758: in. OP is the main output buffer */ ! 4759: static void ! 4760: pcfinclude (buf, limit, name, op) ! 4761: U_CHAR *buf, *limit, *name; ! 4762: FILE_BUF *op; ! 4763: { ! 4764: FILE_BUF tmpbuf; ! 4765: int nstrings; ! 4766: U_CHAR *cp = buf; ! 4767: ! 4768: /* First in the file comes 4 bytes indicating the number of strings, */ ! 4769: /* in network byte order. (MSB first). */ ! 4770: nstrings = *cp++; ! 4771: nstrings = (nstrings << 8) | *cp++; ! 4772: nstrings = (nstrings << 8) | *cp++; ! 4773: nstrings = (nstrings << 8) | *cp++; ! 4774: ! 4775: /* Looping over each string... */ ! 4776: while (nstrings--) { ! 4777: U_CHAR *string_start; ! 4778: U_CHAR *endofthiskey; ! 4779: STRINGDEF *str; ! 4780: int nkeys; ! 4781: ! 4782: /* Each string starts with a STRINGDEF structure (str), followed */ ! 4783: /* by the text of the string (string_start) */ ! 4784: ! 4785: /* First skip to a longword boundary */ ! 4786: /* ??? Why a 4-byte boundary? On all machines? */ ! 4787: /* NOTE: This works correctly even if HOST_WIDE_INT ! 4788: is narrower than a pointer. ! 4789: Do not try risky measures here to get another type to use! ! 4790: Do not include gstddef.h or stddef.h--either one will fail! */ ! 4791: if ((HOST_WIDE_INT) cp & 3) ! 4792: cp += 4 - ((HOST_WIDE_INT) cp & 3); ! 4793: ! 4794: /* Now get the string. */ ! 4795: str = (STRINGDEF *) cp; ! 4796: string_start = cp += sizeof (STRINGDEF); ! 4797: ! 4798: for (; *cp; cp++) /* skip the string */ ! 4799: ; ! 4800: ! 4801: /* We need to macro expand the string here to ensure that the ! 4802: proper definition environment is in place. If it were only ! 4803: expanded when we find out it is needed, macros necessary for ! 4804: its proper expansion might have had their definitions changed. */ ! 4805: tmpbuf = expand_to_temp_buffer (string_start, cp++, 0, 0); ! 4806: /* Lineno is already set in the precompiled file */ ! 4807: str->contents = tmpbuf.buf; ! 4808: str->len = tmpbuf.length; ! 4809: str->writeflag = 0; ! 4810: str->filename = name; ! 4811: str->output_mark = outbuf.bufp - outbuf.buf; ! 4812: ! 4813: str->chain = 0; ! 4814: *stringlist_tailp = str; ! 4815: stringlist_tailp = &str->chain; ! 4816: ! 4817: /* Next comes a fourbyte number indicating the number of keys */ ! 4818: /* for this string. */ ! 4819: nkeys = *cp++; ! 4820: nkeys = (nkeys << 8) | *cp++; ! 4821: nkeys = (nkeys << 8) | *cp++; ! 4822: nkeys = (nkeys << 8) | *cp++; ! 4823: ! 4824: /* If this number is -1, then the string is mandatory. */ ! 4825: if (nkeys == -1) ! 4826: str->writeflag = 1; ! 4827: else ! 4828: /* Otherwise, for each key, */ ! 4829: for (; nkeys--; free (tmpbuf.buf), cp = endofthiskey + 1) { ! 4830: KEYDEF *kp = (KEYDEF *) cp; ! 4831: HASHNODE *hp; ! 4832: ! 4833: /* It starts with a KEYDEF structure */ ! 4834: cp += sizeof (KEYDEF); ! 4835: ! 4836: /* Find the end of the key. At the end of this for loop we ! 4837: advance CP to the start of the next key using this variable. */ ! 4838: endofthiskey = cp + strlen (cp); ! 4839: kp->str = str; ! 4840: ! 4841: /* Expand the key, and enter it into the hash table. */ ! 4842: tmpbuf = expand_to_temp_buffer (cp, endofthiskey, 0, 0); ! 4843: tmpbuf.bufp = tmpbuf.buf; ! 4844: ! 4845: while (is_hor_space[*tmpbuf.bufp]) ! 4846: tmpbuf.bufp++; ! 4847: if (!is_idstart[*tmpbuf.bufp] ! 4848: || tmpbuf.bufp == tmpbuf.buf + tmpbuf.length) { ! 4849: str->writeflag = 1; ! 4850: continue; ! 4851: } ! 4852: ! 4853: hp = lookup (tmpbuf.bufp, -1, -1); ! 4854: if (hp == NULL) { ! 4855: kp->chain = 0; ! 4856: install (tmpbuf.bufp, -1, T_PCSTRING, 0, (char *) kp, -1); ! 4857: } ! 4858: else if (hp->type == T_PCSTRING) { ! 4859: kp->chain = hp->value.keydef; ! 4860: hp->value.keydef = kp; ! 4861: } ! 4862: else ! 4863: str->writeflag = 1; ! 4864: } ! 4865: } ! 4866: /* This output_line_command serves to switch us back to the current ! 4867: input file in case some of these strings get output (which will ! 4868: result in line commands for the header file being output). */ ! 4869: output_line_command (&instack[indepth], op, 0, enter_file); ! 4870: } ! 4871: ! 4872: /* Called from rescan when it hits a key for strings. Mark them all */ ! 4873: /* used and clean up. */ ! 4874: static void ! 4875: pcstring_used (hp) ! 4876: HASHNODE *hp; ! 4877: { ! 4878: KEYDEF *kp, *tmp; ! 4879: ! 4880: for (kp = hp->value.keydef; kp; kp = kp->chain) ! 4881: kp->str->writeflag = 1; ! 4882: delete_macro (hp); ! 4883: } ! 4884: ! 4885: /* Write the output, interspersing precompiled strings in their */ ! 4886: /* appropriate places. */ ! 4887: static void ! 4888: write_output () ! 4889: { ! 4890: STRINGDEF *next_string; ! 4891: U_CHAR *cur_buf_loc; ! 4892: int line_command_len = 80; ! 4893: char *line_command = xmalloc (line_command_len); ! 4894: int len; ! 4895: int written; ! 4896: ! 4897: /* In each run through the loop, either cur_buf_loc == */ ! 4898: /* next_string_loc, in which case we print a series of strings, or */ ! 4899: /* it is less than next_string_loc, in which case we write some of */ ! 4900: /* the buffer. */ ! 4901: cur_buf_loc = outbuf.buf; ! 4902: next_string = stringlist; ! 4903: ! 4904: while (cur_buf_loc < outbuf.bufp || next_string) { ! 4905: if (next_string ! 4906: && cur_buf_loc - outbuf.buf == next_string->output_mark) { ! 4907: if (next_string->writeflag) { ! 4908: len = 4 * strlen (next_string->filename) + 32; ! 4909: while (len > line_command_len) ! 4910: line_command = xrealloc (line_command, ! 4911: line_command_len *= 2); ! 4912: sprintf (line_command, "\n# %d ", next_string->lineno); ! 4913: strcpy (quote_string (line_command + strlen (line_command), ! 4914: next_string->filename), ! 4915: "\n"); ! 4916: safe_write (fileno (stdout), line_command, strlen (line_command)); ! 4917: safe_write (fileno (stdout), next_string->contents, next_string->len); ! 4918: } ! 4919: next_string = next_string->chain; ! 4920: } ! 4921: else { ! 4922: len = (next_string ! 4923: ? (next_string->output_mark ! 4924: - (cur_buf_loc - outbuf.buf)) ! 4925: : outbuf.bufp - cur_buf_loc); ! 4926: ! 4927: safe_write (fileno (stdout), cur_buf_loc, len); ! 4928: cur_buf_loc += len; ! 4929: } ! 4930: } ! 4931: free (line_command); ! 4932: } ! 4933: ! 4934: /* Pass a directive through to the output file. ! 4935: BUF points to the contents of the directive, as a contiguous string. ! 4936: LIMIT points to the first character past the end of the directive. ! 4937: KEYWORD is the keyword-table entry for the directive. */ ! 4938: ! 4939: static void ! 4940: pass_thru_directive (buf, limit, op, keyword) ! 4941: U_CHAR *buf, *limit; ! 4942: FILE_BUF *op; ! 4943: struct directive *keyword; ! 4944: { ! 4945: register unsigned keyword_length = keyword->length; ! 4946: ! 4947: check_expand (op, 1 + keyword_length + (limit - buf)); ! 4948: *op->bufp++ = '#'; ! 4949: bcopy (keyword->name, op->bufp, keyword_length); ! 4950: op->bufp += keyword_length; ! 4951: if (limit != buf && buf[0] != ' ') ! 4952: *op->bufp++ = ' '; ! 4953: bcopy (buf, op->bufp, limit - buf); ! 4954: op->bufp += (limit - buf); ! 4955: #if 0 ! 4956: *op->bufp++ = '\n'; ! 4957: /* Count the line we have just made in the output, ! 4958: to get in sync properly. */ ! 4959: op->lineno++; ! 4960: #endif ! 4961: } ! 4962: ! 4963: /* The arglist structure is built by do_define to tell ! 4964: collect_definition where the argument names begin. That ! 4965: is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist ! 4966: would contain pointers to the strings x, y, and z. ! 4967: Collect_definition would then build a DEFINITION node, ! 4968: with reflist nodes pointing to the places x, y, and z had ! 4969: appeared. So the arglist is just convenience data passed ! 4970: between these two routines. It is not kept around after ! 4971: the current #define has been processed and entered into the ! 4972: hash table. */ ! 4973: ! 4974: struct arglist { ! 4975: struct arglist *next; ! 4976: U_CHAR *name; ! 4977: int length; ! 4978: int argno; ! 4979: char rest_args; ! 4980: }; ! 4981: ! 4982: /* Create a DEFINITION node from a #define directive. Arguments are ! 4983: as for do_define. */ ! 4984: static MACRODEF ! 4985: create_definition (buf, limit, op) ! 4986: U_CHAR *buf, *limit; ! 4987: FILE_BUF *op; ! 4988: { ! 4989: U_CHAR *bp; /* temp ptr into input buffer */ ! 4990: U_CHAR *symname; /* remember where symbol name starts */ ! 4991: int sym_length; /* and how long it is */ ! 4992: int line = instack[indepth].lineno; ! 4993: char *file = instack[indepth].nominal_fname; ! 4994: int rest_args = 0; ! 4995: ! 4996: DEFINITION *defn; ! 4997: int arglengths = 0; /* Accumulate lengths of arg names ! 4998: plus number of args. */ ! 4999: MACRODEF mdef; ! 5000: ! 5001: bp = buf; ! 5002: ! 5003: while (is_hor_space[*bp]) ! 5004: bp++; ! 5005: ! 5006: symname = bp; /* remember where it starts */ ! 5007: sym_length = check_macro_name (bp, "macro"); ! 5008: bp += sym_length; ! 5009: ! 5010: /* Lossage will occur if identifiers or control keywords are broken ! 5011: across lines using backslash. This is not the right place to take ! 5012: care of that. */ ! 5013: ! 5014: if (*bp == '(') { ! 5015: struct arglist *arg_ptrs = NULL; ! 5016: int argno = 0; ! 5017: ! 5018: bp++; /* skip '(' */ ! 5019: SKIP_WHITE_SPACE (bp); ! 5020: ! 5021: /* Loop over macro argument names. */ ! 5022: while (*bp != ')') { ! 5023: struct arglist *temp; ! 5024: ! 5025: temp = (struct arglist *) alloca (sizeof (struct arglist)); ! 5026: temp->name = bp; ! 5027: temp->next = arg_ptrs; ! 5028: temp->argno = argno++; ! 5029: temp->rest_args = 0; ! 5030: arg_ptrs = temp; ! 5031: ! 5032: if (rest_args) ! 5033: pedwarn ("another parameter follows `%s'", ! 5034: rest_extension); ! 5035: ! 5036: if (!is_idstart[*bp]) ! 5037: pedwarn ("invalid character in macro parameter name"); ! 5038: ! 5039: /* Find the end of the arg name. */ ! 5040: while (is_idchar[*bp]) { ! 5041: bp++; ! 5042: /* do we have a "special" rest-args extension here? */ ! 5043: if (limit - bp > REST_EXTENSION_LENGTH && ! 5044: strncmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0) { ! 5045: rest_args = 1; ! 5046: temp->rest_args = 1; ! 5047: break; ! 5048: } ! 5049: } ! 5050: temp->length = bp - temp->name; ! 5051: if (rest_args == 1) ! 5052: bp += REST_EXTENSION_LENGTH; ! 5053: arglengths += temp->length + 2; ! 5054: SKIP_WHITE_SPACE (bp); ! 5055: if (temp->length == 0 || (*bp != ',' && *bp != ')')) { ! 5056: error ("badly punctuated parameter list in `#define'"); ! 5057: goto nope; ! 5058: } ! 5059: if (*bp == ',') { ! 5060: bp++; ! 5061: SKIP_WHITE_SPACE (bp); ! 5062: } ! 5063: if (bp >= limit) { ! 5064: error ("unterminated parameter list in `#define'"); ! 5065: goto nope; ! 5066: } ! 5067: { ! 5068: struct arglist *otemp; ! 5069: ! 5070: for (otemp = temp->next; otemp != NULL; otemp = otemp->next) ! 5071: if (temp->length == otemp->length && ! 5072: strncmp (temp->name, otemp->name, temp->length) == 0) { ! 5073: U_CHAR *name; ! 5074: ! 5075: name = (U_CHAR *) alloca (temp->length + 1); ! 5076: (void) strncpy (name, temp->name, temp->length); ! 5077: name[temp->length] = '\0'; ! 5078: error ("duplicate argument name `%s' in `#define'", name); ! 5079: goto nope; ! 5080: } ! 5081: } ! 5082: } ! 5083: ! 5084: ++bp; /* skip paren */ ! 5085: /* Skip exactly one space or tab if any. */ ! 5086: if (bp < limit && (*bp == ' ' || *bp == '\t')) ++bp; ! 5087: /* now everything from bp before limit is the definition. */ ! 5088: defn = collect_expansion (bp, limit, argno, arg_ptrs); ! 5089: defn->rest_args = rest_args; ! 5090: ! 5091: /* Now set defn->args.argnames to the result of concatenating ! 5092: the argument names in reverse order ! 5093: with comma-space between them. */ ! 5094: defn->args.argnames = (U_CHAR *) xmalloc (arglengths + 1); ! 5095: { ! 5096: struct arglist *temp; ! 5097: int i = 0; ! 5098: for (temp = arg_ptrs; temp; temp = temp->next) { ! 5099: bcopy (temp->name, &defn->args.argnames[i], temp->length); ! 5100: i += temp->length; ! 5101: if (temp->next != 0) { ! 5102: defn->args.argnames[i++] = ','; ! 5103: defn->args.argnames[i++] = ' '; ! 5104: } ! 5105: } ! 5106: defn->args.argnames[i] = 0; ! 5107: } ! 5108: } else { ! 5109: /* simple expansion or empty definition; gobble it */ ! 5110: if (is_hor_space[*bp]) ! 5111: ++bp; /* skip exactly one blank/tab char */ ! 5112: /* now everything from bp before limit is the definition. */ ! 5113: defn = collect_expansion (bp, limit, -1, NULL_PTR); ! 5114: defn->args.argnames = (U_CHAR *) ""; ! 5115: } ! 5116: ! 5117: defn->line = line; ! 5118: defn->file = file; ! 5119: ! 5120: /* OP is null if this is a predefinition */ ! 5121: defn->predefined = !op; ! 5122: mdef.defn = defn; ! 5123: mdef.symnam = symname; ! 5124: mdef.symlen = sym_length; ! 5125: ! 5126: return mdef; ! 5127: ! 5128: nope: ! 5129: mdef.defn = 0; ! 5130: return mdef; ! 5131: } ! 5132: ! 5133: /* Process a #define command. ! 5134: BUF points to the contents of the #define command, as a contiguous string. ! 5135: LIMIT points to the first character past the end of the definition. ! 5136: KEYWORD is the keyword-table entry for #define. */ ! 5137: ! 5138: static int ! 5139: do_define (buf, limit, op, keyword) ! 5140: U_CHAR *buf, *limit; ! 5141: FILE_BUF *op; ! 5142: struct directive *keyword; ! 5143: { ! 5144: int hashcode; ! 5145: MACRODEF mdef; ! 5146: ! 5147: /* If this is a precompiler run (with -pcp) pass thru #define commands. */ ! 5148: if (pcp_outfile && op) ! 5149: pass_thru_directive (buf, limit, op, keyword); ! 5150: ! 5151: mdef = create_definition (buf, limit, op); ! 5152: if (mdef.defn == 0) ! 5153: goto nope; ! 5154: ! 5155: hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE); ! 5156: ! 5157: { ! 5158: HASHNODE *hp; ! 5159: if ((hp = lookup (mdef.symnam, mdef.symlen, hashcode)) != NULL) { ! 5160: int ok = 0; ! 5161: /* Redefining a precompiled key is ok. */ ! 5162: if (hp->type == T_PCSTRING) ! 5163: ok = 1; ! 5164: /* Redefining a macro is ok if the definitions are the same. */ ! 5165: else if (hp->type == T_MACRO) ! 5166: ok = ! compare_defs (mdef.defn, hp->value.defn); ! 5167: /* Redefining a constant is ok with -D. */ ! 5168: else if (hp->type == T_CONST) ! 5169: ok = ! done_initializing; ! 5170: /* Print the warning if it's not ok. */ ! 5171: if (!ok) { ! 5172: U_CHAR *msg; /* what pain... */ ! 5173: ! 5174: /* If we are passing through #define and #undef directives, do ! 5175: that for this re-definition now. */ ! 5176: if (debug_output && op) ! 5177: pass_thru_directive (buf, limit, op, keyword); ! 5178: ! 5179: msg = (U_CHAR *) alloca (mdef.symlen + 22); ! 5180: *msg = '`'; ! 5181: bcopy (mdef.symnam, msg + 1, mdef.symlen); ! 5182: strcpy ((char *) (msg + mdef.symlen + 1), "' redefined"); ! 5183: pedwarn (msg); ! 5184: if (hp->type == T_MACRO) ! 5185: pedwarn_with_file_and_line (hp->value.defn->file, hp->value.defn->line, ! 5186: "this is the location of the previous definition"); ! 5187: } ! 5188: /* Replace the old definition. */ ! 5189: hp->type = T_MACRO; ! 5190: hp->value.defn = mdef.defn; ! 5191: } else { ! 5192: /* If we are passing through #define and #undef directives, do ! 5193: that for this new definition now. */ ! 5194: if (debug_output && op) ! 5195: pass_thru_directive (buf, limit, op, keyword); ! 5196: install (mdef.symnam, mdef.symlen, T_MACRO, 0, ! 5197: (char *) mdef.defn, hashcode); ! 5198: } ! 5199: } ! 5200: ! 5201: return 0; ! 5202: ! 5203: nope: ! 5204: ! 5205: return 1; ! 5206: } ! 5207: ! 5208: /* Check a purported macro name SYMNAME, and yield its length. ! 5209: USAGE is the kind of name this is intended for. */ ! 5210: ! 5211: static int ! 5212: check_macro_name (symname, usage) ! 5213: U_CHAR *symname; ! 5214: char *usage; ! 5215: { ! 5216: U_CHAR *p; ! 5217: int sym_length; ! 5218: ! 5219: for (p = symname; is_idchar[*p]; p++) ! 5220: ; ! 5221: sym_length = p - symname; ! 5222: if (sym_length == 0) ! 5223: error ("invalid %s name", usage); ! 5224: else if (!is_idstart[*symname]) { ! 5225: U_CHAR *msg; /* what pain... */ ! 5226: msg = (U_CHAR *) alloca (sym_length + 1); ! 5227: bcopy (symname, msg, sym_length); ! 5228: msg[sym_length] = 0; ! 5229: error ("invalid %s name `%s'", usage, msg); ! 5230: } else { ! 5231: if (! strncmp (symname, "defined", 7) && sym_length == 7) ! 5232: error ("invalid %s name `defined'", usage); ! 5233: } ! 5234: return sym_length; ! 5235: } ! 5236: ! 5237: /* ! 5238: * return zero if two DEFINITIONs are isomorphic ! 5239: */ ! 5240: static int ! 5241: compare_defs (d1, d2) ! 5242: DEFINITION *d1, *d2; ! 5243: { ! 5244: register struct reflist *a1, *a2; ! 5245: register U_CHAR *p1 = d1->expansion; ! 5246: register U_CHAR *p2 = d2->expansion; ! 5247: int first = 1; ! 5248: ! 5249: if (d1->nargs != d2->nargs) ! 5250: return 1; ! 5251: if (strcmp ((char *)d1->args.argnames, (char *)d2->args.argnames)) ! 5252: return 1; ! 5253: for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2; ! 5254: a1 = a1->next, a2 = a2->next) { ! 5255: if (!((a1->nchars == a2->nchars && ! strncmp (p1, p2, a1->nchars)) ! 5256: || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0)) ! 5257: || a1->argno != a2->argno ! 5258: || a1->stringify != a2->stringify ! 5259: || a1->raw_before != a2->raw_before ! 5260: || a1->raw_after != a2->raw_after) ! 5261: return 1; ! 5262: first = 0; ! 5263: p1 += a1->nchars; ! 5264: p2 += a2->nchars; ! 5265: } ! 5266: if (a1 != a2) ! 5267: return 1; ! 5268: if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion), ! 5269: p2, d2->length - (p2 - d2->expansion), 1)) ! 5270: return 1; ! 5271: return 0; ! 5272: } ! 5273: ! 5274: /* Return 1 if two parts of two macro definitions are effectively different. ! 5275: One of the parts starts at BEG1 and has LEN1 chars; ! 5276: the other has LEN2 chars at BEG2. ! 5277: Any sequence of whitespace matches any other sequence of whitespace. ! 5278: FIRST means these parts are the first of a macro definition; ! 5279: so ignore leading whitespace entirely. ! 5280: LAST means these parts are the last of a macro definition; ! 5281: so ignore trailing whitespace entirely. */ ! 5282: ! 5283: static int ! 5284: comp_def_part (first, beg1, len1, beg2, len2, last) ! 5285: int first; ! 5286: U_CHAR *beg1, *beg2; ! 5287: int len1, len2; ! 5288: int last; ! 5289: { ! 5290: register U_CHAR *end1 = beg1 + len1; ! 5291: register U_CHAR *end2 = beg2 + len2; ! 5292: if (first) { ! 5293: while (beg1 != end1 && is_space[*beg1]) beg1++; ! 5294: while (beg2 != end2 && is_space[*beg2]) beg2++; ! 5295: } ! 5296: if (last) { ! 5297: while (beg1 != end1 && is_space[end1[-1]]) end1--; ! 5298: while (beg2 != end2 && is_space[end2[-1]]) end2--; ! 5299: } ! 5300: while (beg1 != end1 && beg2 != end2) { ! 5301: if (is_space[*beg1] && is_space[*beg2]) { ! 5302: while (beg1 != end1 && is_space[*beg1]) beg1++; ! 5303: while (beg2 != end2 && is_space[*beg2]) beg2++; ! 5304: } else if (*beg1 == *beg2) { ! 5305: beg1++; beg2++; ! 5306: } else break; ! 5307: } ! 5308: return (beg1 != end1) || (beg2 != end2); ! 5309: } ! 5310: ! 5311: /* Read a replacement list for a macro with parameters. ! 5312: Build the DEFINITION structure. ! 5313: Reads characters of text starting at BUF until END. ! 5314: ARGLIST specifies the formal parameters to look for ! 5315: in the text of the definition; NARGS is the number of args ! 5316: in that list, or -1 for a macro name that wants no argument list. ! 5317: MACRONAME is the macro name itself (so we can avoid recursive expansion) ! 5318: and NAMELEN is its length in characters. ! 5319: ! 5320: Note that comments and backslash-newlines have already been deleted ! 5321: from the argument. */ ! 5322: ! 5323: /* Leading and trailing Space, Tab, etc. are converted to markers ! 5324: Newline Space, Newline Tab, etc. ! 5325: Newline Space makes a space in the final output ! 5326: but is discarded if stringified. (Newline Tab is similar but ! 5327: makes a Tab instead.) ! 5328: ! 5329: If there is no trailing whitespace, a Newline Space is added at the end ! 5330: to prevent concatenation that would be contrary to the standard. */ ! 5331: ! 5332: static DEFINITION * ! 5333: collect_expansion (buf, end, nargs, arglist) ! 5334: U_CHAR *buf, *end; ! 5335: int nargs; ! 5336: struct arglist *arglist; ! 5337: { ! 5338: DEFINITION *defn; ! 5339: register U_CHAR *p, *limit, *lastp, *exp_p; ! 5340: struct reflist *endpat = NULL; ! 5341: /* Pointer to first nonspace after last ## seen. */ ! 5342: U_CHAR *concat = 0; ! 5343: /* Pointer to first nonspace after last single-# seen. */ ! 5344: U_CHAR *stringify = 0; ! 5345: int maxsize; ! 5346: int expected_delimiter = '\0'; ! 5347: ! 5348: /* Scan thru the replacement list, ignoring comments and quoted ! 5349: strings, picking up on the macro calls. It does a linear search ! 5350: thru the arg list on every potential symbol. Profiling might say ! 5351: that something smarter should happen. */ ! 5352: ! 5353: if (end < buf) ! 5354: abort (); ! 5355: ! 5356: /* Find the beginning of the trailing whitespace. */ ! 5357: /* Find end of leading whitespace. */ ! 5358: limit = end; ! 5359: p = buf; ! 5360: while (p < limit && is_space[limit[-1]]) limit--; ! 5361: while (p < limit && is_space[*p]) p++; ! 5362: ! 5363: /* Allocate space for the text in the macro definition. ! 5364: Leading and trailing whitespace chars need 2 bytes each. ! 5365: Each other input char may or may not need 1 byte, ! 5366: so this is an upper bound. ! 5367: The extra 2 are for invented trailing newline-marker and final null. */ ! 5368: maxsize = (sizeof (DEFINITION) ! 5369: + 2 * (end - limit) + 2 * (p - buf) ! 5370: + (limit - p) + 3); ! 5371: defn = (DEFINITION *) xcalloc (1, maxsize); ! 5372: ! 5373: defn->nargs = nargs; ! 5374: exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION); ! 5375: lastp = exp_p; ! 5376: ! 5377: p = buf; ! 5378: ! 5379: /* Convert leading whitespace to Newline-markers. */ ! 5380: while (p < limit && is_space[*p]) { ! 5381: *exp_p++ = '\n'; ! 5382: *exp_p++ = *p++; ! 5383: } ! 5384: ! 5385: if (limit - p >= 2 && p[0] == '#' && p[1] == '#') { ! 5386: error ("`##' at start of macro definition"); ! 5387: p += 2; ! 5388: } ! 5389: ! 5390: /* Process the main body of the definition. */ ! 5391: while (p < limit) { ! 5392: int skipped_arg = 0; ! 5393: register U_CHAR c = *p++; ! 5394: ! 5395: *exp_p++ = c; ! 5396: ! 5397: if (!traditional) { ! 5398: switch (c) { ! 5399: case '\'': ! 5400: case '\"': ! 5401: if (expected_delimiter != '\0') { ! 5402: if (c == expected_delimiter) ! 5403: expected_delimiter = '\0'; ! 5404: } else ! 5405: expected_delimiter = c; ! 5406: break; ! 5407: ! 5408: /* Special hack: if a \# is written in the #define ! 5409: include a # in the definition. This is useless for C code ! 5410: but useful for preprocessing other things. */ ! 5411: ! 5412: case '\\': ! 5413: /* \# quotes a # even outside of strings. */ ! 5414: if (p < limit && *p == '#' && !expected_delimiter) { ! 5415: exp_p--; ! 5416: *exp_p++ = *p++; ! 5417: } else if (p < limit && expected_delimiter) { ! 5418: /* In a string, backslash goes through ! 5419: and makes next char ordinary. */ ! 5420: *exp_p++ = *p++; ! 5421: } ! 5422: break; ! 5423: ! 5424: case '#': ! 5425: /* # is ordinary inside a string. */ ! 5426: if (expected_delimiter) ! 5427: break; ! 5428: if (p < limit && *p == '#') { ! 5429: /* ##: concatenate preceding and following tokens. */ ! 5430: /* Take out the first #, discard preceding whitespace. */ ! 5431: exp_p--; ! 5432: while (exp_p > lastp && is_hor_space[exp_p[-1]]) ! 5433: --exp_p; ! 5434: /* Skip the second #. */ ! 5435: p++; ! 5436: /* Discard following whitespace. */ ! 5437: SKIP_WHITE_SPACE (p); ! 5438: concat = p; ! 5439: if (p == limit) ! 5440: error ("`##' at end of macro definition"); ! 5441: } else if (nargs >= 0) { ! 5442: /* Single #: stringify following argument ref. ! 5443: Don't leave the # in the expansion. */ ! 5444: exp_p--; ! 5445: SKIP_WHITE_SPACE (p); ! 5446: if (p == limit || ! is_idstart[*p]) ! 5447: error ("`#' operator is not followed by a macro argument name"); ! 5448: else ! 5449: stringify = p; ! 5450: } ! 5451: break; ! 5452: } ! 5453: } else { ! 5454: /* In -traditional mode, recognize arguments inside strings and ! 5455: and character constants, and ignore special properties of #. ! 5456: Arguments inside strings are considered "stringified", but no ! 5457: extra quote marks are supplied. */ ! 5458: switch (c) { ! 5459: case '\'': ! 5460: case '\"': ! 5461: if (expected_delimiter != '\0') { ! 5462: if (c == expected_delimiter) ! 5463: expected_delimiter = '\0'; ! 5464: } else ! 5465: expected_delimiter = c; ! 5466: break; ! 5467: ! 5468: case '\\': ! 5469: /* Backslash quotes delimiters and itself, but not macro args. */ ! 5470: if (expected_delimiter != 0 && p < limit ! 5471: && (*p == expected_delimiter || *p == '\\')) { ! 5472: *exp_p++ = *p++; ! 5473: continue; ! 5474: } ! 5475: break; ! 5476: ! 5477: case '/': ! 5478: if (expected_delimiter != '\0') /* No comments inside strings. */ ! 5479: break; ! 5480: if (*p == '*') { ! 5481: /* If we find a comment that wasn't removed by handle_directive, ! 5482: this must be -traditional. So replace the comment with ! 5483: nothing at all. */ ! 5484: exp_p--; ! 5485: p += 1; ! 5486: while (p < limit && !(p[-2] == '*' && p[-1] == '/')) ! 5487: p++; ! 5488: #if 0 ! 5489: /* Mark this as a concatenation-point, as if it had been ##. */ ! 5490: concat = p; ! 5491: #endif ! 5492: } ! 5493: break; ! 5494: } ! 5495: } ! 5496: ! 5497: /* Handle the start of a symbol. */ ! 5498: if (is_idchar[c] && nargs > 0) { ! 5499: U_CHAR *id_beg = p - 1; ! 5500: int id_len; ! 5501: ! 5502: --exp_p; ! 5503: while (p != limit && is_idchar[*p]) p++; ! 5504: id_len = p - id_beg; ! 5505: ! 5506: if (is_idstart[c]) { ! 5507: register struct arglist *arg; ! 5508: ! 5509: for (arg = arglist; arg != NULL; arg = arg->next) { ! 5510: struct reflist *tpat; ! 5511: ! 5512: if (arg->name[0] == c ! 5513: && arg->length == id_len ! 5514: && strncmp (arg->name, id_beg, id_len) == 0) { ! 5515: if (expected_delimiter && warn_stringify) { ! 5516: if (traditional) { ! 5517: warning ("macro argument `%.*s' is stringified.", ! 5518: id_len, arg->name); ! 5519: } else { ! 5520: warning ("macro arg `%.*s' would be stringified with -traditional.", ! 5521: id_len, arg->name); ! 5522: } ! 5523: } ! 5524: /* If ANSI, don't actually substitute inside a string. */ ! 5525: if (!traditional && expected_delimiter) ! 5526: break; ! 5527: /* make a pat node for this arg and append it to the end of ! 5528: the pat list */ ! 5529: tpat = (struct reflist *) xmalloc (sizeof (struct reflist)); ! 5530: tpat->next = NULL; ! 5531: tpat->raw_before = concat == id_beg; ! 5532: tpat->raw_after = 0; ! 5533: tpat->rest_args = arg->rest_args; ! 5534: tpat->stringify = (traditional ? expected_delimiter != '\0' ! 5535: : stringify == id_beg); ! 5536: ! 5537: if (endpat == NULL) ! 5538: defn->pattern = tpat; ! 5539: else ! 5540: endpat->next = tpat; ! 5541: endpat = tpat; ! 5542: ! 5543: tpat->argno = arg->argno; ! 5544: tpat->nchars = exp_p - lastp; ! 5545: { ! 5546: register U_CHAR *p1 = p; ! 5547: SKIP_WHITE_SPACE (p1); ! 5548: if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#') ! 5549: tpat->raw_after = 1; ! 5550: } ! 5551: lastp = exp_p; /* place to start copying from next time */ ! 5552: skipped_arg = 1; ! 5553: break; ! 5554: } ! 5555: } ! 5556: } ! 5557: ! 5558: /* If this was not a macro arg, copy it into the expansion. */ ! 5559: if (! skipped_arg) { ! 5560: register U_CHAR *lim1 = p; ! 5561: p = id_beg; ! 5562: while (p != lim1) ! 5563: *exp_p++ = *p++; ! 5564: if (stringify == id_beg) ! 5565: error ("`#' operator should be followed by a macro argument name"); ! 5566: } ! 5567: } ! 5568: } ! 5569: ! 5570: if (limit < end) { ! 5571: /* Convert trailing whitespace to Newline-markers. */ ! 5572: while (limit < end && is_space[*limit]) { ! 5573: *exp_p++ = '\n'; ! 5574: *exp_p++ = *limit++; ! 5575: } ! 5576: } else if (!traditional && expected_delimiter == 0) { ! 5577: /* There is no trailing whitespace, so invent some in ANSI mode. ! 5578: But not if "inside a string" (which in ANSI mode ! 5579: happens only for -D option). */ ! 5580: *exp_p++ = '\n'; ! 5581: *exp_p++ = ' '; ! 5582: } ! 5583: ! 5584: *exp_p = '\0'; ! 5585: ! 5586: defn->length = exp_p - defn->expansion; ! 5587: ! 5588: /* Crash now if we overrun the allocated size. */ ! 5589: if (defn->length + 1 > maxsize) ! 5590: abort (); ! 5591: ! 5592: #if 0 ! 5593: /* This isn't worth the time it takes. */ ! 5594: /* give back excess storage */ ! 5595: defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1); ! 5596: #endif ! 5597: ! 5598: return defn; ! 5599: } ! 5600: ! 5601: static int ! 5602: do_assert (buf, limit, op, keyword) ! 5603: U_CHAR *buf, *limit; ! 5604: FILE_BUF *op; ! 5605: struct directive *keyword; ! 5606: { ! 5607: U_CHAR *bp; /* temp ptr into input buffer */ ! 5608: U_CHAR *symname; /* remember where symbol name starts */ ! 5609: int sym_length; /* and how long it is */ ! 5610: struct arglist *tokens = NULL; ! 5611: ! 5612: if (pedantic && done_initializing && !instack[indepth].system_header_p) ! 5613: pedwarn ("ANSI C does not allow `#assert'"); ! 5614: ! 5615: bp = buf; ! 5616: ! 5617: while (is_hor_space[*bp]) ! 5618: bp++; ! 5619: ! 5620: symname = bp; /* remember where it starts */ ! 5621: sym_length = check_macro_name (bp, "assertion"); ! 5622: bp += sym_length; ! 5623: /* #define doesn't do this, but we should. */ ! 5624: SKIP_WHITE_SPACE (bp); ! 5625: ! 5626: /* Lossage will occur if identifiers or control tokens are broken ! 5627: across lines using backslash. This is not the right place to take ! 5628: care of that. */ ! 5629: ! 5630: if (*bp != '(') { ! 5631: error ("missing token-sequence in `#assert'"); ! 5632: return 1; ! 5633: } ! 5634: ! 5635: { ! 5636: int error_flag = 0; ! 5637: ! 5638: bp++; /* skip '(' */ ! 5639: SKIP_WHITE_SPACE (bp); ! 5640: ! 5641: tokens = read_token_list (&bp, limit, &error_flag); ! 5642: if (error_flag) ! 5643: return 1; ! 5644: if (tokens == 0) { ! 5645: error ("empty token-sequence in `#assert'"); ! 5646: return 1; ! 5647: } ! 5648: ! 5649: ++bp; /* skip paren */ ! 5650: SKIP_WHITE_SPACE (bp); ! 5651: } ! 5652: ! 5653: /* If this name isn't already an assertion name, make it one. ! 5654: Error if it was already in use in some other way. */ ! 5655: ! 5656: { ! 5657: ASSERTION_HASHNODE *hp; ! 5658: int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE); ! 5659: struct tokenlist_list *value ! 5660: = (struct tokenlist_list *) xmalloc (sizeof (struct tokenlist_list)); ! 5661: ! 5662: hp = assertion_lookup (symname, sym_length, hashcode); ! 5663: if (hp == NULL) { ! 5664: if (sym_length == 7 && ! strncmp (symname, "defined", sym_length)) ! 5665: error ("`defined' redefined as assertion"); ! 5666: hp = assertion_install (symname, sym_length, hashcode); ! 5667: } ! 5668: ! 5669: /* Add the spec'd token-sequence to the list of such. */ ! 5670: value->tokens = tokens; ! 5671: value->next = hp->value; ! 5672: hp->value = value; ! 5673: } ! 5674: ! 5675: return 0; ! 5676: } ! 5677: ! 5678: static int ! 5679: do_unassert (buf, limit, op, keyword) ! 5680: U_CHAR *buf, *limit; ! 5681: FILE_BUF *op; ! 5682: struct directive *keyword; ! 5683: { ! 5684: U_CHAR *bp; /* temp ptr into input buffer */ ! 5685: U_CHAR *symname; /* remember where symbol name starts */ ! 5686: int sym_length; /* and how long it is */ ! 5687: ! 5688: struct arglist *tokens = NULL; ! 5689: int tokens_specified = 0; ! 5690: ! 5691: if (pedantic && done_initializing && !instack[indepth].system_header_p) ! 5692: pedwarn ("ANSI C does not allow `#unassert'"); ! 5693: ! 5694: bp = buf; ! 5695: ! 5696: while (is_hor_space[*bp]) ! 5697: bp++; ! 5698: ! 5699: symname = bp; /* remember where it starts */ ! 5700: sym_length = check_macro_name (bp, "assertion"); ! 5701: bp += sym_length; ! 5702: /* #define doesn't do this, but we should. */ ! 5703: SKIP_WHITE_SPACE (bp); ! 5704: ! 5705: /* Lossage will occur if identifiers or control tokens are broken ! 5706: across lines using backslash. This is not the right place to take ! 5707: care of that. */ ! 5708: ! 5709: if (*bp == '(') { ! 5710: int error_flag = 0; ! 5711: ! 5712: bp++; /* skip '(' */ ! 5713: SKIP_WHITE_SPACE (bp); ! 5714: ! 5715: tokens = read_token_list (&bp, limit, &error_flag); ! 5716: if (error_flag) ! 5717: return 1; ! 5718: if (tokens == 0) { ! 5719: error ("empty token list in `#unassert'"); ! 5720: return 1; ! 5721: } ! 5722: ! 5723: tokens_specified = 1; ! 5724: ! 5725: ++bp; /* skip paren */ ! 5726: SKIP_WHITE_SPACE (bp); ! 5727: } ! 5728: ! 5729: { ! 5730: ASSERTION_HASHNODE *hp; ! 5731: int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE); ! 5732: struct tokenlist_list *tail, *prev; ! 5733: ! 5734: hp = assertion_lookup (symname, sym_length, hashcode); ! 5735: if (hp == NULL) ! 5736: return 1; ! 5737: ! 5738: /* If no token list was specified, then eliminate this assertion ! 5739: entirely. */ ! 5740: if (! tokens_specified) { ! 5741: struct tokenlist_list *next; ! 5742: for (tail = hp->value; tail; tail = next) { ! 5743: next = tail->next; ! 5744: free_token_list (tail->tokens); ! 5745: free (tail); ! 5746: } ! 5747: delete_assertion (hp); ! 5748: } else { ! 5749: /* If a list of tokens was given, then delete any matching list. */ ! 5750: ! 5751: tail = hp->value; ! 5752: prev = 0; ! 5753: while (tail) { ! 5754: struct tokenlist_list *next = tail->next; ! 5755: if (compare_token_lists (tail->tokens, tokens)) { ! 5756: if (prev) ! 5757: prev->next = next; ! 5758: else ! 5759: hp->value = tail->next; ! 5760: free_token_list (tail->tokens); ! 5761: free (tail); ! 5762: } else { ! 5763: prev = tail; ! 5764: } ! 5765: tail = next; ! 5766: } ! 5767: } ! 5768: } ! 5769: ! 5770: return 0; ! 5771: } ! 5772: ! 5773: /* Test whether there is an assertion named NAME ! 5774: and optionally whether it has an asserted token list TOKENS. ! 5775: NAME is not null terminated; its length is SYM_LENGTH. ! 5776: If TOKENS_SPECIFIED is 0, then don't check for any token list. */ ! 5777: ! 5778: int ! 5779: check_assertion (name, sym_length, tokens_specified, tokens) ! 5780: U_CHAR *name; ! 5781: int sym_length; ! 5782: int tokens_specified; ! 5783: struct arglist *tokens; ! 5784: { ! 5785: ASSERTION_HASHNODE *hp; ! 5786: int hashcode = hashf (name, sym_length, ASSERTION_HASHSIZE); ! 5787: ! 5788: if (pedantic && !instack[indepth].system_header_p) ! 5789: pedwarn ("ANSI C does not allow testing assertions"); ! 5790: ! 5791: hp = assertion_lookup (name, sym_length, hashcode); ! 5792: if (hp == NULL) ! 5793: /* It is not an assertion; just return false. */ ! 5794: return 0; ! 5795: ! 5796: /* If no token list was specified, then value is 1. */ ! 5797: if (! tokens_specified) ! 5798: return 1; ! 5799: ! 5800: { ! 5801: struct tokenlist_list *tail; ! 5802: ! 5803: tail = hp->value; ! 5804: ! 5805: /* If a list of tokens was given, ! 5806: then succeed if the assertion records a matching list. */ ! 5807: ! 5808: while (tail) { ! 5809: if (compare_token_lists (tail->tokens, tokens)) ! 5810: return 1; ! 5811: tail = tail->next; ! 5812: } ! 5813: ! 5814: /* Fail if the assertion has no matching list. */ ! 5815: return 0; ! 5816: } ! 5817: } ! 5818: ! 5819: /* Compare two lists of tokens for equality including order of tokens. */ ! 5820: ! 5821: static int ! 5822: compare_token_lists (l1, l2) ! 5823: struct arglist *l1, *l2; ! 5824: { ! 5825: while (l1 && l2) { ! 5826: if (l1->length != l2->length) ! 5827: return 0; ! 5828: if (strncmp (l1->name, l2->name, l1->length)) ! 5829: return 0; ! 5830: l1 = l1->next; ! 5831: l2 = l2->next; ! 5832: } ! 5833: ! 5834: /* Succeed if both lists end at the same time. */ ! 5835: return l1 == l2; ! 5836: } ! 5837: ! 5838: /* Read a space-separated list of tokens ending in a close parenthesis. ! 5839: Return a list of strings, in the order they were written. ! 5840: (In case of error, return 0 and store -1 in *ERROR_FLAG.) ! 5841: Parse the text starting at *BPP, and update *BPP. ! 5842: Don't parse beyond LIMIT. */ ! 5843: ! 5844: static struct arglist * ! 5845: read_token_list (bpp, limit, error_flag) ! 5846: U_CHAR **bpp; ! 5847: U_CHAR *limit; ! 5848: int *error_flag; ! 5849: { ! 5850: struct arglist *token_ptrs = 0; ! 5851: U_CHAR *bp = *bpp; ! 5852: int depth = 1; ! 5853: ! 5854: *error_flag = 0; ! 5855: ! 5856: /* Loop over the assertion value tokens. */ ! 5857: while (depth > 0) { ! 5858: struct arglist *temp; ! 5859: int eofp = 0; ! 5860: U_CHAR *beg = bp; ! 5861: ! 5862: /* Find the end of the token. */ ! 5863: if (*bp == '(') { ! 5864: bp++; ! 5865: depth++; ! 5866: } else if (*bp == ')') { ! 5867: depth--; ! 5868: if (depth == 0) ! 5869: break; ! 5870: bp++; ! 5871: } else if (*bp == '"' || *bp == '\'') ! 5872: bp = skip_quoted_string (bp, limit, 0, NULL_PTR, NULL_PTR, &eofp); ! 5873: else ! 5874: while (! is_hor_space[*bp] && *bp != '(' && *bp != ')' ! 5875: && *bp != '"' && *bp != '\'' && bp != limit) ! 5876: bp++; ! 5877: ! 5878: temp = (struct arglist *) xmalloc (sizeof (struct arglist)); ! 5879: temp->name = (U_CHAR *) xmalloc (bp - beg + 1); ! 5880: bcopy (beg, temp->name, bp - beg); ! 5881: temp->name[bp - beg] = 0; ! 5882: temp->next = token_ptrs; ! 5883: token_ptrs = temp; ! 5884: temp->length = bp - beg; ! 5885: ! 5886: SKIP_WHITE_SPACE (bp); ! 5887: ! 5888: if (bp >= limit) { ! 5889: error ("unterminated token sequence in `#assert' or `#unassert'"); ! 5890: *error_flag = -1; ! 5891: return 0; ! 5892: } ! 5893: } ! 5894: *bpp = bp; ! 5895: ! 5896: /* We accumulated the names in reverse order. ! 5897: Now reverse them to get the proper order. */ ! 5898: { ! 5899: register struct arglist *prev = 0, *this, *next; ! 5900: for (this = token_ptrs; this; this = next) { ! 5901: next = this->next; ! 5902: this->next = prev; ! 5903: prev = this; ! 5904: } ! 5905: return prev; ! 5906: } ! 5907: } ! 5908: ! 5909: static void ! 5910: free_token_list (tokens) ! 5911: struct arglist *tokens; ! 5912: { ! 5913: while (tokens) { ! 5914: struct arglist *next = tokens->next; ! 5915: free (tokens->name); ! 5916: free (tokens); ! 5917: tokens = next; ! 5918: } ! 5919: } ! 5920: ! 5921: /* ! 5922: * Install a name in the assertion hash table. ! 5923: * ! 5924: * If LEN is >= 0, it is the length of the name. ! 5925: * Otherwise, compute the length by scanning the entire name. ! 5926: * ! 5927: * If HASH is >= 0, it is the precomputed hash code. ! 5928: * Otherwise, compute the hash code. ! 5929: */ ! 5930: static ASSERTION_HASHNODE * ! 5931: assertion_install (name, len, hash) ! 5932: U_CHAR *name; ! 5933: int len; ! 5934: int hash; ! 5935: { ! 5936: register ASSERTION_HASHNODE *hp; ! 5937: register int i, bucket; ! 5938: register U_CHAR *p, *q; ! 5939: ! 5940: i = sizeof (ASSERTION_HASHNODE) + len + 1; ! 5941: hp = (ASSERTION_HASHNODE *) xmalloc (i); ! 5942: bucket = hash; ! 5943: hp->bucket_hdr = &assertion_hashtab[bucket]; ! 5944: hp->next = assertion_hashtab[bucket]; ! 5945: assertion_hashtab[bucket] = hp; ! 5946: hp->prev = NULL; ! 5947: if (hp->next != NULL) ! 5948: hp->next->prev = hp; ! 5949: hp->length = len; ! 5950: hp->value = 0; ! 5951: hp->name = ((U_CHAR *) hp) + sizeof (ASSERTION_HASHNODE); ! 5952: p = hp->name; ! 5953: q = name; ! 5954: for (i = 0; i < len; i++) ! 5955: *p++ = *q++; ! 5956: hp->name[len] = 0; ! 5957: return hp; ! 5958: } ! 5959: ! 5960: /* ! 5961: * find the most recent hash node for name name (ending with first ! 5962: * non-identifier char) installed by install ! 5963: * ! 5964: * If LEN is >= 0, it is the length of the name. ! 5965: * Otherwise, compute the length by scanning the entire name. ! 5966: * ! 5967: * If HASH is >= 0, it is the precomputed hash code. ! 5968: * Otherwise, compute the hash code. ! 5969: */ ! 5970: static ASSERTION_HASHNODE * ! 5971: assertion_lookup (name, len, hash) ! 5972: U_CHAR *name; ! 5973: int len; ! 5974: int hash; ! 5975: { ! 5976: register U_CHAR *bp; ! 5977: register ASSERTION_HASHNODE *bucket; ! 5978: ! 5979: bucket = assertion_hashtab[hash]; ! 5980: while (bucket) { ! 5981: if (bucket->length == len && strncmp (bucket->name, name, len) == 0) ! 5982: return bucket; ! 5983: bucket = bucket->next; ! 5984: } ! 5985: return NULL; ! 5986: } ! 5987: ! 5988: static void ! 5989: delete_assertion (hp) ! 5990: ASSERTION_HASHNODE *hp; ! 5991: { ! 5992: ! 5993: if (hp->prev != NULL) ! 5994: hp->prev->next = hp->next; ! 5995: if (hp->next != NULL) ! 5996: hp->next->prev = hp->prev; ! 5997: ! 5998: /* make sure that the bucket chain header that ! 5999: the deleted guy was on points to the right thing afterwards. */ ! 6000: if (hp == *hp->bucket_hdr) ! 6001: *hp->bucket_hdr = hp->next; ! 6002: ! 6003: free (hp); ! 6004: } ! 6005: ! 6006: /* ! 6007: * interpret #line command. Remembers previously seen fnames ! 6008: * in its very own hash table. ! 6009: */ ! 6010: #define FNAME_HASHSIZE 37 ! 6011: ! 6012: static int ! 6013: do_line (buf, limit, op, keyword) ! 6014: U_CHAR *buf, *limit; ! 6015: FILE_BUF *op; ! 6016: struct directive *keyword; ! 6017: { ! 6018: register U_CHAR *bp; ! 6019: FILE_BUF *ip = &instack[indepth]; ! 6020: FILE_BUF tem; ! 6021: int new_lineno; ! 6022: enum file_change_code file_change = same_file; ! 6023: ! 6024: /* Expand any macros. */ ! 6025: tem = expand_to_temp_buffer (buf, limit, 0, 0); ! 6026: ! 6027: /* Point to macroexpanded line, which is null-terminated now. */ ! 6028: bp = tem.buf; ! 6029: SKIP_WHITE_SPACE (bp); ! 6030: ! 6031: if (!isdigit (*bp)) { ! 6032: error ("invalid format `#line' command"); ! 6033: return 0; ! 6034: } ! 6035: ! 6036: /* The Newline at the end of this line remains to be processed. ! 6037: To put the next line at the specified line number, ! 6038: we must store a line number now that is one less. */ ! 6039: new_lineno = atoi (bp) - 1; ! 6040: ! 6041: /* NEW_LINENO is one less than the actual line number here. */ ! 6042: if (pedantic && new_lineno < 0) ! 6043: pedwarn ("line number out of range in `#line' command"); ! 6044: ! 6045: /* skip over the line number. */ ! 6046: while (isdigit (*bp)) ! 6047: bp++; ! 6048: ! 6049: #if 0 /* #line 10"foo.c" is supposed to be allowed. */ ! 6050: if (*bp && !is_space[*bp]) { ! 6051: error ("invalid format `#line' command"); ! 6052: return; ! 6053: } ! 6054: #endif ! 6055: ! 6056: SKIP_WHITE_SPACE (bp); ! 6057: ! 6058: if (*bp == '\"') { ! 6059: static HASHNODE *fname_table[FNAME_HASHSIZE]; ! 6060: HASHNODE *hp, **hash_bucket; ! 6061: U_CHAR *fname, *p; ! 6062: int fname_length; ! 6063: ! 6064: fname = ++bp; ! 6065: ! 6066: /* Turn the file name, which is a character string literal, ! 6067: into a null-terminated string. Do this in place. */ ! 6068: p = bp; ! 6069: for (;;) ! 6070: switch ((*p++ = *bp++)) { ! 6071: case '\0': ! 6072: error ("invalid format `#line' command"); ! 6073: return 0; ! 6074: ! 6075: case '\\': ! 6076: { ! 6077: char *bpc = (char *) bp; ! 6078: int c = parse_escape (&bpc); ! 6079: bp = (U_CHAR *) bpc; ! 6080: if (c < 0) ! 6081: p--; ! 6082: else ! 6083: p[-1] = c; ! 6084: } ! 6085: break; ! 6086: ! 6087: case '\"': ! 6088: p[-1] = 0; ! 6089: goto fname_done; ! 6090: } ! 6091: fname_done: ! 6092: fname_length = p - fname; ! 6093: ! 6094: SKIP_WHITE_SPACE (bp); ! 6095: if (*bp) { ! 6096: if (pedantic) ! 6097: pedwarn ("garbage at end of `#line' command"); ! 6098: if (*bp == '1') ! 6099: file_change = enter_file; ! 6100: else if (*bp == '2') ! 6101: file_change = leave_file; ! 6102: else if (*bp == '3') ! 6103: ip->system_header_p = 1; ! 6104: else if (*bp == '4') ! 6105: ip->system_header_p = 2; ! 6106: else { ! 6107: error ("invalid format `#line' command"); ! 6108: return 0; ! 6109: } ! 6110: ! 6111: bp++; ! 6112: SKIP_WHITE_SPACE (bp); ! 6113: if (*bp == '3') { ! 6114: ip->system_header_p = 1; ! 6115: bp++; ! 6116: SKIP_WHITE_SPACE (bp); ! 6117: } ! 6118: if (*bp == '4') { ! 6119: ip->system_header_p = 2; ! 6120: bp++; ! 6121: SKIP_WHITE_SPACE (bp); ! 6122: } ! 6123: if (*bp) { ! 6124: error ("invalid format `#line' command"); ! 6125: return 0; ! 6126: } ! 6127: } ! 6128: ! 6129: hash_bucket = ! 6130: &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)]; ! 6131: for (hp = *hash_bucket; hp != NULL; hp = hp->next) ! 6132: if (hp->length == fname_length && ! 6133: strncmp (hp->value.cpval, fname, fname_length) == 0) { ! 6134: ip->nominal_fname = hp->value.cpval; ! 6135: break; ! 6136: } ! 6137: if (hp == 0) { ! 6138: /* Didn't find it; cons up a new one. */ ! 6139: hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1); ! 6140: hp->next = *hash_bucket; ! 6141: *hash_bucket = hp; ! 6142: ! 6143: hp->length = fname_length; ! 6144: ip->nominal_fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE); ! 6145: bcopy (fname, hp->value.cpval, fname_length); ! 6146: } ! 6147: } else if (*bp) { ! 6148: error ("invalid format `#line' command"); ! 6149: return 0; ! 6150: } ! 6151: ! 6152: ip->lineno = new_lineno; ! 6153: output_line_command (ip, op, 0, file_change); ! 6154: check_expand (op, ip->length - (ip->bufp - ip->buf)); ! 6155: return 0; ! 6156: } ! 6157: ! 6158: /* ! 6159: * remove the definition of a symbol from the symbol table. ! 6160: * according to un*x /lib/cpp, it is not an error to undef ! 6161: * something that has no definitions, so it isn't one here either. ! 6162: */ ! 6163: ! 6164: static int ! 6165: do_undef (buf, limit, op, keyword) ! 6166: U_CHAR *buf, *limit; ! 6167: FILE_BUF *op; ! 6168: struct directive *keyword; ! 6169: { ! 6170: int sym_length; ! 6171: HASHNODE *hp; ! 6172: U_CHAR *orig_buf = buf; ! 6173: ! 6174: /* If this is a precompiler run (with -pcp) pass thru #undef commands. */ ! 6175: if (pcp_outfile && op) ! 6176: pass_thru_directive (buf, limit, op, keyword); ! 6177: ! 6178: SKIP_WHITE_SPACE (buf); ! 6179: sym_length = check_macro_name (buf, "macro"); ! 6180: ! 6181: while ((hp = lookup (buf, sym_length, -1)) != NULL) { ! 6182: /* If we are generating additional info for debugging (with -g) we ! 6183: need to pass through all effective #undef commands. */ ! 6184: if (debug_output && op) ! 6185: pass_thru_directive (orig_buf, limit, op, keyword); ! 6186: if (hp->type != T_MACRO) ! 6187: warning ("undefining `%s'", hp->name); ! 6188: delete_macro (hp); ! 6189: } ! 6190: ! 6191: if (pedantic) { ! 6192: buf += sym_length; ! 6193: SKIP_WHITE_SPACE (buf); ! 6194: if (buf != limit) ! 6195: pedwarn ("garbage after `#undef' directive"); ! 6196: } ! 6197: return 0; ! 6198: } ! 6199: ! 6200: /* ! 6201: * Report a fatal error detected by the program we are processing. ! 6202: * Use the text of the line in the error message, then terminate. ! 6203: * (We use error because it prints the filename & line#.) ! 6204: */ ! 6205: ! 6206: static int ! 6207: do_error (buf, limit, op, keyword) ! 6208: U_CHAR *buf, *limit; ! 6209: FILE_BUF *op; ! 6210: struct directive *keyword; ! 6211: { ! 6212: int length = limit - buf; ! 6213: U_CHAR *copy = (U_CHAR *) xmalloc (length + 1); ! 6214: bcopy (buf, copy, length); ! 6215: copy[length] = 0; ! 6216: SKIP_WHITE_SPACE (copy); ! 6217: error ("#error %s", copy); ! 6218: exit (FAILURE_EXIT_CODE); ! 6219: /* NOTREACHED */ ! 6220: return 0; ! 6221: } ! 6222: ! 6223: /* ! 6224: * Report a warning detected by the program we are processing. ! 6225: * Use the text of the line in the warning message, then continue. ! 6226: * (We use error because it prints the filename & line#.) ! 6227: */ ! 6228: ! 6229: static int ! 6230: do_warning (buf, limit, op, keyword) ! 6231: U_CHAR *buf, *limit; ! 6232: FILE_BUF *op; ! 6233: struct directive *keyword; ! 6234: { ! 6235: int length = limit - buf; ! 6236: U_CHAR *copy = (U_CHAR *) xmalloc (length + 1); ! 6237: bcopy (buf, copy, length); ! 6238: copy[length] = 0; ! 6239: SKIP_WHITE_SPACE (copy); ! 6240: warning ("#warning %s", copy); ! 6241: return 0; ! 6242: } ! 6243: ! 6244: /* Remember the name of the current file being read from so that we can ! 6245: avoid ever including it again. */ ! 6246: ! 6247: static int ! 6248: do_once () ! 6249: { ! 6250: int i; ! 6251: FILE_BUF *ip = NULL; ! 6252: ! 6253: for (i = indepth; i >= 0; i--) ! 6254: if (instack[i].fname != NULL) { ! 6255: ip = &instack[i]; ! 6256: break; ! 6257: } ! 6258: ! 6259: if (ip != NULL) { ! 6260: struct file_name_list *new; ! 6261: ! 6262: new = (struct file_name_list *) xmalloc (sizeof (struct file_name_list)); ! 6263: new->next = dont_repeat_files; ! 6264: dont_repeat_files = new; ! 6265: new->fname = savestring (ip->fname); ! 6266: new->control_macro = 0; ! 6267: new->c_system_include_path = 0; ! 6268: } ! 6269: return 0; ! 6270: } ! 6271: ! 6272: /* #ident has already been copied to the output file, so just ignore it. */ ! 6273: ! 6274: static int ! 6275: do_ident (buf, limit) ! 6276: U_CHAR *buf, *limit; ! 6277: { ! 6278: FILE_BUF trybuf; ! 6279: int len; ! 6280: FILE_BUF *op = &outbuf; ! 6281: ! 6282: /* Allow #ident in system headers, since that's not user's fault. */ ! 6283: if (pedantic && !instack[indepth].system_header_p) ! 6284: pedwarn ("ANSI C does not allow `#ident'"); ! 6285: ! 6286: trybuf = expand_to_temp_buffer (buf, limit, 0, 0); ! 6287: buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1); ! 6288: bcopy (trybuf.buf, buf, trybuf.bufp - trybuf.buf); ! 6289: limit = buf + (trybuf.bufp - trybuf.buf); ! 6290: len = (limit - buf); ! 6291: free (trybuf.buf); ! 6292: ! 6293: /* Output directive name. */ ! 6294: check_expand (op, 8); ! 6295: bcopy ("#ident ", op->bufp, 7); ! 6296: op->bufp += 7; ! 6297: ! 6298: /* Output the expanded argument line. */ ! 6299: check_expand (op, len); ! 6300: bcopy (buf, op->bufp, len); ! 6301: op->bufp += len; ! 6302: ! 6303: return 0; ! 6304: } ! 6305: ! 6306: /* #pragma and its argument line have already been copied to the output file. ! 6307: Just check for some recognized pragmas that need validation here. */ ! 6308: ! 6309: static int ! 6310: do_pragma (buf, limit) ! 6311: U_CHAR *buf, *limit; ! 6312: { ! 6313: while (*buf == ' ' || *buf == '\t') ! 6314: buf++; ! 6315: if (!strncmp (buf, "once", 4)) { ! 6316: /* Allow #pragma once in system headers, since that's not the user's ! 6317: fault. */ ! 6318: if (!instack[indepth].system_header_p) ! 6319: warning ("`#pragma once' is obsolete"); ! 6320: do_once (); ! 6321: } ! 6322: ! 6323: if (!strncmp (buf, "cplusplus", 9)) ! 6324: { ! 6325: if (instack[indepth].system_header_p == 2 && cplusplus) ! 6326: { ! 6327: instack[indepth].system_header_p = 1; ! 6328: output_line_command (&instack[indepth], &outbuf, 0, same_file); ! 6329: } ! 6330: } ! 6331: ! 6332: if (!strncmp (buf, "implementation", 14)) { ! 6333: /* Be quiet about `#pragma implementation' for a file only if it hasn't ! 6334: been included yet. */ ! 6335: struct file_name_list *ptr; ! 6336: U_CHAR *p = buf + 14, *fname, *inc_fname; ! 6337: SKIP_WHITE_SPACE (p); ! 6338: if (*p == '\n' || *p != '\"') ! 6339: return 0; ! 6340: ! 6341: fname = p + 1; ! 6342: if (p = (U_CHAR *) index (fname, '\"')) ! 6343: *p = '\0'; ! 6344: ! 6345: for (ptr = all_include_files; ptr; ptr = ptr->next) { ! 6346: inc_fname = (U_CHAR *) rindex (ptr->fname, '/'); ! 6347: inc_fname = inc_fname ? inc_fname + 1 : (U_CHAR *) ptr->fname; ! 6348: if (inc_fname && !strcmp (inc_fname, fname)) ! 6349: warning ("`#pragma implementation' for `%s' appears after file is included", ! 6350: fname); ! 6351: } ! 6352: } ! 6353: ! 6354: return 0; ! 6355: } ! 6356: ! 6357: #if 0 ! 6358: /* This was a fun hack, but #pragma seems to start to be useful. ! 6359: By failing to recognize it, we pass it through unchanged to cc1. */ ! 6360: ! 6361: /* ! 6362: * the behavior of the #pragma directive is implementation defined. ! 6363: * this implementation defines it as follows. ! 6364: */ ! 6365: ! 6366: static int ! 6367: do_pragma () ! 6368: { ! 6369: close (0); ! 6370: if (open ("/dev/tty", O_RDONLY, 0666) != 0) ! 6371: goto nope; ! 6372: close (1); ! 6373: if (open ("/dev/tty", O_WRONLY, 0666) != 1) ! 6374: goto nope; ! 6375: execl ("/usr/games/hack", "#pragma", 0); ! 6376: execl ("/usr/games/rogue", "#pragma", 0); ! 6377: execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0); ! 6378: execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0); ! 6379: nope: ! 6380: fatal ("You are in a maze of twisty compiler features, all different"); ! 6381: } ! 6382: #endif ! 6383: ! 6384: /* Just ignore #sccs, on systems where we define it at all. */ ! 6385: ! 6386: static int ! 6387: do_sccs () ! 6388: { ! 6389: if (pedantic) ! 6390: pedwarn ("ANSI C does not allow `#sccs'"); ! 6391: return 0; ! 6392: } ! 6393: ! 6394: /* ! 6395: * handle #if command by ! 6396: * 1) inserting special `defined' keyword into the hash table ! 6397: * that gets turned into 0 or 1 by special_symbol (thus, ! 6398: * if the luser has a symbol called `defined' already, it won't ! 6399: * work inside the #if command) ! 6400: * 2) rescan the input into a temporary output buffer ! 6401: * 3) pass the output buffer to the yacc parser and collect a value ! 6402: * 4) clean up the mess left from steps 1 and 2. ! 6403: * 5) call conditional_skip to skip til the next #endif (etc.), ! 6404: * or not, depending on the value from step 3. ! 6405: */ ! 6406: ! 6407: static int ! 6408: do_if (buf, limit, op, keyword) ! 6409: U_CHAR *buf, *limit; ! 6410: FILE_BUF *op; ! 6411: struct directive *keyword; ! 6412: { ! 6413: int value; ! 6414: FILE_BUF *ip = &instack[indepth]; ! 6415: ! 6416: value = eval_if_expression (buf, limit - buf); ! 6417: conditional_skip (ip, value == 0, T_IF, NULL_PTR); ! 6418: return 0; ! 6419: } ! 6420: ! 6421: /* ! 6422: * handle a #elif directive by not changing if_stack either. ! 6423: * see the comment above do_else. ! 6424: */ ! 6425: ! 6426: static int ! 6427: do_elif (buf, limit, op, keyword) ! 6428: U_CHAR *buf, *limit; ! 6429: FILE_BUF *op; ! 6430: struct directive *keyword; ! 6431: { ! 6432: int value; ! 6433: FILE_BUF *ip = &instack[indepth]; ! 6434: ! 6435: if (if_stack == instack[indepth].if_stack) { ! 6436: error ("`#elif' not within a conditional"); ! 6437: return 0; ! 6438: } else { ! 6439: if (if_stack->type != T_IF && if_stack->type != T_ELIF) { ! 6440: error ("`#elif' after `#else'"); ! 6441: #ifdef REPORT_EVENT ! 6442: REPORT_EVENT (0, NULL, if_stack->fname, if_stack->lineno, ! 6443: "matching conditional", 0, 0, 0); ! 6444: #endif ! 6445: fprintf (stderr, " (matches line %d", if_stack->lineno); ! 6446: if (if_stack->fname != NULL && ip->fname != NULL && ! 6447: strcmp (if_stack->fname, ip->nominal_fname) != 0) ! 6448: fprintf (stderr, ", file %s", if_stack->fname); ! 6449: fprintf (stderr, ")\n"); ! 6450: } ! 6451: if_stack->type = T_ELIF; ! 6452: } ! 6453: ! 6454: if (if_stack->if_succeeded) ! 6455: skip_if_group (ip, 0); ! 6456: else { ! 6457: value = eval_if_expression (buf, limit - buf); ! 6458: if (value == 0) ! 6459: skip_if_group (ip, 0); ! 6460: else { ! 6461: ++if_stack->if_succeeded; /* continue processing input */ ! 6462: output_line_command (ip, op, 1, same_file); ! 6463: } ! 6464: } ! 6465: return 0; ! 6466: } ! 6467: ! 6468: /* ! 6469: * evaluate a #if expression in BUF, of length LENGTH, ! 6470: * then parse the result as a C expression and return the value as an int. ! 6471: */ ! 6472: static int ! 6473: eval_if_expression (buf, length) ! 6474: U_CHAR *buf; ! 6475: int length; ! 6476: { ! 6477: FILE_BUF temp_obuf; ! 6478: HASHNODE *save_defined; ! 6479: int value; ! 6480: ! 6481: save_defined = install ("defined", -1, T_SPEC_DEFINED, 0, 0, -1); ! 6482: pcp_inside_if = 1; ! 6483: temp_obuf = expand_to_temp_buffer (buf, buf + length, 0, 1); ! 6484: pcp_inside_if = 0; ! 6485: delete_macro (save_defined); /* clean up special symbol */ ! 6486: ! 6487: value = parse_c_expression (temp_obuf.buf); ! 6488: ! 6489: free (temp_obuf.buf); ! 6490: ! 6491: return value; ! 6492: } ! 6493: ! 6494: /* ! 6495: * routine to handle ifdef/ifndef. Try to look up the symbol, ! 6496: * then do or don't skip to the #endif/#else/#elif depending ! 6497: * on what directive is actually being processed. ! 6498: */ ! 6499: ! 6500: static int ! 6501: do_xifdef (buf, limit, op, keyword) ! 6502: U_CHAR *buf, *limit; ! 6503: FILE_BUF *op; ! 6504: struct directive *keyword; ! 6505: { ! 6506: int skip; ! 6507: FILE_BUF *ip = &instack[indepth]; ! 6508: U_CHAR *end; ! 6509: int start_of_file = 0; ! 6510: U_CHAR *control_macro = 0; ! 6511: ! 6512: /* Detect a #ifndef at start of file (not counting comments). */ ! 6513: if (ip->fname != 0 && keyword->type == T_IFNDEF) { ! 6514: U_CHAR *p = ip->buf; ! 6515: while (p != directive_start) { ! 6516: U_CHAR c = *p++; ! 6517: if (is_space[c]) ! 6518: ; ! 6519: else if (c == '/' && p != ip->bufp && *p == '*') { ! 6520: /* Skip this comment. */ ! 6521: int junk; ! 6522: U_CHAR *save_bufp = ip->bufp; ! 6523: ip->bufp = p + 1; ! 6524: p = skip_to_end_of_comment (ip, &junk, 1); ! 6525: ip->bufp = save_bufp; ! 6526: } else { ! 6527: goto fail; ! 6528: } ! 6529: } ! 6530: /* If we get here, this conditional is the beginning of the file. */ ! 6531: start_of_file = 1; ! 6532: fail: ; ! 6533: } ! 6534: ! 6535: /* Discard leading and trailing whitespace. */ ! 6536: SKIP_WHITE_SPACE (buf); ! 6537: while (limit != buf && is_hor_space[limit[-1]]) limit--; ! 6538: ! 6539: /* Find the end of the identifier at the beginning. */ ! 6540: for (end = buf; is_idchar[*end]; end++); ! 6541: ! 6542: if (end == buf) { ! 6543: skip = (keyword->type == T_IFDEF); ! 6544: if (! traditional) ! 6545: pedwarn (end == limit ? "`#%s' with no argument" ! 6546: : "`#%s' argument starts with punctuation", ! 6547: keyword->name); ! 6548: } else { ! 6549: HASHNODE *hp; ! 6550: ! 6551: if (pedantic && buf[0] >= '0' && buf[0] <= '9') ! 6552: pedwarn ("`#%s' argument starts with a digit", keyword->name); ! 6553: else if (end != limit && !traditional) ! 6554: pedwarn ("garbage at end of `#%s' argument", keyword->name); ! 6555: ! 6556: hp = lookup (buf, end-buf, -1); ! 6557: ! 6558: if (pcp_outfile) { ! 6559: /* Output a precondition for this macro. */ ! 6560: if (hp && hp->value.defn->predefined) ! 6561: fprintf (pcp_outfile, "#define %s\n", hp->name); ! 6562: else { ! 6563: U_CHAR *cp = buf; ! 6564: fprintf (pcp_outfile, "#undef "); ! 6565: while (is_idchar[*cp]) /* Ick! */ ! 6566: fputc (*cp++, pcp_outfile); ! 6567: putc ('\n', pcp_outfile); ! 6568: } ! 6569: } ! 6570: ! 6571: skip = (hp == NULL) ^ (keyword->type == T_IFNDEF); ! 6572: if (start_of_file && !skip) { ! 6573: control_macro = (U_CHAR *) xmalloc (end - buf + 1); ! 6574: bcopy (buf, control_macro, end - buf); ! 6575: control_macro[end - buf] = 0; ! 6576: } ! 6577: } ! 6578: ! 6579: conditional_skip (ip, skip, T_IF, control_macro); ! 6580: return 0; ! 6581: } ! 6582: ! 6583: /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead. ! 6584: If this is a #ifndef starting at the beginning of a file, ! 6585: CONTROL_MACRO is the macro name tested by the #ifndef. ! 6586: Otherwise, CONTROL_MACRO is 0. */ ! 6587: ! 6588: static void ! 6589: conditional_skip (ip, skip, type, control_macro) ! 6590: FILE_BUF *ip; ! 6591: int skip; ! 6592: enum node_type type; ! 6593: U_CHAR *control_macro; ! 6594: { ! 6595: IF_STACK_FRAME *temp; ! 6596: ! 6597: temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME)); ! 6598: temp->fname = ip->nominal_fname; ! 6599: temp->lineno = ip->lineno; ! 6600: temp->next = if_stack; ! 6601: temp->control_macro = control_macro; ! 6602: if_stack = temp; ! 6603: ! 6604: if_stack->type = type; ! 6605: ! 6606: if (skip != 0) { ! 6607: skip_if_group (ip, 0); ! 6608: return; ! 6609: } else { ! 6610: ++if_stack->if_succeeded; ! 6611: output_line_command (ip, &outbuf, 1, same_file); ! 6612: } ! 6613: } ! 6614: ! 6615: /* ! 6616: * skip to #endif, #else, or #elif. adjust line numbers, etc. ! 6617: * leaves input ptr at the sharp sign found. ! 6618: * If ANY is nonzero, return at next directive of any sort. ! 6619: */ ! 6620: static void ! 6621: skip_if_group (ip, any) ! 6622: FILE_BUF *ip; ! 6623: int any; ! 6624: { ! 6625: register U_CHAR *bp = ip->bufp, *cp; ! 6626: register U_CHAR *endb = ip->buf + ip->length; ! 6627: struct directive *kt; ! 6628: IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */ ! 6629: U_CHAR *beg_of_line = bp; ! 6630: register int ident_length; ! 6631: U_CHAR *ident, *after_ident; ! 6632: ! 6633: while (bp < endb) { ! 6634: switch (*bp++) { ! 6635: case '/': /* possible comment */ ! 6636: if (*bp == '\\' && bp[1] == '\n') ! 6637: newline_fix (bp); ! 6638: if (*bp == '*' ! 6639: || (cplusplus_comments && *bp == '/')) { ! 6640: ip->bufp = ++bp; ! 6641: bp = skip_to_end_of_comment (ip, &ip->lineno, 0); ! 6642: } ! 6643: break; ! 6644: case '\"': ! 6645: case '\'': ! 6646: bp = skip_quoted_string (bp - 1, endb, ip->lineno, &ip->lineno, ! 6647: NULL_PTR, NULL_PTR); ! 6648: break; ! 6649: case '\\': ! 6650: /* Char after backslash loses its special meaning. */ ! 6651: if (bp < endb) { ! 6652: if (*bp == '\n') ! 6653: ++ip->lineno; /* But do update the line-count. */ ! 6654: bp++; ! 6655: } ! 6656: break; ! 6657: case '\n': ! 6658: ++ip->lineno; ! 6659: beg_of_line = bp; ! 6660: break; ! 6661: case '#': ! 6662: ip->bufp = bp - 1; ! 6663: ! 6664: /* # keyword: a # must be first nonblank char on the line */ ! 6665: if (beg_of_line == 0) ! 6666: break; ! 6667: /* Scan from start of line, skipping whitespace, comments ! 6668: and backslash-newlines, and see if we reach this #. ! 6669: If not, this # is not special. */ ! 6670: bp = beg_of_line; ! 6671: /* If -traditional, require # to be at beginning of line. */ ! 6672: if (!traditional) ! 6673: while (1) { ! 6674: if (is_hor_space[*bp]) ! 6675: bp++; ! 6676: else if (*bp == '\\' && bp[1] == '\n') ! 6677: bp += 2; ! 6678: else if (*bp == '/' && bp[1] == '*') { ! 6679: bp += 2; ! 6680: while (!(*bp == '*' && bp[1] == '/')) ! 6681: bp++; ! 6682: bp += 2; ! 6683: } else if (cplusplus_comments && *bp == '/' && bp[1] == '/') { ! 6684: bp += 2; ! 6685: while (*bp++ != '\n') ; ! 6686: } ! 6687: else break; ! 6688: } ! 6689: if (bp != ip->bufp) { ! 6690: bp = ip->bufp + 1; /* Reset bp to after the #. */ ! 6691: break; ! 6692: } ! 6693: ! 6694: bp = ip->bufp + 1; /* Point after the '#' */ ! 6695: ! 6696: /* Skip whitespace and \-newline. */ ! 6697: while (1) { ! 6698: if (is_hor_space[*bp]) ! 6699: bp++; ! 6700: else if (*bp == '\\' && bp[1] == '\n') ! 6701: bp += 2; ! 6702: else if (*bp == '/' && bp[1] == '*') { ! 6703: bp += 2; ! 6704: while (!(*bp == '*' && bp[1] == '/')) { ! 6705: if (*bp == '\n') ! 6706: ip->lineno++; ! 6707: bp++; ! 6708: } ! 6709: bp += 2; ! 6710: } else if (cplusplus_comments && *bp == '/' && bp[1] == '/') { ! 6711: bp += 2; ! 6712: while (*bp++ != '\n') ; ! 6713: } ! 6714: else break; ! 6715: } ! 6716: ! 6717: cp = bp; ! 6718: ! 6719: /* Now find end of directive name. ! 6720: If we encounter a backslash-newline, exchange it with any following ! 6721: symbol-constituents so that we end up with a contiguous name. */ ! 6722: ! 6723: while (1) { ! 6724: if (is_idchar[*bp]) ! 6725: bp++; ! 6726: else { ! 6727: if (*bp == '\\' && bp[1] == '\n') ! 6728: name_newline_fix (bp); ! 6729: if (is_idchar[*bp]) ! 6730: bp++; ! 6731: else break; ! 6732: } ! 6733: } ! 6734: ident_length = bp - cp; ! 6735: ident = cp; ! 6736: after_ident = bp; ! 6737: ! 6738: /* A line of just `#' becomes blank. */ ! 6739: ! 6740: if (ident_length == 0 && *after_ident == '\n') { ! 6741: continue; ! 6742: } ! 6743: ! 6744: if (ident_length == 0 || !is_idstart[*ident]) { ! 6745: U_CHAR *p = ident; ! 6746: while (is_idchar[*p]) { ! 6747: if (*p < '0' || *p > '9') ! 6748: break; ! 6749: p++; ! 6750: } ! 6751: /* Handle # followed by a line number. */ ! 6752: if (p != ident && !is_idchar[*p]) { ! 6753: if (pedantic) ! 6754: pedwarn ("`#' followed by integer"); ! 6755: continue; ! 6756: } ! 6757: ! 6758: /* Avoid error for `###' and similar cases unless -pedantic. */ ! 6759: if (p == ident) { ! 6760: while (*p == '#' || is_hor_space[*p]) p++; ! 6761: if (*p == '\n') { ! 6762: if (pedantic && !lang_asm) ! 6763: pedwarn ("invalid preprocessor directive"); ! 6764: continue; ! 6765: } ! 6766: } ! 6767: ! 6768: if (!lang_asm && pedantic) ! 6769: pedwarn ("invalid preprocessor directive name"); ! 6770: continue; ! 6771: } ! 6772: ! 6773: for (kt = directive_table; kt->length >= 0; kt++) { ! 6774: IF_STACK_FRAME *temp; ! 6775: if (ident_length == kt->length ! 6776: && strncmp (cp, kt->name, kt->length) == 0) { ! 6777: /* If we are asked to return on next directive, do so now. */ ! 6778: if (any) ! 6779: return; ! 6780: ! 6781: switch (kt->type) { ! 6782: case T_IF: ! 6783: case T_IFDEF: ! 6784: case T_IFNDEF: ! 6785: temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME)); ! 6786: temp->next = if_stack; ! 6787: if_stack = temp; ! 6788: temp->lineno = ip->lineno; ! 6789: temp->fname = ip->nominal_fname; ! 6790: temp->type = kt->type; ! 6791: break; ! 6792: case T_ELSE: ! 6793: case T_ENDIF: ! 6794: if (pedantic && if_stack != save_if_stack) ! 6795: validate_else (bp); ! 6796: case T_ELIF: ! 6797: if (if_stack == instack[indepth].if_stack) { ! 6798: error ("`#%s' not within a conditional", kt->name); ! 6799: break; ! 6800: } ! 6801: else if (if_stack == save_if_stack) ! 6802: return; /* found what we came for */ ! 6803: ! 6804: if (kt->type != T_ENDIF) { ! 6805: if (if_stack->type == T_ELSE) ! 6806: error ("`#else' or `#elif' after `#else'"); ! 6807: if_stack->type = kt->type; ! 6808: break; ! 6809: } ! 6810: ! 6811: temp = if_stack; ! 6812: if_stack = if_stack->next; ! 6813: free (temp); ! 6814: break; ! 6815: } ! 6816: break; ! 6817: } ! 6818: } ! 6819: /* Don't let erroneous code go by. */ ! 6820: if (kt->length < 0 && !lang_asm && pedantic) ! 6821: pedwarn ("invalid preprocessor directive name"); ! 6822: } ! 6823: } ! 6824: ip->bufp = bp; ! 6825: /* after this returns, rescan will exit because ip->bufp ! 6826: now points to the end of the buffer. ! 6827: rescan is responsible for the error message also. */ ! 6828: } ! 6829: ! 6830: /* ! 6831: * handle a #else directive. Do this by just continuing processing ! 6832: * without changing if_stack ; this is so that the error message ! 6833: * for missing #endif's etc. will point to the original #if. It ! 6834: * is possible that something different would be better. ! 6835: */ ! 6836: ! 6837: static int ! 6838: do_else (buf, limit, op, keyword) ! 6839: U_CHAR *buf, *limit; ! 6840: FILE_BUF *op; ! 6841: struct directive *keyword; ! 6842: { ! 6843: FILE_BUF *ip = &instack[indepth]; ! 6844: ! 6845: if (pedantic) { ! 6846: SKIP_WHITE_SPACE (buf); ! 6847: if (buf != limit) ! 6848: pedwarn ("text following `#else' violates ANSI standard"); ! 6849: } ! 6850: ! 6851: if (if_stack == instack[indepth].if_stack) { ! 6852: error ("`#else' not within a conditional"); ! 6853: return 0; ! 6854: } else { ! 6855: /* #ifndef can't have its special treatment for containing the whole file ! 6856: if it has a #else clause. */ ! 6857: if_stack->control_macro = 0; ! 6858: ! 6859: if (if_stack->type != T_IF && if_stack->type != T_ELIF) { ! 6860: error ("`#else' after `#else'"); ! 6861: #ifdef REPORT_EVENT ! 6862: REPORT_EVENT (0, NULL, if_stack->fname, if_stack->lineno, ! 6863: "matching conditional", 0, 0, 0); ! 6864: #endif ! 6865: fprintf (stderr, " (matches line %d", if_stack->lineno); ! 6866: if (strcmp (if_stack->fname, ip->nominal_fname) != 0) ! 6867: fprintf (stderr, ", file %s", if_stack->fname); ! 6868: fprintf (stderr, ")\n"); ! 6869: } ! 6870: if_stack->type = T_ELSE; ! 6871: } ! 6872: ! 6873: if (if_stack->if_succeeded) ! 6874: skip_if_group (ip, 0); ! 6875: else { ! 6876: ++if_stack->if_succeeded; /* continue processing input */ ! 6877: output_line_command (ip, op, 1, same_file); ! 6878: } ! 6879: return 0; ! 6880: } ! 6881: ! 6882: /* ! 6883: * unstack after #endif command ! 6884: */ ! 6885: ! 6886: static int ! 6887: do_endif (buf, limit, op, keyword) ! 6888: U_CHAR *buf, *limit; ! 6889: FILE_BUF *op; ! 6890: struct directive *keyword; ! 6891: { ! 6892: if (pedantic) { ! 6893: SKIP_WHITE_SPACE (buf); ! 6894: if (buf != limit) ! 6895: pedwarn ("text following `#endif' violates ANSI standard"); ! 6896: } ! 6897: ! 6898: if (if_stack == instack[indepth].if_stack) ! 6899: error ("unbalanced `#endif'"); ! 6900: else { ! 6901: IF_STACK_FRAME *temp = if_stack; ! 6902: if_stack = if_stack->next; ! 6903: if (temp->control_macro != 0) { ! 6904: /* This #endif matched a #ifndef at the start of the file. ! 6905: See if it is at the end of the file. */ ! 6906: FILE_BUF *ip = &instack[indepth]; ! 6907: U_CHAR *p = ip->bufp; ! 6908: U_CHAR *ep = ip->buf + ip->length; ! 6909: ! 6910: while (p != ep) { ! 6911: U_CHAR c = *p++; ! 6912: switch (c) { ! 6913: case ' ': ! 6914: case '\t': ! 6915: case '\n': ! 6916: break; ! 6917: case '/': ! 6918: if (p != ep && *p == '*') { ! 6919: /* Skip this comment. */ ! 6920: int junk; ! 6921: U_CHAR *save_bufp = ip->bufp; ! 6922: ip->bufp = p + 1; ! 6923: p = skip_to_end_of_comment (ip, &junk, 1); ! 6924: ip->bufp = save_bufp; ! 6925: } ! 6926: break; ! 6927: default: ! 6928: goto fail; ! 6929: } ! 6930: } ! 6931: /* If we get here, this #endif ends a #ifndef ! 6932: that contains all of the file (aside from whitespace). ! 6933: Arrange not to include the file again ! 6934: if the macro that was tested is defined. */ ! 6935: if (indepth != 0) ! 6936: record_control_macro (ip->fname, temp->control_macro); ! 6937: fail: ; ! 6938: } ! 6939: free (temp); ! 6940: output_line_command (&instack[indepth], op, 1, same_file); ! 6941: } ! 6942: return 0; ! 6943: } ! 6944: ! 6945: /* When an #else or #endif is found while skipping failed conditional, ! 6946: if -pedantic was specified, this is called to warn about text after ! 6947: the command name. P points to the first char after the command name. */ ! 6948: ! 6949: static void ! 6950: validate_else (p) ! 6951: register U_CHAR *p; ! 6952: { ! 6953: /* Advance P over whitespace and comments. */ ! 6954: while (1) { ! 6955: if (*p == '\\' && p[1] == '\n') ! 6956: p += 2; ! 6957: if (is_hor_space[*p]) ! 6958: p++; ! 6959: else if (*p == '/') { ! 6960: if (p[1] == '\\' && p[2] == '\n') ! 6961: newline_fix (p + 1); ! 6962: if (p[1] == '*') { ! 6963: p += 2; ! 6964: /* Don't bother warning about unterminated comments ! 6965: since that will happen later. Just be sure to exit. */ ! 6966: while (*p) { ! 6967: if (p[1] == '\\' && p[2] == '\n') ! 6968: newline_fix (p + 1); ! 6969: if (*p == '*' && p[1] == '/') { ! 6970: p += 2; ! 6971: break; ! 6972: } ! 6973: p++; ! 6974: } ! 6975: } ! 6976: else if (cplusplus_comments && p[1] == '/') { ! 6977: p += 2; ! 6978: while (*p && *p++ != '\n') ; ! 6979: } ! 6980: } else break; ! 6981: } ! 6982: if (*p && *p != '\n') ! 6983: pedwarn ("text following `#else' or `#endif' violates ANSI standard"); ! 6984: } ! 6985: ! 6986: /* Skip a comment, assuming the input ptr immediately follows the ! 6987: initial slash-star. Bump *LINE_COUNTER for each newline. ! 6988: (The canonical line counter is &ip->lineno.) ! 6989: Don't use this routine (or the next one) if bumping the line ! 6990: counter is not sufficient to deal with newlines in the string. ! 6991: ! 6992: If NOWARN is nonzero, don't warn about slash-star inside a comment. ! 6993: This feature is useful when processing a comment that is going to be ! 6994: processed or was processed at another point in the preprocessor, ! 6995: to avoid a duplicate warning. */ ! 6996: static U_CHAR * ! 6997: skip_to_end_of_comment (ip, line_counter, nowarn) ! 6998: register FILE_BUF *ip; ! 6999: int *line_counter; /* place to remember newlines, or NULL */ ! 7000: int nowarn; ! 7001: { ! 7002: register U_CHAR *limit = ip->buf + ip->length; ! 7003: register U_CHAR *bp = ip->bufp; ! 7004: FILE_BUF *op = &outbuf; /* JF */ ! 7005: int output = put_out_comments && !line_counter; ! 7006: ! 7007: /* JF this line_counter stuff is a crock to make sure the ! 7008: comment is only put out once, no matter how many times ! 7009: the comment is skipped. It almost works */ ! 7010: if (output) { ! 7011: *op->bufp++ = '/'; ! 7012: *op->bufp++ = '*'; ! 7013: } ! 7014: if (cplusplus_comments && bp[-1] == '/') { ! 7015: if (output) { ! 7016: while (bp < limit) ! 7017: if ((*op->bufp++ = *bp++) == '\n') { ! 7018: bp--; ! 7019: break; ! 7020: } ! 7021: op->bufp[-1] = '*'; ! 7022: *op->bufp++ = '/'; ! 7023: *op->bufp++ = '\n'; ! 7024: } else { ! 7025: while (bp < limit) { ! 7026: if (*bp++ == '\n') { ! 7027: bp--; ! 7028: break; ! 7029: } ! 7030: } ! 7031: } ! 7032: ip->bufp = bp; ! 7033: return bp; ! 7034: } ! 7035: while (bp < limit) { ! 7036: if (output) ! 7037: *op->bufp++ = *bp; ! 7038: switch (*bp++) { ! 7039: case '/': ! 7040: if (warn_comments && !nowarn && bp < limit && *bp == '*') ! 7041: warning ("`/*' within comment"); ! 7042: break; ! 7043: case '\n': ! 7044: if (line_counter != NULL) ! 7045: ++*line_counter; ! 7046: if (output) ! 7047: ++op->lineno; ! 7048: break; ! 7049: case '*': ! 7050: if (*bp == '\\' && bp[1] == '\n') ! 7051: newline_fix (bp); ! 7052: if (*bp == '/') { ! 7053: if (output) ! 7054: *op->bufp++ = '/'; ! 7055: ip->bufp = ++bp; ! 7056: return bp; ! 7057: } ! 7058: break; ! 7059: } ! 7060: } ! 7061: ip->bufp = bp; ! 7062: return bp; ! 7063: } ! 7064: ! 7065: /* ! 7066: * Skip over a quoted string. BP points to the opening quote. ! 7067: * Returns a pointer after the closing quote. Don't go past LIMIT. ! 7068: * START_LINE is the line number of the starting point (but it need ! 7069: * not be valid if the starting point is inside a macro expansion). ! 7070: * ! 7071: * The input stack state is not changed. ! 7072: * ! 7073: * If COUNT_NEWLINES is nonzero, it points to an int to increment ! 7074: * for each newline passed. ! 7075: * ! 7076: * If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it ! 7077: * if we pass a backslash-newline. ! 7078: * ! 7079: * If EOFP is nonzero, set *EOFP to 1 if the string is unterminated. ! 7080: */ ! 7081: static U_CHAR * ! 7082: skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp) ! 7083: register U_CHAR *bp; ! 7084: register U_CHAR *limit; ! 7085: int start_line; ! 7086: int *count_newlines; ! 7087: int *backslash_newlines_p; ! 7088: int *eofp; ! 7089: { ! 7090: register U_CHAR c, match; ! 7091: ! 7092: match = *bp++; ! 7093: while (1) { ! 7094: if (bp >= limit) { ! 7095: error_with_line (line_for_error (start_line), ! 7096: "unterminated string or character constant"); ! 7097: error_with_line (multiline_string_line, ! 7098: "possible real start of unterminated constant"); ! 7099: multiline_string_line = 0; ! 7100: if (eofp) ! 7101: *eofp = 1; ! 7102: break; ! 7103: } ! 7104: c = *bp++; ! 7105: if (c == '\\') { ! 7106: while (*bp == '\\' && bp[1] == '\n') { ! 7107: if (backslash_newlines_p) ! 7108: *backslash_newlines_p = 1; ! 7109: if (count_newlines) ! 7110: ++*count_newlines; ! 7111: bp += 2; ! 7112: } ! 7113: if (*bp == '\n' && count_newlines) { ! 7114: if (backslash_newlines_p) ! 7115: *backslash_newlines_p = 1; ! 7116: ++*count_newlines; ! 7117: } ! 7118: bp++; ! 7119: } else if (c == '\n') { ! 7120: if (traditional) { ! 7121: /* Unterminated strings and character constants are 'legal'. */ ! 7122: bp--; /* Don't consume the newline. */ ! 7123: if (eofp) ! 7124: *eofp = 1; ! 7125: break; ! 7126: } ! 7127: if (pedantic || match == '\'') { ! 7128: error_with_line (line_for_error (start_line), ! 7129: "unterminated string or character constant"); ! 7130: bp--; ! 7131: if (eofp) ! 7132: *eofp = 1; ! 7133: break; ! 7134: } ! 7135: /* If not traditional, then allow newlines inside strings. */ ! 7136: if (count_newlines) ! 7137: ++*count_newlines; ! 7138: if (multiline_string_line == 0) ! 7139: multiline_string_line = start_line; ! 7140: } else if (c == match) ! 7141: break; ! 7142: } ! 7143: return bp; ! 7144: } ! 7145: ! 7146: /* Place into DST a quoted string representing the string SRC. ! 7147: Return the address of DST's terminating null. */ ! 7148: static char * ! 7149: quote_string (dst, src) ! 7150: char *dst, *src; ! 7151: { ! 7152: U_CHAR c; ! 7153: ! 7154: *dst++ = '\"'; ! 7155: for (;;) ! 7156: switch ((c = *src++)) ! 7157: { ! 7158: default: ! 7159: if (isprint (c)) ! 7160: *dst++ = c; ! 7161: else ! 7162: { ! 7163: sprintf (dst, "\\%03o", c); ! 7164: dst += 4; ! 7165: } ! 7166: break; ! 7167: ! 7168: case '\"': ! 7169: case '\\': ! 7170: *dst++ = '\\'; ! 7171: *dst++ = c; ! 7172: break; ! 7173: ! 7174: case '\0': ! 7175: *dst++ = '\"'; ! 7176: *dst = '\0'; ! 7177: return dst; ! 7178: } ! 7179: } ! 7180: ! 7181: /* Skip across a group of balanced parens, starting from IP->bufp. ! 7182: IP->bufp is updated. Use this with IP->bufp pointing at an open-paren. ! 7183: ! 7184: This does not handle newlines, because it's used for the arg of #if, ! 7185: where there aren't any newlines. Also, backslash-newline can't appear. */ ! 7186: ! 7187: static U_CHAR * ! 7188: skip_paren_group (ip) ! 7189: register FILE_BUF *ip; ! 7190: { ! 7191: U_CHAR *limit = ip->buf + ip->length; ! 7192: U_CHAR *p = ip->bufp; ! 7193: int depth = 0; ! 7194: int lines_dummy = 0; ! 7195: ! 7196: while (p != limit) { ! 7197: int c = *p++; ! 7198: switch (c) { ! 7199: case '(': ! 7200: depth++; ! 7201: break; ! 7202: ! 7203: case ')': ! 7204: depth--; ! 7205: if (depth == 0) ! 7206: return ip->bufp = p; ! 7207: break; ! 7208: ! 7209: case '/': ! 7210: if (*p == '*') { ! 7211: ip->bufp = p; ! 7212: p = skip_to_end_of_comment (ip, &lines_dummy, 0); ! 7213: p = ip->bufp; ! 7214: } ! 7215: ! 7216: case '"': ! 7217: case '\'': ! 7218: { ! 7219: int eofp = 0; ! 7220: p = skip_quoted_string (p - 1, limit, 0, NULL_PTR, NULL_PTR, &eofp); ! 7221: if (eofp) ! 7222: return ip->bufp = p; ! 7223: } ! 7224: break; ! 7225: } ! 7226: } ! 7227: ! 7228: ip->bufp = p; ! 7229: return p; ! 7230: } ! 7231: ! 7232: /* ! 7233: * write out a #line command, for instance, after an #include file. ! 7234: * If CONDITIONAL is nonzero, we can omit the #line if it would ! 7235: * appear to be a no-op, and we can output a few newlines instead ! 7236: * if we want to increase the line number by a small amount. ! 7237: * FILE_CHANGE says whether we are entering a file, leaving, or neither. ! 7238: */ ! 7239: ! 7240: static void ! 7241: output_line_command (ip, op, conditional, file_change) ! 7242: FILE_BUF *ip, *op; ! 7243: int conditional; ! 7244: enum file_change_code file_change; ! 7245: { ! 7246: int len; ! 7247: char *line_cmd_buf, *line_end; ! 7248: ! 7249: if (no_line_commands ! 7250: || ip->fname == NULL ! 7251: || no_output) { ! 7252: op->lineno = ip->lineno; ! 7253: return; ! 7254: } ! 7255: ! 7256: if (conditional) { ! 7257: if (ip->lineno == op->lineno) ! 7258: return; ! 7259: ! 7260: /* If the inherited line number is a little too small, ! 7261: output some newlines instead of a #line command. */ ! 7262: if (ip->lineno > op->lineno && ip->lineno < op->lineno + 8) { ! 7263: check_expand (op, 10); ! 7264: while (ip->lineno > op->lineno) { ! 7265: *op->bufp++ = '\n'; ! 7266: op->lineno++; ! 7267: } ! 7268: return; ! 7269: } ! 7270: } ! 7271: ! 7272: /* Don't output a line number of 0 if we can help it. */ ! 7273: if (ip->lineno == 0 && ip->bufp - ip->buf < ip->length ! 7274: && *ip->bufp == '\n') { ! 7275: ip->lineno++; ! 7276: ip->bufp++; ! 7277: } ! 7278: ! 7279: line_cmd_buf = (char *) alloca (4 * strlen (ip->nominal_fname) + 100); ! 7280: #ifdef OUTPUT_LINE_COMMANDS ! 7281: sprintf (line_cmd_buf, "#line %d ", ip->lineno); ! 7282: #else ! 7283: sprintf (line_cmd_buf, "# %d ", ip->lineno); ! 7284: #endif ! 7285: line_end = quote_string (line_cmd_buf + strlen (line_cmd_buf), ! 7286: ip->nominal_fname); ! 7287: if (file_change != same_file) { ! 7288: *line_end++ = ' '; ! 7289: *line_end++ = file_change == enter_file ? '1' : '2'; ! 7290: } ! 7291: /* Tell cc1 if following text comes from a system header file. */ ! 7292: if (ip->system_header_p) { ! 7293: *line_end++ = ' '; ! 7294: *line_end++ = '3'; ! 7295: } ! 7296: #ifndef NO_IMPLICIT_EXTERN_C ! 7297: /* Tell cc1plus if following text should be treated as C. */ ! 7298: if (ip->system_header_p == 2 && cplusplus) { ! 7299: *line_end++ = ' '; ! 7300: *line_end++ = '4'; ! 7301: } ! 7302: #endif ! 7303: *line_end++ = '\n'; ! 7304: len = line_end - line_cmd_buf; ! 7305: check_expand (op, len + 1); ! 7306: if (op->bufp > op->buf && op->bufp[-1] != '\n') ! 7307: *op->bufp++ = '\n'; ! 7308: bcopy (line_cmd_buf, op->bufp, len); ! 7309: op->bufp += len; ! 7310: op->lineno = ip->lineno; ! 7311: } ! 7312: ! 7313: /* This structure represents one parsed argument in a macro call. ! 7314: `raw' points to the argument text as written (`raw_length' is its length). ! 7315: `expanded' points to the argument's macro-expansion ! 7316: (its length is `expand_length'). ! 7317: `stringified_length' is the length the argument would have ! 7318: if stringified. ! 7319: `use_count' is the number of times this macro arg is substituted ! 7320: into the macro. If the actual use count exceeds 10, ! 7321: the value stored is 10. ! 7322: `free1' and `free2', if nonzero, point to blocks to be freed ! 7323: when the macro argument data is no longer needed. */ ! 7324: ! 7325: struct argdata { ! 7326: U_CHAR *raw, *expanded; ! 7327: int raw_length, expand_length; ! 7328: int stringified_length; ! 7329: U_CHAR *free1, *free2; ! 7330: char newlines; ! 7331: char comments; ! 7332: char use_count; ! 7333: }; ! 7334: ! 7335: /* Expand a macro call. ! 7336: HP points to the symbol that is the macro being called. ! 7337: Put the result of expansion onto the input stack ! 7338: so that subsequent input by our caller will use it. ! 7339: ! 7340: If macro wants arguments, caller has already verified that ! 7341: an argument list follows; arguments come from the input stack. */ ! 7342: ! 7343: static void ! 7344: macroexpand (hp, op) ! 7345: HASHNODE *hp; ! 7346: FILE_BUF *op; ! 7347: { ! 7348: int nargs; ! 7349: DEFINITION *defn = hp->value.defn; ! 7350: register U_CHAR *xbuf; ! 7351: int xbuf_len; ! 7352: int start_line = instack[indepth].lineno; ! 7353: int rest_args, rest_zero; ! 7354: ! 7355: CHECK_DEPTH (return;); ! 7356: ! 7357: /* it might not actually be a macro. */ ! 7358: if (hp->type != T_MACRO) { ! 7359: special_symbol (hp, op); ! 7360: return; ! 7361: } ! 7362: ! 7363: /* This macro is being used inside a #if, which means it must be */ ! 7364: /* recorded as a precondition. */ ! 7365: if (pcp_inside_if && pcp_outfile && defn->predefined) ! 7366: dump_single_macro (hp, pcp_outfile); ! 7367: ! 7368: nargs = defn->nargs; ! 7369: ! 7370: if (nargs >= 0) { ! 7371: register int i; ! 7372: struct argdata *args; ! 7373: char *parse_error = 0; ! 7374: ! 7375: args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata)); ! 7376: ! 7377: for (i = 0; i < nargs; i++) { ! 7378: args[i].raw = (U_CHAR *) ""; ! 7379: args[i].expanded = 0; ! 7380: args[i].raw_length = args[i].expand_length ! 7381: = args[i].stringified_length = 0; ! 7382: args[i].free1 = args[i].free2 = 0; ! 7383: args[i].use_count = 0; ! 7384: } ! 7385: ! 7386: /* Parse all the macro args that are supplied. I counts them. ! 7387: The first NARGS args are stored in ARGS. ! 7388: The rest are discarded. ! 7389: If rest_args is set then we assume macarg absorbed the rest of the args. ! 7390: */ ! 7391: i = 0; ! 7392: rest_args = 0; ! 7393: do { ! 7394: /* Discard the open-parenthesis or comma before the next arg. */ ! 7395: ++instack[indepth].bufp; ! 7396: if (rest_args) ! 7397: continue; ! 7398: if (i < nargs || (nargs == 0 && i == 0)) { ! 7399: /* if we are working on last arg which absorbs rest of args... */ ! 7400: if (i == nargs - 1 && defn->rest_args) ! 7401: rest_args = 1; ! 7402: parse_error = macarg (&args[i], rest_args); ! 7403: } ! 7404: else ! 7405: parse_error = macarg (NULL_PTR, 0); ! 7406: if (parse_error) { ! 7407: error_with_line (line_for_error (start_line), parse_error); ! 7408: break; ! 7409: } ! 7410: i++; ! 7411: } while (*instack[indepth].bufp != ')'); ! 7412: ! 7413: /* If we got one arg but it was just whitespace, call that 0 args. */ ! 7414: if (i == 1) { ! 7415: register U_CHAR *bp = args[0].raw; ! 7416: register U_CHAR *lim = bp + args[0].raw_length; ! 7417: /* cpp.texi says for foo ( ) we provide one argument. ! 7418: However, if foo wants just 0 arguments, treat this as 0. */ ! 7419: if (nargs == 0) ! 7420: while (bp != lim && is_space[*bp]) bp++; ! 7421: if (bp == lim) ! 7422: i = 0; ! 7423: } ! 7424: ! 7425: /* Don't output an error message if we have already output one for ! 7426: a parse error above. */ ! 7427: rest_zero = 0; ! 7428: if (nargs == 0 && i > 0) { ! 7429: if (! parse_error) ! 7430: error ("arguments given to macro `%s'", hp->name); ! 7431: } else if (i < nargs) { ! 7432: /* traditional C allows foo() if foo wants one argument. */ ! 7433: if (nargs == 1 && i == 0 && traditional) ! 7434: ; ! 7435: /* the rest args token is allowed to absorb 0 tokens */ ! 7436: else if (i == nargs - 1 && defn->rest_args) ! 7437: rest_zero = 1; ! 7438: else if (parse_error) ! 7439: ; ! 7440: else if (i == 0) ! 7441: error ("macro `%s' used without args", hp->name); ! 7442: else if (i == 1) ! 7443: error ("macro `%s' used with just one arg", hp->name); ! 7444: else ! 7445: error ("macro `%s' used with only %d args", hp->name, i); ! 7446: } else if (i > nargs) { ! 7447: if (! parse_error) ! 7448: error ("macro `%s' used with too many (%d) args", hp->name, i); ! 7449: } ! 7450: ! 7451: /* Swallow the closeparen. */ ! 7452: ++instack[indepth].bufp; ! 7453: ! 7454: /* If macro wants zero args, we parsed the arglist for checking only. ! 7455: Read directly from the macro definition. */ ! 7456: if (nargs == 0) { ! 7457: xbuf = defn->expansion; ! 7458: xbuf_len = defn->length; ! 7459: } else { ! 7460: register U_CHAR *exp = defn->expansion; ! 7461: register int offset; /* offset in expansion, ! 7462: copied a piece at a time */ ! 7463: register int totlen; /* total amount of exp buffer filled so far */ ! 7464: ! 7465: register struct reflist *ap, *last_ap; ! 7466: ! 7467: /* Macro really takes args. Compute the expansion of this call. */ ! 7468: ! 7469: /* Compute length in characters of the macro's expansion. ! 7470: Also count number of times each arg is used. */ ! 7471: xbuf_len = defn->length; ! 7472: for (ap = defn->pattern; ap != NULL; ap = ap->next) { ! 7473: if (ap->stringify) ! 7474: xbuf_len += args[ap->argno].stringified_length; ! 7475: else if (ap->raw_before || ap->raw_after || traditional) ! 7476: /* Add 4 for two newline-space markers to prevent ! 7477: token concatenation. */ ! 7478: xbuf_len += args[ap->argno].raw_length + 4; ! 7479: else { ! 7480: /* We have an ordinary (expanded) occurrence of the arg. ! 7481: So compute its expansion, if we have not already. */ ! 7482: if (args[ap->argno].expanded == 0) { ! 7483: FILE_BUF obuf; ! 7484: obuf = expand_to_temp_buffer (args[ap->argno].raw, ! 7485: args[ap->argno].raw + args[ap->argno].raw_length, ! 7486: 1, 0); ! 7487: ! 7488: args[ap->argno].expanded = obuf.buf; ! 7489: args[ap->argno].expand_length = obuf.length; ! 7490: args[ap->argno].free2 = obuf.buf; ! 7491: } ! 7492: ! 7493: /* Add 4 for two newline-space markers to prevent ! 7494: token concatenation. */ ! 7495: xbuf_len += args[ap->argno].expand_length + 4; ! 7496: } ! 7497: if (args[ap->argno].use_count < 10) ! 7498: args[ap->argno].use_count++; ! 7499: } ! 7500: ! 7501: xbuf = (U_CHAR *) xmalloc (xbuf_len + 1); ! 7502: ! 7503: /* Generate in XBUF the complete expansion ! 7504: with arguments substituted in. ! 7505: TOTLEN is the total size generated so far. ! 7506: OFFSET is the index in the definition ! 7507: of where we are copying from. */ ! 7508: offset = totlen = 0; ! 7509: for (last_ap = NULL, ap = defn->pattern; ap != NULL; ! 7510: last_ap = ap, ap = ap->next) { ! 7511: register struct argdata *arg = &args[ap->argno]; ! 7512: int count_before = totlen; ! 7513: ! 7514: /* Add chars to XBUF. */ ! 7515: for (i = 0; i < ap->nchars; i++, offset++) ! 7516: xbuf[totlen++] = exp[offset]; ! 7517: ! 7518: /* If followed by an empty rest arg with concatenation, ! 7519: delete the last run of nonwhite chars. */ ! 7520: if (rest_zero && totlen > count_before ! 7521: && ((ap->rest_args && ap->raw_before) ! 7522: || (last_ap != NULL && last_ap->rest_args ! 7523: && last_ap->raw_after))) { ! 7524: /* Delete final whitespace. */ ! 7525: while (totlen > count_before && is_space[xbuf[totlen - 1]]) { ! 7526: totlen--; ! 7527: } ! 7528: ! 7529: /* Delete the nonwhites before them. */ ! 7530: while (totlen > count_before && ! is_space[xbuf[totlen - 1]]) { ! 7531: totlen--; ! 7532: } ! 7533: } ! 7534: ! 7535: if (ap->stringify != 0) { ! 7536: int arglen = arg->raw_length; ! 7537: int escaped = 0; ! 7538: int in_string = 0; ! 7539: int c; ! 7540: i = 0; ! 7541: while (i < arglen ! 7542: && (c = arg->raw[i], is_space[c])) ! 7543: i++; ! 7544: while (i < arglen ! 7545: && (c = arg->raw[arglen - 1], is_space[c])) ! 7546: arglen--; ! 7547: if (!traditional) ! 7548: xbuf[totlen++] = '\"'; /* insert beginning quote */ ! 7549: for (; i < arglen; i++) { ! 7550: c = arg->raw[i]; ! 7551: ! 7552: /* Special markers Newline Space ! 7553: generate nothing for a stringified argument. */ ! 7554: if (c == '\n' && arg->raw[i+1] != '\n') { ! 7555: i++; ! 7556: continue; ! 7557: } ! 7558: ! 7559: /* Internal sequences of whitespace are replaced by one space ! 7560: except within an string or char token. */ ! 7561: if (! in_string ! 7562: && (c == '\n' ? arg->raw[i+1] == '\n' : is_space[c])) { ! 7563: while (1) { ! 7564: /* Note that Newline Space does occur within whitespace ! 7565: sequences; consider it part of the sequence. */ ! 7566: if (c == '\n' && is_space[arg->raw[i+1]]) ! 7567: i += 2; ! 7568: else if (c != '\n' && is_space[c]) ! 7569: i++; ! 7570: else break; ! 7571: c = arg->raw[i]; ! 7572: } ! 7573: i--; ! 7574: c = ' '; ! 7575: } ! 7576: ! 7577: if (escaped) ! 7578: escaped = 0; ! 7579: else { ! 7580: if (c == '\\') ! 7581: escaped = 1; ! 7582: if (in_string) { ! 7583: if (c == in_string) ! 7584: in_string = 0; ! 7585: } else if (c == '\"' || c == '\'') ! 7586: in_string = c; ! 7587: } ! 7588: ! 7589: /* Escape these chars */ ! 7590: if (c == '\"' || (in_string && c == '\\')) ! 7591: xbuf[totlen++] = '\\'; ! 7592: if (isprint (c)) ! 7593: xbuf[totlen++] = c; ! 7594: else { ! 7595: sprintf ((char *) &xbuf[totlen], "\\%03o", (unsigned int) c); ! 7596: totlen += 4; ! 7597: } ! 7598: } ! 7599: if (!traditional) ! 7600: xbuf[totlen++] = '\"'; /* insert ending quote */ ! 7601: } else if (ap->raw_before || ap->raw_after || traditional) { ! 7602: U_CHAR *p1 = arg->raw; ! 7603: U_CHAR *l1 = p1 + arg->raw_length; ! 7604: if (ap->raw_before) { ! 7605: while (p1 != l1 && is_space[*p1]) p1++; ! 7606: while (p1 != l1 && is_idchar[*p1]) ! 7607: xbuf[totlen++] = *p1++; ! 7608: /* Delete any no-reexpansion marker that follows ! 7609: an identifier at the beginning of the argument ! 7610: if the argument is concatenated with what precedes it. */ ! 7611: if (p1[0] == '\n' && p1[1] == '-') ! 7612: p1 += 2; ! 7613: } else if (!traditional) { ! 7614: /* Ordinary expanded use of the argument. ! 7615: Put in newline-space markers to prevent token pasting. */ ! 7616: xbuf[totlen++] = '\n'; ! 7617: xbuf[totlen++] = ' '; ! 7618: } ! 7619: if (ap->raw_after) { ! 7620: /* Arg is concatenated after: delete trailing whitespace, ! 7621: whitespace markers, and no-reexpansion markers. */ ! 7622: while (p1 != l1) { ! 7623: if (is_space[l1[-1]]) l1--; ! 7624: else if (l1[-1] == '-') { ! 7625: U_CHAR *p2 = l1 - 1; ! 7626: /* If a `-' is preceded by an odd number of newlines then it ! 7627: and the last newline are a no-reexpansion marker. */ ! 7628: while (p2 != p1 && p2[-1] == '\n') p2--; ! 7629: if ((l1 - 1 - p2) & 1) { ! 7630: l1 -= 2; ! 7631: } ! 7632: else break; ! 7633: } ! 7634: else break; ! 7635: } ! 7636: } ! 7637: ! 7638: bcopy (p1, xbuf + totlen, l1 - p1); ! 7639: totlen += l1 - p1; ! 7640: if (!traditional && !ap->raw_after) { ! 7641: /* Ordinary expanded use of the argument. ! 7642: Put in newline-space markers to prevent token pasting. */ ! 7643: xbuf[totlen++] = '\n'; ! 7644: xbuf[totlen++] = ' '; ! 7645: } ! 7646: } else { ! 7647: /* Ordinary expanded use of the argument. ! 7648: Put in newline-space markers to prevent token pasting. */ ! 7649: if (!traditional) { ! 7650: xbuf[totlen++] = '\n'; ! 7651: xbuf[totlen++] = ' '; ! 7652: } ! 7653: bcopy (arg->expanded, xbuf + totlen, arg->expand_length); ! 7654: totlen += arg->expand_length; ! 7655: if (!traditional) { ! 7656: xbuf[totlen++] = '\n'; ! 7657: xbuf[totlen++] = ' '; ! 7658: } ! 7659: /* If a macro argument with newlines is used multiple times, ! 7660: then only expand the newlines once. This avoids creating output ! 7661: lines which don't correspond to any input line, which confuses ! 7662: gdb and gcov. */ ! 7663: if (arg->use_count > 1 && arg->newlines > 0) { ! 7664: /* Don't bother doing change_newlines for subsequent ! 7665: uses of arg. */ ! 7666: arg->use_count = 1; ! 7667: arg->expand_length ! 7668: = change_newlines (arg->expanded, arg->expand_length); ! 7669: } ! 7670: } ! 7671: ! 7672: if (totlen > xbuf_len) ! 7673: abort (); ! 7674: } ! 7675: ! 7676: /* if there is anything left of the definition ! 7677: after handling the arg list, copy that in too. */ ! 7678: ! 7679: for (i = offset; i < defn->length; i++) { ! 7680: /* if we've reached the end of the macro */ ! 7681: if (exp[i] == ')') ! 7682: rest_zero = 0; ! 7683: if (! (rest_zero && last_ap != NULL && last_ap->rest_args ! 7684: && last_ap->raw_after)) ! 7685: xbuf[totlen++] = exp[i]; ! 7686: } ! 7687: ! 7688: xbuf[totlen] = 0; ! 7689: xbuf_len = totlen; ! 7690: ! 7691: for (i = 0; i < nargs; i++) { ! 7692: if (args[i].free1 != 0) ! 7693: free (args[i].free1); ! 7694: if (args[i].free2 != 0) ! 7695: free (args[i].free2); ! 7696: } ! 7697: } ! 7698: } else { ! 7699: xbuf = defn->expansion; ! 7700: xbuf_len = defn->length; ! 7701: } ! 7702: ! 7703: /* Now put the expansion on the input stack ! 7704: so our caller will commence reading from it. */ ! 7705: { ! 7706: register FILE_BUF *ip2; ! 7707: ! 7708: ip2 = &instack[++indepth]; ! 7709: ! 7710: ip2->fname = 0; ! 7711: ip2->nominal_fname = 0; ! 7712: ip2->lineno = 0; ! 7713: ip2->buf = xbuf; ! 7714: ip2->length = xbuf_len; ! 7715: ip2->bufp = xbuf; ! 7716: ip2->free_ptr = (nargs > 0) ? xbuf : 0; ! 7717: ip2->macro = hp; ! 7718: ip2->if_stack = if_stack; ! 7719: ip2->system_header_p = 0; ! 7720: ! 7721: /* Recursive macro use sometimes works traditionally. ! 7722: #define foo(x,y) bar (x (y,0), y) ! 7723: foo (foo, baz) */ ! 7724: ! 7725: if (!traditional) ! 7726: hp->type = T_DISABLED; ! 7727: } ! 7728: } ! 7729: ! 7730: /* ! 7731: * Parse a macro argument and store the info on it into *ARGPTR. ! 7732: * REST_ARGS is passed to macarg1 to make it absorb the rest of the args. ! 7733: * Return nonzero to indicate a syntax error. ! 7734: */ ! 7735: ! 7736: static char * ! 7737: macarg (argptr, rest_args) ! 7738: register struct argdata *argptr; ! 7739: int rest_args; ! 7740: { ! 7741: FILE_BUF *ip = &instack[indepth]; ! 7742: int paren = 0; ! 7743: int newlines = 0; ! 7744: int comments = 0; ! 7745: ! 7746: /* Try to parse as much of the argument as exists at this ! 7747: input stack level. */ ! 7748: U_CHAR *bp = macarg1 (ip->bufp, ip->buf + ip->length, ! 7749: &paren, &newlines, &comments, rest_args); ! 7750: ! 7751: /* If we find the end of the argument at this level, ! 7752: set up *ARGPTR to point at it in the input stack. */ ! 7753: if (!(ip->fname != 0 && (newlines != 0 || comments != 0)) ! 7754: && bp != ip->buf + ip->length) { ! 7755: if (argptr != 0) { ! 7756: argptr->raw = ip->bufp; ! 7757: argptr->raw_length = bp - ip->bufp; ! 7758: argptr->newlines = newlines; ! 7759: } ! 7760: ip->bufp = bp; ! 7761: } else { ! 7762: /* This input stack level ends before the macro argument does. ! 7763: We must pop levels and keep parsing. ! 7764: Therefore, we must allocate a temporary buffer and copy ! 7765: the macro argument into it. */ ! 7766: int bufsize = bp - ip->bufp; ! 7767: int extra = newlines; ! 7768: U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1); ! 7769: int final_start = 0; ! 7770: ! 7771: bcopy (ip->bufp, buffer, bufsize); ! 7772: ip->bufp = bp; ! 7773: ip->lineno += newlines; ! 7774: ! 7775: while (bp == ip->buf + ip->length) { ! 7776: if (instack[indepth].macro == 0) { ! 7777: free (buffer); ! 7778: return "unterminated macro call"; ! 7779: } ! 7780: ip->macro->type = T_MACRO; ! 7781: if (ip->free_ptr) ! 7782: free (ip->free_ptr); ! 7783: ip = &instack[--indepth]; ! 7784: newlines = 0; ! 7785: comments = 0; ! 7786: bp = macarg1 (ip->bufp, ip->buf + ip->length, &paren, ! 7787: &newlines, &comments, rest_args); ! 7788: final_start = bufsize; ! 7789: bufsize += bp - ip->bufp; ! 7790: extra += newlines; ! 7791: buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1); ! 7792: bcopy (ip->bufp, buffer + bufsize - (bp - ip->bufp), bp - ip->bufp); ! 7793: ip->bufp = bp; ! 7794: ip->lineno += newlines; ! 7795: } ! 7796: ! 7797: /* Now, if arg is actually wanted, record its raw form, ! 7798: discarding comments and duplicating newlines in whatever ! 7799: part of it did not come from a macro expansion. ! 7800: EXTRA space has been preallocated for duplicating the newlines. ! 7801: FINAL_START is the index of the start of that part. */ ! 7802: if (argptr != 0) { ! 7803: argptr->raw = buffer; ! 7804: argptr->raw_length = bufsize; ! 7805: argptr->free1 = buffer; ! 7806: argptr->newlines = newlines; ! 7807: argptr->comments = comments; ! 7808: if ((newlines || comments) && ip->fname != 0) ! 7809: argptr->raw_length ! 7810: = final_start + ! 7811: discard_comments (argptr->raw + final_start, ! 7812: argptr->raw_length - final_start, ! 7813: newlines); ! 7814: argptr->raw[argptr->raw_length] = 0; ! 7815: if (argptr->raw_length > bufsize + extra) ! 7816: abort (); ! 7817: } ! 7818: } ! 7819: ! 7820: /* If we are not discarding this argument, ! 7821: macroexpand it and compute its length as stringified. ! 7822: All this info goes into *ARGPTR. */ ! 7823: ! 7824: if (argptr != 0) { ! 7825: register U_CHAR *buf, *lim; ! 7826: register int totlen; ! 7827: ! 7828: buf = argptr->raw; ! 7829: lim = buf + argptr->raw_length; ! 7830: ! 7831: while (buf != lim && is_space[*buf]) ! 7832: buf++; ! 7833: while (buf != lim && is_space[lim[-1]]) ! 7834: lim--; ! 7835: totlen = traditional ? 0 : 2; /* Count opening and closing quote. */ ! 7836: while (buf != lim) { ! 7837: register U_CHAR c = *buf++; ! 7838: totlen++; ! 7839: /* Internal sequences of whitespace are replaced by one space ! 7840: in most cases, but not always. So count all the whitespace ! 7841: in case we need to keep it all. */ ! 7842: #if 0 ! 7843: if (is_space[c]) ! 7844: SKIP_ALL_WHITE_SPACE (buf); ! 7845: else ! 7846: #endif ! 7847: if (c == '\"' || c == '\\') /* escape these chars */ ! 7848: totlen++; ! 7849: else if (!isprint (c)) ! 7850: totlen += 3; ! 7851: } ! 7852: argptr->stringified_length = totlen; ! 7853: } ! 7854: return 0; ! 7855: } ! 7856: ! 7857: /* Scan text from START (inclusive) up to LIMIT (exclusive), ! 7858: counting parens in *DEPTHPTR, ! 7859: and return if reach LIMIT ! 7860: or before a `)' that would make *DEPTHPTR negative ! 7861: or before a comma when *DEPTHPTR is zero. ! 7862: Single and double quotes are matched and termination ! 7863: is inhibited within them. Comments also inhibit it. ! 7864: Value returned is pointer to stopping place. ! 7865: ! 7866: Increment *NEWLINES each time a newline is passed. ! 7867: REST_ARGS notifies macarg1 that it should absorb the rest of the args. ! 7868: Set *COMMENTS to 1 if a comment is seen. */ ! 7869: ! 7870: static U_CHAR * ! 7871: macarg1 (start, limit, depthptr, newlines, comments, rest_args) ! 7872: U_CHAR *start; ! 7873: register U_CHAR *limit; ! 7874: int *depthptr, *newlines, *comments; ! 7875: int rest_args; ! 7876: { ! 7877: register U_CHAR *bp = start; ! 7878: ! 7879: while (bp < limit) { ! 7880: switch (*bp) { ! 7881: case '(': ! 7882: (*depthptr)++; ! 7883: break; ! 7884: case ')': ! 7885: if (--(*depthptr) < 0) ! 7886: return bp; ! 7887: break; ! 7888: case '\\': ! 7889: /* Traditionally, backslash makes following char not special. */ ! 7890: if (bp + 1 < limit && traditional) ! 7891: { ! 7892: bp++; ! 7893: /* But count source lines anyway. */ ! 7894: if (*bp == '\n') ! 7895: ++*newlines; ! 7896: } ! 7897: break; ! 7898: case '\n': ! 7899: ++*newlines; ! 7900: break; ! 7901: case '/': ! 7902: if (bp[1] == '\\' && bp[2] == '\n') ! 7903: newline_fix (bp + 1); ! 7904: if (cplusplus_comments && bp[1] == '/') { ! 7905: *comments = 1; ! 7906: bp += 2; ! 7907: while (bp < limit && *bp++ != '\n') ; ! 7908: ++*newlines; ! 7909: break; ! 7910: } ! 7911: if (bp[1] != '*' || bp + 1 >= limit) ! 7912: break; ! 7913: *comments = 1; ! 7914: bp += 2; ! 7915: while (bp + 1 < limit) { ! 7916: if (bp[0] == '*' ! 7917: && bp[1] == '\\' && bp[2] == '\n') ! 7918: newline_fix (bp + 1); ! 7919: if (bp[0] == '*' && bp[1] == '/') ! 7920: break; ! 7921: if (*bp == '\n') ++*newlines; ! 7922: bp++; ! 7923: } ! 7924: break; ! 7925: case '\'': ! 7926: case '\"': ! 7927: { ! 7928: int quotec; ! 7929: for (quotec = *bp++; bp + 1 < limit && *bp != quotec; bp++) { ! 7930: if (*bp == '\\') { ! 7931: bp++; ! 7932: if (*bp == '\n') ! 7933: ++*newlines; ! 7934: while (*bp == '\\' && bp[1] == '\n') { ! 7935: bp += 2; ! 7936: } ! 7937: } else if (*bp == '\n') { ! 7938: ++*newlines; ! 7939: if (quotec == '\'') ! 7940: break; ! 7941: } ! 7942: } ! 7943: } ! 7944: break; ! 7945: case ',': ! 7946: /* if we've returned to lowest level and we aren't absorbing all args */ ! 7947: if ((*depthptr) == 0 && rest_args == 0) ! 7948: return bp; ! 7949: break; ! 7950: } ! 7951: bp++; ! 7952: } ! 7953: ! 7954: return bp; ! 7955: } ! 7956: ! 7957: /* Discard comments and duplicate newlines ! 7958: in the string of length LENGTH at START, ! 7959: except inside of string constants. ! 7960: The string is copied into itself with its beginning staying fixed. ! 7961: ! 7962: NEWLINES is the number of newlines that must be duplicated. ! 7963: We assume that that much extra space is available past the end ! 7964: of the string. */ ! 7965: ! 7966: static int ! 7967: discard_comments (start, length, newlines) ! 7968: U_CHAR *start; ! 7969: int length; ! 7970: int newlines; ! 7971: { ! 7972: register U_CHAR *ibp; ! 7973: register U_CHAR *obp; ! 7974: register U_CHAR *limit; ! 7975: register int c; ! 7976: ! 7977: /* If we have newlines to duplicate, copy everything ! 7978: that many characters up. Then, in the second part, ! 7979: we will have room to insert the newlines ! 7980: while copying down. ! 7981: NEWLINES may actually be too large, because it counts ! 7982: newlines in string constants, and we don't duplicate those. ! 7983: But that does no harm. */ ! 7984: if (newlines > 0) { ! 7985: ibp = start + length; ! 7986: obp = ibp + newlines; ! 7987: limit = start; ! 7988: while (limit != ibp) ! 7989: *--obp = *--ibp; ! 7990: } ! 7991: ! 7992: ibp = start + newlines; ! 7993: limit = start + length + newlines; ! 7994: obp = start; ! 7995: ! 7996: while (ibp < limit) { ! 7997: *obp++ = c = *ibp++; ! 7998: switch (c) { ! 7999: case '\n': ! 8000: /* Duplicate the newline. */ ! 8001: *obp++ = '\n'; ! 8002: break; ! 8003: ! 8004: case '\\': ! 8005: if (*ibp == '\n') { ! 8006: obp--; ! 8007: ibp++; ! 8008: } ! 8009: break; ! 8010: ! 8011: case '/': ! 8012: if (*ibp == '\\' && ibp[1] == '\n') ! 8013: newline_fix (ibp); ! 8014: /* Delete any comment. */ ! 8015: if (cplusplus_comments && ibp[0] == '/') { ! 8016: obp--; ! 8017: ibp++; ! 8018: while (ibp < limit && *ibp++ != '\n') ; ! 8019: break; ! 8020: } ! 8021: if (ibp[0] != '*' || ibp + 1 >= limit) ! 8022: break; ! 8023: obp--; ! 8024: ibp++; ! 8025: while (ibp + 1 < limit) { ! 8026: if (ibp[0] == '*' ! 8027: && ibp[1] == '\\' && ibp[2] == '\n') ! 8028: newline_fix (ibp + 1); ! 8029: if (ibp[0] == '*' && ibp[1] == '/') ! 8030: break; ! 8031: ibp++; ! 8032: } ! 8033: ibp += 2; ! 8034: break; ! 8035: ! 8036: case '\'': ! 8037: case '\"': ! 8038: /* Notice and skip strings, so that we don't ! 8039: think that comments start inside them, ! 8040: and so we don't duplicate newlines in them. */ ! 8041: { ! 8042: int quotec = c; ! 8043: while (ibp < limit) { ! 8044: *obp++ = c = *ibp++; ! 8045: if (c == quotec) ! 8046: break; ! 8047: if (c == '\n' && quotec == '\'') ! 8048: break; ! 8049: if (c == '\\' && ibp < limit) { ! 8050: while (*ibp == '\\' && ibp[1] == '\n') ! 8051: ibp += 2; ! 8052: *obp++ = *ibp++; ! 8053: } ! 8054: } ! 8055: } ! 8056: break; ! 8057: } ! 8058: } ! 8059: ! 8060: return obp - start; ! 8061: } ! 8062: ! 8063: /* Turn newlines to spaces in the string of length LENGTH at START, ! 8064: except inside of string constants. ! 8065: The string is copied into itself with its beginning staying fixed. */ ! 8066: ! 8067: static int ! 8068: change_newlines (start, length) ! 8069: U_CHAR *start; ! 8070: int length; ! 8071: { ! 8072: register U_CHAR *ibp; ! 8073: register U_CHAR *obp; ! 8074: register U_CHAR *limit; ! 8075: register int c; ! 8076: ! 8077: ibp = start; ! 8078: limit = start + length; ! 8079: obp = start; ! 8080: ! 8081: while (ibp < limit) { ! 8082: *obp++ = c = *ibp++; ! 8083: switch (c) { ! 8084: case '\n': ! 8085: /* If this is a NEWLINE NEWLINE, then this is a real newline in the ! 8086: string. Skip past the newline and its duplicate. ! 8087: Put a space in the output. */ ! 8088: if (*ibp == '\n') ! 8089: { ! 8090: ibp++; ! 8091: obp--; ! 8092: *obp++ = ' '; ! 8093: } ! 8094: break; ! 8095: ! 8096: case '\'': ! 8097: case '\"': ! 8098: /* Notice and skip strings, so that we don't delete newlines in them. */ ! 8099: { ! 8100: int quotec = c; ! 8101: while (ibp < limit) { ! 8102: *obp++ = c = *ibp++; ! 8103: if (c == quotec) ! 8104: break; ! 8105: if (c == '\n' && quotec == '\'') ! 8106: break; ! 8107: } ! 8108: } ! 8109: break; ! 8110: } ! 8111: } ! 8112: ! 8113: return obp - start; ! 8114: } ! 8115: ! 8116: /* ! 8117: * error - print error message and increment count of errors. ! 8118: */ ! 8119: ! 8120: void ! 8121: error (msg, arg1, arg2, arg3) ! 8122: char *msg; ! 8123: char *arg1, *arg2, *arg3; ! 8124: { ! 8125: int i; ! 8126: FILE_BUF *ip = NULL; ! 8127: ! 8128: print_containing_files (); ! 8129: ! 8130: for (i = indepth; i >= 0; i--) ! 8131: if (instack[i].fname != NULL) { ! 8132: ip = &instack[i]; ! 8133: break; ! 8134: } ! 8135: ! 8136: #ifdef REPORT_EVENT ! 8137: REPORT_EVENT (0, NULL, ! 8138: ip ? ip->nominal_fname : NULL, ! 8139: ip ? ip->lineno : 0, ! 8140: msg, arg1, arg2, arg3); ! 8141: #endif ! 8142: ! 8143: if (ip != NULL) ! 8144: fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno); ! 8145: fprintf (stderr, msg, arg1, arg2, arg3); ! 8146: fprintf (stderr, "\n"); ! 8147: errors++; ! 8148: } ! 8149: ! 8150: /* Error including a message from `errno'. */ ! 8151: ! 8152: static void ! 8153: error_from_errno (name) ! 8154: char *name; ! 8155: { ! 8156: int i; ! 8157: FILE_BUF *ip = NULL; ! 8158: ! 8159: print_containing_files (); ! 8160: ! 8161: for (i = indepth; i >= 0; i--) ! 8162: if (instack[i].fname != NULL) { ! 8163: ip = &instack[i]; ! 8164: break; ! 8165: } ! 8166: ! 8167: #ifdef REPORT_EVENT ! 8168: REPORT_EVENT (0, NULL, ! 8169: ip ? ip->nominal_fname : NULL, ! 8170: ip ? ip->lineno : 0, ! 8171: "%s: %s", name, ! 8172: (errno < sys_nerr) ! 8173: ? sys_errlist[errno] ! 8174: : "undocumented I/O error", ! 8175: 0); ! 8176: #endif ! 8177: ! 8178: if (ip != NULL) ! 8179: fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno); ! 8180: ! 8181: if (errno < sys_nerr) ! 8182: fprintf (stderr, "%s: %s\n", name, sys_errlist[errno]); ! 8183: else ! 8184: fprintf (stderr, "%s: undocumented I/O error\n", name); ! 8185: ! 8186: errors++; ! 8187: } ! 8188: ! 8189: /* Print error message but don't count it. */ ! 8190: ! 8191: void ! 8192: warning (msg, arg1, arg2, arg3) ! 8193: char *msg; ! 8194: char *arg1, *arg2, *arg3; ! 8195: { ! 8196: int i; ! 8197: FILE_BUF *ip = NULL; ! 8198: ! 8199: if (inhibit_warnings) ! 8200: return; ! 8201: ! 8202: if (warnings_are_errors) ! 8203: errors++; ! 8204: ! 8205: print_containing_files (); ! 8206: ! 8207: for (i = indepth; i >= 0; i--) ! 8208: if (instack[i].fname != NULL) { ! 8209: ip = &instack[i]; ! 8210: break; ! 8211: } ! 8212: ! 8213: #ifdef REPORT_EVENT ! 8214: REPORT_EVENT (1, NULL, ! 8215: ip ? ip->nominal_fname : NULL, ! 8216: ip ? ip->lineno : 0, ! 8217: msg, arg1, arg2, arg3); ! 8218: #endif ! 8219: ! 8220: if (ip != NULL) ! 8221: fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno); ! 8222: fprintf (stderr, "warning: "); ! 8223: fprintf (stderr, msg, arg1, arg2, arg3); ! 8224: fprintf (stderr, "\n"); ! 8225: } ! 8226: ! 8227: static void ! 8228: error_with_line (line, msg, arg1, arg2, arg3) ! 8229: int line; ! 8230: char *msg; ! 8231: char *arg1, *arg2, *arg3; ! 8232: { ! 8233: int i; ! 8234: FILE_BUF *ip = NULL; ! 8235: ! 8236: print_containing_files (); ! 8237: ! 8238: for (i = indepth; i >= 0; i--) ! 8239: if (instack[i].fname != NULL) { ! 8240: ip = &instack[i]; ! 8241: break; ! 8242: } ! 8243: ! 8244: #ifdef REPORT_EVENT ! 8245: REPORT_EVENT (0, NULL, ! 8246: ip ? ip->nominal_fname : NULL, ! 8247: line, msg, arg1, arg2, arg3); ! 8248: #endif ! 8249: ! 8250: if (ip != NULL) ! 8251: fprintf (stderr, "%s:%d: ", ip->nominal_fname, line); ! 8252: fprintf (stderr, msg, arg1, arg2, arg3); ! 8253: fprintf (stderr, "\n"); ! 8254: errors++; ! 8255: } ! 8256: ! 8257: static void ! 8258: warning_with_line (line, msg, arg1, arg2, arg3) ! 8259: int line; ! 8260: char *msg; ! 8261: char *arg1, *arg2, *arg3; ! 8262: { ! 8263: int i; ! 8264: FILE_BUF *ip = NULL; ! 8265: ! 8266: if (inhibit_warnings) ! 8267: return; ! 8268: ! 8269: if (warnings_are_errors) ! 8270: errors++; ! 8271: ! 8272: print_containing_files (); ! 8273: ! 8274: for (i = indepth; i >= 0; i--) ! 8275: if (instack[i].fname != NULL) { ! 8276: ip = &instack[i]; ! 8277: break; ! 8278: } ! 8279: ! 8280: #ifdef REPORT_EVENT ! 8281: REPORT_EVENT (0, NULL, ! 8282: ip ? ip->nominal_fname : NULL, ! 8283: line, msg, arg1, arg2, arg3); ! 8284: #endif ! 8285: ! 8286: if (ip != NULL) ! 8287: fprintf (stderr, "%s:%d: ", ip->nominal_fname, line); ! 8288: fprintf (stderr, "warning: "); ! 8289: fprintf (stderr, msg, arg1, arg2, arg3); ! 8290: fprintf (stderr, "\n"); ! 8291: } ! 8292: ! 8293: /* print an error message and maybe count it. */ ! 8294: ! 8295: void ! 8296: pedwarn (msg, arg1, arg2, arg3) ! 8297: char *msg; ! 8298: char *arg1, *arg2, *arg3; ! 8299: { ! 8300: if (pedantic_errors) ! 8301: error (msg, arg1, arg2, arg3); ! 8302: else ! 8303: warning (msg, arg1, arg2, arg3); ! 8304: } ! 8305: ! 8306: void ! 8307: pedwarn_with_line (line, msg, arg1, arg2, arg3) ! 8308: int line; ! 8309: char *msg; ! 8310: char *arg1, *arg2, *arg3; ! 8311: { ! 8312: if (pedantic_errors) ! 8313: error_with_line (line, msg, arg1, arg2, arg3); ! 8314: else ! 8315: warning_with_line (line, msg, arg1, arg2, arg3); ! 8316: } ! 8317: ! 8318: /* Report a warning (or an error if pedantic_errors) ! 8319: giving specified file name and line number, not current. */ ! 8320: ! 8321: static void ! 8322: pedwarn_with_file_and_line (file, line, msg, arg1, arg2, arg3) ! 8323: char *file; ! 8324: int line; ! 8325: char *msg; ! 8326: char *arg1, *arg2, *arg3; ! 8327: { ! 8328: int i; ! 8329: #ifdef REPORT_EVENT ! 8330: REPORT_EVENT (pedantic_errors ? 0 : 1, ! 8331: NULL, file, line, msg, arg1, arg2, arg3); ! 8332: #endif ! 8333: if (!pedantic_errors && inhibit_warnings) ! 8334: return; ! 8335: if (file != NULL) ! 8336: fprintf (stderr, "%s:%d: ", file, line); ! 8337: if (pedantic_errors) ! 8338: errors++; ! 8339: if (!pedantic_errors) ! 8340: fprintf (stderr, "warning: "); ! 8341: fprintf (stderr, msg, arg1, arg2, arg3); ! 8342: fprintf (stderr, "\n"); ! 8343: } ! 8344: ! 8345: /* Print the file names and line numbers of the #include ! 8346: commands which led to the current file. */ ! 8347: ! 8348: static void ! 8349: print_containing_files () ! 8350: { ! 8351: FILE_BUF *ip = NULL; ! 8352: int i; ! 8353: int first = 1; ! 8354: ! 8355: /* If stack of files hasn't changed since we last printed ! 8356: this info, don't repeat it. */ ! 8357: if (last_error_tick == input_file_stack_tick) ! 8358: return; ! 8359: ! 8360: for (i = indepth; i >= 0; i--) ! 8361: if (instack[i].fname != NULL) { ! 8362: ip = &instack[i]; ! 8363: break; ! 8364: } ! 8365: ! 8366: /* Give up if we don't find a source file. */ ! 8367: if (ip == NULL) ! 8368: return; ! 8369: ! 8370: /* Find the other, outer source files. */ ! 8371: for (i--; i >= 0; i--) ! 8372: if (instack[i].fname != NULL) { ! 8373: ip = &instack[i]; ! 8374: if (first) { ! 8375: first = 0; ! 8376: fprintf (stderr, "In file included"); ! 8377: } else { ! 8378: fprintf (stderr, ",\n "); ! 8379: } ! 8380: ! 8381: fprintf (stderr, " from %s:%d", ip->nominal_fname, ip->lineno); ! 8382: } ! 8383: if (! first) ! 8384: fprintf (stderr, ":\n"); ! 8385: ! 8386: /* Record we have printed the status as of this time. */ ! 8387: last_error_tick = input_file_stack_tick; ! 8388: } ! 8389: ! 8390: /* Return the line at which an error occurred. ! 8391: The error is not necessarily associated with the current spot ! 8392: in the input stack, so LINE says where. LINE will have been ! 8393: copied from ip->lineno for the current input level. ! 8394: If the current level is for a file, we return LINE. ! 8395: But if the current level is not for a file, LINE is meaningless. ! 8396: In that case, we return the lineno of the innermost file. */ ! 8397: ! 8398: static int ! 8399: line_for_error (line) ! 8400: int line; ! 8401: { ! 8402: int i; ! 8403: int line1 = line; ! 8404: ! 8405: for (i = indepth; i >= 0; ) { ! 8406: if (instack[i].fname != 0) ! 8407: return line1; ! 8408: i--; ! 8409: if (i < 0) ! 8410: return 0; ! 8411: line1 = instack[i].lineno; ! 8412: } ! 8413: abort (); ! 8414: /*NOTREACHED*/ ! 8415: return 0; ! 8416: } ! 8417: ! 8418: /* ! 8419: * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger. ! 8420: * ! 8421: * As things stand, nothing is ever placed in the output buffer to be ! 8422: * removed again except when it's KNOWN to be part of an identifier, ! 8423: * so flushing and moving down everything left, instead of expanding, ! 8424: * should work ok. ! 8425: */ ! 8426: ! 8427: /* You might think void was cleaner for the return type, ! 8428: but that would get type mismatch in check_expand in strict ANSI. */ ! 8429: static int ! 8430: grow_outbuf (obuf, needed) ! 8431: register FILE_BUF *obuf; ! 8432: register int needed; ! 8433: { ! 8434: register U_CHAR *p; ! 8435: int minsize; ! 8436: ! 8437: if (obuf->length - (obuf->bufp - obuf->buf) > needed) ! 8438: return 0; ! 8439: ! 8440: /* Make it at least twice as big as it is now. */ ! 8441: obuf->length *= 2; ! 8442: /* Make it have at least 150% of the free space we will need. */ ! 8443: minsize = (3 * needed) / 2 + (obuf->bufp - obuf->buf); ! 8444: if (minsize > obuf->length) ! 8445: obuf->length = minsize; ! 8446: ! 8447: if ((p = (U_CHAR *) xrealloc (obuf->buf, obuf->length)) == NULL) ! 8448: memory_full (); ! 8449: ! 8450: obuf->bufp = p + (obuf->bufp - obuf->buf); ! 8451: obuf->buf = p; ! 8452: ! 8453: return 0; ! 8454: } ! 8455: ! 8456: /* Symbol table for macro names and special symbols */ ! 8457: ! 8458: /* ! 8459: * install a name in the main hash table, even if it is already there. ! 8460: * name stops with first non alphanumeric, except leading '#'. ! 8461: * caller must check against redefinition if that is desired. ! 8462: * delete_macro () removes things installed by install () in fifo order. ! 8463: * this is important because of the `defined' special symbol used ! 8464: * in #if, and also if pushdef/popdef directives are ever implemented. ! 8465: * ! 8466: * If LEN is >= 0, it is the length of the name. ! 8467: * Otherwise, compute the length by scanning the entire name. ! 8468: * ! 8469: * If HASH is >= 0, it is the precomputed hash code. ! 8470: * Otherwise, compute the hash code. ! 8471: */ ! 8472: static HASHNODE * ! 8473: install (name, len, type, ivalue, value, hash) ! 8474: U_CHAR *name; ! 8475: int len; ! 8476: enum node_type type; ! 8477: int ivalue; ! 8478: char *value; ! 8479: int hash; ! 8480: { ! 8481: register HASHNODE *hp; ! 8482: register int i, bucket; ! 8483: register U_CHAR *p, *q; ! 8484: ! 8485: if (len < 0) { ! 8486: p = name; ! 8487: while (is_idchar[*p]) ! 8488: p++; ! 8489: len = p - name; ! 8490: } ! 8491: ! 8492: if (hash < 0) ! 8493: hash = hashf (name, len, HASHSIZE); ! 8494: ! 8495: i = sizeof (HASHNODE) + len + 1; ! 8496: hp = (HASHNODE *) xmalloc (i); ! 8497: bucket = hash; ! 8498: hp->bucket_hdr = &hashtab[bucket]; ! 8499: hp->next = hashtab[bucket]; ! 8500: hashtab[bucket] = hp; ! 8501: hp->prev = NULL; ! 8502: if (hp->next != NULL) ! 8503: hp->next->prev = hp; ! 8504: hp->type = type; ! 8505: hp->length = len; ! 8506: if (hp->type == T_CONST) ! 8507: hp->value.ival = ivalue; ! 8508: else ! 8509: hp->value.cpval = value; ! 8510: hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE); ! 8511: p = hp->name; ! 8512: q = name; ! 8513: for (i = 0; i < len; i++) ! 8514: *p++ = *q++; ! 8515: hp->name[len] = 0; ! 8516: return hp; ! 8517: } ! 8518: ! 8519: /* ! 8520: * find the most recent hash node for name name (ending with first ! 8521: * non-identifier char) installed by install ! 8522: * ! 8523: * If LEN is >= 0, it is the length of the name. ! 8524: * Otherwise, compute the length by scanning the entire name. ! 8525: * ! 8526: * If HASH is >= 0, it is the precomputed hash code. ! 8527: * Otherwise, compute the hash code. ! 8528: */ ! 8529: HASHNODE * ! 8530: lookup (name, len, hash) ! 8531: U_CHAR *name; ! 8532: int len; ! 8533: int hash; ! 8534: { ! 8535: register U_CHAR *bp; ! 8536: register HASHNODE *bucket; ! 8537: ! 8538: if (len < 0) { ! 8539: for (bp = name; is_idchar[*bp]; bp++) ; ! 8540: len = bp - name; ! 8541: } ! 8542: ! 8543: if (hash < 0) ! 8544: hash = hashf (name, len, HASHSIZE); ! 8545: ! 8546: bucket = hashtab[hash]; ! 8547: while (bucket) { ! 8548: if (bucket->length == len && strncmp (bucket->name, name, len) == 0) ! 8549: return bucket; ! 8550: bucket = bucket->next; ! 8551: } ! 8552: return NULL; ! 8553: } ! 8554: ! 8555: /* ! 8556: * Delete a hash node. Some weirdness to free junk from macros. ! 8557: * More such weirdness will have to be added if you define more hash ! 8558: * types that need it. ! 8559: */ ! 8560: ! 8561: /* Note that the DEFINITION of a macro is removed from the hash table ! 8562: but its storage is not freed. This would be a storage leak ! 8563: except that it is not reasonable to keep undefining and redefining ! 8564: large numbers of macros many times. ! 8565: In any case, this is necessary, because a macro can be #undef'd ! 8566: in the middle of reading the arguments to a call to it. ! 8567: If #undef freed the DEFINITION, that would crash. */ ! 8568: ! 8569: static void ! 8570: delete_macro (hp) ! 8571: HASHNODE *hp; ! 8572: { ! 8573: ! 8574: if (hp->prev != NULL) ! 8575: hp->prev->next = hp->next; ! 8576: if (hp->next != NULL) ! 8577: hp->next->prev = hp->prev; ! 8578: ! 8579: /* make sure that the bucket chain header that ! 8580: the deleted guy was on points to the right thing afterwards. */ ! 8581: if (hp == *hp->bucket_hdr) ! 8582: *hp->bucket_hdr = hp->next; ! 8583: ! 8584: #if 0 ! 8585: if (hp->type == T_MACRO) { ! 8586: DEFINITION *d = hp->value.defn; ! 8587: struct reflist *ap, *nextap; ! 8588: ! 8589: for (ap = d->pattern; ap != NULL; ap = nextap) { ! 8590: nextap = ap->next; ! 8591: free (ap); ! 8592: } ! 8593: free (d); ! 8594: } ! 8595: #endif ! 8596: free (hp); ! 8597: } ! 8598: ! 8599: /* ! 8600: * return hash function on name. must be compatible with the one ! 8601: * computed a step at a time, elsewhere ! 8602: */ ! 8603: static int ! 8604: hashf (name, len, hashsize) ! 8605: register U_CHAR *name; ! 8606: register int len; ! 8607: int hashsize; ! 8608: { ! 8609: register int r = 0; ! 8610: ! 8611: while (len--) ! 8612: r = HASHSTEP (r, *name++); ! 8613: ! 8614: return MAKE_POS (r) % hashsize; ! 8615: } ! 8616: ! 8617: ! 8618: /* Dump the definition of a single macro HP to OF. */ ! 8619: static void ! 8620: dump_single_macro (hp, of) ! 8621: register HASHNODE *hp; ! 8622: FILE *of; ! 8623: { ! 8624: register DEFINITION *defn = hp->value.defn; ! 8625: struct reflist *ap; ! 8626: int offset; ! 8627: int concat; ! 8628: ! 8629: ! 8630: /* Print the definition of the macro HP. */ ! 8631: ! 8632: fprintf (of, "#define %s", hp->name); ! 8633: ! 8634: if (defn->nargs >= 0) { ! 8635: int i; ! 8636: ! 8637: fprintf (of, "("); ! 8638: for (i = 0; i < defn->nargs; i++) { ! 8639: dump_arg_n (defn, i, of); ! 8640: if (i + 1 < defn->nargs) ! 8641: fprintf (of, ", "); ! 8642: } ! 8643: fprintf (of, ")"); ! 8644: } ! 8645: ! 8646: fprintf (of, " "); ! 8647: ! 8648: offset = 0; ! 8649: concat = 0; ! 8650: for (ap = defn->pattern; ap != NULL; ap = ap->next) { ! 8651: dump_defn_1 (defn->expansion, offset, ap->nchars, of); ! 8652: if (ap->nchars != 0) ! 8653: concat = 0; ! 8654: offset += ap->nchars; ! 8655: if (ap->stringify) ! 8656: fprintf (of, " #"); ! 8657: if (ap->raw_before && !concat) ! 8658: fprintf (of, " ## "); ! 8659: concat = 0; ! 8660: dump_arg_n (defn, ap->argno, of); ! 8661: if (ap->raw_after) { ! 8662: fprintf (of, " ## "); ! 8663: concat = 1; ! 8664: } ! 8665: } ! 8666: dump_defn_1 (defn->expansion, offset, defn->length - offset, of); ! 8667: fprintf (of, "\n"); ! 8668: } ! 8669: ! 8670: /* Dump all macro definitions as #defines to stdout. */ ! 8671: ! 8672: static void ! 8673: dump_all_macros () ! 8674: { ! 8675: int bucket; ! 8676: ! 8677: for (bucket = 0; bucket < HASHSIZE; bucket++) { ! 8678: register HASHNODE *hp; ! 8679: ! 8680: for (hp = hashtab[bucket]; hp; hp= hp->next) { ! 8681: if (hp->type == T_MACRO) ! 8682: dump_single_macro (hp, stdout); ! 8683: } ! 8684: } ! 8685: } ! 8686: ! 8687: /* Output to OF a substring of a macro definition. ! 8688: BASE is the beginning of the definition. ! 8689: Output characters START thru LENGTH. ! 8690: Discard newlines outside of strings, thus ! 8691: converting funny-space markers to ordinary spaces. */ ! 8692: ! 8693: static void ! 8694: dump_defn_1 (base, start, length, of) ! 8695: U_CHAR *base; ! 8696: int start; ! 8697: int length; ! 8698: FILE *of; ! 8699: { ! 8700: U_CHAR *p = base + start; ! 8701: U_CHAR *limit = base + start + length; ! 8702: ! 8703: while (p < limit) { ! 8704: if (*p != '\n') ! 8705: putc (*p, of); ! 8706: else if (*p == '\"' || *p =='\'') { ! 8707: U_CHAR *p1 = skip_quoted_string (p, limit, 0, NULL_PTR, ! 8708: NULL_PTR, NULL_PTR); ! 8709: fwrite (p, p1 - p, 1, of); ! 8710: p = p1 - 1; ! 8711: } ! 8712: p++; ! 8713: } ! 8714: } ! 8715: ! 8716: /* Print the name of argument number ARGNUM of macro definition DEFN ! 8717: to OF. ! 8718: Recall that DEFN->args.argnames contains all the arg names ! 8719: concatenated in reverse order with comma-space in between. */ ! 8720: ! 8721: static void ! 8722: dump_arg_n (defn, argnum, of) ! 8723: DEFINITION *defn; ! 8724: int argnum; ! 8725: FILE *of; ! 8726: { ! 8727: register U_CHAR *p = defn->args.argnames; ! 8728: while (argnum + 1 < defn->nargs) { ! 8729: p = (U_CHAR *) index (p, ' ') + 1; ! 8730: argnum++; ! 8731: } ! 8732: ! 8733: while (*p && *p != ',') { ! 8734: putc (*p, of); ! 8735: p++; ! 8736: } ! 8737: } ! 8738: ! 8739: /* Initialize syntactic classifications of characters. */ ! 8740: ! 8741: static void ! 8742: initialize_char_syntax () ! 8743: { ! 8744: register int i; ! 8745: ! 8746: /* ! 8747: * Set up is_idchar and is_idstart tables. These should be ! 8748: * faster than saying (is_alpha (c) || c == '_'), etc. ! 8749: * Set up these things before calling any routines tthat ! 8750: * refer to them. ! 8751: */ ! 8752: for (i = 'a'; i <= 'z'; i++) { ! 8753: is_idchar[i - 'a' + 'A'] = 1; ! 8754: is_idchar[i] = 1; ! 8755: is_idstart[i - 'a' + 'A'] = 1; ! 8756: is_idstart[i] = 1; ! 8757: } ! 8758: for (i = '0'; i <= '9'; i++) ! 8759: is_idchar[i] = 1; ! 8760: is_idchar['_'] = 1; ! 8761: is_idstart['_'] = 1; ! 8762: is_idchar['$'] = dollars_in_ident; ! 8763: is_idstart['$'] = dollars_in_ident; ! 8764: ! 8765: /* horizontal space table */ ! 8766: is_hor_space[' '] = 1; ! 8767: is_hor_space['\t'] = 1; ! 8768: is_hor_space['\v'] = 1; ! 8769: is_hor_space['\f'] = 1; ! 8770: is_hor_space['\r'] = 1; ! 8771: ! 8772: is_space[' '] = 1; ! 8773: is_space['\t'] = 1; ! 8774: is_space['\v'] = 1; ! 8775: is_space['\f'] = 1; ! 8776: is_space['\n'] = 1; ! 8777: is_space['\r'] = 1; ! 8778: } ! 8779: ! 8780: /* Initialize the built-in macros. */ ! 8781: ! 8782: static void ! 8783: initialize_builtins (inp, outp) ! 8784: FILE_BUF *inp; ! 8785: FILE_BUF *outp; ! 8786: { ! 8787: install ("__LINE__", -1, T_SPECLINE, 0, 0, -1); ! 8788: install ("__DATE__", -1, T_DATE, 0, 0, -1); ! 8789: install ("__FILE__", -1, T_FILE, 0, 0, -1); ! 8790: install ("__BASE_FILE__", -1, T_BASE_FILE, 0, 0, -1); ! 8791: install ("__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, 0, 0, -1); ! 8792: install ("__VERSION__", -1, T_VERSION, 0, 0, -1); ! 8793: #ifndef NO_BUILTIN_SIZE_TYPE ! 8794: install ("__SIZE_TYPE__", -1, T_SIZE_TYPE, 0, 0, -1); ! 8795: #endif ! 8796: #ifndef NO_BUILTIN_PTRDIFF_TYPE ! 8797: install ("__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, 0, 0, -1); ! 8798: #endif ! 8799: install ("__WCHAR_TYPE__", -1, T_WCHAR_TYPE, 0, 0, -1); ! 8800: install ("__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE, 0, 0, -1); ! 8801: install ("__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE, 0, 0, -1); ! 8802: install ("__TIME__", -1, T_TIME, 0, 0, -1); ! 8803: if (!traditional) ! 8804: install ("__STDC__", -1, T_CONST, STDC_VALUE, 0, -1); ! 8805: if (objc) ! 8806: install ("__OBJC__", -1, T_CONST, 1, 0, -1); ! 8807: /* This is supplied using a -D by the compiler driver ! 8808: so that it is present only when truly compiling with GNU C. */ ! 8809: /* install ("__GNUC__", -1, T_CONST, 2, 0, -1); */ ! 8810: ! 8811: if (debug_output) ! 8812: { ! 8813: char directive[2048]; ! 8814: register struct directive *dp = &directive_table[0]; ! 8815: struct tm *timebuf = timestamp (); ! 8816: ! 8817: sprintf (directive, " __BASE_FILE__ \"%s\"\n", ! 8818: instack[0].nominal_fname); ! 8819: output_line_command (inp, outp, 0, same_file); ! 8820: pass_thru_directive (directive, &directive[strlen (directive)], outp, dp); ! 8821: ! 8822: sprintf (directive, " __VERSION__ \"%s\"\n", version_string); ! 8823: output_line_command (inp, outp, 0, same_file); ! 8824: pass_thru_directive (directive, &directive[strlen (directive)], outp, dp); ! 8825: ! 8826: #ifndef NO_BUILTIN_SIZE_TYPE ! 8827: sprintf (directive, " __SIZE_TYPE__ %s\n", SIZE_TYPE); ! 8828: output_line_command (inp, outp, 0, same_file); ! 8829: pass_thru_directive (directive, &directive[strlen (directive)], outp, dp); ! 8830: #endif ! 8831: ! 8832: #ifndef NO_BUILTIN_PTRDIFF_TYPE ! 8833: sprintf (directive, " __PTRDIFF_TYPE__ %s\n", PTRDIFF_TYPE); ! 8834: output_line_command (inp, outp, 0, same_file); ! 8835: pass_thru_directive (directive, &directive[strlen (directive)], outp, dp); ! 8836: #endif ! 8837: ! 8838: sprintf (directive, " __WCHAR_TYPE__ %s\n", WCHAR_TYPE); ! 8839: output_line_command (inp, outp, 0, same_file); ! 8840: pass_thru_directive (directive, &directive[strlen (directive)], outp, dp); ! 8841: ! 8842: sprintf (directive, " __DATE__ \"%s %2d %4d\"\n", ! 8843: monthnames[timebuf->tm_mon], ! 8844: timebuf->tm_mday, timebuf->tm_year + 1900); ! 8845: output_line_command (inp, outp, 0, same_file); ! 8846: pass_thru_directive (directive, &directive[strlen (directive)], outp, dp); ! 8847: ! 8848: sprintf (directive, " __TIME__ \"%02d:%02d:%02d\"\n", ! 8849: timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec); ! 8850: output_line_command (inp, outp, 0, same_file); ! 8851: pass_thru_directive (directive, &directive[strlen (directive)], outp, dp); ! 8852: ! 8853: if (!traditional) ! 8854: { ! 8855: sprintf (directive, " __STDC__ 1"); ! 8856: output_line_command (inp, outp, 0, same_file); ! 8857: pass_thru_directive (directive, &directive[strlen (directive)], ! 8858: outp, dp); ! 8859: } ! 8860: if (objc) ! 8861: { ! 8862: sprintf (directive, " __OBJC__ 1"); ! 8863: output_line_command (inp, outp, 0, same_file); ! 8864: pass_thru_directive (directive, &directive[strlen (directive)], ! 8865: outp, dp); ! 8866: } ! 8867: } ! 8868: } ! 8869: ! 8870: /* ! 8871: * process a given definition string, for initialization ! 8872: * If STR is just an identifier, define it with value 1. ! 8873: * If STR has anything after the identifier, then it should ! 8874: * be identifier=definition. ! 8875: */ ! 8876: ! 8877: static void ! 8878: make_definition (str, op) ! 8879: U_CHAR *str; ! 8880: FILE_BUF *op; ! 8881: { ! 8882: FILE_BUF *ip; ! 8883: struct directive *kt; ! 8884: U_CHAR *buf, *p; ! 8885: ! 8886: buf = str; ! 8887: p = str; ! 8888: if (!is_idstart[*p]) { ! 8889: error ("malformed option `-D %s'", str); ! 8890: return; ! 8891: } ! 8892: while (is_idchar[*++p]) ! 8893: ; ! 8894: if (*p == 0) { ! 8895: buf = (U_CHAR *) alloca (p - buf + 4); ! 8896: strcpy ((char *)buf, str); ! 8897: strcat ((char *)buf, " 1"); ! 8898: } else if (*p != '=') { ! 8899: error ("malformed option `-D %s'", str); ! 8900: return; ! 8901: } else { ! 8902: U_CHAR *q; ! 8903: /* Copy the entire option so we can modify it. */ ! 8904: buf = (U_CHAR *) alloca (2 * strlen (str) + 1); ! 8905: strncpy (buf, str, p - str); ! 8906: /* Change the = to a space. */ ! 8907: buf[p - str] = ' '; ! 8908: /* Scan for any backslash-newline and remove it. */ ! 8909: p++; ! 8910: q = &buf[p - str]; ! 8911: while (*p) { ! 8912: if (*p == '\\' && p[1] == '\n') ! 8913: p += 2; ! 8914: /* Change newline chars into newline-markers. */ ! 8915: else if (*p == '\n') ! 8916: { ! 8917: *q++ = '\n'; ! 8918: *q++ = '\n'; ! 8919: p++; ! 8920: } ! 8921: else ! 8922: *q++ = *p++; ! 8923: } ! 8924: *q = 0; ! 8925: } ! 8926: ! 8927: ip = &instack[++indepth]; ! 8928: ip->nominal_fname = ip->fname = "*Initialization*"; ! 8929: ! 8930: ip->buf = ip->bufp = buf; ! 8931: ip->length = strlen (buf); ! 8932: ip->lineno = 1; ! 8933: ip->macro = 0; ! 8934: ip->free_ptr = 0; ! 8935: ip->if_stack = if_stack; ! 8936: ip->system_header_p = 0; ! 8937: ! 8938: for (kt = directive_table; kt->type != T_DEFINE; kt++) ! 8939: ; ! 8940: ! 8941: /* Pass NULL instead of OP, since this is a "predefined" macro. */ ! 8942: do_define (buf, buf + strlen (buf), NULL, kt); ! 8943: --indepth; ! 8944: } ! 8945: ! 8946: /* JF, this does the work for the -U option */ ! 8947: ! 8948: static void ! 8949: make_undef (str, op) ! 8950: U_CHAR *str; ! 8951: FILE_BUF *op; ! 8952: { ! 8953: FILE_BUF *ip; ! 8954: struct directive *kt; ! 8955: ! 8956: ip = &instack[++indepth]; ! 8957: ip->nominal_fname = ip->fname = "*undef*"; ! 8958: ! 8959: ip->buf = ip->bufp = str; ! 8960: ip->length = strlen (str); ! 8961: ip->lineno = 1; ! 8962: ip->macro = 0; ! 8963: ip->free_ptr = 0; ! 8964: ip->if_stack = if_stack; ! 8965: ip->system_header_p = 0; ! 8966: ! 8967: for (kt = directive_table; kt->type != T_UNDEF; kt++) ! 8968: ; ! 8969: ! 8970: do_undef (str, str + strlen (str), op, kt); ! 8971: --indepth; ! 8972: } ! 8973: ! 8974: /* Process the string STR as if it appeared as the body of a #assert. ! 8975: OPTION is the option name for which STR was the argument. */ ! 8976: ! 8977: static void ! 8978: make_assertion (option, str) ! 8979: char *option; ! 8980: U_CHAR *str; ! 8981: { ! 8982: FILE_BUF *ip; ! 8983: struct directive *kt; ! 8984: U_CHAR *buf, *p, *q; ! 8985: ! 8986: /* Copy the entire option so we can modify it. */ ! 8987: buf = (U_CHAR *) alloca (strlen (str) + 1); ! 8988: strcpy ((char *) buf, str); ! 8989: /* Scan for any backslash-newline and remove it. */ ! 8990: p = q = buf; ! 8991: while (*p) { ! 8992: if (*p == '\\' && p[1] == '\n') ! 8993: p += 2; ! 8994: else ! 8995: *q++ = *p++; ! 8996: } ! 8997: *q = 0; ! 8998: ! 8999: p = buf; ! 9000: if (!is_idstart[*p]) { ! 9001: error ("malformed option `%s %s'", option, str); ! 9002: return; ! 9003: } ! 9004: while (is_idchar[*++p]) ! 9005: ; ! 9006: while (*p == ' ' || *p == '\t') p++; ! 9007: if (! (*p == 0 || *p == '(')) { ! 9008: error ("malformed option `%s %s'", option, str); ! 9009: return; ! 9010: } ! 9011: ! 9012: ip = &instack[++indepth]; ! 9013: ip->nominal_fname = ip->fname = "*Initialization*"; ! 9014: ! 9015: ip->buf = ip->bufp = buf; ! 9016: ip->length = strlen (buf); ! 9017: ip->lineno = 1; ! 9018: ip->macro = 0; ! 9019: ip->free_ptr = 0; ! 9020: ip->if_stack = if_stack; ! 9021: ip->system_header_p = 0; ! 9022: ! 9023: for (kt = directive_table; kt->type != T_ASSERT; kt++) ! 9024: ; ! 9025: ! 9026: /* pass NULL as output ptr to do_define since we KNOW it never ! 9027: does any output.... */ ! 9028: do_assert (buf, buf + strlen (buf) , NULL_PTR, kt); ! 9029: --indepth; ! 9030: } ! 9031: ! 9032: /* Append a chain of `struct file_name_list's ! 9033: to the end of the main include chain. ! 9034: FIRST is the beginning of the chain to append, and LAST is the end. */ ! 9035: ! 9036: static void ! 9037: append_include_chain (first, last) ! 9038: struct file_name_list *first, *last; ! 9039: { ! 9040: struct file_name_list *dir; ! 9041: ! 9042: if (!first || !last) ! 9043: return; ! 9044: ! 9045: if (include == 0) ! 9046: include = first; ! 9047: else ! 9048: last_include->next = first; ! 9049: ! 9050: if (first_bracket_include == 0) ! 9051: first_bracket_include = first; ! 9052: ! 9053: for (dir = first; ; dir = dir->next) { ! 9054: int len = strlen (dir->fname) + INCLUDE_LEN_FUDGE; ! 9055: if (len > max_include_len) ! 9056: max_include_len = len; ! 9057: if (dir == last) ! 9058: break; ! 9059: } ! 9060: ! 9061: last->next = NULL; ! 9062: last_include = last; ! 9063: } ! 9064: ! 9065: /* Add output to `deps_buffer' for the -M switch. ! 9066: STRING points to the text to be output. ! 9067: SIZE is the number of bytes, or 0 meaning output until a null. ! 9068: Outputting the empty string breaks the line if it is long enough. */ ! 9069: ! 9070: static void ! 9071: deps_output (string, size) ! 9072: char *string; ! 9073: unsigned size; ! 9074: { ! 9075: if (size == 0) ! 9076: size = strlen (string); ! 9077: ! 9078: #ifndef MAX_OUTPUT_COLUMNS ! 9079: #define MAX_OUTPUT_COLUMNS 75 ! 9080: #endif ! 9081: if (size == 0 && deps_column != 0 ! 9082: && size + deps_column > MAX_OUTPUT_COLUMNS) { ! 9083: deps_output ("\\\n ", 0); ! 9084: deps_column = 0; ! 9085: } ! 9086: ! 9087: if (deps_size + size + 1 > deps_allocated_size) { ! 9088: deps_allocated_size = deps_size + size + 50; ! 9089: deps_allocated_size *= 2; ! 9090: deps_buffer = (char *) xrealloc (deps_buffer, deps_allocated_size); ! 9091: } ! 9092: bcopy (string, &deps_buffer[deps_size], size); ! 9093: deps_size += size; ! 9094: deps_column += size; ! 9095: deps_buffer[deps_size] = 0; ! 9096: } ! 9097: ! 9098: #if defined(USG) || defined(VMS) ! 9099: #ifndef BSTRING ! 9100: ! 9101: void ! 9102: bzero (b, length) ! 9103: register char *b; ! 9104: register unsigned length; ! 9105: { ! 9106: while (length-- > 0) ! 9107: *b++ = 0; ! 9108: } ! 9109: ! 9110: void ! 9111: bcopy (b1, b2, length) ! 9112: register char *b1; ! 9113: register char *b2; ! 9114: register unsigned length; ! 9115: { ! 9116: while (length-- > 0) ! 9117: *b2++ = *b1++; ! 9118: } ! 9119: ! 9120: int ! 9121: bcmp (b1, b2, length) /* This could be a macro! */ ! 9122: register char *b1; ! 9123: register char *b2; ! 9124: register unsigned length; ! 9125: { ! 9126: while (length-- > 0) ! 9127: if (*b1++ != *b2++) ! 9128: return 1; ! 9129: ! 9130: return 0; ! 9131: } ! 9132: #endif /* not BSTRING */ ! 9133: #endif /* USG or VMS */ ! 9134: ! 9135: ! 9136: static void ! 9137: fatal (str, arg) ! 9138: char *str, *arg; ! 9139: { ! 9140: #ifdef REPORT_EVENT ! 9141: REPORT_EVENT (0, progname, NULL, 0, str, arg, 0, 0); ! 9142: #endif ! 9143: fprintf (stderr, "%s: ", progname); ! 9144: fprintf (stderr, str, arg); ! 9145: fprintf (stderr, "\n"); ! 9146: exit (FAILURE_EXIT_CODE); ! 9147: } ! 9148: ! 9149: /* More 'friendly' abort that prints the line and file. ! 9150: config.h can #define abort fancy_abort if you like that sort of thing. */ ! 9151: ! 9152: void ! 9153: fancy_abort () ! 9154: { ! 9155: fatal ("Internal gcc abort."); ! 9156: } ! 9157: ! 9158: static void ! 9159: perror_with_name (name) ! 9160: char *name; ! 9161: { ! 9162: #ifdef REPORT_EVENT ! 9163: REPORT_EVENT (0, progname, NULL, 0, ! 9164: "%s: %s", name, ! 9165: (errno < sys_nerr) ! 9166: ? sys_errlist[errno] ! 9167: : "undocumented I/O error", ! 9168: 0); ! 9169: #endif ! 9170: fprintf (stderr, "%s: ", progname); ! 9171: if (errno < sys_nerr) ! 9172: fprintf (stderr, "%s: %s\n", name, sys_errlist[errno]); ! 9173: else ! 9174: fprintf (stderr, "%s: undocumented I/O error\n", name); ! 9175: errors++; ! 9176: } ! 9177: ! 9178: static void ! 9179: pfatal_with_name (name) ! 9180: char *name; ! 9181: { ! 9182: perror_with_name (name); ! 9183: #ifdef VMS ! 9184: exit (vaxc$errno); ! 9185: #else ! 9186: exit (FAILURE_EXIT_CODE); ! 9187: #endif ! 9188: } ! 9189: ! 9190: /* Handler for SIGPIPE. */ ! 9191: ! 9192: static void ! 9193: pipe_closed (signo) ! 9194: /* If this is missing, some compilers complain. */ ! 9195: int signo; ! 9196: { ! 9197: fatal ("output pipe has been closed"); ! 9198: } ! 9199: ! 9200: static void ! 9201: memory_full () ! 9202: { ! 9203: fatal ("Memory exhausted."); ! 9204: } ! 9205: ! 9206: ! 9207: char * ! 9208: xmalloc (size) ! 9209: unsigned size; ! 9210: { ! 9211: register char *ptr = (char *) malloc (size); ! 9212: if (ptr != 0) return (ptr); ! 9213: memory_full (); ! 9214: /*NOTREACHED*/ ! 9215: return 0; ! 9216: } ! 9217: ! 9218: static char * ! 9219: xrealloc (old, size) ! 9220: char *old; ! 9221: unsigned size; ! 9222: { ! 9223: register char *ptr = (char *) realloc (old, size); ! 9224: if (ptr != 0) return (ptr); ! 9225: memory_full (); ! 9226: /*NOTREACHED*/ ! 9227: return 0; ! 9228: } ! 9229: ! 9230: static char * ! 9231: xcalloc (number, size) ! 9232: unsigned number, size; ! 9233: { ! 9234: register unsigned total = number * size; ! 9235: register char *ptr = (char *) malloc (total); ! 9236: if (ptr != 0) { ! 9237: if (total > 100) ! 9238: bzero (ptr, total); ! 9239: else { ! 9240: /* It's not too long, so loop, zeroing by longs. ! 9241: It must be safe because malloc values are always well aligned. */ ! 9242: register long *zp = (long *) ptr; ! 9243: register long *zl = (long *) (ptr + total - 4); ! 9244: register int i = total - 4; ! 9245: while (zp < zl) ! 9246: *zp++ = 0; ! 9247: if (i < 0) ! 9248: i = 0; ! 9249: while (i < total) ! 9250: ptr[i++] = 0; ! 9251: } ! 9252: return ptr; ! 9253: } ! 9254: memory_full (); ! 9255: /*NOTREACHED*/ ! 9256: return 0; ! 9257: } ! 9258: ! 9259: static char * ! 9260: savestring (input) ! 9261: char *input; ! 9262: { ! 9263: unsigned size = strlen (input); ! 9264: char *output = xmalloc (size + 1); ! 9265: strcpy (output, input); ! 9266: return output; ! 9267: } ! 9268: ! 9269: /* Get the file-mode and data size of the file open on FD ! 9270: and store them in *MODE_POINTER and *SIZE_POINTER. */ ! 9271: ! 9272: static int ! 9273: file_size_and_mode (fd, mode_pointer, size_pointer) ! 9274: int fd; ! 9275: int *mode_pointer; ! 9276: long int *size_pointer; ! 9277: { ! 9278: struct stat sbuf; ! 9279: ! 9280: if (fstat (fd, &sbuf) < 0) return (-1); ! 9281: if (mode_pointer) *mode_pointer = sbuf.st_mode; ! 9282: if (size_pointer) *size_pointer = sbuf.st_size; ! 9283: return 0; ! 9284: } ! 9285: ! 9286: static void ! 9287: output_dots (fd, depth) ! 9288: FILE* fd; ! 9289: int depth; ! 9290: { ! 9291: while (depth > 0) { ! 9292: putc ('.', fd); ! 9293: depth--; ! 9294: } ! 9295: } ! 9296: ! 9297: ! 9298: #ifdef VMS ! 9299: ! 9300: /* Under VMS we need to fix up the "include" specification ! 9301: filename so that everything following the 1st slash is ! 9302: changed into its correct VMS file specification. */ ! 9303: ! 9304: static void ! 9305: hack_vms_include_specification (fname) ! 9306: char *fname; ! 9307: { ! 9308: register char *cp, *cp1, *cp2; ! 9309: int f, check_filename_before_returning, no_prefix_seen; ! 9310: char Local[512]; ! 9311: ! 9312: check_filename_before_returning = 0; ! 9313: no_prefix_seen = 0; ! 9314: ! 9315: /* Ignore leading "./"s */ ! 9316: while (fname[0] == '.' && fname[1] == '/') { ! 9317: strcpy (fname, fname+2); ! 9318: no_prefix_seen = 1; /* mark this for later */ ! 9319: } ! 9320: /* Look for the boundary between the VMS and UNIX filespecs */ ! 9321: cp = rindex (fname, ']'); /* Look for end of dirspec. */ ! 9322: if (cp == 0) cp = rindex (fname, '>'); /* ... Ditto */ ! 9323: if (cp == 0) cp = rindex (fname, ':'); /* Look for end of devspec. */ ! 9324: if (cp) { ! 9325: cp++; ! 9326: } else { ! 9327: cp = index (fname, '/'); /* Look for the "/" */ ! 9328: } ! 9329: ! 9330: cp2 = Local; /* initialize */ ! 9331: ! 9332: /* We are trying to do a number of things here. First of all, we are ! 9333: trying to hammer the filenames into a standard format, such that later ! 9334: processing can handle them. ! 9335: ! 9336: If the file name contains something like [dir.], then it recognizes this ! 9337: as a root, and strips the ".]". Later processing will add whatever is ! 9338: needed to get things working properly. ! 9339: ! 9340: If no device is specified, then the first directory name is taken to be ! 9341: a device name (or a rooted logical). */ ! 9342: ! 9343: /* See if we found that 1st slash */ ! 9344: if (cp == 0) return; /* Nothing to do!!! */ ! 9345: if (*cp != '/') return; /* Nothing to do!!! */ ! 9346: /* Point to the UNIX filename part (which needs to be fixed!) */ ! 9347: cp1 = cp+1; ! 9348: /* If the directory spec is not rooted, we can just copy ! 9349: the UNIX filename part and we are done */ ! 9350: if (((cp - fname) > 1) && ((cp[-1] == ']') || (cp[-1] == '>'))) { ! 9351: if (cp[-2] != '.') { ! 9352: /* ! 9353: * The VMS part ends in a `]', and the preceding character is not a `.'. ! 9354: * We strip the `]', and then splice the two parts of the name in the ! 9355: * usual way. Given the default locations for include files in cccp.c, ! 9356: * we will only use this code if the user specifies alternate locations ! 9357: * with the /include (-I) switch on the command line. */ ! 9358: cp -= 1; /* Strip "]" */ ! 9359: cp1--; /* backspace */ ! 9360: } else { ! 9361: /* ! 9362: * The VMS part has a ".]" at the end, and this will not do. Later ! 9363: * processing will add a second directory spec, and this would be a syntax ! 9364: * error. Thus we strip the ".]", and thus merge the directory specs. ! 9365: * We also backspace cp1, so that it points to a '/'. This inhibits the ! 9366: * generation of the 000000 root directory spec (which does not belong here ! 9367: * in this case). ! 9368: */ ! 9369: cp -= 2; /* Strip ".]" */ ! 9370: cp1--; }; /* backspace */ ! 9371: } else { ! 9372: ! 9373: /* We drop in here if there is no VMS style directory specification yet. ! 9374: * If there is no device specification either, we make the first dir a ! 9375: * device and try that. If we do not do this, then we will be essentially ! 9376: * searching the users default directory (as if they did a #include "asdf.h"). ! 9377: * ! 9378: * Then all we need to do is to push a '[' into the output string. Later ! 9379: * processing will fill this in, and close the bracket. ! 9380: */ ! 9381: if (cp[-1] != ':') *cp2++ = ':'; /* dev not in spec. take first dir */ ! 9382: *cp2++ = '['; /* Open the directory specification */ ! 9383: } ! 9384: ! 9385: /* at this point we assume that we have the device spec, and (at least ! 9386: the opening "[" for a directory specification. We may have directories ! 9387: specified already */ ! 9388: ! 9389: /* If there are no other slashes then the filename will be ! 9390: in the "root" directory. Otherwise, we need to add ! 9391: directory specifications. */ ! 9392: if (index (cp1, '/') == 0) { ! 9393: /* Just add "000000]" as the directory string */ ! 9394: strcpy (cp2, "000000]"); ! 9395: cp2 += strlen (cp2); ! 9396: check_filename_before_returning = 1; /* we might need to fool with this later */ ! 9397: } else { ! 9398: /* As long as there are still subdirectories to add, do them. */ ! 9399: while (index (cp1, '/') != 0) { ! 9400: /* If this token is "." we can ignore it */ ! 9401: if ((cp1[0] == '.') && (cp1[1] == '/')) { ! 9402: cp1 += 2; ! 9403: continue; ! 9404: } ! 9405: /* Add a subdirectory spec. Do not duplicate "." */ ! 9406: if (cp2[-1] != '.' && cp2[-1] != '[' && cp2[-1] != '<') ! 9407: *cp2++ = '.'; ! 9408: /* If this is ".." then the spec becomes "-" */ ! 9409: if ((cp1[0] == '.') && (cp1[1] == '.') && (cp[2] == '/')) { ! 9410: /* Add "-" and skip the ".." */ ! 9411: *cp2++ = '-'; ! 9412: cp1 += 3; ! 9413: continue; ! 9414: } ! 9415: /* Copy the subdirectory */ ! 9416: while (*cp1 != '/') *cp2++= *cp1++; ! 9417: cp1++; /* Skip the "/" */ ! 9418: } ! 9419: /* Close the directory specification */ ! 9420: if (cp2[-1] == '.') /* no trailing periods */ ! 9421: cp2--; ! 9422: *cp2++ = ']'; ! 9423: } ! 9424: /* Now add the filename */ ! 9425: while (*cp1) *cp2++ = *cp1++; ! 9426: *cp2 = 0; ! 9427: /* Now append it to the original VMS spec. */ ! 9428: strcpy (cp, Local); ! 9429: ! 9430: /* If we put a [000000] in the filename, try to open it first. If this fails, ! 9431: remove the [000000], and return that name. This provides flexibility ! 9432: to the user in that they can use both rooted and non-rooted logical names ! 9433: to point to the location of the file. */ ! 9434: ! 9435: if (check_filename_before_returning && no_prefix_seen) { ! 9436: f = open (fname, O_RDONLY, 0666); ! 9437: if (f >= 0) { ! 9438: /* The file name is OK as it is, so return it as is. */ ! 9439: close (f); ! 9440: return; ! 9441: } ! 9442: /* The filename did not work. Try to remove the [000000] from the name, ! 9443: and return it. */ ! 9444: cp = index (fname, '['); ! 9445: cp2 = index (fname, ']') + 1; ! 9446: strcpy (cp, cp2); /* this gets rid of it */ ! 9447: } ! 9448: return; ! 9449: } ! 9450: #endif /* VMS */ ! 9451: ! 9452: #ifdef VMS ! 9453: ! 9454: /* These are the read/write replacement routines for ! 9455: VAX-11 "C". They make read/write behave enough ! 9456: like their UNIX counterparts that CCCP will work */ ! 9457: ! 9458: static int ! 9459: read (fd, buf, size) ! 9460: int fd; ! 9461: char *buf; ! 9462: int size; ! 9463: { ! 9464: #undef read /* Get back the REAL read routine */ ! 9465: register int i; ! 9466: register int total = 0; ! 9467: ! 9468: /* Read until the buffer is exhausted */ ! 9469: while (size > 0) { ! 9470: /* Limit each read to 32KB */ ! 9471: i = (size > (32*1024)) ? (32*1024) : size; ! 9472: i = read (fd, buf, i); ! 9473: if (i <= 0) { ! 9474: if (i == 0) return (total); ! 9475: return (i); ! 9476: } ! 9477: /* Account for this read */ ! 9478: total += i; ! 9479: buf += i; ! 9480: size -= i; ! 9481: } ! 9482: return (total); ! 9483: } ! 9484: ! 9485: static int ! 9486: write (fd, buf, size) ! 9487: int fd; ! 9488: char *buf; ! 9489: int size; ! 9490: { ! 9491: #undef write /* Get back the REAL write routine */ ! 9492: int i; ! 9493: int j; ! 9494: ! 9495: /* Limit individual writes to 32Kb */ ! 9496: i = size; ! 9497: while (i > 0) { ! 9498: j = (i > (32*1024)) ? (32*1024) : i; ! 9499: if (write (fd, buf, j) < 0) return (-1); ! 9500: /* Account for the data written */ ! 9501: buf += j; ! 9502: i -= j; ! 9503: } ! 9504: return (size); ! 9505: } ! 9506: ! 9507: /* The following wrapper functions supply additional arguments to the VMS ! 9508: I/O routines to optimize performance with file handling. The arguments ! 9509: are: ! 9510: "mbc=16" - Set multi-block count to 16 (use a 8192 byte buffer). ! 9511: "deq=64" - When extending the file, extend it in chunks of 32Kbytes. ! 9512: "fop=tef"- Truncate unused portions of file when closing file. ! 9513: "shr=nil"- Disallow file sharing while file is open. ! 9514: */ ! 9515: ! 9516: static FILE * ! 9517: freopen (fname, type, oldfile) ! 9518: char *fname; ! 9519: char *type; ! 9520: FILE *oldfile; ! 9521: { ! 9522: #undef freopen /* Get back the REAL fopen routine */ ! 9523: if (strcmp (type, "w") == 0) ! 9524: return freopen (fname, type, oldfile, "mbc=16", "deq=64", "fop=tef", "shr=nil"); ! 9525: return freopen (fname, type, oldfile, "mbc=16"); ! 9526: } ! 9527: ! 9528: static FILE * ! 9529: fopen (fname, type) ! 9530: char *fname; ! 9531: char *type; ! 9532: { ! 9533: #undef fopen /* Get back the REAL fopen routine */ ! 9534: if (strcmp (type, "w") == 0) ! 9535: return fopen (fname, type, "mbc=16", "deq=64", "fop=tef", "shr=nil"); ! 9536: return fopen (fname, type, "mbc=16"); ! 9537: } ! 9538: ! 9539: static int ! 9540: open (fname, flags, prot) ! 9541: char *fname; ! 9542: int flags; ! 9543: int prot; ! 9544: { ! 9545: #undef open /* Get back the REAL open routine */ ! 9546: return open (fname, flags, prot, "mbc=16", "deq=64", "fop=tef"); ! 9547: } ! 9548: ! 9549: /* Avoid run-time library bug, where copying M out of N+M characters with ! 9550: N >= 65535 results in VAXCRTL's strncat falling into an infinite loop. ! 9551: gcc-cpp exercises this particular bug. */ ! 9552: ! 9553: static char * ! 9554: strncat (dst, src, cnt) ! 9555: char *dst; ! 9556: const char *src; ! 9557: unsigned cnt; ! 9558: { ! 9559: register char *d = dst, *s = (char *) src; ! 9560: register int n = cnt; /* convert to _signed_ type */ ! 9561: ! 9562: while (*d) d++; /* advance to end */ ! 9563: while (--n >= 0) ! 9564: if (!(*d++ = *s++)) break; ! 9565: if (n < 0) *d = '\0'; ! 9566: return dst; ! 9567: } ! 9568: #endif /* VMS */ ! 9569: ! 9570: #ifdef NEXT_SEMANTICS ! 9571: ! 9572: /* Pre-C-Preprocessor to translate RTF (Rich Text Format) Level 0 ! 9573: to plain ASCII before normal preprocessing. This removes all font, color, ! 9574: and help links from the text, but leaves the actual contents unchanged. ! 9575: ! 9576: Using an extra pass through the buffer takes a little extra time, ! 9577: but Rich Source Code is rare and a separate, shared routine ! 9578: can be used. */ ! 9579: ! 9580: #define RTF_HEADER "{\\rtf0\\ansi" ! 9581: #define RTF_HEADER_LEN 11 ! 9582: ! 9583: static void ! 9584: buf_convert_rtf (buf) ! 9585: FILE_BUF *buf; ! 9586: { ! 9587: int asciiTextLen; ! 9588: ! 9589: if (buf->buf ! 9590: && buf->length > RTF_HEADER_LEN ! 9591: && !strncmp (buf->buf, RTF_HEADER, RTF_HEADER_LEN)) ! 9592: { ! 9593: const char * asciiText = rtf_to_ascii(buf->buf, buf->length, &asciiTextLen); ! 9594: if (asciiText) ! 9595: { ! 9596: /* FIXME: deallocate buf->buf */ ! 9597: buf->buf = buf->bufp = (char *) asciiText; ! 9598: buf->length = asciiTextLen; ! 9599: } ! 9600: } ! 9601: } ! 9602: ! 9603: ! 9604: /* Process rtf text. RTFTEXTLEN bytes are processed from ! 9605: RTFTEXTPTR. The output is ASCIITEXTLEN bytes in the same buffer. */ ! 9606: ! 9607: #define ASCII_TERMINATOR '\0' ! 9608: ! 9609: static const char * ! 9610: rtf_to_ascii (const char *rtfTextPtr, int rtfTextLen, int * asciiTextLen) ! 9611: { ! 9612: char * asciiTextBuf = (char *) xmalloc(rtfTextLen); ! 9613: char * asciiTextPtr = asciiTextBuf; ! 9614: const char *endRtfPtr = rtfTextPtr + rtfTextLen; ! 9615: ! 9616: if (!asciiTextBuf) ! 9617: return NULL; ! 9618: ! 9619: while ( rtfTextPtr != endRtfPtr ) { ! 9620: switch( *rtfTextPtr ) { ! 9621: case '\n': ! 9622: rtfTextPtr++; ! 9623: break; ! 9624: case '}': ! 9625: if ( *++rtfTextPtr == '\n' ) { ! 9626: rtfTextPtr++; ! 9627: if (*rtfTextPtr == '�') rtfTextPtr++; ! 9628: } ! 9629: break; ! 9630: case '{': ! 9631: if ( !strncmp( rtfTextPtr, "{\\stylesheet", 12 ) ! 9632: || !strncmp( rtfTextPtr, "{\\fonttbl", 9 ) ! 9633: || !strncmp( rtfTextPtr, "{\\colortbl", 10 ) ! 9634: || !strncmp( rtfTextPtr, "{\\NeXTHelp", 10 ) ! 9635: || !strncmp( rtfTextPtr, "{{\\NeXTHelp", 11 ) ) { ! 9636: int depth = 1; ! 9637: while ( depth > 0 ) { ! 9638: switch ( *++rtfTextPtr ) { ! 9639: case '{': depth++; break; ! 9640: case '}': depth--; break; ! 9641: } ! 9642: } ! 9643: } ! 9644: else ! 9645: rtfTextPtr++; ! 9646: break; ! 9647: case '\\': ! 9648: rtfTextPtr++; ! 9649: if (*rtfTextPtr == '{' ! 9650: || *rtfTextPtr == '}' ! 9651: || *rtfTextPtr == '\\' ! 9652: || *rtfTextPtr == '\n' ) { ! 9653: *asciiTextPtr++ = *rtfTextPtr++; ! 9654: } else if ( *rtfTextPtr == '\'' ) { ! 9655: int v1, v2, value; ! 9656: rtfTextPtr++; ! 9657: v1 = isdigit( *rtfTextPtr ) ? (*rtfTextPtr - '0') ! 9658: : ((*rtfTextPtr - 'a') + 10); ! 9659: rtfTextPtr++; ! 9660: v2 = isdigit( *rtfTextPtr ) ? (*rtfTextPtr - '0') ! 9661: : ((*rtfTextPtr - 'a') + 10); ! 9662: value = (v1 << 4) | (v2); ! 9663: *asciiTextPtr++ = value; ! 9664: rtfTextPtr++; ! 9665: } else { ! 9666: while ( isalpha( *rtfTextPtr ) ) rtfTextPtr++; ! 9667: if (*rtfTextPtr == '-') rtfTextPtr++; ! 9668: while ( isdigit( *rtfTextPtr ) ) rtfTextPtr++; ! 9669: if ( *rtfTextPtr == ' ' ) rtfTextPtr++; ! 9670: else while (*rtfTextPtr == ' ') rtfTextPtr++; ! 9671: } ! 9672: break; ! 9673: default: ! 9674: *asciiTextPtr++ = *rtfTextPtr++; ! 9675: } ! 9676: } ! 9677: *asciiTextPtr = ASCII_TERMINATOR; ! 9678: *asciiTextLen = (int)asciiTextPtr - (int)asciiTextBuf; ! 9679: return asciiTextBuf; ! 9680: } ! 9681: ! 9682: ! 9683: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.