CbC/CbC_gcc: libcpp/include/line-map.h comparison

comparison libcpp/include/line-map.h @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* Map (unsigned int) keys to (source file, line, column) triples.
-Copyright (C) 2001-2018 Free Software Foundation, Inc.
+Copyright (C) 2001-2020 Free Software Foundation, Inc.
 This program is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 3, or (at your option) any
 later version.
 i.e. "3:1:" in GCC corresponds to "(3, 0)" in Emacs.  */
 /* The type of line numbers.  */
 typedef unsigned int linenum_type;
+/* A type for doing arithmetic on line numbers.  */
+typedef long long linenum_arith_t;
 /* A function for for use by qsort for comparing line numbers.  */
 inline int compare (linenum_type lhs, linenum_type rhs)
 {
-/* Avoid truncation issues by using long long for the comparison,
+/* Avoid truncation issues by using linenum_arith_t for the comparison,
 and only consider the sign of the result.  */
-long long diff = (long long)lhs - (long long)rhs;
+linenum_arith_t diff = (linenum_arith_t)lhs - (linenum_arith_t)rhs;
 if (diff)
 return diff > 0 ? 1 : -1;
 return 0;
 }
 LC_ENTER_MACRO,	/* Begin macro expansion.  */
 /* FIXME: add support for stringize and paste.  */
 LC_HWM /* High Water Mark.  */
 };
-/* The typedef "source_location" is a key within the location database,
+/* The typedef "location_t" is a key within the location database,
 identifying a source location or macro expansion, along with range
 information, and (optionally) a pointer for use by gcc.
 This key only has meaning in relation to a line_maps instance.  Within
 gcc there is a single line_maps instance: "line_table", declared in
 | macromap[m-2]->start_location | Start of penultimate macro map
 -----------+-------------------------------+-------------------------------
 | macromap[1]->start_location   | Start of macro map 1
 -----------+-------------------------------+-------------------------------
 | macromap[0]->start_location   | Start of macro map 0
-0x7fffffff | MAX_SOURCE_LOCATION           | Also used as a mask for
+0x7fffffff | MAX_LOCATION_T                | Also used as a mask for
 |                               | accessing the ad-hoc data table
 -----------+-------------------------------+-------------------------------
 0x80000000 | Start of ad-hoc values; the lower 31 bits are used as an index
 ...        | into the line_table->location_adhoc_data_map.data array.
 0xffffffff | UINT_MAX                      |
 == ordmap->start + 0x171e0
 finish == ordmap->start + (23 << 12) + (19 << 5)
 == ordmap->start + 0x17260
-To further see how source_location works in practice, see the
+To further see how location_t works in practice, see the
 worked example in libcpp/location-example.txt.  */
-typedef unsigned int source_location;
+typedef unsigned int location_t;
 /* Do not track column numbers higher than this one.  As a result, the
 range of column_bits is [12, 18] (or 0 if column numbers are
 disabled).  */
 const unsigned int LINE_MAP_MAX_COLUMN_NUMBER = (1U << 12);
 /* Do not pack ranges if locations get higher than this.
 If you change this, update:
 gcc.dg/plugin/location-overflow-test-*.c.  */
-const source_location LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES = 0x50000000;
+const location_t LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES = 0x50000000;
 /* Do not track column numbers if locations get higher than this.
 If you change this, update:
 gcc.dg/plugin/location-overflow-test-*.c.  */
-const source_location LINE_MAP_MAX_LOCATION_WITH_COLS = 0x60000000;
+const location_t LINE_MAP_MAX_LOCATION_WITH_COLS = 0x60000000;
 /* Highest possible source location encoded within an ordinary map.  */
