1 /* Preprocess only, using cpplib.
2 Copyright (C) 1995, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007,
3 2008, 2009, 2010 Free Software Foundation, Inc.
4 Written by Per Bothner, 1994-95.
6 This program is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 3, or (at your option) any
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
24 #include "../libcpp/internal.h"
26 #include "c-common.h" /* For flags. */
27 #include "c-pragma.h" /* For parse_in. */
29 /* Encapsulates state used to convert a stream of tokens into a text
33 FILE *outf
; /* Stream to write to. */
34 const cpp_token
*prev
; /* Previous token. */
35 const cpp_token
*source
; /* Source token for spacing. */
36 int src_line
; /* Line number currently being written. */
37 unsigned char printed
; /* Nonzero if something output at line. */
38 bool first_time
; /* pp_file_change hasn't been called yet. */
39 const char *src_file
; /* Current source file. */
42 /* Defined and undefined macros being queued for output with -dU at
44 typedef struct macro_queue
46 struct macro_queue
*next
; /* Next macro in the list. */
47 char *macro
; /* The name of the macro if not
48 defined, the full definition if
51 static macro_queue
*define_queue
, *undef_queue
;
53 /* General output routines. */
54 static void scan_translation_unit (cpp_reader
*);
55 static void print_lines_directives_only (int, const void *, size_t);
56 static void scan_translation_unit_directives_only (cpp_reader
*);
57 static void scan_translation_unit_trad (cpp_reader
*);
58 static void account_for_newlines (const unsigned char *, size_t);
59 static int dump_macro (cpp_reader
*, cpp_hashnode
*, void *);
60 static void dump_queued_macros (cpp_reader
*);
62 static void print_line (source_location
, const char *);
63 static void maybe_print_line (source_location
);
64 static void do_line_change (cpp_reader
*, const cpp_token
*,
65 source_location
, int);
67 /* Callback routines for the parser. Most of these are active only
69 static void cb_line_change (cpp_reader
*, const cpp_token
*, int);
70 static void cb_define (cpp_reader
*, source_location
, cpp_hashnode
*);
71 static void cb_undef (cpp_reader
*, source_location
, cpp_hashnode
*);
72 static void cb_used_define (cpp_reader
*, source_location
, cpp_hashnode
*);
73 static void cb_used_undef (cpp_reader
*, source_location
, cpp_hashnode
*);
74 static bool cb_include (cpp_reader
*, source_location
, const unsigned char *,
75 const char *, int, const cpp_token
**);
76 static void cb_ident (cpp_reader
*, source_location
, const cpp_string
*);
77 static void cb_def_pragma (cpp_reader
*, source_location
);
78 static void cb_read_pch (cpp_reader
*pfile
, const char *name
,
79 int fd
, const char *orig_name
);
81 /* Preprocess and output. */
83 preprocess_file (cpp_reader
*pfile
)
85 /* A successful cpp_read_main_file guarantees that we can call
86 cpp_scan_nooutput or cpp_get_token next. */
89 /* Scan -included buffers, then the main file. */
90 while (pfile
->buffer
->prev
)
91 cpp_scan_nooutput (pfile
);
92 cpp_scan_nooutput (pfile
);
94 else if (cpp_get_options (pfile
)->traditional
)
95 scan_translation_unit_trad (pfile
);
96 else if (cpp_get_options (pfile
)->directives_only
97 && !cpp_get_options (pfile
)->preprocessed
)
98 scan_translation_unit_directives_only (pfile
);
100 scan_translation_unit (pfile
);
102 /* -dM command line option. Should this be elsewhere? */
103 if (flag_dump_macros
== 'M')
104 cpp_forall_identifiers (pfile
, dump_macro
, NULL
);
106 /* Flush any pending output. */
108 putc ('\n', print
.outf
);
111 /* Set up the callbacks as appropriate. */
113 init_pp_output (FILE *out_stream
)
115 cpp_callbacks
*cb
= cpp_get_callbacks (parse_in
);
119 cb
->line_change
= cb_line_change
;
120 /* Don't emit #pragma or #ident directives if we are processing
121 assembly language; the assembler may choke on them. */
122 if (cpp_get_options (parse_in
)->lang
!= CLK_ASM
)
124 cb
->ident
= cb_ident
;
125 cb
->def_pragma
= cb_def_pragma
;
129 if (flag_dump_includes
)
130 cb
->include
= cb_include
;
132 if (flag_pch_preprocess
)
134 cb
->valid_pch
= c_common_valid_pch
;
135 cb
->read_pch
= cb_read_pch
;
138 if (flag_dump_macros
== 'N' || flag_dump_macros
== 'D')
140 cb
->define
= cb_define
;
141 cb
->undef
= cb_undef
;
144 if (flag_dump_macros
== 'U')
146 cb
->before_define
= dump_queued_macros
;
147 cb
->used_define
= cb_used_define
;
148 cb
->used_undef
= cb_used_undef
;
151 /* Initialize the print structure. */
155 print
.outf
= out_stream
;
156 print
.first_time
= 1;
160 /* Writes out the preprocessed file, handling spacing and paste
163 scan_translation_unit (cpp_reader
*pfile
)
165 bool avoid_paste
= false;
166 bool do_line_adjustments
167 = cpp_get_options (parse_in
)->lang
!= CLK_ASM
168 && !flag_no_line_commands
;
169 bool in_pragma
= false;
175 const cpp_token
*token
= cpp_get_token_with_location (pfile
, &loc
);
177 if (token
->type
== CPP_PADDING
)
180 if (print
.source
== NULL
181 || (!(print
.source
->flags
& PREV_WHITE
)
182 && token
->val
.source
== NULL
))
183 print
.source
= token
->val
.source
;
187 if (token
->type
== CPP_EOF
)
190 /* Subtle logic to output a space if and only if necessary. */
193 const struct line_map
*map
194 = linemap_lookup (line_table
, loc
);
195 int src_line
= SOURCE_LINE (map
, loc
);
197 if (print
.source
== NULL
)
198 print
.source
= token
;
200 if (src_line
!= print
.src_line
201 && do_line_adjustments
204 do_line_change (pfile
, token
, loc
, false);
205 putc (' ', print
.outf
);
207 else if (print
.source
->flags
& PREV_WHITE
209 && cpp_avoid_paste (pfile
, print
.prev
, token
))
210 || (print
.prev
== NULL
&& token
->type
== CPP_HASH
))
211 putc (' ', print
.outf
);
213 else if (token
->flags
& PREV_WHITE
)
215 const struct line_map
*map
216 = linemap_lookup (line_table
, loc
);
217 int src_line
= SOURCE_LINE (map
, loc
);
219 if (src_line
!= print
.src_line
220 && do_line_adjustments
222 do_line_change (pfile
, token
, loc
, false);
223 putc (' ', print
.outf
);
229 if (token
->type
== CPP_PRAGMA
)
234 maybe_print_line (token
->src_loc
);
235 fputs ("#pragma ", print
.outf
);
236 c_pp_lookup_pragma (token
->val
.pragma
, &space
, &name
);
238 fprintf (print
.outf
, "%s %s", space
, name
);
240 fprintf (print
.outf
, "%s", name
);
244 else if (token
->type
== CPP_PRAGMA_EOL
)
246 maybe_print_line (token
->src_loc
);
250 cpp_output_token (token
, print
.outf
);
252 if (token
->type
== CPP_COMMENT
)
253 account_for_newlines (token
->val
.str
.text
, token
->val
.str
.len
);
258 print_lines_directives_only (int lines
, const void *buf
, size_t size
)
260 print
.src_line
+= lines
;
261 fwrite (buf
, 1, size
, print
.outf
);
264 /* Writes out the preprocessed file, handling spacing and paste
267 scan_translation_unit_directives_only (cpp_reader
*pfile
)
269 struct _cpp_dir_only_callbacks cb
;
271 cb
.print_lines
= print_lines_directives_only
;
272 cb
.maybe_print_line
= maybe_print_line
;
274 _cpp_preprocess_dir_only (pfile
, &cb
);
277 /* Adjust print.src_line for newlines embedded in output. */
279 account_for_newlines (const unsigned char *str
, size_t len
)
286 /* Writes out a traditionally preprocessed file. */
288 scan_translation_unit_trad (cpp_reader
*pfile
)
290 while (_cpp_read_logical_line_trad (pfile
))
292 size_t len
= pfile
->out
.cur
- pfile
->out
.base
;
293 maybe_print_line (pfile
->out
.first_line
);
294 fwrite (pfile
->out
.base
, 1, len
, print
.outf
);
296 if (!CPP_OPTION (pfile
, discard_comments
))
297 account_for_newlines (pfile
->out
.base
, len
);
301 /* If the token read on logical line LINE needs to be output on a
302 different line to the current one, output the required newlines or
303 a line marker, and return 1. Otherwise return 0. */
305 maybe_print_line (source_location src_loc
)
307 const struct line_map
*map
= linemap_lookup (line_table
, src_loc
);
308 int src_line
= SOURCE_LINE (map
, src_loc
);
309 /* End the previous line of text. */
312 putc ('\n', print
.outf
);
317 if (src_line
>= print
.src_line
318 && src_line
< print
.src_line
+ 8
319 && strcmp (map
->to_file
, print
.src_file
) == 0)
321 while (src_line
> print
.src_line
)
323 putc ('\n', print
.outf
);
328 print_line (src_loc
, "");
331 /* Output a line marker for logical line LINE. Special flags are "1"
332 or "2" indicating entering or leaving a file. */
334 print_line (source_location src_loc
, const char *special_flags
)
336 /* End any previous line of text. */
338 putc ('\n', print
.outf
);
341 if (!flag_no_line_commands
)
343 const struct line_map
*map
= linemap_lookup (line_table
, src_loc
);
345 size_t to_file_len
= strlen (map
->to_file
);
346 unsigned char *to_file_quoted
=
347 (unsigned char *) alloca (to_file_len
* 4 + 1);
350 print
.src_line
= SOURCE_LINE (map
, src_loc
);
351 print
.src_file
= map
->to_file
;
353 /* cpp_quote_string does not nul-terminate, so we have to do it
355 p
= cpp_quote_string (to_file_quoted
,
356 (const unsigned char *) map
->to_file
, to_file_len
);
358 fprintf (print
.outf
, "# %u \"%s\"%s",
359 print
.src_line
== 0 ? 1 : print
.src_line
,
360 to_file_quoted
, special_flags
);
363 fputs (" 3 4", print
.outf
);
364 else if (map
->sysp
== 1)
365 fputs (" 3", print
.outf
);
367 putc ('\n', print
.outf
);
371 /* Helper function for cb_line_change and scan_translation_unit. */
373 do_line_change (cpp_reader
*pfile
, const cpp_token
*token
,
374 source_location src_loc
, int parsing_args
)
376 if (define_queue
|| undef_queue
)
377 dump_queued_macros (pfile
);
379 if (token
->type
== CPP_EOF
|| parsing_args
)
382 maybe_print_line (src_loc
);
386 /* Supply enough spaces to put this token in its original column,
387 one space per column greater than 2, since scan_translation_unit
388 will provide a space if PREV_WHITE. Don't bother trying to
389 reconstruct tabs; we can't get it right in general, and nothing
390 ought to care. Some things do care; the fault lies with them. */
391 if (!CPP_OPTION (pfile
, traditional
))
393 const struct line_map
*map
= linemap_lookup (line_table
, src_loc
);
394 int spaces
= SOURCE_COLUMN (map
, src_loc
) - 2;
397 while (-- spaces
>= 0)
398 putc (' ', print
.outf
);
402 /* Called when a line of output is started. TOKEN is the first token
403 of the line, and at end of file will be CPP_EOF. */
405 cb_line_change (cpp_reader
*pfile
, const cpp_token
*token
,
408 do_line_change (pfile
, token
, token
->src_loc
, parsing_args
);
412 cb_ident (cpp_reader
*pfile ATTRIBUTE_UNUSED
, source_location line
,
413 const cpp_string
*str
)
415 maybe_print_line (line
);
416 fprintf (print
.outf
, "#ident %s\n", str
->text
);
421 cb_define (cpp_reader
*pfile
, source_location line
, cpp_hashnode
*node
)
423 maybe_print_line (line
);
424 fputs ("#define ", print
.outf
);
426 /* 'D' is whole definition; 'N' is name only. */
427 if (flag_dump_macros
== 'D')
428 fputs ((const char *) cpp_macro_definition (pfile
, node
),
431 fputs ((const char *) NODE_NAME (node
), print
.outf
);
433 putc ('\n', print
.outf
);
434 if (linemap_lookup (line_table
, line
)->to_line
!= 0)
439 cb_undef (cpp_reader
*pfile ATTRIBUTE_UNUSED
, source_location line
,
442 maybe_print_line (line
);
443 fprintf (print
.outf
, "#undef %s\n", NODE_NAME (node
));
448 cb_used_define (cpp_reader
*pfile
, source_location line ATTRIBUTE_UNUSED
,
452 if (node
->flags
& NODE_BUILTIN
)
454 q
= XNEW (macro_queue
);
455 q
->macro
= xstrdup ((const char *) cpp_macro_definition (pfile
, node
));
456 q
->next
= define_queue
;
461 cb_used_undef (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
462 source_location line ATTRIBUTE_UNUSED
,
466 q
= XNEW (macro_queue
);
467 q
->macro
= xstrdup ((const char *) NODE_NAME (node
));
468 q
->next
= undef_queue
;
473 dump_queued_macros (cpp_reader
*pfile ATTRIBUTE_UNUSED
)
477 /* End the previous line of text. */
480 putc ('\n', print
.outf
);
485 for (q
= define_queue
; q
;)
488 fputs ("#define ", print
.outf
);
489 fputs (q
->macro
, print
.outf
);
490 putc ('\n', print
.outf
);
498 for (q
= undef_queue
; q
;)
501 fprintf (print
.outf
, "#undef %s\n", q
->macro
);
512 cb_include (cpp_reader
*pfile ATTRIBUTE_UNUSED
, source_location line
,
513 const unsigned char *dir
, const char *header
, int angle_brackets
,
514 const cpp_token
**comments
)
516 maybe_print_line (line
);
518 fprintf (print
.outf
, "#%s <%s>", dir
, header
);
520 fprintf (print
.outf
, "#%s \"%s\"", dir
, header
);
522 if (comments
!= NULL
)
524 while (*comments
!= NULL
)
526 if ((*comments
)->flags
& PREV_WHITE
)
527 putc (' ', print
.outf
);
528 cpp_output_token (*comments
, print
.outf
);
533 putc ('\n', print
.outf
);
538 /* Callback called when -fworking-director and -E to emit working
539 directory in cpp output file. */
542 pp_dir_change (cpp_reader
*pfile ATTRIBUTE_UNUSED
, const char *dir
)
544 size_t to_file_len
= strlen (dir
);
545 unsigned char *to_file_quoted
=
546 (unsigned char *) alloca (to_file_len
* 4 + 1);
549 /* cpp_quote_string does not nul-terminate, so we have to do it ourselves. */
550 p
= cpp_quote_string (to_file_quoted
, (const unsigned char *) dir
, to_file_len
);
552 fprintf (print
.outf
, "# 1 \"%s//\"\n", to_file_quoted
);
555 /* The file name, line number or system header flags have changed, as
559 pp_file_change (const struct line_map
*map
)
561 const char *flags
= "";
563 if (flag_no_line_commands
)
568 input_location
= map
->start_location
;
569 if (print
.first_time
)
571 /* Avoid printing foo.i when the main file is foo.c. */
572 if (!cpp_get_options (parse_in
)->preprocessed
)
573 print_line (map
->start_location
, flags
);
574 print
.first_time
= 0;
578 /* Bring current file to correct line when entering a new file. */
579 if (map
->reason
== LC_ENTER
)
581 const struct line_map
*from
= INCLUDED_FROM (line_table
, map
);
582 maybe_print_line (LAST_SOURCE_LINE_LOCATION (from
));
584 if (map
->reason
== LC_ENTER
)
586 else if (map
->reason
== LC_LEAVE
)
588 print_line (map
->start_location
, flags
);
593 /* Copy a #pragma directive to the preprocessed output. */
595 cb_def_pragma (cpp_reader
*pfile
, source_location line
)
597 maybe_print_line (line
);
598 fputs ("#pragma ", print
.outf
);
599 cpp_output_line (pfile
, print
.outf
);
603 /* Dump out the hash table. */
605 dump_macro (cpp_reader
*pfile
, cpp_hashnode
*node
, void *v ATTRIBUTE_UNUSED
)
607 if (node
->type
== NT_MACRO
&& !(node
->flags
& NODE_BUILTIN
))
609 fputs ("#define ", print
.outf
);
610 fputs ((const char *) cpp_macro_definition (pfile
, node
),
612 putc ('\n', print
.outf
);
619 /* Load in the PCH file NAME, open on FD. It was originally searched for
620 by ORIG_NAME. Also, print out a #include command so that the PCH
621 file can be loaded when the preprocessed output is compiled. */
624 cb_read_pch (cpp_reader
*pfile
, const char *name
,
625 int fd
, const char *orig_name ATTRIBUTE_UNUSED
)
627 c_common_read_pch (pfile
, name
, fd
, orig_name
);
629 fprintf (print
.outf
, "#pragma GCC pch_preprocess \"%s\"\n", name
);