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   for (;;)
 232     {
 233       size_t len;
 234
 235       if (!_cpp_read_logical_line_trad (pfile))
 236         break;
 237       len = pfile->out.cur - pfile->out.base;
 238       maybe_print_line (print.map, pfile->out.first_line);
 239       fwrite (pfile->out.base, 1, len, print.outf);
 240       print.printed = 1;
 241       if (!CPP_OPTION (pfile, discard_comments))
 242         account_for_newlines (pfile->out.base, len);
 243     }
 244 }
 245
 246 /* If the token read on logical line LINE needs to be output on a
 247    different line to the current one, output the required newlines or
 248    a line marker, and return 1.  Otherwise return 0.  */
 249 static void
 250 maybe_print_line (map, line)
 251      const struct line_map *map;
 252      unsigned int line;
 253 {
 254   /* End the previous line of text.  */
 255   if (print.printed)
 256     {
 257       putc ('\n', print.outf);
 258       print.line++;
 259       print.printed = 0;
 260     }
 261
 262   if (line >= print.line && line < print.line + 8)
 263     {
 264       while (line > print.line)
 265         {
 266           putc ('\n', print.outf);
 267           print.line++;
 268         }
 269     }
 270   else
 271     print_line (map, line, "");
 272 }
 273
 274 /* Output a line marker for logical line LINE.  Special flags are "1"
 275    or "2" indicating entering or leaving a file.  */
 276 static void
 277 print_line (map, line, special_flags)
 278      const struct line_map *map;
 279      unsigned int line;
 280      const char *special_flags;
 281 {
 282   /* End any previous line of text.  */
 283   if (print.printed)
 284     putc ('\n', print.outf);
 285   print.printed = 0;
 286
 287   print.line = line;
 288   if (! options->no_line_commands)
 289     {
 290       size_t to_file_len = strlen (map->to_file);
 291       unsigned char *to_file_quoted = alloca (to_file_len * 4 + 1);
 292       unsigned char *p;
 293
 294       /* cpp_quote_string does not nul-terminate, so we have to do it
 295          ourselves.  */
 296       p = cpp_quote_string (to_file_quoted,
 297                             (unsigned char *)map->to_file, to_file_len);
 298       *p = '\0';
 299       fprintf (print.outf, "# %u \"%s\"%s",
 300                SOURCE_LINE (map, print.line), to_file_quoted, special_flags);
 301
 302       if (map->sysp == 2)
 303         fputs (" 3 4", print.outf);
 304       else if (map->sysp == 1)
 305         fputs (" 3", print.outf);
 306
 307       putc ('\n', print.outf);
 308     }
 309 }
 310
 311 /* Called when a line of output is started.  TOKEN is the first token
 312    of the line, and at end of file will be CPP_EOF.  */
 313 static void
 314 cb_line_change (pfile, token, parsing_args)
 315      cpp_reader *pfile ATTRIBUTE_UNUSED;
 316      const cpp_token *token;
 317      int parsing_args;
 318 {
 319   if (token->type == CPP_EOF || parsing_args)
 320     return;
 321
 322   maybe_print_line (print.map, token->line);
 323   print.printed = 1;
 324   print.prev = 0;
 325   print.source = 0;
 326
 327   /* Supply enough spaces to put this token in its original column,
 328      one space per column greater than 2, since scan_translation_unit
 329      will provide a space if PREV_WHITE.  Don't bother trying to
 330      reconstruct tabs; we can't get it right in general, and nothing
 331      ought to care.  Some things do care; the fault lies with them.  */
 332   if (token->col > 2)
 333     {
 334       unsigned int spaces = token->col - 2;
 335
 336       while (spaces--)
 337         putc (' ', print.outf);
 338     }
 339 }
 340
 341 static void
 342 cb_ident (pfile, line, str)
 343      cpp_reader *pfile ATTRIBUTE_UNUSED;
 344      unsigned int line;
 345      const cpp_string * str;
 346 {
 347   maybe_print_line (print.map, line);
 348   fprintf (print.outf, "#ident \"%s\"\n", str->text);
 349   print.line++;
 350 }
 351
 352 static void
 353 cb_define (pfile, line, node)
 354      cpp_reader *pfile;
 355      unsigned int line;
 356      cpp_hashnode *node;
 357 {
 358   maybe_print_line (print.map, line);
 359   fputs ("#define ", print.outf);
 360
 361   /* -dD command line option.  */
 362   if (options->dump_macros == dump_definitions)
 363     fputs ((const char *) cpp_macro_definition (pfile, node), print.outf);
 364   else
 365     fputs ((const char *) NODE_NAME (node), print.outf);
 366
 367   putc ('\n', print.outf);
 368   print.line++;
 369 }
 370
 371 static void
 372 cb_undef (pfile, line, node)
 373      cpp_reader *pfile ATTRIBUTE_UNUSED;
 374      unsigned int line;
 375      cpp_hashnode *node;
 376 {
 377   maybe_print_line (print.map, line);
 378   fprintf (print.outf, "#undef %s\n", NODE_NAME (node));
 379   print.line++;
 380 }
 381
 382 static void
 383 cb_include (pfile, line, dir, header)
 384      cpp_reader *pfile;
 385      unsigned int line;
 386      const unsigned char *dir;
 387      const cpp_token *header;
 388 {
 389   maybe_print_line (print.map, line);
 390   fprintf (print.outf, "#%s %s\n", dir, cpp_token_as_text (pfile, header));
 391   print.line++;
 392 }
 393
 394 /* The file name, line number or system header flags have changed, as
 395    described in MAP.  From this point on, the old print.map might be
 396    pointing to freed memory, and so must not be dereferenced.  */
 397
 398 static void
 399 cb_file_change (pfile, map)
 400      cpp_reader *pfile ATTRIBUTE_UNUSED;
 401      const struct line_map *map;
 402 {
 403   const char *flags = "";
 404
 405   /* First time?  */
 406   if (print.map == NULL)
 407     {
 408       /* Avoid printing foo.i when the main file is foo.c.  */
 409       if (!options->preprocessed)
 410         print_line (map, map->from_line, flags);
 411     }
 412   else
 413     {
 414       /* Bring current file to correct line when entering a new file.  */
 415       if (map->reason == LC_ENTER)
 416         maybe_print_line (map - 1, map->from_line - 1);
 417
 418       if (map->reason == LC_ENTER)
 419         flags = " 1";
 420       else if (map->reason == LC_LEAVE)
 421         flags = " 2";
 422       print_line (map, map->from_line, flags);
 423     }
 424
 425   print.map = map;
 426 }
 427
 428 /* Copy a #pragma directive to the preprocessed output.  */
 429 static void
 430 cb_def_pragma (pfile, line)
 431      cpp_reader *pfile;
 432      unsigned int line;
 433 {
 434   maybe_print_line (print.map, line);
 435   fputs ("#pragma ", print.outf);
 436   cpp_output_line (pfile, print.outf);
 437   print.line++;
 438 }
 439
 440 /* Dump out the hash table.  */
 441 static int
 442 dump_macro (pfile, node, v)
 443      cpp_reader *pfile;
 444      cpp_hashnode *node;
 445      void *v ATTRIBUTE_UNUSED;
 446 {
 447   if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
 448     {
 449       fputs ("#define ", print.outf);
 450       fputs ((const char *) cpp_macro_definition (pfile, node), print.outf);
 451       putc ('\n', print.outf);
 452       print.line++;
 453     }
 454
 455   return 1;
 456 }