]>
Commit | Line | Data |
---|---|---|
fcde64dc | 1 | /* CPP Library - directive only preprocessing for distributed compilation. |
fbd26352 | 2 | Copyright (C) 2007-2019 Free Software Foundation, Inc. |
fcde64dc | 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 | |
6bc9506f | 7 | Free Software Foundation; either version 3, or (at your option) any |
fcde64dc | 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 | |
6bc9506f | 16 | along with this program; see the file COPYING3. If not see |
17 | <http://www.gnu.org/licenses/>. */ | |
fcde64dc | 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; | |
4999c35b | 44 | linenum_type lines; |
45 | int col; | |
be1e7283 | 46 | location_t loc; |
fcde64dc | 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. */ | |
80ea6373 | 144 | loc = linemap_position_for_column (pfile->line_table, col); |
fcde64dc | 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 | } |