1 /* CPP Library. (Directive handling.)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 Free Software Foundation, Inc.
4 Contributed by Per Bothner, 1994-95.
5 Based on CCCP program by Paul Rubin, June 1986
6 Adapted to ANSI C, Richard Stallman, Jan 1987
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
30 /* Chained list of answers to an assertion. */
38 /* Stack of conditionals currently in progress
39 (including both successful and failing conditionals). */
43 struct if_stack *next;
44 cpp_lexer_pos pos; /* line and column where condition started */
45 const cpp_hashnode *mi_cmacro;/* macro name for #ifndef around entire file */
46 unsigned char was_skipping; /* Value of pfile->skipping before this if. */
47 int type; /* type of last directive seen in this group */
50 /* Values for the origin field of struct directive. KANDR directives
51 come from traditional (K&R) C. STDC89 directives come from the
52 1989 C standard. EXTENSION directives are extensions. */
57 /* Values for the flags field of struct directive. COND indicates a
58 conditional; IF_COND an opening conditional. INCL means to treat
59 "..." and <...> as q-char and h-char sequences respectively. IN_I
60 means this directive should be handled even if -fpreprocessed is in
61 effect (these are the directives with callback hooks). */
63 #define IF_COND (1 << 1)
67 /* Defines one #-directive, including how to handle it. */
68 typedef void (*directive_handler) PARAMS ((cpp_reader *));
69 typedef struct directive directive;
72 directive_handler handler; /* Function to handle directive. */
73 const U_CHAR *name; /* Name of directive. */
74 unsigned short length; /* Length of name. */
75 unsigned char origin; /* Origin of directive. */
76 unsigned char flags; /* Flags describing this directive. */
79 /* Forward declarations. */
81 static void skip_rest_of_line PARAMS ((cpp_reader *));
82 static void check_eol PARAMS ((cpp_reader *));
83 static void start_directive PARAMS ((cpp_reader *));
84 static void end_directive PARAMS ((cpp_reader *, int));
85 static void run_directive PARAMS ((cpp_reader *, int,
87 const char *, size_t));
88 static int glue_header_name PARAMS ((cpp_reader *, cpp_token *));
89 static int parse_include PARAMS ((cpp_reader *, cpp_token *));
90 static void push_conditional PARAMS ((cpp_reader *, int, int,
91 const cpp_hashnode *));
92 static unsigned int read_flag PARAMS ((cpp_reader *, unsigned int));
93 static int strtoul_for_line PARAMS ((const U_CHAR *, unsigned int,
95 static void do_diagnostic PARAMS ((cpp_reader *, enum error_type, int));
96 static cpp_hashnode *lex_macro_node PARAMS ((cpp_reader *));
97 static void do_include_common PARAMS ((cpp_reader *, enum include_type));
98 static void do_pragma_once PARAMS ((cpp_reader *));
99 static void do_pragma_poison PARAMS ((cpp_reader *));
100 static void do_pragma_sdcc_hash PARAMS ((cpp_reader *));
101 static void do_pragma_system_header PARAMS ((cpp_reader *));
102 static void do_pragma_dependency PARAMS ((cpp_reader *));
103 static int get__Pragma_string PARAMS ((cpp_reader *, cpp_token *));
104 static unsigned char *destringize PARAMS ((const cpp_string *,
106 static int parse_answer PARAMS ((cpp_reader *, struct answer **, int));
107 static cpp_hashnode *parse_assertion PARAMS ((cpp_reader *, struct answer **,
109 static struct answer ** find_answer PARAMS ((cpp_hashnode *,
110 const struct answer *));
111 static void handle_assertion PARAMS ((cpp_reader *, const char *, int));
113 /* This is the table of directive handlers. It is ordered by
114 frequency of occurrence; the numbers at the end are directive
115 counts from all the source code I have lying around (egcs and libc
116 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
117 pcmcia-cs-3.0.9). This is no longer important as directive lookup
118 is now O(1). All extensions other than #warning and #include_next
119 are deprecated. The name is where the extension appears to have
122 #define DIRECTIVE_TABLE \
123 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
124 D(include, T_INCLUDE, KANDR, INCL) /* 52262 */ \
125 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
126 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
127 D(if, T_IF, KANDR, COND | IF_COND) /* 18162 */ \
128 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
129 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
130 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
131 D(line, T_LINE, KANDR, IN_I) /* 2465 */ \
132 D(elif, T_ELIF, STDC89, COND) /* 610 */ \
133 D(error, T_ERROR, STDC89, 0) /* 475 */ \
134 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
135 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
136 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL) /* 19 */ \
137 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
138 D(import, T_IMPORT, EXTENSION, INCL) /* 0 ObjC */ \
139 D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
140 D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
141 SCCS_ENTRY /* 0 SVR4? */
143 /* #sccs is not always recognized. */
144 #ifdef SCCS_DIRECTIVE
145 # define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION, 0)
147 # define SCCS_ENTRY /* nothing */
150 /* Use the table to generate a series of prototypes, an enum for the
151 directive names, and an array of directive handlers. */
153 /* The directive-processing functions are declared to return int
154 instead of void, because some old compilers have trouble with
155 pointers to functions returning void. */
157 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
158 #define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
162 #define D(n, tag, o, f) tag,
170 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
171 #define D(name, t, origin, flags) \
172 { CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
173 sizeof STRINGX(name) - 1, origin, flags },
174 static const directive dtable[] =
179 #undef DIRECTIVE_TABLE
181 /* Skip any remaining tokens in a directive. */
183 skip_rest_of_line (pfile)
188 /* Discard all input lookaheads. */
189 while (pfile->la_read)
190 _cpp_release_lookahead (pfile);
192 /* Discard all stacked contexts. */
193 while (pfile->context != &pfile->base_context)
194 _cpp_pop_context (pfile);
196 /* Sweep up all tokens remaining on the line. */
197 pfile->state.prevent_expansion++;
198 while (!pfile->state.next_bol)
199 _cpp_lex_token (pfile, &token);
200 pfile->state.prevent_expansion--;
203 /* Ensure there are no stray tokens at the end of a directive. */
208 if (!pfile->state.next_bol)
212 _cpp_lex_token (pfile, &token);
213 if (token.type != CPP_EOF)
214 cpp_pedwarn (pfile, "extra tokens at end of #%s directive",
215 pfile->directive->name);
219 /* Called when entering a directive, _Pragma or command-line directive. */
221 start_directive (pfile)
224 cpp_buffer *buffer = pfile->buffer;
226 /* Setup in-directive state. */
227 pfile->state.in_directive = 1;
228 pfile->state.save_comments = 0;
230 /* Some handlers need the position of the # for diagnostics. */
231 pfile->directive_pos = pfile->lexer_pos;
233 /* Don't save directive tokens for external clients. */
234 pfile->la_saved = pfile->la_write;
237 /* Turn off skipping. */
238 buffer->was_skipping = pfile->skipping;
242 /* Called when leaving a directive, _Pragma or command-line directive. */
244 end_directive (pfile, skip_line)
248 cpp_buffer *buffer = pfile->buffer;
250 /* Restore pfile->skipping before skip_rest_of_line, so that e.g.
251 __VA_ARGS__ in the rest of the directive doesn't warn. */
252 pfile->skipping = buffer->was_skipping;
254 /* We don't skip for an assembler #. */
256 skip_rest_of_line (pfile);
259 pfile->la_write = pfile->la_saved;
260 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
261 pfile->state.in_directive = 0;
262 pfile->state.angled_headers = 0;
263 pfile->state.line_extension = 0;
264 pfile->directive = 0;
267 /* Check if a token's name matches that of a known directive. Put in
268 this file to save exporting dtable and other unneeded information. */
270 _cpp_handle_directive (pfile, indented)
274 cpp_buffer *buffer = pfile->buffer;
275 const directive *dir = 0;
279 start_directive (pfile);
281 /* Lex the directive name directly. */
282 _cpp_lex_token (pfile, &dname);
284 if (dname.type == CPP_NAME)
286 unsigned int index = dname.val.node->directive_index;
288 dir = &dtable[index - 1];
290 else if (dname.type == CPP_NUMBER)
292 /* # followed by a number is equivalent to #line. Do not
293 recognize this form in assembly language source files or
294 skipped conditional groups. Complain about this form if
295 we're being pedantic, but not if this is regurgitated input
296 (preprocessed or fed back in by the C++ frontend). */
297 if (! buffer->was_skipping && CPP_OPTION (pfile, lang) != CLK_ASM)
299 dir = &dtable[T_LINE];
300 pfile->state.line_extension = 1;
301 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
302 if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed))
303 cpp_pedwarn (pfile, "# followed by integer");
307 pfile->directive = dir;
310 /* Make sure we lex headers correctly, whether skipping or not. */
311 pfile->state.angled_headers = dir->flags & INCL;
313 /* If we are rescanning preprocessed input, only directives tagged
314 with IN_I are honored, and the warnings below are suppressed. */
315 if (CPP_OPTION (pfile, preprocessed))
317 /* Kluge alert. In order to be sure that code like this
320 does not cause '#define foo bar' to get executed when
321 compiled with -save-temps, we recognize directives in
322 -fpreprocessed mode only if the # is in column 1 and the
323 directive name starts in column 2. This output can only
324 be generated by the directive callbacks in cppmain.c (see
325 also the special case in scan_buffer). */
326 if (dir->flags & IN_I && !indented && !(dname.flags & PREV_WHITE))
327 (*dir->handler) (pfile);
328 /* That check misses '# 123' linemarkers. Let them through too. */
329 else if (dname.type == CPP_NUMBER)
330 (*dir->handler) (pfile);
333 /* We don't want to process this directive. Put back the
334 tokens so caller will see them (and issue an error,
336 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
342 /* Traditionally, a directive is ignored unless its # is in
343 column 1. Therefore in code intended to work with K+R
344 compilers, directives added by C89 must have their #
345 indented, and directives present in traditional C must
346 not. This is true even of directives in skipped
347 conditional blocks. */
348 if (CPP_WTRADITIONAL (pfile))
350 if (dir == &dtable[T_ELIF])
352 "suggest not using #elif in traditional C");
353 else if (indented && dir->origin == KANDR)
355 "traditional C ignores #%s with the # indented",
357 else if (!indented && dir->origin != KANDR)
359 "suggest hiding #%s from traditional C with an indented #",
363 /* If we are skipping a failed conditional group, all
364 non-conditional directives are ignored. */
365 if (! buffer->was_skipping || (dir->flags & COND))
367 /* Issue -pedantic warnings for extensions. */
368 if (CPP_PEDANTIC (pfile) && dir->origin == EXTENSION)
369 cpp_pedwarn (pfile, "#%s is a GCC extension", dir->name);
371 /* If we have a directive that is not an opening
372 conditional, invalidate any control macro. */
373 if (! (dir->flags & IF_COND))
374 pfile->mi_state = MI_FAILED;
376 (*dir->handler) (pfile);
380 else if (dname.type != CPP_EOF && ! buffer->was_skipping)
382 /* An unknown directive. Don't complain about it in assembly
383 source: we don't know where the comments are, and # may
384 introduce assembler pseudo-ops. Don't complain about invalid
385 directives in skipped conditional groups (6.10 p4). */
386 if (CPP_OPTION (pfile, lang) == CLK_ASM)
388 /* Output the # and lookahead token for the assembler. */
389 _cpp_push_token (pfile, &dname, &pfile->directive_pos);
393 cpp_error (pfile, "invalid preprocessing directive #%s",
394 cpp_token_as_text (pfile, &dname));
397 end_directive (pfile, skip);
401 /* Directive handler wrapper used by the command line option
404 run_directive (pfile, dir_no, type, buf, count)
407 enum cpp_buffer_type type;
411 unsigned int output_line = pfile->lexer_pos.output_line;
414 buffer = cpp_push_buffer (pfile, (const U_CHAR *) buf, count, type, 0);
416 if (dir_no == T_PRAGMA)
418 /* A kludge to avoid line markers for _Pragma. */
419 pfile->lexer_pos.output_line = output_line;
420 /* Avoid interpretation of directives in a _Pragma string. */
421 pfile->state.next_bol = 0;
424 start_directive (pfile);
425 pfile->state.prevent_expansion++;
426 pfile->directive = &dtable[dir_no];
427 (void) (*pfile->directive->handler) (pfile);
428 pfile->state.prevent_expansion--;
430 end_directive (pfile, 1);
432 cpp_pop_buffer (pfile);
435 /* Checks for validity the macro name in #define, #undef, #ifdef and
436 #ifndef directives. */
437 static cpp_hashnode *
438 lex_macro_node (pfile)
443 /* Lex the macro name directly. */
444 _cpp_lex_token (pfile, &token);
446 /* The token immediately after #define must be an identifier. That
447 identifier is not allowed to be "defined". See predefined macro
448 names (6.10.8.4). In C++, it is not allowed to be any of the
449 <iso646.h> macro names (which are keywords in C++) either. */
451 if (token.type != CPP_NAME)
453 if (token.type == CPP_EOF)
454 cpp_error (pfile, "no macro name given in #%s directive",
455 pfile->directive->name);
456 else if (token.flags & NAMED_OP)
458 "\"%s\" cannot be used as a macro name as it is an operator in C++",
459 NODE_NAME (token.val.node));
461 cpp_error (pfile, "macro names must be identifiers");
465 cpp_hashnode *node = token.val.node;
467 /* In Objective C, some keywords begin with '@', but general
468 identifiers do not, and you're not allowed to #define them. */
469 if (node == pfile->spec_nodes.n_defined || NODE_NAME (node)[0] == '@')
470 cpp_error (pfile, "\"%s\" cannot be used as a macro name",
472 else if (!(node->flags & NODE_POISONED))
479 /* Process a #define directive. Most work is done in cppmacro.c. */
484 cpp_hashnode *node = lex_macro_node (pfile);
488 if (_cpp_create_definition (pfile, node))
489 if (pfile->cb.define)
490 (*pfile->cb.define) (pfile, node);
494 /* Handle #undef. Marks the identifier NT_VOID in the hash table. */
499 cpp_hashnode *node = lex_macro_node (pfile);
501 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
502 is not currently defined as a macro name. */
503 if (node && node->type == NT_MACRO)
506 (*pfile->cb.undef) (pfile, node);
508 if (node->flags & NODE_WARN)
509 cpp_warning (pfile, "undefining \"%s\"", NODE_NAME (node));
511 _cpp_free_definition (node);
516 /* Helper routine used by parse_include. Reinterpret the current line
517 as an h-char-sequence (< ... >); we are looking at the first token
518 after the <. Returns zero on success. */
520 glue_header_name (pfile, header)
525 unsigned char *buffer, *token_mem;
526 size_t len, total_len = 0, capacity = 1024;
528 /* To avoid lexed tokens overwriting our glued name, we can only
529 allocate from the string pool once we've lexed everything. */
531 buffer = (unsigned char *) xmalloc (capacity);
534 cpp_get_token (pfile, &token);
536 if (token.type == CPP_GREATER || token.type == CPP_EOF)
539 len = cpp_token_len (&token);
540 if (total_len + len > capacity)
542 capacity = (capacity + len) * 2;
543 buffer = (unsigned char *) xrealloc (buffer, capacity);
546 if (token.flags & PREV_WHITE)
547 buffer[total_len++] = ' ';
549 total_len = cpp_spell_token (pfile, &token, &buffer[total_len]) - buffer;
552 if (token.type == CPP_EOF)
553 cpp_error (pfile, "missing terminating > character");
556 token_mem = _cpp_pool_alloc (&pfile->ident_pool, total_len + 1);
557 memcpy (token_mem, buffer, total_len);
558 token_mem[total_len] = '\0';
560 header->type = CPP_HEADER_NAME;
561 header->flags &= ~PREV_WHITE;
562 header->val.str.len = total_len;
563 header->val.str.text = token_mem;
567 return token.type == CPP_EOF;
570 /* Parse the header name of #include, #include_next, #import and
571 #pragma dependency. Returns zero on success. */
573 parse_include (pfile, header)
577 int is_pragma = pfile->directive == &dtable[T_PRAGMA];
578 const unsigned char *dir;
581 dir = U"pragma dependency";
583 dir = pfile->directive->name;
585 /* Allow macro expansion. */
586 cpp_get_token (pfile, header);
587 if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
589 if (header->type != CPP_LESS)
591 cpp_error (pfile, "#%s expects \"FILENAME\" or <FILENAME>", dir);
594 if (glue_header_name (pfile, header))
598 if (header->val.str.len == 0)
600 cpp_error (pfile, "empty file name in #%s", dir);
607 /* Get out of macro context, if we are. */
608 skip_rest_of_line (pfile);
609 if (pfile->cb.include)
610 (*pfile->cb.include) (pfile, dir, header);
616 /* Handle #include, #include_next and #import. */
618 do_include_common (pfile, type)
620 enum include_type type;
624 if (!parse_include (pfile, &header))
626 /* Prevent #include recursion. */
627 if (pfile->buffer_stack_depth >= CPP_STACK_MAX)
628 cpp_fatal (pfile, "#include nested too deeply");
629 else if (pfile->context->prev)
630 cpp_ice (pfile, "attempt to push file buffer with contexts stacked");
633 /* For #include_next, if this is the primary source file,
634 warn and use the normal search logic. */
635 if (type == IT_INCLUDE_NEXT && ! pfile->buffer->prev)
637 cpp_warning (pfile, "#include_next in primary source file");
641 _cpp_execute_include (pfile, &header, type);
650 do_include_common (pfile, IT_INCLUDE);
657 if (!pfile->import_warning && CPP_OPTION (pfile, warn_import))
659 pfile->import_warning = 1;
661 "#import is obsolete, use an #ifndef wrapper in the header file");
664 do_include_common (pfile, IT_IMPORT);
668 do_include_next (pfile)
671 do_include_common (pfile, IT_INCLUDE_NEXT);
674 /* Subroutine of do_line. Read possible flags after file name. LAST
675 is the last flag seen; 0 if this is the first flag. Return the flag
676 if it is valid, 0 at the end of the directive. Otherwise complain. */
679 read_flag (pfile, last)
685 _cpp_lex_token (pfile, &token);
686 if (token.type == CPP_NUMBER && token.val.str.len == 1)
688 unsigned int flag = token.val.str.text[0] - '0';
690 if (flag > last && flag <= 4
691 && (flag != 4 || last == 3)
692 && (flag != 2 || last == 0))
696 if (token.type != CPP_EOF)
697 cpp_error (pfile, "invalid flag \"%s\" in line directive",
698 cpp_token_as_text (pfile, &token));
702 /* Another subroutine of do_line. Convert a number in STR, of length
703 LEN, to binary; store it in NUMP, and return 0 if the number was
704 well-formed, 1 if not. Temporary, hopefully. */
706 strtoul_for_line (str, len, nump)
711 unsigned long reg = 0;
725 /* Interpret #line command.
726 Note that the filename string (if any) is treated as if it were an
727 include filename. That means no escape handling. */
733 cpp_buffer *buffer = pfile->buffer;
734 const char *filename = buffer->nominal_fname;
735 unsigned int lineno = buffer->lineno;
736 enum cpp_fc_reason reason = FC_RENAME;
737 unsigned long new_lineno;
741 /* C99 raised the minimum limit on #line numbers. */
742 cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
744 /* #line commands expand macros. */
745 cpp_get_token (pfile, &token);
746 if (token.type != CPP_NUMBER
747 || strtoul_for_line (token.val.str.text, token.val.str.len, &new_lineno))
749 cpp_error (pfile, "\"%s\" after #line is not a positive integer",
750 cpp_token_as_text (pfile, &token));
754 if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
755 cpp_pedwarn (pfile, "line number out of range");
757 cpp_get_token (pfile, &token);
758 if (token.type == CPP_STRING)
760 const char *fname = (const char *) token.val.str.text;
762 /* Only accept flags for the # 55 form. */
763 if (! pfile->state.line_extension)
767 int flag = 0, sysp = 0;
769 flag = read_flag (pfile, flag);
773 flag = read_flag (pfile, flag);
778 flag = read_flag (pfile, flag);
783 flag = read_flag (pfile, flag);
785 sysp = 2, read_flag (pfile, flag);
788 if (reason == FC_ENTER)
790 /* Fake a buffer stack for diagnostics. */
791 cpp_push_buffer (pfile, 0, 0, BUF_FAKE, fname);
792 /* Fake an include for cpp_included. */
793 _cpp_fake_include (pfile, fname);
794 buffer = pfile->buffer;
796 else if (reason == FC_LEAVE)
798 if (buffer->type != BUF_FAKE)
799 cpp_warning (pfile, "file \"%s\" left but not entered",
800 buffer->nominal_fname);
803 cpp_pop_buffer (pfile);
804 buffer = pfile->buffer;
805 #ifdef ENABLE_CHECKING
806 if (strcmp (buffer->nominal_fname, fname))
807 cpp_warning (pfile, "expected to return to file \"%s\"",
808 buffer->nominal_fname);
809 if (buffer->lineno + 1 != new_lineno)
810 cpp_warning (pfile, "expected to return to line number %u",
812 if (buffer->sysp != sysp)
813 cpp_warning (pfile, "header flags for \"%s\" have changed",
814 buffer->nominal_fname);
820 buffer->nominal_fname = fname;
822 else if (token.type != CPP_EOF)
824 cpp_error (pfile, "\"%s\" is not a valid filename",
825 cpp_token_as_text (pfile, &token));
829 /* Our line number is incremented after the directive is processed. */
830 buffer->lineno = new_lineno - 1;
831 _cpp_do_file_change (pfile, reason, filename, lineno);
834 /* Arrange the file_change callback. */
836 _cpp_do_file_change (pfile, reason, from_file, from_lineno)
838 enum cpp_fc_reason reason;
839 const char *from_file;
840 unsigned int from_lineno;
842 if (pfile->cb.file_change)
845 cpp_buffer *buffer = pfile->buffer;
848 fc.to.filename = buffer->nominal_fname;
849 fc.to.lineno = buffer->lineno + 1;
850 fc.sysp = buffer->sysp;
851 fc.externc = CPP_OPTION (pfile, cplusplus) && buffer->sysp == 2;
853 /* Caller doesn't need to handle FC_ENTER. */
854 if (reason == FC_ENTER)
858 from_file = buffer->prev->nominal_fname;
859 from_lineno = buffer->prev->lineno;
864 /* Special case for file "foo.i" with "# 1 foo.c" on first line. */
865 else if (reason == FC_RENAME && ! buffer->prev
866 && pfile->directive_pos.line == 1)
869 fc.from.filename = from_file;
870 fc.from.lineno = from_lineno;
871 pfile->cb.file_change (pfile, &fc);
876 * Report a warning or error detected by the program we are
877 * processing. Use the directive's tokens in the error message.
881 do_diagnostic (pfile, code, print_dir)
883 enum error_type code;
886 if (_cpp_begin_message (pfile, code, NULL, 0))
889 fprintf (stderr, "#%s ", pfile->directive->name);
890 pfile->state.prevent_expansion++;
891 cpp_output_line (pfile, stderr);
892 pfile->state.prevent_expansion--;
900 do_diagnostic (pfile, ERROR, 1);
907 /* We want #warning diagnostics to be emitted in system headers too. */
908 do_diagnostic (pfile, WARNING_SYSHDR, 1);
911 /* Report program identification. */
919 cpp_get_token (pfile, &str);
920 if (str.type != CPP_STRING)
921 cpp_error (pfile, "invalid #ident");
922 else if (pfile->cb.ident)
923 (*pfile->cb.ident) (pfile, &str.val.str);
928 /* Pragmata handling. We handle some of these, and pass the rest on
929 to the front end. C99 defines three pragmas and says that no macro
930 expansion is to be performed on them; whether or not macro
931 expansion happens for other pragmas is implementation defined.
932 This implementation never macro-expands the text after #pragma. */
934 /* Sub-handlers for the pragmas needing treatment here.
935 They return 1 if the token buffer is to be popped, 0 if not. */
938 struct pragma_entry *next;
943 void (*handler) PARAMS ((cpp_reader *));
944 struct pragma_entry *space;
949 cpp_register_pragma (pfile, space, name, handler)
953 void (*handler) PARAMS ((cpp_reader *));
955 struct pragma_entry **x, *new;
961 struct pragma_entry *p = pfile->pragmas;
962 len = strlen (space);
965 if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
972 cpp_ice (pfile, "unknown #pragma namespace %s", space);
977 new = xnew (struct pragma_entry);
979 new->len = strlen (name);
981 new->u.handler = handler;
988 cpp_register_pragma_space (pfile, space)
992 struct pragma_entry *new;
993 const struct pragma_entry *p = pfile->pragmas;
994 size_t len = strlen (space);
998 if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
999 /* Multiple different callers are allowed to register the same
1005 new = xnew (struct pragma_entry);
1011 new->next = pfile->pragmas;
1012 pfile->pragmas = new;
1016 _cpp_init_internal_pragmas (pfile)
1020 cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
1021 cpp_register_pragma (pfile, 0, "once", do_pragma_once);
1024 cpp_register_pragma_space (pfile, "GCC");
1026 cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
1027 cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
1028 cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
1030 /* Kevin abuse for SDCC. */
1031 cpp_register_pragma(pfile, 0, "sdcc_hash", do_pragma_sdcc_hash);
1038 const struct pragma_entry *p;
1043 pfile->state.prevent_expansion++;
1044 cpp_start_lookahead (pfile);
1047 cpp_get_token (pfile, &tok);
1048 if (tok.type == CPP_NAME)
1050 const cpp_hashnode *node = tok.val.node;
1051 size_t len = NODE_LEN (node);
1055 if (strlen (p->name) == len
1056 && !memcmp (p->name, NODE_NAME (node), len))
1065 (*p->u.handler) (pfile);
1074 cpp_stop_lookahead (pfile, drop);
1075 pfile->state.prevent_expansion--;
1077 if (!drop && pfile->cb.def_pragma)
1078 (*pfile->cb.def_pragma) (pfile);
1082 do_pragma_once (pfile)
1085 cpp_warning (pfile, "#pragma once is obsolete");
1087 if (pfile->buffer->prev == NULL)
1088 cpp_warning (pfile, "#pragma once in main file");
1090 _cpp_never_reread (pfile->buffer->inc);
1096 do_pragma_poison (pfile)
1099 /* Poison these symbols so that all subsequent usage produces an
1104 pfile->state.poisoned_ok = 1;
1107 _cpp_lex_token (pfile, &tok);
1108 if (tok.type == CPP_EOF)
1110 if (tok.type != CPP_NAME)
1112 cpp_error (pfile, "invalid #pragma GCC poison directive");
1117 if (hp->flags & NODE_POISONED)
1120 if (hp->type == NT_MACRO)
1121 cpp_warning (pfile, "poisoning existing macro \"%s\"", NODE_NAME (hp));
1122 _cpp_free_definition (hp);
1123 hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1125 pfile->state.poisoned_ok = 0;
1127 #if 0 /* Doesn't quite work yet. */
1128 if (tok.type == CPP_EOF && pfile->cb.poison)
1129 (*pfile->cb.poison) (pfile);
1134 do_pragma_sdcc_hash (pfile)
1138 /*cpp_hashnode *hp;*/
1140 _cpp_lex_token (pfile, &tok);
1141 if (tok.type == CPP_PLUS)
1143 CPP_OPTION(pfile, allow_naked_hash)++;
1145 else if (tok.type == CPP_MINUS)
1147 CPP_OPTION(pfile, allow_naked_hash)--;
1151 cpp_error (pfile, "invalid #pragma sdcc_hash directive, need '+' or '-'");
1155 /* Mark the current header as a system header. This will suppress
1156 some categories of warnings (notably those from -pedantic). It is
1157 intended for use in system libraries that cannot be implemented in
1158 conforming C, but cannot be certain that their headers appear in a
1159 system include directory. To prevent abuse, it is rejected in the
1160 primary source file. */
1162 do_pragma_system_header (pfile)
1165 cpp_buffer *buffer = pfile->buffer;
1167 if (buffer->prev == 0)
1168 cpp_warning (pfile, "#pragma system_header ignored outside include file");
1170 cpp_make_system_header (pfile, 1, 0);
1175 /* Check the modified date of the current include file against a specified
1176 file. Issue a diagnostic, if the specified file is newer. We use this to
1177 determine if a fixed header should be refixed. */
1179 do_pragma_dependency (pfile)
1182 cpp_token header, msg;
1185 if (parse_include (pfile, &header))
1188 ordering = _cpp_compare_file_date (pfile, &header);
1190 cpp_warning (pfile, "cannot find source %s",
1191 cpp_token_as_text (pfile, &header));
1192 else if (ordering > 0)
1194 cpp_warning (pfile, "current file is older than %s",
1195 cpp_token_as_text (pfile, &header));
1196 cpp_start_lookahead (pfile);
1197 cpp_get_token (pfile, &msg);
1198 cpp_stop_lookahead (pfile, msg.type == CPP_EOF);
1199 if (msg.type != CPP_EOF)
1200 do_diagnostic (pfile, WARNING, 0);
1204 /* Check syntax is "(string-literal)". Returns 0 on success. */
1206 get__Pragma_string (pfile, string)
1212 cpp_get_token (pfile, &paren);
1213 if (paren.type != CPP_OPEN_PAREN)
1216 cpp_get_token (pfile, string);
1217 if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1220 cpp_get_token (pfile, &paren);
1221 return paren.type != CPP_CLOSE_PAREN;
1224 /* Returns a malloced buffer containing a destringized cpp_string by
1225 removing the first \ of \" and \\ sequences. */
1226 static unsigned char *
1227 destringize (in, len)
1228 const cpp_string *in;
1231 const unsigned char *src, *limit;
1232 unsigned char *dest, *result;
1234 dest = result = (unsigned char *) xmalloc (in->len);
1235 for (src = in->text, limit = src + in->len; src < limit;)
1237 /* We know there is a character following the backslash. */
1238 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1243 *len = dest - result;
1248 _cpp_do__Pragma (pfile)
1252 unsigned char *buffer;
1255 if (get__Pragma_string (pfile, &string))
1257 cpp_error (pfile, "_Pragma takes a parenthesized string literal");
1261 buffer = destringize (&string.val.str, &len);
1262 run_directive (pfile, T_PRAGMA, BUF_PRAGMA, (char *) buffer, len);
1263 free ((PTR) buffer);
1266 /* Just ignore #sccs, on systems where we define it at all. */
1267 #ifdef SCCS_DIRECTIVE
1270 cpp_reader *pfile ATTRIBUTE_UNUSED;
1281 if (! pfile->buffer->was_skipping)
1283 const cpp_hashnode *node = lex_macro_node (pfile);
1286 skip = node->type != NT_MACRO;
1292 push_conditional (pfile, skip, T_IFDEF, 0);
1300 const cpp_hashnode *node = 0;
1302 if (! pfile->buffer->was_skipping)
1304 node = lex_macro_node (pfile);
1306 skip = node->type == NT_MACRO;
1312 push_conditional (pfile, skip, T_IFNDEF, node);
1315 /* #if cooperates with parse_defined to handle multiple-include
1316 optimisations. If macro expansions or identifiers appear in the
1317 expression, we cannot treat it as a controlling conditional, since
1318 their values could change in the future. */
1325 const cpp_hashnode *cmacro = 0;
1327 if (! pfile->buffer->was_skipping)
1329 /* Controlling macro of #if ! defined () */
1330 pfile->mi_ind_cmacro = 0;
1331 skip = _cpp_parse_expr (pfile) == 0;
1332 cmacro = pfile->mi_ind_cmacro;
1335 push_conditional (pfile, skip, T_IF, cmacro);
1338 /* Flip skipping state if appropriate and continue without changing
1339 if_stack; this is so that the error message for missing #endif's
1340 etc. will point to the original #if. */
1346 cpp_buffer *buffer = pfile->buffer;
1347 struct if_stack *ifs = buffer->if_stack;
1350 cpp_error (pfile, "#else without #if");
1353 if (ifs->type == T_ELSE)
1355 cpp_error (pfile, "#else after #else");
1356 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1357 "the conditional began here");
1361 /* Buffer->was_skipping is 1 if all conditionals in this chain
1362 have been false, 2 if a conditional has been true. */
1363 if (! ifs->was_skipping && buffer->was_skipping != 2)
1364 buffer->was_skipping = ! buffer->was_skipping;
1366 /* Invalidate any controlling macro. */
1373 /* handle a #elif directive by not changing if_stack either. see the
1374 comment above do_else. */
1380 cpp_buffer *buffer = pfile->buffer;
1381 struct if_stack *ifs = buffer->if_stack;
1384 cpp_error (pfile, "#elif without #if");
1387 if (ifs->type == T_ELSE)
1389 cpp_error (pfile, "#elif after #else");
1390 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1391 "the conditional began here");
1395 /* Don't evaluate #elif if our higher level is skipping. */
1396 if (! ifs->was_skipping)
1398 /* Buffer->was_skipping is 1 if all conditionals in this
1399 chain have been false, 2 if a conditional has been true. */
1400 if (buffer->was_skipping == 1)
1401 buffer->was_skipping = ! _cpp_parse_expr (pfile);
1403 buffer->was_skipping = 2;
1405 /* Invalidate any controlling macro. */
1411 /* #endif pops the if stack and resets pfile->skipping. */
1417 cpp_buffer *buffer = pfile->buffer;
1418 struct if_stack *ifs = buffer->if_stack;
1421 cpp_error (pfile, "#endif without #if");
1424 /* If potential control macro, we go back outside again. */
1425 if (ifs->next == 0 && ifs->mi_cmacro)
1427 pfile->mi_state = MI_OUTSIDE;
1428 pfile->mi_cmacro = ifs->mi_cmacro;
1431 buffer->if_stack = ifs->next;
1432 buffer->was_skipping = ifs->was_skipping;
1433 obstack_free (&pfile->buffer_ob, ifs);
1439 /* Push an if_stack entry and set pfile->skipping accordingly.
1440 If this is a #ifndef starting at the beginning of a file,
1441 CMACRO is the macro name tested by the #ifndef. */
1444 push_conditional (pfile, skip, type, cmacro)
1448 const cpp_hashnode *cmacro;
1450 struct if_stack *ifs;
1451 cpp_buffer *buffer = pfile->buffer;
1453 ifs = xobnew (&pfile->buffer_ob, struct if_stack);
1454 ifs->pos = pfile->directive_pos;
1455 ifs->next = buffer->if_stack;
1456 ifs->was_skipping = buffer->was_skipping;
1458 if (pfile->mi_state == MI_OUTSIDE && pfile->mi_cmacro == 0)
1459 ifs->mi_cmacro = cmacro;
1463 buffer->was_skipping = skip;
1464 buffer->if_stack = ifs;
1467 /* Read the tokens of the answer into the macro pool. Only commit the
1468 memory if we intend it as permanent storage, i.e. the #assert case.
1469 Returns 0 on success. */
1472 parse_answer (pfile, answerp, type)
1474 struct answer **answerp;
1477 cpp_token paren, *token;
1478 struct answer *answer;
1480 if (POOL_FRONT (&pfile->macro_pool) + sizeof (struct answer) >
1481 POOL_LIMIT (&pfile->macro_pool))
1482 _cpp_next_chunk (&pfile->macro_pool, sizeof (struct answer), 0);
1483 answer = (struct answer *) POOL_FRONT (&pfile->macro_pool);
1486 /* In a conditional, it is legal to not have an open paren. We
1487 should save the following token in this case. */
1489 cpp_start_lookahead (pfile);
1490 cpp_get_token (pfile, &paren);
1492 cpp_stop_lookahead (pfile, paren.type == CPP_OPEN_PAREN);
1494 /* If not a paren, see if we're OK. */
1495 if (paren.type != CPP_OPEN_PAREN)
1497 /* In a conditional no answer is a test for any answer. It
1498 could be followed by any token. */
1502 /* #unassert with no answer is valid - it removes all answers. */
1503 if (type == T_UNASSERT && paren.type == CPP_EOF)
1506 cpp_error (pfile, "missing '(' after predicate");
1512 token = &answer->first[answer->count];
1513 /* Check we have room for the token. */
1514 if ((unsigned char *) (token + 1) >= POOL_LIMIT (&pfile->macro_pool))
1516 _cpp_next_chunk (&pfile->macro_pool, sizeof (cpp_token),
1517 (unsigned char **) &answer);
1518 token = &answer->first[answer->count];
1521 cpp_get_token (pfile, token);
1522 if (token->type == CPP_CLOSE_PAREN)
1525 if (token->type == CPP_EOF)
1527 cpp_error (pfile, "missing ')' to complete answer");
1533 if (answer->count == 0)
1535 cpp_error (pfile, "predicate's answer is empty");
1539 /* Drop whitespace at start. */
1540 answer->first->flags &= ~PREV_WHITE;
1543 if (type == T_ASSERT || type == T_UNASSERT)
1548 /* Parses an assertion, returning a pointer to the hash node of the
1549 predicate, or 0 on error. If an answer was supplied, it is placed
1550 in ANSWERP, otherwise it is set to 0. */
1551 static cpp_hashnode *
1552 parse_assertion (pfile, answerp, type)
1554 struct answer **answerp;
1557 cpp_hashnode *result = 0;
1558 cpp_token predicate;
1560 /* We don't expand predicates or answers. */
1561 pfile->state.prevent_expansion++;
1564 cpp_get_token (pfile, &predicate);
1565 if (predicate.type == CPP_EOF)
1566 cpp_error (pfile, "assertion without predicate");
1567 else if (predicate.type != CPP_NAME)
1568 cpp_error (pfile, "predicate must be an identifier");
1569 else if (parse_answer (pfile, answerp, type) == 0)
1571 unsigned int len = NODE_LEN (predicate.val.node);
1572 unsigned char *sym = alloca (len + 1);
1574 /* Prefix '#' to get it out of macro namespace. */
1576 memcpy (sym + 1, NODE_NAME (predicate.val.node), len);
1577 result = cpp_lookup (pfile, sym, len + 1);
1580 pfile->state.prevent_expansion--;
1584 /* Returns a pointer to the pointer to the answer in the answer chain,
1585 or a pointer to NULL if the answer is not in the chain. */
1586 static struct answer **
1587 find_answer (node, candidate)
1589 const struct answer *candidate;
1592 struct answer **result;
1594 for (result = &node->value.answers; *result; result = &(*result)->next)
1596 struct answer *answer = *result;
1598 if (answer->count == candidate->count)
1600 for (i = 0; i < answer->count; i++)
1601 if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1604 if (i == answer->count)
1612 /* Test an assertion within a preprocessor conditional. Returns
1613 non-zero on failure, zero on success. On success, the result of
1614 the test is written into VALUE. */
1616 _cpp_test_assertion (pfile, value)
1620 struct answer *answer;
1623 node = parse_assertion (pfile, &answer, T_IF);
1625 *value = (node->type == NT_ASSERTION &&
1626 (answer == 0 || *find_answer (node, answer) != 0));
1628 /* We don't commit the memory for the answer - it's temporary only. */
1636 struct answer *new_answer;
1639 node = parse_assertion (pfile, &new_answer, T_ASSERT);
1642 /* Place the new answer in the answer list. First check there
1643 is not a duplicate. */
1644 new_answer->next = 0;
1645 if (node->type == NT_ASSERTION)
1647 if (*find_answer (node, new_answer))
1649 cpp_warning (pfile, "\"%s\" re-asserted", NODE_NAME (node) + 1);
1652 new_answer->next = node->value.answers;
1654 node->type = NT_ASSERTION;
1655 node->value.answers = new_answer;
1656 POOL_COMMIT (&pfile->macro_pool, (sizeof (struct answer)
1657 + (new_answer->count - 1)
1658 * sizeof (cpp_token)));
1667 struct answer *answer;
1669 node = parse_assertion (pfile, &answer, T_UNASSERT);
1670 /* It isn't an error to #unassert something that isn't asserted. */
1671 if (node && node->type == NT_ASSERTION)
1675 struct answer **p = find_answer (node, answer), *temp;
1677 /* Remove the answer from the list. */
1682 /* Did we free the last answer? */
1683 if (node->value.answers == 0)
1684 node->type = NT_VOID;
1687 _cpp_free_definition (node);
1690 /* We don't commit the memory for the answer - it's temporary only. */
1693 /* These are for -D, -U, -A. */
1695 /* Process the string STR as if it appeared as the body of a #define.
1696 If STR is just an identifier, define it with value 1.
1697 If STR has anything after the identifier, then it should
1698 be identifier=definition. */
1701 cpp_define (pfile, str)
1708 /* Copy the entire option so we can modify it.
1709 Change the first "=" in the string to a space. If there is none,
1710 tack " 1" on the end. */
1712 /* Length including the null. */
1713 count = strlen (str);
1714 buf = (char *) alloca (count + 2);
1715 memcpy (buf, str, count);
1717 p = strchr (str, '=');
1726 run_directive (pfile, T_DEFINE, BUF_CL_OPTION, buf, count);
1729 /* Slight variant of the above for use by initialize_builtins. */
1731 _cpp_define_builtin (pfile, str)
1735 run_directive (pfile, T_DEFINE, BUF_BUILTIN, str, strlen (str));
1738 /* Process MACRO as if it appeared as the body of an #undef. */
1740 cpp_undef (pfile, macro)
1744 run_directive (pfile, T_UNDEF, BUF_CL_OPTION, macro, strlen (macro));
1747 /* Process the string STR as if it appeared as the body of a #assert. */
1749 cpp_assert (pfile, str)
1753 handle_assertion (pfile, str, T_ASSERT);
1756 /* Process STR as if it appeared as the body of an #unassert. */
1758 cpp_unassert (pfile, str)
1762 handle_assertion (pfile, str, T_UNASSERT);
1765 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1767 handle_assertion (pfile, str, type)
1772 size_t count = strlen (str);
1773 const char *p = strchr (str, '=');
1777 /* Copy the entire option so we can modify it. Change the first
1778 "=" in the string to a '(', and tack a ')' on the end. */
1779 char *buf = (char *) alloca (count + 1);
1781 memcpy (buf, str, count);
1787 run_directive (pfile, type, BUF_CL_OPTION, str, count);
1790 /* The number of errors for a given reader. */
1795 return pfile->errors;
1798 /* The options structure. */
1800 cpp_get_options (pfile)
1803 return &pfile->opts;
1806 /* The callbacks structure. */
1808 cpp_get_callbacks (pfile)
1814 /* Copy the given callbacks structure to our own. */
1816 cpp_set_callbacks (pfile, cb)
1823 /* Push a new buffer on the buffer stack. Returns the new buffer; it
1824 doesn't fail. It does not generate a file change call back; that
1825 is the responsibility of the caller. */
1827 cpp_push_buffer (pfile, buffer, len, type, filename)
1829 const U_CHAR *buffer;
1831 enum cpp_buffer_type type;
1832 const char *filename;
1834 cpp_buffer *new = xobnew (&pfile->buffer_ob, cpp_buffer);
1836 if (type == BUF_FAKE)
1838 /* A copy of the current buffer, just with a new name and type. */
1839 memcpy (new, pfile->buffer, sizeof (cpp_buffer));
1840 new->type = BUF_FAKE;
1844 if (type == BUF_BUILTIN)
1845 filename = _("<builtin>");
1846 else if (type == BUF_CL_OPTION)
1847 filename = _("<command line>");
1848 else if (type == BUF_PRAGMA)
1849 filename = "<_Pragma>";
1851 /* Clears, amongst other things, if_stack and mi_cmacro. */
1852 memset (new, 0, sizeof (cpp_buffer));
1854 new->line_base = new->buf = new->cur = buffer;
1855 new->rlimit = buffer + len;
1858 /* No read ahead or extra char initially. */
1859 new->read_ahead = EOF;
1860 new->extra_char = EOF;
1862 /* Preprocessed files, builtins, _Pragma and command line
1863 options don't do trigraph and escaped newline processing. */
1864 new->from_stage3 = type != BUF_FILE || CPP_OPTION (pfile, preprocessed);
1866 pfile->lexer_pos.output_line = 1;
1869 if (*filename == '\0')
1870 new->nominal_fname = _("<stdin>");
1872 new->nominal_fname = filename;
1874 new->prev = pfile->buffer;
1876 new->include_stack_listed = 0;
1879 pfile->state.next_bol = 1;
1880 pfile->buffer_stack_depth++;
1881 pfile->buffer = new;
1886 /* If called from do_line, pops a single buffer. Otherwise pops all
1887 buffers until a real file is reached. Generates appropriate
1890 cpp_pop_buffer (pfile)
1894 struct if_stack *ifs;
1898 buffer = pfile->buffer;
1899 /* Walk back up the conditional stack till we reach its level at
1900 entry to this file, issuing error messages. */
1901 for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
1902 cpp_error_with_line (pfile, ifs->pos.line, ifs->pos.col,
1903 "unterminated #%s", dtable[ifs->type].name);
1905 if (buffer->type == BUF_FAKE)
1906 buffer->prev->cur = buffer->cur;
1907 else if (buffer->type == BUF_FILE)
1908 _cpp_pop_file_buffer (pfile, buffer);
1910 pfile->buffer = buffer->prev;
1911 pfile->buffer_stack_depth--;
1913 /* Callbacks only generated for faked or real files. */
1914 if (buffer->type != BUF_FILE && buffer->type != BUF_FAKE)
1917 /* No callback for EOF of last file. */
1921 /* do_line does its own call backs. */
1922 pfile->buffer->include_stack_listed = 0;
1923 if (pfile->directive == &dtable[T_LINE])
1926 _cpp_do_file_change (pfile, FC_LEAVE, buffer->nominal_fname,
1928 if (pfile->buffer->type == BUF_FILE)
1931 cpp_warning (pfile, "file \"%s\" entered but not left",
1932 buffer->nominal_fname);
1935 obstack_free (&pfile->buffer_ob, buffer);
1936 return pfile->buffer;
1940 _cpp_init_directives (pfile)
1946 /* Register the directives. */
1947 for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
1949 node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
1950 node->directive_index = i + 1;