1 /* CPP Library. (Directive handling.)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002 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. */
29 /* Chained list of answers to an assertion. */
37 /* Stack of conditionals currently in progress
38 (including both successful and failing conditionals). */
41 struct if_stack *next;
42 unsigned int line; /* Line where condition started. */
43 const cpp_hashnode *mi_cmacro;/* macro name for #ifndef around entire file */
44 bool skip_elses; /* Can future #else / #elif be skipped? */
45 bool was_skipping; /* If were skipping on entry. */
46 int type; /* Most recent conditional, for diagnostics. */
49 /* Contains a registered pragma or pragma namespace. */
50 typedef void (*pragma_cb) PARAMS ((cpp_reader *));
53 struct pragma_entry *next;
54 const cpp_hashnode *pragma; /* Name and length. */
58 struct pragma_entry *space;
62 /* Values for the origin field of struct directive. KANDR directives
63 come from traditional (K&R) C. STDC89 directives come from the
64 1989 C standard. EXTENSION directives are extensions. */
69 /* Values for the flags field of struct directive. COND indicates a
70 conditional; IF_COND an opening conditional. INCL means to treat
71 "..." and <...> as q-char and h-char sequences respectively. IN_I
72 means this directive should be handled even if -fpreprocessed is in
73 effect (these are the directives with callback hooks).
75 EXPAND is set on directives that are always macro-expanded. */
77 #define IF_COND (1 << 1)
80 #define EXPAND (1 << 4)
82 /* Defines one #-directive, including how to handle it. */
83 typedef void (*directive_handler) PARAMS ((cpp_reader *));
84 typedef struct directive directive;
87 directive_handler handler; /* Function to handle directive. */
88 const uchar *name; /* Name of directive. */
89 unsigned short length; /* Length of name. */
90 unsigned char origin; /* Origin of directive. */
91 unsigned char flags; /* Flags describing this directive. */
94 /* Forward declarations. */
96 static void skip_rest_of_line PARAMS ((cpp_reader *));
97 static void check_eol PARAMS ((cpp_reader *));
98 static void start_directive PARAMS ((cpp_reader *));
99 static void prepare_directive_trad PARAMS ((cpp_reader *));
100 static void end_directive PARAMS ((cpp_reader *, int));
101 static void directive_diagnostics
102 PARAMS ((cpp_reader *, const directive *, int));
103 static void run_directive PARAMS ((cpp_reader *, int,
104 const char *, size_t));
105 static const cpp_token *glue_header_name PARAMS ((cpp_reader *));
106 static const cpp_token *parse_include PARAMS ((cpp_reader *));
107 static void push_conditional PARAMS ((cpp_reader *, int, int,
108 const cpp_hashnode *));
109 static unsigned int read_flag PARAMS ((cpp_reader *, unsigned int));
110 static uchar *dequote_string PARAMS ((cpp_reader *, const uchar *,
112 static int strtoul_for_line PARAMS ((const uchar *, unsigned int,
114 static void do_diagnostic PARAMS ((cpp_reader *, int, int));
115 static cpp_hashnode *lex_macro_node PARAMS ((cpp_reader *));
116 static void do_include_common PARAMS ((cpp_reader *, enum include_type));
117 static struct pragma_entry *lookup_pragma_entry
118 PARAMS ((struct pragma_entry *, const cpp_hashnode *pragma));
119 static struct pragma_entry *insert_pragma_entry
120 PARAMS ((cpp_reader *, struct pragma_entry **, const cpp_hashnode *,
122 static void do_pragma_once PARAMS ((cpp_reader *));
123 static void do_pragma_poison PARAMS ((cpp_reader *));
124 static void do_pragma_system_header PARAMS ((cpp_reader *));
125 static void do_pragma_dependency PARAMS ((cpp_reader *));
126 static void do_linemarker PARAMS ((cpp_reader *));
127 static const cpp_token *get_token_no_padding PARAMS ((cpp_reader *));
128 static const cpp_token *get__Pragma_string PARAMS ((cpp_reader *));
129 static void destringize_and_run PARAMS ((cpp_reader *, const cpp_string *));
130 static int parse_answer PARAMS ((cpp_reader *, struct answer **, int));
131 static cpp_hashnode *parse_assertion PARAMS ((cpp_reader *, struct answer **,
133 static struct answer ** find_answer PARAMS ((cpp_hashnode *,
134 const struct answer *));
135 static void handle_assertion PARAMS ((cpp_reader *, const char *, int));
137 /* This is the table of directive handlers. It is ordered by
138 frequency of occurrence; the numbers at the end are directive
139 counts from all the source code I have lying around (egcs and libc
140 CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
141 pcmcia-cs-3.0.9). This is no longer important as directive lookup
142 is now O(1). All extensions other than #warning and #include_next
143 are deprecated. The name is where the extension appears to have
146 #define DIRECTIVE_TABLE \
147 D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
148 D(include, T_INCLUDE, KANDR, INCL | EXPAND) /* 52262 */ \
149 D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
150 D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
151 D(if, T_IF, KANDR, COND | IF_COND | EXPAND) /* 18162 */ \
152 D(else, T_ELSE, KANDR, COND) /* 9863 */ \
153 D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
154 D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
155 D(line, T_LINE, KANDR, EXPAND) /* 2465 */ \
156 D(elif, T_ELIF, STDC89, COND | EXPAND) /* 610 */ \
157 D(error, T_ERROR, STDC89, 0) /* 475 */ \
158 D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
159 D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
160 D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL | EXPAND) /* 19 */ \
161 D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
162 D(import, T_IMPORT, EXTENSION, INCL | EXPAND) /* 0 ObjC */ \
163 D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
164 D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
165 D(sccs, T_SCCS, EXTENSION, 0) /* 0 SVR4? */
167 /* Use the table to generate a series of prototypes, an enum for the
168 directive names, and an array of directive handlers. */
170 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
171 #define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
175 #define D(n, tag, o, f) tag,
183 /* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
184 #define D(name, t, origin, flags) \
185 { CONCAT2(do_,name), (const uchar *) STRINGX(name), \
186 sizeof STRINGX(name) - 1, origin, flags },
187 static const directive dtable[] =
192 #undef DIRECTIVE_TABLE
194 /* Wrapper struct directive for linemarkers.
195 The origin is more or less true - the original K+R cpp
196 did use this notation in its preprocessed output. */
197 static const directive linemarker_dir =
199 do_linemarker, U"#", 1, KANDR, IN_I
202 #define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
204 /* Skip any remaining tokens in a directive. */
206 skip_rest_of_line (pfile)
209 /* Discard all stacked contexts. */
210 while (pfile->context->prev)
211 _cpp_pop_context (pfile);
213 /* Sweep up all tokens remaining on the line. */
215 while (_cpp_lex_token (pfile)->type != CPP_EOF)
219 /* Ensure there are no stray tokens at the end of a directive. */
224 if (! SEEN_EOL () && _cpp_lex_token (pfile)->type != CPP_EOF)
225 cpp_error (pfile, DL_PEDWARN, "extra tokens at end of #%s directive",
226 pfile->directive->name);
229 /* Called when entering a directive, _Pragma or command-line directive. */
231 start_directive (pfile)
234 /* Setup in-directive state. */
235 pfile->state.in_directive = 1;
236 pfile->state.save_comments = 0;
238 /* Some handlers need the position of the # for diagnostics. */
239 pfile->directive_line = pfile->line;
242 /* Called when leaving a directive, _Pragma or command-line directive. */
244 end_directive (pfile, skip_line)
248 if (CPP_OPTION (pfile, traditional))
250 /* Revert change of prepare_directive_trad. */
251 pfile->state.prevent_expansion--;
253 if (pfile->directive != &dtable[T_DEFINE])
254 _cpp_remove_overlay (pfile);
256 /* We don't skip for an assembler #. */
259 skip_rest_of_line (pfile);
260 if (!pfile->keep_tokens)
262 pfile->cur_run = &pfile->base_run;
263 pfile->cur_token = pfile->base_run.base;
268 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
269 pfile->state.in_directive = 0;
270 pfile->state.in_expression = 0;
271 pfile->state.angled_headers = 0;
272 pfile->directive = 0;
275 /* Prepare to handle the directive in pfile->directive. */
277 prepare_directive_trad (pfile)
280 if (pfile->directive != &dtable[T_DEFINE])
282 bool no_expand = (pfile->directive
283 && ! (pfile->directive->flags & EXPAND));
284 bool was_skipping = pfile->state.skipping;
286 pfile->state.skipping = false;
287 pfile->state.in_expression = (pfile->directive == &dtable[T_IF]
288 || pfile->directive == &dtable[T_ELIF]);
290 pfile->state.prevent_expansion++;
291 _cpp_read_logical_line_trad (pfile);
293 pfile->state.prevent_expansion--;
294 pfile->state.skipping = was_skipping;
295 _cpp_overlay_buffer (pfile, pfile->out.base,
296 pfile->out.cur - pfile->out.base);
299 /* Stop ISO C from expanding anything. */
300 pfile->state.prevent_expansion++;
303 /* Output diagnostics for a directive DIR. INDENTED is nonzero if
304 the '#' was indented. */
306 directive_diagnostics (pfile, dir, indented)
308 const directive *dir;
311 /* Issue -pedantic warnings for extensions. */
312 if (CPP_PEDANTIC (pfile)
313 && ! pfile->state.skipping
314 && dir->origin == EXTENSION)
315 cpp_error (pfile, DL_PEDWARN, "#%s is a GCC extension", dir->name);
317 /* Traditionally, a directive is ignored unless its # is in
318 column 1. Therefore in code intended to work with K+R
319 compilers, directives added by C89 must have their #
320 indented, and directives present in traditional C must not.
321 This is true even of directives in skipped conditional
322 blocks. #elif cannot be used at all. */
323 if (CPP_WTRADITIONAL (pfile))
325 if (dir == &dtable[T_ELIF])
326 cpp_error (pfile, DL_WARNING,
327 "suggest not using #elif in traditional C");
328 else if (indented && dir->origin == KANDR)
329 cpp_error (pfile, DL_WARNING,
330 "traditional C ignores #%s with the # indented",
332 else if (!indented && dir->origin != KANDR)
333 cpp_error (pfile, DL_WARNING,
334 "suggest hiding #%s from traditional C with an indented #",
339 /* Check if we have a known directive. INDENTED is nonzero if the
340 '#' of the directive was indented. This function is in this file
341 to save unnecessarily exporting dtable etc. to cpplex.c. Returns
342 nonzero if the line of tokens has been handled, zero if we should
343 continue processing the line. */
345 _cpp_handle_directive (pfile, indented)
349 const directive *dir = 0;
350 const cpp_token *dname;
351 bool was_parsing_args = pfile->state.parsing_args;
354 if (was_parsing_args)
356 if (CPP_OPTION (pfile, pedantic))
357 cpp_error (pfile, DL_PEDWARN,
358 "embedding a directive within macro arguments is not portable");
359 pfile->state.parsing_args = 0;
360 pfile->state.prevent_expansion = 0;
362 start_directive (pfile);
363 dname = _cpp_lex_token (pfile);
365 if (dname->type == CPP_NAME)
367 if (dname->val.node->directive_index)
368 dir = &dtable[dname->val.node->directive_index - 1];
370 /* We do not recognize the # followed by a number extension in
372 else if (dname->type == CPP_NUMBER && CPP_OPTION (pfile, lang) != CLK_ASM)
374 dir = &linemarker_dir;
375 if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed)
376 && ! pfile->state.skipping)
377 cpp_error (pfile, DL_PEDWARN,
378 "style of line directive is a GCC extension");
383 /* If we have a directive that is not an opening conditional,
384 invalidate any control macro. */
385 if (! (dir->flags & IF_COND))
386 pfile->mi_valid = false;
388 /* Kluge alert. In order to be sure that code like this
393 does not cause '#define foo bar' to get executed when
394 compiled with -save-temps, we recognize directives in
395 -fpreprocessed mode only if the # is in column 1. cppmacro.c
396 puts a space in front of any '#' at the start of a macro. */
397 if (CPP_OPTION (pfile, preprocessed)
398 && (indented || !(dir->flags & IN_I)))
405 /* In failed conditional groups, all non-conditional
406 directives are ignored. Before doing that, whether
407 skipping or not, we should lex angle-bracketed headers
408 correctly, and maybe output some diagnostics. */
409 pfile->state.angled_headers = dir->flags & INCL;
410 if (! CPP_OPTION (pfile, preprocessed))
411 directive_diagnostics (pfile, dir, indented);
412 if (pfile->state.skipping && !(dir->flags & COND))
416 else if (dname->type == CPP_EOF)
417 ; /* CPP_EOF is the "null directive". */
420 /* An unknown directive. Don't complain about it in assembly
421 source: we don't know where the comments are, and # may
422 introduce assembler pseudo-ops. Don't complain about invalid
423 directives in skipped conditional groups (6.10 p4). */
424 if (CPP_OPTION (pfile, lang) == CLK_ASM)
426 else if (!pfile->state.skipping)
427 cpp_error (pfile, DL_ERROR, "invalid preprocessing directive #%s",
428 cpp_token_as_text (pfile, dname));
431 pfile->directive = dir;
432 if (CPP_OPTION (pfile, traditional))
433 prepare_directive_trad (pfile);
436 (*pfile->directive->handler) (pfile);
438 _cpp_backup_tokens (pfile, 1);
440 end_directive (pfile, skip);
441 if (was_parsing_args)
443 /* Restore state when within macro args. */
444 pfile->state.parsing_args = 2;
445 pfile->state.prevent_expansion = 1;
446 pfile->buffer->saved_flags |= PREV_WHITE;
451 /* Directive handler wrapper used by the command line option
454 run_directive (pfile, dir_no, buf, count)
460 cpp_push_buffer (pfile, (const uchar *) buf, count,
461 /* from_stage3 */ true, 1);
462 /* Disgusting hack. */
463 if (dir_no == T_PRAGMA)
464 pfile->buffer->inc = pfile->buffer->prev->inc;
465 start_directive (pfile);
466 /* We don't want a leading # to be interpreted as a directive. */
467 pfile->buffer->saved_flags = 0;
468 pfile->directive = &dtable[dir_no];
469 if (CPP_OPTION (pfile, traditional))
470 prepare_directive_trad (pfile);
471 (void) (*pfile->directive->handler) (pfile);
472 end_directive (pfile, 1);
473 if (dir_no == T_PRAGMA)
474 pfile->buffer->inc = NULL;
475 _cpp_pop_buffer (pfile);
478 /* Checks for validity the macro name in #define, #undef, #ifdef and
479 #ifndef directives. */
480 static cpp_hashnode *
481 lex_macro_node (pfile)
484 const cpp_token *token = _cpp_lex_token (pfile);
486 /* The token immediately after #define must be an identifier. That
487 identifier may not be "defined", per C99 6.10.8p4.
488 In C++, it may not be any of the "named operators" either,
489 per C++98 [lex.digraph], [lex.key].
490 Finally, the identifier may not have been poisoned. (In that case
491 the lexer has issued the error message for us.) */
493 if (token->type == CPP_NAME)
495 cpp_hashnode *node = token->val.node;
497 if (node == pfile->spec_nodes.n_defined)
498 cpp_error (pfile, DL_ERROR,
499 "\"defined\" cannot be used as a macro name");
500 else if (! (node->flags & NODE_POISONED))
503 else if (token->flags & NAMED_OP)
504 cpp_error (pfile, DL_ERROR,
505 "\"%s\" cannot be used as a macro name as it is an operator in C++",
506 NODE_NAME (token->val.node));
507 else if (token->type == CPP_EOF)
508 cpp_error (pfile, DL_ERROR, "no macro name given in #%s directive",
509 pfile->directive->name);
511 cpp_error (pfile, DL_ERROR, "macro names must be identifiers");
516 /* Process a #define directive. Most work is done in cppmacro.c. */
521 cpp_hashnode *node = lex_macro_node (pfile);
525 /* If we have been requested to expand comments into macros,
526 then re-enable saving of comments. */
527 pfile->state.save_comments =
528 ! CPP_OPTION (pfile, discard_comments_in_macro_exp);
530 if (_cpp_create_definition (pfile, node))
531 if (pfile->cb.define)
532 (*pfile->cb.define) (pfile, pfile->directive_line, node);
536 /* Handle #undef. Mark the identifier NT_VOID in the hash table. */
541 cpp_hashnode *node = lex_macro_node (pfile);
543 /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
544 is not currently defined as a macro name. */
545 if (node && node->type == NT_MACRO)
548 (*pfile->cb.undef) (pfile, pfile->directive_line, node);
550 if (node->flags & NODE_WARN)
551 cpp_error (pfile, DL_WARNING, "undefining \"%s\"", NODE_NAME (node));
553 if (CPP_OPTION (pfile, warn_unused_macros))
554 _cpp_warn_if_unused_macro (pfile, node, NULL);
556 _cpp_free_definition (node);
561 /* Helper routine used by parse_include. Reinterpret the current line
562 as an h-char-sequence (< ... >); we are looking at the first token
563 after the <. Returns the header as a token, or NULL on failure. */
564 static const cpp_token *
565 glue_header_name (pfile)
568 cpp_token *header = NULL;
569 const cpp_token *token;
570 unsigned char *buffer;
571 size_t len, total_len = 0, capacity = 1024;
573 /* To avoid lexed tokens overwriting our glued name, we can only
574 allocate from the string pool once we've lexed everything. */
575 buffer = (unsigned char *) xmalloc (capacity);
578 token = cpp_get_token (pfile);
580 if (token->type == CPP_GREATER || token->type == CPP_EOF)
583 len = cpp_token_len (token);
584 if (total_len + len > capacity)
586 capacity = (capacity + len) * 2;
587 buffer = (unsigned char *) xrealloc (buffer, capacity);
590 if (token->flags & PREV_WHITE)
591 buffer[total_len++] = ' ';
593 total_len = cpp_spell_token (pfile, token, &buffer[total_len]) - buffer;
596 if (token->type == CPP_EOF)
597 cpp_error (pfile, DL_ERROR, "missing terminating > character");
600 unsigned char *token_mem = _cpp_unaligned_alloc (pfile, total_len + 1);
601 memcpy (token_mem, buffer, total_len);
602 token_mem[total_len] = '\0';
604 header = _cpp_temp_token (pfile);
605 header->type = CPP_HEADER_NAME;
607 header->val.str.len = total_len;
608 header->val.str.text = token_mem;
615 /* Returns the header string of #include, #include_next, #import and
616 #pragma dependency. Returns NULL on error. */
617 static const cpp_token *
618 parse_include (pfile)
621 const unsigned char *dir;
622 const cpp_token *header;
624 if (pfile->directive == &dtable[T_PRAGMA])
625 dir = U"pragma dependency";
627 dir = pfile->directive->name;
629 /* Allow macro expansion. */
630 header = cpp_get_token (pfile);
631 if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
633 if (header->type != CPP_LESS)
635 cpp_error (pfile, DL_ERROR,
636 "#%s expects \"FILENAME\" or <FILENAME>", dir);
640 header = glue_header_name (pfile);
645 if (header->val.str.len == 0)
647 cpp_error (pfile, DL_ERROR, "empty file name in #%s", dir);
654 /* Handle #include, #include_next and #import. */
656 do_include_common (pfile, type)
658 enum include_type type;
660 const cpp_token *header;
662 /* For #include_next, if this is the primary source file, warn and
663 use the normal search logic. */
664 if (type == IT_INCLUDE_NEXT && ! pfile->buffer->prev)
666 cpp_error (pfile, DL_WARNING, "#include_next in primary source file");
669 else if (type == IT_IMPORT && CPP_OPTION (pfile, warn_import))
671 CPP_OPTION (pfile, warn_import) = 0;
672 cpp_error (pfile, DL_WARNING,
673 "#import is obsolete, use an #ifndef wrapper in the header file");
676 header = parse_include (pfile);
679 /* Prevent #include recursion. */
680 if (pfile->line_maps.depth >= CPP_STACK_MAX)
681 cpp_error (pfile, DL_ERROR, "#include nested too deeply");
685 /* Get out of macro context, if we are. */
686 skip_rest_of_line (pfile);
687 if (pfile->cb.include)
688 (*pfile->cb.include) (pfile, pfile->directive_line,
689 pfile->directive->name, header);
690 _cpp_execute_include (pfile, header, type);
699 do_include_common (pfile, IT_INCLUDE);
706 do_include_common (pfile, IT_IMPORT);
710 do_include_next (pfile)
713 do_include_common (pfile, IT_INCLUDE_NEXT);
716 /* Subroutine of do_linemarker. Read possible flags after file name.
717 LAST is the last flag seen; 0 if this is the first flag. Return the
718 flag if it is valid, 0 at the end of the directive. Otherwise
721 read_flag (pfile, last)
725 const cpp_token *token = _cpp_lex_token (pfile);
727 if (token->type == CPP_NUMBER && token->val.str.len == 1)
729 unsigned int flag = token->val.str.text[0] - '0';
731 if (flag > last && flag <= 4
732 && (flag != 4 || last == 3)
733 && (flag != 2 || last == 0))
737 if (token->type != CPP_EOF)
738 cpp_error (pfile, DL_ERROR, "invalid flag \"%s\" in line directive",
739 cpp_token_as_text (pfile, token));
743 /* Subroutine of do_line and do_linemarker. Returns a version of STR
744 which has a NUL terminator and all escape sequences converted to
745 their equivalents. Temporary, hopefully. */
747 dequote_string (pfile, str, len)
752 uchar *result = _cpp_unaligned_alloc (pfile, len + 1);
754 const uchar *limit = str + len;
763 *dst++ = cpp_parse_escape (pfile, &str, limit, 0);
769 /* Subroutine of do_line and do_linemarker. Convert a number in STR,
770 of length LEN, to binary; store it in NUMP, and return 0 if the
771 number was well-formed, 1 if not. Temporary, hopefully. */
773 strtoul_for_line (str, len, nump)
778 unsigned long reg = 0;
792 /* Interpret #line command.
793 Note that the filename string (if any) is a true string constant
794 (escapes are interpreted), unlike in #line. */
799 const cpp_token *token;
800 const char *new_file = pfile->map->to_file;
801 unsigned long new_lineno;
803 /* C99 raised the minimum limit on #line numbers. */
804 unsigned int cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
806 /* #line commands expand macros. */
807 token = cpp_get_token (pfile);
808 if (token->type != CPP_NUMBER
809 || strtoul_for_line (token->val.str.text, token->val.str.len,
812 cpp_error (pfile, DL_ERROR,
813 "\"%s\" after #line is not a positive integer",
814 cpp_token_as_text (pfile, token));
818 if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
819 cpp_error (pfile, DL_PEDWARN, "line number out of range");
821 token = cpp_get_token (pfile);
822 if (token->type == CPP_STRING)
824 new_file = (const char *) dequote_string (pfile, token->val.str.text,
828 else if (token->type != CPP_EOF)
830 cpp_error (pfile, DL_ERROR, "\"%s\" is not a valid filename",
831 cpp_token_as_text (pfile, token));
835 skip_rest_of_line (pfile);
836 _cpp_do_file_change (pfile, LC_RENAME, new_file, new_lineno,
840 /* Interpret the # 44 "file" [flags] notation, which has slightly
841 different syntax and semantics from #line: Flags are allowed,
842 and we never complain about the line number being too big. */
844 do_linemarker (pfile)
847 const cpp_token *token;
848 const char *new_file = pfile->map->to_file;
849 unsigned long new_lineno;
850 unsigned int new_sysp = pfile->map->sysp;
851 enum lc_reason reason = LC_RENAME;
854 /* Back up so we can get the number again. Putting this in
855 _cpp_handle_directive risks two calls to _cpp_backup_tokens in
856 some circumstances, which can segfault. */
857 _cpp_backup_tokens (pfile, 1);
859 /* #line commands expand macros. */
860 token = cpp_get_token (pfile);
861 if (token->type != CPP_NUMBER
862 || strtoul_for_line (token->val.str.text, token->val.str.len,
865 cpp_error (pfile, DL_ERROR, "\"%s\" after # is not a positive integer",
866 cpp_token_as_text (pfile, token));
870 token = cpp_get_token (pfile);
871 if (token->type == CPP_STRING)
873 new_file = (const char *) dequote_string (pfile, token->val.str.text,
876 flag = read_flag (pfile, 0);
880 /* Fake an include for cpp_included (). */
881 _cpp_fake_include (pfile, new_file);
882 flag = read_flag (pfile, flag);
887 flag = read_flag (pfile, flag);
892 flag = read_flag (pfile, flag);
899 else if (token->type != CPP_EOF)
901 cpp_error (pfile, DL_ERROR, "\"%s\" is not a valid filename",
902 cpp_token_as_text (pfile, token));
906 skip_rest_of_line (pfile);
907 _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp);
910 /* Arrange the file_change callback. pfile->line has changed to
911 FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system
912 header, 2 for a system header that needs to be extern "C" protected,
913 and zero otherwise. */
915 _cpp_do_file_change (pfile, reason, to_file, file_line, sysp)
917 enum lc_reason reason;
919 unsigned int file_line;
922 pfile->map = add_line_map (&pfile->line_maps, reason, sysp,
923 pfile->line, to_file, file_line);
925 if (pfile->cb.file_change)
926 (*pfile->cb.file_change) (pfile, pfile->map);
929 /* Report a warning or error detected by the program we are
930 processing. Use the directive's tokens in the error message. */
932 do_diagnostic (pfile, code, print_dir)
937 if (_cpp_begin_message (pfile, code,
938 pfile->cur_token[-1].line,
939 pfile->cur_token[-1].col))
942 fprintf (stderr, "#%s ", pfile->directive->name);
943 pfile->state.prevent_expansion++;
944 cpp_output_line (pfile, stderr);
945 pfile->state.prevent_expansion--;
953 do_diagnostic (pfile, DL_ERROR, 1);
960 /* We want #warning diagnostics to be emitted in system headers too. */
961 do_diagnostic (pfile, DL_WARNING_SYSHDR, 1);
964 /* Report program identification. */
969 const cpp_token *str = cpp_get_token (pfile);
971 if (str->type != CPP_STRING)
972 cpp_error (pfile, DL_ERROR, "invalid #ident directive");
973 else if (pfile->cb.ident)
974 (*pfile->cb.ident) (pfile, pfile->directive_line, &str->val.str);
979 /* Lookup a PRAGMA name in a singly-linked CHAIN. Returns the
980 matching entry, or NULL if none is found. The returned entry could
981 be the start of a namespace chain, or a pragma. */
982 static struct pragma_entry *
983 lookup_pragma_entry (chain, pragma)
984 struct pragma_entry *chain;
985 const cpp_hashnode *pragma;
987 while (chain && chain->pragma != pragma)
993 /* Create and insert a pragma entry for NAME at the beginning of a
994 singly-linked CHAIN. If handler is NULL, it is a namespace,
995 otherwise it is a pragma and its handler. */
996 static struct pragma_entry *
997 insert_pragma_entry (pfile, chain, pragma, handler)
999 struct pragma_entry **chain;
1000 const cpp_hashnode *pragma;
1003 struct pragma_entry *new;
1005 new = (struct pragma_entry *)
1006 _cpp_aligned_alloc (pfile, sizeof (struct pragma_entry));
1007 new->pragma = pragma;
1011 new->u.handler = handler;
1016 new->u.space = NULL;
1024 /* Register a pragma NAME in namespace SPACE. If SPACE is null, it
1025 goes in the global namespace. HANDLER is the handler it will call,
1026 which must be non-NULL. */
1028 cpp_register_pragma (pfile, space, name, handler)
1034 struct pragma_entry **chain = &pfile->pragmas;
1035 struct pragma_entry *entry;
1036 const cpp_hashnode *node;
1043 node = cpp_lookup (pfile, U space, strlen (space));
1044 entry = lookup_pragma_entry (*chain, node);
1046 entry = insert_pragma_entry (pfile, chain, node, NULL);
1047 else if (!entry->is_nspace)
1049 chain = &entry->u.space;
1052 /* Check for duplicates. */
1053 node = cpp_lookup (pfile, U name, strlen (name));
1054 entry = lookup_pragma_entry (*chain, node);
1057 if (entry->is_nspace)
1059 cpp_error (pfile, DL_ICE,
1060 "registering \"%s\" as both a pragma and a pragma namespace",
1063 cpp_error (pfile, DL_ICE, "#pragma %s %s is already registered",
1066 cpp_error (pfile, DL_ICE, "#pragma %s is already registered", name);
1069 insert_pragma_entry (pfile, chain, node, handler);
1072 /* Register the pragmas the preprocessor itself handles. */
1074 _cpp_init_internal_pragmas (pfile)
1077 /* Pragmas in the global namespace. */
1078 cpp_register_pragma (pfile, 0, "once", do_pragma_once);
1080 /* New GCC-specific pragmas should be put in the GCC namespace. */
1081 cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
1082 cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
1083 cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
1086 /* Pragmata handling. We handle some, and pass the rest on to the
1087 front end. C99 defines three pragmas and says that no macro
1088 expansion is to be performed on them; whether or not macro
1089 expansion happens for other pragmas is implementation defined.
1090 This implementation never macro-expands the text after #pragma. */
1095 const struct pragma_entry *p = NULL;
1096 const cpp_token *token;
1097 unsigned int count = 1;
1099 pfile->state.prevent_expansion++;
1101 token = cpp_get_token (pfile);
1102 if (token->type == CPP_NAME)
1104 p = lookup_pragma_entry (pfile->pragmas, token->val.node);
1105 if (p && p->is_nspace)
1108 token = cpp_get_token (pfile);
1109 if (token->type == CPP_NAME)
1110 p = lookup_pragma_entry (p->u.space, token->val.node);
1116 /* FIXME. This is an awful kludge to get the front ends to update
1117 their notion of line number for diagnostic purposes. The line
1118 number should be passed to the handler and they should do it
1119 themselves. Stand-alone CPP must ignore us, otherwise it will
1120 prefix the directive with spaces, hence the 1. Ugh. */
1121 if (pfile->cb.line_change)
1122 (*pfile->cb.line_change)(pfile, token, 1);
1125 (*p->u.handler) (pfile);
1126 else if (pfile->cb.def_pragma)
1128 _cpp_backup_tokens (pfile, count);
1129 (*pfile->cb.def_pragma) (pfile, pfile->directive_line);
1132 pfile->state.prevent_expansion--;
1135 /* Handle #pragma once. */
1137 do_pragma_once (pfile)
1140 cpp_error (pfile, DL_WARNING, "#pragma once is obsolete");
1142 if (pfile->buffer->prev == NULL)
1143 cpp_error (pfile, DL_WARNING, "#pragma once in main file");
1145 _cpp_never_reread (pfile->buffer->inc);
1150 /* Handle #pragma GCC poison, to poison one or more identifiers so
1151 that the lexer produces a hard error for each subsequent usage. */
1153 do_pragma_poison (pfile)
1156 const cpp_token *tok;
1159 pfile->state.poisoned_ok = 1;
1162 tok = _cpp_lex_token (pfile);
1163 if (tok->type == CPP_EOF)
1165 if (tok->type != CPP_NAME)
1167 cpp_error (pfile, DL_ERROR, "invalid #pragma GCC poison directive");
1172 if (hp->flags & NODE_POISONED)
1175 if (hp->type == NT_MACRO)
1176 cpp_error (pfile, DL_WARNING, "poisoning existing macro \"%s\"",
1178 _cpp_free_definition (hp);
1179 hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
1181 pfile->state.poisoned_ok = 0;
1184 /* Mark the current header as a system header. This will suppress
1185 some categories of warnings (notably those from -pedantic). It is
1186 intended for use in system libraries that cannot be implemented in
1187 conforming C, but cannot be certain that their headers appear in a
1188 system include directory. To prevent abuse, it is rejected in the
1189 primary source file. */
1191 do_pragma_system_header (pfile)
1194 cpp_buffer *buffer = pfile->buffer;
1196 if (buffer->prev == 0)
1197 cpp_error (pfile, DL_WARNING,
1198 "#pragma system_header ignored outside include file");
1202 skip_rest_of_line (pfile);
1203 cpp_make_system_header (pfile, 1, 0);
1207 /* Check the modified date of the current include file against a specified
1208 file. Issue a diagnostic, if the specified file is newer. We use this to
1209 determine if a fixed header should be refixed. */
1211 do_pragma_dependency (pfile)
1214 const cpp_token *header;
1217 header = parse_include (pfile);
1221 ordering = _cpp_compare_file_date (pfile, header);
1223 cpp_error (pfile, DL_WARNING, "cannot find source %s",
1224 cpp_token_as_text (pfile, header));
1225 else if (ordering > 0)
1227 cpp_error (pfile, DL_WARNING, "current file is older than %s",
1228 cpp_token_as_text (pfile, header));
1229 if (cpp_get_token (pfile)->type != CPP_EOF)
1231 _cpp_backup_tokens (pfile, 1);
1232 do_diagnostic (pfile, DL_WARNING, 0);
1237 /* Get a token but skip padding. */
1238 static const cpp_token *
1239 get_token_no_padding (pfile)
1244 const cpp_token *result = cpp_get_token (pfile);
1245 if (result->type != CPP_PADDING)
1250 /* Check syntax is "(string-literal)". Returns the string on success,
1251 or NULL on failure. */
1252 static const cpp_token *
1253 get__Pragma_string (pfile)
1256 const cpp_token *string;
1258 if (get_token_no_padding (pfile)->type != CPP_OPEN_PAREN)
1261 string = get_token_no_padding (pfile);
1262 if (string->type != CPP_STRING && string->type != CPP_WSTRING)
1265 if (get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
1271 /* Destringize IN into a temporary buffer, by removing the first \ of
1272 \" and \\ sequences, and process the result as a #pragma directive. */
1274 destringize_and_run (pfile, in)
1276 const cpp_string *in;
1278 const unsigned char *src, *limit;
1279 char *dest, *result;
1281 dest = result = alloca (in->len + 1);
1282 for (src = in->text, limit = src + in->len; src < limit;)
1284 /* We know there is a character following the backslash. */
1285 if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
1291 /* Ugh; an awful kludge. We are really not set up to be lexing
1292 tokens when in the middle of a macro expansion. Use a new
1293 context to force cpp_get_token to lex, and so skip_rest_of_line
1294 doesn't go beyond the end of the text. Also, remember the
1295 current lexing position so we can return to it later.
1297 Something like line-at-a-time lexing should remove the need for
1300 cpp_context *saved_context = pfile->context;
1301 cpp_token *saved_cur_token = pfile->cur_token;
1302 tokenrun *saved_cur_run = pfile->cur_run;
1304 pfile->context = xnew (cpp_context);
1305 pfile->context->macro = 0;
1306 pfile->context->prev = 0;
1307 run_directive (pfile, T_PRAGMA, result, dest - result);
1308 free (pfile->context);
1309 pfile->context = saved_context;
1310 pfile->cur_token = saved_cur_token;
1311 pfile->cur_run = saved_cur_run;
1315 /* See above comment. For the moment, we'd like
1317 token1 _Pragma ("foo") token2
1327 Getting the line markers is a little tricky. */
1328 if (pfile->cb.line_change)
1329 (*pfile->cb.line_change) (pfile, pfile->cur_token, false);
1332 /* Handle the _Pragma operator. */
1334 _cpp_do__Pragma (pfile)
1337 const cpp_token *string = get__Pragma_string (pfile);
1340 destringize_and_run (pfile, &string->val.str);
1342 cpp_error (pfile, DL_ERROR,
1343 "_Pragma takes a parenthesized string literal");
1346 /* Just ignore #sccs on all systems. */
1349 cpp_reader *pfile ATTRIBUTE_UNUSED;
1353 /* Handle #ifdef. */
1360 if (! pfile->state.skipping)
1362 const cpp_hashnode *node = lex_macro_node (pfile);
1366 skip = node->type != NT_MACRO;
1367 _cpp_mark_macro_used (node);
1372 push_conditional (pfile, skip, T_IFDEF, 0);
1375 /* Handle #ifndef. */
1381 const cpp_hashnode *node = 0;
1383 if (! pfile->state.skipping)
1385 node = lex_macro_node (pfile);
1389 skip = node->type == NT_MACRO;
1390 _cpp_mark_macro_used (node);
1395 push_conditional (pfile, skip, T_IFNDEF, node);
1398 /* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
1399 pfile->mi_ind_cmacro so we can handle multiple-include
1400 optimisations. If macro expansion occurs in the expression, we
1401 cannot treat it as a controlling conditional, since the expansion
1402 could change in the future. That is handled by cpp_get_token. */
1409 if (! pfile->state.skipping)
1410 skip = _cpp_parse_expr (pfile) == false;
1412 push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
1415 /* Flip skipping state if appropriate and continue without changing
1416 if_stack; this is so that the error message for missing #endif's
1417 etc. will point to the original #if. */
1422 cpp_buffer *buffer = pfile->buffer;
1423 struct if_stack *ifs = buffer->if_stack;
1426 cpp_error (pfile, DL_ERROR, "#else without #if");
1429 if (ifs->type == T_ELSE)
1431 cpp_error (pfile, DL_ERROR, "#else after #else");
1432 cpp_error_with_line (pfile, DL_ERROR, ifs->line, 0,
1433 "the conditional began here");
1437 /* Skip any future (erroneous) #elses or #elifs. */
1438 pfile->state.skipping = ifs->skip_elses;
1439 ifs->skip_elses = true;
1441 /* Invalidate any controlling macro. */
1444 /* Only check EOL if was not originally skipping. */
1445 if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
1450 /* Handle a #elif directive by not changing if_stack either. See the
1451 comment above do_else. */
1456 cpp_buffer *buffer = pfile->buffer;
1457 struct if_stack *ifs = buffer->if_stack;
1460 cpp_error (pfile, DL_ERROR, "#elif without #if");
1463 if (ifs->type == T_ELSE)
1465 cpp_error (pfile, DL_ERROR, "#elif after #else");
1466 cpp_error_with_line (pfile, DL_ERROR, ifs->line, 0,
1467 "the conditional began here");
1471 /* Only evaluate this if we aren't skipping elses. During
1472 evaluation, set skipping to false to get lexer warnings. */
1473 if (ifs->skip_elses)
1474 pfile->state.skipping = 1;
1477 pfile->state.skipping = 0;
1478 pfile->state.skipping = ! _cpp_parse_expr (pfile);
1479 ifs->skip_elses = ! pfile->state.skipping;
1482 /* Invalidate any controlling macro. */
1487 /* #endif pops the if stack and resets pfile->state.skipping. */
1492 cpp_buffer *buffer = pfile->buffer;
1493 struct if_stack *ifs = buffer->if_stack;
1496 cpp_error (pfile, DL_ERROR, "#endif without #if");
1499 /* Only check EOL if was not originally skipping. */
1500 if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
1503 /* If potential control macro, we go back outside again. */
1504 if (ifs->next == 0 && ifs->mi_cmacro)
1506 pfile->mi_valid = true;
1507 pfile->mi_cmacro = ifs->mi_cmacro;
1510 buffer->if_stack = ifs->next;
1511 pfile->state.skipping = ifs->was_skipping;
1512 obstack_free (&pfile->buffer_ob, ifs);
1516 /* Push an if_stack entry for a preprocessor conditional, and set
1517 pfile->state.skipping to SKIP. If TYPE indicates the conditional
1518 is #if or #ifndef, CMACRO is a potentially controlling macro, and
1519 we need to check here that we are at the top of the file. */
1521 push_conditional (pfile, skip, type, cmacro)
1525 const cpp_hashnode *cmacro;
1527 struct if_stack *ifs;
1528 cpp_buffer *buffer = pfile->buffer;
1530 ifs = xobnew (&pfile->buffer_ob, struct if_stack);
1531 ifs->line = pfile->directive_line;
1532 ifs->next = buffer->if_stack;
1533 ifs->skip_elses = pfile->state.skipping || !skip;
1534 ifs->was_skipping = pfile->state.skipping;
1536 /* This condition is effectively a test for top-of-file. */
1537 if (pfile->mi_valid && pfile->mi_cmacro == 0)
1538 ifs->mi_cmacro = cmacro;
1542 pfile->state.skipping = skip;
1543 buffer->if_stack = ifs;
1546 /* Read the tokens of the answer into the macro pool, in a directive
1547 of type TYPE. Only commit the memory if we intend it as permanent
1548 storage, i.e. the #assert case. Returns 0 on success, and sets
1549 ANSWERP to point to the answer. */
1551 parse_answer (pfile, answerp, type)
1553 struct answer **answerp;
1556 const cpp_token *paren;
1557 struct answer *answer;
1558 unsigned int acount;
1560 /* In a conditional, it is legal to not have an open paren. We
1561 should save the following token in this case. */
1562 paren = cpp_get_token (pfile);
1564 /* If not a paren, see if we're OK. */
1565 if (paren->type != CPP_OPEN_PAREN)
1567 /* In a conditional no answer is a test for any answer. It
1568 could be followed by any token. */
1571 _cpp_backup_tokens (pfile, 1);
1575 /* #unassert with no answer is valid - it removes all answers. */
1576 if (type == T_UNASSERT && paren->type == CPP_EOF)
1579 cpp_error (pfile, DL_ERROR, "missing '(' after predicate");
1583 for (acount = 0;; acount++)
1586 const cpp_token *token = cpp_get_token (pfile);
1589 if (token->type == CPP_CLOSE_PAREN)
1592 if (token->type == CPP_EOF)
1594 cpp_error (pfile, DL_ERROR, "missing ')' to complete answer");
1598 /* struct answer includes the space for one token. */
1599 room_needed = (sizeof (struct answer) + acount * sizeof (cpp_token));
1601 if (BUFF_ROOM (pfile->a_buff) < room_needed)
1602 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer));
1604 dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount];
1607 /* Drop whitespace at start, for answer equivalence purposes. */
1609 dest->flags &= ~PREV_WHITE;
1614 cpp_error (pfile, DL_ERROR, "predicate's answer is empty");
1618 answer = (struct answer *) BUFF_FRONT (pfile->a_buff);
1619 answer->count = acount;
1620 answer->next = NULL;
1626 /* Parses an assertion directive of type TYPE, returning a pointer to
1627 the hash node of the predicate, or 0 on error. If an answer was
1628 supplied, it is placed in ANSWERP, otherwise it is set to 0. */
1629 static cpp_hashnode *
1630 parse_assertion (pfile, answerp, type)
1632 struct answer **answerp;
1635 cpp_hashnode *result = 0;
1636 const cpp_token *predicate;
1638 /* We don't expand predicates or answers. */
1639 pfile->state.prevent_expansion++;
1642 predicate = cpp_get_token (pfile);
1643 if (predicate->type == CPP_EOF)
1644 cpp_error (pfile, DL_ERROR, "assertion without predicate");
1645 else if (predicate->type != CPP_NAME)
1646 cpp_error (pfile, DL_ERROR, "predicate must be an identifier");
1647 else if (parse_answer (pfile, answerp, type) == 0)
1649 unsigned int len = NODE_LEN (predicate->val.node);
1650 unsigned char *sym = alloca (len + 1);
1652 /* Prefix '#' to get it out of macro namespace. */
1654 memcpy (sym + 1, NODE_NAME (predicate->val.node), len);
1655 result = cpp_lookup (pfile, sym, len + 1);
1658 pfile->state.prevent_expansion--;
1662 /* Returns a pointer to the pointer to CANDIDATE in the answer chain,
1663 or a pointer to NULL if the answer is not in the chain. */
1664 static struct answer **
1665 find_answer (node, candidate)
1667 const struct answer *candidate;
1670 struct answer **result;
1672 for (result = &node->value.answers; *result; result = &(*result)->next)
1674 struct answer *answer = *result;
1676 if (answer->count == candidate->count)
1678 for (i = 0; i < answer->count; i++)
1679 if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
1682 if (i == answer->count)
1690 /* Test an assertion within a preprocessor conditional. Returns
1691 nonzero on failure, zero on success. On success, the result of
1692 the test is written into VALUE, otherwise the value 0. */
1694 _cpp_test_assertion (pfile, value)
1696 unsigned int *value;
1698 struct answer *answer;
1701 node = parse_assertion (pfile, &answer, T_IF);
1703 /* For recovery, an erroneous assertion expression is handled as a
1704 failing assertion. */
1708 *value = (node->type == NT_ASSERTION &&
1709 (answer == 0 || *find_answer (node, answer) != 0));
1710 else if (pfile->cur_token[-1].type == CPP_EOF)
1711 _cpp_backup_tokens (pfile, 1);
1713 /* We don't commit the memory for the answer - it's temporary only. */
1717 /* Handle #assert. */
1722 struct answer *new_answer;
1725 node = parse_assertion (pfile, &new_answer, T_ASSERT);
1728 /* Place the new answer in the answer list. First check there
1729 is not a duplicate. */
1730 new_answer->next = 0;
1731 if (node->type == NT_ASSERTION)
1733 if (*find_answer (node, new_answer))
1735 cpp_error (pfile, DL_WARNING, "\"%s\" re-asserted",
1736 NODE_NAME (node) + 1);
1739 new_answer->next = node->value.answers;
1742 node->type = NT_ASSERTION;
1743 node->value.answers = new_answer;
1744 BUFF_FRONT (pfile->a_buff) += (sizeof (struct answer)
1745 + (new_answer->count - 1)
1746 * sizeof (cpp_token));
1751 /* Handle #unassert. */
1757 struct answer *answer;
1759 node = parse_assertion (pfile, &answer, T_UNASSERT);
1760 /* It isn't an error to #unassert something that isn't asserted. */
1761 if (node && node->type == NT_ASSERTION)
1765 struct answer **p = find_answer (node, answer), *temp;
1767 /* Remove the answer from the list. */
1772 /* Did we free the last answer? */
1773 if (node->value.answers == 0)
1774 node->type = NT_VOID;
1779 _cpp_free_definition (node);
1782 /* We don't commit the memory for the answer - it's temporary only. */
1785 /* These are for -D, -U, -A. */
1787 /* Process the string STR as if it appeared as the body of a #define.
1788 If STR is just an identifier, define it with value 1.
1789 If STR has anything after the identifier, then it should
1790 be identifier=definition. */
1792 cpp_define (pfile, str)
1799 /* Copy the entire option so we can modify it.
1800 Change the first "=" in the string to a space. If there is none,
1801 tack " 1" on the end. */
1803 count = strlen (str);
1804 buf = (char *) alloca (count + 3);
1805 memcpy (buf, str, count);
1807 p = strchr (str, '=');
1817 run_directive (pfile, T_DEFINE, buf, count);
1820 /* Slight variant of the above for use by initialize_builtins. */
1822 _cpp_define_builtin (pfile, str)
1826 run_directive (pfile, T_DEFINE, str, strlen (str));
1829 /* Process MACRO as if it appeared as the body of an #undef. */
1831 cpp_undef (pfile, macro)
1835 run_directive (pfile, T_UNDEF, macro, strlen (macro));
1838 /* Process the string STR as if it appeared as the body of a #assert. */
1840 cpp_assert (pfile, str)
1844 handle_assertion (pfile, str, T_ASSERT);
1847 /* Process STR as if it appeared as the body of an #unassert. */
1849 cpp_unassert (pfile, str)
1853 handle_assertion (pfile, str, T_UNASSERT);
1856 /* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
1858 handle_assertion (pfile, str, type)
1863 size_t count = strlen (str);
1864 const char *p = strchr (str, '=');
1868 /* Copy the entire option so we can modify it. Change the first
1869 "=" in the string to a '(', and tack a ')' on the end. */
1870 char *buf = (char *) alloca (count + 2);
1872 memcpy (buf, str, count);
1879 run_directive (pfile, type, str, count);
1882 /* The number of errors for a given reader. */
1887 return pfile->errors;
1890 /* The options structure. */
1892 cpp_get_options (pfile)
1895 return &pfile->opts;
1898 /* The callbacks structure. */
1900 cpp_get_callbacks (pfile)
1906 /* The line map set. */
1907 const struct line_maps *
1908 cpp_get_line_maps (pfile)
1911 return &pfile->line_maps;
1914 /* Copy the given callbacks structure to our own. */
1916 cpp_set_callbacks (pfile, cb)
1923 /* Push a new buffer on the buffer stack. Returns the new buffer; it
1924 doesn't fail. It does not generate a file change call back; that
1925 is the responsibility of the caller. */
1927 cpp_push_buffer (pfile, buffer, len, from_stage3, return_at_eof)
1929 const uchar *buffer;
1934 cpp_buffer *new = xobnew (&pfile->buffer_ob, cpp_buffer);
1936 /* Clears, amongst other things, if_stack and mi_cmacro. */
1937 memset (new, 0, sizeof (cpp_buffer));
1939 new->line_base = new->buf = new->cur = buffer;
1940 new->rlimit = buffer + len;
1941 new->from_stage3 = from_stage3 || CPP_OPTION (pfile, traditional);
1942 new->prev = pfile->buffer;
1943 new->return_at_eof = return_at_eof;
1944 new->saved_flags = BOL;
1946 pfile->buffer = new;
1951 /* Pops a single buffer, with a file change call-back if appropriate.
1952 Then pushes the next -include file, if any remain. */
1954 _cpp_pop_buffer (pfile)
1957 cpp_buffer *buffer = pfile->buffer;
1958 struct include_file *inc = buffer->inc;
1959 struct if_stack *ifs;
1961 /* Walk back up the conditional stack till we reach its level at
1962 entry to this file, issuing error messages. */
1963 for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
1964 cpp_error_with_line (pfile, DL_ERROR, ifs->line, 0,
1965 "unterminated #%s", dtable[ifs->type].name);
1967 /* In case of a missing #endif. */
1968 pfile->state.skipping = 0;
1970 /* _cpp_do_file_change expects pfile->buffer to be the new one. */
1971 pfile->buffer = buffer->prev;
1973 /* Free the buffer object now; we may want to push a new buffer
1974 in _cpp_push_next_include_file. */
1975 obstack_free (&pfile->buffer_ob, buffer);
1979 _cpp_pop_file_buffer (pfile, inc);
1981 /* Don't generate a callback for popping the main file. */
1984 _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
1986 /* If this is the main file, there may be some -include
1987 files left to push. */
1988 if (!pfile->buffer->prev)
1989 _cpp_maybe_push_include_file (pfile);
1994 /* Enter all recognized directives in the hash table. */
1996 _cpp_init_directives (pfile)
2002 for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
2004 node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
2005 node->directive_index = i + 1;