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
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 /* Encapsulates state used to convert the stream of tokens coming from
30 cpp_get_token back into a text file. */
33 FILE *outf; /* Stream to write to. */
34 const struct line_map *map; /* Logical to physical line mappings. */
35 unsigned int line; /* Line currently being written. */
36 unsigned char printed; /* Nonzero if something output at line. */
39 int main PARAMS ((int, char **));
40 static void general_init PARAMS ((const char *));
41 static void do_preprocessing PARAMS ((int, char **));
42 static void setup_callbacks PARAMS ((void));
44 /* General output routines. */
45 static void scan_translation_unit PARAMS ((cpp_reader *));
46 static void check_multiline_token PARAMS ((cpp_string *));
47 static int dump_macro PARAMS ((cpp_reader *, cpp_hashnode *, void *));
49 static void print_line PARAMS ((const struct line_map *, unsigned int,
51 static void maybe_print_line PARAMS ((const struct line_map *, unsigned int));
53 /* Callback routines for the parser. Most of these are active only
55 static void cb_line_change PARAMS ((cpp_reader *, const cpp_token *, int));
56 static void cb_define PARAMS ((cpp_reader *, unsigned int, cpp_hashnode *));
57 static void cb_undef PARAMS ((cpp_reader *, unsigned int, cpp_hashnode *));
58 static void cb_include PARAMS ((cpp_reader *, unsigned int,
59 const unsigned char *, const cpp_token *));
60 static void cb_ident PARAMS ((cpp_reader *, unsigned int,
62 static void cb_file_change PARAMS ((cpp_reader *, const struct line_map *));
63 static void cb_def_pragma PARAMS ((cpp_reader *, unsigned int));
65 const char *progname; /* Needs to be global. */
66 static cpp_reader *pfile; /* An opaque handle. */
67 static cpp_options *options; /* Options of pfile. */
68 static struct printer print;
75 general_init (argv[0]);
77 /* Contruct a reader with default language GNU C89. */
78 pfile = cpp_create_reader (NULL, CLK_GNUC89);
79 options = cpp_get_options (pfile);
81 do_preprocessing (argc, argv);
83 if (cpp_destroy (pfile))
84 return FATAL_EXIT_CODE;
86 return SUCCESS_EXIT_CODE;
89 /* Store the program name, and set the locale. */
94 progname = argv0 + strlen (argv0);
96 while (progname != argv0 && ! IS_DIR_SEPARATOR (progname[-1]))
99 xmalloc_set_program_name (progname);
101 /* LC_CTYPE determines the character set used by the terminal so it
102 has to be set to output messages correctly. */
104 #ifdef HAVE_LC_MESSAGES
105 setlocale (LC_CTYPE, "");
106 setlocale (LC_MESSAGES, "");
108 setlocale (LC_ALL, "");
111 (void) bindtextdomain (PACKAGE, localedir);
112 (void) textdomain (PACKAGE);
115 /* Handle switches, preprocess and output. */
117 do_preprocessing (argc, argv)
121 int argi = 1; /* Next argument to handle. */
123 argi += cpp_handle_options (pfile, argc - argi , argv + argi);
124 if (CPP_FATAL_ERRORS (pfile))
128 cpp_fatal (pfile, "Invalid option %s", argv[argi]);
130 cpp_post_options (pfile);
132 if (CPP_FATAL_ERRORS (pfile))
135 /* If cpp_handle_options saw --help or --version on the command
136 line, it will have set pfile->help_only to indicate this. Exit
137 successfully. [The library does not exit itself, because
138 e.g. cc1 needs to print its own --help message at this point.] */
139 if (options->help_only)
142 /* Initialize the printer structure. Setting print.line to -1 here
143 is a trick to guarantee that the first token of the file will
144 cause a linemarker to be output by maybe_print_line. */
145 print.line = (unsigned int) -1;
149 /* Open the output now. We must do so even if no_output is on,
150 because there may be other output than from the actual
151 preprocessing (e.g. from -dM). */
152 if (options->out_fname[0] == '\0')
156 print.outf = fopen (options->out_fname, "w");
157 if (print.outf == NULL)
159 cpp_notice_from_errno (pfile, options->out_fname);
166 if (cpp_start_read (pfile, options->in_fname))
168 /* A successful cpp_start_read guarantees that we can call
169 cpp_scan_nooutput or cpp_get_token next. */
170 if (options->no_output)
171 cpp_scan_nooutput (pfile);
173 scan_translation_unit (pfile);
175 /* -dM command line option. Should this be in cpp_finish? */
176 if (options->dump_macros == dump_only)
177 cpp_forall_identifiers (pfile, dump_macro, NULL);
182 /* Flush any pending output. */
184 putc ('\n', print.outf);
186 if (ferror (print.outf) || fclose (print.outf))
187 cpp_notice_from_errno (pfile, options->out_fname);
190 /* Set up the callbacks as appropriate. */
194 cpp_callbacks *cb = cpp_get_callbacks (pfile);
196 if (! options->no_output)
198 cb->line_change = cb_line_change;
199 cb->ident = cb_ident;
200 cb->def_pragma = cb_def_pragma;
201 if (! options->no_line_commands)
202 cb->file_change = cb_file_change;
205 if (options->dump_includes)
206 cb->include = cb_include;
208 if (options->dump_macros == dump_names
209 || options->dump_macros == dump_definitions)
211 cb->define = cb_define;
212 cb->undef = cb_undef;
216 /* Writes out the preprocessed file. Alternates between two tokens,
217 so that we can avoid accidental token pasting. */
219 scan_translation_unit (pfile)
223 cpp_token tokens[2], *token;
225 for (index = 0;; index = 1 - index)
227 token = &tokens[index];
228 cpp_get_token (pfile, token);
230 if (token->type == CPP_EOF)
233 if ((token->flags & (PREV_WHITE | AVOID_LPASTE | BOL)) == AVOID_LPASTE
234 && cpp_avoid_paste (pfile, &tokens[1 - index], token))
235 token->flags |= PREV_WHITE;
236 /* Special case '# <directive name>': insert a space between
237 the # and the token. This will prevent it from being
238 treated as a directive when this code is re-preprocessed.
239 XXX Should do this only at the beginning of a line, but how? */
240 else if (token->type == CPP_NAME && token->val.node->directive_index
241 && tokens[1 - index].type == CPP_HASH)
242 token->flags |= PREV_WHITE;
244 cpp_output_token (token, print.outf);
245 if (token->type == CPP_STRING || token->type == CPP_WSTRING
246 || token->type == CPP_COMMENT)
247 check_multiline_token (&token->val.str);
251 /* Adjust print.line for newlines embedded in tokens. */
253 check_multiline_token (str)
258 for (i = 0; i < str->len; i++)
259 if (str->text[i] == '\n')
263 /* If the token read on logical line LINE needs to be output on a
264 different line to the current one, output the required newlines or
265 a line marker, and return 1. Otherwise return 0. */
268 maybe_print_line (map, line)
269 const struct line_map *map;
272 /* End the previous line of text. */
275 putc ('\n', print.outf);
280 if (line >= print.line && line < print.line + 8)
282 while (line > print.line)
284 putc ('\n', print.outf);
289 print_line (map, line, "");
292 /* Output a line marker for logical line LINE. Special flags are "1"
293 or "2" indicating entering or leaving a file. */
295 print_line (map, line, special_flags)
296 const struct line_map *map;
298 const char *special_flags;
300 /* End any previous line of text. */
302 putc ('\n', print.outf);
306 if (! options->no_line_commands)
308 fprintf (print.outf, "# %u \"%s\"%s",
309 SOURCE_LINE (map, print.line), map->to_file, special_flags);
312 fputs (" 3 4", print.outf);
313 else if (map->sysp == 1)
314 fputs (" 3", print.outf);
316 putc ('\n', print.outf);
320 /* Called when a line of output is started. TOKEN is the first token
321 of the line, and maybe be CPP_EOF. */
324 cb_line_change (pfile, token, parsing_args)
325 cpp_reader *pfile ATTRIBUTE_UNUSED;
326 const cpp_token *token;
329 if (token->type == CPP_EOF || parsing_args)
332 maybe_print_line (print.map, token->line);
335 /* Supply enough spaces to put this token in its original column,
336 one space per column greater than 2, since scan_translation_unit
337 will provide a space if PREV_WHITE. Don't bother trying to
338 reconstruct tabs; we can't get it right in general, and nothing
339 ought to care. Some things do care; the fault lies with them. */
342 unsigned int spaces = token->col - 2;
345 putc (' ', print.outf);
350 cb_ident (pfile, line, str)
351 cpp_reader *pfile ATTRIBUTE_UNUSED;
353 const cpp_string * str;
355 maybe_print_line (print.map, line);
356 fprintf (print.outf, "#ident \"%s\"\n", str->text);
361 cb_define (pfile, line, node)
366 maybe_print_line (print.map, line);
367 fputs ("#define ", print.outf);
369 /* -dD command line option. */
370 if (options->dump_macros == dump_definitions)
371 fputs ((const char *) cpp_macro_definition (pfile, node), print.outf);
373 fputs ((const char *) NODE_NAME (node), print.outf);
375 putc ('\n', print.outf);
380 cb_undef (pfile, line, node)
381 cpp_reader *pfile ATTRIBUTE_UNUSED;
385 maybe_print_line (print.map, line);
386 fprintf (print.outf, "#undef %s\n", NODE_NAME (node));
391 cb_include (pfile, line, dir, header)
394 const unsigned char *dir;
395 const cpp_token *header;
397 maybe_print_line (print.map, line);
398 fprintf (print.outf, "#%s %s\n", dir, cpp_token_as_text (pfile, header));
402 /* The file name, line number or system header flags have changed, as
403 described in MAP. From this point on, the old print.map might be
404 pointing to freed memory, and so must not be dereferenced. */
407 cb_file_change (pfile, map)
408 cpp_reader *pfile ATTRIBUTE_UNUSED;
409 const struct line_map *map;
411 const char *flags = "";
414 if (print.map == NULL)
416 /* Avoid printing foo.i when the main file is foo.c. */
417 if (!options->preprocessed)
418 print_line (map, map->from_line, flags);
422 /* Bring current file to correct line when entering a new file. */
423 if (map->reason == LC_ENTER)
424 maybe_print_line (map - 1, map->from_line - 1);
426 if (map->reason == LC_ENTER)
428 else if (map->reason == LC_LEAVE)
430 print_line (map, map->from_line, flags);
436 /* Copy a #pragma directive to the preprocessed output. */
438 cb_def_pragma (pfile, line)
442 maybe_print_line (print.map, line);
443 fputs ("#pragma ", print.outf);
444 cpp_output_line (pfile, print.outf);
448 /* Dump out the hash table. */
450 dump_macro (pfile, node, v)
453 void *v ATTRIBUTE_UNUSED;
455 if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
457 fputs ("#define ", print.outf);
458 fputs ((const char *) cpp_macro_definition (pfile, node), print.outf);
459 putc ('\n', print.outf);