![[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 [Research Unix] / researchv10dc / cmd / gcc|
Return to cccp.c CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 root 1: /* C Compatible Compiler Preprocessor (CCCP)
2: Copyright (C) 1986, 1987, Free Software Foundation, Inc.
3: Written by Paul Rubin, June 1986
4: Adapted to ANSI C, Richard Stallman, Jan 1987
5:
6: NO WARRANTY
7:
8: BECAUSE THIS PROGRAM IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
9: NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT
10: WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
11: RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE THIS PROGRAM "AS IS"
12: WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
13: BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
14: FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY
15: AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
16: DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
17: CORRECTION.
18:
19: IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
20: STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY
21: WHO MAY MODIFY AND REDISTRIBUTE THIS PROGRAM AS PERMITTED BELOW, BE
22: LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR
23: OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
24: USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR
25: DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR
26: A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) THIS
27: PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
28: DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY.
29:
30: GENERAL PUBLIC LICENSE TO COPY
31:
32: 1. You may copy and distribute verbatim copies of this source file
33: as you receive it, in any medium, provided that you conspicuously
34: and appropriately publish on each copy a valid copyright notice
35: "Copyright (C) 1987, Free Software Foundation"; and include
36: following the copyright notice a verbatim copy of the above disclaimer
37: of warranty and of this License. You may charge a distribution fee for the
38: physical act of transferring a copy.
39:
40: 2. You may modify your copy or copies of this source file or
41: any portion of it, and copy and distribute such modifications under
42: the terms of Paragraph 1 above, provided that you also do the following:
43:
44: a) cause the modified files to carry prominent notices stating
45: that you changed the files and the date of any change; and
46:
47: b) cause the whole of any work that you distribute or publish,
48: that in whole or in part contains or is a derivative of this
49: program or any part thereof, to be licensed at no charge to all
50: third parties on terms identical to those contained in this
51: License Agreement (except that you may choose to grant more extensive
52: warranty protection to some or all third parties, at your option).
53:
54: c) You may charge a distribution fee for the physical act of
55: transferring a copy, and you may at your option offer warranty
56: protection in exchange for a fee.
57:
58: Mere aggregation of another unrelated program with this program (or its
59: derivative) on a volume of a storage or distribution medium does not bring
60: the other program under the scope of these terms.
61:
62: 3. You may copy and distribute this program (or a portion or derivative
63: of it, under Paragraph 2) in object code or executable form under the terms
64: of Paragraphs 1 and 2 above provided that you also do one of the following:
65:
66: a) accompany it with the complete corresponding machine-readable
67: source code, which must be distributed under the terms of
68: Paragraphs 1 and 2 above; or,
69:
70: b) accompany it with a written offer, valid for at least three
71: years, to give any third party free (except for a nominal
72: shipping charge) a complete machine-readable copy of the
73: corresponding source code, to be distributed under the terms of
74: Paragraphs 1 and 2 above; or,
75:
76: c) accompany it with the information you received as to where the
77: corresponding source code may be obtained. (This alternative is
78: allowed only for noncommercial distribution and only if you
79: received the program in object code or executable form alone.)
80:
81: For an executable file, complete source code means all the source code for
82: all modules it contains; but, as a special exception, it need not include
83: source code for modules which are standard libraries that accompany the
84: operating system on which the executable file runs.
85:
86: 4. You may not copy, sublicense, distribute or transfer this program
87: except as expressly provided under this License Agreement. Any attempt
88: otherwise to copy, sublicense, distribute or transfer this program is void and
89: your rights to use the program under this License agreement shall be
90: automatically terminated. However, parties who have received computer
91: software programs from you with this License Agreement will not have
92: their licenses terminated so long as such parties remain in full compliance.
93:
94: 5. If you wish to incorporate parts of this program into other free
95: programs whose distribution conditions are different, write to the Free
96: Software Foundation at 675 Mass Ave, Cambridge, MA 02139. We have not yet
97: worked out a simple rule that can be stated here, but we will often permit
98: this. We will be guided by the two goals of preserving the free status of
99: all derivatives of our free software and of promoting the sharing and reuse of
100: software.
101:
102:
103: In other words, you are welcome to use, share and improve this program.
104: You are forbidden to forbid anyone else to use, share and improve
105: what you give them. Help stamp out software-hoarding! */
106:
107: typedef unsigned char U_CHAR;
108:
109: #ifdef EMACS
110: #define NO_SHORTNAMES
111: #include "../src/config.h"
112: #ifdef open
113: #undef open
114: #undef read
115: #undef write
116: #endif /* open */
117: #endif /* EMACS */
118:
119: #ifndef EMACS
120: #include "config.h"
121: #endif /* not EMACS */
122:
123: /* In case config.h defines these. */
124: #undef bcopy
125: #undef bzero
126: #undef bcmp
127:
128: #include <sys/types.h>
129: #include <sys/stat.h>
130: #include <ctype.h>
131: #include <stdio.h>
132:
133: #ifndef VMS
134: #include <sys/file.h>
135: #ifndef USG
136: #include <sys/time.h> /* for __DATE__ and __TIME__ */
137: #include <sys/resource.h>
138: #else
139: #define index strchr
140: #define rindex strrchr
141: #include <time.h>
142: #include <fcntl.h>
143: #endif /* USG */
144: #endif /* not VMS */
145:
146: /* VMS-specific definitions */
147: #ifdef VMS
148: #include <time.h>
149: #include <errno.h> /* This defines "errno" properly */
150: #include <perror.h> /* This defines sys_errlist/sys_nerr properly */
151: #define O_RDONLY 0 /* Open arg for Read/Only */
152: #define O_WRONLY 1 /* Open arg for Write/Only */
153: #define read(fd,buf,size) VAX11_C_read(fd,buf,size)
154: #define write(fd,buf,size) VAX11_C_write(fd,buf,size)
155: #ifdef __GNUC__
156: #define BSTRING /* VMS/GCC supplies the bstring routines */
157: #endif __GNUC__
158: #endif /* VMS */
159:
160: /* External declarations. */
161:
162: void bcopy (), bzero ();
163: int bcmp ();
164: extern char version_string[];
165:
166: /* Forward declarations. */
167:
168: int do_define (), do_line (), do_include (), do_undef (), do_error (),
169: do_pragma (), do_if (), do_xifdef (), do_else (),
170: do_elif (), do_endif (), do_sccs ();
171:
172: struct hashnode *install ();
173: struct hashnode *lookup ();
174:
175: char *xmalloc (), *xrealloc (), *xcalloc ();
176: void fatal (), pfatal_with_name (), perror_with_name ();
177:
178: int grow_outbuf ();
179: int handle_directive ();
180: void memory_full ();
181:
182: U_CHAR *macarg1 ();
183: char *macarg ();
184:
185: U_CHAR *skip_to_end_of_comment ();
186: U_CHAR *skip_quoted_string ();
187:
188: #ifndef FATAL_EXIT_CODE
189: #define FATAL_EXIT_CODE 33 /* gnu cc command understands this */
190: #endif
191:
192: #ifndef SUCCESS_EXIT_CODE
193: #define SUCCESS_EXIT_CODE 0 /* 0 means success on Unix. */
194: #endif
195:
196: /* Name under which this program was invoked. */
197:
198: char *progname;
199:
200: /* Current maximum length of directory names in the search path
201: for include files. (Altered as we get more of them.) */
202:
203: int max_include_len = sizeof("/usr/local/lib/gcc-include");
204:
205: /* Nonzero means copy comments into the output file. */
206:
207: int put_out_comments = 0;
208:
209: /* Nonzero means don't process the ANSI trigraph sequences. */
210:
211: int no_trigraphs = 0;
212:
213: /* Nonzero means print the names of included files rather than
214: the preprocessed output. 1 means just the #include "...",
215: 2 means #include <...> as well. */
216:
217: int print_deps = 0;
218:
219: /* Nonzero means don't output line number information. */
220:
221: int no_line_commands;
222:
223: /* Nonzero means inhibit output of the preprocessed text
224: and instead output the definitions of all user-defined macros
225: in a form suitable for use as input to cccp. */
226:
227: int dump_macros;
228:
229: /* Nonzero means give all the error messages the ANSI standard requires. */
230:
231: int pedantic;
232:
233: /* Nonzero means warn if slash-star appears in a comment. */
234:
235: int warn_comments;
236:
237: /* Nonzero means try to imitate old fashioned non-ANSI preprocessor. */
238:
239: int traditional;
240:
241: /* Nonzero causes output not to be done,
242: but directives such as #define that have side effects
243: are still obeyed. */
244:
245: int no_output;
246:
247: /* I/O buffer structure.
248: The `fname' field is nonzero for source files and #include files
249: and for the dummy text used for -D and -U.
250: It is zero for rescanning results of macro expansion
251: and for expanding macro arguments. */
252: #define INPUT_STACK_MAX 200
253: struct file_buf {
254: char *fname;
255: int lineno;
256: int length;
257: U_CHAR *buf;
258: U_CHAR *bufp;
259: /* Macro that this level is the expansion of.
260: Included so that we can reenable the macro
261: at the end of this level. */
262: struct hashnode *macro;
263: /* Value of if_stack at start of this file.
264: Used to prohibit unmatched #endif (etc) in an include file. */
265: struct if_stack *if_stack;
266: /* Object to be freed at end of input at this level. */
267: U_CHAR *free;
268: } instack[INPUT_STACK_MAX];
269:
270: /* Current nesting level of input sources.
271: `instack[indepth]' is the level currently being read. */
272: int indepth = -1;
273:
274: typedef struct file_buf FILE_BUF;
275:
276: /* The output buffer. Its LENGTH field is the amount of room allocated
277: for the buffer, not the number of chars actually present. To get
278: that, subtract outbuf.buf from outbuf.bufp. */
279:
280: #define OUTBUF_SIZE 10 /* initial size of output buffer */
281: FILE_BUF outbuf;
282:
283: /* Grow output buffer OBUF points at
284: so it can hold at least NEEDED more chars. */
285:
286: #define check_expand(OBUF, NEEDED) \
287: (((OBUF)->length - ((OBUF)->bufp - (OBUF)->buf) <= (NEEDED)) \
288: ? grow_outbuf ((OBUF), (NEEDED)) : 0)
289:
290: struct directory_stack
291: {
292: struct directory_stack *next;
293: char *fname;
294: };
295:
296: /* #include "file" looks in source file dir, then stack. */
297: /* #include <file> just looks in the stack. */
298: /* -I directories are added to the end, then the defaults are added. */
299: struct directory_stack include_defaults[] =
300: {
301: #ifndef VMS
302: #ifdef CPLUSPLUS
303: /* Pick up GNU C++ specific include files. */
304: { &include_defaults[1], "/usr/local/lib/g++-include" },
305: /* Borrow AT&T C++ head files, if available. */
306: { &include_defaults[2], "/usr/include/CC" },
307: /* Use GNU CC specific header files. */
308: { &include_defaults[3], "/usr/local/lib/gcc-include" },
309: #else
310: { &include_defaults[1], "/usr/local/lib/gcc-include" },
311: #endif
312: { 0, "/usr/include" }
313: #else
314: { &include_defaults[1], "GNU_CC_INCLUDE:" }, /* GNU includes */
315: { &include_defaults[2], "SYS$SYSROOT:[SYSLIB.]" }, /* VAX-11 "C" includes */
316: { 0, "" }, /* This makes normal VMS filespecs work OK */
317: #endif /* VMS */
318: };
319:
320: struct directory_stack *include = 0; /* First dir to search */
321: /* First dir to search for <file> */
322: struct directory_stack *first_bracket_include = 0;
323: struct directory_stack *last_include = 0; /* Last in chain */
324:
325: /* Structure allocated for every #define. For a simple replacement
326: such as
327: #define foo bar ,
328: nargs = -1, the `pattern' list is null, and the expansion is just
329: the replacement text. Nargs = 0 means a functionlike macro with no args,
330: e.g.,
331: #define getchar() getc (stdin) .
332: When there are args, the expansion is the replacement text with the
333: args squashed out, and the reflist is a list describing how to
334: build the output from the input: e.g., "3 chars, then the 1st arg,
335: then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
336: The chars here come from the expansion. Whatever is left of the
337: expansion after the last arg-occurrence is copied after that arg.
338: Note that the reflist can be arbitrarily long---
339: its length depends on the number of times the arguments appear in
340: the replacement text, not how many args there are. Example:
341: #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
342: pattern list
343: { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
344: where (x, y) means (nchars, argno). */
345:
346: typedef struct definition DEFINITION;
347: struct definition {
348: int nargs;
349: int length; /* length of expansion string */
350: U_CHAR *expansion;
351: struct reflist {
352: struct reflist *next;
353: char stringify; /* nonzero if this arg was preceded by a
354: # operator. */
355: char raw_before; /* Nonzero if a ## operator before arg. */
356: char raw_after; /* Nonzero if a ## operator after arg. */
357: int nchars; /* Number of literal chars to copy before
358: this arg occurrence. */
359: int argno; /* Number of arg to substitute (origin-0) */
360: } *pattern;
361: /* Names of macro args, concatenated in reverse order
362: with comma-space between them.
363: The only use of this is that we warn on redefinition
364: if this differs between the old and new definitions. */
365: U_CHAR *argnames;
366: };
367:
368: /* different kinds of things that can appear in the value field
369: of a hash node. Actually, this may be useless now. */
370: union hashval {
371: int ival;
372: char *cpval;
373: DEFINITION *defn;
374: };
375:
376:
377: /* The structure of a node in the hash table. The hash table
378: has entries for all tokens defined by #define commands (type T_MACRO),
379: plus some special tokens like __LINE__ (these each have their own
380: type, and the appropriate code is run when that type of node is seen.
381: It does not contain control words like "#define", which are recognized
382: by a separate piece of code. */
383:
384: /* different flavors of hash nodes --- also used in keyword table */
385: enum node_type {
386: T_DEFINE = 1, /* the `#define' keyword */
387: T_INCLUDE, /* the `#include' keyword */
388: T_IFDEF, /* the `#ifdef' keyword */
389: T_IFNDEF, /* the `#ifndef' keyword */
390: T_IF, /* the `#if' keyword */
391: T_ELSE, /* `#else' */
392: #if 0
393: /* cpp can pass #pragma through unchanged. */
394: T_PRAGMA, /* `#pragma' */
395: #endif
396: T_ELIF, /* `#else' */
397: T_UNDEF, /* `#undef' */
398: T_LINE, /* `#line' */
399: T_ERROR, /* `#error' */
400: T_ENDIF, /* `#endif' */
401: T_SCCS, /* `#sccs', used on system V. */
402: T_SPECLINE, /* special symbol `__LINE__' */
403: T_DATE, /* `__DATE__' */
404: T_FILE, /* `__FILE__' */
405: T_VERSION, /* `__VERSION__' */
406: T_TIME, /* `__TIME__' */
407: T_CONST, /* Constant value, used by `__STDC__' */
408: T_MACRO, /* macro defined by `#define' */
409: T_DISABLED, /* macro temporarily turned off for rescan */
410: T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
411: T_UNUSED /* Used for something not defined. */
412: };
413:
414: struct hashnode {
415: struct hashnode *next; /* double links for easy deletion */
416: struct hashnode *prev;
417: struct hashnode **bucket_hdr; /* also, a back pointer to this node's hash
418: chain is kept, in case the node is the head
419: of the chain and gets deleted. */
420: enum node_type type; /* type of special token */
421: int length; /* length of token, for quick comparison */
422: U_CHAR *name; /* the actual name */
423: union hashval value; /* pointer to expansion, or whatever */
424: };
425:
426: typedef struct hashnode HASHNODE;
427:
428: /* Some definitions for the hash table. The hash function MUST be
429: computed as shown in hashf () below. That is because the rescan
430: loop computes the hash value `on the fly' for most tokens,
431: in order to avoid the overhead of a lot of procedure calls to
432: the hashf () function. Hashf () only exists for the sake of
433: politeness, for use when speed isn't so important. */
434:
435: #define HASHSIZE 1403
436: HASHNODE *hashtab[HASHSIZE];
437: #define HASHSTEP(old, c) ((old << 2) + c)
438: #define MAKE_POS(v) (v & ~0x80000000) /* make number positive */
439:
440: /* Symbols to predefine. */
441:
442: #ifdef CPP_PREDEFINES
443: char *predefs = CPP_PREDEFINES;
444: #else
445: char *predefs = "";
446: #endif
447:
448: /* `struct directive' defines one #-directive, including how to handle it. */
449:
450: struct directive {
451: int length; /* Length of name */
452: int (*func)(); /* Function to handle directive */
453: char *name; /* Name of directive */
454: enum node_type type; /* Code which describes which directive. */
455: char angle_brackets; /* Nonzero => don't delete comments. */
456: };
457:
458: /* Here is the actual list of #-directives, most-often-used first. */
459:
460: struct directive directive_table[] = {
461: { 6, do_define, "define", T_DEFINE},
462: { 2, do_if, "if", T_IF},
463: { 5, do_xifdef, "ifdef", T_IFDEF},
464: { 6, do_xifdef, "ifndef", T_IFNDEF},
465: { 5, do_endif, "endif", T_ENDIF},
466: { 4, do_else, "else", T_ELSE},
467: { 4, do_elif, "elif", T_ELIF},
468: { 4, do_line, "line", T_LINE},
469: { 7, do_include, "include", T_INCLUDE, 1},
470: { 5, do_undef, "undef", T_UNDEF},
471: { 5, do_error, "error", T_ERROR},
472: #ifdef SCCS_DIRECTIVE
473: { 4, do_sccs, "sccs", T_SCCS},
474: #endif
475: #if 0
476: { 6, do_pragma, "pragma", T_PRAGMA},
477: #endif
478: { -1, 0, "", T_UNUSED},
479: };
480:
481: /* table to tell if char can be part of a C identifier. */
482: U_CHAR is_idchar[256];
483: /* table to tell if char can be first char of a c identifier. */
484: U_CHAR is_idstart[256];
485: /* table to tell if c is horizontal space. */
486: U_CHAR is_hor_space[256];
487: /* table to tell if c is horizontal or vertical space. */
488: U_CHAR is_space[256];
489:
490: #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
491: #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
492:
493: int errors = 0; /* Error counter for exit code */
494:
495: /* Nonzero if have already warned about use of `$'. */
496: int dollar_seen = 0;
497:
498: FILE_BUF expand_to_temp_buffer ();
499:
500: DEFINITION *collect_expansion ();
501:
502: /* Stack of conditionals currently in progress
503: (including both successful and failing conditionals). */
504:
505: struct if_stack {
506: struct if_stack *next; /* for chaining to the next stack frame */
507: char *fname; /* copied from input when frame is made */
508: int lineno; /* similarly */
509: int if_succeeded; /* true if a leg of this if-group
510: has been passed through rescan */
511: enum node_type type; /* type of last directive seen in this group */
512: };
513: typedef struct if_stack IF_STACK_FRAME;
514: IF_STACK_FRAME *if_stack = NULL;
515:
516: /* Buffer of -M output. */
517:
518: char *deps_buffer;
519:
520: /* Number of bytes allocated in above. */
521: int deps_allocated_size;
522:
523: /* Number of bytes used. */
524: int deps_size;
525:
526: /* Number of bytes since the last newline. */
527: int deps_column;
528:
529: /* Nonzero means -I- has been seen,
530: so don't look for #include "foo" the source-file directory. */
531: int ignore_srcdir;
532:
533: int
534: main (argc, argv)
535: int argc;
536: char **argv;
537: {
538: int st_mode;
539: long st_size;
540: char *in_fname, *out_fname;
541: int f, i;
542: FILE_BUF *fp;
543: char **pend_files = (char **) xmalloc (argc * sizeof (char *));
544: char **pend_defs = (char **) xmalloc (argc * sizeof (char *));
545: char **pend_undefs = (char **) xmalloc (argc * sizeof (char *));
546: int inhibit_predefs = 0;
547: int no_standard_includes = 0;
548:
549: #ifdef RLIMIT_STACK
550: /* Get rid of any avoidable limit on stack size. */
551: {
552: struct rlimit rlim;
553:
554: /* Set the stack limit huge so that alloca (particularly stringtab
555: * in dbxread.c) does not fail. */
556: getrlimit (RLIMIT_STACK, &rlim);
557: rlim.rlim_cur = rlim.rlim_max;
558: setrlimit (RLIMIT_STACK, &rlim);
559: }
560: #endif /* RLIMIT_STACK defined */
561:
562: progname = argv[0];
563: in_fname = NULL;
564: out_fname = NULL;
565: initialize_random_junk ();
566:
567: no_line_commands = 0;
568: no_trigraphs = 1;
569: dump_macros = 0;
570: no_output = 0;
571:
572: bzero (pend_files, argc * sizeof (char *));
573: bzero (pend_defs, argc * sizeof (char *));
574: bzero (pend_undefs, argc * sizeof (char *));
575:
576: /* Process switches and find input file name. */
577:
578: for (i = 1; i < argc; i++) {
579: if (argv[i][0] != '-') {
580: if (out_fname != NULL)
581: fatal ("Usage: %s [switches] input output\n", argv[0]);
582: else if (in_fname != NULL) {
583: out_fname = argv[i];
584: if (! freopen (out_fname, "w", stdout))
585: pfatal_with_name (out_fname);
586: } else
587: in_fname = argv[i];
588: } else {
589: switch (argv[i][1]) {
590:
591: case 'i':
592: if (argv[i][2] != 0)
593: pend_files[i] = argv[i] + 2;
594: else
595: pend_files[i] = argv[i+1], i++;
596: break;
597:
598: case 'o':
599: if (out_fname != NULL)
600: fatal ("Output filename specified twice\n");
601: out_fname = argv[++i];
602: if (! freopen (out_fname, "w", stdout))
603: pfatal_with_name (out_fname);
604: break;
605:
606: case 'p':
607: pedantic = 1;
608: break;
609:
610: case 't':
611: traditional = 1;
612: break;
613:
614: case 'W':
615: warn_comments = 1;
616: break;
617:
618: case 'M':
619: if (!strcmp (argv[i], "-M"))
620: print_deps = 2;
621: else if (!strcmp (argv[i], "-MM"))
622: print_deps = 1;
623: deps_allocated_size = 200;
624: deps_buffer = (char *) xmalloc (deps_allocated_size);
625: deps_buffer[0] = 0;
626: deps_size = 0;
627: deps_column = 0;
628:
629: break;
630:
631: case 'd':
632: dump_macros = 1;
633: no_output = 1;
634: break;
635:
636: case 'v':
637: {
638: fprintf (stderr, "GNU CPP version %s\n", version_string);
639: }
640: break;
641:
642: case 'D':
643: {
644: char *p, *p1;
645:
646: if (argv[i][2] != 0)
647: p = argv[i] + 2;
648: else
649: p = argv[++i];
650:
651: if ((p1 = (char *) index (p, '=')) != NULL)
652: *p1 = ' ';
653: pend_defs[i] = p;
654: }
655: break;
656:
657: case 'U': /* JF #undef something */
658: if (argv[i][2] != 0)
659: pend_undefs[i] = argv[i] + 2;
660: else
661: pend_undefs[i] = argv[i+1], i++;
662: break;
663:
664: case 'C':
665: put_out_comments = 1;
666: break;
667:
668: case 'E': /* -E comes from cc -E; ignore it. */
669: break;
670:
671: case 'P':
672: no_line_commands = 1;
673: break;
674:
675: case 'T': /* Enable ANSI trigraphs */
676: no_trigraphs = 0;
677: break;
678:
679: case 'I': /* Add directory to path for includes. */
680: {
681: struct directory_stack *dirtmp;
682:
683: if (! ignore_srcdir && !strcmp (argv[i] + 2, "-"))
684: ignore_srcdir;
685: else {
686: dirtmp = (struct directory_stack *)
687: xmalloc (sizeof (struct directory_stack));
688: dirtmp->next = 0; /* New one goes on the end */
689: if (include == 0)
690: include = dirtmp;
691: else
692: last_include->next = dirtmp;
693: last_include = dirtmp; /* Tail follows the last one */
694: if (argv[i][2] != 0)
695: dirtmp->fname = argv[i] + 2;
696: else
697: dirtmp->fname = argv[++i];
698: if (strlen (dirtmp->fname) > max_include_len)
699: max_include_len = strlen (dirtmp->fname);
700: if (ignore_srcdir && first_bracket_include == 0)
701: first_bracket_include = dirtmp;
702: }
703: }
704: break;
705:
706: case 'n':
707: /* -nostdinc causes no default include directories.
708: You must specify all include-file directories with -I. */
709: no_standard_includes = 1;
710: break;
711:
712: case 'u':
713: /* Sun compiler passes undocumented switch "-undef".
714: Let's assume it means to inhibit the predefined symbols. */
715: inhibit_predefs = 1;
716: break;
717:
718: case '\0': /* JF handle '-' as file name meaning stdin or stdout */
719: if (in_fname == NULL) {
720: in_fname = "";
721: break;
722: } else if (out_fname == NULL) {
723: out_fname = "stdout";
724: break;
725: } /* else fall through into error */
726:
727: default:
728: fatal ("Invalid option `%s'\n", argv[i]);
729: }
730: }
731: }
732:
733: /* Do standard #defines that identify processor type. */
734:
735: if (!inhibit_predefs) {
736: char *p = (char *) alloca (strlen (predefs) + 1);
737: strcpy (p, predefs);
738: while (*p) {
739: char *q;
740: if (p[0] != '-' || p[1] != 'D')
741: abort ();
742: q = &p[2];
743: while (*p && *p != ' ') p++;
744: if (*p != 0)
745: *p++= 0;
746: make_definition (q);
747: }
748: }
749:
750: /* Do defines specified with -D. */
751: for (i = 1; i < argc; i++)
752: if (pend_defs[i])
753: make_definition (pend_defs[i]);
754:
755: /* Do undefines specified with -U. */
756: for (i = 1; i < argc; i++)
757: if (pend_undefs[i])
758: make_undef (pend_undefs[i]);
759:
760: /* Unless -fnostdinc,
761: tack on the standard include file dirs to the specified list */
762: if (!no_standard_includes) {
763: if (include == 0)
764: include = include_defaults;
765: else
766: last_include->next = include_defaults;
767: }
768:
769: /* Initialize output buffer */
770:
771: outbuf.buf = (U_CHAR *) xmalloc (OUTBUF_SIZE);
772: outbuf.bufp = outbuf.buf;
773: outbuf.length = OUTBUF_SIZE;
774:
775: /* Scan the -i files before the main input.
776: Much like #including them, but with no_output set
777: so that only their macro definitions matter. */
778:
779: no_output++;
780: for (i = 1; i < argc; i++)
781: if (pend_files[i]) {
782: int fd = open (pend_files[i], O_RDONLY, 0666);
783: if (fd < 0) {
784: perror_with_name (pend_files[i]);
785: return FATAL_EXIT_CODE;
786: }
787: finclude (fd, pend_files[i], &outbuf);
788: }
789: no_output--;
790:
791: /* Create an input stack level for the main input file
792: and copy the entire contents of the file into it. */
793:
794: fp = &instack[++indepth];
795:
796: /* JF check for stdin */
797: if (in_fname == NULL || *in_fname == 0) {
798: in_fname = "";
799: f = 0;
800: } else if ((f = open (in_fname, O_RDONLY)) < 0)
801: goto perror;
802:
803: /* For -M, print the expected object file name
804: as the target of this Make-rule. */
805: if (print_deps) {
806: if (*in_fname == 0)
807: deps_output ("-: ", 0);
808: else {
809: int len;
810: char *p = in_fname;
811: char *p1 = p;
812: /* Discard all directory prefixes from P. */
813: while (*p1)
814: {
815: if (*p1 == '/')
816: p = p1;
817: p1++;
818: }
819: /* Output P, but remove known suffixes. */
820: len = strlen (p);
821: if (p[len - 2] == '.' && p[len - 1] == 'c')
822: deps_output (p, len - 2);
823: else if (p[len - 3] == '.'
824: && p[len - 2] == 'c'
825: && p[len - 1] == 'c')
826: deps_output (p, len - 3);
827: else
828: deps_output (p, 0);
829: /* Supply our own suffix. */
830: deps_output (".o : ", 0);
831: deps_output (in_fname, 0);
832: deps_output (" ", 0);
833: }
834: }
835:
836: file_size_and_mode (f, &st_mode, &st_size);
837: fp->fname = in_fname;
838: fp->lineno = 1;
839: /* JF all this is mine about reading pipes and ttys */
840: if ((st_mode & S_IFMT) != S_IFREG) {
841: /* Read input from a file that is not a normal disk file.
842: We cannot preallocate a buffer with the correct size,
843: so we must read in the file a piece at the time and make it bigger. */
844: int size;
845: int bsize;
846: int cnt;
847: U_CHAR *bufp;
848:
849: bsize = 2000;
850: size = 0;
851: fp->buf = (U_CHAR *) xmalloc (bsize + 2);
852: bufp = fp->buf;
853: for (;;) {
854: cnt = read (f, bufp, bsize - size);
855: if (cnt < 0) goto perror; /* error! */
856: if (cnt == 0) break; /* End of file */
857: size += cnt;
858: bufp += cnt;
859: if (bsize == size) { /* Buffer is full! */
860: bsize *= 2;
861: fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
862: bufp = fp->buf + size; /* May have moved */
863: }
864: }
865: fp->length = size;
866: } else {
867: /* Read a file whose size we can determine in advance.
868: For the sake of VMS, st_size is just an upper bound. */
869: long i;
870: fp->length = 0;
871: fp->buf = (U_CHAR *) xmalloc (st_size + 2);
872:
873: while (st_size > 0) {
874: i = read (f, fp->buf + fp->length, st_size);
875: if (i <= 0) {
876: if (i == 0) break;
877: goto perror;
878: }
879: fp->length += i;
880: st_size -= i;
881: }
882: }
883: fp->bufp = fp->buf;
884: fp->if_stack = if_stack;
885:
886: /* Unless inhibited, convert trigraphs in the input. */
887:
888: if (!no_trigraphs)
889: trigraph_pcp (fp);
890:
891: /* Make sure data ends with a newline. And put a null after it. */
892:
893: if (fp->length > 0 && fp->buf[fp->length-1] != '\n')
894: fp->buf[fp->length++] = '\n';
895: fp->buf[fp->length] = '\0';
896:
897: output_line_command (fp, &outbuf, 0);
898:
899: /* Scan the input, processing macros and directives. */
900:
901: rescan (&outbuf, 0);
902:
903: /* Now we have processed the entire input
904: Write whichever kind of output has been requested. */
905:
906:
907: if (dump_macros)
908: dump_all_macros ();
909: else if (print_deps)
910: puts (deps_buffer);
911: else if (write (fileno (stdout), outbuf.buf, outbuf.bufp - outbuf.buf) < 0)
912: fatal ("I/O error on output");
913:
914: if (ferror (stdout))
915: fatal ("I/O error on output");
916:
917: if (errors)
918: exit (FATAL_EXIT_CODE);
919: exit (SUCCESS_EXIT_CODE);
920:
921: perror:
922: pfatal_with_name (in_fname);
923: }
924:
925: /* Pre-C-Preprocessor to translate ANSI trigraph idiocy in BUF
926: before main CCCP processing. Name `pcp' is also in honor of the
927: drugs the trigraph designers must have been on.
928:
929: Using an extra pass through the buffer takes a little extra time,
930: but is infinitely less hairy than trying to handle ??/" inside
931: strings, etc. everywhere, and also makes sure that trigraphs are
932: only translated in the top level of processing. */
933:
934: trigraph_pcp (buf)
935: FILE_BUF *buf;
936: {
937: register U_CHAR c, *fptr, *bptr, *sptr;
938: int len;
939:
940: fptr = bptr = sptr = buf->buf;
941: while ((sptr = (U_CHAR *) index (sptr, '?')) != NULL) {
942: if (*++sptr != '?')
943: continue;
944: switch (*++sptr) {
945: case '=':
946: c = '#';
947: break;
948: case '(':
949: c = '[';
950: break;
951: case '/':
952: c = '\\';
953: break;
954: case ')':
955: c = ']';
956: break;
957: case '\'':
958: c = '^';
959: break;
960: case '<':
961: c = '{';
962: break;
963: case '!':
964: c = '|';
965: break;
966: case '>':
967: c = '}';
968: break;
969: case '-':
970: c = '~';
971: break;
972: case '?':
973: sptr--;
974: continue;
975: default:
976: continue;
977: }
978: len = sptr - fptr - 2;
979: if (bptr != fptr && len > 0)
980: bcopy (fptr, bptr, len); /* BSD doc says bcopy () works right
981: for overlapping strings. In ANSI
982: C, this will be memmove (). */
983: bptr += len;
984: *bptr++ = c;
985: fptr = ++sptr;
986: }
987: len = buf->length - (fptr - buf->buf);
988: if (bptr != fptr && len > 0)
989: bcopy (fptr, bptr, len);
990: buf->length -= fptr - bptr;
991: buf->buf[buf->length] = '\0';
992: }
993:
994: /* Move all backslash-newline pairs out of embarrassing places.
995: Exchange all such pairs following BP
996: with any potentially-embarrasing characters that follow them.
997: Potentially-embarrassing characters are / and *
998: (because a backslash-newline inside a comment delimiter
999: would cause it not to be recognized). */
1000:
1001: newline_fix (bp)
1002: U_CHAR *bp;
1003: {
1004: register U_CHAR *p = bp;
1005: register int count = 0;
1006:
1007: /* First count the backslash-newline pairs here. */
1008:
1009: while (*p++ == '\\' && *p++ == '\n')
1010: count++;
1011:
1012: p = bp + count * 2;
1013:
1014: /* What follows the backslash-newlines is not embarrassing. */
1015:
1016: if (count == 0 || (*p != '/' && *p != '*'))
1017: return;
1018:
1019: /* Copy all potentially embarrassing characters
1020: that follow the backslash-newline pairs
1021: down to where the pairs originally started. */
1022:
1023: while (*p == '*' || *p == '/')
1024: *bp++ = *p++;
1025:
1026: /* Now write the same number of pairs after the embarrassing chars. */
1027: while (count-- > 0) {
1028: *bp++ = '\\';
1029: *bp++ = '\n';
1030: }
1031: }
1032:
1033: /* Like newline_fix but for use within a directive-name.
1034: Move any backslash-newlines up past any following symbol constituents. */
1035:
1036: name_newline_fix (bp)
1037: U_CHAR *bp;
1038: {
1039: register U_CHAR *p = bp;
1040: register int count = 0;
1041:
1042: /* First count the backslash-newline pairs here. */
1043:
1044: while (*p++ == '\\' && *p++ == '\n')
1045: count++;
1046:
1047: p = bp + count * 2;
1048:
1049: /* What follows the backslash-newlines is not embarrassing. */
1050:
1051: if (count == 0 || !is_idchar[*p])
1052: return;
1053:
1054: /* Copy all potentially embarrassing characters
1055: that follow the backslash-newline pairs
1056: down to where the pairs originally started. */
1057:
1058: while (is_idchar[*p])
1059: *bp++ = *p++;
1060:
1061: /* Now write the same number of pairs after the embarrassing chars. */
1062: while (count-- > 0) {
1063: *bp++ = '\\';
1064: *bp++ = '\n';
1065: }
1066: }
1067:
1068: /*
1069: * The main loop of the program.
1070: *
1071: * Read characters from the input stack, transferring them to the
1072: * output buffer OP.
1073: *
1074: * Macros are expanded and push levels on the input stack.
1075: * At the end of such a level it is popped off and we keep reading.
1076: * At the end of any other kind of level, we return.
1077: * #-directives are handled, except within macros.
1078: *
1079: * If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
1080: * and insert them when appropriate. This is set while scanning macro
1081: * arguments before substitution. It is zero when scanning for final output.
1082: * There are three types of Newline markers:
1083: * * Newline - follows a macro name that was not expanded
1084: * because it appeared inside an expansion of the same macro.
1085: * This marker prevents future expansion of that identifier.
1086: * When the input is rescanned into the final output, these are deleted.
1087: * These are also deleted by ## concatenation.
1088: * * Newline Space (or Newline and any other whitespace character)
1089: * stands for a place that tokens must be separated or whitespace
1090: * is otherwise desirable, but where the ANSI standard specifies there
1091: * is no whitespace. This marker turns into a Space (or whichever other
1092: * whitespace char appears in the marker) in the final output,
1093: * but it turns into nothing in an argument that is stringified with #.
1094: * Such stringified arguments are the only place where the ANSI standard
1095: * specifies with precision that whitespace may not appear.
1096: *
1097: * During this function, IP->bufp is kept cached in IBP for speed of access.
1098: * Likewise, OP->bufp is kept in OBP. Before calling a subroutine
1099: * IBP, IP and OBP must be copied back to memory. IP and IBP are
1100: * copied back with the RECACHE macro. OBP must be copied back from OP->bufp
1101: * explicitly, and before RECACHE, since RECACHE uses OBP.
1102: */
1103:
1104: rescan (op, output_marks)
1105: FILE_BUF *op;
1106: int output_marks;
1107: {
1108: /* Character being scanned in main loop. */
1109: register U_CHAR c;
1110:
1111: /* Length of pending accumulated identifier. */
1112: register int ident_length = 0;
1113:
1114: /* Hash code of pending accumulated identifier. */
1115: register int hash = 0;
1116:
1117: /* Current input level (&instack[indepth]). */
1118: FILE_BUF *ip;
1119:
1120: /* Pointer for scanning input. */
1121: register U_CHAR *ibp;
1122:
1123: /* Pointer to end of input. End of scan is controlled by LIMIT. */
1124: register U_CHAR *limit;
1125:
1126: /* Pointer for storing output. */
1127: register U_CHAR *obp;
1128:
1129: /* REDO_CHAR is nonzero if we are processing an identifier
1130: after backing up over the terminating character.
1131: Sometimes we process an identifier without backing up over
1132: the terminating character, if the terminating character
1133: is not special. Backing up is done so that the terminating character
1134: will be dispatched on again once the identifier is dealt with. */
1135: int redo_char = 0;
1136:
1137: /* 1 if within an identifier inside of which a concatenation
1138: marker (Newline -) has been seen. */
1139: int concatenated = 0;
1140:
1141: /* While scanning a comment or a string constant,
1142: this records the line it started on, for error messages. */
1143: int start_line;
1144:
1145: /* Record position of last `real' newline. */
1146: U_CHAR *beg_of_line;
1147:
1148: /* Pop the innermost input stack level, assuming it is a macro expansion. */
1149:
1150: #define POPMACRO \
1151: do { ip->macro->type = T_MACRO; \
1152: if (ip->free) free (ip->free); \
1153: --indepth; } while (0)
1154:
1155: /* Reload `rescan's local variables that describe the current
1156: level of the input stack. */
1157:
1158: #define RECACHE \
1159: do { ip = &instack[indepth]; \
1160: ibp = ip->bufp; \
1161: limit = ip->buf + ip->length; \
1162: op->bufp = obp; \
1163: check_expand (op, limit - ibp); \
1164: beg_of_line = 0; \
1165: obp = op->bufp; } while (0)
1166:
1167: if (no_output && instack[indepth].fname != 0)
1168: skip_if_group (&instack[indepth], 1);
1169:
1170: obp = op->bufp;
1171: RECACHE;
1172: beg_of_line = ibp;
1173:
1174: /* Our caller must always put a null after the end of
1175: the input at each input stack level. */
1176: if (*limit != 0)
1177: abort ();
1178:
1179: while (1) {
1180: c = *ibp++;
1181: *obp++ = c;
1182:
1183: switch (c) {
1184: case '\\':
1185: if (ibp >= limit)
1186: break;
1187: if (*ibp == '\n') {
1188: /* Always merge lines ending with backslash-newline,
1189: even in middle of identifier. */
1190: ++ibp;
1191: ++ip->lineno;
1192: --obp; /* remove backslash from obuf */
1193: break;
1194: }
1195: /* Otherwise, backslash suppresses specialness of following char,
1196: so copy it here to prevent the switch from seeing it.
1197: But first get any pending identifier processed. */
1198: if (ident_length > 0)
1199: goto specialchar;
1200: *obp++ = *ibp++;
1201: break;
1202:
1203: case '#':
1204: /* If this is expanding a macro definition, don't recognize
1205: preprocessor directives. */
1206: if (ip->macro != 0)
1207: goto randomchar;
1208: if (ident_length)
1209: goto specialchar;
1210:
1211: /* # keyword: a # must be first nonblank char on the line */
1212: if (beg_of_line == 0)
1213: goto randomchar;
1214: {
1215: U_CHAR *bp;
1216:
1217: /* Scan from start of line, skipping whitespace, comments
1218: and backslash-newlines, and see if we reach this #.
1219: If not, this # is not special. */
1220: bp = beg_of_line;
1221: while (1) {
1222: if (is_hor_space[*bp])
1223: bp++;
1224: else if (*bp == '\\' && bp[1] == '\n')
1225: bp += 2;
1226: else if (*bp == '/' && bp[1] == '*') {
1227: bp += 2;
1228: while (!(*bp == '*' && bp[1] == '/'))
1229: bp++;
1230: bp += 2;
1231: }
1232: #ifdef CPLUSPLUS
1233: else if (*bp == '/' && bp[1] == '/') {
1234: bp += 2;
1235: while (*bp++ != '\n') ;
1236: }
1237: #endif
1238: else break;
1239: }
1240: if (bp + 1 != ibp)
1241: goto randomchar;
1242: }
1243:
1244: /* This # can start a directive. */
1245:
1246: --obp; /* Don't copy the '#' */
1247:
1248: ip->bufp = ibp;
1249: op->bufp = obp;
1250: if (! handle_directive (ip, op)) {
1251: /* Not a known directive: treat it as ordinary text.
1252: IP, OP, IBP, etc. have not been changed. */
1253: if (no_output && instack[indepth].fname) {
1254: /* If not generating expanded output,
1255: what we do with ordinary text is skip it.
1256: Discard everything until next # directive. */
1257: skip_if_group (&instack[indepth], 1);
1258: RECACHE;
1259: beg_of_line = ibp;
1260: break;
1261: }
1262: ++obp; /* Copy the '#' after all */
1263: goto randomchar;
1264: }
1265: /* A # directive has been successfully processed. */
1266: /* If not generating expanded output, ignore everything until
1267: next # directive. */
1268: if (no_output && instack[indepth].fname)
1269: skip_if_group (&instack[indepth], 1);
1270: obp = op->bufp;
1271: RECACHE;
1272: beg_of_line = ibp;
1273: break;
1274:
1275: case '\"': /* skip quoted string */
1276: case '\'':
1277: /* A single quoted string is treated like a double -- some
1278: programs (e.g., troff) are perverse this way */
1279:
1280: if (ident_length)
1281: goto specialchar;
1282:
1283: start_line = ip->lineno;
1284:
1285: /* Skip ahead to a matching quote. */
1286:
1287: while (1) {
1288: if (ibp >= limit)
1289: {
1290: error_with_line (line_for_error (start_line),
1291: "unterminated string constant");
1292: break;
1293: }
1294: *obp++ = *ibp;
1295: switch (*ibp++) {
1296: case '\n':
1297: ++ip->lineno;
1298: ++op->lineno;
1299: break;
1300:
1301: case '\\':
1302: if (ibp >= limit)
1303: break;
1304: if (*ibp == '\n')
1305: {
1306: /* Backslash newline is replaced by nothing at all,
1307: but keep the line counts correct. */
1308: --obp;
1309: ++ibp;
1310: ++ip->lineno;
1311: }
1312: else {
1313: /* ANSI stupidly requires that in \\ the second \
1314: is *not* prevented from combining with a newline. */
1315: while (*ibp == '\\' && ibp[1] == '\n') {
1316: ibp += 2;
1317: ++ip->lineno;
1318: }
1319: *obp++ = *ibp++;
1320: }
1321: break;
1322:
1323: case '\"':
1324: case '\'':
1325: if (ibp[-1] == c)
1326: goto while2end;
1327: break;
1328: }
1329: }
1330: while2end:
1331: break;
1332:
1333: case '/':
1334: if (*ibp == '\\' && ibp[1] == '\n')
1335: newline_fix (ibp);
1336: #ifdef CPLUSPLUS
1337: if (*ibp == '/')
1338: {
1339: /* C++ style comment... */
1340: start_line = ip->lineno;
1341:
1342: --ibp; /* Back over the slash */
1343: --obp;
1344:
1345: /* Comments are equivalent to spaces. */
1346: if (! put_out_comments)
1347: *obp++ = ' ';
1348: else {
1349: /* must fake up a comment here */
1350: *obp++ = '/';
1351: *obp++ = '/';
1352: }
1353: {
1354: U_CHAR *before_bp = ibp+2;
1355:
1356: while (ibp < limit) {
1357: if (*ibp++ == '\n') {
1358: ibp--;
1359: if (put_out_comments) {
1360: bcopy (before_bp, obp, ibp - before_bp);
1361: obp += ibp - before_bp;
1362: }
1363: break;
1364: }
1365: }
1366: break;
1367: }
1368: }
1369: #endif
1370: if (*ibp != '*')
1371: goto randomchar;
1372: if (ip->macro != 0)
1373: goto randomchar;
1374: if (ident_length)
1375: goto specialchar;
1376:
1377: /* We have a comment. Skip it, optionally copying it to output. */
1378:
1379: start_line = ip->lineno;
1380:
1381: ++ibp; /* Skip the star. */
1382:
1383: /* Comments are equivalent to spaces.
1384: Note that we already output the slash; we might not want it.
1385: For -traditional, a comment is equivalent to nothing. */
1386: if (! put_out_comments)
1387: {
1388: if (traditional)
1389: obp--;
1390: else
1391: obp[-1] = ' ';
1392: }
1393: else
1394: *obp++ = '*';
1395:
1396: {
1397: U_CHAR *before_bp = ibp;
1398:
1399: while (ibp < limit) {
1400: switch (*ibp++) {
1401: case '/':
1402: if (warn_comments && ibp < limit && *ibp == '*')
1403: warning("`/*' within comment");
1404: break;
1405: case '*':
1406: if (*ibp == '\\' && ibp[1] == '\n')
1407: newline_fix (ibp);
1408: if (ibp >= limit || *ibp == '/')
1409: goto comment_end;
1410: break;
1411: case '\n':
1412: ++ip->lineno;
1413: /* Copy the newline into the output buffer, in order to
1414: avoid the pain of a #line every time a multiline comment
1415: is seen. */
1416: if (!put_out_comments)
1417: *obp++ = '\n';
1418: ++op->lineno;
1419: }
1420: }
1421: comment_end:
1422:
1423: if (ibp >= limit)
1424: error_with_line (line_for_error (start_line),
1425: "unterminated comment");
1426: else {
1427: ibp++;
1428: if (put_out_comments) {
1429: bcopy (before_bp, obp, ibp - before_bp);
1430: obp += ibp - before_bp;
1431: }
1432: }
1433: }
1434: break;
1435:
1436: case '$':
1437: if (pedantic)
1438: {
1439: if (! dollar_seen)
1440: warning ("ANSI C forbids `$' in identifier (first use here)");
1441: dollar_seen = 1;
1442: }
1443: goto letter;
1444:
1445: case '0': case '1': case '2': case '3': case '4':
1446: case '5': case '6': case '7': case '8': case '9':
1447: /* If digit is not part of identifier, it starts a number,
1448: which means that following letters are not an identifier.
1449: "0x5" does not refer to an identifier "x5".
1450: So copy all alphanumerics that follow without accumulating
1451: as an identifier. Periods also, for sake of "3.e7". */
1452:
1453: if (ident_length == 0) {
1454: while (ibp < limit) {
1455: c = *ibp++;
1456: if (!isalnum (c) && c != '.') {
1457: --ibp;
1458: break;
1459: }
1460: *obp++ = c;
1461: }
1462: break;
1463: }
1464: /* fall through */
1465:
1466: case '_':
1467: case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
1468: case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
1469: case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
1470: case 's': case 't': case 'u': case 'v': case 'w': case 'x':
1471: case 'y': case 'z':
1472: case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
1473: case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
1474: case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
1475: case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
1476: case 'Y': case 'Z':
1477: letter:
1478: ident_length++;
1479: /* Compute step of hash function, to avoid a proc call on every token */
1480: hash = HASHSTEP (hash, c);
1481: break;
1482:
1483: case '\n':
1484: /* If reprocessing a macro expansion, newline is a special marker. */
1485: if (ip->macro != 0) {
1486: /* Newline White is a "funny space" to separate tokens that are
1487: supposed to be separate but without space between.
1488: Here While means any horizontal whitespace character.
1489: Newline - marks a recursive macro use that is not
1490: supposed to be expandable. */
1491:
1492: if (*ibp == '-') {
1493: /* Newline - inhibits expansion of preceding token.
1494: If expanding a macro arg, we keep the newline -.
1495: In final output, it is deleted. */
1496: if (! concatenated) {
1497: ident_length = 0;
1498: hash = 0;
1499: }
1500: ibp++;
1501: if (!output_marks) {
1502: obp--;
1503: } else {
1504: /* If expanding a macro arg, keep the newline -. */
1505: *obp++ = '-';
1506: }
1507: } else if (is_space[*ibp]) {
1508: /* Newline Space does not prevent expansion of preceding token
1509: so expand the preceding token and then come back. */
1510: if (ident_length > 0)
1511: goto specialchar;
1512:
1513: /* If generating final output, newline space makes a space. */
1514: if (!output_marks) {
1515: obp[-1] = *ibp++;
1516: /* And Newline Newline makes a newline, so count it. */
1517: if (obp[-1] == '\n')
1518: op->lineno++;
1519: } else {
1520: /* If expanding a macro arg, keep the newline space.
1521: If the arg gets stringified, newline space makes nothing. */
1522: *obp++ = *ibp++;
1523: }
1524: } else abort (); /* Newline followed by something random? */
1525: break;
1526: }
1527:
1528: /* If there is a pending identifier, handle it and come back here. */
1529: if (ident_length > 0)
1530: goto specialchar;
1531:
1532: beg_of_line = ibp;
1533:
1534: /* Update the line counts and output a #line if necessary. */
1535: ++ip->lineno;
1536: ++op->lineno;
1537: if (ip->lineno != op->lineno) {
1538: op->bufp = obp;
1539: output_line_command (ip, op, 1);
1540: check_expand (op, ip->length - (ip->bufp - ip->buf));
1541: obp = op->bufp;
1542: }
1543: break;
1544:
1545: /* Come here either after (1) a null character that is part of the input
1546: or (2) at the end of the input, because there is a null there. */
1547: case 0:
1548: if (ibp <= limit)
1549: /* Our input really contains a null character. */
1550: goto randomchar;
1551:
1552: /* At end of a macro-expansion level, pop it and read next level. */
1553: if (ip->macro != 0) {
1554: obp--;
1555: ibp--;
1556: POPMACRO;
1557: RECACHE;
1558: break;
1559: }
1560:
1561: /* If we don't have a pending identifier,
1562: return at end of input. */
1563: if (ident_length == 0)
1564: {
1565: obp--;
1566: ibp--;
1567: op->bufp = obp;
1568: ip->bufp = ibp;
1569: goto ending;
1570: }
1571:
1572: /* If we do have a pending identifier, just consider this null
1573: a special character and arrange to dispatch on it again.
1574: The second time, IDENT_LENGTH will be zero so we will return. */
1575:
1576: /* Fall through */
1577:
1578: specialchar:
1579:
1580: /* Handle the case of a character such as /, ', " or null
1581: seen following an identifier. Back over it so that
1582: after the identifier is processed the special char
1583: will be dispatched on again. */
1584:
1585: ibp--;
1586: obp--;
1587: redo_char = 1;
1588:
1589: default:
1590:
1591: randomchar:
1592:
1593: if (ident_length > 0) {
1594: register HASHNODE *hp;
1595:
1596: /* We have just seen an identifier end. If it's a macro, expand it.
1597:
1598: IDENT_LENGTH is the length of the identifier
1599: and HASH is its hash code.
1600:
1601: The identifier has already been copied to the output,
1602: so if it is a macro we must remove it.
1603:
1604: If REDO_CHAR is 0, the char that terminated the identifier
1605: has been skipped in the output and the input.
1606: OBP-IDENT_LENGTH-1 points to the identifier.
1607: If the identifier is a macro, we must back over the terminator.
1608:
1609: If REDO_CHAR is 1, the terminating char has already been
1610: backed over. OBP-IDENT_LENGTH points to the identifier. */
1611:
1612: for (hp = hashtab[MAKE_POS (hash) % HASHSIZE]; hp != NULL;
1613: hp = hp->next) {
1614:
1615: if (hp->length == ident_length) {
1616: U_CHAR *obufp_before_macroname;
1617: int op_lineno_before_macroname;
1618: register int i = ident_length;
1619: register U_CHAR *p = hp->name;
1620: register U_CHAR *q = obp - i;
1621: int disabled;
1622:
1623: if (! redo_char)
1624: q--;
1625:
1626: do { /* All this to avoid a strncmp () */
1627: if (*p++ != *q++)
1628: goto hashcollision;
1629: } while (--i);
1630:
1631: /* We found a use of a macro name.
1632: see if the context shows it is a macro call. */
1633:
1634: /* Back up over terminating character if not already done. */
1635: if (! redo_char)
1636: {
1637: ibp--;
1638: obp--;
1639: }
1640:
1641: obufp_before_macroname = obp - ident_length;
1642: op_lineno_before_macroname = op->lineno;
1643:
1644: /* Record whether the macro is disabled. */
1645: disabled = hp->type == T_DISABLED;
1646:
1647: /* This looks like a macro ref, but if the macro was disabled,
1648: just copy its name and put in a marker if requested. */
1649:
1650: if (disabled)
1651: {
1652: if (output_marks) {
1653: check_expand (op, limit - ibp + 2);
1654: *obp++ = '\n';
1655: *obp++ = '-';
1656: }
1657: break;
1658: }
1659:
1660: /* If macro wants an arglist, verify that a '(' follows.
1661: first skip all whitespace, copying it to the output
1662: after the macro name. Then, if there is no '(',
1663: decide this is not a macro call and leave things that way. */
1664: if ((hp->type == T_MACRO || hp->type == T_DISABLED)
1665: && hp->value.defn->nargs >= 0)
1666: {
1667: while (1) {
1668: /* Scan forward over whitespace, copying it to the output. */
1669: if (ibp == limit && ip->macro != 0) {
1670: POPMACRO;
1671: RECACHE;
1672: }
1673: else if (is_space[*ibp]) {
1674: *obp++ = *ibp++;
1675: if (ibp[-1] == '\n')
1676: {
1677: if (ip->macro == 0) {
1678: /* Newline in a file. Count it. */
1679: ++ip->lineno;
1680: ++op->lineno;
1681: } else if (!output_marks) {
1682: /* A newline mark, and we don't want marks
1683: in the output. If it is newline-hyphen,
1684: discard it entirely. Otherwise, it is
1685: newline-whitechar, so keep the whitechar. */
1686: obp--;
1687: if (*ibp == '-')
1688: ibp++;
1689: else {
1690: if (*ibp == '\n')
1691: ++op->lineno;
1692: *obp++ = *ibp++;
1693: }
1694: } else {
1695: /* A newline mark; copy both chars to the output. */
1696: *obp++ = *ibp++;
1697: }
1698: }
1699: }
1700: else break;
1701: }
1702: if (*ibp != '(')
1703: break;
1704: }
1705:
1706: /* This is now known to be a macro call.
1707: Discard the macro name from the output,
1708: along with any following whitespace just copied. */
1709: obp = obufp_before_macroname;
1710: op->lineno = op_lineno_before_macroname;
1711:
1712: /* Expand the macro, reading arguments as needed,
1713: and push the expansion on the input stack. */
1714: ip->bufp = ibp;
1715: op->bufp = obp;
1716: macroexpand (hp, op);
1717:
1718: /* Reexamine input stack, since macroexpand has pushed
1719: a new level on it. */
1720: obp = op->bufp;
1721: RECACHE;
1722: break;
1723: }
1724: hashcollision:
1725: ;
1726: } /* End hash-table-search loop */
1727: ident_length = hash = 0; /* Stop collecting identifier */
1728: redo_char = 0;
1729: concatenated = 0;
1730: } /* End if (ident_length > 0) */
1731: } /* End switch */
1732: } /* End per-char loop */
1733:
1734: /* Come here to return -- but first give an error message
1735: if there was an unterminated successful conditional. */
1736: ending:
1737: if (if_stack != ip->if_stack) {
1738: char *str;
1739: switch (if_stack->type) {
1740: case T_IF:
1741: str = "if";
1742: break;
1743: case T_IFDEF:
1744: str = "ifdef";
1745: break;
1746: case T_IFNDEF:
1747: str = "ifndef";
1748: break;
1749: case T_ELSE:
1750: str = "else";
1751: break;
1752: case T_ELIF:
1753: str = "elif";
1754: break;
1755: }
1756: error_with_line (line_for_error (if_stack->lineno),
1757: "unterminated #%s conditional", str);
1758: }
1759: if_stack = ip->if_stack;
1760: }
1761:
1762: /*
1763: * Rescan a string into a temporary buffer and return the result
1764: * as a FILE_BUF. Note this function returns a struct, not a pointer.
1765: *
1766: * OUTPUT_MARKS nonzero means keep Newline markers found in the input
1767: * and insert such markers when appropriate. See `rescan' for details.
1768: * OUTPUT_MARKS is 1 for macroexpanding a macro argument separately
1769: * before substitution; it is 0 for other uses.
1770: */
1771: static FILE_BUF
1772: expand_to_temp_buffer (buf, limit, output_marks)
1773: U_CHAR *buf, *limit;
1774: int output_marks;
1775: {
1776: register FILE_BUF *ip;
1777: FILE_BUF obuf;
1778: int length = limit - buf;
1779: U_CHAR *buf1;
1780: int odepth = indepth;
1781:
1782: if (length < 0)
1783: abort ();
1784:
1785: /* Set up the input on the input stack. */
1786:
1787: buf1 = (U_CHAR *) alloca (length + 1);
1788: {
1789: register U_CHAR *p1 = buf;
1790: register U_CHAR *p2 = buf1;
1791:
1792: while (p1 != limit)
1793: *p2++ = *p1++;
1794: }
1795: buf1[length] = 0;
1796:
1797: ++indepth;
1798:
1799: ip = &instack[indepth];
1800: ip->fname = 0;
1801: ip->macro = 0;
1802: ip->free = 0;
1803: ip->length = length;
1804: ip->buf = ip->bufp = buf1;
1805: ip->if_stack = if_stack;
1806:
1807: /* Set up to receive the output. */
1808:
1809: obuf.length = length * 2 + 100; /* Usually enough. Why be stingy? */
1810: obuf.bufp = obuf.buf = (U_CHAR *) xmalloc (obuf.length);
1811: obuf.fname = 0;
1812: obuf.macro = 0;
1813: obuf.free = 0;
1814:
1815: ip->lineno = obuf.lineno = 1;
1816:
1817: /* Scan the input, create the output. */
1818:
1819: rescan (&obuf, output_marks);
1820:
1821: /* Pop input stack to original state. */
1822: --indepth;
1823:
1824: if (indepth != odepth)
1825: abort ();
1826:
1827: /* Record the output. */
1828: obuf.length = obuf.bufp - obuf.buf;
1829:
1830: return obuf;
1831: }
1832:
1833: /*
1834: * Process a # directive. Expects IP->bufp to point to the '#', as in
1835: * `#define foo bar'. Passes to the command handler
1836: * (do_define, do_include, etc.): the addresses of the 1st and
1837: * last chars of the command (starting immediately after the #
1838: * keyword), plus op and the keyword table pointer. If the command
1839: * contains comments it is copied into a temporary buffer sans comments
1840: * and the temporary buffer is passed to the command handler instead.
1841: * Likewise for backslash-newlines.
1842: *
1843: * Returns nonzero if this was a known # directive.
1844: * Otherwise, returns zero, without advancing the input pointer.
1845: */
1846:
1847: int
1848: handle_directive (ip, op)
1849: FILE_BUF *ip, *op;
1850: {
1851: register U_CHAR *bp, *cp;
1852: register struct directive *kt;
1853: register int ident_length;
1854: U_CHAR *resume_p;
1855:
1856: /* Nonzero means we must copy the entire command
1857: to get rid of comments or backslash-newlines. */
1858: int copy_command = 0;
1859:
1860: U_CHAR *ident, *after_ident;
1861:
1862: bp = ip->bufp;
1863: /* Skip whitespace and \-newline. */
1864: while (1) {
1865: if (is_hor_space[*bp])
1866: bp++;
1867: else if (*bp == '\\' && bp[1] == '\n') {
1868: bp += 2; ip->lineno++;
1869: } else break;
1870: }
1871:
1872: /* Now find end of directive name.
1873: If we encounter a backslash-newline, exchange it with any following
1874: symbol-constituents so that we end up with a contiguous name. */
1875:
1876: cp = bp;
1877: while (1) {
1878: if (is_idchar[*cp])
1879: cp++;
1880: else {
1881: if (*cp == '\\' && cp[1] == '\n')
1882: name_newline_fix (cp);
1883: if (is_idchar[*cp])
1884: cp++;
1885: else break;
1886: }
1887: }
1888: ident_length = cp - bp;
1889: ident = bp;
1890: after_ident = cp;
1891:
1892: /*
1893: * Decode the keyword and call the appropriate expansion
1894: * routine, after moving the input pointer up to the next line.
1895: */
1896: for (kt = directive_table; kt->length > 0; kt++) {
1897: if (kt->length == ident_length && !strncmp (kt->name, ident, ident_length)) {
1898: register U_CHAR *buf;
1899: register U_CHAR *limit = ip->buf + ip->length;
1900: int unterminated = 0;
1901:
1902: /* Find the end of this command (first newline not backslashed
1903: and not in a string or comment).
1904: Set COPY_COMMAND if the command must be copied
1905: (it contains a backslash-newline or a comment). */
1906:
1907: buf = bp = after_ident;
1908: while (bp < limit) {
1909: register U_CHAR c = *bp++;
1910: switch (c) {
1911: case '\\':
1912: if (bp < limit) {
1913: if (*bp == '\n')
1914: {
1915: ip->lineno++;
1916: copy_command = 1;
1917: }
1918: bp++;
1919: }
1920: break;
1921:
1922: case '\'':
1923: case '\"':
1924: bp = skip_quoted_string (bp - 1, limit, ip->lineno, &ip->lineno, ©_command, &unterminated);
1925: /* Don't bother calling the directive if we already got an error
1926: message due to unterminated string. Skip everything and pretend
1927: we called the directive. */
1928: if (unterminated) {
1929: ip->bufp = bp;
1930: return 1;
1931: }
1932: break;
1933:
1934: /* <...> is special for #include. */
1935: case '<':
1936: if (!kt->angle_brackets)
1937: break;
1938: while (*bp && *bp != '>') bp++;
1939: break;
1940:
1941: case '/':
1942: if (*bp == '\\' && bp[1] == '\n')
1943: newline_fix (bp);
1944: if (*bp == '*'
1945: #ifdef CPLUSPLUS
1946: || *bp == '/'
1947: #endif
1948: ) {
1949: U_CHAR *obp = bp - 1;
1950: ip->bufp = bp + 1;
1951: skip_to_end_of_comment (ip, &ip->lineno);
1952: bp = ip->bufp;
1953: /* No need to copy the command because of a comment at the end;
1954: just don't include the comment in the directive. */
1955: if (bp == limit || *bp == '\n') {
1956: bp = obp;
1957: goto endloop1;
1958: }
1959: copy_command++;
1960: }
1961: break;
1962:
1963: case '\n':
1964: --bp; /* Point to the newline */
1965: ip->bufp = bp;
1966: goto endloop1;
1967: }
1968: }
1969: ip->bufp = bp;
1970:
1971: endloop1:
1972: resume_p = ip->bufp;
1973: /* BP is the end of the directive.
1974: RESUME_P is the next interesting data after the directive.
1975: A comment may come between. */
1976:
1977: if (copy_command) {
1978: register U_CHAR *xp = buf;
1979: /* Need to copy entire command into temp buffer before dispatching */
1980:
1981: cp = (U_CHAR *) alloca (bp - buf + 5); /* room for cmd plus
1982: some slop */
1983: buf = cp;
1984:
1985: /* Copy to the new buffer, deleting comments
1986: and backslash-newlines (and whitespace surrounding the latter). */
1987:
1988: while (xp < bp) {
1989: register U_CHAR c = *xp++;
1990: *cp++ = c;
1991:
1992: switch (c) {
1993: case '\n':
1994: break;
1995:
1996: /* <...> is special for #include. */
1997: case '<':
1998: if (!kt->angle_brackets)
1999: break;
2000: while (*bp && *bp != '>') bp++;
2001: break;
2002:
2003: case '\\':
2004: if (*xp == '\n') {
2005: xp++;
2006: cp--;
2007: if (cp != buf && is_space[cp[-1]]) {
2008: while (cp != buf && is_space[cp[-1]]) cp--;
2009: cp++;
2010: SKIP_WHITE_SPACE (xp);
2011: } else if (is_space[*xp]) {
2012: *cp++ = *xp++;
2013: SKIP_WHITE_SPACE (xp);
2014: }
2015: }
2016: break;
2017:
2018: case '\'':
2019: case '\"':
2020: {
2021: register U_CHAR *bp1
2022: = skip_quoted_string (xp - 1, limit, ip->lineno, 0, 0, 0);
2023: while (xp != bp1)
2024: *cp++ = *xp++;
2025: }
2026: break;
2027:
2028: case '/':
2029: if (*xp == '*'
2030: #ifdef CPLUSPLUS
2031: || *xp == '/'
2032: #endif
2033: ) {
2034: if (traditional)
2035: cp--;
2036: else
2037: cp[-1] = ' ';
2038: ip->bufp = xp + 1;
2039: skip_to_end_of_comment (ip, 0);
2040: xp = ip->bufp;
2041: }
2042: }
2043: }
2044:
2045: /* Null-terminate the copy. */
2046:
2047: *cp = 0;
2048: }
2049: else
2050: cp = bp;
2051:
2052: ip->bufp = resume_p;
2053:
2054: /* Call the appropriate command handler. buf now points to
2055: either the appropriate place in the input buffer, or to
2056: the temp buffer if it was necessary to make one. cp
2057: points to the first char after the contents of the (possibly
2058: copied) command, in either case. */
2059: (*kt->func) (buf, cp, op, kt);
2060: check_expand (op, ip->length - (ip->bufp - ip->buf));
2061:
2062: return 1;
2063: }
2064: }
2065:
2066: return 0;
2067: }
2068:
2069: static char *monthnames[] = {"jan", "feb", "mar", "apr", "may", "jun",
2070: "jul", "aug", "sep", "oct", "nov", "dec",
2071: };
2072:
2073: /*
2074: * expand things like __FILE__. Place the expansion into the output
2075: * buffer *without* rescanning.
2076: */
2077: special_symbol (hp, op)
2078: HASHNODE *hp;
2079: FILE_BUF *op;
2080: {
2081: char *buf;
2082: int i, len;
2083: FILE_BUF *ip = NULL;
2084: static struct tm *timebuf = NULL;
2085: struct tm *localtime ();
2086:
2087: int paren = 0; /* For special `defined' keyword */
2088:
2089: for (i = indepth; i >= 0; i--)
2090: if (instack[i].fname != NULL) {
2091: ip = &instack[i];
2092: break;
2093: }
2094: if (ip == NULL) {
2095: error ("cccp error: not in any file?!");
2096: return; /* the show must go on */
2097: }
2098:
2099: switch (hp->type) {
2100: case T_FILE:
2101: buf = (char *) alloca (3 + strlen (ip->fname));
2102: sprintf (buf, "\"%s\"", ip->fname);
2103: break;
2104:
2105: case T_VERSION:
2106: buf = (char *) alloca (3 + strlen (version_string));
2107: sprintf (buf, "\"%s\"", version_string);
2108: break;
2109:
2110: case T_CONST:
2111: buf = (char *) alloca (4 * sizeof (int));
2112: sprintf (buf, "%d", hp->value.ival);
2113: break;
2114:
2115: case T_SPECLINE:
2116: buf = (char *) alloca (10);
2117: sprintf (buf, "%d", ip->lineno);
2118: break;
2119:
2120: case T_DATE:
2121: case T_TIME:
2122: if (timebuf == NULL) {
2123: i = time (0);
2124: timebuf = localtime (&i);
2125: }
2126: buf = (char *) alloca (20);
2127: if (hp->type == T_DATE)
2128: sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
2129: timebuf->tm_mday, timebuf->tm_year + 1900);
2130: else
2131: sprintf (buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
2132: timebuf->tm_sec);
2133: break;
2134:
2135: case T_SPEC_DEFINED:
2136: buf = " 0 "; /* Assume symbol is not defined */
2137: ip = &instack[indepth];
2138: SKIP_WHITE_SPACE (ip->bufp);
2139: if (*ip->bufp == '(') {
2140: paren++;
2141: ip->bufp++; /* Skip over the paren */
2142: SKIP_WHITE_SPACE (ip->bufp);
2143: }
2144:
2145: if (!is_idstart[*ip->bufp])
2146: goto oops;
2147: if (lookup (ip->bufp, -1, -1))
2148: buf = " 1 ";
2149: while (is_idchar[*ip->bufp])
2150: ++ip->bufp;
2151: SKIP_WHITE_SPACE (ip->bufp);
2152: if (paren) {
2153: if (*ip->bufp != ')')
2154: goto oops;
2155: ++ip->bufp;
2156: }
2157: break;
2158:
2159: oops:
2160:
2161: error ("`defined' must be followed by ident or (ident)");
2162: break;
2163:
2164: default:
2165: error ("cccp error: invalid special hash type"); /* time for gdb */
2166: abort ();
2167: }
2168: len = strlen (buf);
2169: check_expand (op, len);
2170: bcopy (buf, op->bufp, len);
2171: op->bufp += len;
2172:
2173: return;
2174: }
2175:
2176:
2177: /* Routines to handle #directives */
2178:
2179: /*
2180: * Process include file by reading it in and calling rescan.
2181: * Expects to see "fname" or <fname> on the input.
2182: */
2183:
2184: do_include (buf, limit, op, keyword)
2185: U_CHAR *buf, *limit;
2186: FILE_BUF *op;
2187: struct directive *keyword;
2188: {
2189: char *fname; /* Dynamically allocated fname buffer */
2190: U_CHAR *fbeg, *fend; /* Beginning and end of fname */
2191:
2192: struct directory_stack *stackp = include; /* Chain of dirs to search */
2193: struct directory_stack dsp[1]; /* First in chain, if #include "..." */
2194: int flen;
2195:
2196: int f; /* file number */
2197:
2198: int retried = 0; /* Have already tried macro
2199: expanding the include line*/
2200: FILE_BUF trybuf; /* It got expanded into here */
2201: int system_header_p = 0; /* 0 for "...", 1 for <...> */
2202:
2203: f= -1; /* JF we iz paranoid! */
2204:
2205: get_filename:
2206:
2207: fbeg = buf;
2208: SKIP_WHITE_SPACE (fbeg);
2209: /* Discard trailing whitespace so we can easily see
2210: if we have parsed all the significant chars we were given. */
2211: while (limit != fbeg && is_hor_space[limit[-1]]) limit--;
2212:
2213: switch (*fbeg++) {
2214: case '\"':
2215: fend = fbeg;
2216: while (fend != limit && *fend != '\"')
2217: fend++;
2218: if (*fend == '\"' && fend + 1 == limit) {
2219: FILE_BUF *fp;
2220:
2221: /* We have "filename". Figure out directory this source
2222: file is coming from and put it on the front of the list. */
2223:
2224: /* If -I- was specified, don't search current dir, only spec'd ones. */
2225: if (ignore_srcdir) break;
2226:
2227: for (fp = &instack[indepth]; fp >= instack; fp--)
2228: {
2229: int n;
2230: char *ep,*nam;
2231: extern char *rindex ();
2232:
2233: if ((nam = fp->fname) != NULL)
2234: {
2235: /* Found a named file. Figure out dir of the file,
2236: and put it in front of the search list. */
2237: dsp[0].next = stackp;
2238: stackp = dsp;
2239: #ifndef VMS
2240: ep = rindex (nam, '/');
2241: #else /* VMS */
2242: ep = rindex (nam, ']');
2243: if (ep == NULL) ep = rindex (nam, '>');
2244: if (ep == NULL) ep = rindex (nam, ':');
2245: if (ep != NULL) ep++;
2246: #endif /* VMS */
2247: if (ep != NULL) {
2248: n = ep - nam;
2249: dsp[0].fname = (char *) alloca (n + 1);
2250: strncpy (dsp[0].fname, nam, n);
2251: dsp[0].fname[n] = '\0';
2252: if (n > max_include_len) max_include_len = n;
2253: } else {
2254: dsp[0].fname = 0; /* Current directory */
2255: }
2256: break;
2257: }
2258: }
2259: break;
2260: }
2261: goto fail;
2262:
2263: case '<':
2264: fend = fbeg;
2265: while (fend != limit && *fend != '>') fend++;
2266: if (*fend == '>' && fend + 1 == limit) {
2267: system_header_p = 1;
2268: /* If -I-, start with the first -I dir after the -I-. */
2269: if (first_bracket_include)
2270: stackp = first_bracket_include;
2271: break;
2272: }
2273: goto fail;
2274:
2275: default:
2276: fail:
2277: if (retried) {
2278: error ("#include expects \"fname\" or <fname>");
2279: return;
2280: } else {
2281: trybuf = expand_to_temp_buffer (buf, limit, 0);
2282: buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
2283: bcopy (trybuf.buf, buf, trybuf.bufp - trybuf.buf);
2284: limit = buf + (trybuf.bufp - trybuf.buf);
2285: free (trybuf.buf);
2286: retried++;
2287: goto get_filename;
2288: }
2289: }
2290:
2291: flen = fend - fbeg;
2292: fname = (char *) alloca (max_include_len + flen + 2);
2293: /* + 2 above for slash and terminating null. */
2294:
2295: /* If specified file name is absolute, just open it. */
2296:
2297: if (*fbeg == '/') {
2298: strncpy (fname, fbeg, flen);
2299: fname[flen] = 0;
2300: f = open (fname, O_RDONLY);
2301: } else {
2302: /* Search directory path, trying to open the file.
2303: Copy each filename tried into FNAME. */
2304:
2305: for (; stackp; stackp = stackp->next) {
2306: if (stackp->fname) {
2307: strcpy (fname, stackp->fname);
2308: strcat (fname, "/");
2309: fname[strlen (fname) + flen] = 0;
2310: } else {
2311: fname[0] = 0;
2312: }
2313: strncat (fname, fbeg, flen);
2314: #ifdef VMS
2315: /* Change this 1/2 Unix 1/2 VMS file specification into a
2316: full VMS file specification */
2317: if (stackp->fname && (stackp->fname[0] != 0)) {
2318: /* Fix up the filename */
2319: hack_vms_include_specification (fname);
2320: } else {
2321: /* This is a normal VMS filespec, so use it unchanged. */
2322: strncpy (fname, fbeg, flen);
2323: fname[flen] = 0;
2324: }
2325: #endif /* VMS */
2326: if ((f = open (fname, O_RDONLY)) >= 0)
2327: break;
2328: }
2329: }
2330:
2331: /* For -M, print the name of the included file. */
2332: if (print_deps > system_header_p)
2333: {
2334: deps_output (fname, strlen (fname));
2335: deps_output (" ", 0);
2336: }
2337:
2338: if (f < 0) {
2339: strncpy (fname, fbeg, flen);
2340: fname[flen] = 0;
2341: error ("can't find include file `%s'", fname);
2342: } else {
2343: finclude (f, fname, op);
2344: close (f);
2345: }
2346: }
2347:
2348: /* Process the contents of include file FNAME, already open on descriptor F,
2349: with output to OP. */
2350:
2351: finclude (f, fname, op)
2352: int f;
2353: char *fname;
2354: FILE_BUF *op;
2355: {
2356: long st_size;
2357: long i;
2358: FILE_BUF *fp; /* For input stack frame */
2359: int success = 0;
2360:
2361: if (file_size_and_mode (f, (int *)0, &st_size) < 0)
2362: goto nope; /* Impossible? */
2363:
2364: fp = &instack[indepth + 1];
2365: bzero (fp, sizeof (FILE_BUF));
2366: fp->buf = (U_CHAR *) alloca (st_size + 2);
2367: fp->fname = fname;
2368: fp->length = 0;
2369: fp->lineno = 1;
2370: fp->bufp = fp->buf;
2371: fp->if_stack = if_stack;
2372:
2373: /* Read the file contents, knowing that st_size is an upper bound
2374: on the number of bytes we can read. */
2375: while (st_size > 0) {
2376: i = read (f, fp->buf + fp->length, st_size);
2377: if (i <= 0) {
2378: if (i == 0) break;
2379: goto nope;
2380: }
2381: fp->length += i;
2382: st_size -= i;
2383: }
2384:
2385: if (!no_trigraphs)
2386: trigraph_pcp (fp);
2387:
2388: if (fp->length > 0 && fp->buf[fp->length-1] != '\n')
2389: fp->buf[fp->length++] = '\n';
2390: fp->buf[fp->length] = '\0';
2391:
2392: success = 1;
2393: indepth++;
2394:
2395: output_line_command (fp, op, 0);
2396: rescan (op, 0);
2397: indepth--;
2398: output_line_command (&instack[indepth], op, 0);
2399:
2400: nope:
2401:
2402: close (f);
2403: if (!success) {
2404: perror_with_name (fname);
2405: }
2406: }
2407:
2408: /* The arglist structure is built by do_define to tell
2409: collect_definition where the argument names begin. That
2410: is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
2411: would contain pointers to the strings x, y, and z.
2412: Collect_definition would then build a DEFINITION node,
2413: with reflist nodes pointing to the places x, y, and z had
2414: appeared. So the arglist is just convenience data passed
2415: between these two routines. It is not kept around after
2416: the current #define has been processed and entered into the
2417: hash table. */
2418:
2419: struct arglist {
2420: struct arglist *next;
2421: U_CHAR *name;
2422: int length;
2423: int argno;
2424: };
2425:
2426: /* Process a #define command.
2427: BUF points to the contents of the #define command, as a continguous string.
2428: LIMIT points to the first character past the end of the definition.
2429: KEYWORD is the keyword-table entry for #define. */
2430:
2431: do_define (buf, limit, op, keyword)
2432: U_CHAR *buf, *limit;
2433: FILE_BUF *op;
2434: struct directive *keyword;
2435: {
2436: U_CHAR *bp; /* temp ptr into input buffer */
2437: U_CHAR *symname; /* remember where symbol name starts */
2438: int sym_length; /* and how long it is */
2439:
2440: DEFINITION *defn;
2441: int arglengths = 0; /* Accumulate lengths of arg names
2442: plus number of args. */
2443: int hashcode;
2444:
2445: bp = buf;
2446:
2447: while (is_hor_space[*bp])
2448: bp++;
2449: if (!is_idstart[*bp])
2450: warning ("macro name starts with a digit");
2451:
2452: symname = bp; /* remember where it starts */
2453: while (is_idchar[*bp] && bp < limit) {
2454: if (*bp == '$' && pedantic) {
2455: if (! dollar_seen)
2456: warning ("ANSI C forbids `$' in identifier (first use here)");
2457: dollar_seen = 1;
2458: }
2459: bp++;
2460: }
2461: sym_length = bp - symname;
2462:
2463: /* lossage will occur if identifiers or control keywords are broken
2464: across lines using backslash. This is not the right place to take
2465: care of that. */
2466:
2467: if (*bp == '(') {
2468: struct arglist *arg_ptrs = NULL;
2469: int argno = 0;
2470:
2471: bp++; /* skip '(' */
2472: SKIP_WHITE_SPACE (bp);
2473:
2474: /* Loop over macro argument names. */
2475: while (*bp != ')') {
2476: struct arglist *temp;
2477:
2478: temp = (struct arglist *) alloca (sizeof (struct arglist));
2479: temp->name = bp;
2480: temp->next = arg_ptrs;
2481: temp->argno = argno++;
2482: arg_ptrs = temp;
2483:
2484: if (!is_idstart[*bp])
2485: warning ("parameter name starts with a digit in #define");
2486:
2487: /* Find the end of the arg name. */
2488: while (is_idchar[*bp]) {
2489: if (*bp == '$' && pedantic) {
2490: if (! dollar_seen)
2491: warning ("ANSI C forbids `$' in identifier (first use here)");
2492: dollar_seen = 1;
2493: }
2494: bp++;
2495: }
2496: temp->length = bp - temp->name;
2497: arglengths += temp->length + 2;
2498: SKIP_WHITE_SPACE (bp);
2499: if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
2500: error ("badly punctuated parameter list in #define");
2501: goto nope;
2502: }
2503: if (*bp == ',') {
2504: bp++;
2505: SKIP_WHITE_SPACE (bp);
2506: }
2507: if (bp >= limit) {
2508: error ("unterminated parameter list in #define");
2509: goto nope;
2510: }
2511: }
2512:
2513: ++bp; /* skip paren */
2514: /* Skip exactly one space or tab if any. */
2515: if (bp < limit && (*bp == ' ' || *bp == '\t')) ++bp;
2516: /* now everything from bp before limit is the definition. */
2517: defn = collect_expansion (bp, limit, argno, arg_ptrs);
2518:
2519: /* Now set defn->argnames to the result of concatenating
2520: the argument names in reverse order
2521: with comma-space between them. */
2522: defn->argnames = (U_CHAR *) xmalloc (arglengths + 1);
2523: {
2524: struct arglist *temp;
2525: int i = 0;
2526: for (temp = arg_ptrs; temp; temp = temp->next)
2527: {
2528: bcopy (temp->name, &defn->argnames[i], temp->length);
2529: i += temp->length;
2530: if (temp->next != 0) {
2531: defn->argnames[i++] = ',';
2532: defn->argnames[i++] = ' ';
2533: }
2534: }
2535: defn->argnames[i] = 0;
2536: }
2537: } else {
2538: /* simple expansion or empty definition; gobble it */
2539: if (is_hor_space[*bp])
2540: ++bp; /* skip exactly one blank/tab char */
2541: /* now everything from bp before limit is the definition. */
2542: defn = collect_expansion (bp, limit, -1, 0);
2543: defn->argnames = (U_CHAR *) "";
2544: }
2545:
2546: hashcode = hashf (symname, sym_length, HASHSIZE);
2547:
2548: {
2549: HASHNODE *hp;
2550: if ((hp = lookup (symname, sym_length, hashcode)) != NULL) {
2551: if (hp->type != T_MACRO
2552: || compare_defs (defn, hp->value.defn)) {
2553: U_CHAR *msg; /* what pain... */
2554: msg = (U_CHAR *) alloca (sym_length + 20);
2555: bcopy (symname, msg, sym_length);
2556: strcpy (msg + sym_length, " redefined");
2557: warning (msg);
2558: }
2559: /* Replace the old definition. */
2560: hp->type = T_MACRO;
2561: hp->value.defn = defn;
2562: } else
2563: install (symname, sym_length, T_MACRO, defn, hashcode);
2564: }
2565:
2566: return 0;
2567:
2568: nope:
2569:
2570: return 1;
2571: }
2572:
2573: /*
2574: * return zero if two DEFINITIONs are isomorphic
2575: */
2576: static
2577: compare_defs (d1, d2)
2578: DEFINITION *d1, *d2;
2579: {
2580: register struct reflist *a1, *a2;
2581: register U_CHAR *p1 = d1->expansion;
2582: register U_CHAR *p2 = d2->expansion;
2583: int first = 1;
2584:
2585: if (d1->nargs != d2->nargs)
2586: return 1;
2587: if (strcmp (d1->argnames, d2->argnames))
2588: return 1;
2589: for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
2590: a1 = a1->next, a2 = a2->next) {
2591: if (!((a1->nchars == a2->nchars && ! strncmp (p1, p2, a1->nchars))
2592: || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
2593: || a1->argno != a2->argno
2594: || a1->stringify != a2->stringify
2595: || a1->raw_before != a2->raw_before
2596: || a1->raw_after != a2->raw_after)
2597: return 1;
2598: first = 0;
2599: p1 += a1->nchars;
2600: p2 += a2->nchars;
2601: }
2602: if (a1 != a2)
2603: return 1;
2604: if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
2605: p2, d2->length - (p2 - d2->expansion), 1))
2606: return 1;
2607: return 0;
2608: }
2609:
2610: /* Return 1 if two parts of two macro definitions are effectively different.
2611: One of the parts starts at BEG1 and has LEN1 chars;
2612: the other has LEN2 chars at BEG2.
2613: Any sequence of whitespace matches any other sequence of whitespace.
2614: FIRST means these parts are the first of a macro definition;
2615: so ignore leading whitespace entirely.
2616: LAST means these parts are the last of a macro definition;
2617: so ignore trailing whitespace entirely. */
2618:
2619: comp_def_part (first, beg1, len1, beg2, len2, last)
2620: int first;
2621: U_CHAR *beg1, *beg2;
2622: int len1, len2;
2623: int last;
2624: {
2625: register U_CHAR *end1 = beg1 + len1;
2626: register U_CHAR *end2 = beg2 + len2;
2627: if (first) {
2628: while (beg1 != end1 && is_space[*beg1]) beg1++;
2629: while (beg2 != end2 && is_space[*beg2]) beg2++;
2630: }
2631: if (last) {
2632: while (beg1 != end1 && is_space[end1[-1]]) end1--;
2633: while (beg2 != end2 && is_space[end2[-1]]) end2--;
2634: }
2635: while (beg1 != end1 && beg2 != end2) {
2636: if (is_space[*beg1] && is_space[*beg2]) {
2637: while (beg1 != end1 && is_space[*beg1]) beg1++;
2638: while (beg2 != end2 && is_space[*beg2]) beg2++;
2639: } else if (*beg1 == *beg2) {
2640: beg1++; beg2++;
2641: } else break;
2642: }
2643: return (beg1 != end1) || (beg2 != end2);
2644: }
2645:
2646: /* Read a replacement list for a macro with parameters.
2647: Build the DEFINITION structure.
2648: Reads characters of text starting at BUF until LIMIT.
2649: ARGLIST specifies the formal parameters to look for
2650: in the text of the definition; NARGS is the number of args
2651: in that list, or -1 for a macro name that wants no argument list.
2652: MACRONAME is the macro name itself (so we can avoid recursive expansion)
2653: and NAMELEN is its length in characters.
2654:
2655: Note that comments and backslash-newlines have already been deleted
2656: from the argument. */
2657:
2658: /* Leading and trailing Space, Tab, etc. are converted to markers
2659: Newline Space, Newline Tab, etc.
2660: Newline Space makes a space in the final output
2661: but is discarded if stringified. (Newline Tab is similar but
2662: makes a Tab instead.)
2663:
2664: If there is no trailing whitespace, a Newline Space is added at the end
2665: to prevent concatenation that would be contrary to the standard. */
2666:
2667: static DEFINITION *
2668: collect_expansion (buf, end, nargs, arglist)
2669: U_CHAR *buf, *end;
2670: int nargs;
2671: struct arglist *arglist;
2672: {
2673: DEFINITION *defn;
2674: register U_CHAR *p, *limit, *lastp, *exp_p;
2675: struct reflist *endpat = NULL;
2676: /* Pointer to first nonspace after last ## seen. */
2677: U_CHAR *concat = 0;
2678: /* Pointer to first nonspace after last single-# seen. */
2679: U_CHAR *stringify = 0;
2680:
2681: /* Scan thru the replacement list, ignoring comments and quoted
2682: strings, picking up on the macro calls. It does a linear search
2683: thru the arg list on every potential symbol. Profiling might say
2684: that something smarter should happen. */
2685:
2686: if (end < buf)
2687: abort ();
2688:
2689: defn = (DEFINITION *) xcalloc (1, sizeof (DEFINITION) + 2 * (end - buf + 2));
2690:
2691: defn->nargs = nargs;
2692: exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
2693: lastp = exp_p;
2694:
2695: /* Speed this loop up later? */
2696:
2697: p = buf;
2698: limit = end;
2699:
2700: /* Find the beginning of the trailing whitespace. */
2701: while (p < limit && is_space[limit[-1]]) limit--;
2702:
2703: /* Convert leading whitespace to Newline-markers. */
2704: while (p < limit && is_space[*p]) {
2705: *exp_p++ = '\n';
2706: *exp_p++ = *p++;
2707: }
2708:
2709: /* Process the main body of the definition. */
2710: while (p < limit) {
2711: int skipped_arg = 0;
2712: register U_CHAR c = *p++;
2713:
2714: *exp_p++ = c;
2715:
2716: switch (c) {
2717: case '\'':
2718: case '\"':
2719: if (!traditional) {
2720: for (; p < limit && *p != c; p++) {
2721: *exp_p++ = *p;
2722: if (*p == '\\') {
2723: *exp_p++ = *++p;
2724: }
2725: }
2726: *exp_p++ = *p++;
2727: }
2728: break;
2729:
2730: /* Special hack: if a \# is written in the #define
2731: include a # in the definition. This is useless for C code
2732: but useful for preprocessing other things. */
2733:
2734: case '\\':
2735: if (p < limit && *p == '#') {
2736: /* Pass through this # */
2737: exp_p--;
2738: *exp_p++ = *p++;
2739: }
2740: break;
2741:
2742: case '#':
2743: if (p < limit && *p == '#') {
2744: /* ##: concatenate preceding and following tokens. */
2745: /* Take out the first #, discard preceding whitespace. */
2746: exp_p--;
2747: while (exp_p > lastp && is_hor_space[exp_p[-1]])
2748: --exp_p;
2749: /* Skip the second #. */
2750: p++;
2751: /* Discard following whitespace. */
2752: SKIP_WHITE_SPACE (p);
2753: concat = p;
2754: } else {
2755: /* Single #: stringify following argument ref.
2756: Don't leave the # in the expansion. */
2757: exp_p--;
2758: SKIP_WHITE_SPACE (p);
2759: if (p == limit || ! is_idstart[*p] || nargs <= 0)
2760: error ("# operator should be followed by a macro argument name\n");
2761: else
2762: stringify = p;
2763: }
2764: break;
2765: }
2766:
2767: if (is_idchar[c] && nargs > 0) {
2768: U_CHAR *id_beg = p - 1;
2769: int id_len;
2770:
2771: --exp_p;
2772: while (p != limit && is_idchar[*p]) p++;
2773: id_len = p - id_beg;
2774:
2775: if (is_idstart[c]) {
2776: register struct arglist *arg;
2777:
2778: for (arg = arglist; arg != NULL; arg = arg->next) {
2779: struct reflist *tpat;
2780:
2781: if (arg->name[0] == c
2782: && arg->length == id_len
2783: && strncmp (arg->name, id_beg, id_len) == 0) {
2784: /* make a pat node for this arg and append it to the end of
2785: the pat list */
2786: tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
2787: tpat->next = NULL;
2788: tpat->stringify = stringify == id_beg;
2789: tpat->raw_before = concat == id_beg;
2790: tpat->raw_after = 0;
2791:
2792: if (endpat == NULL)
2793: defn->pattern = tpat;
2794: else
2795: endpat->next = tpat;
2796: endpat = tpat;
2797:
2798: tpat->argno = arg->argno;
2799: tpat->nchars = exp_p - lastp;
2800: {
2801: register U_CHAR *p1 = p;
2802: SKIP_WHITE_SPACE (p1);
2803: if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
2804: tpat->raw_after = 1;
2805: }
2806: lastp = exp_p; /* place to start copying from next time */
2807: skipped_arg = 1;
2808: break;
2809: }
2810: }
2811: }
2812:
2813: /* If this was not a macro arg, copy it into the expansion. */
2814: if (! skipped_arg) {
2815: register U_CHAR *lim1 = p;
2816: p = id_beg;
2817: while (p != lim1)
2818: *exp_p++ = *p++;
2819: if (stringify == id_beg)
2820: error ("# operator should be followed by a macro argument name\n");
2821: }
2822: }
2823: }
2824:
2825: if (limit < end) {
2826: /* Convert trailing whitespace to Newline-markers. */
2827: while (limit < end && is_space[*limit]) {
2828: *exp_p++ = '\n';
2829: *exp_p++ = *limit++;
2830: }
2831: } else if (!traditional) {
2832: /* There is no trailing whitespace, so invent some. */
2833: *exp_p++ = '\n';
2834: *exp_p++ = ' ';
2835: }
2836:
2837: *exp_p = '\0';
2838:
2839: defn->length = exp_p - defn->expansion;
2840:
2841: #if 0
2842: /* This isn't worth the time it takes. */
2843: /* give back excess storage */
2844: defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
2845: #endif
2846:
2847: return defn;
2848: }
2849:
2850: #ifdef DEBUG
2851: /*
2852: * debugging routine ---- return a ptr to a string containing
2853: * first n chars of s. Returns a ptr to a static object
2854: * since I happen to know it will fit.
2855: */
2856: static U_CHAR *
2857: prefix (s, n)
2858: U_CHAR *s;
2859: int n;
2860: {
2861: static U_CHAR buf[1000];
2862: bcopy (s, buf, n);
2863: buf[n] = '\0'; /* this should not be necessary! */
2864: return buf;
2865: }
2866: #endif
2867:
2868: /*
2869: * interpret #line command. Remembers previously seen fnames
2870: * in its very own hash table.
2871: */
2872: #define FNAME_HASHSIZE 37
2873:
2874: do_line (buf, limit, op, keyword)
2875: U_CHAR *buf, *limit;
2876: FILE_BUF *op;
2877: struct directive *keyword;
2878: {
2879: register U_CHAR *bp;
2880: FILE_BUF *ip = &instack[indepth];
2881: FILE_BUF tem;
2882: int new_lineno;
2883:
2884: /* Expand any macros. */
2885: tem = expand_to_temp_buffer (buf, limit, 0);
2886:
2887: /* Point to macroexpanded line, which is null-terminated now. */
2888: bp = tem.buf;
2889: SKIP_WHITE_SPACE (bp);
2890:
2891: if (!isdigit (*bp)) {
2892: error ("invalid format #line command");
2893: return;
2894: }
2895:
2896: /* The Newline at the end of this line remains to be processed.
2897: To put the next line at the specified line number,
2898: we must store a line number now that is one less. */
2899: new_lineno = atoi (bp) - 1;
2900:
2901: /* skip over the line number. */
2902: while (isdigit (*bp))
2903: bp++;
2904: if (*bp && !is_space[*bp]) {
2905: error ("invalid format #line command");
2906: return;
2907: }
2908:
2909: SKIP_WHITE_SPACE (bp);
2910:
2911: if (*bp == '\"') {
2912: static HASHNODE *fname_table[FNAME_HASHSIZE];
2913: HASHNODE *hp, **hash_bucket;
2914: U_CHAR *fname;
2915: int fname_length;
2916:
2917: fname = ++bp;
2918:
2919: while (*bp && *bp != '\"')
2920: bp++;
2921: if (*bp != '\"') {
2922: error ("invalid format #line command");
2923: return;
2924: }
2925:
2926: fname_length = bp - fname;
2927:
2928: bp++;
2929: SKIP_WHITE_SPACE (bp);
2930: if (*bp) {
2931: error ("invalid format #line command");
2932: return;
2933: }
2934:
2935: hash_bucket =
2936: &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
2937: for (hp = *hash_bucket; hp != NULL; hp = hp->next)
2938: if (hp->length == fname_length &&
2939: strncmp (hp->value.cpval, fname, fname_length) == 0) {
2940: ip->fname = hp->value.cpval;
2941: break;
2942: }
2943: if (hp == 0) {
2944: /* Didn't find it; cons up a new one. */
2945: hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
2946: hp->next = *hash_bucket;
2947: *hash_bucket = hp;
2948:
2949: hp->length = fname_length;
2950: ip->fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
2951: bcopy (fname, hp->value.cpval, fname_length);
2952: }
2953: } else if (*bp) {
2954: error ("invalid format #line command");
2955: return;
2956: }
2957:
2958: ip->lineno = new_lineno;
2959: output_line_command (ip, op, 0);
2960: check_expand (op, ip->length - (ip->bufp - ip->buf));
2961: }
2962:
2963: /*
2964: * remove all definitions of symbol from symbol table.
2965: * according to un*x /lib/cpp, it is not an error to undef
2966: * something that has no definitions, so it isn't one here either.
2967: */
2968: do_undef (buf, limit, op, keyword)
2969: U_CHAR *buf, *limit;
2970: FILE_BUF *op;
2971: struct directive *keyword;
2972: {
2973: HASHNODE *hp;
2974:
2975: SKIP_WHITE_SPACE (buf);
2976:
2977: while ((hp = lookup (buf, -1, -1)) != NULL) {
2978: if (hp->type != T_MACRO)
2979: error ("undefining `%s'", hp->name);
2980: delete_macro (hp);
2981: }
2982: }
2983:
2984: /*
2985: * Report a fatal error detected by the program we are processing.
2986: * Use the text of the line in the error message, then terminate.
2987: * (We use error() because it prints the filename & line#.)
2988: */
2989: do_error (buf, limit, op, keyword)
2990: U_CHAR *buf, *limit;
2991: FILE_BUF *op;
2992: struct directive *keyword;
2993: {
2994: int length = limit - buf;
2995: char *copy = (char *) xmalloc (length + 1);
2996: bcopy (buf, copy, length);
2997: copy[length] = 0;
2998: SKIP_WHITE_SPACE (copy);
2999: error ("#error %s", copy);
3000: exit (FATAL_EXIT_CODE);
3001: }
3002:
3003: #if 0
3004: /* This was a fun hack, but #pragma seems to start to be useful.
3005: By failing to recognize it, we pass it through unchanged to cc1. */
3006:
3007: /*
3008: * the behavior of the #pragma directive is implementation defined.
3009: * this implementation defines it as follows.
3010: */
3011: do_pragma ()
3012: {
3013: close (0);
3014: if (open ("/dev/tty", O_RDONLY) != 0)
3015: goto nope;
3016: close (1);
3017: if (open ("/dev/tty", O_WRONLY) != 1)
3018: goto nope;
3019: execl ("/usr/games/hack", "#pragma", 0);
3020: execl ("/usr/games/rogue", "#pragma", 0);
3021: execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
3022: execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
3023: nope:
3024: fatal ("You are in a maze of twisty compiler features, all different");
3025: }
3026: #endif
3027:
3028: /* Just ignore #sccs, on systems where we define it at all. */
3029: do_sccs ()
3030: {}
3031:
3032: /*
3033: * handle #if command by
3034: * 1) inserting special `defined' keyword into the hash table
3035: * that gets turned into 0 or 1 by special_symbol (thus,
3036: * if the luser has a symbol called `defined' already, it won't
3037: * work inside the #if command)
3038: * 2) rescan the input into a temporary output buffer
3039: * 3) pass the output buffer to the yacc parser and collect a value
3040: * 4) clean up the mess left from steps 1 and 2.
3041: * 5) call conditional_skip to skip til the next #endif (etc.),
3042: * or not, depending on the value from step 3.
3043: */
3044:
3045: do_if (buf, limit, op, keyword)
3046: U_CHAR *buf, *limit;
3047: FILE_BUF *op;
3048: struct directive *keyword;
3049: {
3050: int value;
3051: FILE_BUF *ip = &instack[indepth];
3052:
3053: value = eval_if_expression (buf, limit - buf);
3054: conditional_skip (ip, value == 0, T_IF);
3055: }
3056:
3057: /*
3058: * handle a #elif directive by not changing if_stack either.
3059: * see the comment above do_else.
3060: */
3061:
3062: do_elif (buf, limit, op, keyword)
3063: U_CHAR *buf, *limit;
3064: FILE_BUF *op;
3065: struct directive *keyword;
3066: {
3067: int value;
3068: FILE_BUF *ip = &instack[indepth];
3069:
3070: if (if_stack == instack[indepth].if_stack) {
3071: error ("#elif not within a conditional");
3072: return;
3073: } else {
3074: if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
3075: error ("#elif after #else");
3076: fprintf (stderr, " (matches line %d", if_stack->lineno);
3077: if (if_stack->fname != NULL && ip->fname != NULL &&
3078: strcmp (if_stack->fname, ip->fname) != 0)
3079: fprintf (stderr, ", file %s", if_stack->fname);
3080: fprintf (stderr, ")\n");
3081: }
3082: if_stack->type = T_ELIF;
3083: }
3084:
3085: if (if_stack->if_succeeded)
3086: skip_if_group (ip, 0);
3087: else {
3088: value = eval_if_expression (buf, limit - buf);
3089: if (value == 0)
3090: skip_if_group (ip, 0);
3091: else {
3092: ++if_stack->if_succeeded; /* continue processing input */
3093: output_line_command (ip, op, 1);
3094: }
3095: }
3096: }
3097:
3098: /*
3099: * evaluate a #if expression in BUF, of length LENGTH,
3100: * then parse the result as a C expression and return the value as an int.
3101: */
3102: static int
3103: eval_if_expression (buf, length)
3104: U_CHAR *buf;
3105: int length;
3106: {
3107: FILE_BUF temp_obuf;
3108: HASHNODE *save_defined;
3109: int value;
3110:
3111: save_defined = install ("defined", -1, T_SPEC_DEFINED, 0, -1);
3112: temp_obuf = expand_to_temp_buffer (buf, buf + length, 0);
3113: delete_macro (save_defined); /* clean up special symbol */
3114:
3115: value = parse_c_expression (temp_obuf.buf);
3116:
3117: free (temp_obuf.buf);
3118:
3119: return value;
3120: }
3121:
3122: /*
3123: * routine to handle ifdef/ifndef. Try to look up the symbol,
3124: * then do or don't skip to the #endif/#else/#elif depending
3125: * on what directive is actually being processed.
3126: */
3127: do_xifdef (buf, limit, op, keyword)
3128: U_CHAR *buf, *limit;
3129: FILE_BUF *op;
3130: struct directive *keyword;
3131: {
3132: int skip;
3133: FILE_BUF *ip = &instack[indepth];
3134: U_CHAR *end;
3135:
3136: /* Discard leading and trailing whitespace. */
3137: SKIP_WHITE_SPACE (buf);
3138: while (limit != buf && is_hor_space[limit[-1]]) limit--;
3139:
3140: /* Find the end of the identifier at the beginning. */
3141: for (end = buf; is_idchar[*end]; end++);
3142:
3143: if (end == buf)
3144: {
3145: skip = (keyword->type == T_IFDEF);
3146: if (! traditional)
3147: warning (end == limit ? "#%s with no argument"
3148: : "#%s argument starts with punctuation",
3149: keyword->name);
3150: }
3151: else
3152: {
3153: if (pedantic && buf[0] >= '0' && buf[0] <= '9')
3154: warning ("#%s argument starts with a digit", keyword->name);
3155: else if (end != limit && !traditional)
3156: warning ("garbage at end of #%s argument", keyword->name);
3157:
3158: skip = (lookup (buf, end-buf, -1) == NULL) ^ (keyword->type == T_IFNDEF);
3159: }
3160:
3161: conditional_skip (ip, skip, T_IF);
3162: }
3163:
3164: /*
3165: * push TYPE on stack; then, if SKIP is nonzero, skip ahead.
3166: */
3167: static
3168: conditional_skip (ip, skip, type)
3169: FILE_BUF *ip;
3170: int skip;
3171: enum node_type type;
3172: {
3173: IF_STACK_FRAME *temp;
3174:
3175: temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
3176: temp->fname = ip->fname;
3177: temp->lineno = ip->lineno;
3178: temp->next = if_stack;
3179: if_stack = temp;
3180:
3181: if_stack->type = type;
3182:
3183: if (skip != 0) {
3184: skip_if_group (ip, 0);
3185: return;
3186: } else {
3187: ++if_stack->if_succeeded;
3188: output_line_command (ip, &outbuf, 1);
3189: }
3190: }
3191:
3192: /*
3193: * skip to #endif, #else, or #elif. adjust line numbers, etc.
3194: * leaves input ptr at the sharp sign found.
3195: * If ANY is nonzero, return at next directive of any sort.
3196: */
3197: static
3198: skip_if_group (ip, any)
3199: FILE_BUF *ip;
3200: int any;
3201: {
3202: register U_CHAR *bp = ip->bufp, *cp;
3203: register U_CHAR *endb = ip->buf + ip->length;
3204: struct directive *kt;
3205: IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
3206: U_CHAR *beg_of_line = bp;
3207:
3208: while (bp < endb) {
3209: switch (*bp++) {
3210: case '/': /* possible comment */
3211: if (*bp == '\\' && bp[1] == '\n')
3212: newline_fix (bp);
3213: if (*bp == '*'
3214: #ifdef CPLUSPLUS
3215: || *bp == '/'
3216: #endif
3217: ) {
3218: ip->bufp = ++bp;
3219: bp = skip_to_end_of_comment (ip, &ip->lineno);
3220: }
3221: break;
3222: case '\"':
3223: case '\'':
3224: if (!traditional)
3225: bp = skip_quoted_string (bp - 1, endb, ip->lineno, &ip->lineno, 0, 0);
3226: break;
3227: case '\n':
3228: ++ip->lineno;
3229: beg_of_line = bp;
3230: break;
3231: case '#':
3232: ip->bufp = bp - 1;
3233:
3234: /* # keyword: a # must be first nonblank char on the line */
3235: if (beg_of_line == 0)
3236: break;
3237: /* Scan from start of line, skipping whitespace, comments
3238: and backslash-newlines, and see if we reach this #.
3239: If not, this # is not special. */
3240: bp = beg_of_line;
3241: while (1) {
3242: if (is_hor_space[*bp])
3243: bp++;
3244: else if (*bp == '\\' && bp[1] == '\n')
3245: bp += 2;
3246: else if (*bp == '/' && bp[1] == '*') {
3247: bp += 2;
3248: while (!(*bp == '*' && bp[1] == '/'))
3249: bp++;
3250: bp += 2;
3251: }
3252: #ifdef CPLUSPLUS
3253: else if (*bp == '/' && bp[1] == '/') {
3254: bp += 2;
3255: while (*bp++ != '\n') ;
3256: }
3257: #endif
3258: else break;
3259: }
3260: if (bp != ip->bufp) {
3261: bp = ip->bufp + 1; /* Reset bp to after the #. */
3262: break;
3263: }
3264:
3265: bp = ip->bufp + 1; /* point at '#' */
3266:
3267: /* Skip whitespace and \-newline. */
3268: while (1) {
3269: if (is_hor_space[*bp])
3270: bp++;
3271: else if (*bp == '\\' && bp[1] == '\n')
3272: bp += 2;
3273: else break;
3274: }
3275:
3276: cp = bp;
3277:
3278: /* Now find end of directive name.
3279: If we encounter a backslash-newline, exchange it with any following
3280: symbol-constituents so that we end up with a contiguous name. */
3281:
3282: while (1) {
3283: if (is_idchar[*bp])
3284: bp++;
3285: else {
3286: if (*bp == '\\' && bp[1] == '\n')
3287: name_newline_fix (bp);
3288: if (is_idchar[*bp])
3289: bp++;
3290: else break;
3291: }
3292: }
3293:
3294: for (kt = directive_table; kt->length >= 0; kt++) {
3295: IF_STACK_FRAME *temp;
3296: if (strncmp (cp, kt->name, kt->length) == 0
3297: && !is_idchar[cp[kt->length]]) {
3298:
3299: /* If we are asked to return on next directive,
3300: do so now. */
3301: if (any)
3302: return;
3303:
3304: switch (kt->type) {
3305: case T_IF:
3306: case T_IFDEF:
3307: case T_IFNDEF:
3308: temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
3309: temp->next = if_stack;
3310: if_stack = temp;
3311: temp->lineno = ip->lineno;
3312: temp->fname = ip->fname;
3313: temp->type = kt->type;
3314: break;
3315: case T_ELSE:
3316: case T_ENDIF:
3317: if (pedantic && if_stack != save_if_stack)
3318: validate_else (bp);
3319: case T_ELIF:
3320: if (if_stack == instack[indepth].if_stack) {
3321: error ("#%s not within a conditional", kt->name);
3322: break;
3323: }
3324: else if (if_stack == save_if_stack)
3325: return; /* found what we came for */
3326:
3327: if (kt->type != T_ENDIF) {
3328: if (if_stack->type == T_ELSE)
3329: error ("#else or #elif after #else");
3330: if_stack->type = kt->type;
3331: break;
3332: }
3333:
3334: temp = if_stack;
3335: if_stack = if_stack->next;
3336: free (temp);
3337: break;
3338: }
3339: break;
3340: }
3341: }
3342: }
3343: }
3344: ip->bufp = bp;
3345: /* after this returns, rescan will exit because ip->bufp
3346: now points to the end of the buffer.
3347: rescan is responsible for the error message also. */
3348: }
3349:
3350: /*
3351: * handle a #else directive. Do this by just continuing processing
3352: * without changing if_stack ; this is so that the error message
3353: * for missing #endif's etc. will point to the original #if. It
3354: * is possible that something different would be better.
3355: */
3356: do_else (buf, limit, op, keyword)
3357: U_CHAR *buf, *limit;
3358: FILE_BUF *op;
3359: struct directive *keyword;
3360: {
3361: FILE_BUF *ip = &instack[indepth];
3362:
3363: if (pedantic) {
3364: SKIP_WHITE_SPACE (buf);
3365: if (buf != limit)
3366: warning ("text following #else violates ANSI standard");
3367: }
3368:
3369: if (if_stack == instack[indepth].if_stack) {
3370: error ("#else not within a conditional");
3371: return;
3372: } else {
3373: if (if_stack->type != T_IF && if_stack->type != T_ELIF) {
3374: error ("#else after #else");
3375: fprintf (stderr, " (matches line %d", if_stack->lineno);
3376: if (strcmp (if_stack->fname, ip->fname) != 0)
3377: fprintf (stderr, ", file %s", if_stack->fname);
3378: fprintf (stderr, ")\n");
3379: }
3380: if_stack->type = T_ELSE;
3381: }
3382:
3383: if (if_stack->if_succeeded)
3384: skip_if_group (ip, 0);
3385: else {
3386: ++if_stack->if_succeeded; /* continue processing input */
3387: output_line_command (ip, op, 1);
3388: }
3389: }
3390:
3391: /*
3392: * unstack after #endif command
3393: */
3394: do_endif (buf, limit, op, keyword)
3395: U_CHAR *buf, *limit;
3396: FILE_BUF *op;
3397: struct directive *keyword;
3398: {
3399: if (pedantic) {
3400: SKIP_WHITE_SPACE (buf);
3401: if (buf != limit)
3402: warning ("text following #endif violates ANSI standard");
3403: }
3404:
3405: if (if_stack == instack[indepth].if_stack)
3406: error ("unbalanced #endif");
3407: else {
3408: IF_STACK_FRAME *temp = if_stack;
3409: if_stack = if_stack->next;
3410: free (temp);
3411: output_line_command (&instack[indepth], op, 1);
3412: }
3413: }
3414:
3415: /* When an #else or #endif is found while skipping failed conditional,
3416: if -pedantic was specified, this is called to warn about text after
3417: the command name. P points to the first char after the command name. */
3418:
3419: validate_else (p)
3420: register U_CHAR *p;
3421: {
3422: /* Advance P over whitespace and comments. */
3423: while (1) {
3424: if (*p == '\\' && p[1] == '\n')
3425: p += 2;
3426: if (is_hor_space[*p])
3427: p++;
3428: else if (*p == '/') {
3429: if (p[1] == '\\' && p[2] == '\n')
3430: newline_fix (p + 1);
3431: if (p[1] == '*') {
3432: p += 2;
3433: /* Don't bother warning about unterminated comments
3434: since that will happen later. Just be sure to exit. */
3435: while (*p) {
3436: if (p[1] == '\\' && p[2] == '\n')
3437: newline_fix (p + 1);
3438: if (*p == '*' && p[1] == '/') {
3439: p += 2;
3440: break;
3441: }
3442: p++;
3443: }
3444: }
3445: #ifdef CPLUSPLUS
3446: else if (p[1] == '/') {
3447: p += 2;
3448: while (*p && *p++ != '\n') ;
3449: }
3450: #endif
3451: } else break;
3452: }
3453: if (*p && *p != '\n')
3454: warning ("text following #else or #endif violates ANSI standard");
3455: }
3456:
3457: /*
3458: * Skip a comment, assuming the input ptr immediately follows the
3459: * initial slash-star. Bump line counter as necessary.
3460: * (The canonical line counter is &ip->lineno).
3461: * Don't use this routine (or the next one) if bumping the line
3462: * counter is not sufficient to deal with newlines in the string.
3463: */
3464: U_CHAR *
3465: skip_to_end_of_comment (ip, line_counter)
3466: register FILE_BUF *ip;
3467: int *line_counter; /* place to remember newlines, or NULL */
3468: {
3469: register U_CHAR *limit = ip->buf + ip->length;
3470: register U_CHAR *bp = ip->bufp;
3471: FILE_BUF *op = &outbuf; /* JF */
3472: int output = put_out_comments && !line_counter;
3473:
3474: /* JF this line_counter stuff is a crock to make sure the
3475: comment is only put out once, no matter how many times
3476: the comment is skipped. It almost works */
3477: if (output) {
3478: *op->bufp++ = '/';
3479: *op->bufp++ = '*';
3480: }
3481: #ifdef CPLUSPLUS
3482: if (bp[-1] == '/') {
3483: if (output)
3484: {
3485: while (bp < limit)
3486: if ((*op->bufp++ = *bp++) == '\n')
3487: {
3488: bp--;
3489: break;
3490: }
3491: op->bufp[-1] = '*';
3492: *op->bufp++ = '/';
3493: *op->bufp++ = '\n';
3494: }
3495: else
3496: {
3497: while (bp < limit) {
3498: if (*bp++ == '\n')
3499: {
3500: bp--;
3501: break;
3502: }
3503: }
3504: }
3505: ip->bufp = bp;
3506: return bp;
3507: }
3508: #endif
3509: while (bp < limit) {
3510: if (output)
3511: *op->bufp++ = *bp;
3512: switch (*bp++) {
3513: case '\n':
3514: if (line_counter != NULL)
3515: ++*line_counter;
3516: if (output)
3517: ++op->lineno;
3518: break;
3519: case '*':
3520: if (*bp == '\\' && bp[1] == '\n')
3521: newline_fix (bp);
3522: if (*bp == '/') {
3523: if (output)
3524: *op->bufp++ = '/';
3525: ip->bufp = ++bp;
3526: return bp;
3527: }
3528: break;
3529: }
3530: }
3531: ip->bufp = bp;
3532: return bp;
3533: }
3534:
3535: /*
3536: * Skip over a quoted string. BP points to the opening quote.
3537: * Returns a pointer after the closing quote. Don't go past LIMIT.
3538: * START_LINE is the line number of the starting point (but it need
3539: * not be valid if the starting point is inside a macro expansion).
3540: *
3541: * The input stack state is not changed.
3542: *
3543: * If COUNT_NEWLINES is nonzero, it points to an int to increment
3544: * for each newline passed.
3545: *
3546: * If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
3547: * if we pass a backslash-newline.
3548: *
3549: * If EOFP is nonzero, set *EOFP to 1 if the string is unterminated.
3550: */
3551: U_CHAR *
3552: skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
3553: register U_CHAR *bp;
3554: register U_CHAR *limit;
3555: int start_line;
3556: int *count_newlines;
3557: int *backslash_newlines_p;
3558: int *eofp;
3559: {
3560: register U_CHAR c, match;
3561:
3562: match = *bp++;
3563: while (1) {
3564: if (bp >= limit) {
3565: error_with_line (line_for_error (start_line),
3566: "unterminated string constant");
3567: if (eofp)
3568: *eofp = 1;
3569: break;
3570: }
3571: c = *bp++;
3572: if (c == '\\') {
3573: while (*bp == '\\' && bp[1] == '\n') {
3574: if (backslash_newlines_p)
3575: *backslash_newlines_p = 1;
3576: if (count_newlines)
3577: ++*count_newlines;
3578: bp += 2;
3579: }
3580: if (*bp == '\n' && count_newlines) {
3581: if (backslash_newlines_p)
3582: *backslash_newlines_p = 1;
3583: ++*count_newlines;
3584: }
3585: bp++;
3586: } else if (c == '\n') {
3587: if (count_newlines)
3588: ++*count_newlines;
3589: } else if (c == match)
3590: break;
3591: }
3592: return bp;
3593: }
3594:
3595: /*
3596: * write out a #line command, for instance, after an #include file.
3597: * If CONDITIONAL is nonzero, we can omit the #line if it would
3598: * appear to be a no-op, and we can output a few newlines instead
3599: * if we want to increase the line number by a small amount.
3600: */
3601: static
3602: output_line_command (ip, op, conditional)
3603: FILE_BUF *ip, *op;
3604: int conditional;
3605: {
3606: int len;
3607: char line_cmd_buf[500];
3608:
3609: if (no_line_commands
3610: || ip->fname == NULL
3611: || no_output) {
3612: op->lineno = ip->lineno;
3613: return;
3614: }
3615:
3616: if (conditional) {
3617: if (ip->lineno == op->lineno)
3618: return;
3619:
3620: /* If the inherited line number is a little too small,
3621: output some newlines instead of a #line command. */
3622: if (ip->lineno > op->lineno && ip->lineno < op->lineno + 8) {
3623: check_expand (op, 10);
3624: while (ip->lineno > op->lineno) {
3625: *op->bufp++ = '\n';
3626: op->lineno++;
3627: }
3628: return;
3629: }
3630: }
3631:
3632: #ifdef OUTPUT_LINE_COMMANDS
3633: sprintf (line_cmd_buf, "#line %d \"%s\"\n", ip->lineno, ip->fname);
3634: #else
3635: sprintf (line_cmd_buf, "# %d \"%s\"\n", ip->lineno, ip->fname);
3636: #endif
3637: len = strlen (line_cmd_buf);
3638: check_expand (op, len + 1);
3639: if (op->bufp > op->buf && op->bufp[-1] != '\n')
3640: *op->bufp++ = '\n';
3641: bcopy (line_cmd_buf, op->bufp, len);
3642: op->bufp += len;
3643: op->lineno = ip->lineno;
3644: }
3645:
3646: /* This structure represents one parsed argument in a macro call.
3647: `raw' points to the argument text as written (`raw_length' is its length).
3648: `expanded' points to the argument's macro-expansion
3649: (its length is `expand_length').
3650: `stringified_length' is the length the argument would have
3651: if stringified.
3652: `free1' and `free2', if nonzero, point to blocks to be freed
3653: when the macro argument data is no longer needed. */
3654:
3655: struct argdata {
3656: U_CHAR *raw, *expanded;
3657: int raw_length, expand_length;
3658: int stringified_length;
3659: U_CHAR *free1, *free2;
3660: char newlines;
3661: char comments;
3662: };
3663:
3664: /* Expand a macro call.
3665: HP points to the symbol that is the macro being called.
3666: Put the result of expansion onto the input stack
3667: so that subsequent input by our caller will use it.
3668:
3669: If macro wants arguments, caller has already verified that
3670: an argument list follows; arguments come from the input stack. */
3671:
3672: macroexpand (hp, op)
3673: HASHNODE *hp;
3674: FILE_BUF *op;
3675: {
3676: int nargs;
3677: DEFINITION *defn = hp->value.defn;
3678: register U_CHAR *xbuf;
3679: int xbuf_len;
3680: int start_line = instack[indepth].lineno;
3681:
3682: /* it might not actually be a macro. */
3683: if (hp->type != T_MACRO)
3684: {
3685: special_symbol (hp, op);
3686: return;
3687: }
3688:
3689: nargs = defn->nargs;
3690:
3691: if (nargs >= 0)
3692: {
3693: register int i;
3694: struct argdata *args;
3695: char *parse_error = 0;
3696:
3697: args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
3698:
3699: for (i = 0; i < nargs; i++) {
3700: args[i].raw = args[i].expanded = (U_CHAR *) "";
3701: args[i].raw_length = args[i].expand_length
3702: = args[i].stringified_length = 0;
3703: args[i].free1 = args[i].free2 = 0;
3704: }
3705:
3706: /* Parse all the macro args that are supplied. I counts them.
3707: The first NARGS args are stored in ARGS.
3708: The rest are discarded. */
3709: i = 0;
3710: do {
3711: /* Discard the open-parenthesis or comma before the next arg. */
3712: ++instack[indepth].bufp;
3713: if (parse_error = macarg ((i < nargs || (nargs == 0 && i == 0)) ? &args[i] : 0))
3714: {
3715: error_with_line (line_for_error (start_line), parse_error);
3716: break;
3717: }
3718: i++;
3719: } while (*instack[indepth].bufp != ')');
3720:
3721: if (nargs == 0 && i == 1) {
3722: register U_CHAR *bp = args[0].raw;
3723: register U_CHAR *lim = bp + args[0].raw_length;
3724: while (bp != lim && is_space[*bp]) bp++;
3725: if (bp != lim)
3726: error ("arguments given to macro `%s'", hp->name);
3727: } else if (i < nargs)
3728: error ("only %d args to macro `%s'", i, hp->name);
3729: else if (i > nargs)
3730: error ("too many (%d) args to macro `%s'", i, hp->name);
3731:
3732: /* Swallow the closeparen. */
3733: ++instack[indepth].bufp;
3734:
3735: /* If macro wants zero args, we parsed the arglist for checking only.
3736: Read directly from the macro definition. */
3737: if (nargs == 0) {
3738: xbuf = defn->expansion;
3739: xbuf_len = defn->length;
3740: } else {
3741: register U_CHAR *exp = defn->expansion;
3742: register int offset; /* offset in expansion,
3743: copied a piece at a time */
3744: register int totlen; /* total amount of exp buffer filled so far */
3745:
3746: register struct reflist *ap;
3747:
3748: /* Macro really takes args. Compute the expansion of this call. */
3749:
3750: /* Compute length in characters of the macro's expansion. */
3751: xbuf_len = defn->length;
3752: for (ap = defn->pattern; ap != NULL; ap = ap->next) {
3753: if (ap->stringify)
3754: xbuf_len += args[ap->argno].stringified_length;
3755: else if (ap->raw_before || ap->raw_after)
3756: xbuf_len += args[ap->argno].raw_length;
3757: else
3758: xbuf_len += args[ap->argno].expand_length;
3759: }
3760:
3761: xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
3762:
3763: /* Generate in XBUF the complete expansion
3764: with arguments substituted in.
3765: TOTLEN is the total size generated so far.
3766: OFFSET is the index in the definition
3767: of where we are copying from. */
3768: offset = totlen = 0;
3769: for (ap = defn->pattern; ap != NULL; ap = ap->next) {
3770: register struct argdata *arg = &args[ap->argno];
3771:
3772: for (i = 0; i < ap->nchars; i++)
3773: xbuf[totlen++] = exp[offset++];
3774:
3775: if (ap->stringify != 0) {
3776: int arglen = arg->raw_length;
3777: int escaped = 0;
3778: int in_string = 0;
3779: int c;
3780: i = 0;
3781: while (i < arglen
3782: && (c = arg->raw[i], is_space[c]))
3783: i++;
3784: while (i < arglen
3785: && (c = arg->raw[arglen - 1], is_space[c]))
3786: arglen--;
3787: xbuf[totlen++] = '\"'; /* insert beginning quote */
3788: for (; i < arglen; i++) {
3789: c = arg->raw[i];
3790:
3791: /* Special markers Newline Space and Newline Newline
3792: generate nothing for a stringified argument. */
3793: if (c == '\n') {
3794: i++;
3795: continue;
3796: }
3797:
3798: /* Internal sequences of whitespace are replaced by one space. */
3799: if (is_space[c]) {
3800: while (c = arg->raw[i+1], is_space[c]) i++;
3801: c = ' ';
3802: }
3803:
3804: if (escaped)
3805: escaped = 0;
3806: else {
3807: if (c == '\\')
3808: escaped = 1;
3809: if (in_string && c == in_string)
3810: in_string = 0;
3811: else if (c == '\"' || c == '\'')
3812: in_string = c;
3813: }
3814:
3815: /* Escape these chars */
3816: if (c == '\"' || (in_string && c == '\\'))
3817: xbuf[totlen++] = '\\';
3818: if (isprint (c))
3819: xbuf[totlen++] = c;
3820: else {
3821: sprintf (&xbuf[totlen], "\\%03o", (unsigned int) c);
3822: totlen += 4;
3823: }
3824: }
3825: xbuf[totlen++] = '\"'; /* insert ending quote */
3826: } else if (ap->raw_before || ap->raw_after) {
3827: U_CHAR *p1 = arg->raw;
3828: U_CHAR *l1 = p1 + arg->raw_length;
3829: if (ap->raw_before) {
3830: while (p1 != l1 && is_space[*p1]) p1++;
3831: while (p1 != l1 && is_idchar[*p1])
3832: xbuf[totlen++] = *p1++;
3833: /* Delete any no-reexpansion marker that follows
3834: an identifier at the beginning of the argument
3835: if the argument is concatenated with what precedes it. */
3836: if (p1[0] == '\n' && p1[1] == '-')
3837: p1 += 2;
3838: }
3839: if (ap->raw_after) {
3840: /* Arg is concatenated after: delete trailing whitespace,
3841: whitespace markers, and no-reexpansion markers. */
3842: while (p1 != l1) {
3843: if (is_space[l1[-1]]) l1--;
3844: else if (l1[-1] == '-') {
3845: U_CHAR *p2 = l1 - 1;
3846: /* If a `-' is preceded by an odd number of newlines then it
3847: and the last newline are a no-reexpansion marker. */
3848: while (p2 != p1 && p2[-1] == '\n') p2--;
3849: if ((l1 - 1 - p2) & 1) {
3850: l1 -= 2;
3851: }
3852: else break;
3853: }
3854: else break;
3855: }
3856: }
3857: bcopy (p1, xbuf + totlen, l1 - p1);
3858: totlen += l1 - p1;
3859: } else {
3860: bcopy (arg->expanded, xbuf + totlen, arg->expand_length);
3861: totlen += arg->expand_length;
3862: }
3863:
3864: if (totlen > xbuf_len)
3865: abort ();
3866: }
3867:
3868: /* if there is anything left of the definition
3869: after handling the arg list, copy that in too. */
3870:
3871: for (i = offset; i < defn->length; i++)
3872: xbuf[totlen++] = exp[i];
3873:
3874: xbuf[totlen] = 0;
3875: xbuf_len = totlen;
3876:
3877: for (i = 0; i < nargs; i++) {
3878: if (args[i].free1 != 0)
3879: free (args[i].free1);
3880: if (args[i].free2 != 0)
3881: free (args[i].free2);
3882: }
3883: }
3884: }
3885: else
3886: {
3887: xbuf = defn->expansion;
3888: xbuf_len = defn->length;
3889: }
3890:
3891: /* Now put the expansion on the input stack
3892: so our caller will commence reading from it. */
3893: {
3894: register FILE_BUF *ip2;
3895:
3896: ip2 = &instack[++indepth];
3897:
3898: ip2->fname = 0;
3899: ip2->lineno = 0;
3900: ip2->buf = xbuf;
3901: ip2->length = xbuf_len;
3902: ip2->bufp = xbuf;
3903: ip2->free = (nargs > 0) ? xbuf : 0;
3904: ip2->macro = hp;
3905: ip2->if_stack = if_stack;
3906:
3907: if (!traditional)
3908: hp->type = T_DISABLED;
3909: }
3910: }
3911:
3912: /*
3913: * Parse a macro argument and store the info on it into *ARGPTR.
3914: * Return nonzero to indicate a syntax error.
3915: */
3916:
3917: char *
3918: macarg (argptr)
3919: register struct argdata *argptr;
3920: {
3921: FILE_BUF *ip = &instack[indepth];
3922: int paren = 0;
3923: int newlines = 0;
3924: int comments = 0;
3925:
3926: /* Try to parse as much of the argument as exists at this
3927: input stack level. */
3928: U_CHAR *bp = macarg1 (ip->bufp, ip->buf + ip->length,
3929: &paren, &newlines, &comments);
3930:
3931: /* If we find the end of the argument at this level,
3932: set up *ARGPTR to point at it in the input stack. */
3933: if (!(ip->fname != 0 && (newlines != 0 || comments != 0))
3934: && bp != ip->buf + ip->length) {
3935: if (argptr != 0) {
3936: argptr->raw = ip->bufp;
3937: argptr->raw_length = bp - ip->bufp;
3938: }
3939: ip->bufp = bp;
3940: } else {
3941: /* This input stack level ends before the macro argument does.
3942: We must pop levels and keep parsing.
3943: Therefore, we must allocate a temporary buffer and copy
3944: the macro argument into it. */
3945: int bufsize = bp - ip->bufp;
3946: int extra = newlines;
3947: U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1);
3948: int final_start = 0;
3949:
3950: bcopy (ip->bufp, buffer, bufsize);
3951: ip->bufp = bp;
3952: ip->lineno += newlines;
3953:
3954: while (bp == ip->buf + ip->length) {
3955: if (instack[indepth].macro == 0) {
3956: free (buffer);
3957: return "Unterminated macro call";
3958: }
3959: ip->macro->type = T_MACRO;
3960: free (ip->buf);
3961: ip = &instack[--indepth];
3962: newlines = 0;
3963: comments = 0;
3964: bp = macarg1 (ip->bufp, ip->buf + ip->length, &paren,
3965: &newlines, &comments);
3966: final_start = bufsize;
3967: bufsize += bp - ip->bufp;
3968: extra += newlines;
3969: buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1);
3970: bcopy (ip->bufp, buffer + bufsize - (bp - ip->bufp), bp - ip->bufp);
3971: ip->bufp = bp;
3972: ip->lineno += newlines;
3973: }
3974:
3975: /* Now, if arg is actually wanted, record its raw form,
3976: discarding comments and duplicating newlines in whatever
3977: part of it did not come from a macro expansion.
3978: EXTRA space has been preallocated for duplicating the newlines.
3979: FINAL_START is the index of the start of that part. */
3980: if (argptr != 0) {
3981: argptr->raw = buffer;
3982: argptr->raw_length = bufsize;
3983: argptr->free1 = buffer;
3984: argptr->newlines = newlines;
3985: argptr->comments = comments;
3986: if ((newlines || comments) && ip->fname != 0)
3987: argptr->raw_length
3988: = final_start +
3989: discard_comments (argptr->raw + final_start,
3990: argptr->raw_length - final_start,
3991: newlines);
3992: argptr->raw[argptr->raw_length] = 0;
3993: if (argptr->raw_length > bufsize + extra)
3994: abort ();
3995: }
3996: }
3997:
3998: /* If we are not discarding this argument,
3999: macroexpand it and compute its length as stringified.
4000: All this info goes into *ARGPTR. */
4001:
4002: if (argptr != 0) {
4003: FILE_BUF obuf;
4004: register U_CHAR *buf, *lim;
4005: register int totlen;
4006:
4007: obuf = expand_to_temp_buffer (argptr->raw,
4008: argptr->raw + argptr->raw_length,
4009: 1);
4010:
4011: argptr->expanded = obuf.buf;
4012: argptr->expand_length = obuf.length;
4013: argptr->free2 = obuf.buf;
4014:
4015: buf = argptr->raw;
4016: lim = buf + argptr->raw_length;
4017:
4018: while (buf != lim && is_space[*buf])
4019: buf++;
4020: while (buf != lim && is_space[lim[-1]])
4021: lim--;
4022: totlen = 2; /* Count opening and closing quote. */
4023: while (buf != lim) {
4024: register U_CHAR c = *buf++;
4025: totlen++;
4026: /* Internal sequences of whitespace are replaced by one space. */
4027: if (is_space[c])
4028: SKIP_ALL_WHITE_SPACE (buf);
4029: else if (c == '\"' || c == '\\') /* escape these chars */
4030: totlen++;
4031: else if (!isprint (c))
4032: totlen += 3;
4033: }
4034: argptr->stringified_length = totlen;
4035: }
4036: return 0;
4037: }
4038:
4039: /* Scan text from START (inclusive) up to LIMIT (exclusive),
4040: counting parens in *DEPTHPTR,
4041: and return if reach LIMIT
4042: or before a `)' that would make *DEPTHPTR negative
4043: or before a comma when *DEPTHPTR is zero.
4044: Single and double quotes are matched and termination
4045: is inhibited within them. Comments also inhibit it.
4046: Value returned is pointer to stopping place.
4047:
4048: Increment *NEWLINES each time a newline is passed.
4049: Set *COMMENTS to 1 if a comment is seen. */
4050:
4051: U_CHAR *
4052: macarg1 (start, limit, depthptr, newlines, comments)
4053: U_CHAR *start;
4054: register U_CHAR *limit;
4055: int *depthptr, *newlines, *comments;
4056: {
4057: register U_CHAR *bp = start;
4058:
4059: while (bp < limit) {
4060: switch (*bp) {
4061: case '(':
4062: (*depthptr)++;
4063: break;
4064: case ')':
4065: if (--(*depthptr) < 0)
4066: return bp;
4067: break;
4068: case '\n':
4069: ++*newlines;
4070: break;
4071: case '/':
4072: if (bp[1] == '\\' && bp[2] == '\n')
4073: newline_fix (bp + 1);
4074: #ifdef CPLUSPLUS
4075: if (bp[1] == '/') {
4076: *comments = 1;
4077: bp += 2;
4078: while (bp < limit && *bp++ != '\n') ;
4079: ++*newlines;
4080: break;
4081: }
4082: #endif
4083: if (bp[1] != '*' || bp + 1 >= limit)
4084: break;
4085: *comments = 1;
4086: bp += 2;
4087: while (bp + 1 < limit) {
4088: if (bp[0] == '*'
4089: && bp[1] == '\\' && bp[2] == '\n')
4090: newline_fix (bp + 1);
4091: if (bp[0] == '*' && bp[1] == '/')
4092: break;
4093: if (*bp == '\n') ++*newlines;
4094: bp++;
4095: }
4096: break;
4097: case '\'':
4098: case '\"':
4099: {
4100: int quotec;
4101: for (quotec = *bp++; bp + 1 < limit && *bp != quotec; bp++) {
4102: if (*bp == '\\') {
4103: bp++;
4104: if (*bp == '\n')
4105: ++*newlines;
4106: while (*bp == '\\' && bp[1] == '\n') {
4107: bp += 2;
4108: }
4109: } else if (*bp == '\n')
4110: ++*newlines;
4111: }
4112: }
4113: break;
4114: case ',':
4115: if ((*depthptr) == 0)
4116: return bp;
4117: break;
4118: }
4119: bp++;
4120: }
4121:
4122: return bp;
4123: }
4124:
4125: /* Discard comments and duplicate newlines
4126: in the string of length LENGTH at START,
4127: except inside of string constants.
4128: The string is copied into itself with its beginning staying fixed.
4129:
4130: NEWLINES is the number of newlines that must be duplicated.
4131: We assume that that much extra space is available past the end
4132: of the string. */
4133:
4134: int
4135: discard_comments (start, length, newlines)
4136: U_CHAR *start;
4137: int length;
4138: int newlines;
4139: {
4140: register U_CHAR *ibp;
4141: register U_CHAR *obp;
4142: register U_CHAR *limit;
4143: register int c;
4144:
4145: /* If we have newlines to duplicate, copy everything
4146: that many characters up. Then, in the second part,
4147: we will have room to insert the newlines
4148: while copying down.
4149: NEWLINES may actually be too large, because it counts
4150: newlines in string constants, and we don't duplicate those.
4151: But that does no harm. */
4152: if (newlines > 0) {
4153: ibp = start + length;
4154: obp = ibp + newlines;
4155: limit = start;
4156: while (limit != ibp)
4157: *--obp = *--ibp;
4158: }
4159:
4160: ibp = start + newlines;
4161: limit = start + length + newlines;
4162: obp = start;
4163:
4164: while (ibp < limit) {
4165: *obp++ = c = *ibp++;
4166: switch (c) {
4167: case '\n':
4168: /* Duplicate the newline. */
4169: *obp++ = '\n';
4170: break;
4171:
4172: case '/':
4173: if (*ibp == '\\' && ibp[1] == '\n')
4174: newline_fix (ibp);
4175: /* Delete any comment. */
4176: #ifdef CPLUSPLUS
4177: if (ibp[0] == '/') {
4178: obp--;
4179: ibp++;
4180: while (ibp < limit && *ibp++ != '\n') ;
4181: break;
4182: }
4183: #endif
4184: if (ibp[0] != '*' || ibp + 1 >= limit)
4185: break;
4186: obp--;
4187: ibp++;
4188: while (ibp + 1 < limit) {
4189: if (ibp[0] == '*'
4190: && ibp[1] == '\\' && ibp[2] == '\n')
4191: newline_fix (ibp + 1);
4192: if (ibp[0] == '*' && ibp[1] == '/')
4193: break;
4194: ibp++;
4195: }
4196: ibp += 2;
4197: break;
4198:
4199: case '\'':
4200: case '\"':
4201: /* Notice and skip strings, so that we don't
4202: think that comments start inside them,
4203: and so we don't duplicate newlines in them. */
4204: {
4205: int quotec = c;
4206: while (ibp < limit)
4207: {
4208: *obp++ = c = *ibp++;
4209: if (c == quotec)
4210: break;
4211: if (c == '\\' && ibp < limit) {
4212: while (*ibp == '\\' && ibp[1] == '\n')
4213: ibp += 2;
4214: *obp++ = *ibp++;
4215: }
4216: }
4217: }
4218: break;
4219: }
4220: }
4221:
4222: return obp - start;
4223: }
4224:
4225: /*
4226: * error - print error message and increment count of errors.
4227: */
4228: error (msg, arg1, arg2, arg3)
4229: U_CHAR *msg;
4230: {
4231: int i;
4232: FILE_BUF *ip = NULL;
4233:
4234: for (i = indepth; i >= 0; i--)
4235: if (instack[i].fname != NULL) {
4236: ip = &instack[i];
4237: break;
4238: }
4239:
4240: if (ip != NULL)
4241: fprintf (stderr, "%s:%d: ", ip->fname, ip->lineno);
4242: fprintf (stderr, msg, arg1, arg2, arg3);
4243: fprintf (stderr, "\n", msg);
4244: errors++;
4245: return 0;
4246: }
4247:
4248: /* Print error message but don't count it. */
4249:
4250: warning (msg, arg1, arg2, arg3)
4251: U_CHAR *msg;
4252: {
4253: int i;
4254: FILE_BUF *ip = NULL;
4255:
4256: for (i = indepth; i >= 0; i--)
4257: if (instack[i].fname != NULL) {
4258: ip = &instack[i];
4259: break;
4260: }
4261:
4262: if (ip != NULL)
4263: fprintf (stderr, "%s:%d: ", ip->fname, ip->lineno);
4264: fprintf (stderr, "warning: ");
4265: fprintf (stderr, msg, arg1, arg2, arg3);
4266: fprintf (stderr, "\n", msg);
4267: return 0;
4268: }
4269:
4270: error_with_line (line, msg, arg1, arg2, arg3)
4271: int line;
4272: U_CHAR *msg;
4273: {
4274: int i;
4275: FILE_BUF *ip = NULL;
4276:
4277: for (i = indepth; i >= 0; i--)
4278: if (instack[i].fname != NULL) {
4279: ip = &instack[i];
4280: break;
4281: }
4282:
4283: if (ip != NULL)
4284: fprintf (stderr, "%s:%d: ", ip->fname, line);
4285: fprintf (stderr, msg, arg1, arg2, arg3);
4286: fprintf (stderr, "\n", msg);
4287: errors++;
4288: return 0;
4289: }
4290:
4291: /* Return the line at which an error occurred.
4292: The error is not necessarily associated with the current spot
4293: in the input stack, so LINE says where. LINE will have been
4294: copied from ip->lineno for the current input level.
4295: If the current level is for a file, we return LINE.
4296: But if the current level is not for a file, LINE is meaningless.
4297: In that case, we return the lineno of the innermost file. */
4298: int
4299: line_for_error (line)
4300: int line;
4301: {
4302: int i;
4303: int line1 = line;
4304:
4305: for (i = indepth; i >= 0; ) {
4306: if (instack[i].fname != 0)
4307: return line1;
4308: i--;
4309: if (i < 0)
4310: return 0;
4311: line1 = instack[i].lineno;
4312: }
4313: }
4314:
4315: /*
4316: * If OBUF doesn't have NEEDED bytes after OPTR, make it bigger.
4317: *
4318: * As things stand, nothing is ever placed in the output buffer to be
4319: * removed again except when it's KNOWN to be part of an identifier,
4320: * so flushing and moving down everything left, instead of expanding,
4321: * should work ok.
4322: */
4323:
4324: int
4325: grow_outbuf (obuf, needed)
4326: register FILE_BUF *obuf;
4327: register int needed;
4328: {
4329: register U_CHAR *p;
4330: int minsize;
4331:
4332: if (obuf->length - (obuf->bufp - obuf->buf) > needed)
4333: return;
4334:
4335: /* Make it at least twice as big as it is now. */
4336: obuf->length *= 2;
4337: /* Make it have at least 150% of the free space we will need. */
4338: minsize = (3 * needed) / 2 + (obuf->bufp - obuf->buf);
4339: if (minsize > obuf->length)
4340: obuf->length = minsize;
4341:
4342: if ((p = (U_CHAR *) xrealloc (obuf->buf, obuf->length)) == NULL)
4343: memory_full ();
4344:
4345: obuf->bufp = p + (obuf->bufp - obuf->buf);
4346: obuf->buf = p;
4347: }
4348:
4349: /* Symbol table for macro names and special symbols */
4350:
4351: /*
4352: * install a name in the main hash table, even if it is already there.
4353: * name stops with first non alphanumeric, except leading '#'.
4354: * caller must check against redefinition if that is desired.
4355: * delete_macro () removes things installed by install () in fifo order.
4356: * this is important because of the `defined' special symbol used
4357: * in #if, and also if pushdef/popdef directives are ever implemented.
4358: *
4359: * If LEN is >= 0, it is the length of the name.
4360: * Otherwise, compute the length by scanning the entire name.
4361: *
4362: * If HASH is >= 0, it is the precomputed hash code.
4363: * Otherwise, compute the hash code.
4364: */
4365: HASHNODE *
4366: install (name, len, type, value, hash)
4367: U_CHAR *name;
4368: int len;
4369: enum node_type type;
4370: int value;
4371: int hash;
4372: /* watch out here if sizeof (U_CHAR *) != sizeof (int) */
4373: {
4374: register HASHNODE *hp;
4375: register int i, bucket;
4376: register U_CHAR *p, *q;
4377:
4378: if (len < 0) {
4379: p = name;
4380: while (is_idchar[*p])
4381: p++;
4382: len = p - name;
4383: }
4384:
4385: if (hash < 0)
4386: hash = hashf (name, len, HASHSIZE);
4387:
4388: i = sizeof (HASHNODE) + len + 1;
4389: hp = (HASHNODE *) xmalloc (i);
4390: bucket = hash;
4391: hp->bucket_hdr = &hashtab[bucket];
4392: hp->next = hashtab[bucket];
4393: hashtab[bucket] = hp;
4394: hp->prev = NULL;
4395: if (hp->next != NULL)
4396: hp->next->prev = hp;
4397: hp->type = type;
4398: hp->length = len;
4399: hp->value.ival = value;
4400: hp->name = ((U_CHAR *) hp) + sizeof (HASHNODE);
4401: p = hp->name;
4402: q = name;
4403: for (i = 0; i < len; i++)
4404: *p++ = *q++;
4405: hp->name[len] = 0;
4406: return hp;
4407: }
4408:
4409: /*
4410: * find the most recent hash node for name name (ending with first
4411: * non-identifier char) installed by install
4412: *
4413: * If LEN is >= 0, it is the length of the name.
4414: * Otherwise, compute the length by scanning the entire name.
4415: *
4416: * If HASH is >= 0, it is the precomputed hash code.
4417: * Otherwise, compute the hash code.
4418: */
4419: HASHNODE *
4420: lookup (name, len, hash)
4421: U_CHAR *name;
4422: int len;
4423: int hash;
4424: {
4425: register U_CHAR *bp;
4426: register HASHNODE *bucket;
4427:
4428: if (len < 0) {
4429: for (bp = name; is_idchar[*bp]; bp++) ;
4430: len = bp - name;
4431: }
4432:
4433: if (hash < 0)
4434: hash = hashf (name, len, HASHSIZE);
4435:
4436: bucket = hashtab[hash];
4437: while (bucket) {
4438: if (bucket->length == len && strncmp (bucket->name, name, len) == 0)
4439: return bucket;
4440: bucket = bucket->next;
4441: }
4442: return NULL;
4443: }
4444:
4445: /*
4446: * Delete a hash node. Some weirdness to free junk from macros.
4447: * More such weirdness will have to be added if you define more hash
4448: * types that need it.
4449: */
4450:
4451: /* Note that the DEFINITION of a macro is removed from the hash table
4452: but its storage is not freed. This would be a storage leak
4453: except that it is not reasonable to keep undefining and redefining
4454: large numbers of macros many times.
4455: In any case, this is necessary, because a macro can be #undef'd
4456: in the middle of reading the arguments to a call to it.
4457: If #undef freed the DEFINITION, that would crash. */
4458:
4459: delete_macro (hp)
4460: HASHNODE *hp;
4461: {
4462:
4463: if (hp->prev != NULL)
4464: hp->prev->next = hp->next;
4465: if (hp->next != NULL)
4466: hp->next->prev = hp->prev;
4467:
4468: /* make sure that the bucket chain header that
4469: the deleted guy was on points to the right thing afterwards. */
4470: if (hp == *hp->bucket_hdr)
4471: *hp->bucket_hdr = hp->next;
4472:
4473: #if 0
4474: if (hp->type == T_MACRO) {
4475: DEFINITION *d = hp->value.defn;
4476: struct reflist *ap, *nextap;
4477:
4478: for (ap = d->pattern; ap != NULL; ap = nextap) {
4479: nextap = ap->next;
4480: free (ap);
4481: }
4482: free (d);
4483: }
4484: #endif
4485: free (hp);
4486: }
4487:
4488: /*
4489: * return hash function on name. must be compatible with the one
4490: * computed a step at a time, elsewhere
4491: */
4492: int
4493: hashf (name, len, hashsize)
4494: register U_CHAR *name;
4495: register int len;
4496: int hashsize;
4497: {
4498: register int r = 0;
4499:
4500: while (len--)
4501: r = HASHSTEP (r, *name++);
4502:
4503: return MAKE_POS (r) % hashsize;
4504: }
4505:
4506: /* Dump all macro definitions as #defines to stdout. */
4507:
4508: dump_all_macros ()
4509: {
4510: int bucket;
4511:
4512: for (bucket = 0; bucket < HASHSIZE; bucket++) {
4513: register HASHNODE *hp;
4514:
4515: for (hp = hashtab[bucket]; hp; hp= hp->next) {
4516: if (hp->type == T_MACRO) {
4517: register DEFINITION *defn = hp->value.defn;
4518: struct reflist *ap;
4519: int offset;
4520: int concat;
4521:
4522:
4523: /* Print the definition of the macro HP. */
4524:
4525: printf ("#define %s", hp->name);
4526: if (defn->nargs >= 0) {
4527: int i;
4528:
4529: printf ("(");
4530: for (i = 0; i < defn->nargs; i++) {
4531: dump_arg_n (defn, i);
4532: if (i + 1 < defn->nargs)
4533: printf (", ");
4534: }
4535: printf (")");
4536: }
4537:
4538: printf (" ");
4539:
4540: offset = 0;
4541: concat = 0;
4542: for (ap = defn->pattern; ap != NULL; ap = ap->next) {
4543: dump_defn_1 (defn->expansion, offset, ap->nchars);
4544: if (ap->nchars != 0)
4545: concat = 0;
4546: offset += ap->nchars;
4547: if (ap->stringify)
4548: printf (" #");
4549: if (ap->raw_before && !concat)
4550: printf (" ## ");
4551: concat = 0;
4552: dump_arg_n (defn, ap->argno);
4553: if (ap->raw_after) {
4554: printf (" ## ");
4555: concat = 1;
4556: }
4557: }
4558: dump_defn_1 (defn->expansion, offset, defn->length - offset);
4559: printf ("\n");
4560: }
4561: }
4562: }
4563: return NULL;
4564: }
4565:
4566: /* Output to stdout a substring of a macro definition.
4567: BASE is the beginning of the definition.
4568: Output characters START thru LENGTH.
4569: Discard newlines outside of strings, thus
4570: converting funny-space markers to ordinary spaces. */
4571:
4572: dump_defn_1 (base, start, length)
4573: U_CHAR *base;
4574: int start;
4575: int length;
4576: {
4577: U_CHAR *p = base + start;
4578: U_CHAR *limit = base + start + length;
4579:
4580: while (p < limit) {
4581: if (*p != '\n')
4582: putchar (*p);
4583: else if (*p == '\"' || *p =='\'') {
4584: U_CHAR *p1 = skip_quoted_string (p, limit, 0, 0, 0);
4585: fwrite (p, p1 - p, 1, stdout);
4586: p = p1 - 1;
4587: }
4588: p++;
4589: }
4590: }
4591:
4592: /* Print the name of argument number ARGNUM of macro definition DEFN.
4593: Recall that DEFN->argnames contains all the arg names
4594: concatenated in reverse order with comma-space in between. */
4595:
4596: dump_arg_n (defn, argnum)
4597: DEFINITION *defn;
4598: int argnum;
4599: {
4600: register U_CHAR *p = defn->argnames;
4601: while (argnum + 1 < defn->nargs) {
4602: p = (U_CHAR *) index (p, ' ') + 1;
4603: argnum++;
4604: }
4605:
4606: while (*p && *p != ',') {
4607: putchar (*p);
4608: p++;
4609: }
4610: }
4611:
4612: /*
4613: * initialize random junk in the hash table and maybe other places
4614: */
4615: initialize_random_junk ()
4616: {
4617: register int i;
4618:
4619: /*
4620: * Set up is_idchar and is_idstart tables. These should be
4621: * faster than saying (is_alpha (c) || c == '_'), etc.
4622: * Must do set up these things before calling any routines tthat
4623: * refer to them.
4624: */
4625: for (i = 'a'; i <= 'z'; i++) {
4626: ++is_idchar[i - 'a' + 'A'];
4627: ++is_idchar[i];
4628: ++is_idstart[i - 'a' + 'A'];
4629: ++is_idstart[i];
4630: }
4631: for (i = '0'; i <= '9'; i++)
4632: ++is_idchar[i];
4633: ++is_idchar['_'];
4634: ++is_idstart['_'];
4635: ++is_idchar['$'];
4636: ++is_idstart['$'];
4637:
4638: /* horizontal space table */
4639: ++is_hor_space[' '];
4640: ++is_hor_space['\t'];
4641: ++is_hor_space['\v'];
4642: ++is_hor_space['\f'];
4643:
4644: ++is_space[' '];
4645: ++is_space['\t'];
4646: ++is_space['\v'];
4647: ++is_space['\f'];
4648: ++is_space['\n'];
4649:
4650: install ("__LINE__", -1, T_SPECLINE, 0, -1);
4651: install ("__DATE__", -1, T_DATE, 0, -1);
4652: install ("__FILE__", -1, T_FILE, 0, -1);
4653: install ("__VERSION__", -1, T_VERSION, 0, -1);
4654: install ("__TIME__", -1, T_TIME, 0, -1);
4655: install ("__STDC__", -1, T_CONST, 1, -1);
4656: /* install ("__GNU__", -1, T_CONST, 1, -1); */
4657: /* This is supplied using a -D by the compiler driver
4658: so that it is present only when truly compiling with GNU C. */
4659: }
4660:
4661: /*
4662: * process a given definition string, for initialization
4663: * If STR is just an identifier, define it with value 1.
4664: * If STR has anything after the identifier, then it should
4665: * be identifier-space-definition.
4666: */
4667: make_definition (str)
4668: U_CHAR *str;
4669: {
4670: FILE_BUF *ip;
4671: struct directive *kt;
4672: U_CHAR *buf, *p;
4673:
4674: buf = str;
4675: p = str;
4676: while (is_idchar[*p]) p++;
4677: if (*p == 0) {
4678: buf = (U_CHAR *) alloca (p - buf + 4);
4679: strcpy (buf, str);
4680: strcat (buf, " 1");
4681: }
4682:
4683: ip = &instack[++indepth];
4684: ip->fname = "*Initialization*";
4685:
4686: ip->buf = ip->bufp = buf;
4687: ip->length = strlen (buf);
4688: ip->lineno = 1;
4689: ip->macro = 0;
4690: ip->free = 0;
4691: ip->if_stack = if_stack;
4692:
4693: for (kt = directive_table; kt->type != T_DEFINE; kt++)
4694: ;
4695:
4696: /* pass NULL as output ptr to do_define since we KNOW it never
4697: does any output.... */
4698: do_define (buf, buf + strlen (buf) , NULL, kt);
4699: --indepth;
4700: }
4701:
4702: /* JF, this does the work for the -U option */
4703: make_undef (str)
4704: U_CHAR *str;
4705: {
4706: FILE_BUF *ip;
4707: struct directive *kt;
4708:
4709: ip = &instack[++indepth];
4710: ip->fname = "*undef*";
4711:
4712: ip->buf = ip->bufp = str;
4713: ip->length = strlen (str);
4714: ip->lineno = 1;
4715: ip->macro = 0;
4716: ip->free = 0;
4717: ip->if_stack = if_stack;
4718:
4719: for (kt = directive_table; kt->type != T_UNDEF; kt++)
4720: ;
4721:
4722: do_undef (str,str + strlen (str) - 1, NULL, kt);
4723: --indepth;
4724: }
4725:
4726: /* Add output to `deps_buffer' for the -M switch.
4727: STRING points to the text to be output.
4728: SIZE is the number of bytes, or 0 meaning output until a null.
4729: If SIZE is nonzero, we break the line first, if it is long enough. */
4730:
4731: deps_output (string, size)
4732: char *string;
4733: int size;
4734: {
4735: if (size != 0 && deps_column > 50)
4736: {
4737: deps_output ("\\\n ", 0);
4738: deps_column = 0;
4739: }
4740:
4741: if (size == 0)
4742: size = strlen (string);
4743:
4744: if (deps_size + size + 1 > deps_allocated_size)
4745: {
4746: deps_allocated_size = deps_size + size + 50;
4747: deps_allocated_size *= 2;
4748: deps_buffer = (char *) xrealloc (deps_buffer, deps_allocated_size);
4749: }
4750: bcopy (string, &deps_buffer[deps_size], size);
4751: deps_size += size;
4752: deps_column += size;
4753: deps_buffer[deps_size] = 0;
4754: }
4755:
4756: #ifndef BSD
4757: #ifndef BSTRING
4758:
4759: void
4760: bzero (b, length)
4761: register char *b;
4762: register int length;
4763: {
4764: #ifdef VMS
4765: short zero = 0;
4766: long max_str = 65535;
4767:
4768: while (length > max_str)
4769: {
4770: (void) LIB$MOVC5 (&zero, &zero, &zero, &max_str, b);
4771: length -= max_str;
4772: b += max_str;
4773: }
4774: (void) LIB$MOVC5 (&zero, &zero, &zero, &length, b);
4775: #else
4776: while (length-- > 0)
4777: *b++ = 0;
4778: #endif /* not VMS */
4779: }
4780:
4781: void
4782: bcopy (b1, b2, length)
4783: register char *b1;
4784: register char *b2;
4785: register int length;
4786: {
4787: #ifdef VMS
4788: long max_str = 65535;
4789:
4790: while (length > max_str)
4791: {
4792: (void) LIB$MOVC3 (&max_str, b1, b2);
4793: length -= max_str;
4794: b1 += max_str;
4795: b2 += max_str;
4796: }
4797: (void) LIB$MOVC3 (&length, b1, b2);
4798: #else
4799: while (length-- > 0)
4800: *b2++ = *b1++;
4801: #endif /* not VMS */
4802: }
4803:
4804: int
4805: bcmp (b1, b2, length) /* This could be a macro! */
4806: register char *b1;
4807: register char *b2;
4808: register int length;
4809: {
4810: #ifdef VMS
4811: struct dsc$descriptor_s src1 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b1};
4812: struct dsc$descriptor_s src2 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b2};
4813:
4814: return STR$COMPARE (&src1, &src2);
4815: #else
4816: while (length-- > 0)
4817: if (*b1++ != *b2++)
4818: return 1;
4819:
4820: return 0;
4821: #endif /* not VMS */
4822: }
4823: #endif /* not BSTRING */
4824: #endif /* not BSD */
4825:
4826:
4827: void
4828: fatal (str, arg)
4829: char *str, *arg;
4830: {
4831: fprintf (stderr, "%s: ", progname);
4832: fprintf (stderr, str, arg);
4833: fprintf (stderr, "\n");
4834: exit (FATAL_EXIT_CODE);
4835: }
4836:
4837: void
4838: perror_with_name (name)
4839: char *name;
4840: {
4841: extern int errno, sys_nerr;
4842: extern char *sys_errlist[];
4843:
4844: fprintf (stderr, "%s: ", progname);
4845: if (errno < sys_nerr)
4846: fprintf (stderr, "%s for `%s'\n", sys_errlist[errno], name);
4847: else
4848: fprintf (stderr, "cannot open `%s'\n", sys_errlist[errno], name);
4849: }
4850:
4851: void
4852: pfatal_with_name (name)
4853: char *name;
4854: {
4855: perror_with_name (name);
4856: exit (FATAL_EXIT_CODE);
4857: }
4858:
4859:
4860: void
4861: memory_full ()
4862: {
4863: fatal ("Memory exhausted.");
4864: }
4865:
4866:
4867: char *
4868: xmalloc (size)
4869: int size;
4870: {
4871: extern char *malloc ();
4872: register char *ptr = malloc (size);
4873: if (ptr != 0) return (ptr);
4874: memory_full ();
4875: /*NOTREACHED*/
4876: }
4877:
4878: char *
4879: xrealloc (old, size)
4880: char *old;
4881: int size;
4882: {
4883: extern char *realloc ();
4884: register char *ptr = realloc (old, size);
4885: if (ptr != 0) return (ptr);
4886: memory_full ();
4887: /*NOTREACHED*/
4888: }
4889:
4890: char *
4891: xcalloc (number, size)
4892: int number, size;
4893: {
4894: extern char *malloc ();
4895: register int total = number * size;
4896: register char *ptr = malloc (total);
4897: if (ptr != 0)
4898: {
4899: if (total > 100)
4900: bzero (ptr, total);
4901: else {
4902: /* It's not too long, so loop, zeroing by longs.
4903: It must be safe because malloc values are always well aligned. */
4904: register long *zp = (long *) ptr;
4905: register long *zl = (long *) (ptr + total - 4);
4906: register int i = total - 4;
4907: while (zp < zl)
4908: *zp++ = 0;
4909: if (i < 0)
4910: i = 0;
4911: while (i < total)
4912: ptr[i++] = 0;
4913: }
4914: return ptr;
4915: }
4916: memory_full ();
4917: /*NOTREACHED*/
4918: }
4919:
4920:
4921: /* Get the file-mode and data size of the file open on FD
4922: and store them in *MODE_POINTER and *SIZE_POINTER. */
4923:
4924: int
4925: file_size_and_mode (fd, mode_pointer, size_pointer)
4926: int fd;
4927: int *mode_pointer;
4928: long int *size_pointer;
4929: {
4930: struct stat sbuf;
4931:
4932: if (fstat (fd, &sbuf) < 0) return (-1);
4933: #ifdef VMS
4934: #ifdef __GNUC__
4935: #ifdef stat_alignment_fix
4936: /* Fix the size data in the stat buffer (this is temporary!) */
4937: sbuf.st_size = (stat_alignment_fix(&(sbuf))->st_size);
4938: #endif stat_alignment_fix
4939: #endif __GNUC__
4940: #endif VMS
4941: if (mode_pointer) *mode_pointer = sbuf.st_mode;
4942: if (size_pointer) *size_pointer = sbuf.st_size;
4943: return 0;
4944: }
4945:
4946: #ifdef VMS
4947:
4948: /* Under VMS we need to fix up the "include" specification
4949: filename so that everything following the 1st slash is
4950: changed into its correct VMS file specification. */
4951:
4952: hack_vms_include_specification (fname)
4953: char *fname;
4954: {
4955: register char *cp, *cp1, *cp2;
4956: char Local[512];
4957: extern char *index (), *rindex ();
4958:
4959: /* Ignore leading "./"s */
4960: while (fname[0] == '.' && fname[1] == '/')
4961: strcpy (fname, fname+2);
4962: /* Look for the boundary between the VMS and UNIX filespecs */
4963: cp = rindex (fname, ']'); /* Look for end of dirspec. */
4964: if (cp == 0) cp == rindex (fname, '>'); /* ... Ditto */
4965: if (cp == 0) cp == rindex (fname, ':'); /* Look for end of devspec. */
4966: if (cp) {
4967: cp++;
4968: } else {
4969: cp = index (fname, '/'); /* Look for the "/" */
4970: }
4971: /* See if we found that 1st slash */
4972: if (cp == 0) return; /* Nothing to do!!! */
4973: if (*cp != '/') return; /* Nothing to do!!! */
4974: /* Point to the UNIX filename part (which needs to be fixed!) */
4975: cp1 = cp+1;
4976: /* If the directory spec is not rooted, we can just copy
4977: the UNIX filename part and we are done */
4978: if (((cp - fname) > 2)
4979: && ((cp[-1] == ']') || (cp[-1] == '>'))
4980: && (cp[-2] != '.')) {
4981: strcpy (cp, cp1);
4982: return;
4983: }
4984: /* If there are no other slashes then the filename will be
4985: in the "root" directory. Otherwise, we need to add
4986: directory specifications. */
4987: if (index (cp1, '/') == 0) {
4988: /* Just add "[000000]" as the directory string */
4989: strcpy (Local, "[000000]");
4990: cp2 = Local + strlen (Local);
4991: } else {
4992: /* Open the directory specification */
4993: cp2 = Local;
4994: *cp2++ = '[';
4995: /* As long as there are still subdirectories to add, do them. */
4996: while (index (cp1, '/') != 0) {
4997: /* If this token is "." we can ignore it */
4998: if ((cp1[0] == '.') && (cp1[1] == '/')) {
4999: cp1 += 2;
5000: continue;
5001: }
5002: /* Add a subdirectory spec. */
5003: if (cp2 != Local+1) *cp2++ = '.';
5004: /* If this is ".." then the spec becomes "-" */
5005: if ((cp1[0] == '.') && (cp1[1] == '.') && (cp[2] == '/')) {
5006: /* Add "-" and skip the ".." */
5007: *cp2++ = '-';
5008: cp1 += 3;
5009: continue;
5010: }
5011: /* Copy the subdirectory */
5012: while (*cp1 != '/') *cp2++= *cp1++;
5013: cp1++; /* Skip the "/" */
5014: }
5015: /* Close the directory specification */
5016: *cp2++ = ']';
5017: }
5018: /* Now add the filename */
5019: while (*cp1) *cp2++ = *cp1++;
5020: *cp2 = 0;
5021: /* Now append it to the original VMS spec. */
5022: strcpy (cp, Local);
5023: return;
5024: }
5025: #endif /* VMS */
5026:
5027: #ifdef VMS
5028:
5029: /* These are the read/write replacement routines for
5030: VAX-11 "C". They make read/write behave enough
5031: like their UNIX counterparts that CCCP will work */
5032:
5033: int
5034: read (fd, buf, size)
5035: int fd;
5036: char *buf;
5037: int size;
5038: {
5039: #undef read /* Get back the REAL read routine */
5040: register int i;
5041: register int total = 0;
5042:
5043: /* Read until the buffer is exhausted */
5044: while (size > 0) {
5045: /* Limit each read to 32KB */
5046: i = (size > (32*1024)) ? (32*1024) : size;
5047: i = read (fd, buf, i);
5048: if (i <= 0) {
5049: if (i == 0) return (total);
5050: return(i);
5051: }
5052: /* Account for this read */
5053: total += i;
5054: buf += i;
5055: size -= i;
5056: }
5057: return (total);
5058: }
5059:
5060: int
5061: write (fd, buf, size)
5062: int fd;
5063: char *buf;
5064: int size;
5065: {
5066: #undef write /* Get back the REAL write routine */
5067: int i;
5068: int j;
5069:
5070: /* Limit individual writes to 32Kb */
5071: i = size;
5072: while (i > 0) {
5073: j = (i > (32*1024)) ? (32*1024) : i;
5074: if (write (fd, buf, j) < 0) return (-1);
5075: /* Account for the data written */
5076: buf += j;
5077: i -= j;
5078: }
5079: return (size);
5080: }
5081:
5082: #endif /* VMS */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.