gcc/c-ppoutput.c

   1 /* Preprocess only, using cpplib.
   2    Copyright (C) 1995, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007,
   3    2008 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 3, 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; see the file COPYING3.  If not see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "tm.h"
  24 #include "cpplib.h"
  25 #include "../libcpp/internal.h"
  26 #include "tree.h"
  27 #include "c-common.h"           /* For flags.  */
  28 #include "c-pragma.h"           /* For parse_in.  */
  29
  30 /* Encapsulates state used to convert a stream of tokens into a text
  31    file.  */
  32 static struct
  33 {
  34   FILE *outf;                   /* Stream to write to.  */
  35   const cpp_token *prev;        /* Previous token.  */
  36   const cpp_token *source;      /* Source token for spacing.  */
  37   int src_line;                 /* Line number currently being written.  */
  38   unsigned char printed;        /* Nonzero if something output at line.  */
  39   bool first_time;              /* pp_file_change hasn't been called yet.  */
  40 } print;
  41
  42 /* Defined and undefined macros being queued for output with -dU at
  43    the next newline.  */
  44 typedef struct macro_queue
  45 {
  46   struct macro_queue *next;     /* Next macro in the list.  */
  47   char *macro;                  /* The name of the macro if not
  48                                    defined, the full definition if
  49                                    defined.  */
  50 } macro_queue;
  51 static macro_queue *define_queue, *undef_queue;
  52
  53 /* General output routines.  */
  54 static void scan_translation_unit (cpp_reader *);
  55 static void print_lines_directives_only (int, const void *, size_t);
  56 static void scan_translation_unit_directives_only (cpp_reader *);
  57 static void scan_translation_unit_trad (cpp_reader *);
  58 static void account_for_newlines (const unsigned char *, size_t);
  59 static int dump_macro (cpp_reader *, cpp_hashnode *, void *);
  60 static void dump_queued_macros (cpp_reader *);
  61
  62 static void print_line (source_location, const char *);
  63 static void maybe_print_line (source_location);
  64
  65 /* Callback routines for the parser.   Most of these are active only
  66    in specific modes.  */
  67 static void cb_line_change (cpp_reader *, const cpp_token *, int);
  68 static void cb_define (cpp_reader *, source_location, cpp_hashnode *);
  69 static void cb_undef (cpp_reader *, source_location, cpp_hashnode *);
  70 static void cb_used_define (cpp_reader *, source_location, cpp_hashnode *);
  71 static void cb_used_undef (cpp_reader *, source_location, cpp_hashnode *);
  72 static void cb_include (cpp_reader *, source_location, const unsigned char *,
  73                         const char *, int, const cpp_token **);
  74 static void cb_ident (cpp_reader *, source_location, const cpp_string *);
  75 static void cb_def_pragma (cpp_reader *, source_location);
  76 static void cb_read_pch (cpp_reader *pfile, const char *name,
  77                          int fd, const char *orig_name);
  78
  79 /* Preprocess and output.  */
  80 void
  81 preprocess_file (cpp_reader *pfile)
  82 {
  83   /* A successful cpp_read_main_file guarantees that we can call
  84      cpp_scan_nooutput or cpp_get_token next.  */
  85   if (flag_no_output)
  86     {
  87       /* Scan -included buffers, then the main file.  */
  88       while (pfile->buffer->prev)
  89         cpp_scan_nooutput (pfile);
  90       cpp_scan_nooutput (pfile);
  91     }
  92   else if (cpp_get_options (pfile)->traditional)
  93     scan_translation_unit_trad (pfile);
  94   else if (cpp_get_options (pfile)->directives_only
  95            && !cpp_get_options (pfile)->preprocessed)
  96     scan_translation_unit_directives_only (pfile);
  97   else
  98     scan_translation_unit (pfile);
  99
 100   /* -dM command line option.  Should this be elsewhere?  */
 101   if (flag_dump_macros == 'M')
 102     cpp_forall_identifiers (pfile, dump_macro, NULL);
 103
 104   /* Flush any pending output.  */
 105   if (print.printed)
 106     putc ('\n', print.outf);
 107 }
 108
 109 /* Set up the callbacks as appropriate.  */
 110 void
 111 init_pp_output (FILE *out_stream)
 112 {
 113   cpp_callbacks *cb = cpp_get_callbacks (parse_in);
 114
 115   if (!flag_no_output)
 116     {
 117       cb->line_change = cb_line_change;
 118       /* Don't emit #pragma or #ident directives if we are processing
 119          assembly language; the assembler may choke on them.  */
 120       if (cpp_get_options (parse_in)->lang != CLK_ASM)
 121         {
 122           cb->ident      = cb_ident;
 123           cb->def_pragma = cb_def_pragma;
 124         }
 125     }
 126
 127   if (flag_dump_includes)
 128     cb->include  = cb_include;
 129
 130   if (flag_pch_preprocess)
 131     {
 132       cb->valid_pch = c_common_valid_pch;
 133       cb->read_pch = cb_read_pch;
 134     }
 135
 136   if (flag_dump_macros == 'N' || flag_dump_macros == 'D')
 137     {
 138       cb->define = cb_define;
 139       cb->undef  = cb_undef;
 140     }
 141
 142   if (flag_dump_macros == 'U')
 143     {
 144       cb->before_define = dump_queued_macros;
 145       cb->used_define = cb_used_define;
 146       cb->used_undef = cb_used_undef;
 147     }
 148
 149   /* Initialize the print structure.  */
 150   print.src_line = 1;
 151   print.printed = 0;
 152   print.prev = 0;
 153   print.outf = out_stream;
 154   print.first_time = 1;
 155 }
 156
 157 /* Writes out the preprocessed file, handling spacing and paste
 158    avoidance issues.  */
 159 static void
 160 scan_translation_unit (cpp_reader *pfile)
 161 {
 162   bool avoid_paste = false;
 163
 164   print.source = NULL;
 165   for (;;)
 166     {
 167       const cpp_token *token = cpp_get_token (pfile);
 168
 169       if (token->type == CPP_PADDING)
 170         {
 171           avoid_paste = true;
 172           if (print.source == NULL
 173               || (!(print.source->flags & PREV_WHITE)
 174                   && token->val.source == NULL))
 175             print.source = token->val.source;
 176           continue;
 177         }
 178
 179       if (token->type == CPP_EOF)
 180         break;
 181
 182       /* Subtle logic to output a space if and only if necessary.  */
 183       if (avoid_paste)
 184         {
 185           if (print.source == NULL)
 186             print.source = token;
 187           if (print.source->flags & PREV_WHITE
 188               || (print.prev
 189                   && cpp_avoid_paste (pfile, print.prev, token))
 190               || (print.prev == NULL && token->type == CPP_HASH))
 191             putc (' ', print.outf);
 192         }
 193       else if (token->flags & PREV_WHITE)
 194         putc (' ', print.outf);
 195
 196       avoid_paste = false;
 197       print.source = NULL;
 198       print.prev = token;
 199       if (token->type == CPP_PRAGMA)
 200         {
 201           const char *space;
 202           const char *name;
 203
 204           maybe_print_line (token->src_loc);
 205           fputs ("#pragma ", print.outf);
 206           c_pp_lookup_pragma (token->val.pragma, &space, &name);
 207           if (space)
 208             fprintf (print.outf, "%s %s", space, name);
 209           else
 210             fprintf (print.outf, "%s", name);
 211           print.printed = 1;
 212         }
 213       else if (token->type == CPP_PRAGMA_EOL)
 214         maybe_print_line (token->src_loc);
 215       else
 216         cpp_output_token (token, print.outf);
 217
 218       if (token->type == CPP_COMMENT)
 219         account_for_newlines (token->val.str.text, token->val.str.len);
 220     }
 221 }
 222
 223 static void
 224 print_lines_directives_only (int lines, const void *buf, size_t size)
 225 {
 226   print.src_line += lines;
 227   fwrite (buf, 1, size, print.outf);
 228 }
 229
 230 /* Writes out the preprocessed file, handling spacing and paste
 231    avoidance issues.  */
 232 static void
 233 scan_translation_unit_directives_only (cpp_reader *pfile)
 234 {
 235   struct _cpp_dir_only_callbacks cb;
 236
 237   cb.print_lines = print_lines_directives_only;
 238   cb.maybe_print_line = maybe_print_line;
 239
 240   _cpp_preprocess_dir_only (pfile, &cb);
 241 }
 242
 243 /* Adjust print.src_line for newlines embedded in output.  */
 244 static void
 245 account_for_newlines (const unsigned char *str, size_t len)
 246 {
 247   while (len--)
 248     if (*str++ == '\n')
 249       print.src_line++;
 250 }
 251
 252 /* Writes out a traditionally preprocessed file.  */
 253 static void
 254 scan_translation_unit_trad (cpp_reader *pfile)
 255 {
 256   while (_cpp_read_logical_line_trad (pfile))
 257     {
 258       size_t len = pfile->out.cur - pfile->out.base;
 259       maybe_print_line (pfile->out.first_line);
 260       fwrite (pfile->out.base, 1, len, print.outf);
 261       print.printed = 1;
 262       if (!CPP_OPTION (pfile, discard_comments))
 263         account_for_newlines (pfile->out.base, len);
 264     }
 265 }
 266
 267 /* If the token read on logical line LINE needs to be output on a
 268    different line to the current one, output the required newlines or
 269    a line marker, and return 1.  Otherwise return 0.  */
 270 static void
 271 maybe_print_line (source_location src_loc)
 272 {
 273   const struct line_map *map = linemap_lookup (line_table, src_loc);
 274   int src_line = SOURCE_LINE (map, src_loc);
 275   /* End the previous line of text.  */
 276   if (print.printed)
 277     {
 278       putc ('\n', print.outf);
 279       print.src_line++;
 280       print.printed = 0;
 281     }
 282
 283   if (src_line >= print.src_line && src_line < print.src_line + 8)
 284     {
 285       while (src_line > print.src_line)
 286         {
 287           putc ('\n', print.outf);
 288           print.src_line++;
 289         }
 290     }
 291   else
 292     print_line (src_loc, "");
 293 }
 294
 295 /* Output a line marker for logical line LINE.  Special flags are "1"
 296    or "2" indicating entering or leaving a file.  */
 297 static void
 298 print_line (source_location src_loc, const char *special_flags)
 299 {
 300   /* End any previous line of text.  */
 301   if (print.printed)
 302     putc ('\n', print.outf);
 303   print.printed = 0;
 304
 305   if (!flag_no_line_commands)
 306     {
 307       const struct line_map *map = linemap_lookup (line_table, src_loc);
 308
 309       size_t to_file_len = strlen (map->to_file);
 310       unsigned char *to_file_quoted =
 311          (unsigned char *) alloca (to_file_len * 4 + 1);
 312       unsigned char *p;
 313
 314       print.src_line = SOURCE_LINE (map, src_loc);
 315
 316       /* cpp_quote_string does not nul-terminate, so we have to do it
 317          ourselves.  */
 318       p = cpp_quote_string (to_file_quoted,
 319                             (const unsigned char *) map->to_file, to_file_len);
 320       *p = '\0';
 321       fprintf (print.outf, "# %u \"%s\"%s",
 322                print.src_line == 0 ? 1 : print.src_line,
 323                to_file_quoted, special_flags);
 324
 325       if (map->sysp == 2)
 326         fputs (" 3 4", print.outf);
 327       else if (map->sysp == 1)
 328         fputs (" 3", print.outf);
 329
 330       putc ('\n', print.outf);
 331     }
 332 }
 333
 334 /* Called when a line of output is started.  TOKEN is the first token
 335    of the line, and at end of file will be CPP_EOF.  */
 336 static void
 337 cb_line_change (cpp_reader *pfile, const cpp_token *token,
 338                 int parsing_args)
 339 {
 340   source_location src_loc = token->src_loc;
 341
 342   if (define_queue || undef_queue)
 343     dump_queued_macros (pfile);
 344
 345   if (token->type == CPP_EOF || parsing_args)
 346     return;
 347
 348   maybe_print_line (src_loc);
 349   print.prev = 0;
 350   print.source = 0;
 351
 352   /* Supply enough spaces to put this token in its original column,
 353      one space per column greater than 2, since scan_translation_unit
 354      will provide a space if PREV_WHITE.  Don't bother trying to
 355      reconstruct tabs; we can't get it right in general, and nothing
 356      ought to care.  Some things do care; the fault lies with them.  */
 357   if (!CPP_OPTION (pfile, traditional))
 358     {
 359       const struct line_map *map = linemap_lookup (line_table, src_loc);
 360       int spaces = SOURCE_COLUMN (map, src_loc) - 2;
 361       print.printed = 1;
 362
 363       while (-- spaces >= 0)
 364         putc (' ', print.outf);
 365     }
 366 }
 367
 368 static void
 369 cb_ident (cpp_reader *pfile ATTRIBUTE_UNUSED, source_location line,
 370           const cpp_string *str)
 371 {
 372   maybe_print_line (line);
 373   fprintf (print.outf, "#ident %s\n", str->text);
 374   print.src_line++;
 375 }
 376
 377 static void
 378 cb_define (cpp_reader *pfile, source_location line, cpp_hashnode *node)
 379 {
 380   maybe_print_line (line);
 381   fputs ("#define ", print.outf);
 382
 383   /* 'D' is whole definition; 'N' is name only.  */
 384   if (flag_dump_macros == 'D')
 385     fputs ((const char *) cpp_macro_definition (pfile, node),
 386            print.outf);
 387   else
 388     fputs ((const char *) NODE_NAME (node), print.outf);
 389
 390   putc ('\n', print.outf);
 391   if (linemap_lookup (line_table, line)->to_line != 0)
 392     print.src_line++;
 393 }
 394
 395 static void
 396 cb_undef (cpp_reader *pfile ATTRIBUTE_UNUSED, source_location line,
 397           cpp_hashnode *node)
 398 {
 399   maybe_print_line (line);
 400   fprintf (print.outf, "#undef %s\n", NODE_NAME (node));
 401   print.src_line++;
 402 }
 403
 404 static void
 405 cb_used_define (cpp_reader *pfile, source_location line ATTRIBUTE_UNUSED,
 406                 cpp_hashnode *node)
 407 {
 408   macro_queue *q;
 409   if (node->flags & NODE_BUILTIN)
 410     return;
 411   q = XNEW (macro_queue);
 412   q->macro = xstrdup ((const char *) cpp_macro_definition (pfile, node));
 413   q->next = define_queue;
 414   define_queue = q;
 415 }
 416
 417 static void
 418 cb_used_undef (cpp_reader *pfile ATTRIBUTE_UNUSED,
 419                source_location line ATTRIBUTE_UNUSED,
 420                cpp_hashnode *node)
 421 {
 422   macro_queue *q;
 423   q = XNEW (macro_queue);
 424   q->macro = xstrdup ((const char *) NODE_NAME (node));
 425   q->next = undef_queue;
 426   undef_queue = q;
 427 }
 428
 429 static void
 430 dump_queued_macros (cpp_reader *pfile ATTRIBUTE_UNUSED)
 431 {
 432   macro_queue *q;
 433
 434   /* End the previous line of text.  */
 435   if (print.printed)
 436     {
 437       putc ('\n', print.outf);
 438       print.src_line++;
 439       print.printed = 0;
 440     }
 441
 442   for (q = define_queue; q;)
 443     {
 444       macro_queue *oq;
 445       fputs ("#define ", print.outf);
 446       fputs (q->macro, print.outf);
 447       putc ('\n', print.outf);
 448       print.src_line++;
 449       oq = q;
 450       q = q->next;
 451       free (oq->macro);
 452       free (oq);
 453     }
 454   define_queue = NULL;
 455   for (q = undef_queue; q;)
 456     {
 457       macro_queue *oq;
 458       fprintf (print.outf, "#undef %s\n", q->macro);
 459       print.src_line++;
 460       oq = q;
 461       q = q->next;
 462       free (oq->macro);
 463       free (oq);
 464     }
 465   undef_queue = NULL;
 466 }
 467
 468 static void
 469 cb_include (cpp_reader *pfile ATTRIBUTE_UNUSED, source_location line,
 470             const unsigned char *dir, const char *header, int angle_brackets,
 471             const cpp_token **comments)
 472 {
 473   maybe_print_line (line);
 474   if (angle_brackets)
 475     fprintf (print.outf, "#%s <%s>", dir, header);
 476   else
 477     fprintf (print.outf, "#%s \"%s\"", dir, header);
 478
 479   if (comments != NULL)
 480     {
 481       while (*comments != NULL)
 482         {
 483           if ((*comments)->flags & PREV_WHITE)
 484             putc (' ', print.outf);
 485           cpp_output_token (*comments, print.outf);
 486           ++comments;
 487         }
 488     }
 489
 490   putc ('\n', print.outf);
 491   print.src_line++;
 492 }
 493
 494 /* Callback called when -fworking-director and -E to emit working
 495    directory in cpp output file.  */
 496
 497 void
 498 pp_dir_change (cpp_reader *pfile ATTRIBUTE_UNUSED, const char *dir)
 499 {
 500   size_t to_file_len = strlen (dir);
 501   unsigned char *to_file_quoted =
 502      (unsigned char *) alloca (to_file_len * 4 + 1);
 503   unsigned char *p;
 504
 505   /* cpp_quote_string does not nul-terminate, so we have to do it ourselves.  */
 506   p = cpp_quote_string (to_file_quoted, (const unsigned char *) dir, to_file_len);
 507   *p = '\0';
 508   fprintf (print.outf, "# 1 \"%s//\"\n", to_file_quoted);
 509 }
 510
 511 /* The file name, line number or system header flags have changed, as
 512    described in MAP.  */
 513
 514 void
 515 pp_file_change (const struct line_map *map)
 516 {
 517   const char *flags = "";
 518
 519   if (flag_no_line_commands)
 520     return;
 521
 522   if (map != NULL)
 523     {
 524       if (print.first_time)
 525         {
 526           /* Avoid printing foo.i when the main file is foo.c.  */
 527           if (!cpp_get_options (parse_in)->preprocessed)
 528             print_line (map->start_location, flags);
 529           print.first_time = 0;
 530         }
 531       else
 532         {
 533           /* Bring current file to correct line when entering a new file.  */
 534           if (map->reason == LC_ENTER)
 535             {
 536               const struct line_map *from = INCLUDED_FROM (line_table, map);
 537               maybe_print_line (LAST_SOURCE_LINE_LOCATION (from));
 538             }
 539           if (map->reason == LC_ENTER)
 540             flags = " 1";
 541           else if (map->reason == LC_LEAVE)
 542             flags = " 2";
 543           print_line (map->start_location, flags);
 544         }
 545     }
 546 }
 547
 548 /* Copy a #pragma directive to the preprocessed output.  */
 549 static void
 550 cb_def_pragma (cpp_reader *pfile, source_location line)
 551 {
 552   maybe_print_line (line);
 553   fputs ("#pragma ", print.outf);
 554   cpp_output_line (pfile, print.outf);
 555   print.src_line++;
 556 }
 557
 558 /* Dump out the hash table.  */
 559 static int
 560 dump_macro (cpp_reader *pfile, cpp_hashnode *node, void *v ATTRIBUTE_UNUSED)
 561 {
 562   if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
 563     {
 564       fputs ("#define ", print.outf);
 565       fputs ((const char *) cpp_macro_definition (pfile, node),
 566              print.outf);
 567       putc ('\n', print.outf);
 568       print.src_line++;
 569     }
 570
 571   return 1;
 572 }
 573
 574 /* Load in the PCH file NAME, open on FD.  It was originally searched for
 575    by ORIG_NAME.  Also, print out a #include command so that the PCH
 576    file can be loaded when the preprocessed output is compiled.  */
 577
 578 static void
 579 cb_read_pch (cpp_reader *pfile, const char *name,
 580              int fd, const char *orig_name ATTRIBUTE_UNUSED)
 581 {
 582   c_common_read_pch (pfile, name, fd, orig_name);
 583
 584   fprintf (print.outf, "#pragma GCC pch_preprocess \"%s\"\n", name);
 585   print.src_line++;
 586 }