* cfgloop.c (flow_loop_entry_edges_find): Fix typo.
[official-gcc.git] / gcc / cppmain.c
blob237f901932d3545a482fd41828abcf0bd56bc3d1
1 /* CPP main program, using CPP Library.
2 Copyright (C) 1995, 1997, 1998, 1999, 2000, 2001
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
9 later version.
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! */
24 #include "config.h"
25 #include "system.h"
26 #include "cpplib.h"
27 #include "intl.h"
29 /* Encapsulates state used to convert the stream of tokens coming from
30 cpp_get_token back into a text file. */
31 struct printer
33 FILE *outf; /* Stream to write to. */
34 const struct line_map *map; /* Logical to physical line mappings. */
35 const cpp_token *prev; /* Previous token. */
36 const cpp_token *source; /* Source token for spacing. */
37 unsigned int line; /* Line currently being written. */
38 unsigned char printed; /* Nonzero if something output at line. */
41 int main PARAMS ((int, char **));
42 static void general_init PARAMS ((const char *));
43 static void do_preprocessing PARAMS ((int, char **));
44 static void setup_callbacks PARAMS ((void));
46 /* General output routines. */
47 static void scan_translation_unit PARAMS ((cpp_reader *));
48 static void check_multiline_token PARAMS ((const cpp_string *));
49 static int dump_macro PARAMS ((cpp_reader *, cpp_hashnode *, void *));
51 static void print_line PARAMS ((const struct line_map *, unsigned int,
52 const char *));
53 static void maybe_print_line PARAMS ((const struct line_map *, unsigned int));
55 /* Callback routines for the parser. Most of these are active only
56 in specific modes. */
57 static void cb_line_change PARAMS ((cpp_reader *, const cpp_token *, int));
58 static void cb_define PARAMS ((cpp_reader *, unsigned int, cpp_hashnode *));
59 static void cb_undef PARAMS ((cpp_reader *, unsigned int, cpp_hashnode *));
60 static void cb_include PARAMS ((cpp_reader *, unsigned int,
61 const unsigned char *, const cpp_token *));
62 static void cb_ident PARAMS ((cpp_reader *, unsigned int,
63 const cpp_string *));
64 static void cb_file_change PARAMS ((cpp_reader *, const struct line_map *));
65 static void cb_def_pragma PARAMS ((cpp_reader *, unsigned int));
67 const char *progname; /* Needs to be global. */
68 static cpp_reader *pfile; /* An opaque handle. */
69 static cpp_options *options; /* Options of pfile. */
70 static struct printer print;
72 int
73 main (argc, argv)
74 int argc;
75 char **argv;
77 general_init (argv[0]);
79 /* Construct a reader with default language GNU C89. */
80 pfile = cpp_create_reader (CLK_GNUC89);
81 options = cpp_get_options (pfile);
83 do_preprocessing (argc, argv);
85 if (cpp_destroy (pfile))
86 return FATAL_EXIT_CODE;
88 return SUCCESS_EXIT_CODE;
91 /* Store the program name, and set the locale. */
92 static void
93 general_init (argv0)
94 const char *argv0;
96 progname = argv0 + strlen (argv0);
98 while (progname != argv0 && ! IS_DIR_SEPARATOR (progname[-1]))
99 --progname;
101 xmalloc_set_program_name (progname);
103 hex_init ();
104 gcc_init_libintl ();
107 /* Handle switches, preprocess and output. */
108 static void
109 do_preprocessing (argc, argv)
110 int argc;
111 char **argv;
113 int argi = 1; /* Next argument to handle. */
115 argi += cpp_handle_options (pfile, argc - argi , argv + argi);
116 if (CPP_FATAL_ERRORS (pfile))
117 return;
119 if (argi < argc)
121 cpp_fatal (pfile, "invalid option %s", argv[argi]);
122 return;
125 cpp_post_options (pfile);
126 if (CPP_FATAL_ERRORS (pfile))
127 return;
129 /* If cpp_handle_options saw --help or --version on the command
130 line, it will have set pfile->help_only to indicate this. Exit
131 successfully. [The library does not exit itself, because
132 e.g. cc1 needs to print its own --help message at this point.] */
133 if (options->help_only)
134 return;
136 /* Initialize the printer structure. Setting print.line to -1 here
137 is a trick to guarantee that the first token of the file will
138 cause a linemarker to be output by maybe_print_line. */
139 print.line = (unsigned int) -1;
140 print.printed = 0;
141 print.prev = 0;
142 print.map = 0;
144 /* Open the output now. We must do so even if no_output is on,
145 because there may be other output than from the actual
146 preprocessing (e.g. from -dM). */
147 if (options->out_fname[0] == '\0')
148 print.outf = stdout;
149 else
151 print.outf = fopen (options->out_fname, "w");
152 if (print.outf == NULL)
154 cpp_notice_from_errno (pfile, options->out_fname);
155 return;
159 setup_callbacks ();
161 if (cpp_read_main_file (pfile, options->in_fname, NULL))
163 cpp_finish_options (pfile);
165 /* A successful cpp_start_read guarantees that we can call
166 cpp_scan_nooutput or cpp_get_token next. */
167 if (options->no_output)
168 cpp_scan_nooutput (pfile);
169 else
170 scan_translation_unit (pfile);
172 /* -dM command line option. Should this be in cpp_finish? */
173 if (options->dump_macros == dump_only)
174 cpp_forall_identifiers (pfile, dump_macro, NULL);
176 cpp_finish (pfile);
179 /* Flush any pending output. */
180 if (print.printed)
181 putc ('\n', print.outf);
183 if (ferror (print.outf) || fclose (print.outf))
184 cpp_notice_from_errno (pfile, options->out_fname);
187 /* Set up the callbacks as appropriate. */
188 static void
189 setup_callbacks ()
191 cpp_callbacks *cb = cpp_get_callbacks (pfile);
193 if (! options->no_output)
195 cb->line_change = cb_line_change;
196 cb->ident = cb_ident;
197 cb->def_pragma = cb_def_pragma;
198 if (! options->no_line_commands)
199 cb->file_change = cb_file_change;
202 if (options->dump_includes)
203 cb->include = cb_include;
205 if (options->dump_macros == dump_names
206 || options->dump_macros == dump_definitions)
208 cb->define = cb_define;
209 cb->undef = cb_undef;
213 /* Writes out the preprocessed file, handling spacing and paste
214 avoidance issues. */
215 static void
216 scan_translation_unit (pfile)
217 cpp_reader *pfile;
219 bool avoid_paste = false;
221 print.source = NULL;
222 for (;;)
224 const cpp_token *token = cpp_get_token (pfile);
226 if (token->type == CPP_PADDING)
228 avoid_paste = true;
229 if (print.source == NULL
230 || (!(print.source->flags & PREV_WHITE)
231 && token->val.source == NULL))
232 print.source = token->val.source;
233 continue;
236 if (token->type == CPP_EOF)
237 break;
239 /* Subtle logic to output a space if and only if necessary. */
240 if (avoid_paste)
242 if (print.source == NULL)
243 print.source = token;
244 if (print.source->flags & PREV_WHITE
245 || (print.prev && cpp_avoid_paste (pfile, print.prev, token))
246 || (print.prev == NULL && token->type == CPP_HASH))
247 putc (' ', print.outf);
249 else if (token->flags & PREV_WHITE)
250 putc (' ', print.outf);
252 avoid_paste = false;
253 print.source = NULL;
254 print.prev = token;
255 cpp_output_token (token, print.outf);
257 if (token->type == CPP_STRING || token->type == CPP_WSTRING
258 || token->type == CPP_COMMENT)
259 check_multiline_token (&token->val.str);
263 /* Adjust print.line for newlines embedded in tokens. */
264 static void
265 check_multiline_token (str)
266 const cpp_string *str;
268 unsigned int i;
270 for (i = 0; i < str->len; i++)
271 if (str->text[i] == '\n')
272 print.line++;
275 /* If the token read on logical line LINE needs to be output on a
276 different line to the current one, output the required newlines or
277 a line marker, and return 1. Otherwise return 0. */
279 static void
280 maybe_print_line (map, line)
281 const struct line_map *map;
282 unsigned int line;
284 /* End the previous line of text. */
285 if (print.printed)
287 putc ('\n', print.outf);
288 print.line++;
289 print.printed = 0;
292 if (line >= print.line && line < print.line + 8)
294 while (line > print.line)
296 putc ('\n', print.outf);
297 print.line++;
300 else
301 print_line (map, line, "");
304 /* Output a line marker for logical line LINE. Special flags are "1"
305 or "2" indicating entering or leaving a file. */
306 static void
307 print_line (map, line, special_flags)
308 const struct line_map *map;
309 unsigned int line;
310 const char *special_flags;
312 /* End any previous line of text. */
313 if (print.printed)
314 putc ('\n', print.outf);
315 print.printed = 0;
317 print.line = line;
318 if (! options->no_line_commands)
320 fprintf (print.outf, "# %u \"%s\"%s",
321 SOURCE_LINE (map, print.line), map->to_file, special_flags);
323 if (map->sysp == 2)
324 fputs (" 3 4", print.outf);
325 else if (map->sysp == 1)
326 fputs (" 3", print.outf);
328 putc ('\n', print.outf);
332 /* Called when a line of output is started. TOKEN is the first token
333 of the line, and may be CPP_EOF. */
335 static void
336 cb_line_change (pfile, token, parsing_args)
337 cpp_reader *pfile ATTRIBUTE_UNUSED;
338 const cpp_token *token;
339 int parsing_args;
341 if (token->type == CPP_EOF || parsing_args)
342 return;
344 maybe_print_line (print.map, token->line);
345 print.printed = 1;
346 print.prev = 0;
347 print.source = 0;
349 /* Supply enough spaces to put this token in its original column,
350 one space per column greater than 2, since scan_translation_unit
351 will provide a space if PREV_WHITE. Don't bother trying to
352 reconstruct tabs; we can't get it right in general, and nothing
353 ought to care. Some things do care; the fault lies with them. */
354 if (token->col > 2)
356 unsigned int spaces = token->col - 2;
358 while (spaces--)
359 putc (' ', print.outf);
363 static void
364 cb_ident (pfile, line, str)
365 cpp_reader *pfile ATTRIBUTE_UNUSED;
366 unsigned int line;
367 const cpp_string * str;
369 maybe_print_line (print.map, line);
370 fprintf (print.outf, "#ident \"%s\"\n", str->text);
371 print.line++;
374 static void
375 cb_define (pfile, line, node)
376 cpp_reader *pfile;
377 unsigned int line;
378 cpp_hashnode *node;
380 maybe_print_line (print.map, line);
381 fputs ("#define ", print.outf);
383 /* -dD command line option. */
384 if (options->dump_macros == dump_definitions)
385 fputs ((const char *) cpp_macro_definition (pfile, node), print.outf);
386 else
387 fputs ((const char *) NODE_NAME (node), print.outf);
389 putc ('\n', print.outf);
390 print.line++;
393 static void
394 cb_undef (pfile, line, node)
395 cpp_reader *pfile ATTRIBUTE_UNUSED;
396 unsigned int line;
397 cpp_hashnode *node;
399 maybe_print_line (print.map, line);
400 fprintf (print.outf, "#undef %s\n", NODE_NAME (node));
401 print.line++;
404 static void
405 cb_include (pfile, line, dir, header)
406 cpp_reader *pfile;
407 unsigned int line;
408 const unsigned char *dir;
409 const cpp_token *header;
411 maybe_print_line (print.map, line);
412 fprintf (print.outf, "#%s %s\n", dir, cpp_token_as_text (pfile, header));
413 print.line++;
416 /* The file name, line number or system header flags have changed, as
417 described in MAP. From this point on, the old print.map might be
418 pointing to freed memory, and so must not be dereferenced. */
420 static void
421 cb_file_change (pfile, map)
422 cpp_reader *pfile ATTRIBUTE_UNUSED;
423 const struct line_map *map;
425 const char *flags = "";
427 /* First time? */
428 if (print.map == NULL)
430 /* Avoid printing foo.i when the main file is foo.c. */
431 if (!options->preprocessed)
432 print_line (map, map->from_line, flags);
434 else
436 /* Bring current file to correct line when entering a new file. */
437 if (map->reason == LC_ENTER)
438 maybe_print_line (map - 1, map->from_line - 1);
440 if (map->reason == LC_ENTER)
441 flags = " 1";
442 else if (map->reason == LC_LEAVE)
443 flags = " 2";
444 print_line (map, map->from_line, flags);
447 print.map = map;
450 /* Copy a #pragma directive to the preprocessed output. */
451 static void
452 cb_def_pragma (pfile, line)
453 cpp_reader *pfile;
454 unsigned int line;
456 maybe_print_line (print.map, line);
457 fputs ("#pragma ", print.outf);
458 cpp_output_line (pfile, print.outf);
459 print.line++;
462 /* Dump out the hash table. */
463 static int
464 dump_macro (pfile, node, v)
465 cpp_reader *pfile;
466 cpp_hashnode *node;
467 void *v ATTRIBUTE_UNUSED;
469 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
471 fputs ("#define ", print.outf);
472 fputs ((const char *) cpp_macro_definition (pfile, node), print.outf);
473 putc ('\n', print.outf);
474 print.line++;
477 return 1;