]>
Commit | Line | Data |
---|---|---|
ccfc4c91 OW |
1 | /* CPP Library - directive only preprocessing for distributed compilation. |
2 | Copyright (C) 2007 | |
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 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ | |
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; | |
1bb64668 MLI |
45 | linenum_type lines; |
46 | int col; | |
ccfc4c91 OW |
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 | } |