OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [libcpp/] [directives-only.c] - Blame information for rev 280

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.