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