![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cpplib.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to cpplib.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* CPP Library.
2: Copyright (C) 1986, 87, 89, 92, 93, 94, 1995 Free Software Foundation, Inc.
3: Written by Per Bothner, 1994-95.
4: Based on CCCP program by by Paul Rubin, June 1986
5: Adapted to ANSI C, Richard Stallman, Jan 1987
6:
7: This program is free software; you can redistribute it and/or modify it
8: under the terms of the GNU General Public License as published by the
9: Free Software Foundation; either version 2, or (at your option) any
10: later version.
11:
12: This program is distributed in the hope that it will be useful,
13: but WITHOUT ANY WARRANTY; without even the implied warranty of
14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: GNU General Public License for more details.
16:
17: You should have received a copy of the GNU General Public License
18: along with this program; if not, write to the Free Software
19: Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20:
21: In other words, you are welcome to use, share and improve this program.
22: You are forbidden to forbid anyone else to use, share and improve
23: what you give them. Help stamp out software-hoarding! */
24:
25: #ifdef EMACS
26: #define NO_SHORTNAMES
27: #include "../src/config.h"
28: #ifdef open
29: #undef open
30: #undef read
31: #undef write
32: #endif /* open */
33: #endif /* EMACS */
34:
35: /* The macro EMACS is defined when cpp is distributed as part of Emacs,
36: for the sake of machines with limited C compilers. */
37: #ifndef EMACS
38: #include "config.h"
39: #endif /* not EMACS */
40:
41: #ifndef STANDARD_INCLUDE_DIR
42: #define STANDARD_INCLUDE_DIR "/usr/include"
43: #endif
44:
45: #ifndef LOCAL_INCLUDE_DIR
46: #define LOCAL_INCLUDE_DIR "/usr/local/include"
47: #endif
48:
49: #if 0 /* We can't get ptrdiff_t, so I arranged not to need PTR_INT_TYPE. */
50: #ifdef __STDC__
51: #define PTR_INT_TYPE ptrdiff_t
52: #else
53: #define PTR_INT_TYPE long
54: #endif
55: #endif /* 0 */
56:
57: #include "cpplib.h"
58: #include "cpphash.h"
59:
60: #ifndef STDC_VALUE
61: #define STDC_VALUE 1
62: #endif
63:
64: /* By default, colon separates directories in a path. */
65: #ifndef PATH_SEPARATOR
66: #define PATH_SEPARATOR ':'
67: #endif
68:
69: #include <ctype.h>
70: #include <stdio.h>
71: #include <signal.h>
72: #ifdef __STDC__
73: #include <stdlib.h>
74: #endif
75:
76: #ifndef VMS
77: #ifndef USG
78: #include <sys/time.h> /* for __DATE__ and __TIME__ */
79: #include <sys/resource.h>
80: #else
81: #include <sys/param.h> /* CYGNUS LOCAL: shebs -noquiet */
82: #include <sys/times.h>
83: #include <time.h>
84: #include <fcntl.h>
85: #endif /* USG */
86: #endif /* not VMS */
87:
88: /* This defines "errno" properly for VMS, and gives us EACCES. */
89: #include <errno.h>
90:
91: extern char *index ();
92: extern char *rindex ();
93:
94: #ifndef O_RDONLY
95: #define O_RDONLY 0
96: #endif
97:
98: #undef MIN
99: #undef MAX
100: #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
101: #define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
102:
103: /* Find the largest host integer type and set its size and type. */
104:
105: #ifndef HOST_BITS_PER_WIDE_INT
106:
107: #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
108: #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
109: #define HOST_WIDE_INT long
110: #else
111: #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
112: #define HOST_WIDE_INT int
113: #endif
114:
115: #endif
116:
117: #ifndef S_ISREG
118: #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
119: #endif
120:
121: #ifndef S_ISDIR
122: #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
123: #endif
124:
125: /* Define a generic NULL if one hasn't already been defined. */
126:
127: #ifndef NULL
128: #define NULL 0
129: #endif
130:
131: #ifndef GENERIC_PTR
132: #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
133: #define GENERIC_PTR void *
134: #else
135: #define GENERIC_PTR char *
136: #endif
137: #endif
138:
139: #ifndef NULL_PTR
140: #define NULL_PTR ((GENERIC_PTR)0)
141: #endif
142:
143: #ifndef INCLUDE_LEN_FUDGE
144: #define INCLUDE_LEN_FUDGE 0
145: #endif
146:
147: /* Symbols to predefine. */
148:
149: #ifdef CPP_PREDEFINES
150: static char *predefs = CPP_PREDEFINES;
151: #else
152: static char *predefs = "";
153: #endif
154:
155: /* We let tm.h override the types used here, to handle trivial differences
156: such as the choice of unsigned int or long unsigned int for size_t.
157: When machines start needing nontrivial differences in the size type,
158: it would be best to do something here to figure out automatically
159: from other information what type to use. */
160:
161: /* The string value for __SIZE_TYPE__. */
162:
163: #ifndef SIZE_TYPE
164: #define SIZE_TYPE "long unsigned int"
165: #endif
166:
167: /* The string value for __PTRDIFF_TYPE__. */
168:
169: #ifndef PTRDIFF_TYPE
170: #define PTRDIFF_TYPE "long int"
171: #endif
172:
173: /* The string value for __WCHAR_TYPE__. */
174:
175: #ifndef WCHAR_TYPE
176: #define WCHAR_TYPE "int"
177: #endif
178: #define CPP_WCHAR_TYPE(PFILE) \
179: (CPP_OPTIONS (PFILE)->cplusplus ? "__wchar_t" : WCHAR_TYPE)
180:
181: /* The string value for __USER_LABEL_PREFIX__ */
182:
183: #ifndef USER_LABEL_PREFIX
184: #define USER_LABEL_PREFIX ""
185: #endif
186:
187: /* The string value for __REGISTER_PREFIX__ */
188:
189: #ifndef REGISTER_PREFIX
190: #define REGISTER_PREFIX ""
191: #endif
192:
193: /* In the definition of a #assert name, this structure forms
194: a list of the individual values asserted.
195: Each value is itself a list of "tokens".
196: These are strings that are compared by name. */
197:
198: struct tokenlist_list {
199: struct tokenlist_list *next;
200: struct arglist *tokens;
201: };
202:
203: struct assertion_hashnode {
204: struct assertion_hashnode *next; /* double links for easy deletion */
205: struct assertion_hashnode *prev;
206: /* also, a back pointer to this node's hash
207: chain is kept, in case the node is the head
208: of the chain and gets deleted. */
209: struct assertion_hashnode **bucket_hdr;
210: int length; /* length of token, for quick comparison */
211: U_CHAR *name; /* the actual name */
212: /* List of token-sequences. */
213: struct tokenlist_list *value;
214: };
215:
216: #define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
217: #define SKIP_ALL_WHITE_SPACE(p) do { while (is_space[*p]) p++; } while (0)
218:
219: #define PEEKN(N) (CPP_BUFFER (pfile)->rlimit - CPP_BUFFER (pfile)->cur >= (N) ? CPP_BUFFER (pfile)->cur[N] : EOF)
220: #define FORWARD(N) CPP_FORWARD (CPP_BUFFER (pfile), (N))
221: #define GETC() CPP_BUF_GET (CPP_BUFFER (pfile))
222: #define PEEKC() CPP_BUF_PEEK (CPP_BUFFER (pfile))
223: /* CPP_IS_MACRO_BUFFER is true if the buffer contains macro expansion.
224: (Note that it is false while we're expanding marco *arguments*.) */
225: #define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->cleanup == macro_cleanup)
226:
227: /* Move all backslash-newline pairs out of embarrassing places.
228: Exchange all such pairs following BP
229: with any potentially-embarrassing characters that follow them.
230: Potentially-embarrassing characters are / and *
231: (because a backslash-newline inside a comment delimiter
232: would cause it not to be recognized). */
233:
234: #define NEWLINE_FIX \
235: do {while (PEEKC() == '\\' && PEEKN(1) == '\n') FORWARD(2); } while(0)
236:
237: /* Same, but assume we've already read the potential '\\' into C. */
238: #define NEWLINE_FIX1(C) do { \
239: while ((C) == '\\' && PEEKC() == '\n') { FORWARD(1); (C) = GETC(); }\
240: } while(0)
241:
242: struct cpp_pending {
243: struct cpp_pending *next;
244: char *cmd;
245: char *arg;
246: };
247:
248: /* Forward declarations. */
249:
250: extern char *xmalloc ();
251:
252: static void add_import ();
253: static void append_include_chain ();
254: static void make_undef ();
255: static void make_assertion ();
256: static void path_include ();
257: static void initialize_builtins ();
258: static void initialize_char_syntax ();
259: static void dump_arg_n ();
260: static void dump_defn_1 ();
261: extern void delete_macro ();
262: static void trigraph_pcp ();
263: static int finclude ();
264: static void validate_else ();
265: static int comp_def_part ();
266: extern void fancy_abort ();
267: static void pipe_closed ();
268: static void print_containing_files ();
269: static int lookup_import ();
270: static int redundant_include_p ();
271: static is_system_include ();
272: static struct file_name_map *read_name_map ();
273: static char *read_filename_string ();
274: static int open_include_file ();
275: static int check_preconditions ();
276: static void pcfinclude ();
277: static void pcstring_used ();
278: static int check_macro_name ();
279: static int compare_defs ();
280: static int compare_token_lists ();
281: static HOST_WIDE_INT eval_if_expression ();
282: static int change_newlines ();
283: extern int hashf ();
284: static int file_size_and_mode ();
285: static struct arglist *read_token_list ();
286: static void free_token_list ();
287: static int safe_read ();
288: static void push_macro_expansion PARAMS ((cpp_reader *,
289: U_CHAR*, int, HASHNODE*));
290: static struct cpp_pending *nreverse_pending PARAMS ((struct cpp_pending*));
291: extern char *xrealloc ();
292: extern char *xcalloc ();
293: static char *savestring ();
294:
295: static void conditional_skip ();
296: static void skip_if_group ();
297:
298: /* Last arg to output_line_command. */
299: enum file_change_code {same_file, enter_file, leave_file};
300:
301: /* External declarations. */
302:
303: extern HOST_WIDE_INT cpp_parse_expr PARAMS ((cpp_reader*));
304:
305: extern char *getenv ();
306: extern FILE *fdopen ();
307: extern char *version_string;
308: extern struct tm *localtime ();
309:
310: /* These functions are declared to return int instead of void since they
311: are going to be placed in a table and some old compilers have trouble with
312: pointers to functions returning void. */
313:
314: static int do_define ();
315: static int do_line ();
316: static int do_include ();
317: static int do_undef ();
318: static int do_error ();
319: static int do_pragma ();
320: static int do_ident ();
321: static int do_if ();
322: static int do_xifdef ();
323: static int do_else ();
324: static int do_elif ();
325: static int do_endif ();
326: static int do_sccs ();
327: static int do_once ();
328: static int do_assert ();
329: static int do_unassert ();
330: static int do_warning ();
331:
332: struct file_name_list
333: {
334: struct file_name_list *next;
335: char *fname;
336: /* If the following is nonzero, it is a macro name.
337: Don't include the file again if that macro is defined. */
338: U_CHAR *control_macro;
339: /* If the following is nonzero, it is a C-language system include
340: directory. */
341: int c_system_include_path;
342: /* Mapping of file names for this directory. */
343: struct file_name_map *name_map;
344: /* Non-zero if name_map is valid. */
345: int got_name_map;
346: };
347:
348: /* If a buffer's dir field is SELF_DIR_DUMMY, it means the file was found
349: via the same directory as the file that #included it. */
350: #define SELF_DIR_DUMMY ((struct file_name_list*)(~0))
351:
352: /* #include "file" looks in source file dir, then stack. */
353: /* #include <file> just looks in the stack. */
354: /* -I directories are added to the end, then the defaults are added. */
355: /* The */
356: static struct default_include {
357: char *fname; /* The name of the directory. */
358: int cplusplus; /* Only look here if we're compiling C++. */
359: int cxx_aware; /* Includes in this directory don't need to
360: be wrapped in extern "C" when compiling
361: C++. */
362: } include_defaults_array[]
363: #ifdef INCLUDE_DEFAULTS
364: = INCLUDE_DEFAULTS;
365: #else
366: = {
367: /* Pick up GNU C++ specific include files. */
368: { GPLUSPLUS_INCLUDE_DIR, 1, 1 },
369: #ifdef CROSS_COMPILE
370: /* This is the dir for fixincludes. Put it just before
371: the files that we fix. */
372: { GCC_INCLUDE_DIR, 0, 0 },
373: /* For cross-compilation, this dir name is generated
374: automatically in Makefile.in. */
375: { CROSS_INCLUDE_DIR, 0, 0 },
376: /* This is another place that the target system's headers might be. */
377: { TOOL_INCLUDE_DIR, 0, 1 },
378: #else /* not CROSS_COMPILE */
379: /* This should be /usr/local/include and should come before
380: the fixincludes-fixed header files. */
381: { LOCAL_INCLUDE_DIR, 0, 1 },
382: /* This is here ahead of GCC_INCLUDE_DIR because assert.h goes here.
383: Likewise, behind LOCAL_INCLUDE_DIR, where glibc puts its assert.h. */
384: { TOOL_INCLUDE_DIR, 0, 1 },
385: /* This is the dir for fixincludes. Put it just before
386: the files that we fix. */
387: { GCC_INCLUDE_DIR, 0, 0 },
388: /* Some systems have an extra dir of include files. */
389: #ifdef SYSTEM_INCLUDE_DIR
390: { SYSTEM_INCLUDE_DIR, 0, 0 },
391: #endif
392: { STANDARD_INCLUDE_DIR, 0, 0 },
393: #endif /* not CROSS_COMPILE */
394: { 0, 0, 0 }
395: };
396: #endif /* no INCLUDE_DEFAULTS */
397:
398: /* `struct directive' defines one #-directive, including how to handle it. */
399:
400: struct directive {
401: int length; /* Length of name */
402: int (*func)(); /* Function to handle directive */
403: char *name; /* Name of directive */
404: enum node_type type; /* Code which describes which directive. */
405: char command_reads_line; /* One if rest of line is read by func. */
406: char traditional_comments; /* Nonzero: keep comments if -traditional. */
407: char pass_thru; /* Copy preprocessed directive to output file.*/
408: };
409:
410: /* Here is the actual list of #-directives, most-often-used first.
411: The initialize_builtins function assumes #define is the very first. */
412:
413: static struct directive directive_table[] = {
414: { 6, do_define, "define", T_DEFINE, 0, 1},
415: { 5, do_xifdef, "ifdef", T_IFDEF, 1},
416: { 6, do_xifdef, "ifndef", T_IFNDEF, 1},
417: { 7, do_include, "include", T_INCLUDE, 1},
418: { 12, do_include, "include_next", T_INCLUDE_NEXT, 1},
419: { 6, do_include, "import", T_IMPORT, 1},
420: { 5, do_endif, "endif", T_ENDIF, 1},
421: { 4, do_else, "else", T_ELSE, 1},
422: { 2, do_if, "if", T_IF, 1},
423: { 4, do_elif, "elif", T_ELIF, 1},
424: { 5, do_undef, "undef", T_UNDEF},
425: { 5, do_error, "error", T_ERROR},
426: { 7, do_warning, "warning", T_WARNING},
427: { 6, do_pragma, "pragma", T_PRAGMA, 0, 0, 1},
428: { 4, do_line, "line", T_LINE, 1},
429: { 5, do_ident, "ident", T_IDENT, 1, 0, 1},
430: #ifdef SCCS_DIRECTIVE
431: { 4, do_sccs, "sccs", T_SCCS},
432: #endif
433: { 6, do_assert, "assert", T_ASSERT, 1},
434: { 8, do_unassert, "unassert", T_UNASSERT, 1},
435: { -1, 0, "", T_UNUSED},
436: };
437:
438: /* table to tell if char can be part of a C identifier. */
439: U_CHAR is_idchar[256];
440: /* table to tell if char can be first char of a c identifier. */
441: U_CHAR is_idstart[256];
442: /* table to tell if c is horizontal space. */
443: U_CHAR is_hor_space[256];
444: /* table to tell if c is horizontal or vertical space. */
445: static U_CHAR is_space[256];
446:
447: /* Initialize syntactic classifications of characters. */
448:
449: static void
450: initialize_char_syntax (opts)
451: struct cpp_options *opts;
452: {
453: register int i;
454:
455: /*
456: * Set up is_idchar and is_idstart tables. These should be
457: * faster than saying (is_alpha (c) || c == '_'), etc.
458: * Set up these things before calling any routines tthat
459: * refer to them.
460: */
461: for (i = 'a'; i <= 'z'; i++) {
462: is_idchar[i - 'a' + 'A'] = 1;
463: is_idchar[i] = 1;
464: is_idstart[i - 'a' + 'A'] = 1;
465: is_idstart[i] = 1;
466: }
467: for (i = '0'; i <= '9'; i++)
468: is_idchar[i] = 1;
469: is_idchar['_'] = 1;
470: is_idstart['_'] = 1;
471: is_idchar['$'] = opts->dollars_in_ident;
472: is_idstart['$'] = opts->dollars_in_ident;
473:
474: /* horizontal space table */
475: is_hor_space[' '] = 1;
476: is_hor_space['\t'] = 1;
477: is_hor_space['\v'] = 1;
478: is_hor_space['\f'] = 1;
479: is_hor_space['\r'] = 1;
480:
481: is_space[' '] = 1;
482: is_space['\t'] = 1;
483: is_space['\v'] = 1;
484: is_space['\f'] = 1;
485: is_space['\n'] = 1;
486: is_space['\r'] = 1;
487: }
488:
489:
490: /* Place into PFILE a quoted string representing the string SRC.
491: Caller must reserve enough space in pfile->token_buffer. */
492: static void
493: quote_string (pfile, src)
494: cpp_reader *pfile;
495: char *src;
496: {
497: U_CHAR c;
498:
499: CPP_PUTC_Q (pfile, '\"');
500: for (;;)
501: switch ((c = *src++))
502: {
503: default:
504: if (isprint (c))
505: CPP_PUTC_Q (pfile, c);
506: else
507: {
508: sprintf (CPP_PWRITTEN (pfile), "\\%03o", c);
509: CPP_ADJUST_WRITTEN (pfile, 4);
510: }
511: break;
512:
513: case '\"':
514: case '\\':
515: CPP_PUTC_Q (pfile, '\\');
516: CPP_PUTC_Q (pfile, c);
517: break;
518:
519: case '\0':
520: CPP_PUTC_Q (pfile, '\"');
521: CPP_NUL_TERMINATE_Q (pfile);
522: return;
523: }
524: }
525:
526: /* Make sure PFILE->token_buffer will hold at least N more chars. */
527:
528: void
529: cpp_grow_buffer (pfile, n)
530: cpp_reader *pfile;
531: long n;
532: {
533: long old_written = CPP_WRITTEN (pfile);
534: pfile->token_buffer_size = n + 2 * pfile->token_buffer_size;
535: pfile->token_buffer = (U_CHAR*)
536: xrealloc(pfile->token_buffer, pfile->token_buffer_size);
537: CPP_SET_WRITTEN (pfile, old_written);
538: }
539:
540:
541: /*
542: * process a given definition string, for initialization
543: * If STR is just an identifier, define it with value 1.
544: * If STR has anything after the identifier, then it should
545: * be identifier=definition.
546: */
547:
548: void
549: cpp_define (pfile, str)
550: cpp_reader *pfile;
551: U_CHAR *str;
552: {
553: U_CHAR *buf, *p;
554:
555: buf = str;
556: p = str;
557: if (!is_idstart[*p])
558: {
559: cpp_error (pfile, "malformed option `-D %s'", str);
560: return;
561: }
562: while (is_idchar[*++p])
563: ;
564: if (*p == 0)
565: {
566: buf = (U_CHAR *) alloca (p - buf + 4);
567: strcpy ((char *)buf, str);
568: strcat ((char *)buf, " 1");
569: }
570: else if (*p != '=')
571: {
572: cpp_error (pfile, "malformed option `-D %s'", str);
573: return;
574: }
575: else
576: {
577: U_CHAR *q;
578: /* Copy the entire option so we can modify it. */
579: buf = (U_CHAR *) alloca (2 * strlen (str) + 1);
580: strncpy (buf, str, p - str);
581: /* Change the = to a space. */
582: buf[p - str] = ' ';
583: /* Scan for any backslash-newline and remove it. */
584: p++;
585: q = &buf[p - str];
586: while (*p)
587: {
588: if (*p == '\\' && p[1] == '\n')
589: p += 2;
590: else
591: *q++ = *p++;
592: }
593: *q = 0;
594: }
595:
596: do_define (pfile, NULL, buf, buf + strlen (buf));
597: }
598:
599: /* Process the string STR as if it appeared as the body of a #assert.
600: OPTION is the option name for which STR was the argument. */
601:
602: static void
603: make_assertion (pfile, option, str)
604: cpp_reader *pfile;
605: char *option;
606: U_CHAR *str;
607: {
608: cpp_buffer *ip;
609: struct directive *kt;
610: U_CHAR *buf, *p, *q;
611:
612: /* Copy the entire option so we can modify it. */
613: buf = (U_CHAR *) alloca (strlen (str) + 1);
614: strcpy ((char *) buf, str);
615: /* Scan for any backslash-newline and remove it. */
616: p = q = buf;
617: while (*p) {
618: #if 0
619: if (*p == '\\' && p[1] == '\n')
620: p += 2;
621: else
622: #endif
623: *q++ = *p++;
624: }
625: *q = 0;
626:
627: p = buf;
628: if (!is_idstart[*p]) {
629: cpp_error (pfile, "malformed option `%s %s'", option, str);
630: return;
631: }
632: while (is_idchar[*++p])
633: ;
634: while (*p == ' ' || *p == '\t') p++;
635: if (! (*p == 0 || *p == '(')) {
636: cpp_error (pfile, "malformed option `%s %s'", option, str);
637: return;
638: }
639:
640: ip = cpp_push_buffer (pfile, buf, strlen (buf));
641: do_assert (pfile, NULL, NULL, NULL);
642: cpp_pop_buffer (pfile);
643: }
644:
645: /* Append a chain of `struct file_name_list's
646: to the end of the main include chain.
647: FIRST is the beginning of the chain to append, and LAST is the end. */
648:
649: static void
650: append_include_chain (pfile, first, last)
651: cpp_reader *pfile;
652: struct file_name_list *first, *last;
653: {
654: struct cpp_options *opts = CPP_OPTIONS (pfile);
655: struct file_name_list *dir;
656:
657: if (!first || !last)
658: return;
659:
660: if (opts->include == 0)
661: opts->include = first;
662: else
663: opts->last_include->next = first;
664:
665: if (opts->first_bracket_include == 0)
666: opts->first_bracket_include = first;
667:
668: for (dir = first; ; dir = dir->next) {
669: int len = strlen (dir->fname) + INCLUDE_LEN_FUDGE;
670: if (len > pfile->max_include_len)
671: pfile->max_include_len = len;
672: if (dir == last)
673: break;
674: }
675:
676: last->next = NULL;
677: opts->last_include = last;
678: }
679:
680: /* Add output to `deps_buffer' for the -M switch.
681: STRING points to the text to be output.
682: SPACER is ':' for targets, ' ' for dependencies, zero for text
683: to be inserted literally. */
684:
685: static void
686: deps_output (pfile, string, spacer)
687: cpp_reader *pfile;
688: char *string;
689: int spacer;
690: {
691: int size = strlen (string);
692:
693: if (size == 0)
694: return;
695:
696: #ifndef MAX_OUTPUT_COLUMNS
697: #define MAX_OUTPUT_COLUMNS 72
698: #endif
699: if (spacer
700: && pfile->deps_column > 0
701: && (pfile->deps_column + size) > MAX_OUTPUT_COLUMNS)
702: {
703: deps_output (pfile, " \\\n ", 0);
704: pfile->deps_column = 0;
705: }
706:
707: if (pfile->deps_size + size + 8 > pfile->deps_allocated_size)
708: {
709: pfile->deps_allocated_size = (pfile->deps_size + size + 50) * 2;
710: pfile->deps_buffer = (char *) xrealloc (pfile->deps_buffer,
711: pfile->deps_allocated_size);
712: }
713: if (spacer == ' ' && pfile->deps_column > 0)
714: pfile->deps_buffer[pfile->deps_size++] = ' ';
715: bcopy (string, &pfile->deps_buffer[pfile->deps_size], size);
716: pfile->deps_size += size;
717: pfile->deps_column += size;
718: if (spacer == ':')
719: pfile->deps_buffer[pfile->deps_size++] = ':';
720: pfile->deps_buffer[pfile->deps_size] = 0;
721: }
722:
723: /* Given a colon-separated list of file names PATH,
724: add all the names to the search path for include files. */
725:
726: static void
727: path_include (pfile, path)
728: cpp_reader *pfile;
729: char *path;
730: {
731: char *p;
732:
733: p = path;
734:
735: if (*p)
736: while (1) {
737: char *q = p;
738: char *name;
739: struct file_name_list *dirtmp;
740:
741: /* Find the end of this name. */
742: while (*q != 0 && *q != PATH_SEPARATOR) q++;
743: if (p == q) {
744: /* An empty name in the path stands for the current directory. */
745: name = (char *) xmalloc (2);
746: name[0] = '.';
747: name[1] = 0;
748: } else {
749: /* Otherwise use the directory that is named. */
750: name = (char *) xmalloc (q - p + 1);
751: bcopy (p, name, q - p);
752: name[q - p] = 0;
753: }
754:
755: dirtmp = (struct file_name_list *)
756: xmalloc (sizeof (struct file_name_list));
757: dirtmp->next = 0; /* New one goes on the end */
758: dirtmp->control_macro = 0;
759: dirtmp->c_system_include_path = 0;
760: dirtmp->fname = name;
761: dirtmp->got_name_map = 0;
762: append_include_chain (pfile, dirtmp, dirtmp);
763:
764: /* Advance past this name. */
765: p = q;
766: if (*p == 0)
767: break;
768: /* Skip the colon. */
769: p++;
770: }
771: }
772:
773: void
774: init_parse_options (opts)
775: struct cpp_options *opts;
776: {
777: bzero ((char *) opts, sizeof *opts);
778: opts->in_fname = NULL;
779: opts->out_fname = NULL;
780:
781: /* Initialize is_idchar to allow $. */
782: opts->dollars_in_ident = 1;
783: initialize_char_syntax (opts);
784: opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS > 0;
785:
786: opts->no_line_commands = 0;
787: opts->no_trigraphs = 1;
788: opts->put_out_comments = 0;
789: opts->print_include_names = 0;
790: opts->dump_macros = dump_none;
791: opts->no_output = 0;
792: opts->cplusplus = 0;
793: opts->cplusplus_comments = 0;
794:
795: opts->verbose = 0;
796: opts->objc = 0;
797: opts->lang_asm = 0;
798: opts->for_lint = 0;
799: opts->chill = 0;
800: opts->pedantic_errors = 0;
801: opts->inhibit_warnings = 0;
802: opts->warn_comments = 0;
803: opts->warn_import = 1;
804: opts->warnings_are_errors = 0;
805: }
806:
807: enum cpp_token
808: null_underflow (pfile)
809: cpp_reader *pfile;
810: {
811: return CPP_EOF;
812: }
813:
814: int
815: null_cleanup (pbuf, pfile)
816: cpp_buffer *pbuf;
817: cpp_reader *pfile;
818: {
819: return 0;
820: }
821:
822: int
823: macro_cleanup (pbuf, pfile)
824: cpp_buffer *pbuf;
825: cpp_reader *pfile;
826: {
827: HASHNODE *macro = (HASHNODE*)pbuf->data;
828: if (macro->type == T_DISABLED)
829: macro->type = T_MACRO;
830: if (macro->type != T_MACRO || pbuf->buf != macro->value.defn->expansion)
831: free (pbuf->buf);
832: return 0;
833: }
834:
835: int
836: file_cleanup (pbuf, pfile)
837: cpp_buffer *pbuf;
838: cpp_reader *pfile;
839: {
840: if (pbuf->buf)
841: {
842: free (pbuf->buf);
843: pbuf->buf = 0;
844: }
845: return 0;
846: }
847:
848: static void
849: newline_fix (pfile)
850: cpp_reader *pfile;
851: {
852: #if 1
853: NEWLINE_FIX;
854: #else
855: register U_CHAR *p = bp;
856:
857: /* First count the backslash-newline pairs here. */
858:
859: while (p[0] == '\\' && p[1] == '\n')
860: p += 2;
861:
862: /* What follows the backslash-newlines is not embarrassing. */
863:
864: if (*p != '/' && *p != '*')
865: return;
866:
867: /* Copy all potentially embarrassing characters
868: that follow the backslash-newline pairs
869: down to where the pairs originally started. */
870:
871: while (*p == '*' || *p == '/')
872: *bp++ = *p++;
873:
874: /* Now write the same number of pairs after the embarrassing chars. */
875: while (bp < p) {
876: *bp++ = '\\';
877: *bp++ = '\n';
878: }
879: #endif
880: }
881:
882: /* Assuming we have read '/'.
883: If this is the start of a comment (followed by '*' or '/'),
884: skip to the end of the comment, and return ' '.
885: Return EOF if we reached the end of file before the end of the comment.
886: If not the start of a comment, return '/'. */
887:
888: static int
889: skip_comment (pfile, linep)
890: cpp_reader *pfile;
891: long *linep;
892: {
893: int c;
894: while (PEEKC() == '\\' && PEEKN(1) == '\n')
895: {
896: if (linep)
897: (*linep)++;
898: FORWARD(2);
899: }
900: if (PEEKC() == '*')
901: {
902: FORWARD(1);
903: for (;;)
904: {
905: int prev_c = c;
906: c = GETC ();
907: if (c == EOF)
908: return EOF;
909: while (c == '\\' && PEEKC() == '\n')
910: {
911: if (linep)
912: (*linep)++;
913: FORWARD(1), c = GETC();
914: }
915: if (prev_c == '*' && c == '/')
916: return ' ';
917: if (c == '\n' && linep)
918: (*linep)++;
919: }
920: }
921: else if (PEEKC() == '/' && CPP_OPTIONS (pfile)->cplusplus_comments)
922: {
923: FORWARD(1);
924: for (;;)
925: {
926: c = GETC ();
927: if (c == EOF)
928: return ' '; /* Allow // to be terminated by EOF. */
929: while (c == '\\' && PEEKC() == '\n')
930: {
931: FORWARD(1);
932: c = GETC();
933: if (linep)
934: (*linep)++;
935: }
936: if (c == '\n')
937: {
938: /* Don't consider final '\n' to be part of comment. */
939: FORWARD(-1);
940: return ' ';
941: }
942: }
943: }
944: else
945: return '/';
946: }
947:
948: /* Skip whitespace \-newline and comments. Does not macro-expand. */
949: void
950: cpp_skip_hspace (pfile)
951: cpp_reader *pfile;
952: {
953: while (1)
954: {
955: int c = PEEKC();
956: if (c == EOF)
957: return; /* FIXME */
958: if (is_hor_space[c])
959: {
960: if ((c == '\f' || c == '\v') && CPP_PEDANTIC (pfile))
961: cpp_pedwarn (pfile, "%s in preprocessing directive",
962: c == '\f' ? "formfeed" : "vertical tab");
963: FORWARD(1);
964: }
965: else if (c == '/')
966: {
967: FORWARD (1);
968: c = skip_comment (pfile, NULL);
969: if (c == '/')
970: FORWARD(-1);
971: if (c == EOF || c == '/')
972: return;
973: }
974: else if (c == '\\' && PEEKN(1) == '\n') {
975: FORWARD(2);
976: }
977: else if (c == '@' && CPP_BUFFER (pfile)->has_escapes
978: && is_hor_space[PEEKN(1)])
979: FORWARD(2);
980: else return;
981: }
982: }
983:
984: /* Read the rest of the current line.
985: The line is appended to PFILE's output buffer. */
986:
987: void
988: copy_rest_of_line (pfile)
989: cpp_reader *pfile;
990: {
991: struct cpp_options *opts = CPP_OPTIONS (pfile);
992: for (;;)
993: {
994: int c = GETC();
995: int nextc;
996: switch (c)
997: {
998: case EOF:
999: goto end_directive;
1000: case '\\':
1001: if (PEEKC() == '\n')
1002: {
1003: FORWARD (1);
1004: continue;
1005: }
1006: case '\'':
1007: case '\"':
1008: goto scan_directive_token;
1009: break;
1010: case '/':
1011: nextc = PEEKC();
1012: if (nextc == '*' || (opts->cplusplus_comments && nextc == '*'))
1013: goto scan_directive_token;
1014: break;
1015: case '\f':
1016: case '\v':
1017: if (CPP_PEDANTIC (pfile))
1018: cpp_pedwarn (pfile, "%s in preprocessing directive",
1019: c == '\f' ? "formfeed" : "vertical tab");
1020: break;
1021:
1022: case '\n':
1023: FORWARD(-1);
1024: goto end_directive;
1025: scan_directive_token:
1026: FORWARD(-1);
1027: cpp_get_token (pfile);
1028: continue;
1029: }
1030: CPP_PUTC (pfile, c);
1031: }
1032: end_directive: ;
1033: CPP_NUL_TERMINATE (pfile);
1034: }
1035:
1036: void
1037: skip_rest_of_line (pfile)
1038: cpp_reader *pfile;
1039: {
1040: long old = CPP_WRITTEN (pfile);
1041: copy_rest_of_line (pfile);
1042: CPP_SET_WRITTEN (pfile, old);
1043: }
1044:
1045: /* Handle a possible # directive.
1046: '#' has already been read. */
1047:
1048: int
1049: handle_directive (pfile)
1050: cpp_reader *pfile;
1051: { int c;
1052: register struct directive *kt;
1053: int ident_length;
1054: long after_ident;
1055: U_CHAR *ident, *line_end;
1056: long old_written = CPP_WRITTEN (pfile);
1057:
1058: cpp_skip_hspace (pfile);
1059:
1060: c = PEEKC ();
1061: if (c >= '0' && c <= '9')
1062: {
1063: /* Handle # followed by a line number. */
1064: if (CPP_PEDANTIC (pfile))
1065: cpp_pedwarn (pfile, "`#' followed by integer");
1066: do_line (pfile, NULL);
1067: goto done_a_directive;
1068: }
1069:
1070: /* Now find the directive name. */
1071: CPP_PUTC (pfile, '#');
1072: parse_name (pfile, GETC());
1073: ident = pfile->token_buffer + old_written + 1;
1074: ident_length = CPP_PWRITTEN (pfile) - ident;
1075: if (ident_length == 0 && PEEKC() == '\n')
1076: {
1077: /* A line of just `#' becomes blank. */
1078: goto done_a_directive;
1079: }
1080:
1081: #if 0
1082: if (ident_length == 0 || !is_idstart[*ident]) {
1083: U_CHAR *p = ident;
1084: while (is_idchar[*p]) {
1085: if (*p < '0' || *p > '9')
1086: break;
1087: p++;
1088: }
1089: /* Avoid error for `###' and similar cases unless -pedantic. */
1090: if (p == ident) {
1091: while (*p == '#' || is_hor_space[*p]) p++;
1092: if (*p == '\n') {
1093: if (pedantic && !lang_asm)
1094: cpp_warning (pfile, "invalid preprocessor directive");
1095: return 0;
1096: }
1097: }
1098:
1099: if (!lang_asm)
1100: cpp_error (pfile, "invalid preprocessor directive name");
1101:
1102: return 0;
1103: }
1104: #endif
1105: /*
1106: * Decode the keyword and call the appropriate expansion
1107: * routine, after moving the input pointer up to the next line.
1108: */
1109: for (kt = directive_table; ; kt++) {
1110: if (kt->length <= 0)
1111: goto not_a_directive;
1112: if (kt->length == ident_length && !strncmp (kt->name, ident, ident_length))
1113: break;
1114: }
1115:
1116: if (! kt->command_reads_line)
1117: {
1118: /* Nonzero means do not delete comments within the directive.
1119: #define needs this when -traditional. */
1120: int comments = CPP_TRADITIONAL (pfile) && kt->traditional_comments;
1121: int save_put_out_comments = CPP_OPTIONS (pfile)->put_out_comments;
1122: CPP_OPTIONS (pfile)->put_out_comments = comments;
1123: after_ident = CPP_WRITTEN (pfile);
1124: copy_rest_of_line (pfile);
1125: CPP_OPTIONS (pfile)->put_out_comments = save_put_out_comments;
1126: }
1127:
1128: /* For #pragma and #define, we may want to pass through the directive.
1129: Other directives may create output, but we don't want the directive
1130: itself out, so we pop it now. For example #include may write a #line
1131: command (see comment in do_include), and conditionals may emit
1132: #failed ... #endfailed stuff. But note that popping the buffer
1133: means the parameters to kt->func may point after pfile->limit
1134: so these parameters are invalid as soon as something gets appended
1135: to the token_buffer. */
1136:
1137: line_end = CPP_PWRITTEN (pfile);
1138: if (!kt->pass_thru && kt->type != T_DEFINE)
1139: CPP_SET_WRITTEN (pfile, old_written);
1140:
1141: (*kt->func) (pfile, kt, pfile->token_buffer + after_ident, line_end);
1142: if (kt->pass_thru
1143: || (kt->type == T_DEFINE
1144: && CPP_OPTIONS (pfile)->dump_macros == dump_definitions))
1145: {
1146: /* Just leave the entire #define in the output stack. */
1147: }
1148: else if (kt->type == T_DEFINE
1149: && CPP_OPTIONS (pfile)->dump_macros == dump_names)
1150: {
1151: U_CHAR *p = pfile->token_buffer + old_written + 7; /* Skip "#define". */
1152: SKIP_WHITE_SPACE (p);
1153: while (is_idchar[*p]) p++;
1154: pfile->limit = p;
1155: CPP_PUTC (pfile, '\n');
1156: }
1157: else if (kt->type == T_DEFINE)
1158: CPP_SET_WRITTEN (pfile, old_written);
1159: done_a_directive:
1160: return 1;
1161:
1162: not_a_directive:
1163: return 0;
1164: }
1165:
1166: /* Pass a directive through to the output file.
1167: BUF points to the contents of the directive, as a contiguous string.
1168: LIMIT points to the first character past the end of the directive.
1169: KEYWORD is the keyword-table entry for the directive. */
1170:
1171: static void
1172: pass_thru_directive (buf, limit, pfile, keyword)
1173: U_CHAR *buf, *limit;
1174: cpp_reader *pfile;
1175: struct directive *keyword;
1176: {
1177: register unsigned keyword_length = keyword->length;
1178:
1179: CPP_RESERVE (pfile, 1 + keyword_length + (limit - buf));
1180: CPP_PUTC_Q (pfile, '#');
1181: CPP_PUTS_Q (pfile, keyword->name, keyword_length);
1182: if (limit != buf && buf[0] != ' ')
1183: CPP_PUTC_Q (pfile, ' ');
1184: CPP_PUTS_Q (pfile, buf, limit - buf);
1185: #if 0
1186: CPP_PUTS_Q (pfile, '\n');
1187: /* Count the line we have just made in the output,
1188: to get in sync properly. */
1189: pfile->lineno++;
1190: #endif
1191: }
1192:
1193: /* The arglist structure is built by do_define to tell
1194: collect_definition where the argument names begin. That
1195: is, for a define like "#define f(x,y,z) foo+x-bar*y", the arglist
1196: would contain pointers to the strings x, y, and z.
1197: Collect_definition would then build a DEFINITION node,
1198: with reflist nodes pointing to the places x, y, and z had
1199: appeared. So the arglist is just convenience data passed
1200: between these two routines. It is not kept around after
1201: the current #define has been processed and entered into the
1202: hash table. */
1203:
1204: struct arglist {
1205: struct arglist *next;
1206: U_CHAR *name;
1207: int length;
1208: int argno;
1209: char rest_args;
1210: };
1211:
1212: /* Read a replacement list for a macro with parameters.
1213: Build the DEFINITION structure.
1214: Reads characters of text starting at BUF until END.
1215: ARGLIST specifies the formal parameters to look for
1216: in the text of the definition; NARGS is the number of args
1217: in that list, or -1 for a macro name that wants no argument list.
1218: MACRONAME is the macro name itself (so we can avoid recursive expansion)
1219: and NAMELEN is its length in characters.
1220:
1221: Note that comments, backslash-newlines, and leading white space
1222: have already been deleted from the argument. */
1223:
1224: static DEFINITION *
1225: collect_expansion (pfile, buf, limit, nargs, arglist)
1226: cpp_reader *pfile;
1227: U_CHAR *buf, *limit;
1228: int nargs;
1229: struct arglist *arglist;
1230: {
1231: DEFINITION *defn;
1232: register U_CHAR *p, *lastp, *exp_p;
1233: struct reflist *endpat = NULL;
1234: /* Pointer to first nonspace after last ## seen. */
1235: U_CHAR *concat = 0;
1236: /* Pointer to first nonspace after last single-# seen. */
1237: U_CHAR *stringify = 0;
1238: int maxsize;
1239: int expected_delimiter = '\0';
1240:
1241: /* Scan thru the replacement list, ignoring comments and quoted
1242: strings, picking up on the macro calls. It does a linear search
1243: thru the arg list on every potential symbol. Profiling might say
1244: that something smarter should happen. */
1245:
1246: if (limit < buf)
1247: abort ();
1248:
1249: /* Find the beginning of the trailing whitespace. */
1250: p = buf;
1251: while (p < limit && is_space[limit[-1]]) limit--;
1252:
1253: /* Allocate space for the text in the macro definition.
1254: Leading and trailing whitespace chars need 2 bytes each.
1255: Each other input char may or may not need 1 byte,
1256: so this is an upper bound. The extra 5 are for invented
1257: leading and trailing newline-marker and final null. */
1258: maxsize = (sizeof (DEFINITION)
1259: + (limit - p) + 5);
1260: /* Occurrences of '@' get doubled, so allocate extra space for them. */
1261: while (p < limit)
1262: if (*p++ == '@')
1263: maxsize++;
1264: defn = (DEFINITION *) xcalloc (1, maxsize);
1265:
1266: defn->nargs = nargs;
1267: exp_p = defn->expansion = (U_CHAR *) defn + sizeof (DEFINITION);
1268: lastp = exp_p;
1269:
1270: p = buf;
1271:
1272: /* Add one initial space escape-marker to prevent accidental
1273: token-pasting (often removed by macroexpand). */
1274: *exp_p++ = '@';
1275: *exp_p++ = ' ';
1276:
1277: if (limit - p >= 2 && p[0] == '#' && p[1] == '#') {
1278: cpp_error (pfile, "`##' at start of macro definition");
1279: p += 2;
1280: }
1281:
1282: /* Process the main body of the definition. */
1283: while (p < limit) {
1284: int skipped_arg = 0;
1285: register U_CHAR c = *p++;
1286:
1287: *exp_p++ = c;
1288:
1289: if (!CPP_TRADITIONAL (pfile)) {
1290: switch (c) {
1291: case '\'':
1292: case '\"':
1293: if (expected_delimiter != '\0') {
1294: if (c == expected_delimiter)
1295: expected_delimiter = '\0';
1296: } else
1297: expected_delimiter = c;
1298: break;
1299:
1300: case '\\':
1301: if (p < limit && expected_delimiter) {
1302: /* In a string, backslash goes through
1303: and makes next char ordinary. */
1304: *exp_p++ = *p++;
1305: }
1306: break;
1307:
1308: case '@':
1309: /* An '@' in a string or character constant stands for itself,
1310: and does not need to be escaped. */
1311: if (!expected_delimiter)
1312: *exp_p++ = c;
1313: break;
1314:
1315: case '#':
1316: /* # is ordinary inside a string. */
1317: if (expected_delimiter)
1318: break;
1319: if (p < limit && *p == '#') {
1320: /* ##: concatenate preceding and following tokens. */
1321: /* Take out the first #, discard preceding whitespace. */
1322: exp_p--;
1323: while (exp_p > lastp && is_hor_space[exp_p[-1]])
1324: --exp_p;
1325: /* Skip the second #. */
1326: p++;
1327: /* Discard following whitespace. */
1328: SKIP_WHITE_SPACE (p);
1329: concat = p;
1330: if (p == limit)
1331: cpp_error (pfile, "`##' at end of macro definition");
1332: } else if (nargs >= 0) {
1333: /* Single #: stringify following argument ref.
1334: Don't leave the # in the expansion. */
1335: exp_p--;
1336: SKIP_WHITE_SPACE (p);
1337: if (p == limit || ! is_idstart[*p])
1338: cpp_error (pfile,
1339: "`#' operator is not followed by a macro argument name");
1340: else
1341: stringify = p;
1342: }
1343: break;
1344: }
1345: } else {
1346: /* In -traditional mode, recognize arguments inside strings and
1347: and character constants, and ignore special properties of #.
1348: Arguments inside strings are considered "stringified", but no
1349: extra quote marks are supplied. */
1350: switch (c) {
1351: case '\'':
1352: case '\"':
1353: if (expected_delimiter != '\0') {
1354: if (c == expected_delimiter)
1355: expected_delimiter = '\0';
1356: } else
1357: expected_delimiter = c;
1358: break;
1359:
1360: case '\\':
1361: /* Backslash quotes delimiters and itself, but not macro args. */
1362: if (expected_delimiter != 0 && p < limit
1363: && (*p == expected_delimiter || *p == '\\')) {
1364: *exp_p++ = *p++;
1365: continue;
1366: }
1367: break;
1368:
1369: case '/':
1370: if (expected_delimiter != '\0') /* No comments inside strings. */
1371: break;
1372: if (*p == '*') {
1373: /* If we find a comment that wasn't removed by handle_directive,
1374: this must be -traditional. So replace the comment with
1375: nothing at all. */
1376: exp_p--;
1377: p += 1;
1378: while (p < limit && !(p[-2] == '*' && p[-1] == '/'))
1379: p++;
1380: #if 0
1381: /* Mark this as a concatenation-point, as if it had been ##. */
1382: concat = p;
1383: #endif
1384: }
1385: break;
1386: }
1387: }
1388:
1389: /* Handle the start of a symbol. */
1390: if (is_idchar[c] && nargs > 0) {
1391: U_CHAR *id_beg = p - 1;
1392: int id_len;
1393:
1394: --exp_p;
1395: while (p != limit && is_idchar[*p]) p++;
1396: id_len = p - id_beg;
1397:
1398: if (is_idstart[c]) {
1399: register struct arglist *arg;
1400:
1401: for (arg = arglist; arg != NULL; arg = arg->next) {
1402: struct reflist *tpat;
1403:
1404: if (arg->name[0] == c
1405: && arg->length == id_len
1406: && strncmp (arg->name, id_beg, id_len) == 0) {
1407: if (expected_delimiter && CPP_OPTIONS (pfile)->warn_stringify) {
1408: if (CPP_TRADITIONAL (pfile)) {
1409: cpp_warning (pfile, "macro argument `%.*s' is stringified.",
1410: id_len, arg->name);
1411: } else {
1412: cpp_warning (pfile,
1413: "macro arg `%.*s' would be stringified with -traditional.",
1414: id_len, arg->name);
1415: }
1416: }
1417: /* If ANSI, don't actually substitute inside a string. */
1418: if (!CPP_TRADITIONAL (pfile) && expected_delimiter)
1419: break;
1420: /* make a pat node for this arg and append it to the end of
1421: the pat list */
1422: tpat = (struct reflist *) xmalloc (sizeof (struct reflist));
1423: tpat->next = NULL;
1424: tpat->raw_before = concat == id_beg;
1425: tpat->raw_after = 0;
1426: tpat->rest_args = arg->rest_args;
1427: tpat->stringify = (CPP_TRADITIONAL (pfile)
1428: ? expected_delimiter != '\0'
1429: : stringify == id_beg);
1430:
1431: if (endpat == NULL)
1432: defn->pattern = tpat;
1433: else
1434: endpat->next = tpat;
1435: endpat = tpat;
1436:
1437: tpat->argno = arg->argno;
1438: tpat->nchars = exp_p - lastp;
1439: {
1440: register U_CHAR *p1 = p;
1441: SKIP_WHITE_SPACE (p1);
1442: if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
1443: tpat->raw_after = 1;
1444: }
1445: lastp = exp_p; /* place to start copying from next time */
1446: skipped_arg = 1;
1447: break;
1448: }
1449: }
1450: }
1451:
1452: /* If this was not a macro arg, copy it into the expansion. */
1453: if (! skipped_arg) {
1454: register U_CHAR *lim1 = p;
1455: p = id_beg;
1456: while (p != lim1)
1457: *exp_p++ = *p++;
1458: if (stringify == id_beg)
1459: cpp_error (pfile,
1460: "`#' operator should be followed by a macro argument name");
1461: }
1462: }
1463: }
1464:
1465: if (!CPP_TRADITIONAL (pfile) && expected_delimiter == 0)
1466: {
1467: /* If ANSI, put in a "@ " marker to prevent token pasting.
1468: But not if "inside a string" (which in ANSI mode
1469: happens only for -D option). */
1470: *exp_p++ = '@';
1471: *exp_p++ = ' ';
1472: }
1473:
1474: *exp_p = '\0';
1475:
1476: defn->length = exp_p - defn->expansion;
1477:
1478: /* Crash now if we overrun the allocated size. */
1479: if (defn->length + 1 > maxsize)
1480: abort ();
1481:
1482: #if 0
1483: /* This isn't worth the time it takes. */
1484: /* give back excess storage */
1485: defn->expansion = (U_CHAR *) xrealloc (defn->expansion, defn->length + 1);
1486: #endif
1487:
1488: return defn;
1489: }
1490:
1491: /*
1492: * special extension string that can be added to the last macro argument to
1493: * allow it to absorb the "rest" of the arguments when expanded. Ex:
1494: * #define wow(a, b...) process (b, a, b)
1495: * { wow (1, 2, 3); } -> { process (2, 3, 1, 2, 3); }
1496: * { wow (one, two); } -> { process (two, one, two); }
1497: * if this "rest_arg" is used with the concat token '##' and if it is not
1498: * supplied then the token attached to with ## will not be outputted. Ex:
1499: * #define wow (a, b...) process (b ## , a, ## b)
1500: * { wow (1, 2); } -> { process (2, 1, 2); }
1501: * { wow (one); } -> { process (one); {
1502: */
1503: static char rest_extension[] = "...";
1504: #define REST_EXTENSION_LENGTH (sizeof (rest_extension) - 1)
1505:
1506: /* Create a DEFINITION node from a #define directive. Arguments are
1507: as for do_define. */
1508: static MACRODEF
1509: create_definition (buf, limit, pfile, predefinition)
1510: U_CHAR *buf, *limit;
1511: cpp_reader *pfile;
1512: int predefinition;
1513: {
1514: U_CHAR *bp; /* temp ptr into input buffer */
1515: U_CHAR *symname; /* remember where symbol name starts */
1516: int sym_length; /* and how long it is */
1517: int rest_args = 0;
1518: long line, col;
1519: char *file = CPP_BUFFER (pfile) ? CPP_BUFFER (pfile)->nominal_fname : "";
1520: DEFINITION *defn;
1521: int arglengths = 0; /* Accumulate lengths of arg names
1522: plus number of args. */
1523: MACRODEF mdef;
1524: cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
1525:
1526: bp = buf;
1527:
1528: while (is_hor_space[*bp])
1529: bp++;
1530:
1531: symname = bp; /* remember where it starts */
1532:
1533: sym_length = check_macro_name (pfile, bp, "macro");
1534: bp += sym_length;
1535:
1536: /* Lossage will occur if identifiers or control keywords are broken
1537: across lines using backslash. This is not the right place to take
1538: care of that. */
1539:
1540: if (*bp == '(') {
1541: struct arglist *arg_ptrs = NULL;
1542: int argno = 0;
1543:
1544: bp++; /* skip '(' */
1545: SKIP_WHITE_SPACE (bp);
1546:
1547: /* Loop over macro argument names. */
1548: while (*bp != ')') {
1549: struct arglist *temp;
1550:
1551: temp = (struct arglist *) alloca (sizeof (struct arglist));
1552: temp->name = bp;
1553: temp->next = arg_ptrs;
1554: temp->argno = argno++;
1555: temp->rest_args = 0;
1556: arg_ptrs = temp;
1557:
1558: if (rest_args)
1559: cpp_pedwarn (pfile, "another parameter follows `%s'", rest_extension);
1560:
1561: if (!is_idstart[*bp])
1562: cpp_pedwarn (pfile, "invalid character in macro parameter name");
1563:
1564: /* Find the end of the arg name. */
1565: while (is_idchar[*bp]) {
1566: bp++;
1567: /* do we have a "special" rest-args extension here? */
1568: if (limit - bp > REST_EXTENSION_LENGTH &&
1569: strncmp (rest_extension, bp, REST_EXTENSION_LENGTH) == 0) {
1570: rest_args = 1;
1571: temp->rest_args = 1;
1572: break;
1573: }
1574: }
1575: temp->length = bp - temp->name;
1576: if (rest_args == 1)
1577: bp += REST_EXTENSION_LENGTH;
1578: arglengths += temp->length + 2;
1579: SKIP_WHITE_SPACE (bp);
1580: if (temp->length == 0 || (*bp != ',' && *bp != ')')) {
1581: cpp_error (pfile, "badly punctuated parameter list in `#define'");
1582: goto nope;
1583: }
1584: if (*bp == ',') {
1585: bp++;
1586: SKIP_WHITE_SPACE (bp);
1587: }
1588: if (bp >= limit) {
1589: cpp_error (pfile, "unterminated parameter list in `#define'");
1590: goto nope;
1591: }
1592: {
1593: struct arglist *otemp;
1594:
1595: for (otemp = temp->next; otemp != NULL; otemp = otemp->next)
1596: if (temp->length == otemp->length &&
1597: strncmp (temp->name, otemp->name, temp->length) == 0) {
1598: U_CHAR *name;
1599:
1600: name = (U_CHAR *) alloca (temp->length + 1);
1601: (void) strncpy (name, temp->name, temp->length);
1602: name[temp->length] = '\0';
1603: cpp_error (pfile,
1604: "duplicate argument name `%s' in `#define'", name);
1605: goto nope;
1606: }
1607: }
1608: }
1609:
1610: ++bp; /* skip paren */
1611: SKIP_WHITE_SPACE (bp);
1612: /* now everything from bp before limit is the definition. */
1613: defn = collect_expansion (pfile, bp, limit, argno, arg_ptrs);
1614: defn->rest_args = rest_args;
1615:
1616: /* Now set defn->args.argnames to the result of concatenating
1617: the argument names in reverse order
1618: with comma-space between them. */
1619: defn->args.argnames = (U_CHAR *) xmalloc (arglengths + 1);
1620: {
1621: struct arglist *temp;
1622: int i = 0;
1623: for (temp = arg_ptrs; temp; temp = temp->next) {
1624: bcopy (temp->name, &defn->args.argnames[i], temp->length);
1625: i += temp->length;
1626: if (temp->next != 0) {
1627: defn->args.argnames[i++] = ',';
1628: defn->args.argnames[i++] = ' ';
1629: }
1630: }
1631: defn->args.argnames[i] = 0;
1632: }
1633: } else {
1634: /* Simple expansion or empty definition. */
1635:
1636: if (bp < limit)
1637: {
1638: if (is_hor_space[*bp]) {
1639: bp++;
1640: SKIP_WHITE_SPACE (bp);
1641: } else {
1642: switch (*bp) {
1643: case '!': case '"': case '#': case '%': case '&': case '\'':
1644: case ')': case '*': case '+': case ',': case '-': case '.':
1645: case '/': case ':': case ';': case '<': case '=': case '>':
1646: case '?': case '[': case '\\': case ']': case '^': case '{':
1647: case '|': case '}': case '~':
1648: cpp_warning (pfile, "missing white space after `#define %.*s'",
1649: sym_length, symname);
1650: break;
1651:
1652: default:
1653: cpp_pedwarn (pfile, "missing white space after `#define %.*s'",
1654: sym_length, symname);
1655: break;
1656: }
1657: }
1658: }
1659: /* now everything from bp before limit is the definition. */
1660: defn = collect_expansion (pfile, bp, limit, -1, NULL_PTR);
1661: defn->args.argnames = (U_CHAR *) "";
1662: }
1663:
1664: defn->line = line;
1665: defn->file = file;
1666:
1667: /* OP is null if this is a predefinition */
1668: defn->predefined = predefinition;
1669: mdef.defn = defn;
1670: mdef.symnam = symname;
1671: mdef.symlen = sym_length;
1672:
1673: return mdef;
1674:
1675: nope:
1676: mdef.defn = 0;
1677: return mdef;
1678: }
1679:
1680: /* Check a purported macro name SYMNAME, and yield its length.
1681: USAGE is the kind of name this is intended for. */
1682:
1683: static int
1684: check_macro_name (pfile, symname, usage)
1685: cpp_reader *pfile;
1686: U_CHAR *symname;
1687: char *usage;
1688: {
1689: U_CHAR *p;
1690: int sym_length;
1691:
1692: for (p = symname; is_idchar[*p]; p++)
1693: ;
1694: sym_length = p - symname;
1695: if (sym_length == 0)
1696: cpp_error (pfile, "invalid %s name", usage);
1697: else if (!is_idstart[*symname]) {
1698: U_CHAR *msg; /* what pain... */
1699: msg = (U_CHAR *) alloca (sym_length + 1);
1700: bcopy (symname, msg, sym_length);
1701: msg[sym_length] = 0;
1702: cpp_error (pfile, "invalid %s name `%s'", usage, msg);
1703: } else {
1704: if (! strncmp (symname, "defined", 7) && sym_length == 7)
1705: cpp_error (pfile, "invalid %s name `defined'", usage);
1706: }
1707: return sym_length;
1708: }
1709:
1710: /*
1711: * return zero if two DEFINITIONs are isomorphic
1712: */
1713: static int
1714: compare_defs (d1, d2)
1715: DEFINITION *d1, *d2;
1716: {
1717: register struct reflist *a1, *a2;
1718: register U_CHAR *p1 = d1->expansion;
1719: register U_CHAR *p2 = d2->expansion;
1720: int first = 1;
1721:
1722: if (d1->nargs != d2->nargs)
1723: return 1;
1724: if (strcmp ((char *)d1->args.argnames, (char *)d2->args.argnames))
1725: return 1;
1726: for (a1 = d1->pattern, a2 = d2->pattern; a1 && a2;
1727: a1 = a1->next, a2 = a2->next) {
1728: if (!((a1->nchars == a2->nchars && ! strncmp (p1, p2, a1->nchars))
1729: || ! comp_def_part (first, p1, a1->nchars, p2, a2->nchars, 0))
1730: || a1->argno != a2->argno
1731: || a1->stringify != a2->stringify
1732: || a1->raw_before != a2->raw_before
1733: || a1->raw_after != a2->raw_after)
1734: return 1;
1735: first = 0;
1736: p1 += a1->nchars;
1737: p2 += a2->nchars;
1738: }
1739: if (a1 != a2)
1740: return 1;
1741: if (comp_def_part (first, p1, d1->length - (p1 - d1->expansion),
1742: p2, d2->length - (p2 - d2->expansion), 1))
1743: return 1;
1744: return 0;
1745: }
1746:
1747: /* Return 1 if two parts of two macro definitions are effectively different.
1748: One of the parts starts at BEG1 and has LEN1 chars;
1749: the other has LEN2 chars at BEG2.
1750: Any sequence of whitespace matches any other sequence of whitespace.
1751: FIRST means these parts are the first of a macro definition;
1752: so ignore leading whitespace entirely.
1753: LAST means these parts are the last of a macro definition;
1754: so ignore trailing whitespace entirely. */
1755:
1756: static int
1757: comp_def_part (first, beg1, len1, beg2, len2, last)
1758: int first;
1759: U_CHAR *beg1, *beg2;
1760: int len1, len2;
1761: int last;
1762: {
1763: register U_CHAR *end1 = beg1 + len1;
1764: register U_CHAR *end2 = beg2 + len2;
1765: if (first) {
1766: while (beg1 != end1 && is_space[*beg1]) beg1++;
1767: while (beg2 != end2 && is_space[*beg2]) beg2++;
1768: }
1769: if (last) {
1770: while (beg1 != end1 && is_space[end1[-1]]) end1--;
1771: while (beg2 != end2 && is_space[end2[-1]]) end2--;
1772: }
1773: while (beg1 != end1 && beg2 != end2) {
1774: if (is_space[*beg1] && is_space[*beg2]) {
1775: while (beg1 != end1 && is_space[*beg1]) beg1++;
1776: while (beg2 != end2 && is_space[*beg2]) beg2++;
1777: } else if (*beg1 == *beg2) {
1778: beg1++; beg2++;
1779: } else break;
1780: }
1781: return (beg1 != end1) || (beg2 != end2);
1782: }
1783:
1784: /* Process a #define command.
1785: BUF points to the contents of the #define command, as a contiguous string.
1786: LIMIT points to the first character past the end of the definition.
1787: KEYWORD is the keyword-table entry for #define,
1788: or NULL for a "predefined" macro. */
1789:
1790: static int
1791: do_define (pfile, keyword, buf, limit)
1792: cpp_reader *pfile;
1793: struct directive *keyword;
1794: U_CHAR *buf, *limit;
1795: {
1796: int hashcode;
1797: MACRODEF mdef;
1798: HASHNODE *hp;
1799:
1800: #if 0
1801: /* If this is a precompiler run (with -pcp) pass thru #define commands. */
1802: if (pcp_outfile && keyword)
1803: pass_thru_directive (buf, limit, pfile, keyword);
1804: #endif
1805:
1806: mdef = create_definition (buf, limit, pfile, keyword == NULL);
1807: if (mdef.defn == 0)
1808: goto nope;
1809:
1810: hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE);
1811:
1812: if ((hp = cpp_lookup (pfile, mdef.symnam, mdef.symlen, hashcode)) != NULL)
1813: {
1814: int ok = 0;
1815: /* Redefining a precompiled key is ok. */
1816: if (hp->type == T_PCSTRING)
1817: ok = 1;
1818: /* Redefining a macro is ok if the definitions are the same. */
1819: else if (hp->type == T_MACRO)
1820: ok = ! compare_defs (mdef.defn, hp->value.defn);
1821: /* Redefining a constant is ok with -D. */
1822: else if (hp->type == T_CONST)
1823: ok = ! CPP_OPTIONS (pfile)->done_initializing;
1824: /* Print the warning if it's not ok. */
1825: if (!ok)
1826: {
1827: U_CHAR *msg; /* what pain... */
1828:
1829: /* If we are passing through #define and #undef directives, do
1830: that for this re-definition now. */
1831: if (CPP_OPTIONS (pfile)->debug_output && keyword)
1832: pass_thru_directive (buf, limit, pfile, keyword);
1833:
1834: msg = (U_CHAR *) alloca (mdef.symlen + 22);
1835: *msg = '`';
1836: bcopy (mdef.symnam, msg + 1, mdef.symlen);
1837: strcpy ((char *) (msg + mdef.symlen + 1), "' redefined");
1838: cpp_pedwarn (pfile, msg);
1839: if (hp->type == T_MACRO)
1840: cpp_pedwarn_with_file_and_line (pfile, hp->value.defn->file, hp->value.defn->line,
1841: "this is the location of the previous definition");
1842: }
1843: /* Replace the old definition. */
1844: hp->type = T_MACRO;
1845: hp->value.defn = mdef.defn;
1846: }
1847: else
1848: {
1849: /* If we are passing through #define and #undef directives, do
1850: that for this new definition now. */
1851: if (CPP_OPTIONS (pfile)->debug_output && keyword)
1852: pass_thru_directive (buf, limit, pfile, keyword);
1853: install (mdef.symnam, mdef.symlen, T_MACRO, 0,
1854: (char *) mdef.defn, hashcode);
1855: }
1856:
1857: return 0;
1858:
1859: nope:
1860:
1861: return 1;
1862: }
1863:
1864: /* This structure represents one parsed argument in a macro call.
1865: `raw' points to the argument text as written (`raw_length' is its length).
1866: `expanded' points to the argument's macro-expansion
1867: (its length is `expand_length').
1868: `stringified_length' is the length the argument would have
1869: if stringified.
1870: `use_count' is the number of times this macro arg is substituted
1871: into the macro. If the actual use count exceeds 10,
1872: the value stored is 10. */
1873:
1874: /* raw and expanded are relative to ARG_BASE */
1875: #define ARG_BASE ((pfile)->token_buffer)
1876:
1877: struct argdata {
1878: /* Strings relative to pfile->token_buffer */
1879: long raw, expanded, stringified;
1880: int raw_length, expand_length;
1881: int stringified_length;
1882: char newlines;
1883: char use_count;
1884: };
1885:
1886:
1887: cpp_buffer*
1888: cpp_push_buffer (pfile, buffer, length)
1889: cpp_reader *pfile;
1890: U_CHAR *buffer;
1891: long length;
1892: {
1893: #ifdef STATIC_BUFFERS
1894: register cpp_buffer *buf = CPP_BUFFER (pfile);
1895: if (buf == pfile->buffer_stack)
1896: fatal ("%s: macro or `#include' recursion too deep", buf->fname);
1897: buf--;
1898: bzero ((char *) buf, sizeof (cpp_buffer));
1899: CPP_BUFFER (pfile) = buf;
1900: #else
1901: register cpp_buffer *buf = (cpp_buffer*) xmalloc (sizeof(cpp_buffer));
1902: bzero ((char *) buf, sizeof (cpp_buffer));
1903: CPP_PREV_BUFFER (buf) = CPP_BUFFER (pfile);
1904: CPP_BUFFER (pfile) = buf;
1905: #endif
1906: buf->if_stack = pfile->if_stack;
1907: buf->cleanup = null_cleanup;
1908: buf->underflow = null_underflow;
1909: buf->buf = buf->cur = buffer;
1910: buf->alimit = buf->rlimit = buffer + length;
1911:
1912: return buf;
1913: }
1914:
1915: cpp_buffer*
1916: cpp_pop_buffer (pfile)
1917: cpp_reader *pfile;
1918: {
1919: cpp_buffer *buf = CPP_BUFFER (pfile);
1920: #ifdef STATIC_BUFFERS
1921: (*buf->cleanup) (buf, pfile);
1922: return ++CPP_BUFFER (pfile);
1923: #else
1924: cpp_buffer *next_buf = CPP_PREV_BUFFER (buf);
1925: (*buf->cleanup) (buf, pfile);
1926: CPP_BUFFER (pfile) = next_buf;
1927: free (buf);
1928: return next_buf;
1929: #endif
1930: }
1931:
1932: /* Scan until CPP_BUFFER (PFILE) is exhausted into PFILE->token_buffer.
1933: Pop the buffer when done. */
1934:
1935: void
1936: cpp_scan_buffer (pfile)
1937: cpp_reader *pfile;
1938: {
1939: cpp_buffer *buffer = CPP_BUFFER (pfile);
1940: for (;;)
1941: {
1942: enum cpp_token token = cpp_get_token (pfile);
1943: if (token == CPP_EOF) /* Should not happen ... */
1944: break;
1945: if (token == CPP_POP && CPP_BUFFER (pfile) == buffer)
1946: {
1947: cpp_pop_buffer (pfile);
1948: break;
1949: }
1950: }
1951: }
1952:
1953: /*
1954: * Rescan a string (which may have escape marks) into pfile's buffer.
1955: * Place the result in pfile->token_buffer.
1956: *
1957: * The input is copied before it is scanned, so it is safe to pass
1958: * it something from the token_buffer that will get overwritten
1959: * (because it follows CPP_WRITTEN). This is used by do_include.
1960: */
1961:
1962: static void
1963: cpp_expand_to_buffer (pfile, buf, length)
1964: cpp_reader *pfile;
1965: U_CHAR *buf;
1966: int length;
1967: {
1968: register cpp_buffer *ip;
1969: cpp_buffer obuf;
1970: U_CHAR *limit = buf + length;
1971: U_CHAR *buf1;
1972: #if 0
1973: int odepth = indepth;
1974: #endif
1975:
1976: if (length < 0)
1977: abort ();
1978:
1979: /* Set up the input on the input stack. */
1980:
1981: buf1 = (U_CHAR *) alloca (length + 1);
1982: {
1983: register U_CHAR *p1 = buf;
1984: register U_CHAR *p2 = buf1;
1985:
1986: while (p1 != limit)
1987: *p2++ = *p1++;
1988: }
1989: buf1[length] = 0;
1990:
1991: ip = cpp_push_buffer (pfile, buf1, length);
1992: ip->has_escapes = 1;
1993: #if 0
1994: ip->lineno = obuf.lineno = 1;
1995: #endif
1996:
1997: /* Scan the input, create the output. */
1998: cpp_scan_buffer (pfile);
1999:
2000: #if 0
2001: if (indepth != odepth)
2002: abort ();
2003: #endif
2004:
2005: CPP_NUL_TERMINATE (pfile);
2006: }
2007:
2008:
2009: static void
2010: adjust_position (buf, limit, linep, colp)
2011: U_CHAR *buf;
2012: U_CHAR *limit;
2013: long *linep;
2014: long *colp;
2015: {
2016: while (buf < limit)
2017: {
2018: U_CHAR ch = *buf++;
2019: if (ch == '\n')
2020: (*linep)++, (*colp) = 1;
2021: else
2022: (*colp)++;
2023: }
2024: }
2025:
2026: /* Move line_base forward, updating lineno and colno. */
2027:
2028: static void
2029: update_position (pbuf)
2030: register cpp_buffer *pbuf;
2031: {
2032: unsigned char *old_pos = pbuf->buf + pbuf->line_base;
2033: unsigned char *new_pos = pbuf->cur;
2034: register struct parse_marker *mark;
2035: for (mark = pbuf->marks; mark != NULL; mark = mark->next)
2036: {
2037: if (pbuf->buf + mark->position < new_pos)
2038: new_pos = pbuf->buf + mark->position;
2039: }
2040: pbuf->line_base += new_pos - old_pos;
2041: adjust_position (old_pos, new_pos, &pbuf->lineno, &pbuf->colno);
2042: }
2043:
2044: void
2045: cpp_buf_line_and_col (pbuf, linep, colp)
2046: register cpp_buffer *pbuf;
2047: long *linep, *colp;
2048: {
2049: long dummy;
2050: if (colp == NULL)
2051: colp = &dummy;
2052: if (pbuf)
2053: {
2054: *linep = pbuf->lineno;
2055: *colp = pbuf->colno;
2056: adjust_position (pbuf->buf + pbuf->line_base, pbuf->cur, linep, colp);
2057: }
2058: else
2059: {
2060: *linep = 0;
2061: *colp = 0;
2062: }
2063: }
2064:
2065: /* Return the cpp_buffer that corresponds to a file (not a macro). */
2066:
2067: cpp_buffer*
2068: cpp_file_buffer (pfile)
2069: cpp_reader *pfile;
2070: {
2071: cpp_buffer *ip = CPP_BUFFER (pfile);
2072:
2073: for ( ; ip != CPP_NULL_BUFFER (pfile); ip = CPP_PREV_BUFFER (ip))
2074: if (ip->fname != NULL)
2075: return ip;
2076: return NULL;
2077: }
2078:
2079: static long
2080: count_newlines (buf, limit)
2081: register U_CHAR *buf;
2082: register U_CHAR *limit;
2083: {
2084: register long count = 0;
2085: while (buf < limit)
2086: {
2087: U_CHAR ch = *buf++;
2088: if (ch == '\n')
2089: count++;
2090: }
2091: return count;
2092: }
2093:
2094: /*
2095: * write out a #line command, for instance, after an #include file.
2096: * If CONDITIONAL is nonzero, we can omit the #line if it would
2097: * appear to be a no-op, and we can output a few newlines instead
2098: * if we want to increase the line number by a small amount.
2099: * FILE_CHANGE says whether we are entering a file, leaving, or neither.
2100: */
2101:
2102: static void
2103: output_line_command (pfile, conditional, file_change)
2104: cpp_reader *pfile;
2105: int conditional;
2106: enum file_change_code file_change;
2107: {
2108: int len;
2109: char *line_cmd_buf, *line_end;
2110: long line, col;
2111: cpp_buffer *ip = CPP_BUFFER (pfile);
2112:
2113: if (ip->fname == NULL || CPP_OPTIONS (pfile)->no_output) {
2114: return;
2115: }
2116:
2117: update_position (ip);
2118: line = CPP_BUFFER (pfile)->lineno;
2119: col = CPP_BUFFER (pfile)->colno;
2120: adjust_position (CPP_LINE_BASE (ip), ip->cur, &line, &col);
2121:
2122: if (CPP_OPTIONS (pfile)->no_line_commands)
2123: return;
2124:
2125: if (conditional) {
2126: if (line == pfile->lineno)
2127: return;
2128:
2129: /* If the inherited line number is a little too small,
2130: output some newlines instead of a #line command. */
2131: if (line > pfile->lineno && line < pfile->lineno + 8) {
2132: CPP_RESERVE (pfile, 20);
2133: while (line > pfile->lineno) {
2134: CPP_PUTC_Q (pfile, '\n');
2135: pfile->lineno++;
2136: }
2137: return;
2138: }
2139: }
2140:
2141: #if 0
2142: /* Don't output a line number of 0 if we can help it. */
2143: if (ip->lineno == 0 && ip->bufp - ip->buf < ip->length
2144: && *ip->bufp == '\n') {
2145: ip->lineno++;
2146: ip->bufp++;
2147: }
2148: #endif
2149:
2150: CPP_RESERVE (pfile, 4 * strlen (ip->nominal_fname) + 50);
2151: {
2152: #ifdef OUTPUT_LINE_COMMANDS
2153: static char sharp_line[] = "#line ";
2154: #else
2155: static char sharp_line[] = "# ";
2156: #endif
2157: CPP_PUTS_Q (pfile, sharp_line, sizeof(sharp_line)-1);
2158: }
2159:
2160: sprintf (CPP_PWRITTEN (pfile), "%d ", line);
2161: CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
2162:
2163: quote_string (pfile, ip->nominal_fname);
2164: if (file_change != same_file) {
2165: CPP_PUTC_Q (pfile, ' ');
2166: CPP_PUTC_Q (pfile, file_change == enter_file ? '1' : '2');
2167: }
2168: /* Tell cc1 if following text comes from a system header file. */
2169: if (ip->system_header_p) {
2170: CPP_PUTC_Q (pfile, ' ');
2171: CPP_PUTC_Q (pfile, '3');
2172: }
2173: #ifndef NO_IMPLICIT_EXTERN_C
2174: /* Tell cc1plus if following text should be treated as C. */
2175: if (ip->system_header_p == 2 && CPP_OPTIONS (pfile)->cplusplus) {
2176: CPP_PUTC_Q (pfile, ' ');
2177: CPP_PUTC_Q (pfile, '4');
2178: }
2179: #endif
2180: CPP_PUTC_Q (pfile, '\n');
2181: pfile->lineno = line;
2182: }
2183:
2184: /*
2185: * Parse a macro argument and append the info on PFILE's token_buffer.
2186: * REST_ARGS means to absorb the rest of the args.
2187: * Return nonzero to indicate a syntax error.
2188: */
2189:
2190: static enum cpp_token
2191: macarg (pfile, rest_args)
2192: cpp_reader *pfile;
2193: int rest_args;
2194: {
2195: int paren = 0;
2196: enum cpp_token token;
2197: long arg_start = CPP_WRITTEN (pfile);
2198: char save_put_out_comments = CPP_OPTIONS (pfile)->put_out_comments;
2199: CPP_OPTIONS (pfile)->put_out_comments = 0;
2200:
2201: /* Try to parse as much of the argument as exists at this
2202: input stack level. */
2203: pfile->no_macro_expand++;
2204: for (;;)
2205: {
2206: token = cpp_get_token (pfile);
2207: switch (token)
2208: {
2209: case CPP_EOF:
2210: goto done;
2211: case CPP_POP:
2212: /* If we've hit end of file, it's an error (reported by caller).
2213: Ditto if it's the end of cpp_expand_to_buffer text.
2214: If we've hit end of macro, just continue. */
2215: if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
2216: goto done;
2217: break;
2218: case CPP_LPAREN:
2219: paren++;
2220: break;
2221: case CPP_RPAREN:
2222: if (--paren < 0)
2223: goto found;
2224: break;
2225: case CPP_COMMA:
2226: /* if we've returned to lowest level and
2227: we aren't absorbing all args */
2228: if (paren == 0 && rest_args == 0)
2229: goto found;
2230: break;
2231: found:
2232: /* Remove ',' or ')' from argument buffer. */
2233: CPP_ADJUST_WRITTEN (pfile, -1);
2234: goto done;
2235: default: ;
2236: }
2237: }
2238:
2239: done:
2240: CPP_OPTIONS (pfile)->put_out_comments = save_put_out_comments;
2241: pfile->no_macro_expand--;
2242:
2243: return token;
2244: }
2245:
2246: /* Turn newlines to spaces in the string of length LENGTH at START,
2247: except inside of string constants.
2248: The string is copied into itself with its beginning staying fixed. */
2249:
2250: static int
2251: change_newlines (start, length)
2252: U_CHAR *start;
2253: int length;
2254: {
2255: register U_CHAR *ibp;
2256: register U_CHAR *obp;
2257: register U_CHAR *limit;
2258: register int c;
2259:
2260: ibp = start;
2261: limit = start + length;
2262: obp = start;
2263:
2264: while (ibp < limit) {
2265: *obp++ = c = *ibp++;
2266: switch (c) {
2267:
2268: case '\'':
2269: case '\"':
2270: /* Notice and skip strings, so that we don't delete newlines in them. */
2271: {
2272: int quotec = c;
2273: while (ibp < limit) {
2274: *obp++ = c = *ibp++;
2275: if (c == quotec)
2276: break;
2277: if (c == '\n' && quotec == '\'')
2278: break;
2279: }
2280: }
2281: break;
2282: }
2283: }
2284:
2285: return obp - start;
2286: }
2287:
2288:
2289: static struct tm *
2290: timestamp (pfile)
2291: cpp_reader *pfile;
2292: {
2293: if (!pfile->timebuf) {
2294: time_t t = time ((time_t *)0);
2295: pfile->timebuf = localtime (&t);
2296: }
2297: return pfile->timebuf;
2298: }
2299:
2300: static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
2301: "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
2302: };
2303:
2304: /*
2305: * expand things like __FILE__. Place the expansion into the output
2306: * buffer *without* rescanning.
2307: */
2308:
2309: static void
2310: special_symbol (hp, pfile)
2311: HASHNODE *hp;
2312: cpp_reader *pfile;
2313: {
2314: char *buf;
2315: int i, len;
2316: int true_indepth;
2317: cpp_buffer *ip = NULL;
2318: struct tm *timebuf;
2319:
2320: int paren = 0; /* For special `defined' keyword */
2321:
2322: #if 0
2323: if (pcp_outfile && pcp_inside_if
2324: && hp->type != T_SPEC_DEFINED && hp->type != T_CONST)
2325: cpp_error (pfile,
2326: "Predefined macro `%s' used inside `#if' during precompilation",
2327: hp->name);
2328: #endif
2329:
2330: for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip))
2331: {
2332: if (ip == NULL)
2333: {
2334: cpp_error (pfile, "cccp error: not in any file?!");
2335: return; /* the show must go on */
2336: }
2337: if (ip->fname != NULL)
2338: break;
2339: }
2340:
2341: switch (hp->type)
2342: {
2343: case T_FILE:
2344: case T_BASE_FILE:
2345: {
2346: char *string;
2347: if (hp->type == T_BASE_FILE)
2348: {
2349: while (CPP_PREV_BUFFER (ip))
2350: ip = CPP_PREV_BUFFER (ip);
2351: }
2352: string = ip->nominal_fname;
2353:
2354: if (!string)
2355: string = "";
2356: CPP_RESERVE (pfile, 3 + 4 * strlen (string));
2357: quote_string (pfile, string);
2358: return;
2359: }
2360:
2361: case T_INCLUDE_LEVEL:
2362: true_indepth = 0;
2363: for (ip = CPP_BUFFER (pfile); ip != NULL; ip = CPP_PREV_BUFFER (ip))
2364: if (ip->fname != NULL)
2365: true_indepth++;
2366:
2367: buf = (char *) alloca (8); /* Eight bytes ought to be more than enough */
2368: sprintf (buf, "%d", true_indepth - 1);
2369: break;
2370:
2371: case T_VERSION:
2372: buf = (char *) alloca (3 + strlen (version_string));
2373: sprintf (buf, "\"%s\"", version_string);
2374: break;
2375:
2376: #ifndef NO_BUILTIN_SIZE_TYPE
2377: case T_SIZE_TYPE:
2378: buf = SIZE_TYPE;
2379: break;
2380: #endif
2381:
2382: #ifndef NO_BUILTIN_PTRDIFF_TYPE
2383: case T_PTRDIFF_TYPE:
2384: buf = PTRDIFF_TYPE;
2385: break;
2386: #endif
2387:
2388: case T_WCHAR_TYPE:
2389: buf = CPP_WCHAR_TYPE (pfile);
2390: break;
2391:
2392: case T_USER_LABEL_PREFIX_TYPE:
2393: buf = USER_LABEL_PREFIX;
2394: break;
2395:
2396: case T_REGISTER_PREFIX_TYPE:
2397: buf = REGISTER_PREFIX;
2398: break;
2399:
2400: case T_CONST:
2401: buf = (char *) alloca (4 * sizeof (int));
2402: sprintf (buf, "%d", hp->value.ival);
2403: #if 0
2404: if (pcp_inside_if && pcp_outfile)
2405: /* Output a precondition for this macro use */
2406: fprintf (pcp_outfile, "#define %s %d\n", hp->name, hp->value.ival);
2407: #endif
2408: break;
2409:
2410: case T_SPECLINE:
2411: {
2412: long line = ip->lineno;
2413: long col = ip->colno;
2414: adjust_position (CPP_LINE_BASE (ip), ip->cur, &line, &col);
2415:
2416: buf = (char *) alloca (10);
2417: sprintf (buf, "%d", line);
2418: }
2419: break;
2420:
2421: case T_DATE:
2422: case T_TIME:
2423: buf = (char *) alloca (20);
2424: timebuf = timestamp (pfile);
2425: if (hp->type == T_DATE)
2426: sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
2427: timebuf->tm_mday, timebuf->tm_year + 1900);
2428: else
2429: sprintf (buf, "\"%02d:%02d:%02d\"", timebuf->tm_hour, timebuf->tm_min,
2430: timebuf->tm_sec);
2431: break;
2432:
2433: case T_SPEC_DEFINED:
2434: buf = " 0 "; /* Assume symbol is not defined */
2435: ip = CPP_BUFFER (pfile);
2436: SKIP_WHITE_SPACE (ip->cur);
2437: if (*ip->cur == '(')
2438: {
2439: paren++;
2440: ip->cur++; /* Skip over the paren */
2441: SKIP_WHITE_SPACE (ip->cur);
2442: }
2443:
2444: if (!is_idstart[*ip->cur])
2445: goto oops;
2446: if (hp = cpp_lookup (pfile, ip->cur, -1, -1))
2447: {
2448: #if 0
2449: if (pcp_outfile && pcp_inside_if
2450: && (hp->type == T_CONST
2451: || (hp->type == T_MACRO && hp->value.defn->predefined)))
2452: /* Output a precondition for this macro use. */
2453: fprintf (pcp_outfile, "#define %s\n", hp->name);
2454: #endif
2455: buf = " 1 ";
2456: }
2457: #if 0
2458: else
2459: if (pcp_outfile && pcp_inside_if)
2460: {
2461: /* Output a precondition for this macro use */
2462: U_CHAR *cp = ip->bufp;
2463: fprintf (pcp_outfile, "#undef ");
2464: while (is_idchar[*cp]) /* Ick! */
2465: fputc (*cp++, pcp_outfile);
2466: putc ('\n', pcp_outfile);
2467: }
2468: #endif
2469: while (is_idchar[*ip->cur])
2470: ++ip->cur;
2471: SKIP_WHITE_SPACE (ip->cur);
2472: if (paren)
2473: {
2474: if (*ip->cur != ')')
2475: goto oops;
2476: ++ip->cur;
2477: }
2478: break;
2479:
2480: oops:
2481:
2482: cpp_error (pfile, "`defined' without an identifier");
2483: break;
2484:
2485: default:
2486: cpp_error (pfile, "cccp error: invalid special hash type"); /* time for gdb */
2487: abort ();
2488: }
2489: len = strlen (buf);
2490: CPP_RESERVE (pfile, len + 1);
2491: CPP_PUTS_Q (pfile, buf, len);
2492: CPP_NUL_TERMINATE_Q (pfile);
2493:
2494: return;
2495: }
2496:
2497: /* Initialize the built-in macros. */
2498:
2499: static void
2500: initialize_builtins (pfile)
2501: cpp_reader *pfile;
2502: {
2503: install ("__LINE__", -1, T_SPECLINE, 0, 0, -1);
2504: install ("__DATE__", -1, T_DATE, 0, 0, -1);
2505: install ("__FILE__", -1, T_FILE, 0, 0, -1);
2506: install ("__BASE_FILE__", -1, T_BASE_FILE, 0, 0, -1);
2507: install ("__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, 0, 0, -1);
2508: install ("__VERSION__", -1, T_VERSION, 0, 0, -1);
2509: #ifndef NO_BUILTIN_SIZE_TYPE
2510: install ("__SIZE_TYPE__", -1, T_SIZE_TYPE, 0, 0, -1);
2511: #endif
2512: #ifndef NO_BUILTIN_PTRDIFF_TYPE
2513: install ("__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, 0, 0, -1);
2514: #endif
2515: install ("__WCHAR_TYPE__", -1, T_WCHAR_TYPE, 0, 0, -1);
2516: install ("__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE, 0, 0, -1);
2517: install ("__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE, 0, 0, -1);
2518: install ("__TIME__", -1, T_TIME, 0, 0, -1);
2519: if (!CPP_TRADITIONAL (pfile))
2520: install ("__STDC__", -1, T_CONST, STDC_VALUE, 0, -1);
2521: if (CPP_OPTIONS (pfile)->objc)
2522: install ("__OBJC__", -1, T_CONST, 1, 0, -1);
2523: /* This is supplied using a -D by the compiler driver
2524: so that it is present only when truly compiling with GNU C. */
2525: /* install ("__GNUC__", -1, T_CONST, 2, 0, -1); */
2526:
2527: if (CPP_OPTIONS (pfile)->debug_output)
2528: {
2529: char directive[2048];
2530: register struct directive *dp = &directive_table[0];
2531: struct tm *timebuf = timestamp (pfile);
2532: cpp_buffer *pbuffer = CPP_BUFFER (pfile);
2533:
2534: while (CPP_PREV_BUFFER (pbuffer))
2535: pbuffer = CPP_PREV_BUFFER (pbuffer);
2536: sprintf (directive, " __BASE_FILE__ \"%s\"\n",
2537: pbuffer->nominal_fname);
2538: output_line_command (pfile, 0, same_file);
2539: pass_thru_directive (directive, &directive[strlen (directive)], pfile, dp);
2540:
2541: sprintf (directive, " __VERSION__ \"%s\"\n", version_string);
2542: output_line_command (pfile, 0, same_file);
2543: pass_thru_directive (directive, &directive[strlen (directive)], pfile, dp);
2544:
2545: #ifndef NO_BUILTIN_SIZE_TYPE
2546: sprintf (directive, " __SIZE_TYPE__ %s\n", SIZE_TYPE);
2547: output_line_command (pfile, 0, same_file);
2548: pass_thru_directive (directive, &directive[strlen (directive)], pfile, dp);
2549: #endif
2550:
2551: #ifndef NO_BUILTIN_PTRDIFF_TYPE
2552: sprintf (directive, " __PTRDIFF_TYPE__ %s\n", PTRDIFF_TYPE);
2553: output_line_command (pfile, 0, same_file);
2554: pass_thru_directive (directive, &directive[strlen (directive)], pfile, dp);
2555: #endif
2556:
2557: sprintf (directive, " __WCHAR_TYPE__ %s\n", CPP_WCHAR_TYPE (pfile));
2558: output_line_command (pfile, 0, same_file);
2559: pass_thru_directive (directive, &directive[strlen (directive)], pfile, dp);
2560:
2561: sprintf (directive, " __DATE__ \"%s %2d %4d\"\n",
2562: monthnames[timebuf->tm_mon],
2563: timebuf->tm_mday, timebuf->tm_year + 1900);
2564: output_line_command (pfile, 0, same_file);
2565: pass_thru_directive (directive, &directive[strlen (directive)], pfile, dp);
2566:
2567: sprintf (directive, " __TIME__ \"%02d:%02d:%02d\"\n",
2568: timebuf->tm_hour, timebuf->tm_min, timebuf->tm_sec);
2569: output_line_command (pfile, 0, same_file);
2570: pass_thru_directive (directive, &directive[strlen (directive)], pfile, dp);
2571:
2572: if (!CPP_TRADITIONAL (pfile))
2573: {
2574: sprintf (directive, " __STDC__ 1");
2575: output_line_command (pfile, 0, same_file);
2576: pass_thru_directive (directive, &directive[strlen (directive)],
2577: pfile, dp);
2578: }
2579: if (CPP_OPTIONS (pfile)->objc)
2580: {
2581: sprintf (directive, " __OBJC__ 1");
2582: output_line_command (pfile, 0, same_file);
2583: pass_thru_directive (directive, &directive[strlen (directive)],
2584: pfile, dp);
2585: }
2586: }
2587: }
2588:
2589: /* Return 1 iff a token ending in C1 followed directly by a token C2
2590: could cause mis-tokenization. */
2591:
2592: static int
2593: unsafe_chars (c1, c2)
2594: int c1, c2;
2595: {
2596: switch (c1)
2597: {
2598: case '+': case '-':
2599: if (c2 == c1 || c2 == '=')
2600: return 1;
2601: goto letter;
2602: case '.':
2603: case '0': case '1': case '2': case '3': case '4':
2604: case '5': case '6': case '7': case '8': case '9':
2605: case 'e': case 'E':
2606: if (c2 == '-' || c2 == '+')
2607: return 1; /* could extend a pre-processing number */
2608: goto letter;
2609: case 'L':
2610: if (c2 == '\'' || c2 == '\"')
2611: return 1; /* Could turn into L"xxx" or L'xxx'. */
2612: goto letter;
2613: letter:
2614: case '_':
2615: case 'a': case 'b': case 'c': case 'd': case 'f':
2616: case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
2617: case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
2618: case 's': case 't': case 'u': case 'v': case 'w': case 'x':
2619: case 'y': case 'z':
2620: case 'A': case 'B': case 'C': case 'D': case 'F':
2621: case 'G': case 'H': case 'I': case 'J': case 'K':
2622: case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
2623: case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
2624: case 'Y': case 'Z':
2625: /* We're in the middle of either a name or a pre-processing number. */
2626: return (is_idchar[c2] || c2 == '.');
2627: case '<': case '>': case '!': case '%': case '#': case ':':
2628: case '^': case '&': case '|': case '*': case '/': case '=':
2629: return (c2 == c1 || c2 == '=');
2630: }
2631: return 0;
2632: }
2633:
2634: /* Expand a macro call.
2635: HP points to the symbol that is the macro being called.
2636: Put the result of expansion onto the input stack
2637: so that subsequent input by our caller will use it.
2638:
2639: If macro wants arguments, caller has already verified that
2640: an argument list follows; arguments come from the input stack. */
2641:
2642: static void
2643: macroexpand (pfile, hp)
2644: cpp_reader *pfile;
2645: HASHNODE *hp;
2646: {
2647: int nargs;
2648: DEFINITION *defn = hp->value.defn;
2649: register U_CHAR *xbuf;
2650: long start_line, start_column;
2651: int xbuf_len;
2652: struct argdata *args;
2653: long old_written = CPP_WRITTEN (pfile);
2654: #if 0
2655: int start_line = instack[indepth].lineno;
2656: #endif
2657: int rest_args, rest_zero;
2658: register int i;
2659:
2660: #if 0
2661: CHECK_DEPTH (return;);
2662: #endif
2663:
2664: #if 0
2665: /* This macro is being used inside a #if, which means it must be */
2666: /* recorded as a precondition. */
2667: if (pcp_inside_if && pcp_outfile && defn->predefined)
2668: dump_single_macro (hp, pcp_outfile);
2669: #endif
2670:
2671: pfile->output_escapes++;
2672: cpp_buf_line_and_col (cpp_file_buffer (pfile), &start_line, &start_column);
2673:
2674: nargs = defn->nargs;
2675:
2676: if (nargs >= 0)
2677: {
2678: enum cpp_token token;
2679:
2680: args = (struct argdata *) alloca ((nargs + 1) * sizeof (struct argdata));
2681:
2682: for (i = 0; i < nargs; i++)
2683: {
2684: args[i].raw = args[i].expanded = 0;
2685: args[i].raw_length = 0;
2686: args[i].expand_length = args[i].stringified_length = -1;
2687: args[i].use_count = 0;
2688: }
2689:
2690: /* Parse all the macro args that are supplied. I counts them.
2691: The first NARGS args are stored in ARGS.
2692: The rest are discarded. If rest_args is set then we assume
2693: macarg absorbed the rest of the args. */
2694: i = 0;
2695: rest_args = 0;
2696: rest_args = 0;
2697: FORWARD(1); /* Discard the open-parenthesis before the first arg. */
2698: do
2699: {
2700: if (rest_args)
2701: continue;
2702: if (i < nargs || (nargs == 0 && i == 0))
2703: {
2704: /* if we are working on last arg which absorbs rest of args... */
2705: if (i == nargs - 1 && defn->rest_args)
2706: rest_args = 1;
2707: args[i].raw = CPP_WRITTEN (pfile);
2708: token = macarg (pfile, rest_args);
2709: args[i].raw_length = CPP_WRITTEN (pfile) - args[i].raw;
2710: args[i].newlines = 0; /* FIXME */
2711: }
2712: else
2713: token = macarg (pfile, 0);
2714: if (token == CPP_EOF || token == CPP_POP)
2715: {
2716: cpp_error_with_line (pfile, start_line, start_column,
2717: "unterminated macro call");
2718: return;
2719: }
2720: i++;
2721: } while (token == CPP_COMMA);
2722:
2723: /* If we got one arg but it was just whitespace, call that 0 args. */
2724: if (i == 1)
2725: {
2726: register U_CHAR *bp = ARG_BASE + args[0].raw;
2727: register U_CHAR *lim = bp + args[0].raw_length;
2728: /* cpp.texi says for foo ( ) we provide one argument.
2729: However, if foo wants just 0 arguments, treat this as 0. */
2730: if (nargs == 0)
2731: while (bp != lim && is_space[*bp]) bp++;
2732: if (bp == lim)
2733: i = 0;
2734: }
2735:
2736: /* Don't output an error message if we have already output one for
2737: a parse error above. */
2738: rest_zero = 0;
2739: if (nargs == 0 && i > 0)
2740: {
2741: cpp_error (pfile, "arguments given to macro `%s'", hp->name);
2742: }
2743: else if (i < nargs)
2744: {
2745: /* traditional C allows foo() if foo wants one argument. */
2746: if (nargs == 1 && i == 0 && CPP_TRADITIONAL (pfile))
2747: ;
2748: /* the rest args token is allowed to absorb 0 tokens */
2749: else if (i == nargs - 1 && defn->rest_args)
2750: rest_zero = 1;
2751: else if (i == 0)
2752: cpp_error (pfile, "macro `%s' used without args", hp->name);
2753: else if (i == 1)
2754: cpp_error (pfile, "macro `%s' used with just one arg", hp->name);
2755: else
2756: cpp_error (pfile, "macro `%s' used with only %d args",
2757: hp->name, i);
2758: }
2759: else if (i > nargs)
2760: {
2761: cpp_error (pfile,
2762: "macro `%s' used with too many (%d) args", hp->name, i);
2763: }
2764: }
2765:
2766: /* If macro wants zero args, we parsed the arglist for checking only.
2767: Read directly from the macro definition. */
2768: if (nargs <= 0)
2769: {
2770: xbuf = defn->expansion;
2771: xbuf_len = defn->length;
2772: }
2773: else
2774: {
2775: register U_CHAR *exp = defn->expansion;
2776: register int offset; /* offset in expansion,
2777: copied a piece at a time */
2778: register int totlen; /* total amount of exp buffer filled so far */
2779:
2780: register struct reflist *ap, *last_ap;
2781:
2782: /* Macro really takes args. Compute the expansion of this call. */
2783:
2784: /* Compute length in characters of the macro's expansion.
2785: Also count number of times each arg is used. */
2786: xbuf_len = defn->length;
2787: for (ap = defn->pattern; ap != NULL; ap = ap->next)
2788: {
2789: if (ap->stringify)
2790: {
2791: register struct argdata *arg = &args[ap->argno];
2792: /* Stringify it it hasn't already been */
2793: if (arg->stringified_length < 0)
2794: {
2795: int arglen = arg->raw_length;
2796: int escaped = 0;
2797: int in_string = 0;
2798: int c;
2799: /* Initially need_space is -1. Otherwise, 1 means the
2800: previous character was a space, but we suppressed it;
2801: 0 means the previous character was a non-space. */
2802: int need_space = -1;
2803: i = 0;
2804: arg->stringified = CPP_WRITTEN (pfile);
2805: if (!CPP_TRADITIONAL (pfile))
2806: CPP_PUTC (pfile, '\"'); /* insert beginning quote */
2807: for (; i < arglen; i++)
2808: {
2809: c = (ARG_BASE + arg->raw)[i];
2810:
2811: if (! in_string)
2812: {
2813: /* Internal sequences of whitespace are replaced by
2814: one space except within an string or char token.*/
2815: if (is_space[c])
2816: {
2817: if (CPP_WRITTEN (pfile) > arg->stringified
2818: && (CPP_PWRITTEN (pfile))[-1] == '@')
2819: {
2820: /* "@ " escape markers are removed */
2821: CPP_ADJUST_WRITTEN (pfile, -1);
2822: continue;
2823: }
2824: if (need_space == 0)
2825: need_space = 1;
2826: continue;
2827: }
2828: else if (need_space > 0)
2829: CPP_PUTC (pfile, ' ');
2830: need_space = 0;
2831: }
2832:
2833: if (escaped)
2834: escaped = 0;
2835: else
2836: {
2837: if (c == '\\')
2838: escaped = 1;
2839: if (in_string)
2840: {
2841: if (c == in_string)
2842: in_string = 0;
2843: }
2844: else if (c == '\"' || c == '\'')
2845: in_string = c;
2846: }
2847:
2848: /* Escape these chars */
2849: if (c == '\"' || (in_string && c == '\\'))
2850: CPP_PUTC (pfile, '\\');
2851: if (isprint (c))
2852: CPP_PUTC (pfile, c);
2853: else
2854: {
2855: CPP_RESERVE (pfile, 4);
2856: sprintf (CPP_PWRITTEN (pfile), "\\%03o",
2857: (unsigned int) c);
2858: CPP_ADJUST_WRITTEN (pfile, 4);
2859: }
2860: }
2861: if (!CPP_TRADITIONAL (pfile))
2862: CPP_PUTC (pfile, '\"'); /* insert ending quote */
2863: arg->stringified_length
2864: = CPP_WRITTEN (pfile) - arg->stringified;
2865: }
2866: xbuf_len += args[ap->argno].stringified_length;
2867: }
2868: else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
2869: /* Add 4 for two newline-space markers to prevent
2870: token concatenation. */
2871: xbuf_len += args[ap->argno].raw_length + 4;
2872: else
2873: {
2874: /* We have an ordinary (expanded) occurrence of the arg.
2875: So compute its expansion, if we have not already. */
2876: if (args[ap->argno].expand_length < 0)
2877: {
2878: args[ap->argno].expanded = CPP_WRITTEN (pfile);
2879: cpp_expand_to_buffer (pfile,
2880: ARG_BASE + args[ap->argno].raw,
2881: args[ap->argno].raw_length);
2882:
2883: args[ap->argno].expand_length
2884: = CPP_WRITTEN (pfile) - args[ap->argno].expanded;
2885: }
2886:
2887: /* Add 4 for two newline-space markers to prevent
2888: token concatenation. */
2889: xbuf_len += args[ap->argno].expand_length + 4;
2890: }
2891: if (args[ap->argno].use_count < 10)
2892: args[ap->argno].use_count++;
2893: }
2894:
2895: xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
2896:
2897: /* Generate in XBUF the complete expansion
2898: with arguments substituted in.
2899: TOTLEN is the total size generated so far.
2900: OFFSET is the index in the definition
2901: of where we are copying from. */
2902: offset = totlen = 0;
2903: for (last_ap = NULL, ap = defn->pattern; ap != NULL;
2904: last_ap = ap, ap = ap->next)
2905: {
2906: register struct argdata *arg = &args[ap->argno];
2907: int count_before = totlen;
2908:
2909: /* Add chars to XBUF. */
2910: for (i = 0; i < ap->nchars; i++, offset++)
2911: xbuf[totlen++] = exp[offset];
2912:
2913: /* If followed by an empty rest arg with concatenation,
2914: delete the last run of nonwhite chars. */
2915: if (rest_zero && totlen > count_before
2916: && ((ap->rest_args && ap->raw_before)
2917: || (last_ap != NULL && last_ap->rest_args
2918: && last_ap->raw_after)))
2919: {
2920: /* Delete final whitespace. */
2921: while (totlen > count_before && is_space[xbuf[totlen - 1]])
2922: totlen--;
2923:
2924: /* Delete the nonwhites before them. */
2925: while (totlen > count_before && ! is_space[xbuf[totlen - 1]])
2926: totlen--;
2927: }
2928:
2929: if (ap->stringify != 0)
2930: {
2931: bcopy (ARG_BASE + arg->stringified,
2932: xbuf + totlen, arg->stringified_length);
2933: totlen += arg->stringified_length;
2934: }
2935: else if (ap->raw_before || ap->raw_after || CPP_TRADITIONAL (pfile))
2936: {
2937: U_CHAR *p1 = ARG_BASE + arg->raw;
2938: U_CHAR *l1 = p1 + arg->raw_length;
2939: if (ap->raw_before)
2940: {
2941: while (p1 != l1 && is_space[*p1]) p1++;
2942: while (p1 != l1 && is_idchar[*p1])
2943: xbuf[totlen++] = *p1++;
2944: }
2945: if (ap->raw_after)
2946: {
2947: /* Arg is concatenated after: delete trailing whitespace,
2948: whitespace markers, and no-reexpansion markers. */
2949: while (p1 != l1)
2950: {
2951: if (is_space[l1[-1]]) l1--;
2952: else if (l1[-1] == '-')
2953: {
2954: U_CHAR *p2 = l1 - 1;
2955: /* If a `-' is preceded by an odd number of newlines then it
2956: and the last newline are a no-reexpansion marker. */
2957: while (p2 != p1 && p2[-1] == '\n') p2--;
2958: if ((l1 - 1 - p2) & 1) {
2959: l1 -= 2;
2960: }
2961: else break;
2962: }
2963: else break;
2964: }
2965: }
2966:
2967: bcopy (p1, xbuf + totlen, l1 - p1);
2968: totlen += l1 - p1;
2969: }
2970: else
2971: {
2972: U_CHAR *expanded = ARG_BASE + arg->expanded;
2973: if (!ap->raw_before && totlen > 0 && arg->expand_length
2974: && !CPP_TRADITIONAL(pfile)
2975: && unsafe_chars (xbuf[totlen-1], expanded[0]))
2976: {
2977: xbuf[totlen++] = '@';
2978: xbuf[totlen++] = ' ';
2979: }
2980:
2981: bcopy (expanded, xbuf + totlen, arg->expand_length);
2982: totlen += arg->expand_length;
2983:
2984: if (!ap->raw_after && totlen > 0 && offset < defn->length
2985: && !CPP_TRADITIONAL(pfile)
2986: && unsafe_chars (xbuf[totlen-1], exp[offset]))
2987: {
2988: xbuf[totlen++] = '@';
2989: xbuf[totlen++] = ' ';
2990: }
2991:
2992: /* If a macro argument with newlines is used multiple times,
2993: then only expand the newlines once. This avoids creating
2994: output lines which don't correspond to any input line,
2995: which confuses gdb and gcov. */
2996: if (arg->use_count > 1 && arg->newlines > 0)
2997: {
2998: /* Don't bother doing change_newlines for subsequent
2999: uses of arg. */
3000: arg->use_count = 1;
3001: arg->expand_length
3002: = change_newlines (expanded, arg->expand_length);
3003: }
3004: }
3005:
3006: if (totlen > xbuf_len)
3007: abort ();
3008: }
3009:
3010: /* if there is anything left of the definition
3011: after handling the arg list, copy that in too. */
3012:
3013: for (i = offset; i < defn->length; i++)
3014: {
3015: /* if we've reached the end of the macro */
3016: if (exp[i] == ')')
3017: rest_zero = 0;
3018: if (! (rest_zero && last_ap != NULL && last_ap->rest_args
3019: && last_ap->raw_after))
3020: xbuf[totlen++] = exp[i];
3021: }
3022:
3023: xbuf[totlen] = 0;
3024: xbuf_len = totlen;
3025:
3026: }
3027:
3028: pfile->output_escapes--;
3029:
3030: /* Now put the expansion on the input stack
3031: so our caller will commence reading from it. */
3032: push_macro_expansion (pfile, xbuf, xbuf_len, hp);
3033: CPP_BUFFER (pfile)->has_escapes = 1;
3034:
3035: /* Pop the space we've used in the token_buffer for argument expansion. */
3036: CPP_SET_WRITTEN (pfile, old_written);
3037:
3038: /* Recursive macro use sometimes works traditionally.
3039: #define foo(x,y) bar (x (y,0), y)
3040: foo (foo, baz) */
3041:
3042: if (!CPP_TRADITIONAL (pfile))
3043: hp->type = T_DISABLED;
3044: }
3045:
3046: static void
3047: push_macro_expansion (pfile, xbuf, xbuf_len, hp)
3048: cpp_reader *pfile;
3049: register U_CHAR *xbuf;
3050: int xbuf_len;
3051: HASHNODE *hp;
3052: {
3053: register cpp_buffer *mbuf = cpp_push_buffer (pfile, xbuf, xbuf_len);
3054: mbuf->cleanup = macro_cleanup;
3055: mbuf->data = hp;
3056:
3057: /* The first chars of the expansion should be a "@ " added by
3058: collect_expansion. This is to prevent accidental token-pasting
3059: between the text preceding the macro invocation, and the macro
3060: expansion text.
3061:
3062: We would like to avoid adding unneeded spaces (for the sake of
3063: tools that use cpp, such as imake). In some common cases we can
3064: tell that it is safe to omit the space.
3065:
3066: The character before the macro invocation cannot have been an
3067: idchar (or else it would have been pasted with the idchars of
3068: the macro name). Therefore, if the first non-space character
3069: of the expansion is an idchar, we do not need the extra space
3070: to prevent token pasting.
3071:
3072: Also, we don't need the extra space if the first char is '(',
3073: or some other (less common) characters. */
3074:
3075: if (xbuf[0] == '@' && xbuf[1] == ' '
3076: && (is_idchar[xbuf[2]] || xbuf[2] == '(' || xbuf[2] == '\''
3077: || xbuf[2] == '\"'))
3078: mbuf->cur += 2;
3079: }
3080:
3081: /* Like cpp_get_token, except that it does not read past end-of-line.
3082: Also, horizontal space is skipped, and macros are popped. */
3083:
3084: static enum cpp_token
3085: get_directive_token (pfile)
3086: cpp_reader *pfile;
3087: {
3088: for (;;)
3089: {
3090: long old_written = CPP_WRITTEN (pfile);
3091: enum cpp_token token;
3092: cpp_skip_hspace (pfile);
3093: if (PEEKC () == '\n')
3094: return CPP_VSPACE;
3095: token = cpp_get_token (pfile);
3096: switch (token)
3097: {
3098: case CPP_POP:
3099: if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
3100: return token;
3101: /* ... else fall though ... */
3102: case CPP_HSPACE: case CPP_COMMENT:
3103: CPP_SET_WRITTEN (pfile, old_written);
3104: break;
3105: default:
3106: return token;
3107: }
3108: }
3109: }
3110:
3111: /* Handle #include and #import.
3112: This function expects to see "fname" or <fname> on the input.
3113:
3114: The input is normally in part of the output_buffer following
3115: CPP_WRITTEN, and will get overwritten by output_line_command.
3116: I.e. in input file specification has been popped by handle_directive.
3117: This is safe. */
3118:
3119: static int
3120: do_include (pfile, keyword, unused1, unused2)
3121: cpp_reader *pfile;
3122: struct directive *keyword;
3123: U_CHAR *unused1, *unused2;
3124: {
3125: int importing = (keyword->type == T_IMPORT);
3126: int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
3127: char *fname; /* Dynamically allocated fname buffer */
3128: char *pcftry;
3129: char *pcfname;
3130: U_CHAR *fbeg, *fend; /* Beginning and end of fname */
3131: enum cpp_token token;
3132:
3133: /* Chain of dirs to search */
3134: struct file_name_list *search_start = CPP_OPTIONS (pfile)->include;
3135: struct file_name_list dsp[1]; /* First in chain, if #include "..." */
3136: struct file_name_list *searchptr = 0;
3137: long old_written = CPP_WRITTEN (pfile);
3138:
3139: int flen;
3140:
3141: int f; /* file number */
3142:
3143: int retried = 0; /* Have already tried macro
3144: expanding the include line*/
3145: int angle_brackets = 0; /* 0 for "...", 1 for <...> */
3146: int pcf = -1;
3147: char *pcfbuf;
3148: char *pcfbuflimit;
3149: int pcfnum;
3150: f= -1; /* JF we iz paranoid! */
3151:
3152: if (importing && CPP_OPTIONS (pfile)->warn_import
3153: && !CPP_OPTIONS (pfile)->inhibit_warnings
3154: && !CPP_BUFFER (pfile)->system_header_p && !pfile->import_warning)
3155: {
3156: pfile->import_warning = 1;
3157: cpp_warning (pfile, "using `#import' is not recommended");
3158: fprintf (stderr, "The fact that a certain header file need not be processed more than once\n");
3159: fprintf (stderr, "should be indicated in the header file, not where it is used.\n");
3160: fprintf (stderr, "The best way to do this is with a conditional of this form:\n\n");
3161: fprintf (stderr, " #ifndef _FOO_H_INCLUDED\n");
3162: fprintf (stderr, " #define _FOO_H_INCLUDED\n");
3163: fprintf (stderr, " ... <real contents of file> ...\n");
3164: fprintf (stderr, " #endif /* Not _FOO_H_INCLUDED */\n\n");
3165: fprintf (stderr, "Then users can use `#include' any number of times.\n");
3166: fprintf (stderr, "GNU C automatically avoids processing the file more than once\n");
3167: fprintf (stderr, "when it is equipped with such a conditional.\n");
3168: }
3169:
3170: pfile->parsing_include_directive++;
3171: token = get_directive_token (pfile);
3172: pfile->parsing_include_directive--;
3173:
3174: if (token == CPP_STRING)
3175: {
3176: /* FIXME - check no trailing garbage */
3177: fbeg = pfile->token_buffer + old_written + 1;
3178: fend = CPP_PWRITTEN (pfile) - 1;
3179: if (fbeg[-1] == '<')
3180: {
3181: angle_brackets = 1;
3182: /* If -I-, start with the first -I dir after the -I-. */
3183: if (CPP_OPTIONS (pfile)->first_bracket_include)
3184: search_start = CPP_OPTIONS (pfile)->first_bracket_include;
3185: }
3186: /* If -I- was specified, don't search current dir, only spec'd ones. */
3187: else if (! CPP_OPTIONS (pfile)->ignore_srcdir)
3188: {
3189: cpp_buffer *fp;
3190: /* We have "filename". Figure out directory this source
3191: file is coming from and put it on the front of the list. */
3192:
3193: for (fp = CPP_BUFFER (pfile); fp != NULL; fp = CPP_PREV_BUFFER (fp))
3194: {
3195: int n;
3196: char *ep,*nam;
3197:
3198: if ((nam = fp->nominal_fname) != NULL)
3199: {
3200: /* Found a named file. Figure out dir of the file,
3201: and put it in front of the search list. */
3202: dsp[0].next = search_start;
3203: search_start = dsp;
3204: #ifndef VMS
3205: ep = rindex (nam, '/');
3206: #else /* VMS */
3207: ep = rindex (nam, ']');
3208: if (ep == NULL) ep = rindex (nam, '>');
3209: if (ep == NULL) ep = rindex (nam, ':');
3210: if (ep != NULL) ep++;
3211: #endif /* VMS */
3212: if (ep != NULL)
3213: {
3214: n = ep - nam;
3215: dsp[0].fname = (char *) alloca (n + 1);
3216: strncpy (dsp[0].fname, nam, n);
3217: dsp[0].fname[n] = '\0';
3218: if (n + INCLUDE_LEN_FUDGE > pfile->max_include_len)
3219: pfile->max_include_len = n + INCLUDE_LEN_FUDGE;
3220: }
3221: else
3222: {
3223: dsp[0].fname = 0; /* Current directory */
3224: }
3225: dsp[0].got_name_map = 0;
3226: break;
3227: }
3228: }
3229: }
3230: }
3231: #ifdef VMS
3232: else if (token == CPP_NAME)
3233: {
3234: /*
3235: * Support '#include xyz' like VAX-C to allow for easy use of all the
3236: * decwindow include files. It defaults to '#include <xyz.h>' (so the
3237: * code from case '<' is repeated here) and generates a warning.
3238: */
3239: cpp_warning (pfile,
3240: "VAX-C-style include specification found, use '#include <filename.h>' !");
3241: angle_brackets = 1;
3242: /* If -I-, start with the first -I dir after the -I-. */
3243: if (CPP_OPTIONS (pfile)->first_bracket_include)
3244: search_start = CPP_OPTIONS (pfile)->first_bracket_include;
3245: fbeg = pfile->token_buffer + old_written;
3246: fend = CPP_PWRITTEN (pfile);
3247: }
3248: #endif
3249: else
3250: {
3251: cpp_error (pfile,
3252: "`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
3253: CPP_SET_WRITTEN (pfile, old_written);
3254: skip_rest_of_line (pfile);
3255: return 0;
3256: }
3257:
3258: *fend = 0;
3259:
3260: token = get_directive_token (pfile);
3261: if (token != CPP_VSPACE)
3262: {
3263: cpp_error (pfile, "junk at end of `#include'");
3264: while (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP)
3265: token = get_directive_token (pfile);
3266: }
3267:
3268: /* For #include_next, skip in the search path
3269: past the dir in which the containing file was found. */
3270: if (skip_dirs)
3271: {
3272: cpp_buffer *fp;
3273: for (fp = CPP_BUFFER (pfile); fp != NULL; fp = CPP_PREV_BUFFER (fp))
3274: if (fp->fname != NULL)
3275: {
3276: /* fp->dir is null if the containing file was specified with
3277: an absolute file name. In that case, don't skip anything. */
3278: if (fp->dir == SELF_DIR_DUMMY)
3279: search_start = CPP_OPTIONS (pfile)->include;
3280: else if (fp->dir)
3281: search_start = fp->dir->next;
3282: break;
3283: }
3284: }
3285:
3286: CPP_SET_WRITTEN (pfile, old_written);
3287:
3288: flen = fend - fbeg;
3289:
3290: if (flen == 0)
3291: {
3292: cpp_error (pfile, "empty file name in `#%s'", keyword->name);
3293: return 0;
3294: }
3295:
3296: /* Allocate this permanently, because it gets stored in the definitions
3297: of macros. */
3298: fname = (char *) xmalloc (pfile->max_include_len + flen + 4);
3299: /* + 2 above for slash and terminating null. */
3300: /* + 2 added for '.h' on VMS (to support '#include filename') */
3301:
3302: /* If specified file name is absolute, just open it. */
3303:
3304: if (*fbeg == '/') {
3305: strncpy (fname, fbeg, flen);
3306: fname[flen] = 0;
3307: if (redundant_include_p (pfile, fname))
3308: return 0;
3309: if (importing)
3310: f = lookup_import (pfile, fname, NULL_PTR);
3311: else
3312: f = open_include_file (pfile, fname, NULL_PTR);
3313: if (f == -2)
3314: return 0; /* Already included this file */
3315: } else {
3316: /* Search directory path, trying to open the file.
3317: Copy each filename tried into FNAME. */
3318:
3319: for (searchptr = search_start; searchptr; searchptr = searchptr->next) {
3320: if (searchptr->fname) {
3321: /* The empty string in a search path is ignored.
3322: This makes it possible to turn off entirely
3323: a standard piece of the list. */
3324: if (searchptr->fname[0] == 0)
3325: continue;
3326: strcpy (fname, searchptr->fname);
3327: strcat (fname, "/");
3328: fname[strlen (fname) + flen] = 0;
3329: } else {
3330: fname[0] = 0;
3331: }
3332: strncat (fname, fbeg, flen);
3333: #ifdef VMS
3334: /* Change this 1/2 Unix 1/2 VMS file specification into a
3335: full VMS file specification */
3336: if (searchptr->fname && (searchptr->fname[0] != 0)) {
3337: /* Fix up the filename */
3338: hack_vms_include_specification (fname);
3339: } else {
3340: /* This is a normal VMS filespec, so use it unchanged. */
3341: strncpy (fname, fbeg, flen);
3342: fname[flen] = 0;
3343: /* if it's '#include filename', add the missing .h */
3344: if (index(fname,'.')==NULL) {
3345: strcat (fname, ".h");
3346: }
3347: }
3348: #endif /* VMS */
3349: /* ??? There are currently 3 separate mechanisms for avoiding processing
3350: of redundant include files: #import, #pragma once, and
3351: redundant_include_p. It would be nice if they were unified. */
3352: if (redundant_include_p (pfile, fname))
3353: return 0;
3354: if (importing)
3355: f = lookup_import (pfile, fname, searchptr);
3356: else
3357: f = open_include_file (pfile, fname, searchptr);
3358: if (f == -2)
3359: return 0; /* Already included this file */
3360: #ifdef EACCES
3361: else if (f == -1 && errno == EACCES)
3362: cpp_warning (pfile, "Header file %s exists, but is not readable",
3363: fname);
3364: #endif
3365: if (f >= 0)
3366: break;
3367: }
3368: }
3369:
3370: if (f < 0)
3371: {
3372: /* A file that was not found. */
3373: strncpy (fname, fbeg, flen);
3374: fname[flen] = 0;
3375: /* If generating dependencies and -MG was specified, we assume missing
3376: files are leaf files, living in the same directory as the source file
3377: or other similar place; these missing files may be generated from
3378: other files and may not exist yet (eg: y.tab.h). */
3379:
3380: if (CPP_OPTIONS(pfile)->print_deps_missing_files
3381: && CPP_PRINT_DEPS (pfile)
3382: > (angle_brackets || (pfile->system_include_depth > 0)))
3383: {
3384: /* If it was requested as a system header file,
3385: then assume it belongs in the first place to look for such. */
3386: if (angle_brackets)
3387: {
3388: for (searchptr = search_start; searchptr;
3389: searchptr = searchptr->next)
3390: {
3391: if (searchptr->fname)
3392: {
3393: char *p;
3394:
3395: if (searchptr->fname[0] == 0)
3396: continue;
3397: p = (char *) alloca (strlen (searchptr->fname)
3398: + strlen (fname) + 2);
3399: strcpy (p, searchptr->fname);
3400: strcat (p, "/");
3401: strcat (p, fname);
3402: deps_output (pfile, p, ' ');
3403: break;
3404: }
3405: }
3406: }
3407: else
3408: {
3409: /* Otherwise, omit the directory, as if the file existed
3410: in the directory with the source. */
3411: deps_output (pfile, fname, ' ');
3412: }
3413: }
3414: /* If -M was specified, and this header file won't be added to the
3415: dependency list, then don't count this as an error, because we can
3416: still produce correct output. Otherwise, we can't produce correct
3417: output, because there may be dependencies we need inside the missing
3418: file, and we don't know what directory this missing file exists in.*/
3419: else if (CPP_PRINT_DEPS (pfile)
3420: && (CPP_PRINT_DEPS (pfile)
3421: <= (angle_brackets || (pfile->system_include_depth > 0))))
3422: cpp_warning (pfile, "No include path in which to find %s", fname);
3423: else if (search_start)
3424: cpp_error_from_errno (pfile, fname);
3425: else
3426: cpp_error (pfile, "No include path in which to find %s", fname);
3427: }
3428: else {
3429: /* Check to see if this include file is a once-only include file.
3430: If so, give up. */
3431:
3432: struct file_name_list* ptr;
3433:
3434: for (ptr = pfile->dont_repeat_files; ptr; ptr = ptr->next) {
3435: if (!strcmp (ptr->fname, fname)) {
3436: close (f);
3437: return 0; /* This file was once'd. */
3438: }
3439: }
3440:
3441: for (ptr = pfile->all_include_files; ptr; ptr = ptr->next) {
3442: if (!strcmp (ptr->fname, fname))
3443: break; /* This file was included before. */
3444: }
3445:
3446: if (ptr == 0) {
3447: /* This is the first time for this file. */
3448: /* Add it to list of files included. */
3449:
3450: ptr = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
3451: ptr->control_macro = 0;
3452: ptr->c_system_include_path = 0;
3453: ptr->next = pfile->all_include_files;
3454: pfile->all_include_files = ptr;
3455: ptr->fname = savestring (fname);
3456: ptr->got_name_map = 0;
3457:
3458: /* For -M, add this file to the dependencies. */
3459: if (CPP_PRINT_DEPS (pfile)
3460: > (angle_brackets || (pfile->system_include_depth > 0)))
3461: deps_output (pfile, fname, ' ');
3462: }
3463:
3464: /* Handle -H option. */
3465: if (CPP_OPTIONS(pfile)->print_include_names)
3466: {
3467: cpp_buffer *buf = CPP_BUFFER (pfile);
3468: while ((buf = CPP_PREV_BUFFER (buf)) != NULL)
3469: putc ('.', stderr);
3470: fprintf (stderr, "%s\n", fname);
3471: }
3472:
3473: if (angle_brackets)
3474: pfile->system_include_depth++;
3475:
3476: /* Actually process the file. */
3477:
3478: /* Record file on "seen" list for #import. */
3479: add_import (pfile, f, fname);
3480:
3481: pcftry = (char *) alloca (strlen (fname) + 30);
3482: pcfbuf = 0;
3483: pcfnum = 0;
3484:
3485: #if 0
3486: if (!no_precomp)
3487: {
3488: struct stat stat_f;
3489:
3490: fstat (f, &stat_f);
3491:
3492: do {
3493: sprintf (pcftry, "%s%d", fname, pcfnum++);
3494:
3495: pcf = open (pcftry, O_RDONLY, 0666);
3496: if (pcf != -1)
3497: {
3498: struct stat s;
3499:
3500: fstat (pcf, &s);
3501: if (bcmp ((char *) &stat_f.st_ino, (char *) &s.st_ino,
3502: sizeof (s.st_ino))
3503: || stat_f.st_dev != s.st_dev)
3504: {
3505: pcfbuf = check_precompiled (pcf, fname, &pcfbuflimit);
3506: /* Don't need it any more. */
3507: close (pcf);
3508: }
3509: else
3510: {
3511: /* Don't need it at all. */
3512: close (pcf);
3513: break;
3514: }
3515: }
3516: } while (pcf != -1 && !pcfbuf);
3517: }
3518: #endif
3519:
3520: /* Actually process the file */
3521: cpp_push_buffer (pfile, NULL, 0);
3522: if (finclude (pfile, f, fname, is_system_include (pfile, fname),
3523: searchptr != dsp ? searchptr : SELF_DIR_DUMMY))
3524: {
3525: output_line_command (pfile, 0, enter_file);
3526: pfile->only_seen_white = 2;
3527: }
3528:
3529: if (angle_brackets)
3530: pfile->system_include_depth--;
3531: }
3532: return 0;
3533: }
3534:
3535: /* Return nonzero if there is no need to include file NAME
3536: because it has already been included and it contains a conditional
3537: to make a repeated include do nothing. */
3538:
3539: static int
3540: redundant_include_p (pfile, name)
3541: cpp_reader *pfile;
3542: char *name;
3543: {
3544: struct file_name_list *l = pfile->all_include_files;
3545: for (; l; l = l->next)
3546: if (! strcmp (name, l->fname)
3547: && l->control_macro
3548: && cpp_lookup (pfile, l->control_macro, -1, -1))
3549: return 1;
3550: return 0;
3551: }
3552:
3553: /* Return nonzero if the given FILENAME is an absolute pathname which
3554: designates a file within one of the known "system" include file
3555: directories. We assume here that if the given FILENAME looks like
3556: it is the name of a file which resides either directly in a "system"
3557: include file directory, or within any subdirectory thereof, then the
3558: given file must be a "system" include file. This function tells us
3559: if we should suppress pedantic errors/warnings for the given FILENAME.
3560:
3561: The value is 2 if the file is a C-language system header file
3562: for which C++ should (on most systems) assume `extern "C"'. */
3563:
3564: static int
3565: is_system_include (pfile, filename)
3566: cpp_reader *pfile;
3567: register char *filename;
3568: {
3569: struct file_name_list *searchptr;
3570:
3571: for (searchptr = CPP_OPTIONS (pfile)->first_system_include; searchptr;
3572: searchptr = searchptr->next)
3573: if (searchptr->fname) {
3574: register char *sys_dir = searchptr->fname;
3575: register unsigned length = strlen (sys_dir);
3576:
3577: if (! strncmp (sys_dir, filename, length) && filename[length] == '/')
3578: {
3579: if (searchptr->c_system_include_path)
3580: return 2;
3581: else
3582: return 1;
3583: }
3584: }
3585: return 0;
3586: }
3587:
3588:
3589: /*
3590: * Install a name in the assertion hash table.
3591: *
3592: * If LEN is >= 0, it is the length of the name.
3593: * Otherwise, compute the length by scanning the entire name.
3594: *
3595: * If HASH is >= 0, it is the precomputed hash code.
3596: * Otherwise, compute the hash code.
3597: */
3598: static ASSERTION_HASHNODE *
3599: assertion_install (pfile, name, len, hash)
3600: cpp_reader *pfile;
3601: U_CHAR *name;
3602: int len;
3603: int hash;
3604: {
3605: register ASSERTION_HASHNODE *hp;
3606: register int i, bucket;
3607: register U_CHAR *p, *q;
3608:
3609: i = sizeof (ASSERTION_HASHNODE) + len + 1;
3610: hp = (ASSERTION_HASHNODE *) xmalloc (i);
3611: bucket = hash;
3612: hp->bucket_hdr = &pfile->assertion_hashtab[bucket];
3613: hp->next = pfile->assertion_hashtab[bucket];
3614: pfile->assertion_hashtab[bucket] = hp;
3615: hp->prev = NULL;
3616: if (hp->next != NULL)
3617: hp->next->prev = hp;
3618: hp->length = len;
3619: hp->value = 0;
3620: hp->name = ((U_CHAR *) hp) + sizeof (ASSERTION_HASHNODE);
3621: p = hp->name;
3622: q = name;
3623: for (i = 0; i < len; i++)
3624: *p++ = *q++;
3625: hp->name[len] = 0;
3626: return hp;
3627: }
3628: /*
3629: * find the most recent hash node for name name (ending with first
3630: * non-identifier char) installed by install
3631: *
3632: * If LEN is >= 0, it is the length of the name.
3633: * Otherwise, compute the length by scanning the entire name.
3634: *
3635: * If HASH is >= 0, it is the precomputed hash code.
3636: * Otherwise, compute the hash code.
3637: */
3638:
3639: static ASSERTION_HASHNODE *
3640: assertion_lookup (pfile, name, len, hash)
3641: cpp_reader *pfile;
3642: U_CHAR *name;
3643: int len;
3644: int hash;
3645: {
3646: register ASSERTION_HASHNODE *bucket;
3647:
3648: bucket = pfile->assertion_hashtab[hash];
3649: while (bucket) {
3650: if (bucket->length == len && strncmp (bucket->name, name, len) == 0)
3651: return bucket;
3652: bucket = bucket->next;
3653: }
3654: return NULL;
3655: }
3656:
3657: static void
3658: delete_assertion (hp)
3659: ASSERTION_HASHNODE *hp;
3660: {
3661: struct tokenlist_list *tail;
3662: if (hp->prev != NULL)
3663: hp->prev->next = hp->next;
3664: if (hp->next != NULL)
3665: hp->next->prev = hp->prev;
3666:
3667: for (tail = hp->value; tail; )
3668: {
3669: struct tokenlist_list *next = tail->next;
3670: free_token_list (tail->tokens);
3671: free (tail);
3672: tail = next;
3673: }
3674:
3675: /* make sure that the bucket chain header that
3676: the deleted guy was on points to the right thing afterwards. */
3677: if (hp == *hp->bucket_hdr)
3678: *hp->bucket_hdr = hp->next;
3679:
3680: free (hp);
3681: }
3682:
3683: /* Convert a character string literal into a nul-terminated string.
3684: The input string is [IN ... LIMIT).
3685: The result is placed in RESULT. RESULT can be the same as IN.
3686: The value returned in the end of the string written to RESULT,
3687: or NULL on error. */
3688:
3689: static U_CHAR*
3690: convert_string (pfile, result, in, limit, handle_escapes)
3691: cpp_reader *pfile;
3692: register U_CHAR *result, *in, *limit;
3693: int handle_escapes;
3694: {
3695: U_CHAR c;
3696: c = *in++;
3697: if (c != '\"')
3698: return NULL;
3699: while (in < limit)
3700: {
3701: U_CHAR c = *in++;
3702: switch (c)
3703: {
3704: case '\0':
3705: return NULL;
3706: case '\"':
3707: limit = in;
3708: break;
3709: case '\\':
3710: if (handle_escapes)
3711: {
3712: char *bpc = (char *) in;
3713: int i = (U_CHAR) cpp_parse_escape (pfile, &bpc);
3714: in = (U_CHAR *) bpc;
3715: if (i >= 0)
3716: *result++ = (U_CHAR)c;
3717: break;
3718: }
3719: /* else fall through */
3720: default:
3721: *result++ = c;
3722: }
3723: }
3724: *result = 0;
3725: return result;
3726: }
3727:
3728: /*
3729: * interpret #line command. Remembers previously seen fnames
3730: * in its very own hash table.
3731: */
3732: #define FNAME_HASHSIZE 37
3733:
3734: static int
3735: do_line (pfile, keyword)
3736: cpp_reader *pfile;
3737: struct directive *keyword;
3738: {
3739: cpp_buffer *ip = CPP_BUFFER (pfile);
3740: int new_lineno;
3741: long old_written = CPP_WRITTEN (pfile);
3742: enum file_change_code file_change = same_file;
3743: enum cpp_token token;
3744: int i;
3745:
3746: token = get_directive_token (pfile);
3747:
3748: if (token != CPP_NUMBER
3749: || !isdigit(pfile->token_buffer[old_written]))
3750: {
3751: cpp_error (pfile, "invalid format `#line' command");
3752: goto bad_line_directive;
3753: }
3754:
3755: /* The Newline at the end of this line remains to be processed.
3756: To put the next line at the specified line number,
3757: we must store a line number now that is one less. */
3758: new_lineno = atoi (pfile->token_buffer + old_written) - 1;
3759: CPP_SET_WRITTEN (pfile, old_written);
3760:
3761: /* NEW_LINENO is one less than the actual line number here. */
3762: if (CPP_PEDANTIC (pfile) && new_lineno < 0)
3763: cpp_pedwarn (pfile, "line number out of range in `#line' command");
3764:
3765: #if 0 /* #line 10"foo.c" is supposed to be allowed. */
3766: if (PEEKC() && !is_space[PEEKC()]) {
3767: cpp_error (pfile, "invalid format `#line' command");
3768: goto bad_line_directive;
3769: }
3770: #endif
3771:
3772: token = get_directive_token (pfile);
3773:
3774: if (token == CPP_STRING) {
3775: U_CHAR *fname = pfile->token_buffer + old_written;
3776: U_CHAR *end_name;
3777: static HASHNODE *fname_table[FNAME_HASHSIZE];
3778: HASHNODE *hp, **hash_bucket;
3779: U_CHAR *p;
3780: long num_start;
3781: int fname_length;
3782:
3783: /* Turn the file name, which is a character string literal,
3784: into a null-terminated string. Do this in place. */
3785: end_name = convert_string (pfile, fname, fname, CPP_PWRITTEN (pfile), 1);
3786: if (end_name == NULL)
3787: {
3788: cpp_error (pfile, "invalid format `#line' command");
3789: goto bad_line_directive;
3790: }
3791:
3792: fname_length = end_name - fname;
3793:
3794: num_start = CPP_WRITTEN (pfile);
3795: token = get_directive_token (pfile);
3796: if (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP) {
3797: p = pfile->token_buffer + num_start;
3798: if (CPP_PEDANTIC (pfile))
3799: cpp_pedwarn (pfile, "garbage at end of `#line' command");
3800:
3801: if (token != CPP_NUMBER || *p < '0' || *p > '4' || p[1] != '\0')
3802: {
3803: cpp_error (pfile, "invalid format `#line' command");
3804: goto bad_line_directive;
3805: }
3806: if (*p == '1')
3807: file_change = enter_file;
3808: else if (*p == 2)
3809: file_change = leave_file;
3810: else if (*p == 3)
3811: ip->system_header_p = 1;
3812: else /* if (*p == 4) */
3813: ip->system_header_p = 2;
3814:
3815: CPP_SET_WRITTEN (pfile, num_start);
3816: token = get_directive_token (pfile);
3817: p = pfile->token_buffer + num_start;
3818: if (token == CPP_NUMBER && p[1] == '\0' && (*p == '3' || *p== '4')) {
3819: ip->system_header_p = *p == 3 ? 1 : 2;
3820: token = get_directive_token (pfile);
3821: }
3822: if (token != CPP_VSPACE) {
3823: cpp_error (pfile, "invalid format `#line' command");
3824: goto bad_line_directive;
3825: }
3826: }
3827:
3828: hash_bucket =
3829: &fname_table[hashf (fname, fname_length, FNAME_HASHSIZE)];
3830: for (hp = *hash_bucket; hp != NULL; hp = hp->next)
3831: if (hp->length == fname_length &&
3832: strncmp (hp->value.cpval, fname, fname_length) == 0) {
3833: ip->nominal_fname = hp->value.cpval;
3834: break;
3835: }
3836: if (hp == 0) {
3837: /* Didn't find it; cons up a new one. */
3838: hp = (HASHNODE *) xcalloc (1, sizeof (HASHNODE) + fname_length + 1);
3839: hp->next = *hash_bucket;
3840: *hash_bucket = hp;
3841:
3842: hp->length = fname_length;
3843: ip->nominal_fname = hp->value.cpval = ((char *) hp) + sizeof (HASHNODE);
3844: bcopy (fname, hp->value.cpval, fname_length);
3845: }
3846: }
3847: else if (token != CPP_VSPACE && token != CPP_EOF) {
3848: cpp_error (pfile, "invalid format `#line' command");
3849: goto bad_line_directive;
3850: }
3851:
3852: ip->lineno = new_lineno;
3853: bad_line_directive:
3854: skip_rest_of_line (pfile);
3855: CPP_SET_WRITTEN (pfile, old_written);
3856: output_line_command (pfile, 0, file_change);
3857: return 0;
3858: }
3859:
3860: /*
3861: * remove the definition of a symbol from the symbol table.
3862: * according to un*x /lib/cpp, it is not an error to undef
3863: * something that has no definitions, so it isn't one here either.
3864: */
3865:
3866: static int
3867: do_undef (pfile, keyword, buf, limit)
3868: cpp_reader *pfile;
3869: struct directive *keyword;
3870: U_CHAR *buf, *limit;
3871: {
3872: int sym_length;
3873: HASHNODE *hp;
3874: U_CHAR *orig_buf = buf;
3875:
3876: #if 0
3877: /* If this is a precompiler run (with -pcp) pass thru #undef commands. */
3878: if (pcp_outfile && keyword)
3879: pass_thru_directive (buf, limit, pfile, keyword);
3880: #endif
3881:
3882: SKIP_WHITE_SPACE (buf);
3883: sym_length = check_macro_name (pfile, buf, "macro");
3884:
3885: while ((hp = cpp_lookup (pfile, buf, sym_length, -1)) != NULL)
3886: {
3887: /* If we are generating additional info for debugging (with -g) we
3888: need to pass through all effective #undef commands. */
3889: if (CPP_OPTIONS (pfile)->debug_output && keyword)
3890: pass_thru_directive (orig_buf, limit, pfile, keyword);
3891: if (hp->type != T_MACRO)
3892: cpp_warning (pfile, "undefining `%s'", hp->name);
3893: delete_macro (hp);
3894: }
3895:
3896: if (CPP_PEDANTIC (pfile)) {
3897: buf += sym_length;
3898: SKIP_WHITE_SPACE (buf);
3899: if (buf != limit)
3900: cpp_pedwarn (pfile, "garbage after `#undef' directive");
3901: }
3902: return 0;
3903: }
3904:
3905: /*
3906: * Report an error detected by the program we are processing.
3907: * Use the text of the line in the error message.
3908: * (We use error because it prints the filename & line#.)
3909: */
3910:
3911: static int
3912: do_error (pfile, keyword, buf, limit)
3913: cpp_reader *pfile;
3914: struct directive *keyword;
3915: U_CHAR *buf, *limit;
3916: {
3917: int length = limit - buf;
3918: U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
3919: bcopy (buf, copy, length);
3920: copy[length] = 0;
3921: SKIP_WHITE_SPACE (copy);
3922: cpp_error (pfile, "#error %s", copy);
3923: return 0;
3924: }
3925:
3926: /*
3927: * Report a warning detected by the program we are processing.
3928: * Use the text of the line in the warning message, then continue.
3929: * (We use error because it prints the filename & line#.)
3930: */
3931:
3932: static int
3933: do_warning (pfile, keyword, buf, limit)
3934: cpp_reader *pfile;
3935: struct directive *keyword;
3936: U_CHAR *buf, *limit;
3937: {
3938: int length = limit - buf;
3939: U_CHAR *copy = (U_CHAR *) xmalloc (length + 1);
3940: bcopy (buf, copy, length);
3941: copy[length] = 0;
3942: SKIP_WHITE_SPACE (copy);
3943: cpp_warning (pfile, "#warning %s", copy);
3944: return 0;
3945: }
3946:
3947: /* Remember the name of the current file being read from so that we can
3948: avoid ever including it again. */
3949:
3950: static int
3951: do_once (pfile)
3952: cpp_reader *pfile;
3953: {
3954: cpp_buffer *ip = NULL;
3955: struct file_name_list *new;
3956:
3957: for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip))
3958: {
3959: if (ip == NULL)
3960: return 0;
3961: if (ip->fname != NULL)
3962: break;
3963: }
3964:
3965:
3966: new = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
3967: new->next = pfile->dont_repeat_files;
3968: pfile->dont_repeat_files = new;
3969: new->fname = savestring (ip->fname);
3970: new->control_macro = 0;
3971: new->got_name_map = 0;
3972: new->c_system_include_path = 0;
3973:
3974: return 0;
3975: }
3976:
3977: /* #ident has already been copied to the output file, so just ignore it. */
3978:
3979: static int
3980: do_ident (pfile, keyword, buf, limit)
3981: cpp_reader *pfile;
3982: struct directive *keyword;
3983: U_CHAR *buf, *limit;
3984: {
3985: /* long old_written = CPP_WRITTEN (pfile);*/
3986: int len;
3987:
3988: /* Allow #ident in system headers, since that's not user's fault. */
3989: if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
3990: cpp_pedwarn (pfile, "ANSI C does not allow `#ident'");
3991:
3992: /* Leave rest of line to be read by later calls to cpp_get_token. */
3993:
3994: return 0;
3995: }
3996:
3997: /* #pragma and its argument line have already been copied to the output file.
3998: Just check for some recognized pragmas that need validation here. */
3999:
4000: static int
4001: do_pragma (pfile, keyword, buf, limit)
4002: cpp_reader *pfile;
4003: struct directive *keyword;
4004: U_CHAR *buf, *limit;
4005: {
4006: while (*buf == ' ' || *buf == '\t')
4007: buf++;
4008: if (!strncmp (buf, "once", 4)) {
4009: /* Allow #pragma once in system headers, since that's not the user's
4010: fault. */
4011: if (!CPP_BUFFER (pfile)->system_header_p)
4012: cpp_warning (pfile, "`#pragma once' is obsolete");
4013: do_once (pfile);
4014: }
4015:
4016: if (!strncmp (buf, "implementation", 14)) {
4017: /* Be quiet about `#pragma implementation' for a file only if it hasn't
4018: been included yet. */
4019: struct file_name_list *ptr;
4020: U_CHAR *p = buf + 14, *fname, *inc_fname;
4021: int fname_len;
4022: SKIP_WHITE_SPACE (p);
4023: if (*p == '\n' || *p != '\"')
4024: return 0;
4025:
4026: fname = p + 1;
4027: p = (U_CHAR *) index (fname, '\"');
4028: fname_len = p != NULL ? p - fname : strlen (fname);
4029:
4030: for (ptr = pfile->all_include_files; ptr; ptr = ptr->next) {
4031: inc_fname = (U_CHAR *) rindex (ptr->fname, '/');
4032: inc_fname = inc_fname ? inc_fname + 1 : (U_CHAR *) ptr->fname;
4033: if (inc_fname && !strncmp (inc_fname, fname, fname_len))
4034: cpp_warning (pfile,
4035: "`#pragma implementation' for `%s' appears after file is included",
4036: fname);
4037: }
4038: }
4039:
4040: return 0;
4041: }
4042:
4043: #if 0
4044: /* This was a fun hack, but #pragma seems to start to be useful.
4045: By failing to recognize it, we pass it through unchanged to cc1. */
4046:
4047: /*
4048: * the behavior of the #pragma directive is implementation defined.
4049: * this implementation defines it as follows.
4050: */
4051:
4052: static int
4053: do_pragma ()
4054: {
4055: close (0);
4056: if (open ("/dev/tty", O_RDONLY, 0666) != 0)
4057: goto nope;
4058: close (1);
4059: if (open ("/dev/tty", O_WRONLY, 0666) != 1)
4060: goto nope;
4061: execl ("/usr/games/hack", "#pragma", 0);
4062: execl ("/usr/games/rogue", "#pragma", 0);
4063: execl ("/usr/new/emacs", "-f", "hanoi", "9", "-kill", 0);
4064: execl ("/usr/local/emacs", "-f", "hanoi", "9", "-kill", 0);
4065: nope:
4066: fatal ("You are in a maze of twisty compiler features, all different");
4067: }
4068: #endif
4069:
4070: /* Just ignore #sccs, on systems where we define it at all. */
4071:
4072: static int
4073: do_sccs (pfile, keyword, buf, limit)
4074: cpp_reader *pfile;
4075: struct directive *keyword;
4076: U_CHAR *buf, *limit;
4077: {
4078: if (CPP_PEDANTIC (pfile))
4079: cpp_pedwarn (pfile, "ANSI C does not allow `#sccs'");
4080: return 0;
4081: }
4082:
4083: /*
4084: * handle #if command by
4085: * 1) inserting special `defined' keyword into the hash table
4086: * that gets turned into 0 or 1 by special_symbol (thus,
4087: * if the luser has a symbol called `defined' already, it won't
4088: * work inside the #if command)
4089: * 2) rescan the input into a temporary output buffer
4090: * 3) pass the output buffer to the yacc parser and collect a value
4091: * 4) clean up the mess left from steps 1 and 2.
4092: * 5) call conditional_skip to skip til the next #endif (etc.),
4093: * or not, depending on the value from step 3.
4094: */
4095:
4096: static int
4097: do_if (pfile, keyword, buf, limit)
4098: cpp_reader *pfile;
4099: struct directive *keyword;
4100: U_CHAR *buf, *limit;
4101: {
4102: HOST_WIDE_INT value = eval_if_expression (pfile, buf, limit - buf);
4103: conditional_skip (pfile, value == 0, T_IF, NULL_PTR);
4104: return 0;
4105: }
4106:
4107: /*
4108: * handle a #elif directive by not changing if_stack either.
4109: * see the comment above do_else.
4110: */
4111:
4112: static int
4113: do_elif (pfile, keyword, buf, limit)
4114: cpp_reader *pfile;
4115: struct directive *keyword;
4116: U_CHAR *buf, *limit;
4117: {
4118: if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack) {
4119: cpp_error (pfile, "`#elif' not within a conditional");
4120: return 0;
4121: } else {
4122: if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF) {
4123: cpp_error (pfile, "`#elif' after `#else'");
4124: #if 0
4125: fprintf (stderr, " (matches line %d", pfile->if_stack->lineno);
4126: #endif
4127: if (pfile->if_stack->fname != NULL && CPP_BUFFER (pfile)->fname != NULL
4128: && strcmp (pfile->if_stack->fname,
4129: CPP_BUFFER (pfile)->nominal_fname) != 0)
4130: fprintf (stderr, ", file %s", pfile->if_stack->fname);
4131: fprintf (stderr, ")\n");
4132: }
4133: pfile->if_stack->type = T_ELIF;
4134: }
4135:
4136: if (pfile->if_stack->if_succeeded)
4137: skip_if_group (pfile, 0);
4138: else {
4139: HOST_WIDE_INT value = eval_if_expression (pfile, buf, limit - buf);
4140: if (value == 0)
4141: skip_if_group (pfile, 0);
4142: else {
4143: ++pfile->if_stack->if_succeeded; /* continue processing input */
4144: output_line_command (pfile, 1, same_file);
4145: }
4146: }
4147: return 0;
4148: }
4149:
4150: /*
4151: * evaluate a #if expression in BUF, of length LENGTH,
4152: * then parse the result as a C expression and return the value as an int.
4153: */
4154: static HOST_WIDE_INT
4155: eval_if_expression (pfile, buf, length)
4156: cpp_reader *pfile;
4157: U_CHAR *buf;
4158: int length;
4159: {
4160: HASHNODE *save_defined;
4161: HOST_WIDE_INT value;
4162: long old_written = CPP_WRITTEN (pfile);
4163:
4164: save_defined = install ("defined", -1, T_SPEC_DEFINED, 0, 0, -1);
4165: pfile->pcp_inside_if = 1;
4166:
4167: value = cpp_parse_expr (pfile);
4168: pfile->pcp_inside_if = 0;
4169: delete_macro (save_defined); /* clean up special symbol */
4170:
4171: CPP_SET_WRITTEN (pfile, old_written); /* Pop */
4172:
4173: return value;
4174: }
4175:
4176: /*
4177: * routine to handle ifdef/ifndef. Try to look up the symbol,
4178: * then do or don't skip to the #endif/#else/#elif depending
4179: * on what directive is actually being processed.
4180: */
4181:
4182: static int
4183: do_xifdef (pfile, keyword, unused1, unused2)
4184: cpp_reader *pfile;
4185: struct directive *keyword;
4186: U_CHAR *unused1, *unused2;
4187: {
4188: int skip;
4189: cpp_buffer *ip = CPP_BUFFER (pfile);
4190: U_CHAR* ident;
4191: int ident_length;
4192: enum cpp_token token;
4193: int start_of_file = 0;
4194: U_CHAR *control_macro = 0;
4195: int old_written = CPP_WRITTEN (pfile);
4196:
4197: /* Detect a #ifndef at start of file (not counting comments). */
4198: if (ip->fname != 0 && keyword->type == T_IFNDEF)
4199: start_of_file = pfile->only_seen_white == 2;
4200:
4201: pfile->no_macro_expand++;
4202: token = get_directive_token (pfile);
4203: pfile->no_macro_expand--;
4204:
4205: ident = pfile->token_buffer + old_written;
4206: ident_length = CPP_WRITTEN (pfile) - old_written;
4207: CPP_SET_WRITTEN (pfile, old_written); /* Pop */
4208:
4209: if (token == CPP_VSPACE || token == CPP_POP || token == CPP_EOF)
4210: {
4211: skip = (keyword->type == T_IFDEF);
4212: if (! CPP_TRADITIONAL (pfile))
4213: cpp_pedwarn (pfile, "`#%s' with no argument", keyword->name);
4214: }
4215: else if (token == CPP_NAME)
4216: {
4217: HASHNODE *hp = cpp_lookup (pfile, ident, ident_length, -1);
4218: skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
4219: if (start_of_file && !skip)
4220: {
4221: control_macro = (U_CHAR *) xmalloc (ident_length + 1);
4222: bcopy (ident, control_macro, ident_length + 1);
4223: }
4224: }
4225: else
4226: {
4227: skip = (keyword->type == T_IFDEF);
4228: if (! CPP_TRADITIONAL (pfile))
4229: cpp_error (pfile, "`#%s' with invalid argument", keyword->name);
4230: }
4231:
4232: if (!CPP_TRADITIONAL (pfile))
4233: { int c;
4234: cpp_skip_hspace (pfile);
4235: c = PEEKC ();
4236: if (c != EOF && c != '\n')
4237: cpp_pedwarn (pfile, "garbage at end of `#%s' argument", keyword->name);
4238: }
4239: skip_rest_of_line (pfile);
4240:
4241: #if 0
4242: if (pcp_outfile) {
4243: /* Output a precondition for this macro. */
4244: if (hp && hp->value.defn->predefined)
4245: fprintf (pcp_outfile, "#define %s\n", hp->name);
4246: else {
4247: U_CHAR *cp = buf;
4248: fprintf (pcp_outfile, "#undef ");
4249: while (is_idchar[*cp]) /* Ick! */
4250: fputc (*cp++, pcp_outfile);
4251: putc ('\n', pcp_outfile);
4252: }
4253: #endif
4254:
4255: conditional_skip (pfile, skip, T_IF, control_macro);
4256: return 0;
4257: }
4258:
4259: /* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
4260: If this is a #ifndef starting at the beginning of a file,
4261: CONTROL_MACRO is the macro name tested by the #ifndef.
4262: Otherwise, CONTROL_MACRO is 0. */
4263:
4264: static void
4265: conditional_skip (pfile, skip, type, control_macro)
4266: cpp_reader *pfile;
4267: int skip;
4268: enum node_type type;
4269: U_CHAR *control_macro;
4270: {
4271: IF_STACK_FRAME *temp;
4272:
4273: temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
4274: temp->fname = CPP_BUFFER (pfile)->nominal_fname;
4275: #if 0
4276: temp->lineno = CPP_BUFFER (pfile)->lineno;
4277: #endif
4278: temp->next = pfile->if_stack;
4279: temp->control_macro = control_macro;
4280: pfile->if_stack = temp;
4281:
4282: pfile->if_stack->type = type;
4283:
4284: if (skip != 0) {
4285: skip_if_group (pfile, 0);
4286: return;
4287: } else {
4288: ++pfile->if_stack->if_succeeded;
4289: output_line_command (pfile, 1, same_file);
4290: }
4291: }
4292:
4293: /*
4294: * skip to #endif, #else, or #elif. adjust line numbers, etc.
4295: * leaves input ptr at the sharp sign found.
4296: * If ANY is nonzero, return at next directive of any sort.
4297: */
4298: static void
4299: skip_if_group (pfile, any)
4300: cpp_reader *pfile;
4301: int any;
4302: {
4303: int c;
4304: int at_beg_of_line = 1;
4305: struct directive *kt;
4306: IF_STACK_FRAME *save_if_stack = pfile->if_stack; /* don't pop past here */
4307: #if 0
4308: U_CHAR *beg_of_line = bp;
4309: #endif
4310: register int ident_length;
4311: U_CHAR *ident, *after_ident;
4312: struct parse_marker line_start_mark;
4313:
4314: parse_set_mark (&line_start_mark, pfile);
4315:
4316: if (CPP_OPTIONS (pfile)->output_conditionals) {
4317: static char failed[] = "#failed\n";
4318: CPP_PUTS (pfile, failed, sizeof(failed)-1);
4319: pfile->lineno++;
4320: output_line_command (pfile, 1, same_file);
4321: }
4322:
4323: beg_of_line:
4324: if (CPP_OPTIONS (pfile)->output_conditionals)
4325: {
4326: cpp_buffer *pbuf = CPP_BUFFER (pfile);
4327: U_CHAR *start_line = pbuf->buf + line_start_mark.position;
4328: CPP_PUTS (pfile, start_line, pbuf->cur - start_line);
4329: }
4330: parse_move_mark (&line_start_mark, pfile);
4331: if (!CPP_TRADITIONAL (pfile))
4332: cpp_skip_hspace (pfile);
4333: c = GETC();
4334: if (c == '#')
4335: {
4336: int old_written = CPP_WRITTEN (pfile);
4337: cpp_skip_hspace (pfile);
4338:
4339: parse_name (pfile, GETC());
4340: ident_length = CPP_WRITTEN (pfile) - old_written;
4341: ident = pfile->token_buffer + old_written;
4342: pfile->limit = ident;
4343: #if 0
4344: if (ident_length == 0)
4345: goto not_a_directive;
4346:
4347: /* Handle # followed by a line number. */
4348:
4349: /* Avoid error for `###' and similar cases unless -pedantic. */
4350: #endif
4351:
4352: for (kt = directive_table; kt->length >= 0; kt++)
4353: {
4354: IF_STACK_FRAME *temp;
4355: if (ident_length == kt->length
4356: && strncmp (ident, kt->name, kt->length) == 0)
4357: {
4358: /* If we are asked to return on next directive, do so now. */
4359: if (any)
4360: goto done;
4361:
4362: switch (kt->type)
4363: {
4364: case T_IF:
4365: case T_IFDEF:
4366: case T_IFNDEF:
4367: temp
4368: = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
4369: temp->next = pfile->if_stack;
4370: pfile->if_stack = temp;
4371: #if 0
4372: temp->lineno = CPP_BUFFER(pfile)->lineno;
4373: #endif
4374: temp->fname = CPP_BUFFER(pfile)->nominal_fname;
4375: temp->type = kt->type;
4376: break;
4377: case T_ELSE:
4378: case T_ENDIF:
4379: if (CPP_PEDANTIC (pfile) && pfile->if_stack != save_if_stack)
4380: validate_else (pfile,
4381: kt->type == T_ELSE ? "#else" : "#endif");
4382: case T_ELIF:
4383: if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack)
4384: {
4385: cpp_error (pfile,
4386: "`#%s' not within a conditional", kt->name);
4387: break;
4388: }
4389: else if (pfile->if_stack == save_if_stack)
4390: goto done; /* found what we came for */
4391:
4392: if (kt->type != T_ENDIF)
4393: {
4394: if (pfile->if_stack->type == T_ELSE)
4395: cpp_error (pfile, "`#else' or `#elif' after `#else'");
4396: pfile->if_stack->type = kt->type;
4397: break;
4398: }
4399:
4400: temp = pfile->if_stack;
4401: pfile->if_stack = temp->next;
4402: free (temp);
4403: break;
4404: default: ;
4405: }
4406: break;
4407: }
4408: /* Don't let erroneous code go by. */
4409: if (kt->length < 0 && !CPP_OPTIONS (pfile)->lang_asm
4410: && CPP_PEDANTIC (pfile))
4411: cpp_pedwarn (pfile, "invalid preprocessor directive name");
4412: }
4413: c = GETC ();
4414: }
4415: /* We're in the middle of a line. Skip the rest of it. */
4416: for (;;) {
4417: switch (c)
4418: {
4419: long old;
4420: case EOF:
4421: goto done;
4422: case '/': /* possible comment */
4423: c = skip_comment (pfile, NULL);
4424: if (c == EOF)
4425: goto done;
4426: break;
4427: case '\"':
4428: case '\'':
4429: FORWARD(-1);
4430: old = CPP_WRITTEN (pfile);
4431: cpp_get_token (pfile);
4432: CPP_SET_WRITTEN (pfile, old);
4433: break;
4434: case '\\':
4435: /* Char after backslash loses its special meaning. */
4436: if (PEEKC() == '\n')
4437: FORWARD (1);
4438: break;
4439: case '\n':
4440: goto beg_of_line;
4441: break;
4442: }
4443: c = GETC ();
4444: }
4445: done:
4446: if (CPP_OPTIONS (pfile)->output_conditionals) {
4447: static char end_failed[] = "#endfailed\n";
4448: CPP_PUTS (pfile, end_failed, sizeof(end_failed)-1);
4449: pfile->lineno++;
4450: }
4451: pfile->only_seen_white = 1;
4452: parse_goto_mark (&line_start_mark, pfile);
4453: parse_clear_mark (&line_start_mark);
4454: }
4455:
4456: /*
4457: * handle a #else directive. Do this by just continuing processing
4458: * without changing if_stack ; this is so that the error message
4459: * for missing #endif's etc. will point to the original #if. It
4460: * is possible that something different would be better.
4461: */
4462:
4463: static int
4464: do_else (pfile, keyword, buf, limit)
4465: cpp_reader *pfile;
4466: struct directive *keyword;
4467: U_CHAR *buf, *limit;
4468: {
4469: cpp_buffer *ip = CPP_BUFFER (pfile);
4470:
4471: if (CPP_PEDANTIC (pfile))
4472: validate_else (pfile, "#else");
4473: skip_rest_of_line (pfile);
4474:
4475: if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack) {
4476: cpp_error (pfile, "`#else' not within a conditional");
4477: return 0;
4478: } else {
4479: /* #ifndef can't have its special treatment for containing the whole file
4480: if it has a #else clause. */
4481: pfile->if_stack->control_macro = 0;
4482:
4483: if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF) {
4484: cpp_error (pfile, "`#else' after `#else'");
4485: fprintf (stderr, " (matches line %d", pfile->if_stack->lineno);
4486: if (strcmp (pfile->if_stack->fname, ip->nominal_fname) != 0)
4487: fprintf (stderr, ", file %s", pfile->if_stack->fname);
4488: fprintf (stderr, ")\n");
4489: }
4490: pfile->if_stack->type = T_ELSE;
4491: }
4492:
4493: if (pfile->if_stack->if_succeeded)
4494: skip_if_group (pfile, 0);
4495: else {
4496: ++pfile->if_stack->if_succeeded; /* continue processing input */
4497: output_line_command (pfile, 1, same_file);
4498: }
4499: return 0;
4500: }
4501:
4502: /*
4503: * unstack after #endif command
4504: */
4505:
4506: static int
4507: do_endif (pfile, keyword, buf, limit)
4508: cpp_reader *pfile;
4509: struct directive *keyword;
4510: U_CHAR *buf, *limit;
4511: {
4512: if (CPP_PEDANTIC (pfile))
4513: validate_else (pfile, "#endif");
4514: skip_rest_of_line (pfile);
4515:
4516: if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack)
4517: cpp_error (pfile, "unbalanced `#endif'");
4518: else
4519: {
4520: IF_STACK_FRAME *temp = pfile->if_stack;
4521: pfile->if_stack = temp->next;
4522: if (temp->control_macro != 0)
4523: {
4524: /* This #endif matched a #ifndef at the start of the file.
4525: See if it is at the end of the file. */
4526: struct parse_marker start_mark;
4527: int c;
4528:
4529: parse_set_mark (&start_mark, pfile);
4530:
4531: for (;;)
4532: {
4533: cpp_skip_hspace (pfile);
4534: c = GETC ();
4535: if (c != '\n')
4536: break;
4537: }
4538: parse_goto_mark (&start_mark, pfile);
4539: parse_clear_mark (&start_mark);
4540:
4541: if (c == EOF)
4542: {
4543: /* If we get here, this #endif ends a #ifndef
4544: that contains all of the file (aside from whitespace).
4545: Arrange not to include the file again
4546: if the macro that was tested is defined.
4547:
4548: Do not do this for the top-level file in a -include or any
4549: file in a -imacros. */
4550: #if 0
4551: FIXME!
4552: if (indepth != 0
4553: && ! (indepth == 1 && pfile->no_record_file)
4554: && ! (pfile->no_record_file && no_output))
4555: #endif
4556: {
4557: struct file_name_list *ifile = pfile->all_include_files;
4558:
4559: for ( ; ifile != NULL; ifile = ifile->next)
4560: {
4561: if (!strcmp (ifile->fname, CPP_BUFFER (pfile)->fname))
4562: {
4563: ifile->control_macro = temp->control_macro;
4564: break;
4565: }
4566: }
4567: }
4568: }
4569: }
4570: free (temp);
4571: output_line_command (pfile, 1, same_file);
4572: }
4573: return 0;
4574: }
4575:
4576: /* When an #else or #endif is found while skipping failed conditional,
4577: if -pedantic was specified, this is called to warn about text after
4578: the command name. P points to the first char after the command name. */
4579:
4580: static void
4581: validate_else (pfile, directive)
4582: cpp_reader *pfile;
4583: char *directive;
4584: {
4585: int c;
4586: cpp_skip_hspace (pfile);
4587: c = PEEKC ();
4588: if (c != EOF && c != '\n')
4589: cpp_pedwarn (pfile,
4590: "text following `%s' violates ANSI standard", directive);
4591: }
4592:
4593: /* Get the next token, and add it to the text in pfile->token_buffer.
4594: Return the kind of token we got. */
4595:
4596:
4597: enum cpp_token
4598: cpp_get_token (pfile)
4599: cpp_reader *pfile;
4600: {
4601: register int c, c2, c3;
4602: long old_written;
4603: long start_line, start_column;
4604: enum cpp_token token;
4605: struct cpp_options *opts = CPP_OPTIONS (pfile);
4606: CPP_BUFFER (pfile)->prev = CPP_BUFFER (pfile)->cur;
4607: get_next:
4608: c = GETC();
4609: if (c == EOF)
4610: {
4611: handle_eof:
4612: if (CPP_BUFFER (pfile)->seen_eof)
4613: {
4614: if (cpp_pop_buffer (pfile) != CPP_NULL_BUFFER (pfile))
4615: goto get_next;
4616: else
4617: return CPP_EOF;
4618: }
4619: else
4620: {
4621: cpp_buffer *next_buf
4622: = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
4623: CPP_BUFFER (pfile)->seen_eof = 1;
4624: if (CPP_BUFFER (pfile)->nominal_fname && next_buf != 0)
4625: {
4626: /* We're about to return from an #include file.
4627: Emit #line information now (as part of the CPP_POP) result.
4628: But the #line refers to the file we will pop to. */
4629: cpp_buffer *cur_buffer = CPP_BUFFER (pfile);
4630: CPP_BUFFER (pfile) = next_buf;
4631: pfile->input_stack_listing_current = 0;
4632: output_line_command (pfile, 0, leave_file);
4633: CPP_BUFFER (pfile) = cur_buffer;
4634: }
4635: return CPP_POP;
4636: }
4637: }
4638: else
4639: {
4640: switch (c)
4641: {
4642: long newlines;
4643: struct parse_marker start_mark;
4644: case '/':
4645: if (PEEKC () == '=')
4646: goto op2;
4647: if (opts->put_out_comments)
4648: parse_set_mark (&start_mark, pfile);
4649: newlines = 0;
4650: cpp_buf_line_and_col (cpp_file_buffer (pfile),
4651: &start_line, &start_column);
4652: c = skip_comment (pfile, &newlines);
4653: if (opts->put_out_comments && (c == '/' || c == EOF))
4654: parse_clear_mark (&start_mark);
4655: if (c == '/')
4656: goto randomchar;
4657: if (c == EOF)
4658: {
4659: cpp_error_with_line (pfile, start_line, start_column,
4660: "unterminated comment");
4661: goto handle_eof;
4662: }
4663: c = '/'; /* Initial letter of comment. */
4664: return_comment:
4665: /* Comments are equivalent to spaces.
4666: For -traditional, a comment is equivalent to nothing. */
4667: if (opts->put_out_comments)
4668: {
4669: cpp_buffer *pbuf = CPP_BUFFER (pfile);
4670: long dummy;
4671: U_CHAR *start = pbuf->buf + start_mark.position;
4672: int len = pbuf->cur - start;
4673: CPP_RESERVE(pfile, 1 + len);
4674: CPP_PUTC_Q (pfile, c);
4675: CPP_PUTS_Q (pfile, start, len);
4676: pfile->lineno += newlines;
4677: parse_clear_mark (&start_mark);
4678: return CPP_COMMENT;
4679: }
4680: else if (CPP_TRADITIONAL (pfile))
4681: {
4682: return CPP_COMMENT;
4683: }
4684: else
4685: {
4686: #if 0
4687: /* This may not work if cpp_get_token is called recursively,
4688: since many places look for horizontal space. */
4689: if (newlines)
4690: {
4691: /* Copy the newlines into the output buffer, in order to
4692: avoid the pain of a #line every time a multiline comment
4693: is seen. */
4694: CPP_RESERVE(pfile, newlines);
4695: while (--newlines >= 0)
4696: {
4697: CPP_PUTC_Q (pfile, '\n');
4698: pfile->lineno++;
4699: }
4700: return CPP_VSPACE;
4701: }
4702: #endif
4703: CPP_RESERVE(pfile, 1);
4704: CPP_PUTC_Q (pfile, ' ');
4705: return CPP_HSPACE;
4706: }
4707: #if 0
4708: if (opts->for_lint) {
4709: U_CHAR *argbp;
4710: int cmdlen, arglen;
4711: char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
4712:
4713: if (lintcmd != NULL) {
4714: /* I believe it is always safe to emit this newline: */
4715: obp[-1] = '\n';
4716: bcopy ("#pragma lint ", (char *) obp, 13);
4717: obp += 13;
4718: bcopy (lintcmd, (char *) obp, cmdlen);
4719: obp += cmdlen;
4720:
4721: if (arglen != 0) {
4722: *(obp++) = ' ';
4723: bcopy (argbp, (char *) obp, arglen);
4724: obp += arglen;
4725: }
4726:
4727: /* OK, now bring us back to the state we were in before we entered
4728: this branch. We need #line b/c the newline for the pragma
4729: could fuck things up. */
4730: output_line_command (pfile, 0, same_file);
4731: *(obp++) = ' '; /* just in case, if comments are copied thru */
4732: *(obp++) = '/';
4733: }
4734: }
4735: #endif
4736:
4737: case '#':
4738: #if 0
4739: /* If this is expanding a macro definition, don't recognize
4740: preprocessor directives. */
4741: if (ip->macro != 0)
4742: goto randomchar;
4743: /* If this is expand_into_temp_buffer, recognize them
4744: only after an actual newline at this level,
4745: not at the beginning of the input level. */
4746: if (ip->fname == 0 && beg_of_line == ip->buf)
4747: goto randomchar;
4748: if (ident_length)
4749: goto specialchar;
4750: #endif
4751:
4752: if (!pfile->only_seen_white)
4753: goto randomchar;
4754: if (handle_directive (pfile))
4755: return CPP_DIRECTIVE;
4756: pfile->only_seen_white = 0;
4757: return CPP_OTHER;
4758:
4759: case '\"':
4760: case '\'':
4761: /* A single quoted string is treated like a double -- some
4762: programs (e.g., troff) are perverse this way */
4763: cpp_buf_line_and_col (cpp_file_buffer (pfile),
4764: &start_line, &start_column);
4765: old_written = CPP_WRITTEN (pfile);
4766: string:
4767: CPP_PUTC (pfile, c);
4768: while (1)
4769: {
4770: int cc = GETC();
4771: if (cc == EOF)
4772: {
4773: if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
4774: {
4775: /* try harder: this string crosses a macro expansion
4776: boundary. This can happen naturally if -traditional.
4777: Otherwise, only -D can make a macro with an unmatched
4778: quote. */
4779: cpp_buffer *next_buf
4780: = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
4781: (*CPP_BUFFER (pfile)->cleanup)
4782: (CPP_BUFFER (pfile), pfile);
4783: CPP_BUFFER (pfile) = next_buf;
4784: continue;
4785: }
4786: if (!CPP_TRADITIONAL (pfile))
4787: {
4788: cpp_error_with_line (pfile, start_line, start_column,
4789: "unterminated string or character constant");
4790: if (pfile->multiline_string_line != start_line
4791: && pfile->multiline_string_line != 0)
4792: cpp_error_with_line (pfile,
4793: pfile->multiline_string_line, -1,
4794: "possible real start of unterminated constant");
4795: pfile->multiline_string_line = 0;
4796: }
4797: break;
4798: }
4799: CPP_PUTC (pfile, cc);
4800: switch (cc)
4801: {
4802: case '\n':
4803: /* Traditionally, end of line ends a string constant with
4804: no error. So exit the loop and record the new line. */
4805: if (CPP_TRADITIONAL (pfile))
4806: goto while2end;
4807: if (c == '\'')
4808: {
4809: cpp_error_with_line (pfile, start_line, start_column,
4810: "unterminated character constant");
4811: goto while2end;
4812: }
4813: if (CPP_PEDANTIC (pfile)
4814: && pfile->multiline_string_line == 0)
4815: {
4816: cpp_pedwarn_with_line (pfile, start_line, start_column,
4817: "string constant runs past end of line");
4818: }
4819: if (pfile->multiline_string_line == 0)
4820: pfile->multiline_string_line = start_line;
4821: break;
4822:
4823: case '\\':
4824: cc = GETC();
4825: if (cc == '\n')
4826: {
4827: /* Backslash newline is replaced by nothing at all. */
4828: CPP_ADJUST_WRITTEN (pfile, -1);
4829: pfile->lineno++;
4830: }
4831: else
4832: {
4833: /* ANSI stupidly requires that in \\ the second \
4834: is *not* prevented from combining with a newline. */
4835: NEWLINE_FIX1(cc);
4836: if (cc != EOF)
4837: CPP_PUTC (pfile, cc);
4838: }
4839: break;
4840:
4841: case '\"':
4842: case '\'':
4843: if (cc == c)
4844: goto while2end;
4845: break;
4846: }
4847: }
4848: while2end:
4849: pfile->lineno += count_newlines (pfile->token_buffer + old_written,
4850: CPP_PWRITTEN (pfile));
4851: pfile->only_seen_white = 0;
4852: return c == '\'' ? CPP_CHAR : CPP_STRING;
4853:
4854: case '$':
4855: if (!opts->dollars_in_ident)
4856: goto randomchar;
4857: goto letter;
4858:
4859: case ':':
4860: if (opts->cplusplus && PEEKC () == ':')
4861: goto op2;
4862: goto randomchar;
4863:
4864: case '&':
4865: case '+':
4866: case '|':
4867: NEWLINE_FIX;
4868: c2 = PEEKC ();
4869: if (c2 == c || c2 == '=')
4870: goto op2;
4871: goto randomchar;
4872:
4873: case '*':
4874: case '!':
4875: case '%':
4876: case '=':
4877: case '^':
4878: NEWLINE_FIX;
4879: if (PEEKC () == '=')
4880: goto op2;
4881: goto randomchar;
4882:
4883: case '-':
4884: NEWLINE_FIX;
4885: c2 = PEEKC ();
4886: if (c2 == '-' && opts->chill)
4887: {
4888: /* Chill style comment */
4889: if (opts->put_out_comments)
4890: parse_set_mark (&start_mark, pfile);
4891: FORWARD(1); /* Skip second '-'. */
4892: for (;;)
4893: {
4894: c = GETC ();
4895: if (c == EOF)
4896: break;
4897: if (c == '\n')
4898: {
4899: /* Don't consider final '\n' to be part of comment. */
4900: FORWARD(-1);
4901: break;
4902: }
4903: }
4904: c = '-';
4905: goto return_comment;
4906: }
4907: if (c2 == '-' || c2 == '=' || c2 == '>')
4908: goto op2;
4909: goto randomchar;
4910:
4911: case '<':
4912: if (pfile->parsing_include_directive)
4913: {
4914: for (;;)
4915: {
4916: CPP_PUTC (pfile, c);
4917: if (c == '>')
4918: break;
4919: c = GETC ();
4920: NEWLINE_FIX1 (c);
4921: if (c == '\n' || c == EOF)
4922: {
4923: cpp_error (pfile,
4924: "missing '>' in `#include <FILENAME>'");
4925: break;
4926: }
4927: }
4928: return CPP_STRING;
4929: }
4930: /* else fall through */
4931: case '>':
4932: NEWLINE_FIX;
4933: c2 = PEEKC ();
4934: if (c2 == '=')
4935: goto op2;
4936: if (c2 != c)
4937: goto randomchar;
4938: FORWARD(1);
4939: CPP_RESERVE (pfile, 4);
4940: CPP_PUTC (pfile, c);
4941: CPP_PUTC (pfile, c2);
4942: NEWLINE_FIX;
4943: c3 = PEEKC ();
4944: if (c3 == '=')
4945: CPP_PUTC_Q (pfile, GETC ());
4946: CPP_NUL_TERMINATE_Q (pfile);
4947: pfile->only_seen_white = 0;
4948: return CPP_OTHER;
4949:
4950: case '@':
4951: if (CPP_BUFFER (pfile)->has_escapes)
4952: {
4953: c = GETC ();
4954: if (c == '-')
4955: {
4956: if (pfile->output_escapes)
4957: CPP_PUTS (pfile, "@-", 2);
4958: parse_name (pfile, GETC ());
4959: return CPP_NAME;
4960: }
4961: else if (is_space [c])
4962: {
4963: CPP_RESERVE (pfile, 2);
4964: if (pfile->output_escapes)
4965: CPP_PUTC_Q (pfile, '@');
4966: CPP_PUTC_Q (pfile, c);
4967: return CPP_HSPACE;
4968: }
4969: }
4970: if (pfile->output_escapes)
4971: {
4972: CPP_PUTS (pfile, "@@", 2);
4973: return CPP_OTHER;
4974: }
4975: goto randomchar;
4976:
4977: case '.':
4978: NEWLINE_FIX;
4979: c2 = PEEKC ();
4980: if (isdigit(c2))
4981: {
4982: CPP_RESERVE(pfile, 2);
4983: CPP_PUTC_Q (pfile, '.');
4984: c = GETC ();
4985: goto number;
4986: }
4987: /* FIXME - misses the case "..\\\n." */
4988: if (c2 == '.' && PEEKN(1) == '.')
4989: {
4990: CPP_RESERVE(pfile, 4);
4991: CPP_PUTC_Q (pfile, '.');
4992: CPP_PUTC_Q (pfile, '.');
4993: CPP_PUTC_Q (pfile, '.');
4994: FORWARD (2);
4995: CPP_NUL_TERMINATE_Q (pfile);
4996: pfile->only_seen_white = 0;
4997: return CPP_3DOTS;
4998: }
4999: goto randomchar;
5000:
5001: op2:
5002: token = CPP_OTHER;
5003: pfile->only_seen_white = 0;
5004: op2any:
5005: CPP_RESERVE(pfile, 3);
5006: CPP_PUTC_Q (pfile, c);
5007: CPP_PUTC_Q (pfile, GETC ());
5008: CPP_NUL_TERMINATE_Q (pfile);
5009: return token;
5010:
5011: case 'L':
5012: NEWLINE_FIX;
5013: c2 = PEEKC ();
5014: if ((c2 == '\'' || c2 == '\"') && !CPP_TRADITIONAL (pfile))
5015: {
5016: CPP_PUTC (pfile, c);
5017: c = GETC ();
5018: goto string;
5019: }
5020: goto letter;
5021:
5022: case '0': case '1': case '2': case '3': case '4':
5023: case '5': case '6': case '7': case '8': case '9':
5024: number:
5025: c2 = '.';
5026: for (;;)
5027: {
5028: CPP_RESERVE (pfile, 2);
5029: CPP_PUTC_Q (pfile, c);
5030: NEWLINE_FIX;
5031: c = PEEKC ();
5032: if (c == EOF)
5033: break;
5034: if (!is_idchar[c] && c != '.'
5035: && ((c2 != 'e' && c2 != 'E') || (c != '+' && c != '-')))
5036: break;
5037: FORWARD(1);
5038: c2= c;
5039: }
5040: CPP_NUL_TERMINATE_Q (pfile);
5041: pfile->only_seen_white = 0;
5042: return CPP_NUMBER;
5043: case 'b': case 'c': case 'd': case 'h': case 'o':
5044: case 'B': case 'C': case 'D': case 'H': case 'O':
5045: if (opts->chill && PEEKC () == '\'')
5046: {
5047: pfile->only_seen_white = 0;
5048: CPP_RESERVE (pfile, 2);
5049: CPP_PUTC_Q (pfile, c);
5050: CPP_PUTC_Q (pfile, '\'');
5051: FORWARD(1);
5052: for (;;)
5053: {
5054: c = GETC();
5055: if (c == EOF)
5056: goto chill_number_eof;
5057: if (!is_idchar[c])
5058: {
5059: if (c == '\\' && PEEKC() == '\n')
5060: {
5061: FORWARD(2);
5062: continue;
5063: }
5064: break;
5065: }
5066: CPP_PUTC (pfile, c);
5067: }
5068: if (c == '\'')
5069: {
5070: CPP_RESERVE (pfile, 2);
5071: CPP_PUTC_Q (pfile, c);
5072: CPP_NUL_TERMINATE_Q (pfile);
5073: return CPP_STRING;
5074: }
5075: else
5076: {
5077: FORWARD(-1);
5078: chill_number_eof:
5079: CPP_NUL_TERMINATE (pfile);
5080: return CPP_NUMBER;
5081: }
5082: }
5083: else
5084: goto letter;
5085: case '_':
5086: case 'a': case 'e': case 'f': case 'g': case 'i': case 'j':
5087: case 'k': case 'l': case 'm': case 'n': case 'p': case 'q':
5088: case 'r': case 's': case 't': case 'u': case 'v': case 'w':
5089: case 'x': case 'y': case 'z':
5090: case 'A': case 'E': case 'F': case 'G': case 'I': case 'J':
5091: case 'K': case 'M': case 'N': case 'P': case 'Q': case 'R':
5092: case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
5093: case 'Y': case 'Z':
5094: letter:
5095: {
5096: HASHNODE *hp;
5097: unsigned char *ident;
5098: int before_name_written = CPP_WRITTEN (pfile);
5099: int ident_len;
5100: parse_name (pfile, c);
5101: pfile->only_seen_white = 0;
5102: if (pfile->no_macro_expand)
5103: return CPP_NAME;
5104: ident = pfile->token_buffer + before_name_written;
5105: ident_len = CPP_PWRITTEN (pfile) - ident;
5106: hp = cpp_lookup (pfile, ident, ident_len, -1);
5107: if (!hp)
5108: return CPP_NAME;
5109: if (hp->type == T_DISABLED)
5110: {
5111: if (pfile->output_escapes)
5112: { /* Return "@-IDENT", followed by '\0'. */
5113: int i;
5114: CPP_RESERVE (pfile, 3);
5115: ident = pfile->token_buffer + before_name_written;
5116: CPP_ADJUST_WRITTEN (pfile, 2);
5117: for (i = ident_len; i >= 0; i--) ident[i+2] = ident[i];
5118: ident[0] = '@';
5119: ident[1] = '-';
5120: }
5121: return CPP_NAME;
5122: }
5123:
5124: /* If macro wants an arglist, verify that a '(' follows.
5125: first skip all whitespace, copying it to the output
5126: after the macro name. Then, if there is no '(',
5127: decide this is not a macro call and leave things that way. */
5128: if (hp->type == T_MACRO && hp->value.defn->nargs >= 0)
5129: {
5130: struct parse_marker macro_mark;
5131: int is_macro_call;
5132: while (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
5133: {
5134: cpp_buffer *next_buf;
5135: cpp_skip_hspace (pfile);
5136: if (PEEKC () != EOF)
5137: break;
5138: next_buf = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
5139: (*CPP_BUFFER (pfile)->cleanup) (CPP_BUFFER (pfile), pfile);
5140: CPP_BUFFER (pfile) = next_buf;
5141: }
5142: parse_set_mark (¯o_mark, pfile);
5143: for (;;)
5144: {
5145: cpp_skip_hspace (pfile);
5146: c = PEEKC ();
5147: is_macro_call = c == '(';
5148: if (c != '\n')
5149: break;
5150: FORWARD (1);
5151: }
5152: if (!is_macro_call)
5153: parse_goto_mark (¯o_mark, pfile);
5154: parse_clear_mark (¯o_mark);
5155: if (!is_macro_call)
5156: return CPP_NAME;
5157: }
5158: /* This is now known to be a macro call. */
5159:
5160: /* it might not actually be a macro. */
5161: if (hp->type != T_MACRO) {
5162: int xbuf_len; U_CHAR *xbuf;
5163: CPP_SET_WRITTEN (pfile, before_name_written);
5164: special_symbol (hp, pfile);
5165: xbuf_len = CPP_WRITTEN (pfile) - before_name_written;
5166: xbuf = (U_CHAR *) xmalloc (xbuf_len + 1);
5167: CPP_SET_WRITTEN (pfile, before_name_written);
5168: bcopy (CPP_PWRITTEN (pfile), xbuf, xbuf_len + 1);
5169: push_macro_expansion (pfile, xbuf, xbuf_len, hp);
5170: }
5171: else
5172: {
5173: /* Expand the macro, reading arguments as needed,
5174: and push the expansion on the input stack. */
5175: macroexpand (pfile, hp);
5176: CPP_SET_WRITTEN (pfile, before_name_written);
5177: }
5178:
5179: /* An extra "@ " is added to the end of a macro expansion
5180: to prevent accidental token pasting. We prefer to avoid
5181: unneeded extra spaces (for the sake of cpp-using tools like
5182: imake). Here we remove the space if it is safe to do so. */
5183: if (pfile->buffer->rlimit - pfile->buffer->cur >= 3
5184: && pfile->buffer->rlimit[-2] == '@'
5185: && pfile->buffer->rlimit[-1] == ' ')
5186: {
5187: int c1 = pfile->buffer->rlimit[-3];
5188: int c2 = CPP_BUF_PEEK (CPP_PREV_BUFFER (CPP_BUFFER (pfile)));
5189: if (c2 == EOF || ! unsafe_chars (c1, c2))
5190: pfile->buffer->rlimit -= 2;
5191: }
5192: }
5193: goto get_next;
5194:
5195: case ' ': case '\t': case '\v': case '\r':
5196: for (;;)
5197: {
5198: CPP_PUTC (pfile, c);
5199: c = PEEKC ();
5200: if (c == EOF || !is_hor_space[c])
5201: break;
5202: FORWARD(1);
5203: }
5204: return CPP_HSPACE;
5205:
5206: case '\\':
5207: c2 = PEEKC ();
5208: if (c2 != '\n')
5209: goto randomchar;
5210: token = CPP_HSPACE;
5211: goto op2any;
5212:
5213: case '\n':
5214: CPP_PUTC (pfile, c);
5215: if (pfile->only_seen_white == 0)
5216: pfile->only_seen_white = 1;
5217: pfile->lineno++;
5218: output_line_command (pfile, 1, same_file);
5219: return CPP_VSPACE;
5220:
5221: case '(': token = CPP_LPAREN; goto char1;
5222: case ')': token = CPP_RPAREN; goto char1;
5223: case '{': token = CPP_LBRACE; goto char1;
5224: case '}': token = CPP_RBRACE; goto char1;
5225: case ',': token = CPP_COMMA; goto char1;
5226: case ';': token = CPP_SEMICOLON; goto char1;
5227:
5228: randomchar:
5229: default:
5230: token = CPP_OTHER;
5231: char1:
5232: pfile->only_seen_white = 0;
5233: CPP_PUTC (pfile, c);
5234: return token;
5235: }
5236: }
5237: }
5238:
5239: /* Like cpp_get_token, but skip spaces and comments. */
5240: enum cpp_token
5241: cpp_get_non_space_token (pfile)
5242: cpp_reader *pfile;
5243: {
5244: int old_written = CPP_WRITTEN (pfile);
5245: for (;;)
5246: {
5247: enum cpp_token token = cpp_get_token (pfile);
5248: if (token != CPP_COMMENT && token != CPP_POP
5249: && token != CPP_HSPACE && token != CPP_VSPACE)
5250: return token;
5251: CPP_SET_WRITTEN (pfile, old_written);
5252: }
5253: }
5254:
5255: /* Parse an identifier starting with C. */
5256:
5257: int
5258: parse_name (pfile, c)
5259: cpp_reader *pfile; int c;
5260: {
5261: for (;;)
5262: {
5263: if (! is_idchar[c])
5264: {
5265: if (c == '\\' && PEEKC() == '\n')
5266: {
5267: FORWARD(2);
5268: continue;
5269: }
5270: FORWARD (-1);
5271: break;
5272: }
5273:
5274: CPP_RESERVE(pfile, 2); /* One more for final NUL. */
5275: CPP_PUTC_Q (pfile, c);
5276: c = GETC();
5277: if (c == EOF)
5278: break;
5279: }
5280: CPP_NUL_TERMINATE_Q (pfile);
5281: return 1;
5282: }
5283:
5284:
5285: /* Maintain and search list of included files, for #import. */
5286:
5287: /* Hash a file name for import_hash_table. */
5288:
5289: static int
5290: import_hash (f)
5291: char *f;
5292: {
5293: int val = 0;
5294:
5295: while (*f) val += *f++;
5296: return (val%IMPORT_HASH_SIZE);
5297: }
5298:
5299: /* Search for file FILENAME in import_hash_table.
5300: Return -2 if found, either a matching name or a matching inode.
5301: Otherwise, open the file and return a file descriptor if successful
5302: or -1 if unsuccessful. */
5303:
5304: static int
5305: lookup_import (pfile, filename, searchptr)
5306: cpp_reader *pfile;
5307: char *filename;
5308: struct file_name_list *searchptr;
5309: {
5310: struct import_file *i;
5311: int h;
5312: int hashval;
5313: struct stat sb;
5314: int fd;
5315:
5316: hashval = import_hash (filename);
5317:
5318: /* Attempt to find file in list of already included files */
5319: i = pfile->import_hash_table[hashval];
5320:
5321: while (i) {
5322: if (!strcmp (filename, i->name))
5323: return -2; /* return found */
5324: i = i->next;
5325: }
5326: /* Open it and try a match on inode/dev */
5327: fd = open_include_file (pfile, filename, searchptr);
5328: if (fd < 0)
5329: return fd;
5330: fstat (fd, &sb);
5331: for (h = 0; h < IMPORT_HASH_SIZE; h++) {
5332: i = pfile->import_hash_table[h];
5333: while (i) {
5334: /* Compare the inode and the device.
5335: Supposedly on some systems the inode is not a scalar. */
5336: if (!bcmp ((char *) &i->inode, (char *) &sb.st_ino, sizeof (sb.st_ino))
5337: && i->dev == sb.st_dev) {
5338: close (fd);
5339: return -2; /* return found */
5340: }
5341: i = i->next;
5342: }
5343: }
5344: return fd; /* Not found, return open file */
5345: }
5346:
5347: /* Add the file FNAME, open on descriptor FD, to import_hash_table. */
5348:
5349: static void
5350: add_import (pfile, fd, fname)
5351: cpp_reader *pfile;
5352: int fd;
5353: char *fname;
5354: {
5355: struct import_file *i;
5356: int hashval;
5357: struct stat sb;
5358:
5359: hashval = import_hash (fname);
5360: fstat (fd, &sb);
5361: i = (struct import_file *)xmalloc (sizeof (struct import_file));
5362: i->name = (char *)xmalloc (strlen (fname)+1);
5363: strcpy (i->name, fname);
5364: bcopy ((char *) &sb.st_ino, (char *) &i->inode, sizeof (sb.st_ino));
5365: i->dev = sb.st_dev;
5366: i->next = pfile->import_hash_table[hashval];
5367: pfile->import_hash_table[hashval] = i;
5368: }
5369:
5370: /* The file_name_map structure holds a mapping of file names for a
5371: particular directory. This mapping is read from the file named
5372: FILE_NAME_MAP_FILE in that directory. Such a file can be used to
5373: map filenames on a file system with severe filename restrictions,
5374: such as DOS. The format of the file name map file is just a series
5375: of lines with two tokens on each line. The first token is the name
5376: to map, and the second token is the actual name to use. */
5377:
5378: struct file_name_map
5379: {
5380: struct file_name_map *map_next;
5381: char *map_from;
5382: char *map_to;
5383: };
5384:
5385: #define FILE_NAME_MAP_FILE "header.gcc"
5386:
5387: /* Read a space delimited string of unlimited length from a stdio
5388: file. */
5389:
5390: static char *
5391: read_filename_string (ch, f)
5392: int ch;
5393: FILE *f;
5394: {
5395: char *alloc, *set;
5396: int len;
5397:
5398: len = 20;
5399: set = alloc = xmalloc (len + 1);
5400: if (! is_space[ch])
5401: {
5402: *set++ = ch;
5403: while ((ch = getc (f)) != EOF && ! is_space[ch])
5404: {
5405: if (set - alloc == len)
5406: {
5407: len *= 2;
5408: alloc = xrealloc (alloc, len + 1);
5409: set = alloc + len / 2;
5410: }
5411: *set++ = ch;
5412: }
5413: }
5414: *set = '\0';
5415: ungetc (ch, f);
5416: return alloc;
5417: }
5418:
5419: /* This structure holds a linked list of file name maps, one per directory. */
5420: struct file_name_map_list
5421: {
5422: struct file_name_map_list *map_list_next;
5423: char *map_list_name;
5424: struct file_name_map *map_list_map;
5425: };
5426:
5427: /* Read the file name map file for DIRNAME. */
5428:
5429: static struct file_name_map *
5430: read_name_map (pfile, dirname)
5431: cpp_reader *pfile;
5432: char *dirname;
5433: {
5434: register struct file_name_map_list *map_list_ptr;
5435: char *name;
5436: FILE *f;
5437:
5438: for (map_list_ptr = CPP_OPTIONS (pfile)->map_list; map_list_ptr;
5439: map_list_ptr = map_list_ptr->map_list_next)
5440: if (! strcmp (map_list_ptr->map_list_name, dirname))
5441: return map_list_ptr->map_list_map;
5442:
5443: map_list_ptr = ((struct file_name_map_list *)
5444: xmalloc (sizeof (struct file_name_map_list)));
5445: map_list_ptr->map_list_name = savestring (dirname);
5446: map_list_ptr->map_list_map = NULL;
5447:
5448: name = (char *) alloca (strlen (dirname) + strlen (FILE_NAME_MAP_FILE) + 2);
5449: strcpy (name, dirname);
5450: if (*dirname)
5451: strcat (name, "/");
5452: strcat (name, FILE_NAME_MAP_FILE);
5453: f = fopen (name, "r");
5454: if (!f)
5455: map_list_ptr->map_list_map = NULL;
5456: else
5457: {
5458: int ch;
5459: int dirlen = strlen (dirname);
5460:
5461: while ((ch = getc (f)) != EOF)
5462: {
5463: char *from, *to;
5464: struct file_name_map *ptr;
5465:
5466: if (is_space[ch])
5467: continue;
5468: from = read_filename_string (ch, f);
5469: while ((ch = getc (f)) != EOF && is_hor_space[ch])
5470: ;
5471: to = read_filename_string (ch, f);
5472:
5473: ptr = ((struct file_name_map *)
5474: xmalloc (sizeof (struct file_name_map)));
5475: ptr->map_from = from;
5476:
5477: /* Make the real filename absolute. */
5478: if (*to == '/')
5479: ptr->map_to = to;
5480: else
5481: {
5482: ptr->map_to = xmalloc (dirlen + strlen (to) + 2);
5483: strcpy (ptr->map_to, dirname);
5484: ptr->map_to[dirlen] = '/';
5485: strcpy (ptr->map_to + dirlen + 1, to);
5486: free (to);
5487: }
5488:
5489: ptr->map_next = map_list_ptr->map_list_map;
5490: map_list_ptr->map_list_map = ptr;
5491:
5492: while ((ch = getc (f)) != '\n')
5493: if (ch == EOF)
5494: break;
5495: }
5496: fclose (f);
5497: }
5498:
5499: map_list_ptr->map_list_next = CPP_OPTIONS (pfile)->map_list;
5500: CPP_OPTIONS (pfile)->map_list = map_list_ptr;
5501:
5502: return map_list_ptr->map_list_map;
5503: }
5504:
5505: /* Try to open include file FILENAME. SEARCHPTR is the directory
5506: being tried from the include file search path. This function maps
5507: filenames on file systems based on information read by
5508: read_name_map. */
5509:
5510: static int
5511: open_include_file (pfile, filename, searchptr)
5512: cpp_reader *pfile;
5513: char *filename;
5514: struct file_name_list *searchptr;
5515: {
5516: register struct file_name_map *map;
5517: register char *from;
5518: char *p, *dir;
5519:
5520: if (searchptr && ! searchptr->got_name_map)
5521: {
5522: searchptr->name_map = read_name_map (pfile,
5523: searchptr->fname
5524: ? searchptr->fname : ".");
5525: searchptr->got_name_map = 1;
5526: }
5527:
5528: /* First check the mapping for the directory we are using. */
5529: if (searchptr && searchptr->name_map)
5530: {
5531: from = filename;
5532: if (searchptr->fname)
5533: from += strlen (searchptr->fname) + 1;
5534: for (map = searchptr->name_map; map; map = map->map_next)
5535: {
5536: if (! strcmp (map->map_from, from))
5537: {
5538: /* Found a match. */
5539: return open (map->map_to, O_RDONLY, 0666);
5540: }
5541: }
5542: }
5543:
5544: /* Try to find a mapping file for the particular directory we are
5545: looking in. Thus #include <sys/types.h> will look up sys/types.h
5546: in /usr/include/header.gcc and look up types.h in
5547: /usr/include/sys/header.gcc. */
5548: p = rindex (filename, '/');
5549: if (! p)
5550: p = filename;
5551: if (searchptr
5552: && searchptr->fname
5553: && strlen (searchptr->fname) == p - filename
5554: && ! strncmp (searchptr->fname, filename, p - filename))
5555: {
5556: /* FILENAME is in SEARCHPTR, which we've already checked. */
5557: return open (filename, O_RDONLY, 0666);
5558: }
5559:
5560: if (p == filename)
5561: {
5562: dir = ".";
5563: from = filename;
5564: }
5565: else
5566: {
5567: dir = (char *) alloca (p - filename + 1);
5568: bcopy (filename, dir, p - filename);
5569: dir[p - filename] = '\0';
5570: from = p + 1;
5571: }
5572: for (map = read_name_map (pfile, dir); map; map = map->map_next)
5573: if (! strcmp (map->map_from, from))
5574: return open (map->map_to, O_RDONLY, 0666);
5575:
5576: return open (filename, O_RDONLY, 0666);
5577: }
5578:
5579: /* Process the contents of include file FNAME, already open on descriptor F,
5580: with output to OP.
5581: SYSTEM_HEADER_P is 1 if this file resides in any one of the known
5582: "system" include directories (as decided by the `is_system_include'
5583: function above).
5584: DIRPTR is the link in the dir path through which this file was found,
5585: or 0 if the file name was absolute or via the current directory.
5586: Return 1 on success, 0 on failure.
5587:
5588: The caller is responsible for the cpp_push_buffer. */
5589:
5590: static int
5591: finclude (pfile, f, fname, system_header_p, dirptr)
5592: cpp_reader *pfile;
5593: int f;
5594: char *fname;
5595: int system_header_p;
5596: struct file_name_list *dirptr;
5597: {
5598: int st_mode;
5599: long st_size;
5600: long i;
5601: int length;
5602: cpp_buffer *fp; /* For input stack frame */
5603: int missing_newline = 0;
5604:
5605: if (file_size_and_mode (f, &st_mode, &st_size) < 0)
5606: {
5607: cpp_perror_with_name (pfile, fname);
5608: close (f);
5609: cpp_pop_buffer (pfile);
5610: return 0;
5611: }
5612:
5613: fp = CPP_BUFFER (pfile);
5614: fp->nominal_fname = fp->fname = fname;
5615: #if 0
5616: fp->length = 0;
5617: #endif
5618: fp->dir = dirptr;
5619: fp->system_header_p = system_header_p;
5620: fp->lineno = 1;
5621: fp->colno = 1;
5622: fp->cleanup = file_cleanup;
5623:
5624: if (S_ISREG (st_mode)) {
5625: fp->buf = (U_CHAR *) xmalloc (st_size + 2);
5626: fp->alimit = fp->buf + st_size + 2;
5627: fp->cur = fp->buf;
5628:
5629: /* Read the file contents, knowing that st_size is an upper bound
5630: on the number of bytes we can read. */
5631: length = safe_read (f, fp->buf, st_size);
5632: fp->rlimit = fp->buf + length;
5633: if (length < 0) goto nope;
5634: }
5635: else if (S_ISDIR (st_mode)) {
5636: cpp_error (pfile, "directory `%s' specified in #include", fname);
5637: close (f);
5638: return 0;
5639: } else {
5640: /* Cannot count its file size before reading.
5641: First read the entire file into heap and
5642: copy them into buffer on stack. */
5643:
5644: int bsize = 2000;
5645:
5646: st_size = 0;
5647: fp->buf = (U_CHAR *) xmalloc (bsize + 2);
5648:
5649: for (;;) {
5650: i = safe_read (f, fp->buf + st_size, bsize - st_size);
5651: if (i < 0)
5652: goto nope; /* error! */
5653: st_size += i;
5654: if (st_size != bsize)
5655: break; /* End of file */
5656: bsize *= 2;
5657: fp->buf = (U_CHAR *) xrealloc (fp->buf, bsize + 2);
5658: }
5659: fp->cur = fp->buf;
5660: length = st_size;
5661: }
5662:
5663: if ((length > 0 && fp->buf[length - 1] != '\n')
5664: /* Backslash-newline at end is not good enough. */
5665: || (length > 1 && fp->buf[length - 2] == '\\')) {
5666: fp->buf[length++] = '\n';
5667: #if 0
5668: missing_newline = 1;
5669: #endif
5670: }
5671: fp->buf[length] = '\0';
5672: fp->rlimit = fp->buf + length;
5673:
5674: /* Close descriptor now, so nesting does not use lots of descriptors. */
5675: close (f);
5676:
5677: /* Must do this before calling trigraph_pcp, so that the correct file name
5678: will be printed in warning messages. */
5679:
5680: pfile->input_stack_listing_current = 0;
5681:
5682: #if 0
5683: if (!no_trigraphs)
5684: trigraph_pcp (fp);
5685: #endif
5686:
5687: #if 0
5688: rescan (op, 0);
5689:
5690: if (missing_newline)
5691: fp->lineno--;
5692:
5693: if (CPP_PEDANTIC (pfile) && missing_newline)
5694: pedwarn ("file does not end in newline");
5695:
5696: indepth--;
5697: input_file_stack_tick++;
5698: free (fp->buf);
5699: #endif
5700: return 1;
5701:
5702: nope:
5703:
5704: cpp_perror_with_name (pfile, fname);
5705: close (f);
5706: free (fp->buf);
5707: return 1;
5708: }
5709:
5710: int
5711: push_parse_file (pfile, fname)
5712: cpp_reader *pfile;
5713: char *fname;
5714: {
5715: struct cpp_options *opts = CPP_OPTIONS (pfile);
5716: struct cpp_pending *pend;
5717: char *p;
5718: int f;
5719: cpp_buffer *fp;
5720:
5721: /* The code looks at the defaults through this pointer, rather than through
5722: the constant structure above. This pointer gets changed if an environment
5723: variable specifies other defaults. */
5724: struct default_include *include_defaults = include_defaults_array;
5725:
5726: /* Add dirs from CPATH after dirs from -I. */
5727: /* There seems to be confusion about what CPATH should do,
5728: so for the moment it is not documented. */
5729: /* Some people say that CPATH should replace the standard include dirs,
5730: but that seems pointless: it comes before them, so it overrides them
5731: anyway. */
5732: p = (char *) getenv ("CPATH");
5733: if (p != 0 && ! opts->no_standard_includes)
5734: path_include (pfile, p);
5735:
5736: /* Now that dollars_in_ident is known, initialize is_idchar. */
5737: initialize_char_syntax (opts);
5738:
5739: /* Do partial setup of input buffer for the sake of generating
5740: early #line directives (when -g is in effect). */
5741: fp = cpp_push_buffer (pfile, NULL, 0);
5742: if (opts->in_fname == NULL)
5743: opts->in_fname = "";
5744: fp->nominal_fname = fp->fname = opts->in_fname;
5745: fp->lineno = 0;
5746:
5747: /* Install __LINE__, etc. Must follow initialize_char_syntax
5748: and option processing. */
5749: initialize_builtins (pfile);
5750:
5751: /* Do standard #defines and assertions
5752: that identify system and machine type. */
5753:
5754: if (!opts->inhibit_predefs) {
5755: char *p = (char *) alloca (strlen (predefs) + 1);
5756: strcpy (p, predefs);
5757: while (*p) {
5758: char *q;
5759: while (*p == ' ' || *p == '\t')
5760: p++;
5761: /* Handle -D options. */
5762: if (p[0] == '-' && p[1] == 'D') {
5763: q = &p[2];
5764: while (*p && *p != ' ' && *p != '\t')
5765: p++;
5766: if (*p != 0)
5767: *p++= 0;
5768: if (opts->debug_output)
5769: output_line_command (pfile, 0, same_file);
5770: cpp_define (pfile, q);
5771: while (*p == ' ' || *p == '\t')
5772: p++;
5773: } else if (p[0] == '-' && p[1] == 'A') {
5774: /* Handle -A options (assertions). */
5775: char *assertion;
5776: char *past_name;
5777: char *value;
5778: char *past_value;
5779: char *termination;
5780: int save_char;
5781:
5782: assertion = &p[2];
5783: past_name = assertion;
5784: /* Locate end of name. */
5785: while (*past_name && *past_name != ' '
5786: && *past_name != '\t' && *past_name != '(')
5787: past_name++;
5788: /* Locate `(' at start of value. */
5789: value = past_name;
5790: while (*value && (*value == ' ' || *value == '\t'))
5791: value++;
5792: if (*value++ != '(')
5793: abort ();
5794: while (*value && (*value == ' ' || *value == '\t'))
5795: value++;
5796: past_value = value;
5797: /* Locate end of value. */
5798: while (*past_value && *past_value != ' '
5799: && *past_value != '\t' && *past_value != ')')
5800: past_value++;
5801: termination = past_value;
5802: while (*termination && (*termination == ' ' || *termination == '\t'))
5803: termination++;
5804: if (*termination++ != ')')
5805: abort ();
5806: if (*termination && *termination != ' ' && *termination != '\t')
5807: abort ();
5808: /* Temporarily null-terminate the value. */
5809: save_char = *termination;
5810: *termination = '\0';
5811: /* Install the assertion. */
5812: make_assertion (pfile, "-A", assertion);
5813: *termination = (char) save_char;
5814: p = termination;
5815: while (*p == ' ' || *p == '\t')
5816: p++;
5817: } else {
5818: abort ();
5819: }
5820: }
5821: }
5822:
5823: /* Now handle the command line options. */
5824:
5825: /* Do -U's, -D's and -A's in the order they were seen. */
5826: /* First reverse the list. */
5827: opts->pending = nreverse_pending (opts->pending);
5828:
5829: for (pend = opts->pending; pend; pend = pend->next)
5830: {
5831: if (pend->cmd != NULL && pend->cmd[0] == '-')
5832: {
5833: switch (pend->cmd[1])
5834: {
5835: case 'U':
5836: if (opts->debug_output)
5837: output_line_command (pfile, 0, same_file);
5838: do_undef (pfile, NULL, pend->arg, pend->arg + strlen (pend->arg));
5839: break;
5840: case 'D':
5841: if (opts->debug_output)
5842: output_line_command (pfile, 0, same_file);
5843: cpp_define (pfile, pend->arg);
5844: break;
5845: case 'A':
5846: make_assertion (pfile, "-A", pend->arg);
5847: break;
5848: }
5849: }
5850: }
5851:
5852: opts->done_initializing = 1;
5853:
5854: { /* read the appropriate environment variable and if it exists
5855: replace include_defaults with the listed path. */
5856: char *epath = 0;
5857: switch ((opts->objc << 1) + opts->cplusplus)
5858: {
5859: case 0:
5860: epath = getenv ("C_INCLUDE_PATH");
5861: break;
5862: case 1:
5863: epath = getenv ("CPLUS_INCLUDE_PATH");
5864: break;
5865: case 2:
5866: epath = getenv ("OBJC_INCLUDE_PATH");
5867: break;
5868: case 3:
5869: epath = getenv ("OBJCPLUS_INCLUDE_PATH");
5870: break;
5871: }
5872: /* If the environment var for this language is set,
5873: add to the default list of include directories. */
5874: if (epath) {
5875: char *nstore = (char *) alloca (strlen (epath) + 2);
5876: int num_dirs;
5877: char *startp, *endp;
5878:
5879: for (num_dirs = 1, startp = epath; *startp; startp++)
5880: if (*startp == PATH_SEPARATOR)
5881: num_dirs++;
5882: include_defaults
5883: = (struct default_include *) xmalloc ((num_dirs
5884: * sizeof (struct default_include))
5885: + sizeof (include_defaults_array));
5886: startp = endp = epath;
5887: num_dirs = 0;
5888: while (1) {
5889: /* Handle cases like c:/usr/lib:d:/gcc/lib */
5890: if ((*endp == PATH_SEPARATOR)
5891: || *endp == 0) {
5892: strncpy (nstore, startp, endp-startp);
5893: if (endp == startp)
5894: strcpy (nstore, ".");
5895: else
5896: nstore[endp-startp] = '\0';
5897:
5898: include_defaults[num_dirs].fname = savestring (nstore);
5899: include_defaults[num_dirs].cplusplus = opts->cplusplus;
5900: include_defaults[num_dirs].cxx_aware = 1;
5901: num_dirs++;
5902: if (*endp == '\0')
5903: break;
5904: endp = startp = endp + 1;
5905: } else
5906: endp++;
5907: }
5908: /* Put the usual defaults back in at the end. */
5909: bcopy ((char *) include_defaults_array,
5910: (char *) &include_defaults[num_dirs],
5911: sizeof (include_defaults_array));
5912: }
5913: }
5914:
5915: append_include_chain (pfile, opts->before_system, opts->last_before_system);
5916: opts->first_system_include = opts->before_system;
5917:
5918: /* Unless -fnostdinc,
5919: tack on the standard include file dirs to the specified list */
5920: if (!opts->no_standard_includes) {
5921: struct default_include *p = include_defaults;
5922: char *specd_prefix = opts->include_prefix;
5923: char *default_prefix = savestring (GCC_INCLUDE_DIR);
5924: int default_len = 0;
5925: /* Remove the `include' from /usr/local/lib/gcc.../include. */
5926: if (!strcmp (default_prefix + strlen (default_prefix) - 8, "/include")) {
5927: default_len = strlen (default_prefix) - 7;
5928: default_prefix[default_len] = 0;
5929: }
5930: /* Search "translated" versions of GNU directories.
5931: These have /usr/local/lib/gcc... replaced by specd_prefix. */
5932: if (specd_prefix != 0 && default_len != 0)
5933: for (p = include_defaults; p->fname; p++) {
5934: /* Some standard dirs are only for C++. */
5935: if (!p->cplusplus
5936: || (opts->cplusplus && !opts->no_standard_cplusplus_includes)) {
5937: /* Does this dir start with the prefix? */
5938: if (!strncmp (p->fname, default_prefix, default_len)) {
5939: /* Yes; change prefix and add to search list. */
5940: struct file_name_list *new
5941: = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
5942: int this_len = strlen (specd_prefix) + strlen (p->fname) - default_len;
5943: char *str = (char *) xmalloc (this_len + 1);
5944: strcpy (str, specd_prefix);
5945: strcat (str, p->fname + default_len);
5946: new->fname = str;
5947: new->control_macro = 0;
5948: new->c_system_include_path = !p->cxx_aware;
5949: new->got_name_map = 0;
5950: append_include_chain (pfile, new, new);
5951: if (opts->first_system_include == 0)
5952: opts->first_system_include = new;
5953: }
5954: }
5955: }
5956: /* Search ordinary names for GNU include directories. */
5957: for (p = include_defaults; p->fname; p++) {
5958: /* Some standard dirs are only for C++. */
5959: if (!p->cplusplus
5960: || (opts->cplusplus && !opts->no_standard_cplusplus_includes)) {
5961: struct file_name_list *new
5962: = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
5963: new->control_macro = 0;
5964: new->c_system_include_path = !p->cxx_aware;
5965: new->fname = p->fname;
5966: new->got_name_map = 0;
5967: append_include_chain (pfile, new, new);
5968: if (opts->first_system_include == 0)
5969: opts->first_system_include = new;
5970: }
5971: }
5972: }
5973:
5974: /* Tack the after_include chain at the end of the include chain. */
5975: append_include_chain (pfile, opts->after_include, opts->last_after_include);
5976: if (opts->first_system_include == 0)
5977: opts->first_system_include = opts->after_include;
5978:
5979: /* With -v, print the list of dirs to search. */
5980: if (opts->verbose) {
5981: struct file_name_list *p;
5982: fprintf (stderr, "#include \"...\" search starts here:\n");
5983: for (p = opts->include; p; p = p->next) {
5984: if (p == opts->first_bracket_include)
5985: fprintf (stderr, "#include <...> search starts here:\n");
5986: fprintf (stderr, " %s\n", p->fname);
5987: }
5988: fprintf (stderr, "End of search list.\n");
5989: }
5990:
5991: /* Scan the -imacros files before the main input.
5992: Much like #including them, but with no_output set
5993: so that only their macro definitions matter. */
5994:
5995: opts->no_output++; pfile->no_record_file++;
5996: for (pend = opts->pending; pend; pend = pend->next)
5997: {
5998: if (pend->cmd != NULL && strcmp (pend->cmd, "-imacros") == 0)
5999: {
6000: int fd = open (pend->arg, O_RDONLY, 0666);
6001: if (fd < 0)
6002: {
6003: cpp_perror_with_name (pfile, pend->arg);
6004: return FATAL_EXIT_CODE;
6005: }
6006: cpp_push_buffer (pfile, NULL, 0);
6007: finclude (pfile, fd, pend->arg, 0, NULL_PTR);
6008: cpp_scan_buffer (pfile);
6009: }
6010: }
6011: opts->no_output--; pfile->no_record_file--;
6012:
6013: /* Copy the entire contents of the main input file into
6014: the stacked input buffer previously allocated for it. */
6015: if (fname == NULL || *fname == 0) {
6016: fname = "";
6017: f = 0;
6018: } else if ((f = open (fname, O_RDONLY, 0666)) < 0)
6019: cpp_pfatal_with_name (pfile, fname);
6020:
6021: /* -MG doesn't select the form of output and must be specified with one of
6022: -M or -MM. -MG doesn't make sense with -MD or -MMD since they don't
6023: inhibit compilation. */
6024: if (opts->print_deps_missing_files
6025: && (opts->print_deps == 0 || !opts->no_output))
6026: fatal (pfile, "-MG must be specified with one of -M or -MM");
6027:
6028: /* Either of two environment variables can specify output of deps.
6029: Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
6030: where OUTPUT_FILE is the file to write deps info to
6031: and DEPS_TARGET is the target to mention in the deps. */
6032:
6033: if (opts->print_deps == 0
6034: && (getenv ("SUNPRO_DEPENDENCIES") != 0
6035: || getenv ("DEPENDENCIES_OUTPUT") != 0)) {
6036: char *spec = getenv ("DEPENDENCIES_OUTPUT");
6037: char *s;
6038: char *output_file;
6039:
6040: if (spec == 0)
6041: {
6042: spec = getenv ("SUNPRO_DEPENDENCIES");
6043: opts->print_deps = 2;
6044: }
6045: else
6046: opts->print_deps = 1;
6047:
6048: s = spec;
6049: /* Find the space before the DEPS_TARGET, if there is one. */
6050: /* This should use index. (mrs) */
6051: while (*s != 0 && *s != ' ') s++;
6052: if (*s != 0)
6053: {
6054: opts->deps_target = s + 1;
6055: output_file = (char *) xmalloc (s - spec + 1);
6056: bcopy (spec, output_file, s - spec);
6057: output_file[s - spec] = 0;
6058: }
6059: else
6060: {
6061: opts->deps_target = 0;
6062: output_file = spec;
6063: }
6064:
6065: opts->deps_file = output_file;
6066: opts->print_deps_append = 1;
6067: }
6068:
6069: /* For -M, print the expected object file name
6070: as the target of this Make-rule. */
6071: if (opts->print_deps)
6072: {
6073: pfile->deps_allocated_size = 200;
6074: pfile->deps_buffer = (char *) xmalloc (pfile->deps_allocated_size);
6075: pfile->deps_buffer[0] = 0;
6076: pfile->deps_size = 0;
6077: pfile->deps_column = 0;
6078:
6079: if (opts->deps_target)
6080: deps_output (pfile, opts->deps_target, ':');
6081: else if (*opts->in_fname == 0)
6082: deps_output (pfile, "-", ':');
6083: else
6084: {
6085: char *p, *q;
6086: int len;
6087:
6088: /* Discard all directory prefixes from filename. */
6089: if ((q = rindex (opts->in_fname, '/')) != NULL
6090: #ifdef DIR_SEPARATOR
6091: && (q = rindex (opts->in_fname, DIR_SEPARATOR)) != NULL
6092: #endif
6093: )
6094: ++q;
6095: else
6096: q = opts->in_fname;
6097:
6098: /* Copy remainder to mungable area. */
6099: p = (char *) alloca (strlen(q) + 8);
6100: strcpy (p, q);
6101:
6102: /* Output P, but remove known suffixes. */
6103: len = strlen (p);
6104: q = p + len;
6105: if (len >= 2
6106: && p[len - 2] == '.'
6107: && index("cCsSm", p[len - 1]))
6108: q = p + (len - 2);
6109: else if (len >= 3
6110: && p[len - 3] == '.'
6111: && p[len - 2] == 'c'
6112: && p[len - 1] == 'c')
6113: q = p + (len - 3);
6114: else if (len >= 4
6115: && p[len - 4] == '.'
6116: && p[len - 3] == 'c'
6117: && p[len - 2] == 'x'
6118: && p[len - 1] == 'x')
6119: q = p + (len - 4);
6120: else if (len >= 4
6121: && p[len - 4] == '.'
6122: && p[len - 3] == 'c'
6123: && p[len - 2] == 'p'
6124: && p[len - 1] == 'p')
6125: q = p + (len - 4);
6126:
6127: /* Supply our own suffix. */
6128: #ifndef VMS
6129: strcpy (q, ".o");
6130: #else
6131: strcpy (q, ".obj");
6132: #endif
6133:
6134: deps_output (pfile, p, ':');
6135: deps_output (pfile, opts->in_fname, ' ');
6136: }
6137: }
6138:
6139: #if 0
6140: /* Make sure data ends with a newline. And put a null after it. */
6141:
6142: if ((fp->length > 0 && fp->buf[fp->length - 1] != '\n')
6143: /* Backslash-newline at end is not good enough. */
6144: || (fp->length > 1 && fp->buf[fp->length - 2] == '\\')) {
6145: fp->buf[fp->length++] = '\n';
6146: missing_newline = 1;
6147: }
6148: fp->buf[fp->length] = '\0';
6149:
6150: /* Unless inhibited, convert trigraphs in the input. */
6151:
6152: if (!no_trigraphs)
6153: trigraph_pcp (fp);
6154: #endif
6155:
6156: /* Scan the -include files before the main input.
6157: We push these in reverse order, so that the first one is handled first. */
6158:
6159: pfile->no_record_file++;
6160: opts->pending = nreverse_pending (opts->pending);
6161: for (pend = opts->pending; pend; pend = pend->next)
6162: {
6163: if (pend->cmd != NULL && strcmp (pend->cmd, "-include") == 0)
6164: {
6165: int fd = open (pend->arg, O_RDONLY, 0666);
6166: if (fd < 0)
6167: {
6168: cpp_perror_with_name (pfile, pend->arg);
6169: return FATAL_EXIT_CODE;
6170: }
6171: cpp_push_buffer (pfile, NULL, 0);
6172: finclude (pfile, fd, pend->arg, 0, NULL_PTR);
6173: }
6174: }
6175: pfile->no_record_file--;
6176:
6177: /* Free the pending list. */
6178: for (pend = opts->pending; pend; )
6179: {
6180: struct cpp_pending *next = pend->next;
6181: free (pend);
6182: pend = next;
6183: }
6184: opts->pending = NULL;
6185:
6186: #if 0
6187: /* Scan the input, processing macros and directives. */
6188:
6189: rescan (&outbuf, 0);
6190:
6191: if (missing_newline)
6192: fp->lineno--;
6193:
6194: if (CPP_PEDANTIC (pfile) && missing_newline)
6195: pedwarn ("file does not end in newline");
6196:
6197: #endif
6198: if (finclude (pfile, f, fname, 0, NULL_PTR))
6199: output_line_command (pfile, 0, same_file);
6200: return SUCCESS_EXIT_CODE;
6201: }
6202:
6203: void
6204: init_parse_file (pfile)
6205: cpp_reader *pfile;
6206: {
6207: bzero ((char *) pfile, sizeof (cpp_reader));
6208: pfile->get_token = cpp_get_token;
6209:
6210: pfile->token_buffer_size = 200;
6211: pfile->token_buffer = (U_CHAR*)xmalloc (pfile->token_buffer_size);
6212: CPP_SET_WRITTEN (pfile, 0);
6213:
6214: pfile->system_include_depth = 0;
6215: pfile->dont_repeat_files = 0;
6216: pfile->all_include_files = 0;
6217: pfile->max_include_len = 0;
6218: pfile->timebuf = NULL;
6219: pfile->only_seen_white = 1;
6220: pfile->buffer = CPP_NULL_BUFFER(pfile);
6221: }
6222:
6223: static struct cpp_pending *
6224: nreverse_pending (list)
6225: struct cpp_pending *list;
6226:
6227: {
6228: register struct cpp_pending *prev = 0, *next, *pend;
6229: for (pend = list; pend; pend = next)
6230: {
6231: next = pend->next;
6232: pend->next = prev;
6233: prev = pend;
6234: }
6235: return prev;
6236: }
6237:
6238: static void
6239: push_pending (pfile, cmd, arg)
6240: cpp_reader *pfile;
6241: char *cmd;
6242: char *arg;
6243: {
6244: struct cpp_pending *pend
6245: = (struct cpp_pending*)xmalloc (sizeof (struct cpp_pending));
6246: pend->cmd = cmd;
6247: pend->arg = arg;
6248: pend->next = CPP_OPTIONS (pfile)->pending;
6249: CPP_OPTIONS (pfile)->pending = pend;
6250: }
6251:
6252: /* Handle command-line options in (argc, argv).
6253: Can be called multiple times, to handle multiple sets of options.
6254: Returns if an unrecognized option is seen.
6255: Returns number of handled arguments. */
6256:
6257: int
6258: cpp_handle_options (pfile, argc, argv)
6259: cpp_reader *pfile;
6260: int argc;
6261: char **argv;
6262: {
6263: int i;
6264: struct cpp_options *opts = CPP_OPTIONS (pfile);
6265: for (i = 0; i < argc; i++) {
6266: if (argv[i][0] != '-') {
6267: if (opts->out_fname != NULL)
6268: fatal ("Usage: %s [switches] input output", argv[0]);
6269: else if (opts->in_fname != NULL)
6270: opts->out_fname = argv[i];
6271: else
6272: opts->in_fname = argv[i];
6273: } else {
6274: switch (argv[i][1]) {
6275:
6276: case 'i':
6277: if (!strcmp (argv[i], "-include")
6278: || !strcmp (argv[i], "-imacros")) {
6279: if (i + 1 == argc)
6280: fatal ("Filename missing after `%s' option", argv[i]);
6281: else
6282: push_pending (pfile, argv[i], argv[i+1]), i++;
6283: }
6284: if (!strcmp (argv[i], "-iprefix")) {
6285: if (i + 1 == argc)
6286: fatal ("Filename missing after `-iprefix' option");
6287: else
6288: opts->include_prefix = argv[++i];
6289: }
6290: if (!strcmp (argv[i], "-ifoutput")) {
6291: opts->output_conditionals = 1;
6292: }
6293: if (!strcmp (argv[i], "-isystem")) {
6294: struct file_name_list *dirtmp;
6295:
6296: if (i + 1 == argc)
6297: fatal ("Filename missing after `-isystem' option");
6298:
6299: dirtmp = (struct file_name_list *)
6300: xmalloc (sizeof (struct file_name_list));
6301: dirtmp->next = 0;
6302: dirtmp->control_macro = 0;
6303: dirtmp->c_system_include_path = 1;
6304: dirtmp->fname = (char *) xmalloc (strlen (argv[i+1]) + 1);
6305: strcpy (dirtmp->fname, argv[++i]);
6306: dirtmp->got_name_map = 0;
6307:
6308: if (opts->before_system == 0)
6309: opts->before_system = dirtmp;
6310: else
6311: opts->last_before_system->next = dirtmp;
6312: opts->last_before_system = dirtmp; /* Tail follows the last one */
6313: }
6314: /* Add directory to end of path for includes,
6315: with the default prefix at the front of its name. */
6316: if (!strcmp (argv[i], "-iwithprefix")) {
6317: struct file_name_list *dirtmp;
6318: char *prefix;
6319:
6320: if (opts->include_prefix != 0)
6321: prefix = opts->include_prefix;
6322: else {
6323: prefix = savestring (GCC_INCLUDE_DIR);
6324: /* Remove the `include' from /usr/local/lib/gcc.../include. */
6325: if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
6326: prefix[strlen (prefix) - 7] = 0;
6327: }
6328:
6329: dirtmp = (struct file_name_list *)
6330: xmalloc (sizeof (struct file_name_list));
6331: dirtmp->next = 0; /* New one goes on the end */
6332: dirtmp->control_macro = 0;
6333: dirtmp->c_system_include_path = 0;
6334: if (i + 1 == argc)
6335: fatal ("Directory name missing after `-iwithprefix' option");
6336:
6337: dirtmp->fname = (char *) xmalloc (strlen (argv[i+1])
6338: + strlen (prefix) + 1);
6339: strcpy (dirtmp->fname, prefix);
6340: strcat (dirtmp->fname, argv[++i]);
6341: dirtmp->got_name_map = 0;
6342:
6343: if (opts->after_include == 0)
6344: opts->after_include = dirtmp;
6345: else
6346: opts->last_after_include->next = dirtmp;
6347: opts->last_after_include = dirtmp; /* Tail follows the last one */
6348: }
6349: /* Add directory to main path for includes,
6350: with the default prefix at the front of its name. */
6351: if (!strcmp (argv[i], "-iwithprefixbefore")) {
6352: struct file_name_list *dirtmp;
6353: char *prefix;
6354:
6355: if (opts->include_prefix != 0)
6356: prefix = opts->include_prefix;
6357: else {
6358: prefix = savestring (GCC_INCLUDE_DIR);
6359: /* Remove the `include' from /usr/local/lib/gcc.../include. */
6360: if (!strcmp (prefix + strlen (prefix) - 8, "/include"))
6361: prefix[strlen (prefix) - 7] = 0;
6362: }
6363:
6364: dirtmp = (struct file_name_list *)
6365: xmalloc (sizeof (struct file_name_list));
6366: dirtmp->next = 0; /* New one goes on the end */
6367: dirtmp->control_macro = 0;
6368: dirtmp->c_system_include_path = 0;
6369: if (i + 1 == argc)
6370: fatal ("Directory name missing after `-iwithprefixbefore' option");
6371:
6372: dirtmp->fname = (char *) xmalloc (strlen (argv[i+1])
6373: + strlen (prefix) + 1);
6374: strcpy (dirtmp->fname, prefix);
6375: strcat (dirtmp->fname, argv[++i]);
6376: dirtmp->got_name_map = 0;
6377:
6378: append_include_chain (pfile, dirtmp, dirtmp);
6379: }
6380: /* Add directory to end of path for includes. */
6381: if (!strcmp (argv[i], "-idirafter")) {
6382: struct file_name_list *dirtmp;
6383:
6384: dirtmp = (struct file_name_list *)
6385: xmalloc (sizeof (struct file_name_list));
6386: dirtmp->next = 0; /* New one goes on the end */
6387: dirtmp->control_macro = 0;
6388: dirtmp->c_system_include_path = 0;
6389: if (i + 1 == argc)
6390: fatal ("Directory name missing after `-idirafter' option");
6391: else
6392: dirtmp->fname = argv[++i];
6393: dirtmp->got_name_map = 0;
6394:
6395: if (opts->after_include == 0)
6396: opts->after_include = dirtmp;
6397: else
6398: opts->last_after_include->next = dirtmp;
6399: opts->last_after_include = dirtmp; /* Tail follows the last one */
6400: }
6401: break;
6402:
6403: case 'o':
6404: if (opts->out_fname != NULL)
6405: fatal ("Output filename specified twice");
6406: if (i + 1 == argc)
6407: fatal ("Filename missing after -o option");
6408: opts->out_fname = argv[++i];
6409: if (!strcmp (opts->out_fname, "-"))
6410: opts->out_fname = "";
6411: break;
6412:
6413: case 'p':
6414: if (!strcmp (argv[i], "-pedantic"))
6415: CPP_PEDANTIC (pfile) = 1;
6416: else if (!strcmp (argv[i], "-pedantic-errors")) {
6417: CPP_PEDANTIC (pfile) = 1;
6418: opts->pedantic_errors = 1;
6419: }
6420: #if 0
6421: else if (!strcmp (argv[i], "-pcp")) {
6422: char *pcp_fname = argv[++i];
6423: pcp_outfile =
6424: ((pcp_fname[0] != '-' || pcp_fname[1] != '\0')
6425: ? fopen (pcp_fname, "w")
6426: : fdopen (dup (fileno (stdout)), "w"));
6427: if (pcp_outfile == 0)
6428: cpp_pfatal_with_name (pfile, pcp_fname);
6429: no_precomp = 1;
6430: }
6431: #endif
6432: break;
6433:
6434: case 't':
6435: if (!strcmp (argv[i], "-traditional")) {
6436: opts->traditional = 1;
6437: if (opts->dollars_in_ident > 0)
6438: opts->dollars_in_ident = 1;
6439: } else if (!strcmp (argv[i], "-trigraphs")) {
6440: if (!opts->chill)
6441: opts->no_trigraphs = 0;
6442: }
6443: break;
6444:
6445: case 'l':
6446: if (! strcmp (argv[i], "-lang-c"))
6447: opts->cplusplus = 0, opts->cplusplus_comments = 0, opts->objc = 0;
6448: if (! strcmp (argv[i], "-lang-c++"))
6449: opts->cplusplus = 1, opts->cplusplus_comments = 1, opts->objc = 0;
6450: if (! strcmp (argv[i], "-lang-c-c++-comments"))
6451: opts->cplusplus = 0, opts->cplusplus_comments = 1, opts->objc = 0;
6452: if (! strcmp (argv[i], "-lang-objc"))
6453: opts->objc = 1, opts->cplusplus = 0, opts->cplusplus_comments = 1;
6454: if (! strcmp (argv[i], "-lang-objc++"))
6455: opts->objc = 1, opts->cplusplus = 1, opts->cplusplus_comments = 1;
6456: if (! strcmp (argv[i], "-lang-asm"))
6457: opts->lang_asm = 1;
6458: if (! strcmp (argv[i], "-lint"))
6459: opts->for_lint = 1;
6460: if (! strcmp (argv[i], "-lang-chill"))
6461: opts->objc = 0, opts->cplusplus = 0, opts->chill = 1,
6462: opts->traditional = 1, opts->no_trigraphs = 1;
6463: break;
6464:
6465: case '+':
6466: opts->cplusplus = 1, opts->cplusplus_comments = 1;
6467: break;
6468:
6469: case 'w':
6470: opts->inhibit_warnings = 1;
6471: break;
6472:
6473: case 'W':
6474: if (!strcmp (argv[i], "-Wtrigraphs"))
6475: opts->warn_trigraphs = 1;
6476: else if (!strcmp (argv[i], "-Wno-trigraphs"))
6477: opts->warn_trigraphs = 0;
6478: else if (!strcmp (argv[i], "-Wcomment"))
6479: opts->warn_comments = 1;
6480: else if (!strcmp (argv[i], "-Wno-comment"))
6481: opts->warn_comments = 0;
6482: else if (!strcmp (argv[i], "-Wcomments"))
6483: opts->warn_comments = 1;
6484: else if (!strcmp (argv[i], "-Wno-comments"))
6485: opts->warn_comments = 0;
6486: else if (!strcmp (argv[i], "-Wtraditional"))
6487: opts->warn_stringify = 1;
6488: else if (!strcmp (argv[i], "-Wno-traditional"))
6489: opts->warn_stringify = 0;
6490: else if (!strcmp (argv[i], "-Wimport"))
6491: opts->warn_import = 1;
6492: else if (!strcmp (argv[i], "-Wno-import"))
6493: opts->warn_import = 0;
6494: else if (!strcmp (argv[i], "-Werror"))
6495: opts->warnings_are_errors = 1;
6496: else if (!strcmp (argv[i], "-Wno-error"))
6497: opts->warnings_are_errors = 0;
6498: else if (!strcmp (argv[i], "-Wall"))
6499: {
6500: opts->warn_trigraphs = 1;
6501: opts->warn_comments = 1;
6502: }
6503: break;
6504:
6505: case 'M':
6506: /* The style of the choices here is a bit mixed.
6507: The chosen scheme is a hybrid of keeping all options in one string
6508: and specifying each option in a separate argument:
6509: -M|-MM|-MD file|-MMD file [-MG]. An alternative is:
6510: -M|-MM|-MD file|-MMD file|-MG|-MMG; or more concisely:
6511: -M[M][G][D file]. This is awkward to handle in specs, and is not
6512: as extensible. */
6513: /* ??? -MG must be specified in addition to one of -M or -MM.
6514: This can be relaxed in the future without breaking anything.
6515: The converse isn't true. */
6516:
6517: /* -MG isn't valid with -MD or -MMD. This is checked for later. */
6518: if (!strcmp (argv[i], "-MG"))
6519: {
6520: opts->print_deps_missing_files = 1;
6521: break;
6522: }
6523: if (!strcmp (argv[i], "-M"))
6524: opts->print_deps = 2;
6525: else if (!strcmp (argv[i], "-MM"))
6526: opts->print_deps = 1;
6527: else if (!strcmp (argv[i], "-MD"))
6528: opts->print_deps = 2;
6529: else if (!strcmp (argv[i], "-MMD"))
6530: opts->print_deps = 1;
6531: /* For -MD and -MMD options, write deps on file named by next arg. */
6532: if (!strcmp (argv[i], "-MD") || !strcmp (argv[i], "-MMD"))
6533: {
6534: if (i+1 == argc)
6535: fatal ("Filename missing after %s option", argv[i]);
6536: opts->deps_file = argv[++i];
6537: }
6538: else
6539: {
6540: /* For -M and -MM, write deps on standard output
6541: and suppress the usual output. */
6542: opts->no_output = 1;
6543: }
6544: break;
6545:
6546: case 'd':
6547: {
6548: char *p = argv[i] + 2;
6549: char c;
6550: while ((c = *p++) != 0) {
6551: /* Arg to -d specifies what parts of macros to dump */
6552: switch (c) {
6553: case 'M':
6554: opts->dump_macros = dump_only;
6555: opts->no_output = 1;
6556: break;
6557: case 'N':
6558: opts->dump_macros = dump_names;
6559: break;
6560: case 'D':
6561: opts->dump_macros = dump_definitions;
6562: break;
6563: }
6564: }
6565: }
6566: break;
6567:
6568: case 'g':
6569: if (argv[i][2] == '3')
6570: opts->debug_output = 1;
6571: break;
6572:
6573: case 'v':
6574: fprintf (stderr, "GNU CPP version %s", version_string);
6575: #ifdef TARGET_VERSION
6576: TARGET_VERSION;
6577: #endif
6578: fprintf (stderr, "\n");
6579: opts->verbose = 1;
6580: break;
6581:
6582: case 'H':
6583: opts->print_include_names = 1;
6584: break;
6585:
6586: case 'D':
6587: if (argv[i][2] != 0)
6588: push_pending (pfile, "-D", argv[i] + 2);
6589: else if (i + 1 == argc)
6590: fatal ("Macro name missing after -D option");
6591: else
6592: i++, push_pending (pfile, "-D", argv[i]);
6593: break;
6594:
6595: case 'A':
6596: {
6597: char *p;
6598:
6599: if (argv[i][2] != 0)
6600: p = argv[i] + 2;
6601: else if (i + 1 == argc)
6602: fatal ("Assertion missing after -A option");
6603: else
6604: p = argv[++i];
6605:
6606: if (!strcmp (p, "-")) {
6607: struct cpp_pending **ptr;
6608: /* -A- eliminates all predefined macros and assertions.
6609: Let's include also any that were specified earlier
6610: on the command line. That way we can get rid of any
6611: that were passed automatically in from GCC. */
6612: int j;
6613: opts->inhibit_predefs = 1;
6614: for (ptr = &opts->pending; *ptr != NULL; )
6615: {
6616: struct cpp_pending *pend = *ptr;
6617: if (pend->cmd && pend->cmd[0] == '-'
6618: && (pend->cmd[1] == 'D' || pend->cmd[1] == 'A'))
6619: {
6620: *ptr = pend->next;
6621: free (pend);
6622: }
6623: else
6624: ptr = &pend->next;
6625: }
6626: } else {
6627: push_pending (pfile, "-A", p);
6628: }
6629: }
6630: break;
6631:
6632: case 'U': /* JF #undef something */
6633: if (argv[i][2] != 0)
6634: push_pending (pfile, "-U", argv[i] + 2);
6635: else if (i + 1 == argc)
6636: fatal ("Macro name missing after -U option");
6637: else
6638: push_pending (pfile, "-U", argv[i+1]), i++;
6639: break;
6640:
6641: case 'C':
6642: opts->put_out_comments = 1;
6643: break;
6644:
6645: case 'E': /* -E comes from cc -E; ignore it. */
6646: break;
6647:
6648: case 'P':
6649: opts->no_line_commands = 1;
6650: break;
6651:
6652: case '$': /* Don't include $ in identifiers. */
6653: opts->dollars_in_ident = 0;
6654: break;
6655:
6656: case 'I': /* Add directory to path for includes. */
6657: {
6658: struct file_name_list *dirtmp;
6659:
6660: if (! CPP_OPTIONS(pfile)->ignore_srcdir
6661: && !strcmp (argv[i] + 2, "-")) {
6662: CPP_OPTIONS (pfile)->ignore_srcdir = 1;
6663: /* Don't use any preceding -I directories for #include <...>. */
6664: CPP_OPTIONS (pfile)->first_bracket_include = 0;
6665: }
6666: else {
6667: dirtmp = (struct file_name_list *)
6668: xmalloc (sizeof (struct file_name_list));
6669: dirtmp->next = 0; /* New one goes on the end */
6670: dirtmp->control_macro = 0;
6671: dirtmp->c_system_include_path = 0;
6672: if (argv[i][2] != 0)
6673: dirtmp->fname = argv[i] + 2;
6674: else if (i + 1 == argc)
6675: fatal ("Directory name missing after -I option");
6676: else
6677: dirtmp->fname = argv[++i];
6678: dirtmp->got_name_map = 0;
6679: append_include_chain (pfile, dirtmp, dirtmp);
6680: }
6681: }
6682: break;
6683:
6684: case 'n':
6685: if (!strcmp (argv[i], "-nostdinc"))
6686: /* -nostdinc causes no default include directories.
6687: You must specify all include-file directories with -I. */
6688: opts->no_standard_includes = 1;
6689: else if (!strcmp (argv[i], "-nostdinc++"))
6690: /* -nostdinc++ causes no default C++-specific include directories. */
6691: opts->no_standard_cplusplus_includes = 1;
6692: #if 0
6693: else if (!strcmp (argv[i], "-noprecomp"))
6694: no_precomp = 1;
6695: #endif
6696: break;
6697:
6698: case 'u':
6699: /* Sun compiler passes undocumented switch "-undef".
6700: Let's assume it means to inhibit the predefined symbols. */
6701: opts->inhibit_predefs = 1;
6702: break;
6703:
6704: case '\0': /* JF handle '-' as file name meaning stdin or stdout */
6705: if (opts->in_fname == NULL) {
6706: opts->in_fname = "";
6707: break;
6708: } else if (opts->out_fname == NULL) {
6709: opts->out_fname = "";
6710: break;
6711: } /* else fall through into error */
6712:
6713: default:
6714: return i;
6715: }
6716: }
6717: }
6718: return i;
6719: }
6720:
6721: void
6722: cpp_finish (pfile)
6723: cpp_reader *pfile;
6724: {
6725: struct cpp_options *opts = CPP_OPTIONS (pfile);
6726:
6727: if (opts->print_deps)
6728: {
6729: /* Stream on which to print the dependency information. */
6730: FILE *deps_stream;
6731:
6732: /* Don't actually write the deps file if compilation has failed. */
6733: if (pfile->errors == 0)
6734: {
6735: char *deps_mode = opts->print_deps_append ? "a" : "w";
6736: if (opts->deps_file == 0)
6737: deps_stream = stdout;
6738: else if ((deps_stream = fopen (opts->deps_file, deps_mode)) == 0)
6739: cpp_pfatal_with_name (pfile, opts->deps_file);
6740: fputs (pfile->deps_buffer, deps_stream);
6741: putc ('\n', deps_stream);
6742: if (opts->deps_file)
6743: {
6744: if (ferror (deps_stream) || fclose (deps_stream) != 0)
6745: fatal ("I/O error on output");
6746: }
6747: }
6748: }
6749: }
6750:
6751: /* Free resources used by PFILE. */
6752:
6753: void
6754: cpp_cleanup (pfile)
6755: cpp_reader *pfile;
6756: {
6757: int i;
6758: while ( CPP_BUFFER (pfile) != CPP_NULL_BUFFER (pfile))
6759: cpp_pop_buffer (pfile);
6760:
6761: if (pfile->token_buffer)
6762: {
6763: free (pfile->token_buffer);
6764: pfile->token_buffer = NULL;
6765: }
6766:
6767: if (pfile->deps_buffer)
6768: {
6769: free (pfile->deps_buffer);
6770: pfile->deps_buffer = NULL;
6771: pfile->deps_allocated_size = 0;
6772: }
6773:
6774: while (pfile->if_stack)
6775: {
6776: IF_STACK_FRAME *temp = pfile->if_stack;
6777: pfile->if_stack = temp->next;
6778: free (temp);
6779: }
6780:
6781: while (pfile->dont_repeat_files)
6782: {
6783: struct file_name_list *temp = pfile->dont_repeat_files;
6784: pfile->dont_repeat_files = temp->next;
6785: free (temp->fname);
6786: free (temp);
6787: }
6788:
6789: while (pfile->all_include_files)
6790: {
6791: struct file_name_list *temp = pfile->all_include_files;
6792: pfile->all_include_files = temp->next;
6793: free (temp->fname);
6794: free (temp);
6795: }
6796:
6797: for (i = IMPORT_HASH_SIZE; --i >= 0; )
6798: {
6799: register struct import_file *imp = pfile->import_hash_table[i];
6800: while (imp)
6801: {
6802: struct import_file *next = imp->next;
6803: free (imp->name);
6804: free (imp);
6805: imp = next;
6806: }
6807: pfile->import_hash_table[i] = 0;
6808: }
6809:
6810: for (i = ASSERTION_HASHSIZE; --i >= 0; )
6811: {
6812: while (pfile->assertion_hashtab[i])
6813: delete_assertion (pfile->assertion_hashtab[i]);
6814: }
6815:
6816: cpp_hash_cleanup (pfile);
6817: }
6818:
6819: static int
6820: do_assert (pfile, keyword, buf, limit)
6821: cpp_reader *pfile;
6822: struct directive *keyword;
6823: U_CHAR *buf, *limit;
6824: {
6825: long symstart; /* remember where symbol name starts */
6826: int c;
6827: int sym_length; /* and how long it is */
6828: struct arglist *tokens = NULL;
6829:
6830: if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing
6831: && !CPP_BUFFER (pfile)->system_header_p)
6832: cpp_pedwarn (pfile, "ANSI C does not allow `#assert'");
6833:
6834: cpp_skip_hspace (pfile);
6835: symstart = CPP_WRITTEN (pfile); /* remember where it starts */
6836: parse_name (pfile, GETC());
6837: sym_length = check_macro_name (pfile, pfile->token_buffer + symstart,
6838: "assertion");
6839:
6840: cpp_skip_hspace (pfile);
6841: if (PEEKC() != '(') {
6842: cpp_error (pfile, "missing token-sequence in `#assert'");
6843: goto error;
6844: }
6845:
6846: {
6847: int error_flag = 0;
6848: tokens = read_token_list (pfile, &error_flag);
6849: if (error_flag)
6850: goto error;
6851: if (tokens == 0) {
6852: cpp_error (pfile, "empty token-sequence in `#assert'");
6853: goto error;
6854: }
6855: cpp_skip_hspace (pfile);
6856: c = PEEKC ();
6857: if (c != EOF && c != '\n')
6858: cpp_pedwarn (pfile, "junk at end of `#assert'");
6859: skip_rest_of_line (pfile);
6860: }
6861:
6862: /* If this name isn't already an assertion name, make it one.
6863: Error if it was already in use in some other way. */
6864:
6865: {
6866: ASSERTION_HASHNODE *hp;
6867: U_CHAR *symname = pfile->token_buffer + symstart;
6868: int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6869: struct tokenlist_list *value
6870: = (struct tokenlist_list *) xmalloc (sizeof (struct tokenlist_list));
6871:
6872: hp = assertion_lookup (pfile, symname, sym_length, hashcode);
6873: if (hp == NULL) {
6874: if (sym_length == 7 && ! strncmp (symname, "defined", sym_length))
6875: cpp_error (pfile, "`defined' redefined as assertion");
6876: hp = assertion_install (pfile, symname, sym_length, hashcode);
6877: }
6878:
6879: /* Add the spec'd token-sequence to the list of such. */
6880: value->tokens = tokens;
6881: value->next = hp->value;
6882: hp->value = value;
6883: }
6884: CPP_SET_WRITTEN (pfile, symstart); /* Pop */
6885: return 0;
6886: error:
6887: CPP_SET_WRITTEN (pfile, symstart); /* Pop */
6888: skip_rest_of_line (pfile);
6889: return 1;
6890: }
6891:
6892: static int
6893: do_unassert (pfile, keyword, buf, limit)
6894: cpp_reader *pfile;
6895: struct directive *keyword;
6896: U_CHAR *buf, *limit;
6897: {
6898: long symstart; /* remember where symbol name starts */
6899: int sym_length; /* and how long it is */
6900: int c;
6901:
6902: struct arglist *tokens = NULL;
6903: int tokens_specified = 0;
6904:
6905: if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing
6906: && !CPP_BUFFER (pfile)->system_header_p)
6907: cpp_pedwarn (pfile, "ANSI C does not allow `#unassert'");
6908:
6909: cpp_skip_hspace (pfile);
6910:
6911: symstart = CPP_WRITTEN (pfile); /* remember where it starts */
6912: parse_name (pfile, GETC());
6913: sym_length = check_macro_name (pfile, pfile->token_buffer + symstart,
6914: "assertion");
6915:
6916: cpp_skip_hspace (pfile);
6917: if (PEEKC() == '(') {
6918: int error_flag = 0;
6919:
6920: tokens = read_token_list (pfile, &error_flag);
6921: if (error_flag)
6922: goto error;
6923: if (tokens == 0) {
6924: cpp_error (pfile, "empty token list in `#unassert'");
6925: goto error;
6926: }
6927:
6928: tokens_specified = 1;
6929: }
6930:
6931: cpp_skip_hspace (pfile);
6932: c = PEEKC ();
6933: if (c != EOF && c != '\n')
6934: cpp_error (pfile, "junk at end of `#unassert'");
6935: skip_rest_of_line (pfile);
6936:
6937: {
6938: ASSERTION_HASHNODE *hp;
6939: U_CHAR *symname = pfile->token_buffer + symstart;
6940: int hashcode = hashf (symname, sym_length, ASSERTION_HASHSIZE);
6941: struct tokenlist_list *tail, *prev;
6942:
6943: hp = assertion_lookup (pfile, symname, sym_length, hashcode);
6944: if (hp == NULL)
6945: return 1;
6946:
6947: /* If no token list was specified, then eliminate this assertion
6948: entirely. */
6949: if (! tokens_specified)
6950: delete_assertion (hp);
6951: else {
6952: /* If a list of tokens was given, then delete any matching list. */
6953:
6954: tail = hp->value;
6955: prev = 0;
6956: while (tail) {
6957: struct tokenlist_list *next = tail->next;
6958: if (compare_token_lists (tail->tokens, tokens)) {
6959: if (prev)
6960: prev->next = next;
6961: else
6962: hp->value = tail->next;
6963: free_token_list (tail->tokens);
6964: free (tail);
6965: } else {
6966: prev = tail;
6967: }
6968: tail = next;
6969: }
6970: }
6971: }
6972:
6973: CPP_SET_WRITTEN (pfile, symstart); /* Pop */
6974: return 0;
6975: error:
6976: CPP_SET_WRITTEN (pfile, symstart); /* Pop */
6977: skip_rest_of_line (pfile);
6978: return 1;
6979: }
6980:
6981: /* Test whether there is an assertion named NAME
6982: and optionally whether it has an asserted token list TOKENS.
6983: NAME is not null terminated; its length is SYM_LENGTH.
6984: If TOKENS_SPECIFIED is 0, then don't check for any token list. */
6985:
6986: int
6987: check_assertion (pfile, name, sym_length, tokens_specified, tokens)
6988: cpp_reader *pfile;
6989: U_CHAR *name;
6990: int sym_length;
6991: int tokens_specified;
6992: struct arglist *tokens;
6993: {
6994: ASSERTION_HASHNODE *hp;
6995: int hashcode = hashf (name, sym_length, ASSERTION_HASHSIZE);
6996:
6997: if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
6998: cpp_pedwarn (pfile, "ANSI C does not allow testing assertions");
6999:
7000: hp = assertion_lookup (pfile, name, sym_length, hashcode);
7001: if (hp == NULL)
7002: /* It is not an assertion; just return false. */
7003: return 0;
7004:
7005: /* If no token list was specified, then value is 1. */
7006: if (! tokens_specified)
7007: return 1;
7008:
7009: {
7010: struct tokenlist_list *tail;
7011:
7012: tail = hp->value;
7013:
7014: /* If a list of tokens was given,
7015: then succeed if the assertion records a matching list. */
7016:
7017: while (tail) {
7018: if (compare_token_lists (tail->tokens, tokens))
7019: return 1;
7020: tail = tail->next;
7021: }
7022:
7023: /* Fail if the assertion has no matching list. */
7024: return 0;
7025: }
7026: }
7027:
7028: /* Compare two lists of tokens for equality including order of tokens. */
7029:
7030: static int
7031: compare_token_lists (l1, l2)
7032: struct arglist *l1, *l2;
7033: {
7034: while (l1 && l2) {
7035: if (l1->length != l2->length)
7036: return 0;
7037: if (strncmp (l1->name, l2->name, l1->length))
7038: return 0;
7039: l1 = l1->next;
7040: l2 = l2->next;
7041: }
7042:
7043: /* Succeed if both lists end at the same time. */
7044: return l1 == l2;
7045: }
7046:
7047: struct arglist *
7048: reverse_token_list (tokens)
7049: struct arglist *tokens;
7050: {
7051: register struct arglist *prev = 0, *this, *next;
7052: for (this = tokens; this; this = next)
7053: {
7054: next = this->next;
7055: this->next = prev;
7056: prev = this;
7057: }
7058: return prev;
7059: }
7060:
7061: /* Read a space-separated list of tokens ending in a close parenthesis.
7062: Return a list of strings, in the order they were written.
7063: (In case of error, return 0 and store -1 in *ERROR_FLAG.) */
7064:
7065: static struct arglist *
7066: read_token_list (pfile, error_flag)
7067: cpp_reader *pfile;
7068: int *error_flag;
7069: {
7070: struct arglist *token_ptrs = 0;
7071: int depth = 1;
7072: int length;
7073:
7074: *error_flag = 0;
7075: FORWARD (1); /* Skip '(' */
7076:
7077: /* Loop over the assertion value tokens. */
7078: while (depth > 0)
7079: {
7080: struct arglist *temp;
7081: long name_written = CPP_WRITTEN (pfile);
7082: int eofp = 0; int c;
7083:
7084: cpp_skip_hspace (pfile);
7085:
7086: c = GETC ();
7087:
7088: /* Find the end of the token. */
7089: if (c == '(')
7090: {
7091: CPP_PUTC (pfile, c);
7092: depth++;
7093: }
7094: else if (c == ')')
7095: {
7096: depth--;
7097: if (depth == 0)
7098: break;
7099: CPP_PUTC (pfile, c);
7100: }
7101: else if (c == '"' || c == '\'')
7102: {
7103: FORWARD(-1);
7104: cpp_get_token (pfile);
7105: }
7106: else if (c == '\n')
7107: break;
7108: else
7109: {
7110: while (c != EOF && ! is_space[c] && c != '(' && c != ')'
7111: && c != '"' && c != '\'')
7112: {
7113: CPP_PUTC (pfile, c);
7114: c = GETC();
7115: }
7116: if (c != EOF) FORWARD(-1);
7117: }
7118:
7119: length = CPP_WRITTEN (pfile) - name_written;
7120: temp = (struct arglist *)
7121: xmalloc (sizeof (struct arglist) + length + 1);
7122: temp->name = (U_CHAR *) (temp + 1);
7123: bcopy ((char *) (pfile->token_buffer + name_written),
7124: (char *) temp->name, length);
7125: temp->name[length] = 0;
7126: temp->next = token_ptrs;
7127: token_ptrs = temp;
7128: temp->length = length;
7129:
7130: CPP_ADJUST_WRITTEN (pfile, -length); /* pop */
7131:
7132: if (c == EOF || c == '\n')
7133: { /* FIXME */
7134: cpp_error (pfile,
7135: "unterminated token sequence following `#' operator");
7136: return 0;
7137: }
7138: }
7139:
7140: /* We accumulated the names in reverse order.
7141: Now reverse them to get the proper order. */
7142: return reverse_token_list (token_ptrs);
7143: }
7144:
7145: static void
7146: free_token_list (tokens)
7147: struct arglist *tokens;
7148: {
7149: while (tokens) {
7150: struct arglist *next = tokens->next;
7151: free (tokens->name);
7152: free (tokens);
7153: tokens = next;
7154: }
7155: }
7156:
7157: /* Get the file-mode and data size of the file open on FD
7158: and store them in *MODE_POINTER and *SIZE_POINTER. */
7159:
7160: static int
7161: file_size_and_mode (fd, mode_pointer, size_pointer)
7162: int fd;
7163: int *mode_pointer;
7164: long int *size_pointer;
7165: {
7166: struct stat sbuf;
7167:
7168: if (fstat (fd, &sbuf) < 0) return (-1);
7169: if (mode_pointer) *mode_pointer = sbuf.st_mode;
7170: if (size_pointer) *size_pointer = sbuf.st_size;
7171: return 0;
7172: }
7173:
7174: /* Read LEN bytes at PTR from descriptor DESC, for file FILENAME,
7175: retrying if necessary. Return a negative value if an error occurs,
7176: otherwise return the actual number of bytes read,
7177: which must be LEN unless end-of-file was reached. */
7178:
7179: static int
7180: safe_read (desc, ptr, len)
7181: int desc;
7182: char *ptr;
7183: int len;
7184: {
7185: int left = len;
7186: while (left > 0) {
7187: int nchars = read (desc, ptr, left);
7188: if (nchars < 0)
7189: {
7190: #ifdef EINTR
7191: if (errno == EINTR)
7192: continue;
7193: #endif
7194: return nchars;
7195: }
7196: if (nchars == 0)
7197: break;
7198: ptr += nchars;
7199: left -= nchars;
7200: }
7201: return len - left;
7202: }
7203:
7204: static char *
7205: savestring (input)
7206: char *input;
7207: {
7208: unsigned size = strlen (input);
7209: char *output = xmalloc (size + 1);
7210: strcpy (output, input);
7211: return output;
7212: }
7213:
7214: /* Initialize PMARK to remember the current position of PFILE. */
7215: void
7216: parse_set_mark (pmark, pfile)
7217: struct parse_marker *pmark;
7218: cpp_reader *pfile;
7219: {
7220: cpp_buffer *pbuf = CPP_BUFFER (pfile);
7221: pmark->next = pbuf->marks;
7222: pbuf->marks = pmark;
7223: pmark->buf = pbuf;
7224: pmark->position = pbuf->cur - pbuf->buf;
7225: }
7226:
7227: /* Cleanup PMARK - we no longer need it. */
7228: void
7229: parse_clear_mark (pmark)
7230: struct parse_marker *pmark;
7231: {
7232: struct parse_marker **pp = &pmark->buf->marks;
7233: for (; ; pp = &(*pp)->next) {
7234: if (*pp == NULL) fatal ("internal error", "in parse_set_mark");
7235: if (*pp == pmark) break;
7236: }
7237: *pp = pmark->next;
7238: }
7239:
7240: /* Backup the current position of PFILE to that saved in PMARK. */
7241:
7242: void
7243: parse_goto_mark (pmark, pfile)
7244: struct parse_marker *pmark;
7245: cpp_reader *pfile;
7246: {
7247: cpp_buffer *pbuf = CPP_BUFFER (pfile);
7248: if (pbuf != pmark->buf)
7249: fatal ("internal error %s", "parse_goto_mark");
7250: pbuf->cur = pbuf->buf + pmark->position;
7251: }
7252:
7253: /* Reset PMARK to point to the current position of PFILE. (Same
7254: as parse_clear_mark (PMARK), parse_set_mark (PMARK, PFILE) but faster. */
7255:
7256: void
7257: parse_move_mark (pmark, pfile)
7258: struct parse_marker *pmark;
7259: cpp_reader *pfile;
7260: {
7261: cpp_buffer *pbuf = CPP_BUFFER (pfile);
7262: if (pbuf != pmark->buf)
7263: fatal ("internal error %s", "parse_move_mark");
7264: pmark->position = pbuf->cur - pbuf->buf;
7265: }
7266:
7267: int
7268: cpp_read_check_assertion (pfile)
7269: cpp_reader *pfile;
7270: {
7271: int name_start = CPP_WRITTEN (pfile);
7272: int name_length, name_written;
7273: int result;
7274: FORWARD (1); /* Skip '#' */
7275: cpp_skip_hspace (pfile);
7276: parse_name (pfile, GETC ());
7277: name_written = CPP_WRITTEN (pfile);
7278: name_length = name_written - name_start;
7279: cpp_skip_hspace (pfile);
7280: if (CPP_BUF_PEEK (CPP_BUFFER (pfile)) == '(')
7281: {
7282: int error_flag;
7283: struct arglist *token_ptrs = read_token_list (pfile, &error_flag);
7284: result = check_assertion (pfile,
7285: pfile->token_buffer + name_start, name_length,
7286: 1, token_ptrs);
7287: }
7288: else
7289: result = check_assertion (pfile,
7290: pfile->token_buffer + name_start, name_length,
7291: 0, NULL_PTR);
7292: CPP_ADJUST_WRITTEN (pfile, - name_length); /* pop */
7293: return result;
7294: }
7295:
7296: void
7297: cpp_print_file_and_line (pfile)
7298: cpp_reader *pfile;
7299: {
7300: cpp_buffer *ip = cpp_file_buffer (pfile);
7301:
7302: if (ip != NULL)
7303: {
7304: long line, col;
7305: cpp_buf_line_and_col (ip, &line, &col);
7306: cpp_file_line_for_message (pfile, ip->nominal_fname,
7307: line, pfile->show_column ? col : -1);
7308: }
7309: }
7310:
7311: void
7312: cpp_error (pfile, msg, arg1, arg2, arg3)
7313: cpp_reader *pfile;
7314: char *msg;
7315: char *arg1, *arg2, *arg3;
7316: {
7317: cpp_print_containing_files (pfile);
7318: cpp_print_file_and_line (pfile);
7319: cpp_message (pfile, 1, msg, arg1, arg2, arg3);
7320: }
7321:
7322: /* Print error message but don't count it. */
7323:
7324: void
7325: cpp_warning (pfile, msg, arg1, arg2, arg3)
7326: cpp_reader *pfile;
7327: char *msg;
7328: char *arg1, *arg2, *arg3;
7329: {
7330: if (CPP_OPTIONS (pfile)->inhibit_warnings)
7331: return;
7332:
7333: if (CPP_OPTIONS (pfile)->warnings_are_errors)
7334: pfile->errors++;
7335:
7336: cpp_print_containing_files (pfile);
7337: cpp_print_file_and_line (pfile);
7338: cpp_message (pfile, 0, msg, arg1, arg2, arg3);
7339: }
7340:
7341: /* Print an error message and maybe count it. */
7342:
7343: void
7344: cpp_pedwarn (pfile, msg, arg1, arg2, arg3)
7345: cpp_reader *pfile;
7346: char *msg;
7347: char *arg1, *arg2, *arg3;
7348: {
7349: if (CPP_OPTIONS (pfile)->pedantic_errors)
7350: cpp_error (pfile, msg, arg1, arg2, arg3);
7351: else
7352: cpp_warning (pfile, msg, arg1, arg2, arg3);
7353: }
7354:
7355: void
7356: cpp_error_with_line (pfile, line, column, msg, arg1, arg2, arg3)
7357: cpp_reader *pfile;
7358: int line, column;
7359: char *msg;
7360: char *arg1, *arg2, *arg3;
7361: {
7362: int i;
7363: cpp_buffer *ip = cpp_file_buffer (pfile);
7364:
7365: cpp_print_containing_files (pfile);
7366:
7367: if (ip != NULL)
7368: cpp_file_line_for_message (pfile, ip->nominal_fname, line, column);
7369:
7370: cpp_message (pfile, 1, msg, arg1, arg2, arg3);
7371: }
7372:
7373: static void
7374: cpp_warning_with_line (pfile, line, column, msg, arg1, arg2, arg3)
7375: cpp_reader *pfile;
7376: int line, column;
7377: char *msg;
7378: char *arg1, *arg2, *arg3;
7379: {
7380: int i;
7381: cpp_buffer *ip;
7382:
7383: if (CPP_OPTIONS (pfile)->inhibit_warnings)
7384: return;
7385:
7386: if (CPP_OPTIONS (pfile)->warnings_are_errors)
7387: pfile->errors++;
7388:
7389: cpp_print_containing_files (pfile);
7390:
7391: ip = cpp_file_buffer (pfile);
7392:
7393: if (ip != NULL)
7394: cpp_file_line_for_message (pfile, ip->nominal_fname, line, column);
7395:
7396: cpp_message (pfile, 0, msg, arg1, arg2, arg3);
7397: }
7398:
7399: void
7400: cpp_pedwarn_with_line (pfile, line, column, msg, arg1, arg2, arg3)
7401: cpp_reader *pfile;
7402: int line;
7403: char *msg;
7404: char *arg1, *arg2, *arg3;
7405: {
7406: if (CPP_OPTIONS (pfile)->pedantic_errors)
7407: cpp_error_with_line (pfile, column, line, msg, arg1, arg2, arg3);
7408: else
7409: cpp_warning_with_line (pfile, line, column, msg, arg1, arg2, arg3);
7410: }
7411:
7412: /* Report a warning (or an error if pedantic_errors)
7413: giving specified file name and line number, not current. */
7414:
7415: void
7416: cpp_pedwarn_with_file_and_line (pfile, file, line, msg, arg1, arg2, arg3)
7417: cpp_reader *pfile;
7418: char *file;
7419: int line;
7420: char *msg;
7421: char *arg1, *arg2, *arg3;
7422: {
7423: if (!CPP_OPTIONS (pfile)->pedantic_errors
7424: && CPP_OPTIONS (pfile)->inhibit_warnings)
7425: return;
7426: if (file != NULL)
7427: cpp_file_line_for_message (pfile, file, line, -1);
7428: cpp_message (pfile, CPP_OPTIONS (pfile)->pedantic_errors,
7429: msg, arg1, arg2, arg3);
7430: }
7431:
7432: /* This defines "errno" properly for VMS, and gives us EACCES. */
7433: #include <errno.h>
7434: #ifndef errno
7435: extern int errno;
7436: #endif
7437:
7438: #ifndef VMS
7439: #ifndef HAVE_STRERROR
7440: extern int sys_nerr;
7441: #if defined(bsd4_4)
7442: extern const char *const sys_errlist[];
7443: #else
7444: extern char *sys_errlist[];
7445: #endif
7446: #else /* HAVE_STRERROR */
7447: char *strerror ();
7448: #endif
7449: #else /* VMS */
7450: char *strerror (int,...);
7451: #endif
7452:
7453: /*
7454: * my_strerror - return the descriptive text associated with an `errno' code.
7455: */
7456:
7457: char *
7458: my_strerror (errnum)
7459: int errnum;
7460: {
7461: char *result;
7462:
7463: #ifndef VMS
7464: #ifndef HAVE_STRERROR
7465: result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0);
7466: #else
7467: result = strerror (errnum);
7468: #endif
7469: #else /* VMS */
7470: /* VAXCRTL's strerror() takes an optional second argument, which only
7471: matters when the first argument is EVMSERR. However, it's simplest
7472: just to pass it unconditionally. `vaxc$errno' is declared in
7473: <errno.h>, and maintained by the library in parallel with `errno'.
7474: We assume that caller's `errnum' either matches the last setting of
7475: `errno' by the library or else does not have the value `EVMSERR'. */
7476:
7477: result = strerror (errnum, vaxc$errno);
7478: #endif
7479:
7480: if (!result)
7481: result = "undocumented I/O error";
7482:
7483: return result;
7484: }
7485:
7486: /* Error including a message from `errno'. */
7487:
7488: void
7489: cpp_error_from_errno (pfile, name)
7490: cpp_reader *pfile;
7491: char *name;
7492: {
7493: int i;
7494: cpp_buffer *ip = cpp_file_buffer (pfile);
7495:
7496: cpp_print_containing_files (pfile);
7497:
7498: if (ip != NULL)
7499: cpp_file_line_for_message (pfile, ip->nominal_fname, ip->lineno, -1);
7500:
7501: cpp_message (pfile, 1, "%s: %s", name, my_strerror (errno));
7502: }
7503:
7504: void
7505: cpp_perror_with_name (pfile, name)
7506: cpp_reader *pfile;
7507: char *name;
7508: {
7509: cpp_message (pfile, 1, "%s: %s: %s", progname, name, my_strerror (errno));
7510: }
7511:
7512: /* TODO:
7513: * No pre-compiled header file support.
7514: *
7515: * Possibly different enum token codes for each C/C++ token.
7516: *
7517: * Should clean up remaining directives to that do_XXX functions
7518: * only take two arguments and all have command_reads_line.
7519: *
7520: * Find and cleanup remaining uses of static variables,
7521: *
7522: * Support for trigraphs.
7523: *
7524: * Support -dM flag (dump_all_macros).
7525: *
7526: * Support for_lint flag.
7527: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.