1 /* Preprocess only, using cpplib.
2 Copyright (C) 1995-2024 Free Software Foundation, Inc.
3 Written by Per Bothner, 1994-95.
5 This program is free software; you can redistribute it and/or modify it
6 under the terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 3, or (at your option) any
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; see the file COPYING3. If not see
17 <http://www.gnu.org/licenses/>. */
21 #include "coretypes.h"
22 #include "c-common.h" /* For flags. */
23 #include "../libcpp/internal.h"
24 #include "langhooks.h"
25 #include "c-pragma.h" /* For parse_in. */
26 #include "file-prefix-map.h" /* remap_macro_filename() */
30 /* Encapsulates state used to convert a stream of tokens into a text
34 FILE *outf
; /* Stream to write to. */
35 const cpp_token
*prev
; /* Previous token. */
36 const cpp_token
*source
; /* Source token for spacing. */
37 unsigned src_line
; /* Line number currently being written. */
38 bool printed
; /* True if something output at line. */
39 bool first_time
; /* pp_file_change hasn't been called yet. */
40 bool prev_was_system_token
; /* True if the previous token was a
42 const char *src_file
; /* Current source file. */
43 token_streamer
*streamer
; /* Instance of class token_streamer using this
47 /* Defined and undefined macros being queued for output with -dU at
51 struct macro_queue
*next
; /* Next macro in the list. */
52 char *macro
; /* The name of the macro if not
53 defined, the full definition if
56 static macro_queue
*define_queue
, *undef_queue
;
58 /* General output routines. */
59 static void scan_translation_unit (cpp_reader
*);
60 static void scan_translation_unit_directives_only (cpp_reader
*);
61 static void scan_translation_unit_trad (cpp_reader
*);
62 static void account_for_newlines (const unsigned char *, size_t);
63 static int dump_macro (cpp_reader
*, cpp_hashnode
*, void *);
64 static void dump_queued_macros (cpp_reader
*);
66 static bool print_line_1 (location_t
, const char*, FILE *);
67 static bool print_line (location_t
, const char *);
68 static bool maybe_print_line_1 (location_t
, FILE *);
69 static bool maybe_print_line (location_t
);
70 static bool do_line_change (cpp_reader
*, const cpp_token
*,
73 /* Callback routines for the parser. Most of these are active only
75 static void cb_line_change (cpp_reader
*, const cpp_token
*, int);
76 static void cb_define (cpp_reader
*, location_t
, cpp_hashnode
*);
77 static void cb_undef (cpp_reader
*, location_t
, cpp_hashnode
*);
78 static void cb_used_define (cpp_reader
*, location_t
, cpp_hashnode
*);
79 static void cb_used_undef (cpp_reader
*, location_t
, cpp_hashnode
*);
80 static void cb_include (cpp_reader
*, location_t
, const unsigned char *,
81 const char *, int, const cpp_token
**);
82 static void cb_ident (cpp_reader
*, location_t
, const cpp_string
*);
83 static void cb_def_pragma (cpp_reader
*, location_t
);
84 static void cb_read_pch (cpp_reader
*pfile
, const char *name
,
85 int fd
, const char *orig_name
);
87 /* Preprocess and output. */
89 preprocess_file (cpp_reader
*pfile
)
91 /* A successful cpp_read_main_file guarantees that we can call
92 cpp_scan_nooutput or cpp_get_token next. */
93 if (flag_no_output
&& pfile
->buffer
)
95 /* Scan -included buffers, then the main file. */
96 while (pfile
->buffer
->prev
)
97 cpp_scan_nooutput (pfile
);
98 cpp_scan_nooutput (pfile
);
100 else if (cpp_get_options (pfile
)->traditional
)
101 scan_translation_unit_trad (pfile
);
102 else if (cpp_get_options (pfile
)->directives_only
103 && !cpp_get_options (pfile
)->preprocessed
)
104 scan_translation_unit_directives_only (pfile
);
106 scan_translation_unit (pfile
);
108 /* -dM command line option. Should this be elsewhere? */
109 if (flag_dump_macros
== 'M')
110 cpp_forall_identifiers (pfile
, dump_macro
, NULL
);
112 /* Flush any pending output. */
114 putc ('\n', print
.outf
);
117 /* Don't emit #pragma or #ident directives if we are processing
118 assembly language; the assembler may choke on them. */
120 should_output_pragmas ()
122 return cpp_get_options (parse_in
)->lang
!= CLK_ASM
;
125 /* Set up the callbacks as appropriate. */
127 init_pp_output (FILE *out_stream
)
129 cpp_callbacks
*cb
= cpp_get_callbacks (parse_in
);
133 cb
->line_change
= cb_line_change
;
134 if (should_output_pragmas ())
136 cb
->ident
= cb_ident
;
137 cb
->def_pragma
= cb_def_pragma
;
141 if (flag_dump_includes
)
142 cb
->include
= cb_include
;
144 if (flag_pch_preprocess
)
146 cb
->valid_pch
= c_common_valid_pch
;
147 cb
->read_pch
= cb_read_pch
;
150 if (flag_dump_macros
== 'N' || flag_dump_macros
== 'D')
152 cb
->define
= cb_define
;
153 cb
->undef
= cb_undef
;
156 if (flag_dump_macros
== 'U')
158 cb
->before_define
= dump_queued_macros
;
159 cb
->used_define
= cb_used_define
;
160 cb
->used_undef
= cb_used_undef
;
163 cb
->has_attribute
= c_common_has_attribute
;
164 cb
->has_builtin
= c_common_has_builtin
;
165 cb
->has_feature
= c_common_has_feature
;
166 cb
->get_source_date_epoch
= cb_get_source_date_epoch
;
167 cb
->remap_filename
= remap_macro_filename
;
169 /* Initialize the print structure. */
171 print
.printed
= false;
173 print
.outf
= out_stream
;
174 print
.first_time
= 1;
176 print
.prev_was_system_token
= false;
177 print
.streamer
= nullptr;
180 // FIXME: Ideally we'd just turn the entirety of the print struct into
181 // an encapsulated streamer ...
186 bool do_line_adjustments
;
190 token_streamer (cpp_reader
*pfile
)
191 :avoid_paste (false),
192 do_line_adjustments (cpp_get_options (pfile
)->lang
!= CLK_ASM
193 && !flag_no_line_commands
),
196 gcc_assert (!print
.streamer
);
197 print
.streamer
= this;
205 void stream (cpp_reader
*pfile
, const cpp_token
*tok
, location_t
);
209 token_streamer::stream (cpp_reader
*pfile
, const cpp_token
*token
,
212 /* Keep input_location up to date, since it is needed for processing early
213 pragmas such as #pragma GCC diagnostic. */
214 input_location
= loc
;
216 if (token
->type
== CPP_PADDING
)
219 if (print
.source
== NULL
220 || (!(print
.source
->flags
& PREV_WHITE
)
221 && token
->val
.source
== NULL
))
222 print
.source
= token
->val
.source
;
226 if (token
->type
== CPP_EOF
)
229 /* Keep track when we move into and out of system locations. */
230 const bool is_system_token
= in_system_header_at (loc
);
231 const bool system_state_changed
232 = (is_system_token
!= print
.prev_was_system_token
);
233 print
.prev_was_system_token
= is_system_token
;
235 /* Subtle logic to output a space if and only if necessary. */
236 bool line_marker_emitted
= false;
239 unsigned src_line
= LOCATION_LINE (loc
);
241 if (print
.source
== NULL
)
242 print
.source
= token
;
244 if (src_line
!= print
.src_line
245 && do_line_adjustments
248 line_marker_emitted
= do_line_change (pfile
, token
, loc
, false);
249 putc (' ', print
.outf
);
250 print
.printed
= true;
252 else if (print
.source
->flags
& PREV_WHITE
254 && cpp_avoid_paste (pfile
, print
.prev
, token
))
255 || (print
.prev
== NULL
&& token
->type
== CPP_HASH
))
257 putc (' ', print
.outf
);
258 print
.printed
= true;
261 else if (token
->flags
& PREV_WHITE
&& token
->type
!= CPP_PRAGMA
)
263 unsigned src_line
= LOCATION_LINE (loc
);
265 if (src_line
!= print
.src_line
266 && do_line_adjustments
268 line_marker_emitted
= do_line_change (pfile
, token
, loc
, false);
269 putc (' ', print
.outf
);
270 print
.printed
= true;
276 if (token
->type
== CPP_PRAGMA
)
279 if (should_output_pragmas ())
284 line_marker_emitted
= maybe_print_line (token
->src_loc
);
285 fputs ("#pragma ", print
.outf
);
286 c_pp_lookup_pragma (token
->val
.pragma
, &space
, &name
);
288 fprintf (print
.outf
, "%s %s", space
, name
);
290 fprintf (print
.outf
, "%s", name
);
291 print
.printed
= true;
293 if (token
->val
.pragma
>= PRAGMA_FIRST_EXTERNAL
)
294 c_pp_invoke_early_pragma_handler (token
->val
.pragma
);
296 else if (token
->type
== CPP_PRAGMA_EOL
)
298 if (should_output_pragmas ())
299 maybe_print_line (UNKNOWN_LOCATION
);
304 if (cpp_get_options (parse_in
)->debug
)
305 linemap_dump_location (line_table
, token
->src_loc
, print
.outf
);
307 if (do_line_adjustments
309 && !line_marker_emitted
310 && system_state_changed
311 && !is_location_from_builtin_token (loc
))
312 /* The system-ness of this token is different from the one of
313 the previous token. Let's emit a line change to mark the
314 new system-ness before we emit the token. */
316 line_marker_emitted
= do_line_change (pfile
, token
, loc
, false);
318 if (!in_pragma
|| should_output_pragmas ())
320 cpp_output_token (token
, print
.outf
);
321 print
.printed
= true;
325 /* CPP_COMMENT tokens and raw-string literal tokens can have
326 embedded new-line characters. Rather than enumerating all the
327 possible token types just check if token uses val.str union
329 if (cpp_token_val_index (token
) == CPP_TOKEN_FLD_STR
)
330 account_for_newlines (token
->val
.str
.text
, token
->val
.str
.len
);
333 /* Writes out the preprocessed file, handling spacing and paste
337 scan_translation_unit (cpp_reader
*pfile
)
339 token_streamer
streamer (pfile
);
340 uintptr_t filter
= 0;
342 if (lang_hooks
.preprocess_token
)
343 filter
= lang_hooks
.preprocess_token (pfile
, NULL
, filter
);
348 location_t spelling_loc
;
349 const cpp_token
*token
350 = cpp_get_token_with_location (pfile
, &spelling_loc
);
352 streamer
.stream (pfile
, token
, spelling_loc
);
355 unsigned flags
= lang_hooks
.preprocess_token (pfile
, token
, filter
);
356 if (flags
& lang_hooks::PT_begin_pragma
)
357 streamer
.begin_pragma ();
359 if (token
->type
== CPP_EOF
)
364 lang_hooks
.preprocess_token (pfile
, NULL
, filter
);
367 class do_streamer
: public token_streamer
372 do_streamer (cpp_reader
*pfile
, uintptr_t filter
)
373 :token_streamer (pfile
), filter (filter
)
379 directives_only_cb (cpp_reader
*pfile
, CPP_DO_task task
, void *data_
, ...)
382 va_start (args
, data_
);
384 do_streamer
*streamer
= reinterpret_cast <do_streamer
*> (data_
);
392 print
.src_line
+= va_arg (args
, unsigned);
394 const void *buf
= va_arg (args
, const void *);
395 size_t size
= va_arg (args
, size_t);
396 fwrite (buf
, 1, size
, print
.outf
);
400 case CPP_DO_location
:
401 maybe_print_line (va_arg (args
, location_t
));
406 const cpp_token
*token
= va_arg (args
, const cpp_token
*);
407 location_t spelling_loc
= va_arg (args
, location_t
);
408 streamer
->stream (pfile
, token
, spelling_loc
);
409 if (streamer
->filter
)
411 unsigned flags
= lang_hooks
.preprocess_token
412 (pfile
, token
, streamer
->filter
);
413 if (flags
& lang_hooks::PT_begin_pragma
)
414 streamer
->begin_pragma ();
423 /* Writes out the preprocessed file, handling spacing and paste
426 scan_translation_unit_directives_only (cpp_reader
*pfile
)
428 uintptr_t filter
= 0;
429 if (lang_hooks
.preprocess_token
)
430 filter
= lang_hooks
.preprocess_token (pfile
, NULL
, filter
);
431 do_streamer
streamer (pfile
, filter
);
432 cpp_directive_only_process (pfile
, &streamer
, directives_only_cb
);
434 lang_hooks
.preprocess_token (pfile
, NULL
, streamer
.filter
);
437 /* Adjust print.src_line for newlines embedded in output. For example, if a raw
438 string literal contains newlines, then we need to increment our notion of the
439 current line to keep in sync and avoid outputting a line marker
440 unnecessarily. If a raw string literal containing newlines is the result of
441 macro expansion, then we have the opposite problem, where the token takes up
442 more lines in the output than it did in the input, and hence a line marker is
443 needed to restore the correct state for subsequent lines. In this case,
444 incrementing print.src_line still does the job, because it will cause us to
445 emit the line marker the next time a token is streamed. */
447 account_for_newlines (const unsigned char *str
, size_t len
)
454 /* Writes out a traditionally preprocessed file. */
456 scan_translation_unit_trad (cpp_reader
*pfile
)
458 while (_cpp_read_logical_line_trad (pfile
))
460 size_t len
= pfile
->out
.cur
- pfile
->out
.base
;
461 maybe_print_line (pfile
->out
.first_line
);
462 fwrite (pfile
->out
.base
, 1, len
, print
.outf
);
463 print
.printed
= true;
464 if (!CPP_OPTION (pfile
, discard_comments
))
465 account_for_newlines (pfile
->out
.base
, len
);
469 /* If the token read on logical line LINE needs to be output on a
470 different line to the current one, output the required newlines or
471 a line marker. If a line marker was emitted, return TRUE otherwise
475 maybe_print_line_1 (location_t src_loc
, FILE *stream
)
477 bool emitted_line_marker
= false;
478 unsigned src_line
= LOCATION_LINE (src_loc
);
479 const char *src_file
= LOCATION_FILE (src_loc
);
481 /* End the previous line of text. */
486 print
.printed
= false;
489 if (!flag_no_line_commands
490 && src_line
>= print
.src_line
491 && src_line
< print
.src_line
+ 8
492 && src_loc
!= UNKNOWN_LOCATION
493 && strcmp (src_file
, print
.src_file
) == 0)
495 while (src_line
> print
.src_line
)
502 emitted_line_marker
= print_line_1 (src_loc
, "", stream
);
504 return emitted_line_marker
;
507 /* If the token read on logical line LINE needs to be output on a
508 different line to the current one, output the required newlines or
509 a line marker. If a line marker was emitted, return TRUE otherwise
513 maybe_print_line (location_t src_loc
)
515 if (cpp_get_options (parse_in
)->debug
)
516 linemap_dump_location (line_table
, src_loc
,
518 return maybe_print_line_1 (src_loc
, print
.outf
);
521 /* Output a line marker for logical line LINE. Special flags are "1"
522 or "2" indicating entering or leaving a file. If the line marker
523 was effectively emitted, return TRUE otherwise return FALSE. */
526 print_line_1 (location_t src_loc
, const char *special_flags
, FILE *stream
)
528 bool emitted_line_marker
= false;
530 /* End any previous line of text. */
533 print
.printed
= false;
535 if (src_loc
!= UNKNOWN_LOCATION
&& !flag_no_line_commands
)
537 const char *file_path
= LOCATION_FILE (src_loc
);
538 size_t to_file_len
= strlen (file_path
);
539 unsigned char *to_file_quoted
=
540 (unsigned char *) alloca (to_file_len
* 4 + 1);
542 /* cpp_quote_string does not nul-terminate, so we have to do it
544 unsigned char *p
= cpp_quote_string (to_file_quoted
,
545 (const unsigned char *) file_path
,
549 print
.src_line
= LOCATION_LINE (src_loc
);
550 print
.src_file
= file_path
;
552 fprintf (stream
, "# %u \"%s\"%s",
553 print
.src_line
, to_file_quoted
, special_flags
);
555 int sysp
= in_system_header_at (src_loc
);
557 fputs (" 3 4", stream
);
559 fputs (" 3", stream
);
562 emitted_line_marker
= true;
565 return emitted_line_marker
;
568 /* Output a line marker for logical line LINE. Special flags are "1"
569 or "2" indicating entering or leaving a file. Return TRUE if a
570 line marker was effectively emitted, FALSE otherwise. */
573 print_line (location_t src_loc
, const char *special_flags
)
575 if (cpp_get_options (parse_in
)->debug
)
576 linemap_dump_location (line_table
, src_loc
,
578 return print_line_1 (src_loc
, special_flags
, print
.outf
);
581 /* Helper function for cb_line_change and scan_translation_unit.
582 Return TRUE if a line marker is emitted, FALSE otherwise. */
584 do_line_change (cpp_reader
*pfile
, const cpp_token
*token
,
585 location_t src_loc
, int parsing_args
)
587 bool emitted_line_marker
= false;
588 if (define_queue
|| undef_queue
)
589 dump_queued_macros (pfile
);
591 if (token
->type
== CPP_EOF
|| parsing_args
)
594 emitted_line_marker
= maybe_print_line (src_loc
);
598 /* Supply enough spaces to put this token in its original column,
599 one space per column greater than 2, since scan_translation_unit
600 will provide a space if PREV_WHITE. Don't bother trying to
601 reconstruct tabs; we can't get it right in general, and nothing
602 ought to care. Some things do care; the fault lies with them.
604 Also do not output the spaces if this is a CPP_PRAGMA token. In this
605 case, libcpp has provided the location of the first token after #pragma,
606 so we would start at the wrong column. */
607 if (!CPP_OPTION (pfile
, traditional
) && token
->type
!= CPP_PRAGMA
)
609 int spaces
= LOCATION_COLUMN (src_loc
) - 2;
610 print
.printed
= true;
612 while (-- spaces
>= 0)
613 putc (' ', print
.outf
);
616 return emitted_line_marker
;
619 /* Called when a line of output is started. TOKEN is the first token
620 of the line, and at end of file will be CPP_EOF. */
622 cb_line_change (cpp_reader
*pfile
, const cpp_token
*token
,
625 do_line_change (pfile
, token
, token
->src_loc
, parsing_args
);
629 cb_ident (cpp_reader
*pfile ATTRIBUTE_UNUSED
, location_t line
,
630 const cpp_string
*str
)
632 maybe_print_line (line
);
633 fprintf (print
.outf
, "#ident %s\n", str
->text
);
638 cb_define (cpp_reader
*pfile
, location_t line
, cpp_hashnode
*node
)
640 const line_map_ordinary
*map
;
642 maybe_print_line (line
);
643 fputs ("#define ", print
.outf
);
645 /* 'D' is whole definition; 'N' is name only. */
646 if (flag_dump_macros
== 'D')
647 fputs ((const char *) cpp_macro_definition (pfile
, node
),
650 fputs ((const char *) NODE_NAME (node
), print
.outf
);
652 putc ('\n', print
.outf
);
653 print
.printed
= false;
654 linemap_resolve_location (line_table
, line
,
655 LRK_MACRO_DEFINITION_LOCATION
,
661 cb_undef (cpp_reader
*pfile
, location_t line
, cpp_hashnode
*node
)
663 if (lang_hooks
.preprocess_undef
)
664 lang_hooks
.preprocess_undef (pfile
, line
, node
);
665 maybe_print_line (line
);
666 fprintf (print
.outf
, "#undef %s\n", NODE_NAME (node
));
671 cb_used_define (cpp_reader
*pfile
, location_t line ATTRIBUTE_UNUSED
,
674 if (cpp_user_macro_p (node
))
677 q
= XNEW (macro_queue
);
678 q
->macro
= xstrdup ((const char *) cpp_macro_definition (pfile
, node
));
679 q
->next
= define_queue
;
685 cb_used_undef (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
686 location_t line ATTRIBUTE_UNUSED
,
690 q
= XNEW (macro_queue
);
691 q
->macro
= xstrdup ((const char *) NODE_NAME (node
));
692 q
->next
= undef_queue
;
697 dump_queued_macros (cpp_reader
*pfile ATTRIBUTE_UNUSED
)
701 /* End the previous line of text. */
704 putc ('\n', print
.outf
);
706 print
.printed
= false;
709 for (q
= define_queue
; q
;)
712 fputs ("#define ", print
.outf
);
713 fputs (q
->macro
, print
.outf
);
714 putc ('\n', print
.outf
);
715 print
.printed
= false;
723 for (q
= undef_queue
; q
;)
726 fprintf (print
.outf
, "#undef %s\n", q
->macro
);
737 cb_include (cpp_reader
*pfile ATTRIBUTE_UNUSED
, location_t line
,
738 const unsigned char *dir
, const char *header
, int angle_brackets
,
739 const cpp_token
**comments
)
741 maybe_print_line (line
);
743 fprintf (print
.outf
, "#%s <%s>", dir
, header
);
745 fprintf (print
.outf
, "#%s \"%s\"", dir
, header
);
747 if (comments
!= NULL
)
749 while (*comments
!= NULL
)
751 if ((*comments
)->flags
& PREV_WHITE
)
752 putc (' ', print
.outf
);
753 cpp_output_token (*comments
, print
.outf
);
758 putc ('\n', print
.outf
);
759 print
.printed
= false;
763 /* Callback called when -fworking-director and -E to emit working
764 directory in cpp output file. */
767 pp_dir_change (cpp_reader
*pfile ATTRIBUTE_UNUSED
, const char *dir
)
769 size_t to_file_len
= strlen (dir
);
770 unsigned char *to_file_quoted
=
771 (unsigned char *) alloca (to_file_len
* 4 + 1);
774 /* cpp_quote_string does not nul-terminate, so we have to do it ourselves. */
775 p
= cpp_quote_string (to_file_quoted
, (const unsigned char *) dir
, to_file_len
);
777 fprintf (print
.outf
, "# 1 \"%s//\"\n", to_file_quoted
);
780 /* The file name, line number or system header flags have changed, as
784 pp_file_change (const line_map_ordinary
*map
)
786 const char *flags
= "";
788 if (flag_no_line_commands
)
793 input_location
= map
->start_location
;
794 if (print
.first_time
)
796 /* Avoid printing foo.i when the main file is foo.c. */
797 if (!cpp_get_options (parse_in
)->preprocessed
)
798 print_line (map
->start_location
, flags
);
799 print
.first_time
= 0;
803 /* Bring current file to correct line when entering a new file. */
804 if (map
->reason
== LC_ENTER
)
806 maybe_print_line (linemap_included_from (map
));
809 else if (map
->reason
== LC_LEAVE
)
811 print_line (map
->start_location
, flags
);
816 /* Copy a #pragma directive to the preprocessed output. */
818 cb_def_pragma (cpp_reader
*pfile
, location_t line
)
820 maybe_print_line (line
);
821 fputs ("#pragma ", print
.outf
);
822 cpp_output_line (pfile
, print
.outf
);
823 print
.printed
= false;
827 /* Stream a token as if we had seen it directly ourselves; needed
828 in case a token was lexed externally, e.g. while processing a
831 c_pp_stream_token (cpp_reader
*pfile
, const cpp_token
*tok
, location_t loc
)
833 gcc_assert (print
.streamer
);
834 print
.streamer
->stream (pfile
, tok
, loc
);
837 /* Dump out the hash table. */
839 dump_macro (cpp_reader
*pfile
, cpp_hashnode
*node
, void *v ATTRIBUTE_UNUSED
)
841 if (cpp_user_macro_p (node
))
843 fputs ("#define ", print
.outf
);
844 fputs ((const char *) cpp_macro_definition (pfile
, node
),
846 putc ('\n', print
.outf
);
847 print
.printed
= false;
854 /* Load in the PCH file NAME, open on FD. It was originally searched for
855 by ORIG_NAME. Also, print out a #include command so that the PCH
856 file can be loaded when the preprocessed output is compiled. */
859 cb_read_pch (cpp_reader
*pfile
, const char *name
,
860 int fd
, const char *orig_name ATTRIBUTE_UNUSED
)
862 c_common_read_pch (pfile
, name
, fd
, orig_name
);
864 fprintf (print
.outf
, "#pragma GCC pch_preprocess \"%s\"\n", name
);
867 /* The process of reading the PCH has destroyed the frontend parser,
868 so ask the frontend to reinitialize it, in case we need it to
869 process any #pragma directives encountered while preprocessing. */
870 c_init_preprocess ();