Mercurial > hg > CbC > CbC_gcc
annotate libcpp/include/line-map.h @ 120:f93fa5091070
fix conv1.c
| author | mir3636 |
|---|---|
| date | Thu, 08 Mar 2018 14:53:42 +0900 |
| parents | 04ced10e8804 |
| children | 84e7813d76e9 |
| rev | line source |
|---|---|
| 111 | 1 /* Map (unsigned int) keys to (source file, line, column) triples. |
| 2 Copyright (C) 2001-2017 Free Software Foundation, Inc. | |
| 0 | 3 |
| 4 This program is free software; you can redistribute it and/or modify it | |
| 5 under the terms of the GNU General Public License as published by the | |
| 6 Free Software Foundation; either version 3, or (at your option) any | |
| 7 later version. | |
| 8 | |
| 9 This program is distributed in the hope that it will be useful, | |
| 10 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| 12 GNU General Public License for more details. | |
| 13 | |
| 14 You should have received a copy of the GNU General Public License | |
| 15 along with this program; see the file COPYING3. If not see | |
| 16 <http://www.gnu.org/licenses/>. | |
| 17 | |
| 18 In other words, you are welcome to use, share and improve this program. | |
| 19 You are forbidden to forbid anyone else to use, share and improve | |
| 20 what you give them. Help stamp out software-hoarding! */ | |
| 21 | |
| 22 #ifndef LIBCPP_LINE_MAP_H | |
| 23 #define LIBCPP_LINE_MAP_H | |
| 24 | |
| 25 #ifndef GTY | |
| 26 #define GTY(x) /* nothing */ | |
| 27 #endif | |
| 28 | |
| 111 | 29 /* Reason for creating a new line map with linemap_add. LC_ENTER is |
| 0 | 30 when including a new file, e.g. a #include directive in C. |
| 31 LC_LEAVE is when reaching a file's end. LC_RENAME is when a file | |
| 32 name or line number changes for neither of the above reasons | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
33 (e.g. a #line directive in C); LC_RENAME_VERBATIM is like LC_RENAME |
| 111 | 34 but a filename of "" is not specially interpreted as standard |
| 35 input. LC_ENTER_MACRO is when a macro expansion is about to start. */ | |
| 36 enum lc_reason | |
| 37 { | |
| 38 LC_ENTER = 0, | |
| 39 LC_LEAVE, | |
| 40 LC_RENAME, | |
| 41 LC_RENAME_VERBATIM, | |
| 42 LC_ENTER_MACRO | |
| 43 /* FIXME: add support for stringize and paste. */ | |
| 44 }; | |
| 0 | 45 |
| 46 /* The type of line numbers. */ | |
| 47 typedef unsigned int linenum_type; | |
| 48 | |
| 111 | 49 /* The typedef "source_location" is a key within the location database, |
| 50 identifying a source location or macro expansion, along with range | |
| 51 information, and (optionally) a pointer for use by gcc. | |
| 52 | |
| 53 This key only has meaning in relation to a line_maps instance. Within | |
| 54 gcc there is a single line_maps instance: "line_table", declared in | |
| 55 gcc/input.h and defined in gcc/input.c. | |
| 56 | |
| 57 The values of the keys are intended to be internal to libcpp, | |
| 58 but for ease-of-understanding the implementation, they are currently | |
| 59 assigned as follows: | |
| 60 | |
| 61 Actual | Value | Meaning | |
| 62 -----------+-------------------------------+------------------------------- | |
| 63 0x00000000 | UNKNOWN_LOCATION (gcc/input.h)| Unknown/invalid location. | |
| 64 -----------+-------------------------------+------------------------------- | |
| 65 0x00000001 | BUILTINS_LOCATION | The location for declarations | |
| 66 | (gcc/input.h) | in "<built-in>" | |
| 67 -----------+-------------------------------+------------------------------- | |
| 68 0x00000002 | RESERVED_LOCATION_COUNT | The first location to be | |
| 69 | (also | handed out, and the | |
| 70 | ordmap[0]->start_location) | first line in ordmap 0 | |
| 71 -----------+-------------------------------+------------------------------- | |
| 72 | ordmap[1]->start_location | First line in ordmap 1 | |
| 73 | ordmap[1]->start_location+32 | First column in that line | |
| 74 | (assuming range_bits == 5) | | |
| 75 | ordmap[1]->start_location+64 | 2nd column in that line | |
| 76 | ordmap[1]->start_location+4096| Second line in ordmap 1 | |
| 77 | (assuming column_bits == 12) | |
| 78 | | |
| 79 | Subsequent lines are offset by (1 << column_bits), | |
| 80 | e.g. 4096 for 12 bits, with a column value of 0 representing | |
| 81 | "the whole line". | |
| 82 | | |
| 83 | Within a line, the low "range_bits" (typically 5) are used for | |
| 84 | storing short ranges, so that there's an offset of | |
| 85 | (1 << range_bits) between individual columns within a line, | |
| 86 | typically 32. | |
| 87 | The low range_bits store the offset of the end point from the | |
| 88 | start point, and the start point is found by masking away | |
| 89 | the range bits. | |
| 90 | | |
| 91 | For example: | |
| 92 | ordmap[1]->start_location+64 "2nd column in that line" | |
| 93 | above means a caret at that location, with a range | |
| 94 | starting and finishing at the same place (the range bits | |
| 95 | are 0), a range of length 1. | |
| 96 | | |
| 97 | By contrast: | |
| 98 | ordmap[1]->start_location+68 | |
| 99 | has range bits 0x4, meaning a caret with a range starting at | |
| 100 | that location, but with endpoint 4 columns further on: a range | |
| 101 | of length 5. | |
| 102 | | |
| 103 | Ranges that have caret != start, or have an endpoint too | |
| 104 | far away to fit in range_bits are instead stored as ad-hoc | |
| 105 | locations. Hence for range_bits == 5 we can compactly store | |
| 106 | tokens of length <= 32 without needing to use the ad-hoc | |
| 107 | table. | |
| 108 | | |
| 109 | This packing scheme means we effectively have | |
| 110 | (column_bits - range_bits) | |
| 111 | of bits for the columns, typically (12 - 5) = 7, for 128 | |
| 112 | columns; longer line widths are accomodated by starting a | |
| 113 | new ordmap with a higher column_bits. | |
| 114 | | |
| 115 | ordmap[2]->start_location-1 | Final location in ordmap 1 | |
| 116 -----------+-------------------------------+------------------------------- | |
| 117 | ordmap[2]->start_location | First line in ordmap 2 | |
| 118 | ordmap[3]->start_location-1 | Final location in ordmap 2 | |
| 119 -----------+-------------------------------+------------------------------- | |
| 120 | | (etc) | |
| 121 -----------+-------------------------------+------------------------------- | |
| 122 | ordmap[n-1]->start_location | First line in final ord map | |
| 123 | | (etc) | |
| 124 | set->highest_location - 1 | Final location in that ordmap | |
| 125 -----------+-------------------------------+------------------------------- | |
| 126 | set->highest_location | Location of the where the next | |
| 127 | | ordinary linemap would start | |
| 128 -----------+-------------------------------+------------------------------- | |
| 129 | | | |
| 130 | VVVVVVVVVVVVVVVVVVVVVVVVVVV | |
| 131 | Ordinary maps grow this way | |
| 132 | | |
| 133 | (unallocated integers) | |
| 134 | | |
| 135 0x60000000 | LINE_MAP_MAX_LOCATION_WITH_COLS | |
| 136 | Beyond this point, ordinary linemaps have 0 bits per column: | |
| 137 | each increment of the value corresponds to a new source line. | |
| 138 | | |
| 139 0x70000000 | LINE_MAP_MAX_SOURCE_LOCATION | |
| 140 | Beyond the point, we give up on ordinary maps; attempts to | |
| 141 | create locations in them lead to UNKNOWN_LOCATION (0). | |
| 142 | | |
| 143 | (unallocated integers) | |
| 144 | | |
| 145 | Macro maps grow this way | |
| 146 | ^^^^^^^^^^^^^^^^^^^^^^^^ | |
| 147 | | | |
| 148 -----------+-------------------------------+------------------------------- | |
| 149 | LINEMAPS_MACRO_LOWEST_LOCATION| Locations within macro maps | |
| 150 | macromap[m-1]->start_location | Start of last macro map | |
| 151 | | | |
| 152 -----------+-------------------------------+------------------------------- | |
| 153 | macromap[m-2]->start_location | Start of penultimate macro map | |
| 154 -----------+-------------------------------+------------------------------- | |
| 155 | macromap[1]->start_location | Start of macro map 1 | |
| 156 -----------+-------------------------------+------------------------------- | |
| 157 | macromap[0]->start_location | Start of macro map 0 | |
| 158 0x7fffffff | MAX_SOURCE_LOCATION | Also used as a mask for | |
| 159 | | accessing the ad-hoc data table | |
| 160 -----------+-------------------------------+------------------------------- | |
| 161 0x80000000 | Start of ad-hoc values; the lower 31 bits are used as an index | |
| 162 ... | into the line_table->location_adhoc_data_map.data array. | |
| 163 0xffffffff | UINT_MAX | | |
| 164 -----------+-------------------------------+------------------------------- | |
| 165 | |
| 166 Examples of location encoding. | |
| 167 | |
| 168 Packed ranges | |
| 169 ============= | |
| 170 | |
| 171 Consider encoding the location of a token "foo", seen underlined here | |
| 172 on line 523, within an ordinary line_map that starts at line 500: | |
| 173 | |
| 174 11111111112 | |
| 175 12345678901234567890 | |
| 176 522 | |
| 177 523 return foo + bar; | |
| 178 ^~~ | |
| 179 524 | |
| 180 | |
| 181 The location's caret and start are both at line 523, column 11; the | |
| 182 location's finish is on the same line, at column 13 (an offset of 2 | |
| 183 columns, for length 3). | |
| 184 | |
| 185 Line 523 is offset 23 from the starting line of the ordinary line_map. | |
| 186 | |
| 187 caret == start, and the offset of the finish fits within 5 bits, so | |
| 188 this can be stored as a packed range. | |
| 189 | |
| 190 This is encoded as: | |
| 191 ordmap->start | |
| 192 + (line_offset << ordmap->m_column_and_range_bits) | |
| 193 + (column << ordmap->m_range_bits) | |
| 194 + (range_offset); | |
| 195 i.e. (for line offset 23, column 11, range offset 2): | |
| 196 ordmap->start | |
| 197 + (23 << 12) | |
| 198 + (11 << 5) | |
| 199 + 2; | |
| 200 i.e.: | |
| 201 ordmap->start + 0x17162 | |
| 202 assuming that the line_map uses the default of 7 bits for columns and | |
| 203 5 bits for packed range (giving 12 bits for m_column_and_range_bits). | |
| 204 | |
| 205 | |
| 206 "Pure" locations | |
| 207 ================ | |
| 208 | |
| 209 These are a special case of the above, where | |
| 210 caret == start == finish | |
| 211 They are stored as packed ranges with offset == 0. | |
| 212 For example, the location of the "f" of "foo" could be stored | |
| 213 as above, but with range offset 0, giving: | |
| 214 ordmap->start | |
| 215 + (23 << 12) | |
| 216 + (11 << 5) | |
| 217 + 0; | |
| 218 i.e.: | |
| 219 ordmap->start + 0x17160 | |
| 220 | |
| 221 | |
| 222 Unoptimized ranges | |
| 223 ================== | |
| 224 | |
| 225 Consider encoding the location of the binary expression | |
| 226 below: | |
| 227 | |
| 228 11111111112 | |
| 229 12345678901234567890 | |
| 230 522 | |
| 231 523 return foo + bar; | |
| 232 ~~~~^~~~~ | |
| 233 524 | |
| 234 | |
| 235 The location's caret is at the "+", line 523 column 15, but starts | |
| 236 earlier, at the "f" of "foo" at column 11. The finish is at the "r" | |
| 237 of "bar" at column 19. | |
| 238 | |
| 239 This can't be stored as a packed range since start != caret. | |
| 240 Hence it is stored as an ad-hoc location e.g. 0x80000003. | |
| 241 | |
| 242 Stripping off the top bit gives us an index into the ad-hoc | |
| 243 lookaside table: | |
| 244 | |
| 245 line_table->location_adhoc_data_map.data[0x3] | |
| 246 | |
| 247 from which the caret, start and finish can be looked up, | |
| 248 encoded as "pure" locations: | |
| 249 | |
| 250 start == ordmap->start + (23 << 12) + (11 << 5) | |
| 251 == ordmap->start + 0x17160 (as above; the "f" of "foo") | |
| 252 | |
| 253 caret == ordmap->start + (23 << 12) + (15 << 5) | |
| 254 == ordmap->start + 0x171e0 | |
| 255 | |
| 256 finish == ordmap->start + (23 << 12) + (19 << 5) | |
| 257 == ordmap->start + 0x17260 | |
| 258 | |
| 259 To further see how source_location works in practice, see the | |
| 260 worked example in libcpp/location-example.txt. */ | |
| 0 | 261 typedef unsigned int source_location; |
| 262 | |
| 111 | 263 /* Do not pack ranges if locations get higher than this. |
| 264 If you change this, update: | |
| 265 gcc.dg/plugin/location-overflow-test-*.c. */ | |
| 266 const source_location LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES = 0x50000000; | |
| 267 | |
| 268 /* Do not track column numbers if locations get higher than this. | |
| 269 If you change this, update: | |
| 270 gcc.dg/plugin/location-overflow-test-*.c. */ | |
| 271 const source_location LINE_MAP_MAX_LOCATION_WITH_COLS = 0x60000000; | |
| 272 | |
| 273 /* A range of source locations. | |
| 274 | |
| 275 Ranges are closed: | |
| 276 m_start is the first location within the range, | |
| 277 m_finish is the last location within the range. | |
| 278 | |
| 279 We may need a more compact way to store these, but for now, | |
| 280 let's do it the simple way, as a pair. */ | |
| 281 struct GTY(()) source_range | |
| 282 { | |
| 283 source_location m_start; | |
| 284 source_location m_finish; | |
| 285 | |
| 286 /* We avoid using constructors, since various structs that | |
| 287 don't yet have constructors will embed instances of | |
| 288 source_range. */ | |
| 289 | |
| 290 /* Make a source_range from a source_location. */ | |
| 291 static source_range from_location (source_location loc) | |
| 292 { | |
| 293 source_range result; | |
| 294 result.m_start = loc; | |
| 295 result.m_finish = loc; | |
| 296 return result; | |
| 297 } | |
| 298 | |
| 299 /* Make a source_range from a pair of source_location. */ | |
| 300 static source_range from_locations (source_location start, | |
| 301 source_location finish) | |
| 302 { | |
| 303 source_range result; | |
| 304 result.m_start = start; | |
| 305 result.m_finish = finish; | |
| 306 return result; | |
| 307 } | |
| 308 }; | |
| 309 | |
| 0 | 310 /* Memory allocation function typedef. Works like xrealloc. */ |
| 311 typedef void *(*line_map_realloc) (void *, size_t); | |
| 312 | |
| 111 | 313 /* Memory allocator function that returns the actual allocated size, |
| 314 for a given requested allocation. */ | |
| 315 typedef size_t (*line_map_round_alloc_size_func) (size_t); | |
| 316 | |
| 317 /* A line_map encodes a sequence of locations. | |
| 318 There are two kinds of maps. Ordinary maps and macro expansion | |
| 319 maps, a.k.a macro maps. | |
| 320 | |
| 321 A macro map encodes source locations of tokens that are part of a | |
| 322 macro replacement-list, at a macro expansion point. E.g, in: | |
| 323 | |
| 324 #define PLUS(A,B) A + B | |
| 325 | |
| 326 No macro map is going to be created there, because we are not at a | |
| 327 macro expansion point. We are at a macro /definition/ point. So the | |
| 328 locations of the tokens of the macro replacement-list (i.e, A + B) | |
| 329 will be locations in an ordinary map, not a macro map. | |
| 330 | |
| 331 On the other hand, if we later do: | |
| 332 | |
| 333 int a = PLUS (1,2); | |
| 334 | |
| 335 The invocation of PLUS here is a macro expansion. So we are at a | |
| 336 macro expansion point. The preprocessor expands PLUS (1,2) and | |
| 337 replaces it with the tokens of its replacement-list: 1 + 2. A macro | |
| 338 map is going to be created to hold (or rather to map, haha ...) the | |
| 339 locations of the tokens 1, + and 2. The macro map also records the | |
| 340 location of the expansion point of PLUS. That location is mapped in | |
| 341 the map that is active right before the location of the invocation | |
| 342 of PLUS. */ | |
| 343 struct GTY((tag ("0"), desc ("%h.reason == LC_ENTER_MACRO ? 2 : 1"))) line_map { | |
| 344 source_location start_location; | |
| 345 | |
| 346 /* The reason for creation of this line map. */ | |
| 347 ENUM_BITFIELD (lc_reason) reason : CHAR_BIT; | |
| 348 }; | |
| 349 | |
| 350 /* An ordinary line map encodes physical source locations. Those | |
| 351 physical source locations are called "spelling locations". | |
| 352 | |
| 353 Physical source file TO_FILE at line TO_LINE at column 0 is represented | |
| 0 | 354 by the logical START_LOCATION. TO_LINE+L at column C is represented by |
| 111 | 355 START_LOCATION+(L*(1<<m_column_and_range_bits))+(C*1<<m_range_bits), as |
| 356 long as C<(1<<effective range bits), and the result_location is less than | |
| 357 the next line_map's start_location. | |
| 0 | 358 (The top line is line 1 and the leftmost column is column 1; line/column 0 |
| 359 means "entire file/line" or "unknown line/column" or "not applicable".) | |
| 111 | 360 |
| 361 The highest possible source location is MAX_SOURCE_LOCATION. */ | |
| 362 struct GTY((tag ("1"))) line_map_ordinary : public line_map { | |
| 0 | 363 const char *to_file; |
| 364 linenum_type to_line; | |
| 111 | 365 |
| 366 /* An index into the set that gives the line mapping at whose end | |
| 367 the current one was included. File(s) at the bottom of the | |
| 368 include stack have this set to -1. */ | |
| 0 | 369 int included_from; |
| 111 | 370 |
| 371 /* SYSP is one for a system header, two for a C system header file | |
| 372 that therefore needs to be extern "C" protected in C++, and zero | |
| 373 otherwise. This field isn't really needed now that it's in | |
| 374 cpp_buffer. */ | |
| 0 | 375 unsigned char sysp; |
| 111 | 376 |
| 377 /* Number of the low-order source_location bits used for column numbers | |
| 378 and ranges. */ | |
| 379 unsigned int m_column_and_range_bits : 8; | |
| 380 | |
| 381 /* Number of the low-order "column" bits used for storing short ranges | |
| 382 inline, rather than in the ad-hoc table. | |
| 383 MSB LSB | |
| 384 31 0 | |
| 385 +-------------------------+-------------------------------------------+ | |
| 386 | |<---map->column_and_range_bits (e.g. 12)-->| | |
| 387 +-------------------------+-----------------------+-------------------+ | |
| 388 | | column_and_range_bits | map->range_bits | | |
| 389 | | - range_bits | | | |
| 390 +-------------------------+-----------------------+-------------------+ | |
| 391 | row bits | effective column bits | short range bits | | |
| 392 | | (e.g. 7) | (e.g. 5) | | |
| 393 +-------------------------+-----------------------+-------------------+ */ | |
| 394 unsigned int m_range_bits : 8; | |
| 395 }; | |
| 396 | |
| 397 /* This is the highest possible source location encoded within an | |
| 398 ordinary or macro map. */ | |
| 399 const source_location MAX_SOURCE_LOCATION = 0x7FFFFFFF; | |
| 400 | |
| 401 struct cpp_hashnode; | |
| 402 | |
| 403 /* A macro line map encodes location of tokens coming from a macro | |
| 404 expansion. | |
| 405 | |
| 406 The offset from START_LOCATION is used to index into | |
| 407 MACRO_LOCATIONS; this holds the original location of the token. */ | |
| 408 struct GTY((tag ("2"))) line_map_macro : public line_map { | |
| 409 /* The cpp macro which expansion gave birth to this macro map. */ | |
| 410 struct cpp_hashnode * GTY ((nested_ptr (union tree_node, | |
| 411 "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL", | |
| 412 "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL"))) | |
| 413 macro; | |
| 414 | |
| 415 /* The number of tokens inside the replacement-list of MACRO. */ | |
| 416 unsigned int n_tokens; | |
| 417 | |
| 418 /* This array of location is actually an array of pairs of | |
| 419 locations. The elements inside it thus look like: | |
| 420 | |
| 421 x0,y0, x1,y1, x2,y2, ...., xn,yn. | |
| 422 | |
| 423 where n == n_tokens; | |
| 424 | |
| 425 Remember that these xI,yI are collected when libcpp is about to | |
| 426 expand a given macro. | |
| 427 | |
| 428 yI is the location in the macro definition, either of the token | |
| 429 itself or of a macro parameter that it replaces. | |
| 430 | |
| 431 Imagine this: | |
| 432 | |
| 433 #define PLUS(A, B) A + B <--- #1 | |
| 434 | |
| 435 int a = PLUS (1,2); <--- #2 | |
| 436 | |
| 437 There is a macro map for the expansion of PLUS in #2. PLUS is | |
| 438 expanded into its expansion-list. The expansion-list is the | |
| 439 replacement-list of PLUS where the macro parameters are replaced | |
| 440 with their arguments. So the replacement-list of PLUS is made of | |
| 441 the tokens: | |
| 442 | |
| 443 A, +, B | |
| 444 | |
| 445 and the expansion-list is made of the tokens: | |
| 446 | |
| 447 1, +, 2 | |
| 448 | |
| 449 Let's consider the case of token "+". Its y1 [yI for I == 1] is | |
| 450 its spelling location in #1. | |
| 451 | |
| 452 y0 (thus for token "1") is the spelling location of A in #1. | |
| 453 | |
| 454 And y2 (of token "2") is the spelling location of B in #1. | |
| 455 | |
| 456 When the token is /not/ an argument for a macro, xI is the same | |
| 457 location as yI. Otherwise, xI is the location of the token | |
| 458 outside this macro expansion. If this macro was expanded from | |
| 459 another macro expansion, xI is a virtual location representing | |
| 460 the token in that macro expansion; otherwise, it is the spelling | |
| 461 location of the token. | |
| 462 | |
| 463 Note that a virtual location is a location returned by | |
| 464 linemap_add_macro_token. It encodes the relevant locations (x,y | |
| 465 pairs) of that token across the macro expansions from which it | |
| 466 (the token) might come from. | |
| 467 | |
| 468 In the example above x1 (for token "+") is going to be the same | |
| 469 as y1. x0 is the spelling location for the argument token "1", | |
| 470 and x2 is the spelling location for the argument token "2". */ | |
| 471 source_location * GTY((atomic)) macro_locations; | |
| 472 | |
| 473 /* This is the location of the expansion point of the current macro | |
| 474 map. It's the location of the macro name. That location is held | |
| 475 by the map that was current right before the current one. It | |
| 476 could have been either a macro or an ordinary map, depending on | |
| 477 if we are in a nested expansion context not. */ | |
| 478 source_location expansion; | |
| 479 }; | |
| 480 | |
| 481 #if CHECKING_P && (GCC_VERSION >= 2007) | |
| 482 | |
| 483 /* Assertion macro to be used in line-map code. */ | |
| 484 #define linemap_assert(EXPR) \ | |
| 485 do { \ | |
| 486 if (! (EXPR)) \ | |
| 487 abort (); \ | |
| 488 } while (0) | |
| 489 | |
| 490 /* Assert that becomes a conditional expression when checking is disabled at | |
| 491 compilation time. Use this for conditions that should not happen but if | |
| 492 they happen, it is better to handle them gracefully rather than crash | |
| 493 randomly later. | |
| 494 Usage: | |
| 495 | |
| 496 if (linemap_assert_fails(EXPR)) handle_error(); */ | |
| 497 #define linemap_assert_fails(EXPR) __extension__ \ | |
| 498 ({linemap_assert (EXPR); false;}) | |
| 499 | |
| 500 #else | |
| 501 /* Include EXPR, so that unused variable warnings do not occur. */ | |
| 502 #define linemap_assert(EXPR) ((void)(0 && (EXPR))) | |
| 503 #define linemap_assert_fails(EXPR) (! (EXPR)) | |
| 504 #endif | |
| 505 | |
| 506 /* Return TRUE if MAP encodes locations coming from a macro | |
| 507 replacement-list at macro expansion point. */ | |
| 508 bool | |
| 509 linemap_macro_expansion_map_p (const struct line_map *); | |
| 510 | |
| 511 /* Assert that MAP encodes locations of tokens that are not part of | |
| 512 the replacement-list of a macro expansion, downcasting from | |
| 513 line_map * to line_map_ordinary *. */ | |
| 514 | |
| 515 inline line_map_ordinary * | |
| 516 linemap_check_ordinary (struct line_map *map) | |
| 517 { | |
| 518 linemap_assert (!linemap_macro_expansion_map_p (map)); | |
| 519 return (line_map_ordinary *)map; | |
| 520 } | |
| 521 | |
| 522 /* Assert that MAP encodes locations of tokens that are not part of | |
| 523 the replacement-list of a macro expansion, downcasting from | |
| 524 const line_map * to const line_map_ordinary *. */ | |
| 525 | |
| 526 inline const line_map_ordinary * | |
| 527 linemap_check_ordinary (const struct line_map *map) | |
| 528 { | |
| 529 linemap_assert (!linemap_macro_expansion_map_p (map)); | |
| 530 return (const line_map_ordinary *)map; | |
| 531 } | |
| 532 | |
| 533 /* Assert that MAP is a macro expansion and downcast to the appropriate | |
| 534 subclass. */ | |
| 535 | |
| 536 inline line_map_macro *linemap_check_macro (line_map *map) | |
| 537 { | |
| 538 linemap_assert (linemap_macro_expansion_map_p (map)); | |
| 539 return (line_map_macro *)map; | |
| 540 } | |
| 541 | |
| 542 /* Assert that MAP is a macro expansion and downcast to the appropriate | |
| 543 subclass. */ | |
| 544 | |
| 545 inline const line_map_macro * | |
| 546 linemap_check_macro (const line_map *map) | |
| 547 { | |
| 548 linemap_assert (linemap_macro_expansion_map_p (map)); | |
| 549 return (const line_map_macro *)map; | |
| 550 } | |
| 551 | |
| 552 /* Read the start location of MAP. */ | |
| 553 | |
| 554 inline source_location | |
| 555 MAP_START_LOCATION (const line_map *map) | |
| 556 { | |
| 557 return map->start_location; | |
| 558 } | |
| 559 | |
| 560 /* Get the starting line number of ordinary map MAP. */ | |
| 561 | |
| 562 inline linenum_type | |
| 563 ORDINARY_MAP_STARTING_LINE_NUMBER (const line_map_ordinary *ord_map) | |
| 564 { | |
| 565 return ord_map->to_line; | |
| 566 } | |
| 567 | |
| 568 /* Get the index of the ordinary map at whose end | |
| 569 ordinary map MAP was included. | |
| 570 | |
| 571 File(s) at the bottom of the include stack have this set. */ | |
| 572 | |
| 573 inline int | |
| 574 ORDINARY_MAP_INCLUDER_FILE_INDEX (const line_map_ordinary *ord_map) | |
| 575 { | |
| 576 return ord_map->included_from; | |
| 577 } | |
| 578 | |
| 579 /* Return a positive value if map encodes locations from a system | |
| 580 header, 0 otherwise. Returns 1 if ordinary map MAP encodes locations | |
| 581 in a system header and 2 if it encodes locations in a C system header | |
| 582 that therefore needs to be extern "C" protected in C++. */ | |
| 583 | |
| 584 inline unsigned char | |
| 585 ORDINARY_MAP_IN_SYSTEM_HEADER_P (const line_map_ordinary *ord_map) | |
| 586 { | |
| 587 return ord_map->sysp; | |
| 588 } | |
| 589 | |
| 590 /* Get the filename of ordinary map MAP. */ | |
| 591 | |
| 592 inline const char * | |
| 593 ORDINARY_MAP_FILE_NAME (const line_map_ordinary *ord_map) | |
| 594 { | |
| 595 return ord_map->to_file; | |
| 596 } | |
| 597 | |
| 598 /* Get the cpp macro whose expansion gave birth to macro map MAP. */ | |
| 599 | |
| 600 inline cpp_hashnode * | |
| 601 MACRO_MAP_MACRO (const line_map_macro *macro_map) | |
| 602 { | |
| 603 return macro_map->macro; | |
| 604 } | |
| 605 | |
| 606 /* Get the number of tokens inside the replacement-list of the macro | |
| 607 that led to macro map MAP. */ | |
| 608 | |
| 609 inline unsigned int | |
| 610 MACRO_MAP_NUM_MACRO_TOKENS (const line_map_macro *macro_map) | |
| 611 { | |
| 612 return macro_map->n_tokens; | |
| 613 } | |
| 614 | |
| 615 /* Get the array of pairs of locations within macro map MAP. | |
| 616 See the declaration of line_map_macro for more information. */ | |
| 617 | |
| 618 inline source_location * | |
| 619 MACRO_MAP_LOCATIONS (const line_map_macro *macro_map) | |
| 620 { | |
| 621 return macro_map->macro_locations; | |
| 622 } | |
| 623 | |
| 624 /* Get the location of the expansion point of the macro map MAP. */ | |
| 625 | |
| 626 inline source_location | |
| 627 MACRO_MAP_EXPANSION_POINT_LOCATION (const line_map_macro *macro_map) | |
| 628 { | |
| 629 return macro_map->expansion; | |
| 630 } | |
| 631 | |
| 632 /* The abstraction of a set of location maps. There can be several | |
| 633 types of location maps. This abstraction contains the attributes | |
| 634 that are independent from the type of the map. | |
| 635 | |
| 636 Essentially this is just a vector of T_linemap_subclass, | |
| 637 which can only ever grow in size. */ | |
| 638 | |
| 639 struct GTY(()) maps_info_ordinary { | |
| 640 /* This array contains the "ordinary" line maps, for all | |
| 641 events other than macro expansion | |
| 642 (e.g. when a new preprocessing unit starts or ends). */ | |
| 643 line_map_ordinary * GTY ((length ("%h.used"))) maps; | |
| 644 | |
| 645 /* The total number of allocated maps. */ | |
| 646 unsigned int allocated; | |
| 647 | |
| 648 /* The number of elements used in maps. This number is smaller | |
| 649 or equal to ALLOCATED. */ | |
| 650 unsigned int used; | |
| 651 | |
| 652 unsigned int cache; | |
| 653 }; | |
| 654 | |
| 655 struct GTY(()) maps_info_macro { | |
| 656 /* This array contains the macro line maps. | |
| 657 A macro line map is created whenever a macro expansion occurs. */ | |
| 658 line_map_macro * GTY ((length ("%h.used"))) maps; | |
| 659 | |
| 660 /* The total number of allocated maps. */ | |
| 661 unsigned int allocated; | |
| 662 | |
| 663 /* The number of elements used in maps. This number is smaller | |
| 664 or equal to ALLOCATED. */ | |
| 665 unsigned int used; | |
| 666 | |
| 667 unsigned int cache; | |
| 668 }; | |
| 669 | |
| 670 /* Data structure to associate a source_range together with an arbitrary | |
| 671 data pointer with a source location. */ | |
| 672 struct GTY(()) location_adhoc_data { | |
| 673 source_location locus; | |
| 674 source_range src_range; | |
| 675 void * GTY((skip)) data; | |
| 676 }; | |
| 677 | |
| 678 struct htab; | |
| 679 | |
| 680 /* The following data structure encodes a location with some adhoc data | |
| 681 and maps it to a new unsigned integer (called an adhoc location) | |
| 682 that replaces the original location to represent the mapping. | |
| 683 | |
| 684 The new adhoc_loc uses the highest bit as the enabling bit, i.e. if the | |
| 685 highest bit is 1, then the number is adhoc_loc. Otherwise, it serves as | |
| 686 the original location. Once identified as the adhoc_loc, the lower 31 | |
| 687 bits of the integer is used to index the location_adhoc_data array, | |
| 688 in which the locus and associated data is stored. */ | |
| 689 | |
| 690 struct GTY(()) location_adhoc_data_map { | |
| 691 struct htab * GTY((skip)) htab; | |
| 692 source_location curr_loc; | |
| 693 unsigned int allocated; | |
| 694 struct location_adhoc_data GTY((length ("%h.allocated"))) *data; | |
| 0 | 695 }; |
| 696 | |
| 697 /* A set of chronological line_map structures. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
698 struct GTY(()) line_maps { |
| 0 | 699 |
| 111 | 700 ~line_maps (); |
| 701 | |
| 702 maps_info_ordinary info_ordinary; | |
| 0 | 703 |
| 111 | 704 maps_info_macro info_macro; |
| 0 | 705 |
| 706 /* Depth of the include stack, including the current file. */ | |
| 707 unsigned int depth; | |
| 708 | |
| 709 /* If true, prints an include trace a la -H. */ | |
| 710 bool trace_includes; | |
| 711 | |
| 712 /* Highest source_location "given out". */ | |
| 713 source_location highest_location; | |
| 714 | |
| 715 /* Start of line of highest source_location "given out". */ | |
| 716 source_location highest_line; | |
| 717 | |
| 718 /* The maximum column number we can quickly allocate. Higher numbers | |
| 719 may require allocating a new line_map. */ | |
| 720 unsigned int max_column_hint; | |
| 721 | |
| 722 /* If non-null, the allocator to use when resizing 'maps'. If null, | |
| 723 xrealloc is used. */ | |
| 724 line_map_realloc reallocator; | |
| 111 | 725 |
| 726 /* The allocators' function used to know the actual size it | |
| 727 allocated, for a certain allocation size requested. */ | |
| 728 line_map_round_alloc_size_func round_alloc_size; | |
| 729 | |
| 730 struct location_adhoc_data_map location_adhoc_data_map; | |
| 731 | |
| 732 /* The special location value that is used as spelling location for | |
| 733 built-in tokens. */ | |
| 734 source_location builtin_location; | |
| 735 | |
| 736 /* True if we've seen a #line or # 44 "file" directive. */ | |
| 737 bool seen_line_directive; | |
| 738 | |
| 739 /* The default value of range_bits in ordinary line maps. */ | |
| 740 unsigned int default_range_bits; | |
| 741 | |
| 742 unsigned int num_optimized_ranges; | |
| 743 unsigned int num_unoptimized_ranges; | |
| 0 | 744 }; |
| 745 | |
| 111 | 746 /* Returns the number of allocated maps so far. MAP_KIND shall be TRUE |
| 747 if we are interested in macro maps, FALSE otherwise. */ | |
| 748 inline unsigned int | |
| 749 LINEMAPS_ALLOCATED (const line_maps *set, bool map_kind) | |
| 750 { | |
| 751 if (map_kind) | |
| 752 return set->info_macro.allocated; | |
| 753 else | |
| 754 return set->info_ordinary.allocated; | |
| 755 } | |
| 756 | |
| 757 /* As above, but by reference (e.g. as an lvalue). */ | |
| 758 | |
| 759 inline unsigned int & | |
| 760 LINEMAPS_ALLOCATED (line_maps *set, bool map_kind) | |
| 761 { | |
| 762 if (map_kind) | |
| 763 return set->info_macro.allocated; | |
| 764 else | |
| 765 return set->info_ordinary.allocated; | |
| 766 } | |
| 767 | |
| 768 /* Returns the number of used maps so far. MAP_KIND shall be TRUE if | |
| 769 we are interested in macro maps, FALSE otherwise.*/ | |
| 770 inline unsigned int | |
| 771 LINEMAPS_USED (const line_maps *set, bool map_kind) | |
| 772 { | |
| 773 if (map_kind) | |
| 774 return set->info_macro.used; | |
| 775 else | |
| 776 return set->info_ordinary.used; | |
| 777 } | |
| 778 | |
| 779 /* As above, but by reference (e.g. as an lvalue). */ | |
| 780 | |
| 781 inline unsigned int & | |
| 782 LINEMAPS_USED (line_maps *set, bool map_kind) | |
| 783 { | |
| 784 if (map_kind) | |
| 785 return set->info_macro.used; | |
| 786 else | |
| 787 return set->info_ordinary.used; | |
| 788 } | |
| 789 | |
| 790 /* Returns the index of the last map that was looked up with | |
| 791 linemap_lookup. MAP_KIND shall be TRUE if we are interested in | |
| 792 macro maps, FALSE otherwise. */ | |
| 793 inline unsigned int | |
| 794 LINEMAPS_CACHE (const line_maps *set, bool map_kind) | |
| 795 { | |
| 796 if (map_kind) | |
| 797 return set->info_macro.cache; | |
| 798 else | |
| 799 return set->info_ordinary.cache; | |
| 800 } | |
| 801 | |
| 802 /* As above, but by reference (e.g. as an lvalue). */ | |
| 803 | |
| 804 inline unsigned int & | |
| 805 LINEMAPS_CACHE (line_maps *set, bool map_kind) | |
| 806 { | |
| 807 if (map_kind) | |
| 808 return set->info_macro.cache; | |
| 809 else | |
| 810 return set->info_ordinary.cache; | |
| 811 } | |
| 812 | |
| 813 /* Return the map at a given index. */ | |
| 814 inline line_map * | |
| 815 LINEMAPS_MAP_AT (const line_maps *set, bool map_kind, int index) | |
| 816 { | |
| 817 if (map_kind) | |
| 818 return &set->info_macro.maps[index]; | |
| 819 else | |
| 820 return &set->info_ordinary.maps[index]; | |
| 821 } | |
| 822 | |
| 823 /* Returns the last map used in the line table SET. MAP_KIND | |
| 824 shall be TRUE if we are interested in macro maps, FALSE | |
| 825 otherwise.*/ | |
| 826 inline line_map * | |
| 827 LINEMAPS_LAST_MAP (const line_maps *set, bool map_kind) | |
| 828 { | |
| 829 return LINEMAPS_MAP_AT (set, map_kind, | |
| 830 LINEMAPS_USED (set, map_kind) - 1); | |
| 831 } | |
| 832 | |
| 833 /* Returns the last map that was allocated in the line table SET. | |
| 834 MAP_KIND shall be TRUE if we are interested in macro maps, FALSE | |
| 835 otherwise.*/ | |
| 836 inline line_map * | |
| 837 LINEMAPS_LAST_ALLOCATED_MAP (const line_maps *set, bool map_kind) | |
| 838 { | |
| 839 return LINEMAPS_MAP_AT (set, map_kind, | |
| 840 LINEMAPS_ALLOCATED (set, map_kind) - 1); | |
| 841 } | |
| 842 | |
| 843 /* Returns a pointer to the memory region where ordinary maps are | |
| 844 allocated in the line table SET. */ | |
| 845 inline line_map_ordinary * | |
| 846 LINEMAPS_ORDINARY_MAPS (const line_maps *set) | |
| 847 { | |
| 848 return set->info_ordinary.maps; | |
| 849 } | |
| 850 | |
| 851 /* Returns the INDEXth ordinary map. */ | |
| 852 inline line_map_ordinary * | |
| 853 LINEMAPS_ORDINARY_MAP_AT (const line_maps *set, int index) | |
| 854 { | |
| 855 linemap_assert (index >= 0); | |
| 856 linemap_assert ((unsigned int)index < set->info_ordinary.used); | |
| 857 return &set->info_ordinary.maps[index]; | |
| 858 } | |
| 859 | |
| 860 /* Return the number of ordinary maps allocated in the line table | |
| 861 SET. */ | |
| 862 inline unsigned int | |
| 863 LINEMAPS_ORDINARY_ALLOCATED (const line_maps *set) | |
| 864 { | |
| 865 return LINEMAPS_ALLOCATED (set, false); | |
| 866 } | |
| 867 | |
| 868 /* Return the number of ordinary maps used in the line table SET. */ | |
| 869 inline unsigned int | |
| 870 LINEMAPS_ORDINARY_USED (const line_maps *set) | |
| 871 { | |
| 872 return LINEMAPS_USED (set, false); | |
| 873 } | |
| 874 | |
| 875 /* Return the index of the last ordinary map that was looked up with | |
| 876 linemap_lookup. */ | |
| 877 inline unsigned int | |
| 878 LINEMAPS_ORDINARY_CACHE (const line_maps *set) | |
| 879 { | |
| 880 return LINEMAPS_CACHE (set, false); | |
| 881 } | |
| 882 | |
| 883 /* As above, but by reference (e.g. as an lvalue). */ | |
| 0 | 884 |
| 111 | 885 inline unsigned int & |
| 886 LINEMAPS_ORDINARY_CACHE (line_maps *set) | |
| 887 { | |
| 888 return LINEMAPS_CACHE (set, false); | |
| 889 } | |
| 890 | |
| 891 /* Returns a pointer to the last ordinary map used in the line table | |
| 892 SET. */ | |
| 893 inline line_map_ordinary * | |
| 894 LINEMAPS_LAST_ORDINARY_MAP (const line_maps *set) | |
| 895 { | |
| 896 return (line_map_ordinary *)LINEMAPS_LAST_MAP (set, false); | |
| 897 } | |
| 898 | |
| 899 /* Returns a pointer to the last ordinary map allocated the line table | |
| 900 SET. */ | |
| 901 inline line_map_ordinary * | |
| 902 LINEMAPS_LAST_ALLOCATED_ORDINARY_MAP (const line_maps *set) | |
| 903 { | |
| 904 return (line_map_ordinary *)LINEMAPS_LAST_ALLOCATED_MAP (set, false); | |
| 905 } | |
| 906 | |
| 907 /* Returns a pointer to the beginning of the region where macro maps | |
| 908 are allocated. */ | |
| 909 inline line_map_macro * | |
| 910 LINEMAPS_MACRO_MAPS (const line_maps *set) | |
| 911 { | |
| 912 return set->info_macro.maps; | |
| 913 } | |
| 914 | |
| 915 /* Returns the INDEXth macro map. */ | |
| 916 inline line_map_macro * | |
| 917 LINEMAPS_MACRO_MAP_AT (const line_maps *set, int index) | |
| 918 { | |
| 919 linemap_assert (index >= 0); | |
| 920 linemap_assert ((unsigned int)index < set->info_macro.used); | |
| 921 return &set->info_macro.maps[index]; | |
| 922 } | |
| 923 | |
| 924 /* Returns the number of macro maps that were allocated in the line | |
| 925 table SET. */ | |
| 926 inline unsigned int | |
| 927 LINEMAPS_MACRO_ALLOCATED (const line_maps *set) | |
| 928 { | |
| 929 return LINEMAPS_ALLOCATED (set, true); | |
| 930 } | |
| 931 | |
| 932 /* Returns the number of macro maps used in the line table SET. */ | |
| 933 inline unsigned int | |
| 934 LINEMAPS_MACRO_USED (const line_maps *set) | |
| 935 { | |
| 936 return LINEMAPS_USED (set, true); | |
| 937 } | |
| 938 | |
| 939 /* Returns the index of the last macro map looked up with | |
| 940 linemap_lookup. */ | |
| 941 inline unsigned int | |
| 942 LINEMAPS_MACRO_CACHE (const line_maps *set) | |
| 943 { | |
| 944 return LINEMAPS_CACHE (set, true); | |
| 945 } | |
| 946 | |
| 947 /* As above, but by reference (e.g. as an lvalue). */ | |
| 948 | |
| 949 inline unsigned int & | |
| 950 LINEMAPS_MACRO_CACHE (line_maps *set) | |
| 951 { | |
| 952 return LINEMAPS_CACHE (set, true); | |
| 953 } | |
| 954 | |
| 955 /* Returns the last macro map used in the line table SET. */ | |
| 956 inline line_map_macro * | |
| 957 LINEMAPS_LAST_MACRO_MAP (const line_maps *set) | |
| 958 { | |
| 959 return (line_map_macro *)LINEMAPS_LAST_MAP (set, true); | |
| 960 } | |
| 961 | |
| 962 /* Returns the lowest location [of a token resulting from macro | |
| 963 expansion] encoded in this line table. */ | |
| 964 inline source_location | |
| 965 LINEMAPS_MACRO_LOWEST_LOCATION (const line_maps *set) | |
| 966 { | |
| 967 return LINEMAPS_MACRO_USED (set) | |
| 968 ? MAP_START_LOCATION (LINEMAPS_LAST_MACRO_MAP (set)) | |
| 969 : MAX_SOURCE_LOCATION; | |
| 970 } | |
| 971 | |
| 972 /* Returns the last macro map allocated in the line table SET. */ | |
| 973 inline line_map_macro * | |
| 974 LINEMAPS_LAST_ALLOCATED_MACRO_MAP (const line_maps *set) | |
| 975 { | |
| 976 return (line_map_macro *)LINEMAPS_LAST_ALLOCATED_MAP (set, true); | |
| 977 } | |
| 978 | |
| 979 extern source_location get_combined_adhoc_loc (struct line_maps *, | |
| 980 source_location, | |
| 981 source_range, | |
| 982 void *); | |
| 983 extern void *get_data_from_adhoc_loc (struct line_maps *, source_location); | |
| 984 extern source_location get_location_from_adhoc_loc (struct line_maps *, | |
| 985 source_location); | |
| 986 | |
| 987 extern source_range get_range_from_loc (line_maps *set, source_location loc); | |
| 988 | |
| 989 /* Get whether location LOC is an ad-hoc location. */ | |
| 990 | |
| 991 inline bool | |
| 992 IS_ADHOC_LOC (source_location loc) | |
| 993 { | |
| 994 return (loc & MAX_SOURCE_LOCATION) != loc; | |
| 995 } | |
| 996 | |
| 997 /* Get whether location LOC is a "pure" location, or | |
| 998 whether it is an ad-hoc location, or embeds range information. */ | |
| 999 | |
| 1000 bool | |
| 1001 pure_location_p (line_maps *set, source_location loc); | |
| 1002 | |
| 1003 /* Given location LOC within SET, strip away any packed range information | |
| 1004 or ad-hoc information. */ | |
| 1005 | |
| 1006 extern source_location get_pure_location (line_maps *set, | |
| 1007 source_location loc); | |
| 1008 | |
| 1009 /* Combine LOC and BLOCK, giving a combined adhoc location. */ | |
| 1010 | |
| 1011 inline source_location | |
| 1012 COMBINE_LOCATION_DATA (struct line_maps *set, | |
| 1013 source_location loc, | |
| 1014 source_range src_range, | |
| 1015 void *block) | |
| 1016 { | |
| 1017 return get_combined_adhoc_loc (set, loc, src_range, block); | |
| 1018 } | |
| 1019 | |
| 1020 extern void rebuild_location_adhoc_htab (struct line_maps *); | |
| 1021 | |
| 1022 /* Initialize a line map set. SET is the line map set to initialize | |
| 1023 and BUILTIN_LOCATION is the special location value to be used as | |
| 1024 spelling location for built-in tokens. This BUILTIN_LOCATION has | |
| 1025 to be strictly less than RESERVED_LOCATION_COUNT. */ | |
| 1026 extern void linemap_init (struct line_maps *set, | |
| 1027 source_location builtin_location); | |
| 0 | 1028 |
| 1029 /* Check for and warn about line_maps entered but not exited. */ | |
| 1030 | |
| 1031 extern void linemap_check_files_exited (struct line_maps *); | |
| 1032 | |
| 1033 /* Return a source_location for the start (i.e. column==0) of | |
| 1034 (physical) line TO_LINE in the current source file (as in the | |
| 1035 most recent linemap_add). MAX_COLUMN_HINT is the highest column | |
| 1036 number we expect to use in this line (but it does not change | |
| 1037 the highest_location). */ | |
| 1038 | |
| 1039 extern source_location linemap_line_start | |
| 1040 (struct line_maps *set, linenum_type to_line, unsigned int max_column_hint); | |
| 1041 | |
| 1042 /* Add a mapping of logical source line to physical source file and | |
| 111 | 1043 line number. This function creates an "ordinary map", which is a |
| 1044 map that records locations of tokens that are not part of macro | |
| 1045 replacement-lists present at a macro expansion point. | |
| 0 | 1046 |
| 1047 The text pointed to by TO_FILE must have a lifetime | |
| 111 | 1048 at least as long as the lifetime of SET. An empty |
| 0 | 1049 TO_FILE means standard input. If reason is LC_LEAVE, and |
| 1050 TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their | |
| 1051 natural values considering the file we are returning to. | |
| 1052 | |
| 1053 A call to this function can relocate the previous set of | |
| 1054 maps, so any stored line_map pointers should not be used. */ | |
| 1055 extern const struct line_map *linemap_add | |
| 1056 (struct line_maps *, enum lc_reason, unsigned int sysp, | |
| 1057 const char *to_file, linenum_type to_line); | |
| 1058 | |
| 111 | 1059 /* Given a logical source location, returns the map which the |
| 1060 corresponding (source file, line, column) triplet can be deduced | |
| 1061 from. Since the set is built chronologically, the logical lines are | |
| 1062 monotonic increasing, and so the list is sorted and we can use a | |
| 1063 binary search. If no line map have been allocated yet, this | |
| 1064 function returns NULL. */ | |
| 0 | 1065 extern const struct line_map *linemap_lookup |
| 1066 (struct line_maps *, source_location); | |
| 1067 | |
| 111 | 1068 /* Returns TRUE if the line table set tracks token locations across |
| 1069 macro expansion, FALSE otherwise. */ | |
| 1070 bool linemap_tracks_macro_expansion_locs_p (struct line_maps *); | |
| 1071 | |
| 1072 /* Return the name of the macro associated to MACRO_MAP. */ | |
| 1073 const char* linemap_map_get_macro_name (const line_map_macro *); | |
| 1074 | |
| 1075 /* Return a positive value if LOCATION is the locus of a token that is | |
| 1076 located in a system header, O otherwise. It returns 1 if LOCATION | |
| 1077 is the locus of a token that is located in a system header, and 2 | |
| 1078 if LOCATION is the locus of a token located in a C system header | |
| 1079 that therefore needs to be extern "C" protected in C++. | |
| 1080 | |
| 1081 Note that this function returns 1 if LOCATION belongs to a token | |
| 1082 that is part of a macro replacement-list defined in a system | |
| 1083 header, but expanded in a non-system file. */ | |
| 1084 int linemap_location_in_system_header_p (struct line_maps *, | |
| 1085 source_location); | |
| 1086 | |
| 1087 /* Return TRUE if LOCATION is a source code location of a token that is part of | |
| 1088 a macro expansion, FALSE otherwise. */ | |
| 1089 bool linemap_location_from_macro_expansion_p (const struct line_maps *, | |
| 1090 source_location); | |
| 1091 | |
| 1092 /* TRUE if LOCATION is a source code location of a token that is part of the | |
| 1093 definition of a macro, FALSE otherwise. */ | |
| 1094 bool linemap_location_from_macro_definition_p (struct line_maps *, | |
| 1095 source_location); | |
| 1096 | |
| 1097 /* With the precondition that LOCATION is the locus of a token that is | |
| 1098 an argument of a function-like macro MACRO_MAP and appears in the | |
| 1099 expansion of MACRO_MAP, return the locus of that argument in the | |
| 1100 context of the caller of MACRO_MAP. */ | |
| 1101 | |
| 1102 extern source_location linemap_macro_map_loc_unwind_toward_spelling | |
| 1103 (line_maps *set, const line_map_macro *macro_map, source_location location); | |
| 1104 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1105 /* source_location values from 0 to RESERVED_LOCATION_COUNT-1 will |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1106 be reserved for libcpp user as special values, no token from libcpp |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1107 will contain any of those locations. */ |
| 111 | 1108 const source_location RESERVED_LOCATION_COUNT = 2; |
| 0 | 1109 |
| 1110 /* Converts a map and a source_location to source line. */ | |
| 111 | 1111 inline linenum_type |
| 1112 SOURCE_LINE (const line_map_ordinary *ord_map, source_location loc) | |
| 1113 { | |
| 1114 return ((loc - ord_map->start_location) | |
| 1115 >> ord_map->m_column_and_range_bits) + ord_map->to_line; | |
| 1116 } | |
| 1117 | |
| 1118 /* Convert a map and source_location to source column number. */ | |
| 1119 inline linenum_type | |
| 1120 SOURCE_COLUMN (const line_map_ordinary *ord_map, source_location loc) | |
| 1121 { | |
| 1122 return ((loc - ord_map->start_location) | |
| 1123 & ((1 << ord_map->m_column_and_range_bits) - 1)) >> ord_map->m_range_bits; | |
| 1124 } | |
| 1125 | |
| 1126 /* Return the location of the last source line within an ordinary | |
| 1127 map. */ | |
| 1128 inline source_location | |
| 1129 LAST_SOURCE_LINE_LOCATION (const line_map_ordinary *map) | |
| 1130 { | |
| 1131 return (((map[1].start_location - 1 | |
| 1132 - map->start_location) | |
| 1133 & ~((1 << map->m_column_and_range_bits) - 1)) | |
| 1134 + map->start_location); | |
| 1135 } | |
| 1136 | |
| 1137 /* Returns the last source line number within an ordinary map. This | |
| 1138 is the (last) line of the #include, or other directive, that caused | |
| 1139 a map change. */ | |
| 1140 inline linenum_type | |
| 1141 LAST_SOURCE_LINE (const line_map_ordinary *map) | |
| 1142 { | |
| 1143 return SOURCE_LINE (map, LAST_SOURCE_LINE_LOCATION (map)); | |
| 1144 } | |
| 1145 | |
| 1146 /* Return the last column number within an ordinary map. */ | |
| 1147 | |
| 1148 inline linenum_type | |
| 1149 LAST_SOURCE_COLUMN (const line_map_ordinary *map) | |
| 1150 { | |
| 1151 return SOURCE_COLUMN (map, LAST_SOURCE_LINE_LOCATION (map)); | |
| 1152 } | |
| 1153 | |
| 1154 /* Returns the map a given map was included from, or NULL if the map | |
| 1155 belongs to the main file, i.e, a file that wasn't included by | |
| 1156 another one. */ | |
| 1157 inline line_map_ordinary * | |
| 1158 INCLUDED_FROM (struct line_maps *set, const line_map_ordinary *ord_map) | |
| 1159 { | |
| 1160 return ((ord_map->included_from == -1) | |
| 1161 ? NULL | |
| 1162 : LINEMAPS_ORDINARY_MAP_AT (set, ord_map->included_from)); | |
| 1163 } | |
| 1164 | |
| 1165 /* True if the map is at the bottom of the include stack. */ | |
| 1166 | |
| 1167 inline bool | |
| 1168 MAIN_FILE_P (const line_map_ordinary *ord_map) | |
| 1169 { | |
| 1170 return ord_map->included_from < 0; | |
| 1171 } | |
| 1172 | |
| 1173 /* Encode and return a source_location from a column number. The | |
| 1174 source line considered is the last source line used to call | |
| 1175 linemap_line_start, i.e, the last source line which a location was | |
| 1176 encoded from. */ | |
| 1177 extern source_location | |
| 1178 linemap_position_for_column (struct line_maps *, unsigned int); | |
| 1179 | |
| 1180 /* Encode and return a source location from a given line and | |
| 1181 column. */ | |
| 1182 source_location | |
| 1183 linemap_position_for_line_and_column (line_maps *set, | |
| 1184 const line_map_ordinary *, | |
| 1185 linenum_type, unsigned int); | |
| 1186 | |
| 1187 /* Encode and return a source_location starting from location LOC and | |
| 1188 shifting it by OFFSET columns. This function does not support | |
| 1189 virtual locations. */ | |
| 1190 source_location | |
| 1191 linemap_position_for_loc_and_offset (struct line_maps *set, | |
| 1192 source_location loc, | |
| 1193 unsigned int offset); | |
| 1194 | |
| 1195 /* Return the file this map is for. */ | |
| 1196 inline const char * | |
| 1197 LINEMAP_FILE (const line_map_ordinary *ord_map) | |
| 1198 { | |
| 1199 return ord_map->to_file; | |
| 1200 } | |
| 1201 | |
| 1202 /* Return the line number this map started encoding location from. */ | |
| 1203 inline linenum_type | |
| 1204 LINEMAP_LINE (const line_map_ordinary *ord_map) | |
| 1205 { | |
| 1206 return ord_map->to_line; | |
| 1207 } | |
| 0 | 1208 |
| 111 | 1209 /* Return a positive value if map encodes locations from a system |
| 1210 header, 0 otherwise. Returns 1 if MAP encodes locations in a | |
| 1211 system header and 2 if it encodes locations in a C system header | |
| 1212 that therefore needs to be extern "C" protected in C++. */ | |
| 1213 inline unsigned char | |
| 1214 LINEMAP_SYSP (const line_map_ordinary *ord_map) | |
| 1215 { | |
| 1216 return ord_map->sysp; | |
| 1217 } | |
| 1218 | |
| 1219 /* Return a positive value if PRE denotes the location of a token that | |
| 1220 comes before the token of POST, 0 if PRE denotes the location of | |
| 1221 the same token as the token for POST, and a negative value | |
| 1222 otherwise. */ | |
| 1223 int linemap_compare_locations (struct line_maps *set, | |
| 1224 source_location pre, | |
| 1225 source_location post); | |
| 1226 | |
| 1227 /* Return TRUE if LOC_A denotes the location a token that comes | |
| 1228 topogically before the token denoted by location LOC_B, or if they | |
| 1229 are equal. */ | |
| 1230 inline bool | |
| 1231 linemap_location_before_p (struct line_maps *set, | |
| 1232 source_location loc_a, | |
| 1233 source_location loc_b) | |
| 1234 { | |
| 1235 return linemap_compare_locations (set, loc_a, loc_b) >= 0; | |
| 1236 } | |
| 1237 | |
| 1238 typedef struct | |
| 1239 { | |
| 1240 /* The name of the source file involved. */ | |
| 1241 const char *file; | |
| 1242 | |
| 1243 /* The line-location in the source file. */ | |
| 1244 int line; | |
| 1245 | |
| 1246 int column; | |
| 1247 | |
| 1248 void *data; | |
| 1249 | |
| 1250 /* In a system header?. */ | |
| 1251 bool sysp; | |
| 1252 } expanded_location; | |
| 1253 | |
| 1254 /* Both gcc and emacs number source *lines* starting at 1, but | |
| 1255 they have differing conventions for *columns*. | |
| 1256 | |
| 1257 GCC uses a 1-based convention for source columns, | |
| 1258 whereas Emacs's M-x column-number-mode uses a 0-based convention. | |
| 1259 | |
| 1260 For example, an error in the initial, left-hand | |
| 1261 column of source line 3 is reported by GCC as: | |
| 1262 | |
| 1263 some-file.c:3:1: error: ...etc... | |
| 1264 | |
| 1265 On navigating to the location of that error in Emacs | |
| 1266 (e.g. via "next-error"), | |
| 1267 the locus is reported in the Mode Line | |
| 1268 (assuming M-x column-number-mode) as: | |
| 1269 | |
| 1270 some-file.c 10% (3, 0) | |
| 1271 | |
| 1272 i.e. "3:1:" in GCC corresponds to "(3, 0)" in Emacs. */ | |
| 1273 | |
| 1274 /* A location within a rich_location: a caret&range, with | |
| 1275 the caret potentially flagged for display. */ | |
| 1276 | |
| 1277 struct location_range | |
| 1278 { | |
| 1279 source_location m_loc; | |
| 1280 | |
| 1281 /* Should a caret be drawn for this range? Typically this is | |
| 1282 true for the 0th range, and false for subsequent ranges, | |
| 1283 but the Fortran frontend overrides this for rendering things like: | |
| 1284 | |
| 1285 x = x + y | |
| 1286 1 2 | |
| 1287 Error: Shapes for operands at (1) and (2) are not conformable | |
| 1288 | |
| 1289 where "1" and "2" are notionally carets. */ | |
| 1290 bool m_show_caret_p; | |
| 1291 }; | |
| 1292 | |
| 1293 /* A partially-embedded vec for use within rich_location for storing | |
| 1294 ranges and fix-it hints. | |
| 1295 | |
| 1296 Elements [0..NUM_EMBEDDED) are allocated within m_embed, after | |
| 1297 that they are within the dynamically-allocated m_extra. | |
| 1298 | |
| 1299 This allows for static allocation in the common case, whilst | |
| 1300 supporting the rarer case of an arbitrary number of elements. | |
| 1301 | |
| 1302 Dynamic allocation is not performed unless it's needed. */ | |
| 1303 | |
| 1304 template <typename T, int NUM_EMBEDDED> | |
| 1305 class semi_embedded_vec | |
| 1306 { | |
| 1307 public: | |
| 1308 semi_embedded_vec (); | |
| 1309 ~semi_embedded_vec (); | |
| 0 | 1310 |
| 111 | 1311 unsigned int count () const { return m_num; } |
| 1312 T& operator[] (int idx); | |
| 1313 const T& operator[] (int idx) const; | |
| 1314 | |
| 1315 void push (const T&); | |
| 1316 void truncate (int len); | |
| 1317 | |
| 1318 private: | |
| 1319 int m_num; | |
| 1320 T m_embedded[NUM_EMBEDDED]; | |
| 1321 int m_alloc; | |
| 1322 T *m_extra; | |
| 1323 }; | |
| 1324 | |
| 1325 /* Constructor for semi_embedded_vec. In particular, no dynamic allocation | |
| 1326 is done. */ | |
| 1327 | |
| 1328 template <typename T, int NUM_EMBEDDED> | |
| 1329 semi_embedded_vec<T, NUM_EMBEDDED>::semi_embedded_vec () | |
| 1330 : m_num (0), m_alloc (0), m_extra (NULL) | |
| 1331 { | |
| 1332 } | |
| 1333 | |
| 1334 /* semi_embedded_vec's dtor. Release any dynamically-allocated memory. */ | |
| 1335 | |
| 1336 template <typename T, int NUM_EMBEDDED> | |
| 1337 semi_embedded_vec<T, NUM_EMBEDDED>::~semi_embedded_vec () | |
| 1338 { | |
| 1339 XDELETEVEC (m_extra); | |
| 1340 } | |
| 1341 | |
| 1342 /* Look up element IDX, mutably. */ | |
| 1343 | |
| 1344 template <typename T, int NUM_EMBEDDED> | |
| 1345 T& | |
| 1346 semi_embedded_vec<T, NUM_EMBEDDED>::operator[] (int idx) | |
| 1347 { | |
| 1348 linemap_assert (idx < m_num); | |
| 1349 if (idx < NUM_EMBEDDED) | |
| 1350 return m_embedded[idx]; | |
| 1351 else | |
| 1352 { | |
| 1353 linemap_assert (m_extra != NULL); | |
| 1354 return m_extra[idx - NUM_EMBEDDED]; | |
| 1355 } | |
| 1356 } | |
| 1357 | |
| 1358 /* Look up element IDX (const). */ | |
| 1359 | |
| 1360 template <typename T, int NUM_EMBEDDED> | |
| 1361 const T& | |
| 1362 semi_embedded_vec<T, NUM_EMBEDDED>::operator[] (int idx) const | |
| 1363 { | |
| 1364 linemap_assert (idx < m_num); | |
| 1365 if (idx < NUM_EMBEDDED) | |
| 1366 return m_embedded[idx]; | |
| 1367 else | |
| 1368 { | |
| 1369 linemap_assert (m_extra != NULL); | |
| 1370 return m_extra[idx - NUM_EMBEDDED]; | |
| 1371 } | |
| 1372 } | |
| 1373 | |
| 1374 /* Append VALUE to the end of the semi_embedded_vec. */ | |
| 1375 | |
| 1376 template <typename T, int NUM_EMBEDDED> | |
| 1377 void | |
| 1378 semi_embedded_vec<T, NUM_EMBEDDED>::push (const T& value) | |
| 1379 { | |
| 1380 int idx = m_num++; | |
| 1381 if (idx < NUM_EMBEDDED) | |
| 1382 m_embedded[idx] = value; | |
| 1383 else | |
| 1384 { | |
| 1385 /* Offset "idx" to be an index within m_extra. */ | |
| 1386 idx -= NUM_EMBEDDED; | |
| 1387 if (NULL == m_extra) | |
| 1388 { | |
| 1389 linemap_assert (m_alloc == 0); | |
| 1390 m_alloc = 16; | |
| 1391 m_extra = XNEWVEC (T, m_alloc); | |
| 1392 } | |
| 1393 else if (idx >= m_alloc) | |
| 1394 { | |
| 1395 linemap_assert (m_alloc > 0); | |
| 1396 m_alloc *= 2; | |
| 1397 m_extra = XRESIZEVEC (T, m_extra, m_alloc); | |
| 1398 } | |
| 1399 linemap_assert (m_extra); | |
| 1400 linemap_assert (idx < m_alloc); | |
| 1401 m_extra[idx] = value; | |
| 1402 } | |
| 1403 } | |
| 1404 | |
| 1405 /* Truncate to length LEN. No deallocation is performed. */ | |
| 0 | 1406 |
| 111 | 1407 template <typename T, int NUM_EMBEDDED> |
| 1408 void | |
| 1409 semi_embedded_vec<T, NUM_EMBEDDED>::truncate (int len) | |
| 1410 { | |
| 1411 linemap_assert (len <= m_num); | |
| 1412 m_num = len; | |
| 1413 } | |
| 1414 | |
| 1415 class fixit_hint; | |
| 1416 | |
| 1417 /* A "rich" source code location, for use when printing diagnostics. | |
| 1418 A rich_location has one or more carets&ranges, where the carets | |
| 1419 are optional. These are referred to as "ranges" from here. | |
| 1420 Typically the zeroth range has a caret; other ranges sometimes | |
| 1421 have carets. | |
| 1422 | |
| 1423 The "primary" location of a rich_location is the caret of range 0, | |
| 1424 used for determining the line/column when printing diagnostic | |
| 1425 text, such as: | |
| 1426 | |
| 1427 some-file.c:3:1: error: ...etc... | |
| 1428 | |
| 1429 Additional ranges may be added to help the user identify other | |
| 1430 pertinent clauses in a diagnostic. | |
| 1431 | |
| 1432 rich_location instances are intended to be allocated on the stack | |
| 1433 when generating diagnostics, and to be short-lived. | |
| 1434 | |
| 1435 Examples of rich locations | |
| 1436 -------------------------- | |
| 1437 | |
| 1438 Example A | |
| 1439 ********* | |
| 1440 int i = "foo"; | |
| 1441 ^ | |
| 1442 This "rich" location is simply a single range (range 0), with | |
| 1443 caret = start = finish at the given point. | |
| 1444 | |
| 1445 Example B | |
| 1446 ********* | |
| 1447 a = (foo && bar) | |
| 1448 ~~~~~^~~~~~~ | |
| 1449 This rich location has a single range (range 0), with the caret | |
| 1450 at the first "&", and the start/finish at the parentheses. | |
| 1451 Compare with example C below. | |
| 1452 | |
| 1453 Example C | |
| 1454 ********* | |
| 1455 a = (foo && bar) | |
| 1456 ~~~ ^~ ~~~ | |
| 1457 This rich location has three ranges: | |
| 1458 - Range 0 has its caret and start location at the first "&" and | |
| 1459 end at the second "&. | |
| 1460 - Range 1 has its start and finish at the "f" and "o" of "foo"; | |
| 1461 the caret is not flagged for display, but is perhaps at the "f" | |
| 1462 of "foo". | |
| 1463 - Similarly, range 2 has its start and finish at the "b" and "r" of | |
| 1464 "bar"; the caret is not flagged for display, but is perhaps at the | |
| 1465 "b" of "bar". | |
| 1466 Compare with example B above. | |
| 1467 | |
| 1468 Example D (Fortran frontend) | |
| 1469 **************************** | |
| 1470 x = x + y | |
| 1471 1 2 | |
| 1472 This rich location has range 0 at "1", and range 1 at "2". | |
| 1473 Both are flagged for caret display. Both ranges have start/finish | |
| 1474 equal to their caret point. The frontend overrides the diagnostic | |
| 1475 context's default caret character for these ranges. | |
| 1476 | |
| 1477 Example E | |
| 1478 ********* | |
| 1479 printf ("arg0: %i arg1: %s arg2: %i", | |
| 1480 ^~ | |
| 1481 100, 101, 102); | |
| 1482 ~~~ | |
| 1483 This rich location has two ranges: | |
| 1484 - range 0 is at the "%s" with start = caret = "%" and finish at | |
| 1485 the "s". | |
| 1486 - range 1 has start/finish covering the "101" and is not flagged for | |
| 1487 caret printing; it is perhaps at the start of "101". | |
| 1488 | |
| 1489 | |
| 1490 Fix-it hints | |
| 1491 ------------ | |
| 1492 | |
| 1493 Rich locations can also contain "fix-it hints", giving suggestions | |
| 1494 for the user on how to edit their code to fix a problem. These | |
| 1495 can be expressed as insertions, replacements, and removals of text. | |
| 1496 The edits by default are relative to the zeroth range within the | |
| 1497 rich_location, but optionally they can be expressed relative to | |
| 1498 other locations (using various overloaded methods of the form | |
| 1499 rich_location::add_fixit_*). | |
| 1500 | |
| 1501 For example: | |
| 1502 | |
| 1503 Example F: fix-it hint: insert_before | |
| 1504 ************************************* | |
| 1505 ptr = arr[0]; | |
| 1506 ^~~~~~ | |
| 1507 & | |
| 1508 This rich location has a single range (range 0) covering "arr[0]", | |
| 1509 with the caret at the start. The rich location has a single | |
| 1510 insertion fix-it hint, inserted before range 0, added via | |
| 1511 richloc.add_fixit_insert_before ("&"); | |
| 0 | 1512 |
| 111 | 1513 Example G: multiple fix-it hints: insert_before and insert_after |
| 1514 **************************************************************** | |
| 1515 #define FN(ARG0, ARG1, ARG2) fn(ARG0, ARG1, ARG2) | |
| 1516 ^~~~ ^~~~ ^~~~ | |
| 1517 ( ) ( ) ( ) | |
| 1518 This rich location has three ranges, covering "arg0", "arg1", | |
| 1519 and "arg2", all with caret-printing enabled. | |
| 1520 The rich location has 6 insertion fix-it hints: each arg | |
| 1521 has a pair of insertion fix-it hints, suggesting wrapping | |
| 1522 them with parentheses: one a '(' inserted before, | |
| 1523 the other a ')' inserted after, added via | |
| 1524 richloc.add_fixit_insert_before (LOC, "("); | |
| 1525 and | |
| 1526 richloc.add_fixit_insert_after (LOC, ")"); | |
| 1527 | |
| 1528 Example H: fix-it hint: removal | |
| 1529 ******************************* | |
| 1530 struct s {int i};; | |
| 1531 ^ | |
| 1532 - | |
| 1533 This rich location has a single range at the stray trailing | |
| 1534 semicolon, along with a single removal fix-it hint, covering | |
| 1535 the same range, added via: | |
| 1536 richloc.add_fixit_remove (); | |
| 1537 | |
| 1538 Example I: fix-it hint: replace | |
| 1539 ******************************* | |
| 1540 c = s.colour; | |
| 1541 ^~~~~~ | |
| 1542 color | |
| 1543 This rich location has a single range (range 0) covering "colour", | |
| 1544 and a single "replace" fix-it hint, covering the same range, | |
| 1545 added via | |
| 1546 richloc.add_fixit_replace ("color"); | |
| 1547 | |
| 1548 Adding a fix-it hint can fail: for example, attempts to insert content | |
| 1549 at the transition between two line maps may fail due to there being no | |
| 1550 source_location (aka location_t) value to express the new location. | |
| 1551 | |
| 1552 Attempts to add a fix-it hint within a macro expansion will fail. | |
| 1553 | |
| 1554 There is only limited support for newline characters in fix-it hints: | |
| 1555 only hints with newlines which insert an entire new line are permitted, | |
| 1556 inserting at the start of a line, and finishing with a newline | |
| 1557 (with no interior newline characters). Other attempts to add | |
| 1558 fix-it hints containing newline characters will fail. | |
| 1559 Similarly, attempts to delete or replace a range *affecting* multiple | |
| 1560 lines will fail. | |
| 1561 | |
| 1562 The rich_location API handles these failures gracefully, so that | |
| 1563 diagnostics can attempt to add fix-it hints without each needing | |
| 1564 extensive checking. | |
| 1565 | |
| 1566 Fix-it hints within a rich_location are "atomic": if any hints can't | |
| 1567 be applied, none of them will be (tracked by the m_seen_impossible_fixit | |
| 1568 flag), and no fix-its hints will be displayed for that rich_location. | |
| 1569 This implies that diagnostic messages need to be worded in such a way | |
| 1570 that they make sense whether or not the fix-it hints are displayed, | |
| 1571 or that richloc.seen_impossible_fixit_p () should be checked before | |
| 1572 issuing the diagnostics. */ | |
| 1573 | |
| 1574 class rich_location | |
| 1575 { | |
| 1576 public: | |
| 1577 /* Constructors. */ | |
| 1578 | |
| 1579 /* Constructing from a location. */ | |
| 1580 rich_location (line_maps *set, source_location loc); | |
| 1581 | |
| 1582 /* Destructor. */ | |
| 1583 ~rich_location (); | |
| 1584 | |
| 1585 /* Accessors. */ | |
| 1586 source_location get_loc () const { return get_loc (0); } | |
| 1587 source_location get_loc (unsigned int idx) const; | |
| 1588 | |
| 1589 void | |
| 1590 add_range (source_location loc, bool show_caret_p); | |
| 1591 | |
| 1592 void | |
| 1593 set_range (line_maps *set, unsigned int idx, source_location loc, | |
| 1594 bool show_caret_p); | |
| 1595 | |
| 1596 unsigned int get_num_locations () const { return m_ranges.count (); } | |
| 1597 | |
| 1598 const location_range *get_range (unsigned int idx) const; | |
| 1599 location_range *get_range (unsigned int idx); | |
| 1600 | |
| 1601 expanded_location get_expanded_location (unsigned int idx); | |
| 1602 | |
| 1603 void | |
| 1604 override_column (int column); | |
| 1605 | |
| 1606 /* Fix-it hints. */ | |
| 1607 | |
| 1608 /* Methods for adding insertion fix-it hints. */ | |
| 0 | 1609 |
| 111 | 1610 /* Suggest inserting NEW_CONTENT immediately before the primary |
| 1611 range's start. */ | |
| 1612 void | |
| 1613 add_fixit_insert_before (const char *new_content); | |
| 1614 | |
| 1615 /* Suggest inserting NEW_CONTENT immediately before the start of WHERE. */ | |
| 1616 void | |
| 1617 add_fixit_insert_before (source_location where, | |
| 1618 const char *new_content); | |
| 1619 | |
| 1620 /* Suggest inserting NEW_CONTENT immediately after the end of the primary | |
| 1621 range. */ | |
| 1622 void | |
| 1623 add_fixit_insert_after (const char *new_content); | |
| 1624 | |
| 1625 /* Suggest inserting NEW_CONTENT immediately after the end of WHERE. */ | |
| 1626 void | |
| 1627 add_fixit_insert_after (source_location where, | |
| 1628 const char *new_content); | |
| 1629 | |
| 1630 /* Methods for adding removal fix-it hints. */ | |
| 1631 | |
| 1632 /* Suggest removing the content covered by range 0. */ | |
| 1633 void | |
| 1634 add_fixit_remove (); | |
| 1635 | |
| 1636 /* Suggest removing the content covered between the start and finish | |
| 1637 of WHERE. */ | |
| 1638 void | |
| 1639 add_fixit_remove (source_location where); | |
| 1640 | |
| 1641 /* Suggest removing the content covered by SRC_RANGE. */ | |
| 1642 void | |
| 1643 add_fixit_remove (source_range src_range); | |
| 1644 | |
| 1645 /* Methods for adding "replace" fix-it hints. */ | |
| 1646 | |
| 1647 /* Suggest replacing the content covered by range 0 with NEW_CONTENT. */ | |
| 1648 void | |
| 1649 add_fixit_replace (const char *new_content); | |
| 1650 | |
| 1651 /* Suggest replacing the content between the start and finish of | |
| 1652 WHERE with NEW_CONTENT. */ | |
| 1653 void | |
| 1654 add_fixit_replace (source_location where, | |
| 1655 const char *new_content); | |
| 1656 | |
| 1657 /* Suggest replacing the content covered by SRC_RANGE with | |
| 1658 NEW_CONTENT. */ | |
| 1659 void | |
| 1660 add_fixit_replace (source_range src_range, | |
| 1661 const char *new_content); | |
| 1662 | |
| 1663 unsigned int get_num_fixit_hints () const { return m_fixit_hints.count (); } | |
| 1664 fixit_hint *get_fixit_hint (int idx) const { return m_fixit_hints[idx]; } | |
| 1665 fixit_hint *get_last_fixit_hint () const; | |
| 1666 bool seen_impossible_fixit_p () const { return m_seen_impossible_fixit; } | |
| 1667 | |
| 1668 /* Set this if the fix-it hints are not suitable to be | |
| 1669 automatically applied. | |
| 1670 | |
| 1671 For example, if you are suggesting more than one | |
| 1672 mutually exclusive solution to a problem, then | |
| 1673 it doesn't make sense to apply all of the solutions; | |
| 1674 manual intervention is required. | |
| 1675 | |
| 1676 If set, then the fix-it hints in the rich_location will | |
| 1677 be printed, but will not be added to generated patches, | |
| 1678 or affect the modified version of the file. */ | |
| 1679 void fixits_cannot_be_auto_applied () | |
| 1680 { | |
| 1681 m_fixits_cannot_be_auto_applied = true; | |
| 1682 } | |
| 1683 | |
| 1684 bool fixits_can_be_auto_applied_p () const | |
| 1685 { | |
| 1686 return !m_fixits_cannot_be_auto_applied; | |
| 1687 } | |
| 1688 | |
| 1689 private: | |
| 1690 bool reject_impossible_fixit (source_location where); | |
| 1691 void stop_supporting_fixits (); | |
| 1692 void maybe_add_fixit (source_location start, | |
| 1693 source_location next_loc, | |
| 1694 const char *new_content); | |
| 1695 | |
| 1696 public: | |
| 1697 static const int STATICALLY_ALLOCATED_RANGES = 3; | |
| 1698 | |
| 1699 protected: | |
| 1700 line_maps *m_line_table; | |
| 1701 semi_embedded_vec <location_range, STATICALLY_ALLOCATED_RANGES> m_ranges; | |
| 1702 | |
| 1703 int m_column_override; | |
| 1704 | |
| 1705 bool m_have_expanded_location; | |
| 1706 expanded_location m_expanded_location; | |
| 1707 | |
| 1708 static const int MAX_STATIC_FIXIT_HINTS = 2; | |
| 1709 semi_embedded_vec <fixit_hint *, MAX_STATIC_FIXIT_HINTS> m_fixit_hints; | |
| 1710 | |
| 1711 bool m_seen_impossible_fixit; | |
| 1712 bool m_fixits_cannot_be_auto_applied; | |
| 1713 }; | |
| 0 | 1714 |
| 111 | 1715 /* A fix-it hint: a suggested insertion, replacement, or deletion of text. |
| 1716 We handle these three types of edit with one class, by representing | |
| 1717 them as replacement of a half-open range: | |
| 1718 [start, next_loc) | |
| 1719 Insertions have start == next_loc: "replace" the empty string at the | |
| 1720 start location with the new string. | |
| 1721 Deletions are replacement with the empty string. | |
| 1722 | |
| 1723 There is only limited support for newline characters in fix-it hints | |
| 1724 as noted above in the comment for class rich_location. | |
| 1725 A fixit_hint instance can have at most one newline character; if | |
| 1726 present, the newline character must be the final character of | |
| 1727 the content (preventing e.g. fix-its that split a pre-existing line). */ | |
| 1728 | |
| 1729 class fixit_hint | |
| 1730 { | |
| 1731 public: | |
| 1732 fixit_hint (source_location start, | |
| 1733 source_location next_loc, | |
| 1734 const char *new_content); | |
| 1735 ~fixit_hint () { free (m_bytes); } | |
| 1736 | |
| 1737 bool affects_line_p (const char *file, int line) const; | |
| 1738 source_location get_start_loc () const { return m_start; } | |
| 1739 source_location get_next_loc () const { return m_next_loc; } | |
| 1740 bool maybe_append (source_location start, | |
| 1741 source_location next_loc, | |
| 1742 const char *new_content); | |
| 1743 | |
| 1744 const char *get_string () const { return m_bytes; } | |
| 1745 size_t get_length () const { return m_len; } | |
| 1746 | |
| 1747 bool insertion_p () const { return m_start == m_next_loc; } | |
| 1748 | |
| 1749 bool ends_with_newline_p () const; | |
| 1750 | |
| 1751 private: | |
| 1752 /* We don't use source_range here since, unlike most places, | |
| 1753 this is a half-open/half-closed range: | |
| 1754 [start, next_loc) | |
| 1755 so that we can support insertion via start == next_loc. */ | |
| 1756 source_location m_start; | |
| 1757 source_location m_next_loc; | |
| 1758 char *m_bytes; | |
| 1759 size_t m_len; | |
| 1760 }; | |
| 1761 | |
| 1762 | |
| 1763 /* This is enum is used by the function linemap_resolve_location | |
| 1764 below. The meaning of the values is explained in the comment of | |
| 1765 that function. */ | |
| 1766 enum location_resolution_kind | |
| 1767 { | |
| 1768 LRK_MACRO_EXPANSION_POINT, | |
| 1769 LRK_SPELLING_LOCATION, | |
| 1770 LRK_MACRO_DEFINITION_LOCATION | |
| 1771 }; | |
| 1772 | |
| 1773 /* Resolve a virtual location into either a spelling location, an | |
| 1774 expansion point location or a token argument replacement point | |
| 1775 location. Return the map that encodes the virtual location as well | |
| 1776 as the resolved location. | |
| 1777 | |
| 1778 If LOC is *NOT* the location of a token resulting from the | |
| 1779 expansion of a macro, then the parameter LRK (which stands for | |
| 1780 Location Resolution Kind) is ignored and the resulting location | |
| 1781 just equals the one given in argument. | |
| 1782 | |
| 1783 Now if LOC *IS* the location of a token resulting from the | |
| 1784 expansion of a macro, this is what happens. | |
| 1785 | |
| 1786 * If LRK is set to LRK_MACRO_EXPANSION_POINT | |
| 1787 ------------------------------- | |
| 1788 | |
| 1789 The virtual location is resolved to the first macro expansion point | |
| 1790 that led to this macro expansion. | |
| 1791 | |
| 1792 * If LRK is set to LRK_SPELLING_LOCATION | |
| 1793 ------------------------------------- | |
| 1794 | |
| 1795 The virtual location is resolved to the locus where the token has | |
| 1796 been spelled in the source. This can follow through all the macro | |
| 1797 expansions that led to the token. | |
| 1798 | |
| 1799 * If LRK is set to LRK_MACRO_DEFINITION_LOCATION | |
| 1800 -------------------------------------- | |
| 1801 | |
| 1802 The virtual location is resolved to the locus of the token in the | |
| 1803 context of the macro definition. | |
| 1804 | |
| 1805 If LOC is the locus of a token that is an argument of a | |
| 1806 function-like macro [replacing a parameter in the replacement list | |
| 1807 of the macro] the virtual location is resolved to the locus of the | |
| 1808 parameter that is replaced, in the context of the definition of the | |
| 1809 macro. | |
| 1810 | |
| 1811 If LOC is the locus of a token that is not an argument of a | |
| 1812 function-like macro, then the function behaves as if LRK was set to | |
| 1813 LRK_SPELLING_LOCATION. | |
| 1814 | |
| 1815 If LOC_MAP is not NULL, *LOC_MAP is set to the map encoding the | |
| 1816 returned location. Note that if the returned location wasn't originally | |
| 1817 encoded by a map, the *MAP is set to NULL. This can happen if LOC | |
| 1818 resolves to a location reserved for the client code, like | |
| 1819 UNKNOWN_LOCATION or BUILTINS_LOCATION in GCC. */ | |
| 0 | 1820 |
| 111 | 1821 source_location linemap_resolve_location (struct line_maps *, |
| 1822 source_location loc, | |
| 1823 enum location_resolution_kind lrk, | |
| 1824 const line_map_ordinary **loc_map); | |
| 1825 | |
| 1826 /* Suppose that LOC is the virtual location of a token coming from the | |
| 1827 expansion of a macro M. This function then steps up to get the | |
| 1828 location L of the point where M got expanded. If L is a spelling | |
| 1829 location inside a macro expansion M', then this function returns | |
| 1830 the point where M' was expanded. LOC_MAP is an output parameter. | |
| 1831 When non-NULL, *LOC_MAP is set to the map of the returned | |
| 1832 location. */ | |
| 1833 source_location linemap_unwind_toward_expansion (struct line_maps *, | |
| 1834 source_location loc, | |
| 1835 const struct line_map **loc_map); | |
| 1836 | |
| 1837 /* If LOC is the virtual location of a token coming from the expansion | |
| 1838 of a macro M and if its spelling location is reserved (e.g, a | |
| 1839 location for a built-in token), then this function unwinds (using | |
| 1840 linemap_unwind_toward_expansion) the location until a location that | |
| 1841 is not reserved and is not in a system header is reached. In other | |
| 1842 words, this unwinds the reserved location until a location that is | |
| 1843 in real source code is reached. | |
| 1844 | |
| 1845 Otherwise, if the spelling location for LOC is not reserved or if | |
| 1846 LOC doesn't come from the expansion of a macro, the function | |
| 1847 returns LOC as is and *MAP is not touched. | |
| 1848 | |
| 1849 *MAP is set to the map of the returned location if the later is | |
| 1850 different from LOC. */ | |
| 1851 source_location linemap_unwind_to_first_non_reserved_loc (struct line_maps *, | |
| 1852 source_location loc, | |
| 1853 const struct line_map **map); | |
| 1854 | |
| 1855 /* Expand source code location LOC and return a user readable source | |
| 1856 code location. LOC must be a spelling (non-virtual) location. If | |
| 1857 it's a location < RESERVED_LOCATION_COUNT a zeroed expanded source | |
| 1858 location is returned. */ | |
| 1859 expanded_location linemap_expand_location (struct line_maps *, | |
| 1860 const struct line_map *, | |
| 1861 source_location loc); | |
| 1862 | |
| 1863 /* Statistics about maps allocation and usage as returned by | |
| 1864 linemap_get_statistics. */ | |
| 1865 struct linemap_stats | |
| 1866 { | |
| 1867 long num_ordinary_maps_allocated; | |
| 1868 long num_ordinary_maps_used; | |
| 1869 long ordinary_maps_allocated_size; | |
| 1870 long ordinary_maps_used_size; | |
| 1871 long num_expanded_macros; | |
| 1872 long num_macro_tokens; | |
| 1873 long num_macro_maps_used; | |
| 1874 long macro_maps_allocated_size; | |
| 1875 long macro_maps_used_size; | |
| 1876 long macro_maps_locations_size; | |
| 1877 long duplicated_macro_maps_locations_size; | |
| 1878 long adhoc_table_size; | |
| 1879 long adhoc_table_entries_used; | |
| 1880 }; | |
| 1881 | |
| 1882 /* Return the highest location emitted for a given file for which | |
| 1883 there is a line map in SET. FILE_NAME is the file name to | |
| 1884 consider. If the function returns TRUE, *LOC is set to the highest | |
| 1885 location emitted for that file. */ | |
| 1886 bool linemap_get_file_highest_location (struct line_maps * set, | |
| 1887 const char *file_name, | |
| 1888 source_location *loc); | |
| 1889 | |
| 1890 /* Compute and return statistics about the memory consumption of some | |
| 1891 parts of the line table SET. */ | |
| 1892 void linemap_get_statistics (struct line_maps *, struct linemap_stats *); | |
| 1893 | |
| 1894 /* Dump debugging information about source location LOC into the file | |
| 1895 stream STREAM. SET is the line map set LOC comes from. */ | |
| 1896 void linemap_dump_location (struct line_maps *, source_location, FILE *); | |
| 1897 | |
| 1898 /* Dump line map at index IX in line table SET to STREAM. If STREAM | |
| 1899 is NULL, use stderr. IS_MACRO is true if the caller wants to | |
| 1900 dump a macro map, false otherwise. */ | |
| 1901 void linemap_dump (FILE *, struct line_maps *, unsigned, bool); | |
| 1902 | |
| 1903 /* Dump line table SET to STREAM. If STREAM is NULL, stderr is used. | |
| 1904 NUM_ORDINARY specifies how many ordinary maps to dump. NUM_MACRO | |
| 1905 specifies how many macro maps to dump. */ | |
| 1906 void line_table_dump (FILE *, struct line_maps *, unsigned int, unsigned int); | |
| 1907 | |
| 1908 /* An enum for distinguishing the various parts within a source_location. */ | |
| 1909 | |
| 1910 enum location_aspect | |
| 1911 { | |
| 1912 LOCATION_ASPECT_CARET, | |
| 1913 LOCATION_ASPECT_START, | |
| 1914 LOCATION_ASPECT_FINISH | |
| 1915 }; | |
| 1916 | |
| 1917 /* The rich_location class requires a way to expand source_location instances. | |
| 1918 We would directly use expand_location_to_spelling_point, which is | |
| 1919 implemented in gcc/input.c, but we also need to use it for rich_location | |
| 1920 within genmatch.c. | |
| 1921 Hence we require client code of libcpp to implement the following | |
| 1922 symbol. */ | |
| 1923 extern expanded_location | |
| 1924 linemap_client_expand_location_to_spelling_point (source_location, | |
| 1925 enum location_aspect); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1926 |
| 0 | 1927 #endif /* !LIBCPP_LINE_MAP_H */ |