-const source_location LINE_MAP_MAX_LOCATION = 0x70000000;
+const location_t LINE_MAP_MAX_LOCATION = 0x70000000;
 /* A range of source locations.
 Ranges are closed:
 m_start is the first location within the range,
 We may need a more compact way to store these, but for now,
 let's do it the simple way, as a pair.  */
 struct GTY(()) source_range
 {
-source_location m_start;
+location_t m_start;
-source_location m_finish;
+location_t m_finish;
 /* We avoid using constructors, since various structs that
 don't yet have constructors will embed instances of
 source_range.  */
-/* Make a source_range from a source_location.  */
+/* Make a source_range from a location_t.  */
-static source_range from_location (source_location loc)
+static source_range from_location (location_t loc)
 {
 source_range result;
 result.m_start = loc;
 result.m_finish = loc;
 return result;
 }
-/* Make a source_range from a pair of source_location.  */
+/* Make a source_range from a pair of location_t.  */
-static source_range from_locations (source_location start,
+static source_range from_locations (location_t start,
-				      source_location finish)
+				      location_t finish)
 {
 source_range result;
 result.m_start = start;
 result.m_finish = finish;
 return result;
 of PLUS.  */
 /* This contains GTY mark-up to support precompiled headers.
 line_map is an abstract class, only derived objects exist.  */
 struct GTY((tag ("0"), desc ("MAP_ORDINARY_P (&%h) ? 1 : 2"))) line_map {
-source_location start_location;
+location_t start_location;
 /* Size and alignment is (usually) 4 bytes.  */
 };
 /* An ordinary line map encodes physical source locations. Those
 long as C<(1<<effective range bits), and the result_location is less than
 the next line_map's start_location.
 (The top line is line 1 and the leftmost column is column 1; line/column 0
 means "entire file/line" or "unknown line/column" or "not applicable".)
-The highest possible source location is MAX_SOURCE_LOCATION.  */
+The highest possible source location is MAX_LOCATION_T.  */
 struct GTY((tag ("1"))) line_map_ordinary : public line_map {
 /* Base class is 4 bytes.  */
 /* 4 bytes of integers, each 1 byte for easy extraction/insertion.  */
 that therefore needs to be extern "C" protected in C++, and zero
 otherwise.  This field isn't really needed now that it's in
 cpp_buffer.  */
 unsigned char sysp;
-/* Number of the low-order source_location bits used for column numbers
+/* Number of the low-order location_t bits used for column numbers
 and ranges.  */
 unsigned int m_column_and_range_bits : 8;
 /* Number of the low-order "column" bits used for storing short ranges
 inline, rather than in the ad-hoc table.
 linenum_type to_line;
 /* Location from whence this line map was included.  For regular
 #includes, this location will be the last location of a map.  For
 outermost file, this is 0.  */
-source_location included_from;
+location_t included_from;
 /* Size is 20 or 24 bytes, no padding  */
 };
 /* This is the highest possible source location encoded within an
 ordinary or macro map.  */
-const source_location MAX_SOURCE_LOCATION = 0x7FFFFFFF;
+const location_t MAX_LOCATION_T = 0x7FFFFFFF;
 struct cpp_hashnode;
 /* A macro line map encodes location of tokens coming from a macro
 expansion.
 (the token) might come from.
 In the example above x1 (for token "+") is going to be the same
 as y1.  x0 is the spelling location for the argument token "1",
 and x2 is the spelling location for the argument token "2".  */
-source_location * GTY((atomic)) macro_locations;
+location_t * GTY((atomic)) macro_locations;
 /* This is the location of the expansion point of the current macro
 map.  It's the location of the macro name.  That location is held
 by the map that was current right before the current one. It
 could have been either a macro or an ordinary map, depending on
 if we are in a nested expansion context not.  */
-source_location expansion;
+location_t expansion;
 /* Size is 20 or 32 (4 bytes padding on 64-bit).  */
 };
 #if CHECKING_P && (GCC_VERSION >= 2007)
 /* Include EXPR, so that unused variable warnings do not occur.  */
 #define linemap_assert(EXPR) ((void)(0 && (EXPR)))
 #define linemap_assert_fails(EXPR) (! (EXPR))
 #endif
+/* Get whether location LOC is an ad-hoc, ordinary or macro location.  */
+inline bool
+IS_ORDINARY_LOC (location_t loc)
+{
+return loc < LINE_MAP_MAX_LOCATION;
+}
+inline bool
+IS_ADHOC_LOC (location_t loc)
+{
+return loc > MAX_LOCATION_T;
+}
+inline bool
+IS_MACRO_LOC (location_t loc)
+{
+return !IS_ORDINARY_LOC (loc) && !IS_ADHOC_LOC (loc);
+}
 /* Categorize line map kinds.  */
 inline bool
 MAP_ORDINARY_P (const line_map *map)
 {
-return map->start_location < LINE_MAP_MAX_LOCATION;
+return IS_ORDINARY_LOC (map->start_location);
 }
 /* Return TRUE if MAP encodes locations coming from a macro
 replacement-list at macro expansion point.  */
 bool
-linemap_macro_expansion_map_p (const struct line_map *);
+linemap_macro_expansion_map_p (const line_map *);
 /* Assert that MAP encodes locations of tokens that are not part of
 the replacement-list of a macro expansion, downcasting from
 line_map * to line_map_ordinary *.  */
 inline line_map_ordinary *
-linemap_check_ordinary (struct line_map *map)
+linemap_check_ordinary (line_map *map)
 {
 linemap_assert (MAP_ORDINARY_P (map));
 return (line_map_ordinary *)map;
 }
 /* Assert that MAP encodes locations of tokens that are not part of
 the replacement-list of a macro expansion, downcasting from
 const line_map * to const line_map_ordinary *.  */
 inline const line_map_ordinary *
-linemap_check_ordinary (const struct line_map *map)
+linemap_check_ordinary (const line_map *map)
 {
 linemap_assert (MAP_ORDINARY_P (map));
 return (const line_map_ordinary *)map;
 }
 return (const line_map_macro *)map;
 }
 /* Read the start location of MAP.  */
