|
0
|
1 /* Map logical line numbers to (source file, line number) pairs.
|
|
|
2 Copyright (C) 2001, 2003, 2004, 2007, 2008, 2009
|
|
|
3 Free Software Foundation, Inc.
|
|
|
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 In other words, you are welcome to use, share and improve this program.
|
|
|
20 You are forbidden to forbid anyone else to use, share and improve
|
|
|
21 what you give them. Help stamp out software-hoarding! */
|
|
|
22
|
|
|
23 #include "config.h"
|
|
|
24 #include "system.h"
|
|
|
25 #include "line-map.h"
|
|
|
26
|
|
|
27 static void trace_include (const struct line_maps *, const struct line_map *);
|
|
|
28
|
|
|
29 /* Initialize a line map set. */
|
|
|
30
|
|
|
31 void
|
|
|
32 linemap_init (struct line_maps *set)
|
|
|
33 {
|
|
|
34 set->maps = NULL;
|
|
|
35 set->allocated = 0;
|
|
|
36 set->used = 0;
|
|
|
37 set->last_listed = -1;
|
|
|
38 set->trace_includes = false;
|
|
|
39 set->depth = 0;
|
|
|
40 set->cache = 0;
|
|
|
41 set->highest_location = 0;
|
|
|
42 set->highest_line = 0;
|
|
|
43 set->max_column_hint = 0;
|
|
|
44 }
|
|
|
45
|
|
|
46 /* Check for and warn about line_maps entered but not exited. */
|
|
|
47
|
|
|
48 void
|
|
|
49 linemap_check_files_exited (struct line_maps *set)
|
|
|
50 {
|
|
|
51 struct line_map *map;
|
|
|
52 /* Depending upon whether we are handling preprocessed input or
|
|
|
53 not, this can be a user error or an ICE. */
|
|
|
54 for (map = &set->maps[set->used - 1]; ! MAIN_FILE_P (map);
|
|
|
55 map = INCLUDED_FROM (set, map))
|
|
|
56 fprintf (stderr, "line-map.c: file \"%s\" entered but not left\n",
|
|
|
57 map->to_file);
|
|
|
58 }
|
|
|
59
|
|
|
60 /* Free a line map set. */
|
|
|
61
|
|
|
62 void
|
|
|
63 linemap_free (struct line_maps *set)
|
|
|
64 {
|
|
|
65 if (set->maps)
|
|
|
66 {
|
|
|
67 linemap_check_files_exited (set);
|
|
|
68
|
|
|
69 free (set->maps);
|
|
|
70 }
|
|
|
71 }
|
|
|
72
|
|
|
73 /* Add a mapping of logical source line to physical source file and
|
|
|
74 line number.
|
|
|
75
|
|
|
76 The text pointed to by TO_FILE must have a lifetime
|
|
|
77 at least as long as the final call to lookup_line (). An empty
|
|
|
78 TO_FILE means standard input. If reason is LC_LEAVE, and
|
|
|
79 TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their
|
|
|
80 natural values considering the file we are returning to.
|
|
|
81
|
|
|
82 FROM_LINE should be monotonic increasing across calls to this
|
|
|
83 function. A call to this function can relocate the previous set of
|
|
|
84 maps, so any stored line_map pointers should not be used. */
|
|
|
85
|
|
|
86 const struct line_map *
|
|
|
87 linemap_add (struct line_maps *set, enum lc_reason reason,
|
|
|
88 unsigned int sysp, const char *to_file, linenum_type to_line)
|
|
|
89 {
|
|
|
90 struct line_map *map;
|
|
|
91 source_location start_location = set->highest_location + 1;
|
|
|
92
|
|
|
93 if (set->used && start_location < set->maps[set->used - 1].start_location)
|
|
|
94 abort ();
|
|
|
95
|
|
|
96 if (set->used == set->allocated)
|
|
|
97 {
|
|
|
98 line_map_realloc reallocator
|
|
|
99 = set->reallocator ? set->reallocator : xrealloc;
|
|
|
100 set->allocated = 2 * set->allocated + 256;
|
|
|
101 set->maps
|
|
|
102 = (struct line_map *) (*reallocator) (set->maps,
|
|
|
103 set->allocated
|
|
|
104 * sizeof (struct line_map));
|
|
|
105 memset (&set->maps[set->used], 0, ((set->allocated - set->used)
|
|
|
106 * sizeof (struct line_map)));
|
|
|
107 }
|
|
|
108
|
|
|
109 map = &set->maps[set->used];
|
|
|
110
|
|
|
111 if (to_file && *to_file == '\0')
|
|
|
112 to_file = "<stdin>";
|
|
|
113
|
|
|
114 /* If we don't keep our line maps consistent, we can easily
|
|
|
115 segfault. Don't rely on the client to do it for us. */
|
|
|
116 if (set->depth == 0)
|
|
|
117 reason = LC_ENTER;
|
|
|
118 else if (reason == LC_LEAVE)
|
|
|
119 {
|
|
|
120 struct line_map *from;
|
|
|
121 bool error;
|
|
|
122
|
|
|
123 if (MAIN_FILE_P (map - 1))
|
|
|
124 {
|
|
|
125 if (to_file == NULL)
|
|
|
126 {
|
|
|
127 set->depth--;
|
|
|
128 return NULL;
|
|
|
129 }
|
|
|
130 error = true;
|
|
|
131 reason = LC_RENAME;
|
|
|
132 from = map - 1;
|
|
|
133 }
|
|
|
134 else
|
|
|
135 {
|
|
|
136 from = INCLUDED_FROM (set, map - 1);
|
|
|
137 error = to_file && strcmp (from->to_file, to_file);
|
|
|
138 }
|
|
|
139
|
|
|
140 /* Depending upon whether we are handling preprocessed input or
|
|
|
141 not, this can be a user error or an ICE. */
|
|
|
142 if (error)
|
|
|
143 fprintf (stderr, "line-map.c: file \"%s\" left but not entered\n",
|
|
|
144 to_file);
|
|
|
145
|
|
|
146 /* A TO_FILE of NULL is special - we use the natural values. */
|
|
|
147 if (error || to_file == NULL)
|
|
|
148 {
|
|
|
149 to_file = from->to_file;
|
|
|
150 to_line = SOURCE_LINE (from, from[1].start_location);
|
|
|
151 sysp = from->sysp;
|
|
|
152 }
|
|
|
153 }
|
|
|
154
|
|
|
155 map->reason = reason;
|
|
|
156 map->sysp = sysp;
|
|
|
157 map->start_location = start_location;
|
|
|
158 map->to_file = to_file;
|
|
|
159 map->to_line = to_line;
|
|
|
160 set->cache = set->used++;
|
|
|
161 map->column_bits = 0;
|
|
|
162 set->highest_location = start_location;
|
|
|
163 set->highest_line = start_location;
|
|
|
164 set->max_column_hint = 0;
|
|
|
165
|
|
|
166 if (reason == LC_ENTER)
|
|
|
167 {
|
|
|
168 map->included_from = set->depth == 0 ? -1 : (int) (set->used - 2);
|
|
|
169 set->depth++;
|
|
|
170 if (set->trace_includes)
|
|
|
171 trace_include (set, map);
|
|
|
172 }
|
|
|
173 else if (reason == LC_RENAME)
|
|
|
174 map->included_from = map[-1].included_from;
|
|
|
175 else if (reason == LC_LEAVE)
|
|
|
176 {
|
|
|
177 set->depth--;
|
|
|
178 map->included_from = INCLUDED_FROM (set, map - 1)->included_from;
|
|
|
179 }
|
|
|
180
|
|
|
181 return map;
|
|
|
182 }
|
|
|
183
|
|
|
184 source_location
|
|
|
185 linemap_line_start (struct line_maps *set, linenum_type to_line,
|
|
|
186 unsigned int max_column_hint)
|
|
|
187 {
|
|
|
188 struct line_map *map = &set->maps[set->used - 1];
|
|
|
189 source_location highest = set->highest_location;
|
|
|
190 source_location r;
|
|
|
191 linenum_type last_line = SOURCE_LINE (map, set->highest_line);
|
|
|
192 int line_delta = to_line - last_line;
|
|
|
193 bool add_map = false;
|
|
|
194 if (line_delta < 0
|
|
|
195 || (line_delta > 10 && line_delta * map->column_bits > 1000)
|
|
|
196 || (max_column_hint >= (1U << map->column_bits))
|
|
|
197 || (max_column_hint <= 80 && map->column_bits >= 10))
|
|
|
198 {
|
|
|
199 add_map = true;
|
|
|
200 }
|
|
|
201 else
|
|
|
202 max_column_hint = set->max_column_hint;
|
|
|
203 if (add_map)
|
|
|
204 {
|
|
|
205 int column_bits;
|
|
|
206 if (max_column_hint > 100000 || highest > 0xC0000000)
|
|
|
207 {
|
|
|
208 /* If the column number is ridiculous or we've allocated a huge
|
|
|
209 number of source_locations, give up on column numbers. */
|
|
|
210 max_column_hint = 0;
|
|
|
211 if (highest >0xF0000000)
|
|
|
212 return 0;
|
|
|
213 column_bits = 0;
|
|
|
214 }
|
|
|
215 else
|
|
|
216 {
|
|
|
217 column_bits = 7;
|
|
|
218 while (max_column_hint >= (1U << column_bits))
|
|
|
219 column_bits++;
|
|
|
220 max_column_hint = 1U << column_bits;
|
|
|
221 }
|
|
|
222 /* Allocate the new line_map. However, if the current map only has a
|
|
|
223 single line we can sometimes just increase its column_bits instead. */
|
|
|
224 if (line_delta < 0
|
|
|
225 || last_line != map->to_line
|
|
|
226 || SOURCE_COLUMN (map, highest) >= (1U << column_bits))
|
|
|
227 map = (struct line_map *) linemap_add (set, LC_RENAME, map->sysp,
|
|
|
228 map->to_file, to_line);
|
|
|
229 map->column_bits = column_bits;
|
|
|
230 r = map->start_location + ((to_line - map->to_line) << column_bits);
|
|
|
231 }
|
|
|
232 else
|
|
|
233 r = highest - SOURCE_COLUMN (map, highest)
|
|
|
234 + (line_delta << map->column_bits);
|
|
|
235 set->highest_line = r;
|
|
|
236 if (r > set->highest_location)
|
|
|
237 set->highest_location = r;
|
|
|
238 set->max_column_hint = max_column_hint;
|
|
|
239 return r;
|
|
|
240 }
|
|
|
241
|
|
|
242 source_location
|
|
|
243 linemap_position_for_column (struct line_maps *set, unsigned int to_column)
|
|
|
244 {
|
|
|
245 source_location r = set->highest_line;
|
|
|
246 if (to_column >= set->max_column_hint)
|
|
|
247 {
|
|
|
248 if (r >= 0xC000000 || to_column > 100000)
|
|
|
249 {
|
|
|
250 /* Running low on source_locations - disable column numbers. */
|
|
|
251 return r;
|
|
|
252 }
|
|
|
253 else
|
|
|
254 {
|
|
|
255 struct line_map *map = &set->maps[set->used - 1];
|
|
|
256 r = linemap_line_start (set, SOURCE_LINE (map, r), to_column + 50);
|
|
|
257 }
|
|
|
258 }
|
|
|
259 r = r + to_column;
|
|
|
260 if (r >= set->highest_location)
|
|
|
261 set->highest_location = r;
|
|
|
262 return r;
|
|
|
263 }
|
|
|
264
|
|
|
265 /* Given a logical line, returns the map from which the corresponding
|
|
|
266 (source file, line) pair can be deduced. Since the set is built
|
|
|
267 chronologically, the logical lines are monotonic increasing, and so
|
|
|
268 the list is sorted and we can use a binary search. */
|
|
|
269
|
|
|
270 const struct line_map *
|
|
|
271 linemap_lookup (struct line_maps *set, source_location line)
|
|
|
272 {
|
|
|
273 unsigned int md, mn, mx;
|
|
|
274 const struct line_map *cached;
|
|
|
275
|
|
|
276 mn = set->cache;
|
|
|
277 mx = set->used;
|
|
|
278
|
|
|
279 cached = &set->maps[mn];
|
|
|
280 /* We should get a segfault if no line_maps have been added yet. */
|
|
|
281 if (line >= cached->start_location)
|
|
|
282 {
|
|
|
283 if (mn + 1 == mx || line < cached[1].start_location)
|
|
|
284 return cached;
|
|
|
285 }
|
|
|
286 else
|
|
|
287 {
|
|
|
288 mx = mn;
|
|
|
289 mn = 0;
|
|
|
290 }
|
|
|
291
|
|
|
292 while (mx - mn > 1)
|
|
|
293 {
|
|
|
294 md = (mn + mx) / 2;
|
|
|
295 if (set->maps[md].start_location > line)
|
|
|
296 mx = md;
|
|
|
297 else
|
|
|
298 mn = md;
|
|
|
299 }
|
|
|
300
|
|
|
301 set->cache = mn;
|
|
|
302 return &set->maps[mn];
|
|
|
303 }
|
|
|
304
|
|
|
305 /* Print the file names and line numbers of the #include commands
|
|
|
306 which led to the map MAP, if any, to stderr. Nothing is output if
|
|
|
307 the most recently listed stack is the same as the current one. */
|
|
|
308
|
|
|
309 void
|
|
|
310 linemap_print_containing_files (struct line_maps *set,
|
|
|
311 const struct line_map *map)
|
|
|
312 {
|
|
|
313 if (MAIN_FILE_P (map) || set->last_listed == map->included_from)
|
|
|
314 return;
|
|
|
315
|
|
|
316 set->last_listed = map->included_from;
|
|
|
317 map = INCLUDED_FROM (set, map);
|
|
|
318
|
|
|
319 fprintf (stderr, _("In file included from %s:%u"),
|
|
|
320 map->to_file, LAST_SOURCE_LINE (map));
|
|
|
321
|
|
|
322 while (! MAIN_FILE_P (map))
|
|
|
323 {
|
|
|
324 map = INCLUDED_FROM (set, map);
|
|
|
325 /* Translators note: this message is used in conjunction
|
|
|
326 with "In file included from %s:%ld" and some other
|
|
|
327 tricks. We want something like this:
|
|
|
328
|
|
|
329 | In file included from sys/select.h:123,
|
|
|
330 | from sys/types.h:234,
|
|
|
331 | from userfile.c:31:
|
|
|
332 | bits/select.h:45: <error message here>
|
|
|
333
|
|
|
334 with all the "from"s lined up.
|
|
|
335 The trailing comma is at the beginning of this message,
|
|
|
336 and the trailing colon is not translated. */
|
|
|
337 fprintf (stderr, _(",\n from %s:%u"),
|
|
|
338 map->to_file, LAST_SOURCE_LINE (map));
|
|
|
339 }
|
|
|
340
|
|
|
341 fputs (":\n", stderr);
|
|
|
342 }
|
|
|
343
|
|
|
344 /* Print an include trace, for e.g. the -H option of the preprocessor. */
|
|
|
345
|
|
|
346 static void
|
|
|
347 trace_include (const struct line_maps *set, const struct line_map *map)
|
|
|
348 {
|
|
|
349 unsigned int i = set->depth;
|
|
|
350
|
|
|
351 while (--i)
|
|
|
352 putc ('.', stderr);
|
|
|
353 fprintf (stderr, " %s\n", map->to_file);
|
|
|
354 }
|
