1 /* Preprocess only, using cpplib.
2 Copyright (C) 1995, 1997, 1998, 1999, 2000, 2001, 2002
3 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 2, 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; if not, write to the Free Software
18 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 In other words, you are welcome to use, share and improve this program.
21 You are forbidden to forbid anyone else to use, share and improve
22 what you give them. Help stamp out software-hoarding! */
29 static void setup_callbacks PARAMS ((cpp_reader *));
31 /* General output routines. */
32 static void scan_translation_unit PARAMS ((cpp_reader *));
33 static void scan_translation_unit_trad PARAMS ((cpp_reader *));
34 static void account_for_newlines PARAMS ((cpp_reader *, const uchar *,
36 static int dump_macro PARAMS ((cpp_reader *, cpp_hashnode *, void *));
38 static void print_line PARAMS ((cpp_reader *, const struct line_map *,
39 unsigned int, const char *));
40 static void maybe_print_line PARAMS ((cpp_reader *, const struct line_map *,
43 /* Callback routines for the parser. Most of these are active only
45 static void cb_line_change PARAMS ((cpp_reader *, const cpp_token *, int));
46 static void cb_define PARAMS ((cpp_reader *, unsigned int, cpp_hashnode *));
47 static void cb_undef PARAMS ((cpp_reader *, unsigned int, cpp_hashnode *));
48 static void cb_include PARAMS ((cpp_reader *, unsigned int,
49 const unsigned char *, const cpp_token *));
50 static void cb_ident PARAMS ((cpp_reader *, unsigned int,
52 static void cb_file_change PARAMS ((cpp_reader *, const struct line_map *));
53 static void cb_def_pragma PARAMS ((cpp_reader *, unsigned int));
55 /* Preprocess and output. */
57 cpp_preprocess_file (pfile, in_fname, out_stream)
62 /* Initialize the printer structure. Setting print.line to -1 here
63 is a trick to guarantee that the first token of the file will
64 cause a linemarker to be output by maybe_print_line. */
65 pfile->print.line = (unsigned int) -1;
66 pfile->print.printed = 0;
67 pfile->print.prev = 0;
69 pfile->print.outf = out_stream;
71 setup_callbacks (pfile);
73 if (cpp_read_main_file (pfile, in_fname, NULL))
75 cpp_options *options = &pfile->opts;
76 cpp_finish_options (pfile);
78 /* A successful cpp_read_main_file guarantees that we can call
79 cpp_scan_nooutput or cpp_get_token next. */
80 if (options->no_output)
82 /* Scan -included buffers, then the main file. */
83 while (pfile->buffer->prev)
84 cpp_scan_nooutput (pfile);
85 cpp_scan_nooutput (pfile);
87 else if (options->traditional)
88 scan_translation_unit_trad (pfile);
90 scan_translation_unit (pfile);
92 /* -dM command line option. Should this be in cpp_finish? */
93 if (options->dump_macros == dump_only)
94 cpp_forall_identifiers (pfile, dump_macro, NULL);
97 /* Flush any pending output. */
98 if (pfile->print.printed)
99 putc ('\n', pfile->print.outf);
102 /* Set up the callbacks as appropriate. */
104 setup_callbacks (pfile)
107 cpp_options *options = &pfile->opts;
108 cpp_callbacks *cb = cpp_get_callbacks (pfile);
110 if (! options->no_output)
112 cb->line_change = cb_line_change;
113 /* Don't emit #pragma or #ident directives if we are processing
114 assembly language; the assembler may choke on them. */
115 if (options->lang != CLK_ASM)
117 cb->ident = cb_ident;
118 cb->def_pragma = cb_def_pragma;
120 if (! options->no_line_commands)
121 cb->file_change = cb_file_change;
124 if (options->dump_includes)
125 cb->include = cb_include;
127 if (options->dump_macros == dump_names
128 || options->dump_macros == dump_definitions)
130 cb->define = cb_define;
131 cb->undef = cb_undef;
135 /* Writes out the preprocessed file, handling spacing and paste
138 scan_translation_unit (pfile)
141 bool avoid_paste = false;
143 pfile->print.source = NULL;
146 const cpp_token *token = cpp_get_token (pfile);
148 if (token->type == CPP_PADDING)
151 if (pfile->print.source == NULL
152 || (!(pfile->print.source->flags & PREV_WHITE)
153 && token->val.source == NULL))
154 pfile->print.source = token->val.source;
158 if (token->type == CPP_EOF)
161 /* Subtle logic to output a space if and only if necessary. */
164 if (pfile->print.source == NULL)
165 pfile->print.source = token;
166 if (pfile->print.source->flags & PREV_WHITE
167 || (pfile->print.prev
168 && cpp_avoid_paste (pfile, pfile->print.prev, token))
169 || (pfile->print.prev == NULL && token->type == CPP_HASH))
170 putc (' ', pfile->print.outf);
172 else if (token->flags & PREV_WHITE)
173 putc (' ', pfile->print.outf);
176 pfile->print.source = NULL;
177 pfile->print.prev = token;
178 cpp_output_token (token, pfile->print.outf);
180 if (token->type == CPP_COMMENT)
181 account_for_newlines (pfile, token->val.str.text, token->val.str.len);
185 /* Adjust pfile->print.line for newlines embedded in output. */
187 account_for_newlines (pfile, str, len)
197 /* Writes out a traditionally preprocessed file. */
199 scan_translation_unit_trad (pfile)
202 while (_cpp_read_logical_line_trad (pfile))
204 size_t len = pfile->out.cur - pfile->out.base;
205 maybe_print_line (pfile, pfile->print.map, pfile->out.first_line);
206 fwrite (pfile->out.base, 1, len, pfile->print.outf);
207 pfile->print.printed = 1;
208 if (!CPP_OPTION (pfile, discard_comments))
209 account_for_newlines (pfile, pfile->out.base, len);
213 /* If the token read on logical line LINE needs to be output on a
214 different line to the current one, output the required newlines or
215 a line marker, and return 1. Otherwise return 0. */
217 maybe_print_line (pfile, map, line)
219 const struct line_map *map;
222 /* End the previous line of text. */
223 if (pfile->print.printed)
225 putc ('\n', pfile->print.outf);
227 pfile->print.printed = 0;
230 if (line >= pfile->print.line && line < pfile->print.line + 8)
232 while (line > pfile->print.line)
234 putc ('\n', pfile->print.outf);
239 print_line (pfile, map, line, "");
242 /* Output a line marker for logical line LINE. Special flags are "1"
243 or "2" indicating entering or leaving a file. */
245 print_line (pfile, map, line, special_flags)
247 const struct line_map *map;
249 const char *special_flags;
251 /* End any previous line of text. */
252 if (pfile->print.printed)
253 putc ('\n', pfile->print.outf);
254 pfile->print.printed = 0;
256 pfile->print.line = line;
257 if (! CPP_OPTION (pfile, no_line_commands))
259 size_t to_file_len = strlen (map->to_file);
260 unsigned char *to_file_quoted = alloca (to_file_len * 4 + 1);
263 /* cpp_quote_string does not nul-terminate, so we have to do it
265 p = cpp_quote_string (to_file_quoted,
266 (unsigned char *)map->to_file, to_file_len);
268 fprintf (pfile->print.outf, "# %u \"%s\"%s",
269 SOURCE_LINE (map, pfile->print.line),
270 to_file_quoted, special_flags);
273 fputs (" 3 4", pfile->print.outf);
274 else if (map->sysp == 1)
275 fputs (" 3", pfile->print.outf);
277 putc ('\n', pfile->print.outf);
281 /* Called when a line of output is started. TOKEN is the first token
282 of the line, and at end of file will be CPP_EOF. */
284 cb_line_change (pfile, token, parsing_args)
286 const cpp_token *token;
289 if (token->type == CPP_EOF || parsing_args)
292 maybe_print_line (pfile, pfile->print.map, token->line);
293 pfile->print.prev = 0;
294 pfile->print.source = 0;
296 /* Supply enough spaces to put this token in its original column,
297 one space per column greater than 2, since scan_translation_unit
298 will provide a space if PREV_WHITE. Don't bother trying to
299 reconstruct tabs; we can't get it right in general, and nothing
300 ought to care. Some things do care; the fault lies with them. */
301 if (!CPP_OPTION (pfile, traditional))
303 pfile->print.printed = 1;
306 unsigned int spaces = token->col - 2;
309 putc (' ', pfile->print.outf);
315 cb_ident (pfile, line, str)
318 const cpp_string * str;
320 maybe_print_line (pfile, pfile->print.map, line);
321 fprintf (pfile->print.outf, "#ident \"%s\"\n", str->text);
326 cb_define (pfile, line, node)
331 maybe_print_line (pfile, pfile->print.map, line);
332 fputs ("#define ", pfile->print.outf);
334 /* -dD command line option. */
335 if (CPP_OPTION (pfile, dump_macros) == dump_definitions)
336 fputs ((const char *) cpp_macro_definition (pfile, node),
339 fputs ((const char *) NODE_NAME (node), pfile->print.outf);
341 putc ('\n', pfile->print.outf);
346 cb_undef (pfile, line, node)
351 maybe_print_line (pfile, pfile->print.map, line);
352 fprintf (pfile->print.outf, "#undef %s\n", NODE_NAME (node));
357 cb_include (pfile, line, dir, header)
360 const unsigned char *dir;
361 const cpp_token *header;
363 maybe_print_line (pfile, pfile->print.map, line);
364 fprintf (pfile->print.outf, "#%s %s\n", dir,
365 cpp_token_as_text (pfile, header));
369 /* The file name, line number or system header flags have changed, as
370 described in MAP. From this point on, the old pfile->print.map might be
371 pointing to freed memory, and so must not be dereferenced. */
374 cb_file_change (pfile, map)
376 const struct line_map *map;
378 const char *flags = "";
381 if (pfile->print.map == NULL)
383 /* Avoid printing foo.i when the main file is foo.c. */
384 if (!CPP_OPTION (pfile, preprocessed))
385 print_line (pfile, map, map->from_line, flags);
389 /* Bring current file to correct line when entering a new file. */
390 if (map->reason == LC_ENTER)
391 maybe_print_line (pfile, map - 1, map->from_line - 1);
393 if (map->reason == LC_ENTER)
395 else if (map->reason == LC_LEAVE)
397 print_line (pfile, map, map->from_line, flags);
400 pfile->print.map = map;
403 /* Copy a #pragma directive to the preprocessed output. */
405 cb_def_pragma (pfile, line)
409 maybe_print_line (pfile, pfile->print.map, line);
410 fputs ("#pragma ", pfile->print.outf);
411 cpp_output_line (pfile, pfile->print.outf);
415 /* Dump out the hash table. */
417 dump_macro (pfile, node, v)
420 void *v ATTRIBUTE_UNUSED;
422 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
424 fputs ("#define ", pfile->print.outf);
425 fputs ((const char *) cpp_macro_definition (pfile, node),
427 putc ('\n', pfile->print.outf);