120 lines
4.7 KiB
C
120 lines
4.7 KiB
C
/* Map logical line numbers to (source file, line number) pairs.
|
|
Copyright (C) 2001
|
|
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 2, or (at your option) any
|
|
later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
In other words, you are welcome to use, share and improve this program.
|
|
You are forbidden to forbid anyone else to use, share and improve
|
|
what you give them. Help stamp out software-hoarding! */
|
|
|
|
#ifndef GCC_LINE_MAP_H
|
|
#define GCC_LINE_MAP_H
|
|
|
|
/* Reason for adding a line change with add_line_map (). LC_ENTER is
|
|
when including a new file, e.g. a #include directive in C.
|
|
LC_LEAVE is when reaching a file's end. LC_RENAME is when a file
|
|
name or line number changes for neither of the above reasons
|
|
(e.g. a #line directive in C). */
|
|
enum lc_reason {LC_ENTER = 0, LC_LEAVE, LC_RENAME};
|
|
|
|
/* The logical line FROM_LINE maps to physical source file TO_FILE at
|
|
line TO_LINE, and subsequently one-to-one until the next line_map
|
|
structure in the set. INCLUDED_FROM is an index into the set that
|
|
gives the line mapping at whose end the current one was included.
|
|
File(s) at the bottom of the include stack have this set to -1.
|
|
REASON is the reason for creation of this line map, SYSP is one for
|
|
a system header, two for a C system header file that therefore
|
|
needs to be extern "C" protected in C++, and zero otherwise. */
|
|
struct line_map
|
|
{
|
|
const char *to_file;
|
|
unsigned int to_line;
|
|
unsigned int from_line;
|
|
int included_from;
|
|
ENUM_BITFIELD (lc_reason) reason : CHAR_BIT;
|
|
unsigned char sysp;
|
|
};
|
|
|
|
/* A set of chronological line_map structures. */
|
|
struct line_maps
|
|
{
|
|
struct line_map *maps;
|
|
unsigned int allocated;
|
|
unsigned int used;
|
|
|
|
/* The most recently listed include stack, if any, starts with
|
|
LAST_LISTED as the topmost including file. -1 indicates nothing
|
|
has been listed yet. */
|
|
int last_listed;
|
|
|
|
/* Depth of the include stack, including the current file. */
|
|
unsigned int depth;
|
|
|
|
/* If true, prints an include trace a la -H. */
|
|
bool trace_includes;
|
|
};
|
|
|
|
/* Initialize a line map set. */
|
|
extern void init_line_maps
|
|
PARAMS ((struct line_maps *));
|
|
|
|
/* Free a line map set. */
|
|
extern void free_line_maps
|
|
PARAMS ((struct line_maps *));
|
|
|
|
/* Add a mapping of logical source line to physical source file and
|
|
line number. The text pointed to by TO_FILE must have a lifetime
|
|
at least as long as the line maps. If reason is LC_LEAVE, and
|
|
TO_FILE is NULL, then TO_FILE, TO_LINE and SYSP are given their
|
|
natural values considering the file we are returning to.
|
|
|
|
FROM_LINE should be monotonic increasing across calls to this
|
|
function. 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 *add_line_map
|
|
PARAMS ((struct line_maps *, enum lc_reason, unsigned int sysp,
|
|
unsigned int from_line, const char *to_file, unsigned int to_line));
|
|
|
|
/* Given a logical line, returns the map from which the corresponding
|
|
(source file, line) pair can be deduced. */
|
|
extern const struct line_map *lookup_line
|
|
PARAMS ((struct line_maps *, unsigned int));
|
|
|
|
/* Print the file names and line numbers of the #include commands
|
|
which led to the map MAP, if any, to stderr. Nothing is output if
|
|
the most recently listed stack is the same as the current one. */
|
|
extern void print_containing_files
|
|
PARAMS ((struct line_maps *, const struct line_map *));
|
|
|
|
/* Converts a map and logical line to source line. */
|
|
#define SOURCE_LINE(MAP, LINE) ((LINE) + (MAP)->to_line - (MAP)->from_line)
|
|
|
|
/* Returns the last source line within a map. This is the (last) line
|
|
of the #include, or other directive, that caused a map change. */
|
|
#define LAST_SOURCE_LINE(MAP) SOURCE_LINE ((MAP), (MAP)[1].from_line - 1)
|
|
|
|
/* Returns the map a given map was included from. */
|
|
#define INCLUDED_FROM(SET, MAP) (&(SET)->maps[(MAP)->included_from])
|
|
|
|
/* Non-zero if the map is at the bottom of the include stack. */
|
|
#define MAIN_FILE_P(MAP) ((MAP)->included_from < 0)
|
|
|
|
/* The current line map. Saves a call to lookup_line if the caller is
|
|
sure he is in the scope of the current map. */
|
|
#define CURRENT_LINE_MAP(MAPS) ((MAPS)->maps + (MAPS)->used - 1)
|
|
|
|
#endif /* !GCC_LINE_MAP_H */
|