gcc/cppmain.c

   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.
   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 "cpphash.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 static void setup_callbacks PARAMS ((cpp_reader *));
  42
  43 /* General output routines.  */
  44 static void scan_translation_unit PARAMS ((cpp_reader *));
  45 static void scan_translation_unit_trad PARAMS ((cpp_reader *));
  46 static void account_for_newlines PARAMS ((const uchar *, size_t));
  47 static int dump_macro PARAMS ((cpp_reader *, cpp_hashnode *, void *));
  48
  49 static void print_line PARAMS ((const struct line_map *, unsigned int,
  50                                 const char *));
  51 static void maybe_print_line PARAMS ((const struct line_map *, unsigned int));
  52
  53 /* Callback routines for the parser.   Most of these are active only
  54    in specific modes.  */
  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,
  61                                    const cpp_string *));
  62 static void cb_file_change PARAMS ((cpp_reader *, const struct line_map *));
  63 static void cb_def_pragma PARAMS ((cpp_reader *, unsigned int));
  64
  65 static cpp_options *options;    /* Options of pfile.  */
  66 static struct printer print;
  67
  68 /* Preprocess and output.  */
  69 void
  70 cpp_preprocess_file (pfile)
  71      cpp_reader *pfile;
  72 {
  73   options = cpp_get_options (pfile);
  74
  75   /* Let preprocessor know if it's only preprocessing.  It would be
  76      nice to lose this somehow.  */
  77   options->preprocess_only = 1;
  78
  79   /* Initialize the printer structure.  Setting print.line to -1 here
  80      is a trick to guarantee that the first token of the file will
  81      cause a linemarker to be output by maybe_print_line.  */
  82   print.line = (unsigned int) -1;
  83   print.printed = 0;
  84   print.prev = 0;
  85   print.map = 0;
  86
  87   /* Open the output now.  We must do so even if no_output is on,
  88      because there may be other output than from the actual
  89      preprocessing (e.g. from -dM).  */
  90   if (options->out_fname[0] == '\0')
  91     print.outf = stdout;
  92   else
  93     {
  94       print.outf = fopen (options->out_fname, "w");
  95       if (print.outf == NULL)
  96         {
  97           cpp_errno (pfile, DL_ERROR, options->out_fname);
  98           return;
  99         }
 100     }
 101
 102   setup_callbacks (pfile);
 103
 104   if (cpp_read_main_file (pfile, options->in_fname, NULL))
 105     {
 106       cpp_finish_options (pfile);
 107
 108       /* A successful cpp_read_main_file guarantees that we can call
 109          cpp_scan_nooutput or cpp_get_token next.  */
 110       if (options->no_output)
 111         cpp_scan_nooutput (pfile);
 112       else if (options->traditional)
 113         scan_translation_unit_trad (pfile);
 114       else
 115         scan_translation_unit (pfile);
 116
 117       /* -dM command line option.  Should this be in cpp_finish?  */
 118       if (options->dump_macros == dump_only)
 119         cpp_forall_identifiers (pfile, dump_macro, NULL);
 120     }
 121
 122   /* Flush any pending output.  */
 123   if (print.printed)
 124     putc ('\n', print.outf);
 125
 126   /* Don't close stdout (dependencies have yet to be output).  */
 127   if (print.outf != stdout)
 128     {
 129       if (ferror (print.outf) || fclose (print.outf))
 130         cpp_errno (pfile, DL_ERROR, options->out_fname);
 131     }
 132 }
 133
 134 /* Set up the callbacks as appropriate.  */
 135 static void
 136 setup_callbacks (pfile)
 137      cpp_reader *pfile;
 138 {
 139   cpp_callbacks *cb = cpp_get_callbacks (pfile);
 140
 141   if (! options->no_output)
 142     {
 143       cb->line_change = cb_line_change;
 144       /* Don't emit #pragma or #ident directives if we are processing
 145          assembly language; the assembler may choke on them.  */
 146       if (options->lang != CLK_ASM)
 147         {
 148           cb->ident      = cb_ident;
 149           cb->def_pragma = cb_def_pragma;
 150         }
 151       if (! options->no_line_commands)
 152         cb->file_change = cb_file_change;
 153     }
 154
 155   if (options->dump_includes)
 156     cb->include  = cb_include;
 157
 158   if (options->dump_macros == dump_names
 159       || options->dump_macros == dump_definitions)
 160     {
 161       cb->define = cb_define;
 162       cb->undef  = cb_undef;
 163     }
 164 }
 165
 166 /* Writes out the preprocessed file, handling spacing and paste
 167    avoidance issues.  */
 168 static void
 169 scan_translation_unit (pfile)
 170      cpp_reader *pfile;
 171 {
 172   bool avoid_paste = false;
 173
 174   print.source = NULL;
 175   for (;;)
 176     {
 177       const cpp_token *token = cpp_get_token (pfile);
 178
 179       if (token->type == CPP_PADDING)
 180         {
 181           avoid_paste = true;
 182           if (print.source == NULL
 183               || (!(print.source->flags & PREV_WHITE)
 184                   && token->val.source == NULL))
 185             print.source = token->val.source;
 186           continue;
 187         }
 188
 189       if (token->type == CPP_EOF)
 190         break;
 191
 192       /* Subtle logic to output a space if and only if necessary.  */
 193       if (avoid_paste)
 194         {
 195           if (print.source == NULL)
 196             print.source = token;
 197           if (print.source->flags & PREV_WHITE
 198               || (print.prev && cpp_avoid_paste (pfile, print.prev, token))
 199               || (print.prev == NULL && token->type == CPP_HASH))
 200             putc (' ', print.outf);
 201         }
 202       else if (token->flags & PREV_WHITE)
 203         putc (' ', print.outf);
 204
 205       avoid_paste = false;
 206       print.source = NULL;
 207       print.prev = token;
 208       cpp_output_token (token, print.outf);
 209
 210       if (token->type == CPP_COMMENT)
 211         account_for_newlines (token->val.str.text, token->val.str.len);
 212     }
 213 }
 214
 215 /* Adjust print.line for newlines embedded in output.  */
 216 static void
 217 account_for_newlines (str, len)
 218      const uchar *str;
 219      size_t len;
 220 {
 221   while (len--)
 222     if (*str++ == '\n')
 223       print.line++;
 224 }
 225
 226 /* Writes out a traditionally preprocessed file.  */
 227 static void
 228 scan_translation_unit_trad (pfile)
 229      cpp_reader *pfile;
 230 {
 231   while (_cpp_read_logical_line_trad (pfile))
 232     {
 233       size_t len = pfile->out.cur - pfile->out.base;
 234       maybe_print_line (print.map, pfile->out.first_line);
 235       fwrite (pfile->out.base, 1, len, print.outf);
 236       print.printed = 1;
 237       if (!CPP_OPTION (pfile, discard_comments))
 238         account_for_newlines (pfile->out.base, len);
 239     }
 240 }
 241
 242 /* If the token read on logical line LINE needs to be output on a
 243    different line to the current one, output the required newlines or
 244    a line marker, and return 1.  Otherwise return 0.  */
 245 static void
 246 maybe_print_line (map, line)
 247      const struct line_map *map;
 248      unsigned int line;
 249 {
 250   /* End the previous line of text.  */
 251   if (print.printed)
 252     {
 253       putc ('\n', print.outf);
 254       print.line++;
 255       print.printed = 0;
 256     }
 257
 258   if (line >= print.line && line < print.line + 8)
 259     {
 260       while (line > print.line)
 261         {
 262           putc ('\n', print.outf);
 263           print.line++;
 264         }
 265     }
 266   else
 267     print_line (map, line, "");
 268 }
 269
 270 /* Output a line marker for logical line LINE.  Special flags are "1"
 271    or "2" indicating entering or leaving a file.  */
 272 static void
 273 print_line (map, line, special_flags)
 274      const struct line_map *map;
 275      unsigned int line;
 276      const char *special_flags;
 277 {
 278   /* End any previous line of text.  */
 279   if (print.printed)
 280     putc ('\n', print.outf);
 281   print.printed = 0;
 282
 283   print.line = line;
 284   if (! options->no_line_commands)
 285     {
 286       size_t to_file_len = strlen (map->to_file);
 287       unsigned char *to_file_quoted = alloca (to_file_len * 4 + 1);
 288       unsigned char *p;
 289
 290       /* cpp_quote_string does not nul-terminate, so we have to do it
 291          ourselves.  */
 292       p = cpp_quote_string (to_file_quoted,
 293                             (unsigned char *)map->to_file, to_file_len);
 294       *p = '\0';
 295       fprintf (print.outf, "# %u \"%s\"%s",
 296                SOURCE_LINE (map, print.line), to_file_quoted, special_flags);
 297
 298       if (map->sysp == 2)
 299         fputs (" 3 4", print.outf);
 300       else if (map->sysp == 1)
 301         fputs (" 3", print.outf);
 302
 303       putc ('\n', print.outf);
 304     }
 305 }
 306
 307 /* Called when a line of output is started.  TOKEN is the first token
 308    of the line, and at end of file will be CPP_EOF.  */
 309 static void
 310 cb_line_change (pfile, token, parsing_args)
 311      cpp_reader *pfile ATTRIBUTE_UNUSED;
 312      const cpp_token *token;
 313      int parsing_args;
 314 {
 315   if (token->type == CPP_EOF || parsing_args)
 316     return;
 317
 318   maybe_print_line (print.map, token->line);
 319   print.prev = 0;
 320   print.source = 0;
 321
 322   /* Supply enough spaces to put this token in its original column,
 323      one space per column greater than 2, since scan_translation_unit
 324      will provide a space if PREV_WHITE.  Don't bother trying to
 325      reconstruct tabs; we can't get it right in general, and nothing
 326      ought to care.  Some things do care; the fault lies with them.  */
 327   if (!CPP_OPTION (pfile, traditional))
 328     {
 329       print.printed = 1;
 330       if (token->col > 2)
 331         {
 332           unsigned int spaces = token->col - 2;
 333
 334           while (spaces--)
 335             putc (' ', print.outf);
 336         }
 337     }
 338 }
 339
 340 static void
 341 cb_ident (pfile, line, str)
 342      cpp_reader *pfile ATTRIBUTE_UNUSED;
 343      unsigned int line;
 344      const cpp_string * str;
 345 {
 346   maybe_print_line (print.map, line);
 347   fprintf (print.outf, "#ident \"%s\"\n", str->text);
 348   print.line++;
 349 }
 350
 351 static void
 352 cb_define (pfile, line, node)
 353      cpp_reader *pfile;
 354      unsigned int line;
 355      cpp_hashnode *node;
 356 {
 357   maybe_print_line (print.map, line);
 358   fputs ("#define ", print.outf);
 359
 360   /* -dD command line option.  */
 361   if (options->dump_macros == dump_definitions)
 362     fputs ((const char *) cpp_macro_definition (pfile, node), print.outf);
 363   else
 364     fputs ((const char *) NODE_NAME (node), print.outf);
 365
 366   putc ('\n', print.outf);
 367   print.line++;
 368 }
 369
 370 static void
 371 cb_undef (pfile, line, node)
 372      cpp_reader *pfile ATTRIBUTE_UNUSED;
 373      unsigned int line;
 374      cpp_hashnode *node;
 375 {
 376   maybe_print_line (print.map, line);
 377   fprintf (print.outf, "#undef %s\n", NODE_NAME (node));
 378   print.line++;
 379 }
 380
 381 static void
 382 cb_include (pfile, line, dir, header)
 383      cpp_reader *pfile;
 384      unsigned int line;
 385      const unsigned char *dir;
 386      const cpp_token *header;
 387 {
 388   maybe_print_line (print.map, line);
 389   fprintf (print.outf, "#%s %s\n", dir, cpp_token_as_text (pfile, header));
 390   print.line++;
 391 }
 392
 393 /* The file name, line number or system header flags have changed, as
 394    described in MAP.  From this point on, the old print.map might be
 395    pointing to freed memory, and so must not be dereferenced.  */
 396
 397 static void
 398 cb_file_change (pfile, map)
 399      cpp_reader *pfile ATTRIBUTE_UNUSED;
 400      const struct line_map *map;
 401 {
 402   const char *flags = "";
 403
 404   /* First time?  */
 405   if (print.map == NULL)
 406     {
 407       /* Avoid printing foo.i when the main file is foo.c.  */
 408       if (!options->preprocessed)
 409         print_line (map, map->from_line, flags);
 410     }
 411   else
 412     {
 413       /* Bring current file to correct line when entering a new file.  */
 414       if (map->reason == LC_ENTER)
 415         maybe_print_line (map - 1, map->from_line - 1);
 416
 417       if (map->reason == LC_ENTER)
 418         flags = " 1";
 419       else if (map->reason == LC_LEAVE)
 420         flags = " 2";
 421       print_line (map, map->from_line, flags);
 422     }
 423
 424   print.map = map;
 425 }
 426
 427 /* Copy a #pragma directive to the preprocessed output.  */
 428 static void
 429 cb_def_pragma (pfile, line)
 430      cpp_reader *pfile;
 431      unsigned int line;
 432 {
 433   maybe_print_line (print.map, line);
 434   fputs ("#pragma ", print.outf);
 435   cpp_output_line (pfile, print.outf);
 436   print.line++;
 437 }
 438
 439 /* Dump out the hash table.  */
 440 static int
 441 dump_macro (pfile, node, v)
 442      cpp_reader *pfile;
 443      cpp_hashnode *node;
 444      void *v ATTRIBUTE_UNUSED;
 445 {
 446   if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
 447     {
 448       fputs ("#define ", print.outf);
 449       fputs ((const char *) cpp_macro_definition (pfile, node), print.outf);
 450       putc ('\n', print.outf);
 451       print.line++;
 452     }
 453
 454   return 1;
 455 }