|
0
|
1 /* Map logical line numbers to (source file, line number) pairs.
|
|
|
2 Copyright (C) 2001, 2003, 2004, 2007, 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 #ifndef LIBCPP_LINE_MAP_H
|
|
|
24 #define LIBCPP_LINE_MAP_H
|
|
|
25
|
|
|
26 #ifndef GTY
|
|
|
27 #define GTY(x) /* nothing */
|
|
|
28 #endif
|
|
|
29
|
|
|
30 /* Reason for adding a line change with add_line_map (). LC_ENTER is
|
|
|
31 when including a new file, e.g. a #include directive in C.
|
|
|
32 LC_LEAVE is when reaching a file's end. LC_RENAME is when a file
|
|
|
33 name or line number changes for neither of the above reasons
|
|
|
34 (e.g. a #line directive in C). */
|
|
|
35 enum lc_reason {LC_ENTER = 0, LC_LEAVE, LC_RENAME};
|
|
|
36
|
|
|
37 /* The type of line numbers. */
|
|
|
38 typedef unsigned int linenum_type;
|
|
|
39
|
|
|
40 /* A logical line/column number, i.e. an "index" into a line_map. */
|
|
|
41 /* Long-term, we want to use this to replace struct location_s (in input.h),
|
|
|
42 and effectively typedef source_location location_t. */
|
|
|
43 typedef unsigned int source_location;
|
|
|
44
|
|
|
45 /* Memory allocation function typedef. Works like xrealloc. */
|
|
|
46 typedef void *(*line_map_realloc) (void *, size_t);
|
|
|
47
|
|
|
48 /* Physical source file TO_FILE at line TO_LINE at column 0 is represented
|
|
|
49 by the logical START_LOCATION. TO_LINE+L at column C is represented by
|
|
|
50 START_LOCATION+(L*(1<<column_bits))+C, as long as C<(1<<column_bits),
|
|
|
51 and the result_location is less than the next line_map's start_location.
|
|
|
52 (The top line is line 1 and the leftmost column is column 1; line/column 0
|
|
|
53 means "entire file/line" or "unknown line/column" or "not applicable".)
|
|
|
54 INCLUDED_FROM is an index into the set that gives the line mapping
|
|
|
55 at whose end the current one was included. File(s) at the bottom
|
|
|
56 of the include stack have this set to -1. REASON is the reason for
|
|
|
57 creation of this line map, SYSP is one for a system header, two for
|
|
|
58 a C system header file that therefore needs to be extern "C"
|
|
|
59 protected in C++, and zero otherwise. */
|
|
|
60 struct line_map GTY(())
|
|
|
61 {
|
|
|
62 const char *to_file;
|
|
|
63 linenum_type to_line;
|
|
|
64 source_location start_location;
|
|
|
65 int included_from;
|
|
|
66 ENUM_BITFIELD (lc_reason) reason : CHAR_BIT;
|
|
|
67 /* The sysp field isn't really needed now that it's in cpp_buffer. */
|
|
|
68 unsigned char sysp;
|
|
|
69 /* Number of the low-order source_location bits used for a column number. */
|
|
|
70 unsigned int column_bits : 8;
|
|
|
71 };
|
|
|
72
|
|
|
73 /* A set of chronological line_map structures. */
|
|
|
74 struct line_maps GTY(())
|
|
|
75 {
|
|
|
76 struct line_map * GTY ((length ("%h.used"))) maps;
|
|
|
77 unsigned int allocated;
|
|
|
78 unsigned int used;
|
|
|
79
|
|
|
80 unsigned int cache;
|
|
|
81
|
|
|
82 /* The most recently listed include stack, if any, starts with
|
|
|
83 LAST_LISTED as the topmost including file. -1 indicates nothing
|
|
|
84 has been listed yet. */
|
|
|
85 int last_listed;
|
|
|
86
|
|
|
87 /* Depth of the include stack, including the current file. */
|
|
|
88 unsigned int depth;
|
|
|
89
|
|
|
90 /* If true, prints an include trace a la -H. */
|
|
|
91 bool trace_includes;
|
|
|
92
|
|
|
93 /* Highest source_location "given out". */
|
|
|
94 source_location highest_location;
|
|
|
95
|
|
|
96 /* Start of line of highest source_location "given out". */
|
|
|
97 source_location highest_line;
|
|
|
98
|
|
|
99 /* The maximum column number we can quickly allocate. Higher numbers
|
|
|
100 may require allocating a new line_map. */
|
|
|
101 unsigned int max_column_hint;
|
|
|
102
|
|
|
103 /* If non-null, the allocator to use when resizing 'maps'. If null,
|
|
|
104 xrealloc is used. */
|
|
|
105 line_map_realloc reallocator;
|
|
|
106 };
|
|
|
107
|
|
|
108 /* Initialize a line map set. */
|
|
|
109 extern void linemap_init (struct line_maps *);
|
|
|
110
|
|
|
111 /* Free a line map set. */
|
|
|
112 extern void linemap_free (struct line_maps *);
|
|
|
113
|
|
|
114 /* Check for and warn about line_maps entered but not exited. */
|
|
|
115
|
|
|
116 extern void linemap_check_files_exited (struct line_maps *);
|
|
|
117
|
|
|
118 /* Return a source_location for the start (i.e. column==0) of
|
|
|
119 (physical) line TO_LINE in the current source file (as in the
|
|
|
120 most recent linemap_add). MAX_COLUMN_HINT is the highest column
|
|
|
121 number we expect to use in this line (but it does not change
|
|
|
122 the highest_location). */
|
|
|
123
|
|
|
124 extern source_location linemap_line_start
|
|
|
125 (struct line_maps *set, linenum_type to_line, unsigned int max_column_hint);
|
|
|
126
|
|
|
127 /* Add a mapping of logical source line to physical source file and
|
|
|
128 line number.
|
|
|
129
|
|
|
130 The text pointed to by TO_FILE must have a lifetime
|
|
|
131 at least as long as the final call to lookup_line (). An empty
|
|
|
132 TO_FILE means standard input. If reason is LC_LEAVE, and
|
|
|
133 TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their
|
|
|
134 natural values considering the file we are returning to.
|
|
|
135
|
|
|
136 A call to this function can relocate the previous set of
|
|
|
137 maps, so any stored line_map pointers should not be used. */
|
|
|
138 extern const struct line_map *linemap_add
|
|
|
139 (struct line_maps *, enum lc_reason, unsigned int sysp,
|
|
|
140 const char *to_file, linenum_type to_line);
|
|
|
141
|
|
|
142 /* Given a logical line, returns the map from which the corresponding
|
|
|
143 (source file, line) pair can be deduced. */
|
|
|
144 extern const struct line_map *linemap_lookup
|
|
|
145 (struct line_maps *, source_location);
|
|
|
146
|
|
|
147 /* Print the file names and line numbers of the #include commands
|
|
|
148 which led to the map MAP, if any, to stderr. Nothing is output if
|
|
|
149 the most recently listed stack is the same as the current one. */
|
|
|
150 extern void linemap_print_containing_files (struct line_maps *,
|
|
|
151 const struct line_map *);
|
|
|
152
|
|
|
153 /* Converts a map and a source_location to source line. */
|
|
|
154 #define SOURCE_LINE(MAP, LOC) \
|
|
|
155 ((((LOC) - (MAP)->start_location) >> (MAP)->column_bits) + (MAP)->to_line)
|
|
|
156
|
|
|
157 #define SOURCE_COLUMN(MAP, LOC) \
|
|
|
158 (((LOC) - (MAP)->start_location) & ((1 << (MAP)->column_bits) - 1))
|
|
|
159
|
|
|
160 /* Returns the last source line within a map. This is the (last) line
|
|
|
161 of the #include, or other directive, that caused a map change. */
|
|
|
162 #define LAST_SOURCE_LINE(MAP) \
|
|
|
163 SOURCE_LINE (MAP, LAST_SOURCE_LINE_LOCATION (MAP))
|
|
|
164 #define LAST_SOURCE_LINE_LOCATION(MAP) \
|
|
|
165 ((((MAP)[1].start_location - 1 - (MAP)->start_location) \
|
|
|
166 & ~((1 << (MAP)->column_bits) - 1)) \
|
|
|
167 + (MAP)->start_location)
|
|
|
168
|
|
|
169 /* Returns the map a given map was included from. */
|
|
|
170 #define INCLUDED_FROM(SET, MAP) (&(SET)->maps[(MAP)->included_from])
|
|
|
171
|
|
|
172 /* Nonzero if the map is at the bottom of the include stack. */
|
|
|
173 #define MAIN_FILE_P(MAP) ((MAP)->included_from < 0)
|
|
|
174
|
|
|
175 /* Set LOC to a source position that is the same line as the most recent
|
|
|
176 linemap_line_start, but with the specified TO_COLUMN column number. */
|
|
|
177
|
|
|
178 #define LINEMAP_POSITION_FOR_COLUMN(LOC, SET, TO_COLUMN) do { \
|
|
|
179 unsigned int to_column = (TO_COLUMN); \
|
|
|
180 struct line_maps *set = (SET); \
|
|
|
181 if (__builtin_expect (to_column >= set->max_column_hint, 0)) \
|
|
|
182 (LOC) = linemap_position_for_column (set, to_column); \
|
|
|
183 else { \
|
|
|
184 source_location r = set->highest_line; \
|
|
|
185 r = r + to_column; \
|
|
|
186 if (r >= set->highest_location) \
|
|
|
187 set->highest_location = r; \
|
|
|
188 (LOC) = r; \
|
|
|
189 }} while (0)
|
|
|
190
|
|
|
191
|
|
|
192 extern source_location
|
|
|
193 linemap_position_for_column (struct line_maps *set, unsigned int to_column);
|
|
|
194 #endif /* !LIBCPP_LINE_MAP_H */
|