-inline source_location
+inline location_t
 MAP_START_LOCATION (const line_map *map)
 {
 return map->start_location;
 }
 }
 /* Get the array of pairs of locations within macro map MAP.
 See the declaration of line_map_macro for more information.  */
-inline source_location *
+inline location_t *
 MACRO_MAP_LOCATIONS (const line_map_macro *macro_map)
 {
 return macro_map->macro_locations;
 }
 /* Get the location of the expansion point of the macro map MAP.  */
-inline source_location
+inline location_t
 MACRO_MAP_EXPANSION_POINT_LOCATION (const line_map_macro *macro_map)
 {
 return macro_map->expansion;
 }
 /* The number of elements used in maps. This number is smaller
 or equal to ALLOCATED.  */
 unsigned int used;
-unsigned int cache;
+mutable unsigned int cache;
 };
 struct GTY(()) maps_info_macro {
 /* This array contains the macro line maps.
 A macro line map is created whenever a macro expansion occurs.  */
 /* The number of elements used in maps. This number is smaller
 or equal to ALLOCATED.  */
 unsigned int used;
-unsigned int cache;
+mutable unsigned int cache;
 };
 /* Data structure to associate a source_range together with an arbitrary
 data pointer with a source location.  */
 struct GTY(()) location_adhoc_data {
-source_location locus;
+location_t locus;
 source_range src_range;
 void * GTY((skip)) data;
 };
 struct htab;
 bits of the integer is used to index the location_adhoc_data array,
 in which the locus and associated data is stored.  */
 struct GTY(()) location_adhoc_data_map {
 struct htab * GTY((skip)) htab;
-source_location curr_loc;
+location_t curr_loc;
 unsigned int allocated;
 struct location_adhoc_data GTY((length ("%h.allocated"))) *data;
 };
 /* A set of chronological line_map structures.  */
-struct GTY(()) line_maps {
+class GTY(()) line_maps {
+public:
 ~line_maps ();
 maps_info_ordinary info_ordinary;
 unsigned int depth;
 /* If true, prints an include trace a la -H.  */
 bool trace_includes;
-/* Highest source_location "given out".  */
+/* Highest location_t "given out".  */
-source_location highest_location;
+location_t highest_location;
-/* Start of line of highest source_location "given out".  */
+/* Start of line of highest location_t "given out".  */
-source_location highest_line;
+location_t highest_line;
 /* The maximum column number we can quickly allocate.  Higher numbers
 may require allocating a new line_map.  */
 unsigned int max_column_hint;
 struct location_adhoc_data_map location_adhoc_data_map;
 /* The special location value that is used as spelling location for
 built-in tokens.  */
-source_location builtin_location;
+location_t builtin_location;
 /* True if we've seen a #line or # 44 "file" directive.  */
 bool seen_line_directive;
 /* The default value of range_bits in ordinary line maps.  */
 }
 /* Returns the index of the last map that was looked up with
 linemap_lookup. MAP_KIND shall be TRUE if we are interested in
 macro maps, FALSE otherwise.  */
-inline unsigned int
+inline unsigned int &
 LINEMAPS_CACHE (const line_maps *set, bool map_kind)
-{
-if (map_kind)
-return set->info_macro.cache;
-else
-return set->info_ordinary.cache;
-}
-/* As above, but by reference (e.g. as an lvalue).  */
-inline unsigned int &
-LINEMAPS_CACHE (line_maps *set, bool map_kind)
 {
 if (map_kind)
 return set->info_macro.cache;
 else
 return set->info_ordinary.cache;
 /* Returns the INDEXth ordinary map.  */
 inline line_map_ordinary *
 LINEMAPS_ORDINARY_MAP_AT (const line_maps *set, int index)
 {
-linemap_assert (index >= 0);
+linemap_assert (index >= 0
-linemap_assert ((unsigned int)index < set->info_ordinary.used);
+		  && (unsigned int)index < LINEMAPS_USED (set, false));
-return &set->info_ordinary.maps[index];
+return (line_map_ordinary *)LINEMAPS_MAP_AT (set, false, index);
 }
 /* Return the number of ordinary maps allocated in the line table
 SET.  */
 inline unsigned int
 return LINEMAPS_USED (set, false);
 }
 /* Return the index of the last ordinary map that was looked up with
 linemap_lookup.  */
-inline unsigned int
+inline unsigned int &
 LINEMAPS_ORDINARY_CACHE (const line_maps *set)
-{
-return LINEMAPS_CACHE (set, false);
-}
-/* As above, but by reference (e.g. as an lvalue).  */
-inline unsigned int &
-LINEMAPS_ORDINARY_CACHE (line_maps *set)
 {
 return LINEMAPS_CACHE (set, false);
 }
 /* Returns a pointer to the last ordinary map used in the line table
 /* Returns the INDEXth macro map.  */
 inline line_map_macro *
 LINEMAPS_MACRO_MAP_AT (const line_maps *set, int index)
 {
-linemap_assert (index >= 0);
+linemap_assert (index >= 0
-linemap_assert ((unsigned int)index < set->info_macro.used);
+		  && (unsigned int)index < LINEMAPS_USED (set, true));
-return &set->info_macro.maps[index];
+return (line_map_macro *)LINEMAPS_MAP_AT (set, true, index);
 }
 /* Returns the number of macro maps that were allocated in the line
 table SET.  */
 inline unsigned int
 LINEMAPS_MACRO_USED (const line_maps *set)
 {
 return LINEMAPS_USED (set, true);
 }
-/* Returns the index of the last macro map looked up with
+/* Return the index of the last macro map that was looked up with
 linemap_lookup.  */
-inline unsigned int
+inline unsigned int &
 LINEMAPS_MACRO_CACHE (const line_maps *set)
-{
-return LINEMAPS_CACHE (set, true);
-}
-/* As above, but by reference (e.g. as an lvalue).  */
-inline unsigned int &
-LINEMAPS_MACRO_CACHE (line_maps *set)
 {
 return LINEMAPS_CACHE (set, true);
 }
 /* Returns the last macro map used in the line table SET.  */
 return (line_map_macro *)LINEMAPS_LAST_MAP (set, true);
 }
 /* Returns the lowest location [of a token resulting from macro
 expansion] encoded in this line table.  */
