Mercurial > hg > CbC > CbC_gcc
comparison libcpp/include/line-map.h @ 0:a06113de4d67
first commit
author | kent <kent@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Fri, 17 Jul 2009 14:47:48 +0900 |
parents | |
children | 77e2b8dfacca |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:a06113de4d67 |
---|---|
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 */ |