gcc/cppmain.c

   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.
   5
   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.
  10
  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.
  15
  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.
  19
  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!  */
  23
  24 #include "config.h"
  25 #include "system.h"
  26 #include "cpplib.h"
  27 #include "intl.h"
  28
  29 /* Encapsulates state used to convert the stream of tokens coming from
  30    cpp_get_token back into a text file.  */
  31 struct printer
  32 {
  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.  */
  39 };
  40
  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));
  45
  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 *));
  50
  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));
  54
  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));
  66
  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;
  71
  72 int
  73 main (argc, argv)
  74      int argc;
  75      char **argv;
  76 {
  77   general_init (argv[0]);
  78
  79   /* Contruct a reader with default language GNU C89.  */
  80   pfile = cpp_create_reader (CLK_GNUC89);
  81   options = cpp_get_options (pfile);
  82
  83   do_preprocessing (argc, argv);
  84
  85   if (cpp_destroy (pfile))
  86     return FATAL_EXIT_CODE;
  87
  88   return SUCCESS_EXIT_CODE;
  89 }
  90
  91 /* Store the program name, and set the locale.  */
  92 static void
  93 general_init (argv0)
  94      const char *argv0;
  95 {
  96   progname = argv0 + strlen (argv0);
  97
  98   while (progname != argv0 && ! IS_DIR_SEPARATOR (progname[-1]))
  99     --progname;
 100
 101   xmalloc_set_program_name (progname);
 102
 103   hex_init ();
 104   gcc_init_libintl ();
 105 }
 106
 107 /* Handle switches, preprocess and output.  */
 108 static void
 109 do_preprocessing (argc, argv)
 110      int argc;
 111      char **argv;
 112 {
 113   int argi = 1;  /* Next argument to handle.  */
 114
 115   argi += cpp_handle_options (pfile, argc - argi , argv + argi);
 116   if (CPP_FATAL_ERRORS (pfile))
 117     return;
 118
 119   if (argi < argc)
 120     {
 121       cpp_fatal (pfile, "Invalid option %s", argv[argi]);
 122       return;
 123     }
 124
 125   cpp_post_options (pfile);
 126   if (CPP_FATAL_ERRORS (pfile))
 127     return;
 128
 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;
 135
 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;
 143
 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
 150     {
 151       print.outf = fopen (options->out_fname, "w");
 152       if (print.outf == NULL)
 153         {
 154           cpp_notice_from_errno (pfile, options->out_fname);
 155           return;
 156         }
 157     }
 158
 159   setup_callbacks ();
 160
 161   if (cpp_read_main_file (pfile, options->in_fname, NULL))
 162     {
 163       cpp_finish_options (pfile);
 164
 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);
 171
 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);
 175
 176       cpp_finish (pfile);
 177     }
 178
 179   /* Flush any pending output.  */
 180   if (print.printed)
 181     putc ('\n', print.outf);
 182
 183   if (ferror (print.outf) || fclose (print.outf))
 184     cpp_notice_from_errno (pfile, options->out_fname);
 185 }
 186
 187 /* Set up the callbacks as appropriate.  */
 188 static void
 189 setup_callbacks ()
 190 {
 191   cpp_callbacks *cb = cpp_get_callbacks (pfile);
 192
 193   if (! options->no_output)
 194     {
 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;
 200     }
 201
 202   if (options->dump_includes)
 203     cb->include  = cb_include;
 204
 205   if (options->dump_macros == dump_names
 206       || options->dump_macros == dump_definitions)
 207     {
 208       cb->define = cb_define;
 209       cb->undef  = cb_undef;
 210     }
 211 }
 212
 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;
 218 {
 219   bool avoid_paste = false;
 220
 221   print.source = NULL;
 222   for (;;)
 223     {
 224       const cpp_token *token = cpp_get_token (pfile);
 225
 226       if (token->type == CPP_PADDING)
 227         {
 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;
 234         }
 235
 236       if (token->type == CPP_EOF)
 237         break;
 238
 239       /* Subtle logic to output a space if and only if necessary.  */
 240       if (avoid_paste)
 241         {
 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);
 248         }
 249       else if (token->flags & PREV_WHITE)
 250         putc (' ', print.outf);
 251
 252       avoid_paste = false;
 253       print.source = NULL;
 254       print.prev = token;
 255       cpp_output_token (token, print.outf);
 256
 257       if (token->type == CPP_STRING || token->type == CPP_WSTRING
 258           || token->type == CPP_COMMENT)
 259         check_multiline_token (&token->val.str);
 260     }
 261 }
 262
 263 /* Adjust print.line for newlines embedded in tokens.  */
 264 static void
 265 check_multiline_token (str)
 266      const cpp_string *str;
 267 {
 268   unsigned int i;
 269
 270   for (i = 0; i < str->len; i++)
 271     if (str->text[i] == '\n')
 272       print.line++;
 273 }
 274
 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.  */
 278
 279 static void
 280 maybe_print_line (map, line)
 281      const struct line_map *map;
 282      unsigned int line;
 283 {
 284   /* End the previous line of text.  */
 285   if (print.printed)
 286     {
 287       putc ('\n', print.outf);
 288       print.line++;
 289       print.printed = 0;
 290     }
 291
 292   if (line >= print.line && line < print.line + 8)
 293     {
 294       while (line > print.line)
 295         {
 296           putc ('\n', print.outf);
 297           print.line++;
 298         }
 299     }
 300   else
 301     print_line (map, line, "");
 302 }
 303
 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;
 311 {
 312   /* End any previous line of text.  */
 313   if (print.printed)
 314     putc ('\n', print.outf);
 315   print.printed = 0;
 316
 317   print.line = line;
 318   if (! options->no_line_commands)
 319     {
 320       fprintf (print.outf, "# %u \"%s\"%s",
 321                SOURCE_LINE (map, print.line), map->to_file, special_flags);
 322
 323       if (map->sysp == 2)
 324         fputs (" 3 4", print.outf);
 325       else if (map->sysp == 1)
 326         fputs (" 3", print.outf);
 327
 328       putc ('\n', print.outf);
 329     }
 330 }
 331
 332 /* Called when a line of output is started.  TOKEN is the first token
 333    of the line, and may be CPP_EOF.  */
 334
 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;
 340 {
 341   if (token->type == CPP_EOF || parsing_args)
 342     return;
 343
 344   maybe_print_line (print.map, token->line);
 345   print.printed = 1;
 346   print.prev = 0;
 347   print.source = 0;
 348
 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)
 355     {
 356       unsigned int spaces = token->col - 2;
 357
 358       while (spaces--)
 359         putc (' ', print.outf);
 360     }
 361 }
 362
 363 static void
 364 cb_ident (pfile, line, str)
 365      cpp_reader *pfile ATTRIBUTE_UNUSED;
 366      unsigned int line;
 367      const cpp_string * str;
 368 {
 369   maybe_print_line (print.map, line);
 370   fprintf (print.outf, "#ident \"%s\"\n", str->text);
 371   print.line++;
 372 }
 373
 374 static void
 375 cb_define (pfile, line, node)
 376      cpp_reader *pfile;
 377      unsigned int line;
 378      cpp_hashnode *node;
 379 {
 380   maybe_print_line (print.map, line);
 381   fputs ("#define ", print.outf);
 382
 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);
 388
 389   putc ('\n', print.outf);
 390   print.line++;
 391 }
 392
 393 static void
 394 cb_undef (pfile, line, node)
 395      cpp_reader *pfile ATTRIBUTE_UNUSED;
 396      unsigned int line;
 397      cpp_hashnode *node;
 398 {
 399   maybe_print_line (print.map, line);
 400   fprintf (print.outf, "#undef %s\n", NODE_NAME (node));
 401   print.line++;
 402 }
 403
 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;
 410 {
 411   maybe_print_line (print.map, line);
 412   fprintf (print.outf, "#%s %s\n", dir, cpp_token_as_text (pfile, header));
 413   print.line++;
 414 }
 415
 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.  */
 419
 420 static void
 421 cb_file_change (pfile, map)
 422      cpp_reader *pfile ATTRIBUTE_UNUSED;
 423      const struct line_map *map;
 424 {
 425   const char *flags = "";
 426
 427   /* First time?  */
 428   if (print.map == NULL)
 429     {
 430       /* Avoid printing foo.i when the main file is foo.c.  */
 431       if (!options->preprocessed)
 432         print_line (map, map->from_line, flags);
 433     }
 434   else
 435     {
 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);
 439
 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);
 445     }
 446
 447   print.map = map;
 448 }
 449
 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;
 455 {
 456   maybe_print_line (print.map, line);
 457   fputs ("#pragma ", print.outf);
 458   cpp_output_line (pfile, print.outf);
 459   print.line++;
 460 }
 461
 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;
 468 {
 469   if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
 470     {
 471       fputs ("#define ", print.outf);
 472       fputs ((const char *) cpp_macro_definition (pfile, node), print.outf);
 473       putc ('\n', print.outf);
 474       print.line++;
 475     }
 476
 477   return 1;
 478 }