libcpp/directives-only.c

   1 /* CPP Library - directive only preprocessing for distributed compilation.
   2    Copyright (C) 2007-2019 Free Software Foundation, Inc.
   3    Contributed by Ollie Wild <aaw@google.com>.
   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 3, 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; see the file COPYING3.  If not see
  17 <http://www.gnu.org/licenses/>.  */
  18
  19 #include "config.h"
  20 #include "system.h"
  21 #include "cpplib.h"
  22 #include "internal.h"
  23
  24 /* DO (Directive only) flags. */
  25 #define DO_BOL           (1 << 0) /* At the beginning of a logical line. */
  26 #define DO_STRING        (1 << 1) /* In a string constant. */
  27 #define DO_CHAR          (1 << 2) /* In a character constant. */
  28 #define DO_BLOCK_COMMENT (1 << 3) /* In a block comment. */
  29 #define DO_LINE_COMMENT  (1 << 4) /* In a single line "//-style" comment. */
  30
  31 #define DO_LINE_SPECIAL (DO_STRING | DO_CHAR | DO_LINE_COMMENT)
  32 #define DO_SPECIAL      (DO_LINE_SPECIAL | DO_BLOCK_COMMENT)
  33
  34 /* Writes out the preprocessed file, handling spacing and paste
  35    avoidance issues.  */
  36 void
  37 _cpp_preprocess_dir_only (cpp_reader *pfile,
  38                           const struct _cpp_dir_only_callbacks *cb)
  39 {
  40   struct cpp_buffer *buffer;
  41   const unsigned char *cur, *base, *next_line, *rlimit;
  42   cppchar_t c, last_c;
  43   unsigned flags;
  44   linenum_type lines;
  45   int col;
  46   location_t loc;
  47
  48  restart:
  49   /* Buffer initialization ala _cpp_clean_line(). */
  50   buffer = pfile->buffer;
  51   buffer->cur_note = buffer->notes_used = 0;
  52   buffer->cur = buffer->line_base = buffer->next_line;
  53   buffer->need_line = false;
  54
  55   /* This isn't really needed.  It prevents a compiler warning, though. */
  56   loc = pfile->line_table->highest_line;
  57
  58   /* Scan initialization. */
  59   next_line = cur = base = buffer->cur;
  60   rlimit = buffer->rlimit;
  61   flags = DO_BOL;
  62   lines = 0;
  63   col = 1;
  64
  65   for (last_c = '\n', c = *cur; cur < rlimit; last_c = c, c = *++cur, ++col)
  66     {
  67       /* Skip over escaped newlines. */
  68       if (__builtin_expect (c == '\\', false))
  69         {
  70           const unsigned char *tmp = cur + 1;
  71
  72           while (is_nvspace (*tmp) && tmp < rlimit)
  73             tmp++;
  74           if (*tmp == '\r')
  75             tmp++;
  76           if (*tmp == '\n' && tmp < rlimit)
  77             {
  78               CPP_INCREMENT_LINE (pfile, 0);
  79               lines++;
  80               col = 0;
  81               cur = tmp;
  82               c = last_c;
  83               continue;
  84             }
  85         }
  86
  87       if (__builtin_expect (last_c == '#', false) && !(flags & DO_SPECIAL))
  88         {
  89           if (c != '#' && (flags & DO_BOL))
  90           {
  91             struct line_maps *line_table;
  92
  93             if (!pfile->state.skipping && next_line != base)
  94               cb->print_lines (lines, base, next_line - base);
  95
  96             /* Prep things for directive handling. */
  97             buffer->next_line = cur;
  98             buffer->need_line = true;
  99             _cpp_get_fresh_line (pfile);
 100
 101             /* Ensure proper column numbering for generated error messages. */
 102             buffer->line_base -= col - 1;
 103
 104             _cpp_handle_directive (pfile, 0 /* ignore indented */);
 105
 106             /* Sanitize the line settings.  Duplicate #include's can mess
 107                things up. */
 108             line_table = pfile->line_table;
 109             line_table->highest_location = line_table->highest_line;
 110
 111             /* The if block prevents us from outputing line information when
 112                the file ends with a directive and no newline.  Note that we
 113                must use pfile->buffer, not buffer. */
 114             if (pfile->buffer->next_line < pfile->buffer->rlimit)
 115               cb->maybe_print_line (pfile->line_table->highest_line);
 116
 117             goto restart;
 118           }
 119
 120           flags &= ~DO_BOL;
 121           pfile->mi_valid = false;
 122         }
 123       else if (__builtin_expect (last_c == '/', false) \
 124                && !(flags & DO_SPECIAL) && c != '*' && c != '/')
 125         {
 126           /* If a previous slash is not starting a block comment, clear the
 127              DO_BOL flag.  */
 128           flags &= ~DO_BOL;
 129           pfile->mi_valid = false;
 130         }
 131
 132       switch (c)
 133         {
 134         case '/':
 135           if ((flags & DO_BLOCK_COMMENT) && last_c == '*')
 136             {
 137               flags &= ~DO_BLOCK_COMMENT;
 138               c = 0;
 139             }
 140           else if (!(flags & DO_SPECIAL) && last_c == '/')
 141             flags |= DO_LINE_COMMENT;
 142           else if (!(flags & DO_SPECIAL))
 143             /* Mark the position for possible error reporting. */
 144             loc = linemap_position_for_column (pfile->line_table, col);
 145
 146           break;
 147
 148         case '*':
 149           if (!(flags & DO_SPECIAL))
 150             {
 151               if (last_c == '/')
 152                 flags |= DO_BLOCK_COMMENT;
 153               else
 154                 {
 155                   flags &= ~DO_BOL;
 156                   pfile->mi_valid = false;
 157                 }
 158             }
 159
 160           break;
 161
 162         case '\'':
 163         case '"':
 164           {
 165             unsigned state = (c == '"') ? DO_STRING : DO_CHAR;
 166
 167             if (!(flags & DO_SPECIAL))
 168               {
 169                 flags |= state;
 170                 flags &= ~DO_BOL;
 171                 pfile->mi_valid = false;
 172               }
 173             else if ((flags & state) && last_c != '\\')
 174               flags &= ~state;
 175
 176             break;
 177           }
 178
 179         case '\\':
 180           {
 181             if ((flags & (DO_STRING | DO_CHAR)) && last_c == '\\')
 182               c = 0;
 183
 184             if (!(flags & DO_SPECIAL))
 185               {
 186                 flags &= ~DO_BOL;
 187                 pfile->mi_valid = false;
 188               }
 189
 190             break;
 191           }
 192
 193         case '\n':
 194           CPP_INCREMENT_LINE (pfile, 0);
 195           lines++;
 196           col = 0;
 197           flags &= ~DO_LINE_SPECIAL;
 198           if (!(flags & DO_SPECIAL))
 199             flags |= DO_BOL;
 200           break;
 201
 202         case '#':
 203           next_line = cur;
 204           /* Don't update DO_BOL yet. */
 205           break;
 206
 207         case ' ': case '\t': case '\f': case '\v': case '\0':
 208           break;
 209
 210         default:
 211           if (!(flags & DO_SPECIAL))
 212             {
 213               flags &= ~DO_BOL;
 214               pfile->mi_valid = false;
 215             }
 216           break;
 217         }
 218     }
 219
 220   if (flags & DO_BLOCK_COMMENT)
 221     cpp_error_with_line (pfile, CPP_DL_ERROR, loc, 0, "unterminated comment");
 222
 223   if (!pfile->state.skipping && cur != base)
 224     {
 225       /* If the file was not newline terminated, add rlimit, which is
 226          guaranteed to point to a newline, to the end of our range.  */
 227       if (cur[-1] != '\n')
 228         {
 229           cur++;
 230           CPP_INCREMENT_LINE (pfile, 0);
 231           lines++;
 232         }
 233
 234       cb->print_lines (lines, base, cur - base);
 235     }
 236
 237   _cpp_pop_buffer (pfile);
 238   if (pfile->buffer)
 239     goto restart;
 240 }