-inline source_location
+inline location_t
 LINEMAPS_MACRO_LOWEST_LOCATION (const line_maps *set)
 {
 return LINEMAPS_MACRO_USED (set)
 ? MAP_START_LOCATION (LINEMAPS_LAST_MACRO_MAP (set))
-: MAX_SOURCE_LOCATION + 1;
+: MAX_LOCATION_T + 1;
 }
 /* Returns the last macro map allocated in the line table SET.  */
 inline line_map_macro *
 LINEMAPS_LAST_ALLOCATED_MACRO_MAP (const line_maps *set)
 {
 return (line_map_macro *)LINEMAPS_LAST_ALLOCATED_MAP (set, true);
 }
-extern source_location get_combined_adhoc_loc (struct line_maps *,
+extern location_t get_combined_adhoc_loc (class line_maps *,
-					       source_location,
+					       location_t,
 					       source_range,
 					       void *);
-extern void *get_data_from_adhoc_loc (struct line_maps *, source_location);
+extern void *get_data_from_adhoc_loc (const line_maps *, location_t);
-extern source_location get_location_from_adhoc_loc (struct line_maps *,
+extern location_t get_location_from_adhoc_loc (const line_maps *,
-						    source_location);
+						    location_t);
-extern source_range get_range_from_loc (line_maps *set, source_location loc);
+extern source_range get_range_from_loc (line_maps *set, location_t loc);
-/* Get whether location LOC is an ad-hoc location.  */
-inline bool
-IS_ADHOC_LOC (source_location loc)
-{
-return (loc & MAX_SOURCE_LOCATION) != loc;
-}
 /* Get whether location LOC is a "pure" location, or
 whether it is an ad-hoc location, or embeds range information.  */
 bool
-pure_location_p (line_maps *set, source_location loc);
+pure_location_p (line_maps *set, location_t loc);
 /* Given location LOC within SET, strip away any packed range information
 or ad-hoc information.  */
-extern source_location get_pure_location (line_maps *set,
+extern location_t get_pure_location (line_maps *set,
-					  source_location loc);
+					  location_t loc);
 /* Combine LOC and BLOCK, giving a combined adhoc location.  */
-inline source_location
+inline location_t
-COMBINE_LOCATION_DATA (struct line_maps *set,
+COMBINE_LOCATION_DATA (class line_maps *set,
-		       source_location loc,
+		       location_t loc,
 		       source_range src_range,
 		       void *block)
 {
 return get_combined_adhoc_loc (set, loc, src_range, block);
 }
-extern void rebuild_location_adhoc_htab (struct line_maps *);
+extern void rebuild_location_adhoc_htab (class line_maps *);
 /* Initialize a line map set.  SET is the line map set to initialize
 and BUILTIN_LOCATION is the special location value to be used as
 spelling location for built-in tokens.  This BUILTIN_LOCATION has
 to be strictly less than RESERVED_LOCATION_COUNT.  */
-extern void linemap_init (struct line_maps *set,
+extern void linemap_init (class line_maps *set,
-			  source_location builtin_location);
+			  location_t builtin_location);
 /* Check for and warn about line_maps entered but not exited.  */
-extern void linemap_check_files_exited (struct line_maps *);
+extern void linemap_check_files_exited (class line_maps *);
-/* Return a source_location for the start (i.e. column==0) of
+/* Return a location_t for the start (i.e. column==0) of
 (physical) line TO_LINE in the current source file (as in the
 most recent linemap_add).   MAX_COLUMN_HINT is the highest column
 number we expect to use in this line (but it does not change
 the highest_location).  */
-extern source_location linemap_line_start
+extern location_t linemap_line_start
-(struct line_maps *set, linenum_type to_line,  unsigned int max_column_hint);
+(class line_maps *set, linenum_type to_line,  unsigned int max_column_hint);
 /* Add a mapping of logical source line to physical source file and
 line number. This function creates an "ordinary map", which is a
 map that records locations of tokens that are not part of macro
 replacement-lists present at a macro expansion point.
 TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their
 natural values considering the file we are returning to.
 A call to this function can relocate the previous set of
 maps, so any stored line_map pointers should not be used.  */
-extern const struct line_map *linemap_add
+extern const line_map *linemap_add
-(struct line_maps *, enum lc_reason, unsigned int sysp,
+(class line_maps *, enum lc_reason, unsigned int sysp,
 const char *to_file, linenum_type to_line);
 /* Given a logical source location, returns the map which the
 corresponding (source file, line, column) triplet can be deduced
 from. Since the set is built chronologically, the logical lines are
 monotonic increasing, and so the list is sorted and we can use a
 binary search. If no line map have been allocated yet, this
 function returns NULL.  */
-extern const struct line_map *linemap_lookup
+extern const line_map *linemap_lookup
-(struct line_maps *, source_location);
+(const line_maps *, location_t);
 /* Returns TRUE if the line table set tracks token locations across
 macro expansion, FALSE otherwise.  */
-bool linemap_tracks_macro_expansion_locs_p (struct line_maps *);
+bool linemap_tracks_macro_expansion_locs_p (class line_maps *);
 /* Return the name of the macro associated to MACRO_MAP.  */
 const char* linemap_map_get_macro_name (const line_map_macro *);
 /* Return a positive value if LOCATION is the locus of a token that is
 that therefore needs to be extern "C" protected in C++.
 Note that this function returns 1 if LOCATION belongs to a token
 that is part of a macro replacement-list defined in a system
 header, but expanded in a non-system file.  */
-int linemap_location_in_system_header_p (struct line_maps *,
+int linemap_location_in_system_header_p (class line_maps *,
-					 source_location);
+					 location_t);
 /* Return TRUE if LOCATION is a source code location of a token that is part of
 a macro expansion, FALSE otherwise.  */
-bool linemap_location_from_macro_expansion_p (const struct line_maps *,
+bool linemap_location_from_macro_expansion_p (const line_maps *,
-					      source_location);
+					      location_t);
 /* TRUE if LOCATION is a source code location of a token that is part of the
 definition of a macro, FALSE otherwise.  */
-bool linemap_location_from_macro_definition_p (struct line_maps *,
+bool linemap_location_from_macro_definition_p (class line_maps *,
-					       source_location);
+					       location_t);
 /* With the precondition that LOCATION is the locus of a token that is
 an argument of a function-like macro MACRO_MAP and appears in the
 expansion of MACRO_MAP, return the locus of that argument in the
 context of the caller of MACRO_MAP.  */
-extern source_location linemap_macro_map_loc_unwind_toward_spelling
+extern location_t linemap_macro_map_loc_unwind_toward_spelling
-(line_maps *set, const line_map_macro *macro_map, source_location location);
+(line_maps *set, const line_map_macro *macro_map, location_t location);
-/* source_location values from 0 to RESERVED_LOCATION_COUNT-1 will
+/* location_t values from 0 to RESERVED_LOCATION_COUNT-1 will
 be reserved for libcpp user as special values, no token from libcpp
 will contain any of those locations.  */
-const source_location RESERVED_LOCATION_COUNT = 2;
+const location_t RESERVED_LOCATION_COUNT = 2;
-/* Converts a map and a source_location to source line.  */
+/* Converts a map and a location_t to source line.  */
 inline linenum_type
-SOURCE_LINE (const line_map_ordinary *ord_map, source_location loc)
+SOURCE_LINE (const line_map_ordinary *ord_map, location_t loc)
 {
 return ((loc - ord_map->start_location)
 	  >> ord_map->m_column_and_range_bits) + ord_map->to_line;
 }
-/* Convert a map and source_location to source column number.  */
+/* Convert a map and location_t to source column number.  */
 inline linenum_type
-SOURCE_COLUMN (const line_map_ordinary *ord_map, source_location loc)
+SOURCE_COLUMN (const line_map_ordinary *ord_map, location_t loc)
 {
 return ((loc - ord_map->start_location)
 	  & ((1 << ord_map->m_column_and_range_bits) - 1)) >> ord_map->m_range_bits;
 }
-inline source_location
+inline location_t
 linemap_included_from (const line_map_ordinary *ord_map)
 {
 return ord_map->included_from;
 }
 MAIN_FILE_P (const line_map_ordinary *ord_map)
 {
 return ord_map->included_from == 0;
 }
-/* Encode and return a source_location from a column number. The
+/* Encode and return a location_t from a column number. The
 source line considered is the last source line used to call
 linemap_line_start, i.e, the last source line which a location was
 encoded from.  */
-extern source_location
+extern location_t
-linemap_position_for_column (struct line_maps *, unsigned int);
+linemap_position_for_column (class line_maps *, unsigned int);
 /* Encode and return a source location from a given line and
 column.  */
-source_location
+location_t
 linemap_position_for_line_and_column (line_maps *set,
 				      const line_map_ordinary *,
 				      linenum_type, unsigned int);
-/* Encode and return a source_location starting from location LOC and
+/* Encode and return a location_t starting from location LOC and
 shifting it by OFFSET columns.  This function does not support
 virtual locations.  */
-source_location
+location_t
-linemap_position_for_loc_and_offset (struct line_maps *set,
+linemap_position_for_loc_and_offset (class line_maps *set,
-				     source_location loc,
+				     location_t loc,
 				     unsigned int offset);
 /* Return the file this map is for.  */
 inline const char *
 LINEMAP_FILE (const line_map_ordinary *ord_map)
 /* Return a positive value if PRE denotes the location of a token that
 comes before the token of POST, 0 if PRE denotes the location of
 the same token as the token for POST, and a negative value
 otherwise.  */
-int linemap_compare_locations (struct line_maps *set,
+int linemap_compare_locations (class line_maps *set,
-			       source_location   pre,
+			       location_t   pre,
-			       source_location   post);
+			       location_t   post);
 /* Return TRUE if LOC_A denotes the location a token that comes
 topogically before the token denoted by location LOC_B, or if they
 are equal.  */
 inline bool
-linemap_location_before_p (struct line_maps *set,
+linemap_location_before_p (class line_maps *set,
-			   source_location loc_a,
+			   location_t loc_a,
-			   source_location loc_b)
+			   location_t loc_b)
 {
 return linemap_compare_locations (set, loc_a, loc_b) >= 0;
 }
 typedef struct
 the caret potentially flagged for display, and an optional
 label.  */
 struct location_range
 {
-source_location m_loc;
+location_t m_loc;
 enum range_display_kind m_range_display_kind;
 /* If non-NULL, the label for this range.  */
 const range_label *m_label;
 linemap_assert (len <= m_num);
 m_num = len;
 }
 class fixit_hint;
+class diagnostic_path;
 /* A "rich" source code location, for use when printing diagnostics.
 A rich_location has one or more carets&ranges, where the carets
 are optional.  These are referred to as "ranges" from here.
 Typically the zeroth range has a caret; other ranges sometimes
 on the "i" of int).  It has a insertion fix-it hint of the string
 "#include <stdio.h>\n".
 Adding a fix-it hint can fail: for example, attempts to insert content
 at the transition between two line maps may fail due to there being no
-source_location (aka location_t) value to express the new location.
+location_t value to express the new location.
 Attempts to add a fix-it hint within a macro expansion will fail.
 There is only limited support for newline characters in fix-it hints:
 only hints with newlines which insert an entire new line are permitted,
 {
 public:
 /* Constructors.  */
 /* Constructing from a location.  */
-rich_location (line_maps *set, source_location loc,
+rich_location (line_maps *set, location_t loc,
 		 const range_label *label = NULL);
 /* Destructor.  */
 ~rich_location ();
 /* Accessors.  */
-source_location get_loc () const { return get_loc (0); }
+location_t get_loc () const { return get_loc (0); }
-source_location get_loc (unsigned int idx) const;
+location_t get_loc (unsigned int idx) const;
 void
-add_range (source_location loc,
+add_range (location_t loc,
 	     enum range_display_kind range_display_kind
 	       = SHOW_RANGE_WITHOUT_CARET,
 	     const range_label *label = NULL);
 void
-set_range (unsigned int idx, source_location loc,
+set_range (unsigned int idx, location_t loc,
 	     enum range_display_kind range_display_kind);
 unsigned int get_num_locations () const { return m_ranges.count (); }
 const location_range *get_range (unsigned int idx) const;
 void
 add_fixit_insert_before (const char *new_content);
 /* Suggest inserting NEW_CONTENT immediately before the start of WHERE.  */
 void
-add_fixit_insert_before (source_location where,
+add_fixit_insert_before (location_t where,
 			   const char *new_content);
 /* Suggest inserting NEW_CONTENT immediately after the end of the primary
 range.  */
 void
 add_fixit_insert_after (const char *new_content);
 /* Suggest inserting NEW_CONTENT immediately after the end of WHERE.  */
 void
-add_fixit_insert_after (source_location where,
+add_fixit_insert_after (location_t where,
 			  const char *new_content);
 /* Methods for adding removal fix-it hints.  */
 /* Suggest removing the content covered by range 0.  */
 add_fixit_remove ();
 /* Suggest removing the content covered between the start and finish
 of WHERE.  */
 void
-add_fixit_remove (source_location where);
+add_fixit_remove (location_t where);
 /* Suggest removing the content covered by SRC_RANGE.  */
 void
 add_fixit_remove (source_range src_range);
 add_fixit_replace (const char *new_content);
 /* Suggest replacing the content between the start and finish of
 WHERE with NEW_CONTENT.  */
 void
-add_fixit_replace (source_location where,
+add_fixit_replace (location_t where,
 		     const char *new_content);
 /* Suggest replacing the content covered by SRC_RANGE with
 NEW_CONTENT.  */
 void
 bool fixits_can_be_auto_applied_p () const
 {
 return !m_fixits_cannot_be_auto_applied;
 }
+/* An optional path through the code.  */
+const diagnostic_path *get_path () const { return m_path; }
+void set_path (const diagnostic_path *path) { m_path = path; }
 private:
-bool reject_impossible_fixit (source_location where);
+bool reject_impossible_fixit (location_t where);
 void stop_supporting_fixits ();
-void maybe_add_fixit (source_location start,
+void maybe_add_fixit (location_t start,
-			source_location next_loc,
+			location_t next_loc,
 			const char *new_content);
 public:
 static const int STATICALLY_ALLOCATED_RANGES = 3;
 static const int MAX_STATIC_FIXIT_HINTS = 2;
 semi_embedded_vec <fixit_hint *, MAX_STATIC_FIXIT_HINTS> m_fixit_hints;
 bool m_seen_impossible_fixit;
 bool m_fixits_cannot_be_auto_applied;
+const diagnostic_path *m_path;
 };
 /* A struct for the result of range_label::get_text: a NUL-terminated buffer
 of localized text, and a flag to determine if the caller should "free" the
 buffer.  */
-struct label_text
+class label_text
 {
+public:
 label_text ()
 : m_buffer (NULL), m_caller_owned (false)
-{}
-label_text (char *buffer, bool caller_owned)
-: m_buffer (buffer), m_caller_owned (caller_owned)
 {}
 void maybe_free ()
 {
 if (m_caller_owned)
 free (m_buffer);
 }
+/* Create a label_text instance that borrows BUFFER from a
+longer-lived owner.  */
+static label_text borrow (const char *buffer)
+{
+return label_text (const_cast <char *> (buffer), false);
+}
+/* Create a label_text instance that takes ownership of BUFFER.  */
+static label_text take (char *buffer)
+{
+return label_text (buffer, true);
+}
+/* Take ownership of the buffer, copying if necessary.  */
+char *take_or_copy ()
+{
+if (m_caller_owned)
+return m_buffer;
+else
+return xstrdup (m_buffer);
+}
 char *m_buffer;
 bool m_caller_owned;
+private:
+label_text (char *buffer, bool owned)
+: m_buffer (buffer), m_caller_owned (owned)
+{}
 };
 /* Abstract base class for labelling a range within a rich_location
 (e.g. for labelling expressions with their type).
 the content (preventing e.g. fix-its that split a pre-existing line).  */
 class fixit_hint
 {
 public:
-fixit_hint (source_location start,
+fixit_hint (location_t start,
-	      source_location next_loc,
+	      location_t next_loc,
 	      const char *new_content);
 ~fixit_hint () { free (m_bytes); }
 bool affects_line_p (const char *file, int line) const;
-source_location get_start_loc () const { return m_start; }
+location_t get_start_loc () const { return m_start; }
-source_location get_next_loc () const { return m_next_loc; }
+location_t get_next_loc () const { return m_next_loc; }
-bool maybe_append (source_location start,
+bool maybe_append (location_t start,
-		     source_location next_loc,
+		     location_t next_loc,
 		     const char *new_content);
 const char *get_string () const { return m_bytes; }
 size_t get_length () const { return m_len; }
 private:
 /* We don't use source_range here since, unlike most places,
 this is a half-open/half-closed range:
 [start, next_loc)
 so that we can support insertion via start == next_loc.  */
-source_location m_start;
+location_t m_start;
-source_location m_next_loc;
+location_t m_next_loc;
 char *m_bytes;
 size_t m_len;
 };
 returned location.  Note that if the returned location wasn't originally
 encoded by a map, the *MAP is set to NULL.  This can happen if LOC
 resolves to a location reserved for the client code, like
 UNKNOWN_LOCATION or BUILTINS_LOCATION in GCC.  */
-source_location linemap_resolve_location (struct line_maps *,
+location_t linemap_resolve_location (class line_maps *,
-					  source_location loc,
+				     location_t loc,
-					  enum location_resolution_kind lrk,
+				     enum location_resolution_kind lrk,
-					  const line_map_ordinary **loc_map);
+				     const line_map_ordinary **loc_map);
 /* Suppose that LOC is the virtual location of a token coming from the
 expansion of a macro M.  This function then steps up to get the
 location L of the point where M got expanded.  If L is a spelling
 location inside a macro expansion M', then this function returns
 the point where M' was expanded.  LOC_MAP is an output parameter.
 When non-NULL, *LOC_MAP is set to the map of the returned
 location.  */
-source_location linemap_unwind_toward_expansion (struct line_maps *,
+location_t linemap_unwind_toward_expansion (class line_maps *,
-						 source_location loc,
+					    location_t loc,
-						 const struct line_map **loc_map);
+					    const line_map **loc_map);
 /* If LOC is the virtual location of a token coming from the expansion
 of a macro M and if its spelling location is reserved (e.g, a
 location for a built-in token), then this function unwinds (using
 linemap_unwind_toward_expansion) the location until a location that
 LOC doesn't come from the expansion of a macro, the function
 returns LOC as is and *MAP is not touched.
 *MAP is set to the map of the returned location if the later is
 different from LOC.  */
-source_location linemap_unwind_to_first_non_reserved_loc (struct line_maps *,
+location_t linemap_unwind_to_first_non_reserved_loc (class line_maps *,
-							  source_location loc,
+						     location_t loc,
-							  const struct line_map **map);
+						     const line_map **map);
 /* Expand source code location LOC and return a user readable source
 code location.  LOC must be a spelling (non-virtual) location.  If
 it's a location < RESERVED_LOCATION_COUNT a zeroed expanded source
 location is returned.  */
-expanded_location linemap_expand_location (struct line_maps *,
+expanded_location linemap_expand_location (class line_maps *,
-					   const struct line_map *,
+					   const line_map *,
-					   source_location loc);
+					   location_t loc);
 /* Statistics about maps allocation and usage as returned by
 linemap_get_statistics.  */
 struct linemap_stats
 {
 /* Return the highest location emitted for a given file for which
 there is a line map in SET.  FILE_NAME is the file name to
 consider.  If the function returns TRUE, *LOC is set to the highest
 location emitted for that file.  */
-bool linemap_get_file_highest_location (struct line_maps * set,
+bool linemap_get_file_highest_location (class line_maps * set,
 					const char *file_name,
-					source_location *loc);
+					location_t *loc);
 /* Compute and return statistics about the memory consumption of some
 parts of the line table SET.  */
-void linemap_get_statistics (struct line_maps *, struct linemap_stats *);
+void linemap_get_statistics (line_maps *, struct linemap_stats *);
 /* Dump debugging information about source location LOC into the file
 stream STREAM. SET is the line map set LOC comes from.  */
-void linemap_dump_location (struct line_maps *, source_location, FILE *);
+void linemap_dump_location (line_maps *, location_t, FILE *);
 /* Dump line map at index IX in line table SET to STREAM.  If STREAM
 is NULL, use stderr.  IS_MACRO is true if the caller wants to
 dump a macro map, false otherwise.  */
-void linemap_dump (FILE *, struct line_maps *, unsigned, bool);
+void linemap_dump (FILE *, line_maps *, unsigned, bool);
 /* Dump line table SET to STREAM.  If STREAM is NULL, stderr is used.
 NUM_ORDINARY specifies how many ordinary maps to dump.  NUM_MACRO
 specifies how many macro maps to dump.  */
-void line_table_dump (FILE *, struct line_maps *, unsigned int, unsigned int);
+void line_table_dump (FILE *, line_maps *, unsigned int, unsigned int);
-/* An enum for distinguishing the various parts within a source_location.  */
+/* An enum for distinguishing the various parts within a location_t.  */
 enum location_aspect
 {
 LOCATION_ASPECT_CARET,
 LOCATION_ASPECT_START,
 LOCATION_ASPECT_FINISH
 };
-/* The rich_location class requires a way to expand source_location instances.
+/* The rich_location class requires a way to expand location_t instances.
 We would directly use expand_location_to_spelling_point, which is
 implemented in gcc/input.c, but we also need to use it for rich_location
 within genmatch.c.
 Hence we require client code of libcpp to implement the following
 symbol.  */
 extern expanded_location
-linemap_client_expand_location_to_spelling_point (source_location,
+linemap_client_expand_location_to_spelling_point (location_t,
 						  enum location_aspect);
 #endif /* !LIBCPP_LINE_MAP_H  */

Mercurial > hg > CbC > CbC_gcc

comparison libcpp/include/line-map.h @ 145:1830386684a0