gcc/cppmain.c

   1 /* CPP main program, using CPP Library.
   2    Copyright (C) 1995, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
   3    Written by Per Bothner, 1994-95.
   4
   5 This program is free software; you can redistribute it and/or modify it
   6 under the terms of the GNU General Public License as published by the
   7 Free Software Foundation; either version 2, or (at your option) any
   8 later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19  In other words, you are welcome to use, share and improve this program.
  20  You are forbidden to forbid anyone else to use, share and improve
  21  what you give them.   Help stamp out software-hoarding!  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "cpplib.h"
  26 #include "intl.h"
  27
  28 /* Encapsulates state used to convert the stream of tokens coming from
  29    cpp_get_token back into a text file.  */
  30 struct printer
  31 {
  32   FILE *outf;                   /* stream to write to.  */
  33   const char *last_fname;       /* previous file name.  */
  34   const char *syshdr_flags;     /* system header flags, if any.  */
  35   unsigned int lineno;          /* line currently being written.  */
  36   unsigned char printed;        /* nonzero if something output at lineno.  */
  37   unsigned char no_line_dirs;   /* nonzero to output no line directives.  */
  38 };
  39
  40 int main                PARAMS ((int, char **));
  41 static void general_init PARAMS ((const char *));
  42 static void setup_callbacks PARAMS ((void));
  43
  44 /* General output routines.  */
  45 static void scan_buffer PARAMS ((cpp_reader *));
  46 static int printer_init PARAMS ((cpp_reader *));
  47 static int dump_macro PARAMS ((cpp_reader *, cpp_hashnode *, void *));
  48
  49 static void print_line PARAMS ((const char *));
  50 static void maybe_print_line PARAMS ((unsigned int));
  51
  52 /* Callback routines for the parser.   Most of these are active only
  53    in specific modes.  */
  54 static void cb_define   PARAMS ((cpp_reader *, cpp_hashnode *));
  55 static void cb_undef    PARAMS ((cpp_reader *, cpp_hashnode *));
  56 static void cb_include  PARAMS ((cpp_reader *, const unsigned char *,
  57                                  const cpp_token *));
  58 static void cb_ident      PARAMS ((cpp_reader *, const cpp_string *));
  59 static void cb_change_file PARAMS ((cpp_reader *, const cpp_file_change *));
  60 static void cb_def_pragma PARAMS ((cpp_reader *));
  61 static void do_pragma_implementation PARAMS ((cpp_reader *));
  62
  63 const char *progname;           /* Needs to be global.  */
  64 static cpp_reader *pfile;
  65 static struct printer print;
  66
  67 int
  68 main (argc, argv)
  69      int argc;
  70      char **argv;
  71 {
  72   int argi = 1;  /* Next argument to handle.  */
  73
  74   general_init (argv[0]);
  75   /* Default language is GNU C89.  */
  76   pfile = cpp_create_reader (CLK_GNUC89);
  77
  78   argi += cpp_handle_options (pfile, argc - argi , argv + argi);
  79   if (argi < argc && ! CPP_FATAL_ERRORS (pfile))
  80     cpp_fatal (pfile, "Invalid option %s", argv[argi]);
  81   if (CPP_FATAL_ERRORS (pfile))
  82     return (FATAL_EXIT_CODE);
  83
  84   /* Open the output now.  We must do so even if no_output is on,
  85      because there may be other output than from the actual
  86      preprocessing (e.g. from -dM).  */
  87   if (printer_init (pfile))
  88     return (FATAL_EXIT_CODE);
  89
  90   setup_callbacks ();
  91
  92   if (! cpp_start_read (pfile, CPP_OPTION (pfile, in_fname)))
  93     return (FATAL_EXIT_CODE);
  94
  95   if (CPP_BUFFER (pfile))
  96     {
  97       if (CPP_OPTION (pfile, no_output))
  98         cpp_scan_buffer_nooutput (pfile, 1);
  99       else
 100         scan_buffer (pfile);
 101     }
 102
 103   /* -dM command line option.  */
 104   if (CPP_OPTION (pfile, dump_macros) == dump_only)
 105     cpp_forall_identifiers (pfile, dump_macro, NULL);
 106
 107   cpp_finish (pfile);
 108   cpp_cleanup (pfile);
 109
 110   /* Flush any pending output.  */
 111   if (print.printed)
 112     putc ('\n', print.outf);
 113   if (ferror (print.outf) || fclose (print.outf))
 114     cpp_notice_from_errno (pfile, CPP_OPTION (pfile, out_fname));
 115
 116   if (pfile->errors)
 117     return (FATAL_EXIT_CODE);
 118   return (SUCCESS_EXIT_CODE);
 119 }
 120
 121 /* Store the program name, and set the locale.  */
 122 static void
 123 general_init (const char *argv0)
 124 {
 125   progname = argv0 + strlen (argv0);
 126
 127   while (progname != argv0 && ! IS_DIR_SEPARATOR (progname[-1]))
 128     --progname;
 129
 130   xmalloc_set_program_name (progname);
 131
 132 #ifdef HAVE_LC_MESSAGES
 133   setlocale (LC_MESSAGES, "");
 134 #endif
 135   (void) bindtextdomain (PACKAGE, localedir);
 136   (void) textdomain (PACKAGE);
 137 }
 138
 139 /* Set up the callbacks and register the pragmas we handle.  */
 140 static void
 141 setup_callbacks ()
 142 {
 143   /* Set callbacks.  */
 144   if (! CPP_OPTION (pfile, no_output))
 145     {
 146       pfile->cb.ident      = cb_ident;
 147       pfile->cb.def_pragma = cb_def_pragma;
 148       if (! CPP_OPTION (pfile, no_line_commands))
 149         pfile->cb.change_file = cb_change_file;
 150     }
 151
 152   if (CPP_OPTION (pfile, dump_includes))
 153     pfile->cb.include  = cb_include;
 154
 155   if (CPP_OPTION (pfile, debug_output)
 156       || CPP_OPTION (pfile, dump_macros) == dump_names
 157       || CPP_OPTION (pfile, dump_macros) == dump_definitions)
 158     {
 159       pfile->cb.define = cb_define;
 160       pfile->cb.undef  = cb_undef;
 161       pfile->cb.poison = cb_def_pragma;
 162     }
 163
 164   /* Register one #pragma which needs special handling.  */
 165   cpp_register_pragma(pfile, 0, "implementation", do_pragma_implementation);
 166   cpp_register_pragma(pfile, "GCC", "implementation", do_pragma_implementation);
 167 }
 168
 169 /* Writes out the preprocessed file.  Alternates between two tokens,
 170    so that we can avoid accidental token pasting.  */
 171 static void
 172 scan_buffer (pfile)
 173      cpp_reader *pfile;
 174 {
 175   unsigned int index, line;
 176   cpp_token tokens[2], *token;
 177
 178   do
 179     {
 180       for (index = 0;; index = 1 - index)
 181         {
 182           token = &tokens[index];
 183           cpp_get_token (pfile, token);
 184
 185           if (token->type == CPP_EOF)
 186             break;
 187
 188           line = cpp_get_line (pfile)->output_line;
 189           if (print.lineno != line)
 190             {
 191               unsigned int col = cpp_get_line (pfile)->col;
 192
 193               /* Supply enough whitespace to put this token in its original
 194                  column.  Don't bother trying to reconstruct tabs; we can't
 195                  get it right in general, and nothing ought to care.  (Yes,
 196                  some things do care; the fault lies with them.)  */
 197               maybe_print_line (line);
 198               if (col > 1)
 199                 {
 200                   if (token->flags & PREV_WHITE)
 201                     col--;
 202                   while (--col)
 203                     putc (' ', print.outf);
 204                 }
 205             }
 206           else if (print.printed
 207                    && ! (token->flags & PREV_WHITE)
 208                    && CPP_OPTION (pfile, lang) != CLK_ASM
 209                    && cpp_avoid_paste (pfile, &tokens[1 - index], token))
 210             token->flags |= PREV_WHITE;
 211
 212           cpp_output_token (token, print.outf);
 213           print.printed = 1;
 214         }
 215     }
 216   while (cpp_pop_buffer (pfile) != 0);
 217 }
 218
 219 /* Initialize a cpp_printer structure.  As a side effect, open the
 220    output file.  */
 221 static int
 222 printer_init (pfile)
 223      cpp_reader *pfile;
 224 {
 225   print.last_fname = 0;
 226   print.lineno = 0;
 227   print.printed = 0;
 228   print.no_line_dirs = CPP_OPTION (pfile, no_line_commands);
 229
 230   if (CPP_OPTION (pfile, out_fname) == NULL)
 231     CPP_OPTION (pfile, out_fname) = "";
 232
 233   if (CPP_OPTION (pfile, out_fname)[0] == '\0')
 234     print.outf = stdout;
 235   else
 236     {
 237       print.outf = fopen (CPP_OPTION (pfile, out_fname), "w");
 238       if (! print.outf)
 239         {
 240           cpp_notice_from_errno (pfile, CPP_OPTION (pfile, out_fname));
 241           return 1;
 242         }
 243     }
 244   return 0;
 245 }
 246
 247 /* Newline-terminate any output line currently in progress.  If
 248    appropriate, write the current line number to the output, or pad
 249    with newlines so the output line matches the current line.  */
 250 static void
 251 maybe_print_line (line)
 252      unsigned int line;
 253 {
 254   /* End the previous line of text (probably only needed until we get
 255      multi-line tokens fixed).  */
 256   if (print.printed)
 257     {
 258       putc ('\n', print.outf);
 259       print.lineno++;
 260       print.printed = 0;
 261     }
 262
 263   if (print.no_line_dirs)
 264     return;
 265
 266   /* print.lineno is zero if this is the first token of the file.  We
 267      handle this specially, so that a first line of "# 1 "foo.c" in
 268      file foo.i outputs just the foo.c line, and not a foo.i line.  */
 269   if (line >= print.lineno && line < print.lineno + 8 && print.lineno)
 270     {
 271       while (line > print.lineno)
 272         {
 273           putc ('\n', print.outf);
 274           print.lineno++;
 275         }
 276     }
 277   else
 278     {
 279       print.lineno = line;
 280       print_line ("");
 281     }
 282 }
 283
 284 static void
 285 print_line (special_flags)
 286   const char *special_flags;
 287 {
 288   /* End any previous line of text.  */
 289   if (print.printed)
 290     putc ('\n', print.outf);
 291   print.printed = 0;
 292
 293   fprintf (print.outf, "# %u \"%s\"%s%s\n",
 294            print.lineno, print.last_fname, special_flags, print.syshdr_flags);
 295 }
 296
 297 /* Callbacks */
 298
 299 static void
 300 cb_ident (pfile, str)
 301      cpp_reader *pfile ATTRIBUTE_UNUSED;
 302      const cpp_string * str;
 303 {
 304   maybe_print_line (cpp_get_line (pfile)->output_line);
 305   fprintf (print.outf, "#ident \"%.*s\"\n", (int) str->len, str->text);
 306   print.lineno++;
 307 }
 308
 309 static void
 310 cb_define (pfile, node)
 311      cpp_reader *pfile;
 312      cpp_hashnode *node;
 313 {
 314   if (pfile->done_initializing)
 315     {
 316       maybe_print_line (cpp_get_line (pfile)->output_line);
 317       fprintf (print.outf, "#define %s", node->name);
 318
 319       /* -dD or -g3 command line options.  */
 320       if (CPP_OPTION (pfile, debug_output)
 321           || CPP_OPTION (pfile, dump_macros) == dump_definitions)
 322         fputs ((const char *) cpp_macro_definition (pfile, node), print.outf);
 323
 324       putc ('\n', print.outf);
 325       print.lineno++;
 326     }
 327 }
 328
 329 static void
 330 cb_undef (pfile, node)
 331      cpp_reader *pfile;
 332      cpp_hashnode *node;
 333 {
 334   if (pfile->done_initializing)
 335     {
 336       maybe_print_line (cpp_get_line (pfile)->output_line);
 337       fprintf (print.outf, "#undef %s\n", node->name);
 338       print.lineno++;
 339     }
 340 }
 341
 342 static void
 343 cb_include (pfile, dir, header)
 344      cpp_reader *pfile ATTRIBUTE_UNUSED;
 345      const unsigned char *dir;
 346      const cpp_token *header;
 347 {
 348   maybe_print_line (cpp_get_line (pfile)->output_line);
 349   fprintf (print.outf, "#%s %s\n", dir, cpp_token_as_text (pfile, header));
 350   print.lineno++;
 351 }
 352
 353 static void
 354 cb_change_file (pfile, fc)
 355      cpp_reader *pfile ATTRIBUTE_UNUSED;
 356      const cpp_file_change *fc;
 357 {
 358   const char *flags;
 359
 360   /* Bring current file to correct line (except first file).  */
 361   if (fc->reason == FC_ENTER && fc->from.filename)
 362     maybe_print_line (fc->from.lineno);
 363
 364   print.last_fname = fc->to.filename;
 365   if (fc->externc)
 366     print.syshdr_flags = " 3 4";
 367   else if (fc->sysp)
 368     print.syshdr_flags = " 3";
 369   else
 370     print.syshdr_flags = "";
 371
 372   if (print.lineno)
 373     {
 374       print.lineno = fc->to.lineno;
 375       switch (fc->reason)
 376         {
 377         case FC_ENTER : flags = " 1"; break;
 378         case FC_LEAVE : flags = " 2"; break;
 379         case FC_RENAME: flags = ""; break;
 380         }
 381
 382       print_line (flags);
 383     }
 384 }
 385
 386 static void
 387 cb_def_pragma (pfile)
 388      cpp_reader *pfile;
 389 {
 390   maybe_print_line (cpp_get_line (pfile)->output_line);
 391   fputs ("#pragma ", print.outf);
 392   cpp_output_line (pfile, print.outf);
 393   print.lineno++;
 394 }
 395
 396 static void
 397 do_pragma_implementation (pfile)
 398      cpp_reader *pfile;
 399 {
 400   /* Be quiet about `#pragma implementation' for a file only if it hasn't
 401      been included yet.  */
 402   cpp_token token;
 403
 404   cpp_start_lookahead (pfile);
 405   cpp_get_token (pfile, &token);
 406   cpp_stop_lookahead (pfile, 0);
 407
 408   /* If it's not a string, pass it through and let the front end complain.  */
 409   if (token.type == CPP_STRING)
 410     {
 411      /* Make a NUL-terminated copy of the string.  */
 412       char *filename = alloca (token.val.str.len + 1);
 413       memcpy (filename, token.val.str.text, token.val.str.len);
 414       filename[token.val.str.len] = '\0';
 415       if (cpp_included (pfile, filename))
 416         cpp_warning (pfile,
 417              "#pragma GCC implementation for \"%s\" appears after file is included",
 418                      filename);
 419     }
 420   else if (token.type != CPP_EOF)
 421     {
 422       cpp_error (pfile, "malformed #pragma GCC implementation");
 423       return;
 424     }
 425
 426   /* Output?  This is nasty, but we don't have [GCC] implementation in
 427      the buffer.  */
 428   if (pfile->cb.def_pragma)
 429     {
 430       maybe_print_line (cpp_get_line (pfile)->output_line);
 431       fputs ("#pragma GCC implementation ", print.outf);
 432       cpp_output_line (pfile, print.outf);
 433       print.lineno++;
 434     }
 435 }
 436
 437 /* Dump out the hash table.  */
 438 static int
 439 dump_macro (pfile, node, v)
 440      cpp_reader *pfile;
 441      cpp_hashnode *node;
 442      void *v ATTRIBUTE_UNUSED;
 443 {
 444   if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
 445     {
 446       fprintf (print.outf, "#define %s", node->name);
 447       fputs ((const char *) cpp_macro_definition (pfile, node), print.outf);
 448       putc ('\n', print.outf);
 449       print.lineno++;
 450     }
 451
 452   return 1;
 453 }