| /* Diagnostic subroutines for printing source-code |
| Copyright (C) 1999-2016 Free Software Foundation, Inc. |
| Contributed by Gabriel Dos Reis <gdr@codesourcery.com> |
| |
| This file is part of GCC. |
| |
| GCC 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. |
| |
| GCC 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 GCC; see the file COPYING3. If not see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #include "config.h" |
| #include "system.h" |
| #include "coretypes.h" |
| #include "version.h" |
| #include "demangle.h" |
| #include "intl.h" |
| #include "backtrace.h" |
| #include "diagnostic.h" |
| #include "diagnostic-color.h" |
| |
| #ifdef HAVE_TERMIOS_H |
| # include <termios.h> |
| #endif |
| |
| #ifdef GWINSZ_IN_SYS_IOCTL |
| # include <sys/ioctl.h> |
| #endif |
| |
| /* Classes for rendering source code and diagnostics, within an |
| anonymous namespace. |
| The work is done by "class layout", which embeds and uses |
| "class colorizer" and "class layout_range" to get things done. */ |
| |
| namespace { |
| |
| /* The state at a given point of the source code, assuming that we're |
| in a range: which range are we in, and whether we should draw a caret at |
| this point. */ |
| |
| struct point_state |
| { |
| int range_idx; |
| bool draw_caret_p; |
| }; |
| |
| /* A class to inject colorization codes when printing the diagnostic locus. |
| |
| It has one kind of colorization for each of: |
| - normal text |
| - range 0 (the "primary location") |
| - range 1 |
| - range 2 |
| |
| The class caches the lookup of the color codes for the above. |
| |
| The class also has responsibility for tracking which of the above is |
| active, filtering out unnecessary changes. This allows |
| layout::print_source_line and layout::print_annotation_line |
| to simply request a colorization code for *every* character they print, |
| via this class, and have the filtering be done for them here. */ |
| |
| class colorizer |
| { |
| public: |
| colorizer (diagnostic_context *context, |
| const diagnostic_info *diagnostic); |
| ~colorizer (); |
| |
| void set_range (int range_idx) { set_state (range_idx); } |
| void set_normal_text () { set_state (STATE_NORMAL_TEXT); } |
| void set_fixit_hint () { set_state (0); } |
| |
| private: |
| void set_state (int state); |
| void begin_state (int state); |
| void finish_state (int state); |
| |
| private: |
| static const int STATE_NORMAL_TEXT = -1; |
| |
| diagnostic_context *m_context; |
| const diagnostic_info *m_diagnostic; |
| int m_current_state; |
| const char *m_caret_cs; |
| const char *m_caret_ce; |
| const char *m_range1_cs; |
| const char *m_range2_cs; |
| const char *m_range_ce; |
| }; |
| |
| /* A point within a layout_range; similar to an expanded_location, |
| but after filtering on file. */ |
| |
| class layout_point |
| { |
| public: |
| layout_point (const expanded_location &exploc) |
| : m_line (exploc.line), |
| m_column (exploc.column) {} |
| |
| int m_line; |
| int m_column; |
| }; |
| |
| /* A class for use by "class layout" below: a filtered location_range. */ |
| |
| class layout_range |
| { |
| public: |
| layout_range (const expanded_location *start_exploc, |
| const expanded_location *finish_exploc, |
| bool show_caret_p, |
| const expanded_location *caret_exploc); |
| |
| bool contains_point (int row, int column) const; |
| |
| layout_point m_start; |
| layout_point m_finish; |
| bool m_show_caret_p; |
| layout_point m_caret; |
| }; |
| |
| /* A struct for use by layout::print_source_line for telling |
| layout::print_annotation_line the extents of the source line that |
| it printed, so that underlines can be clipped appropriately. */ |
| |
| struct line_bounds |
| { |
| int m_first_non_ws; |
| int m_last_non_ws; |
| }; |
| |
| /* A range of contiguous source lines within a layout (e.g. "lines 5-10" |
| or "line 23"). During the layout ctor, layout::calculate_line_spans |
| splits the pertinent source lines into a list of disjoint line_span |
| instances (e.g. lines 5-10, lines 15-20, line 23). */ |
| |
| struct line_span |
| { |
| line_span (linenum_type first_line, linenum_type last_line) |
| : m_first_line (first_line), m_last_line (last_line) |
| { |
| gcc_assert (first_line <= last_line); |
| } |
| linenum_type get_first_line () const { return m_first_line; } |
| linenum_type get_last_line () const { return m_last_line; } |
| |
| bool contains_line_p (linenum_type line) const |
| { |
| return line >= m_first_line && line <= m_last_line; |
| } |
| |
| static int comparator (const void *p1, const void *p2) |
| { |
| const line_span *ls1 = (const line_span *)p1; |
| const line_span *ls2 = (const line_span *)p2; |
| int first_line_diff = (int)ls1->m_first_line - (int)ls2->m_first_line; |
| if (first_line_diff) |
| return first_line_diff; |
| return (int)ls1->m_last_line - (int)ls2->m_last_line; |
| } |
| |
| linenum_type m_first_line; |
| linenum_type m_last_line; |
| }; |
| |
| /* A class to control the overall layout when printing a diagnostic. |
| |
| The layout is determined within the constructor. |
| It is then printed by repeatedly calling the "print_source_line", |
| "print_annotation_line" and "print_any_fixits" methods. |
| |
| We assume we have disjoint ranges. */ |
| |
| class layout |
| { |
| public: |
| layout (diagnostic_context *context, |
| const diagnostic_info *diagnostic); |
| |
| int get_num_line_spans () const { return m_line_spans.length (); } |
| const line_span *get_line_span (int idx) const { return &m_line_spans[idx]; } |
| |
| bool print_heading_for_line_span_index_p (int line_span_idx) const; |
| |
| expanded_location get_expanded_location (const line_span *) const; |
| |
| bool print_source_line (int row, line_bounds *lbounds_out); |
| void print_annotation_line (int row, const line_bounds lbounds); |
| void print_any_fixits (int row, const rich_location *richloc); |
| |
| private: |
| void calculate_line_spans (); |
| |
| void print_newline (); |
| |
| bool |
| get_state_at_point (/* Inputs. */ |
| int row, int column, |
| int first_non_ws, int last_non_ws, |
| /* Outputs. */ |
| point_state *out_state); |
| |
| int |
| get_x_bound_for_row (int row, int caret_column, |
| int last_non_ws); |
| |
| void |
| move_to_column (int *column, int dest_column); |
| |
| private: |
| diagnostic_context *m_context; |
| pretty_printer *m_pp; |
| diagnostic_t m_diagnostic_kind; |
| expanded_location m_exploc; |
| colorizer m_colorizer; |
| bool m_colorize_source_p; |
| auto_vec <layout_range> m_layout_ranges; |
| auto_vec <line_span> m_line_spans; |
| int m_x_offset; |
| }; |
| |
| /* Implementation of "class colorizer". */ |
| |
| /* The constructor for "colorizer". Lookup and store color codes for the |
| different kinds of things we might need to print. */ |
| |
| colorizer::colorizer (diagnostic_context *context, |
| const diagnostic_info *diagnostic) : |
| m_context (context), |
| m_diagnostic (diagnostic), |
| m_current_state (STATE_NORMAL_TEXT) |
| { |
| m_caret_ce = colorize_stop (pp_show_color (context->printer)); |
| m_range1_cs = colorize_start (pp_show_color (context->printer), "range1"); |
| m_range2_cs = colorize_start (pp_show_color (context->printer), "range2"); |
| m_range_ce = colorize_stop (pp_show_color (context->printer)); |
| } |
| |
| /* The destructor for "colorize". If colorization is on, print a code to |
| turn it off. */ |
| |
| colorizer::~colorizer () |
| { |
| finish_state (m_current_state); |
| } |
| |
| /* Update state, printing color codes if necessary if there's a state |
| change. */ |
| |
| void |
| colorizer::set_state (int new_state) |
| { |
| if (m_current_state != new_state) |
| { |
| finish_state (m_current_state); |
| m_current_state = new_state; |
| begin_state (new_state); |
| } |
| } |
| |
| /* Turn on any colorization for STATE. */ |
| |
| void |
| colorizer::begin_state (int state) |
| { |
| switch (state) |
| { |
| case STATE_NORMAL_TEXT: |
| break; |
| |
| case 0: |
| /* Make range 0 be the same color as the "kind" text |
| (error vs warning vs note). */ |
| pp_string |
| (m_context->printer, |
| colorize_start (pp_show_color (m_context->printer), |
| diagnostic_get_color_for_kind (m_diagnostic->kind))); |
| break; |
| |
| case 1: |
| pp_string (m_context->printer, m_range1_cs); |
| break; |
| |
| case 2: |
| pp_string (m_context->printer, m_range2_cs); |
| break; |
| |
| default: |
| /* We don't expect more than 3 ranges per diagnostic. */ |
| gcc_unreachable (); |
| break; |
| } |
| } |
| |
| /* Turn off any colorization for STATE. */ |
| |
| void |
| colorizer::finish_state (int state) |
| { |
| switch (state) |
| { |
| case STATE_NORMAL_TEXT: |
| break; |
| |
| case 0: |
| pp_string (m_context->printer, m_caret_ce); |
| break; |
| |
| default: |
| /* Within a range. */ |
| gcc_assert (state > 0); |
| pp_string (m_context->printer, m_range_ce); |
| break; |
| } |
| } |
| |
| /* Implementation of class layout_range. */ |
| |
| /* The constructor for class layout_range. |
| Initialize various layout_point fields from expanded_location |
| equivalents; we've already filtered on file. */ |
| |
| layout_range::layout_range (const expanded_location *start_exploc, |
| const expanded_location *finish_exploc, |
| bool show_caret_p, |
| const expanded_location *caret_exploc) |
| : m_start (*start_exploc), |
| m_finish (*finish_exploc), |
| m_show_caret_p (show_caret_p), |
| m_caret (*caret_exploc) |
| { |
| } |
| |
| /* Is (column, row) within the given range? |
| We've already filtered on the file. |
| |
| Ranges are closed (both limits are within the range). |
| |
| Example A: a single-line range: |
| start: (col=22, line=2) |
| finish: (col=38, line=2) |
| |
| |00000011111111112222222222333333333344444444444 |
| |34567890123456789012345678901234567890123456789 |
| --+----------------------------------------------- |
| 01|bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb |
| 02|bbbbbbbbbbbbbbbbbbbSwwwwwwwwwwwwwwwFaaaaaaaaaaa |
| 03|aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa |
| |
| Example B: a multiline range with |
| start: (col=14, line=3) |
| finish: (col=08, line=5) |
| |
| |00000011111111112222222222333333333344444444444 |
| |34567890123456789012345678901234567890123456789 |
| --+----------------------------------------------- |
| 01|bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb |
| 02|bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb |
| 03|bbbbbbbbbbbSwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww |
| 04|wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww |
| 05|wwwwwFaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa |
| 06|aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa |
| --+----------------------------------------------- |
| |
| Legend: |
| - 'b' indicates a point *before* the range |
| - 'S' indicates the start of the range |
| - 'w' indicates a point within the range |
| - 'F' indicates the finish of the range (which is |
| within it). |
| - 'a' indicates a subsequent point *after* the range. */ |
| |
| bool |
| layout_range::contains_point (int row, int column) const |
| { |
| gcc_assert (m_start.m_line <= m_finish.m_line); |
| /* ...but the equivalent isn't true for the columns; |
| consider example B in the comment above. */ |
| |
| if (row < m_start.m_line) |
| /* Points before the first line of the range are |
| outside it (corresponding to line 01 in example A |
| and lines 01 and 02 in example B above). */ |
| return false; |
| |
| if (row == m_start.m_line) |
| /* On same line as start of range (corresponding |
| to line 02 in example A and line 03 in example B). */ |
| { |
| if (column < m_start.m_column) |
| /* Points on the starting line of the range, but |
| before the column in which it begins. */ |
| return false; |
| |
| if (row < m_finish.m_line) |
| /* This is a multiline range; the point |
| is within it (corresponds to line 03 in example B |
| from column 14 onwards) */ |
| return true; |
| else |
| { |
| /* This is a single-line range. */ |
| gcc_assert (row == m_finish.m_line); |
| return column <= m_finish.m_column; |
| } |
| } |
| |
| /* The point is in a line beyond that containing the |
| start of the range: lines 03 onwards in example A, |
| and lines 04 onwards in example B. */ |
| gcc_assert (row > m_start.m_line); |
| |
| if (row > m_finish.m_line) |
| /* The point is beyond the final line of the range |
| (lines 03 onwards in example A, and lines 06 onwards |
| in example B). */ |
| return false; |
| |
| if (row < m_finish.m_line) |
| { |
| /* The point is in a line that's fully within a multiline |
| range (e.g. line 04 in example B). */ |
| gcc_assert (m_start.m_line < m_finish.m_line); |
| return true; |
| } |
| |
| gcc_assert (row == m_finish.m_line); |
| |
| return column <= m_finish.m_column; |
| } |
| |
| /* Given a source line LINE of length LINE_WIDTH, determine the width |
| without any trailing whitespace. */ |
| |
| static int |
| get_line_width_without_trailing_whitespace (const char *line, int line_width) |
| { |
| int result = line_width; |
| while (result > 0) |
| { |
| char ch = line[result - 1]; |
| if (ch == ' ' || ch == '\t') |
| result--; |
| else |
| break; |
| } |
| gcc_assert (result >= 0); |
| gcc_assert (result <= line_width); |
| gcc_assert (result == 0 || |
| (line[result - 1] != ' ' |
| && line[result -1] != '\t')); |
| return result; |
| } |
| |
| /* Helper function for layout's ctor, for sanitizing locations relative |
| to the primary location within a diagnostic. |
| |
| Compare LOC_A and LOC_B to see if it makes sense to print underlines |
| connecting their expanded locations. Doing so is only guaranteed to |
| make sense if the locations share the same macro expansion "history" |
| i.e. they can be traced through the same macro expansions, eventually |
| reaching an ordinary map. |
| |
| This may be too strong a condition, but it effectively sanitizes |
| PR c++/70105, which has an example of printing an expression where the |
| final location of the expression is in a different macro, which |
| erroneously was leading to hundreds of lines of irrelevant source |
| being printed. */ |
| |
| static bool |
| compatible_locations_p (location_t loc_a, location_t loc_b) |
| { |
| if (IS_ADHOC_LOC (loc_a)) |
| loc_a = get_location_from_adhoc_loc (line_table, loc_a); |
| if (IS_ADHOC_LOC (loc_b)) |
| loc_b = get_location_from_adhoc_loc (line_table, loc_b); |
| |
| /* If either location is one of the special locations outside of a |
| linemap, they are only compatible if they are equal. */ |
| if (loc_a < RESERVED_LOCATION_COUNT |
| || loc_b < RESERVED_LOCATION_COUNT) |
| return loc_a == loc_b; |
| |
| const line_map *map_a = linemap_lookup (line_table, loc_a); |
| linemap_assert (map_a); |
| |
| const line_map *map_b = linemap_lookup (line_table, loc_b); |
| linemap_assert (map_b); |
| |
| /* Are they within the same map? */ |
| if (map_a == map_b) |
| { |
| /* Are both within the same macro expansion? */ |
| if (linemap_macro_expansion_map_p (map_a)) |
| { |
| /* Expand each location towards the spelling location, and |
| recurse. */ |
| const line_map_macro *macro_map = linemap_check_macro (map_a); |
| source_location loc_a_toward_spelling |
| = linemap_macro_map_loc_unwind_toward_spelling (line_table, |
| macro_map, |
| loc_a); |
| source_location loc_b_toward_spelling |
| = linemap_macro_map_loc_unwind_toward_spelling (line_table, |
| macro_map, |
| loc_b); |
| return compatible_locations_p (loc_a_toward_spelling, |
| loc_b_toward_spelling); |
| } |
| |
| /* Otherwise they are within the same ordinary map. */ |
| return true; |
| } |
| else |
| { |
| /* Within different maps. */ |
| |
| /* If either is within a macro expansion, they are incompatible. */ |
| if (linemap_macro_expansion_map_p (map_a) |
| || linemap_macro_expansion_map_p (map_b)) |
| return false; |
| |
| /* Within two different ordinary maps; they are compatible iff they |
| are in the same file. */ |
| const line_map_ordinary *ord_map_a = linemap_check_ordinary (map_a); |
| const line_map_ordinary *ord_map_b = linemap_check_ordinary (map_b); |
| return ord_map_a->to_file == ord_map_b->to_file; |
| } |
| } |
| |
| /* Implementation of class layout. */ |
| |
| /* Constructor for class layout. |
| |
| Filter the ranges from the rich_location to those that we can |
| sanely print, populating m_layout_ranges. |
| Determine the range of lines that we will print, splitting them |
| up into an ordered list of disjoint spans of contiguous line numbers. |
| Determine m_x_offset, to ensure that the primary caret |
| will fit within the max_width provided by the diagnostic_context. */ |
| |
| layout::layout (diagnostic_context * context, |
| const diagnostic_info *diagnostic) |
| : m_context (context), |
| m_pp (context->printer), |
| m_diagnostic_kind (diagnostic->kind), |
| m_exploc (diagnostic->richloc->get_expanded_location (0)), |
| m_colorizer (context, diagnostic), |
| m_colorize_source_p (context->colorize_source_p), |
| m_layout_ranges (rich_location::MAX_RANGES), |
| m_line_spans (1 + rich_location::MAX_RANGES), |
| m_x_offset (0) |
| { |
| rich_location *richloc = diagnostic->richloc; |
| source_location primary_loc = richloc->get_range (0)->m_loc; |
| |
| for (unsigned int idx = 0; idx < richloc->get_num_locations (); idx++) |
| { |
| /* This diagnostic printer can only cope with "sufficiently sane" ranges. |
| Ignore any ranges that are awkward to handle. */ |
| const location_range *loc_range = richloc->get_range (idx); |
| |
| /* Split the "range" into caret and range information. */ |
| source_range src_range = get_range_from_loc (line_table, loc_range->m_loc); |
| |
| /* Expand the various locations. */ |
| expanded_location start |
| = linemap_client_expand_location_to_spelling_point (src_range.m_start); |
| expanded_location finish |
| = linemap_client_expand_location_to_spelling_point (src_range.m_finish); |
| expanded_location caret |
| = linemap_client_expand_location_to_spelling_point (loc_range->m_loc); |
| |
| /* If any part of the range isn't in the same file as the primary |
| location of this diagnostic, ignore the range. */ |
| if (start.file != m_exploc.file) |
| continue; |
| if (finish.file != m_exploc.file) |
| continue; |
| if (loc_range->m_show_caret_p) |
| if (caret.file != m_exploc.file) |
| continue; |
| |
| /* Sanitize the caret location for non-primary ranges. */ |
| if (m_layout_ranges.length () > 0) |
| if (loc_range->m_show_caret_p) |
| if (!compatible_locations_p (loc_range->m_loc, primary_loc)) |
| /* Discard any non-primary ranges that can't be printed |
| sanely relative to the primary location. */ |
| continue; |
| |
| /* Everything is now known to be in the correct source file, |
| but it may require further sanitization. */ |
| layout_range ri (&start, &finish, loc_range->m_show_caret_p, &caret); |
| |
| /* If we have a range that finishes before it starts (perhaps |
| from something built via macro expansion), printing the |
| range is likely to be nonsensical. Also, attempting to do so |
| breaks assumptions within the printing code (PR c/68473). |
| Similarly, don't attempt to print ranges if one or both ends |
| of the range aren't sane to print relative to the |
| primary location (PR c++/70105). */ |
| if (start.line > finish.line |
| || !compatible_locations_p (src_range.m_start, primary_loc) |
| || !compatible_locations_p (src_range.m_finish, primary_loc)) |
| { |
| /* Is this the primary location? */ |
| if (m_layout_ranges.length () == 0) |
| { |
| /* We want to print the caret for the primary location, but |
| we must sanitize away m_start and m_finish. */ |
| ri.m_start = ri.m_caret; |
| ri.m_finish = ri.m_caret; |
| } |
| else |
| /* This is a non-primary range; ignore it. */ |
| continue; |
| } |
| |
| /* Passed all the tests; add the range to m_layout_ranges so that |
| it will be printed. */ |
| m_layout_ranges.safe_push (ri); |
| } |
| |
| /* Populate m_line_spans. */ |
| calculate_line_spans (); |
| |
| /* Adjust m_x_offset. |
| Center the primary caret to fit in max_width; all columns |
| will be adjusted accordingly. */ |
| int max_width = m_context->caret_max_width; |
| int line_width; |
| const char *line = location_get_source_line (m_exploc.file, m_exploc.line, |
| &line_width); |
| if (line && m_exploc.column <= line_width) |
| { |
| int right_margin = CARET_LINE_MARGIN; |
| int column = m_exploc.column; |
| right_margin = MIN (line_width - column, right_margin); |
| right_margin = max_width - right_margin; |
| if (line_width >= max_width && column > right_margin) |
| m_x_offset = column - right_margin; |
| gcc_assert (m_x_offset >= 0); |
| } |
| } |
| |
| /* Return true iff we should print a heading when starting the |
| line span with the given index. */ |
| |
| bool |
| layout::print_heading_for_line_span_index_p (int line_span_idx) const |
| { |
| /* We print a heading for every change of line span, hence for every |
| line span after the initial one. */ |
| if (line_span_idx > 0) |
| return true; |
| |
| /* We also do it for the initial span if the primary location of the |
| diagnostic is in a different span. */ |
| if (m_exploc.line > (int)get_line_span (0)->m_last_line) |
| return true; |
| |
| return false; |
| } |
| |
| /* Get an expanded_location for the first location of interest within |
| the given line_span. |
| Used when printing a heading to indicate a new line span. */ |
| |
| expanded_location |
| layout::get_expanded_location (const line_span *line_span) const |
| { |
| /* Whenever possible, use the caret location. */ |
| if (line_span->contains_line_p (m_exploc.line)) |
| return m_exploc; |
| |
| /* Otherwise, use the start of the first range that's present |
| within the line_span. */ |
| for (unsigned int i = 0; i < m_layout_ranges.length (); i++) |
| { |
| const layout_range *lr = &m_layout_ranges[i]; |
| if (line_span->contains_line_p (lr->m_start.m_line)) |
| { |
| expanded_location exploc = m_exploc; |
| exploc.line = lr->m_start.m_line; |
| exploc.column = lr->m_start.m_column; |
| return exploc; |
| } |
| } |
| |
| /* It should not be possible to have a line span that didn't |
| contain any of the layout_range instances. */ |
| gcc_unreachable (); |
| return m_exploc; |
| } |
| |
| /* We want to print the pertinent source code at a diagnostic. The |
| rich_location can contain multiple locations. This will have been |
| filtered into m_exploc (the caret for the primary location) and |
| m_layout_ranges, for those ranges within the same source file. |
| |
| We will print a subset of the lines within the source file in question, |
| as a collection of "spans" of lines. |
| |
| This function populates m_line_spans with an ordered, disjoint list of |
| the line spans of interest. |
| |
| For example, if the primary caret location is on line 7, with ranges |
| covering lines 5-6 and lines 9-12: |
| |
| 004 |
| 005 |RANGE 0 |
| 006 |RANGE 0 |
| 007 |PRIMARY CARET |
| 008 |
| 009 |RANGE 1 |
| 010 |RANGE 1 |
| 011 |RANGE 1 |
| 012 |RANGE 1 |
| 013 |
| |
| then we want two spans: lines 5-7 and lines 9-12. */ |
| |
| void |
| layout::calculate_line_spans () |
| { |
| /* This should only be called once, by the ctor. */ |
| gcc_assert (m_line_spans.length () == 0); |
| |
| /* Populate tmp_spans with individual spans, for each of |
| m_exploc, and for m_layout_ranges. */ |
| auto_vec<line_span> tmp_spans (1 + rich_location::MAX_RANGES); |
| tmp_spans.safe_push (line_span (m_exploc.line, m_exploc.line)); |
| for (unsigned int i = 0; i < m_layout_ranges.length (); i++) |
| { |
| const layout_range *lr = &m_layout_ranges[i]; |
| gcc_assert (lr->m_start.m_line <= lr->m_finish.m_line); |
| tmp_spans.safe_push (line_span (lr->m_start.m_line, |
| lr->m_finish.m_line)); |
| } |
| |
| /* Sort them. */ |
| tmp_spans.qsort(line_span::comparator); |
| |
| /* Now iterate through tmp_spans, copying into m_line_spans, and |
| combining where possible. */ |
| gcc_assert (tmp_spans.length () > 0); |
| m_line_spans.safe_push (tmp_spans[0]); |
| for (unsigned int i = 1; i < tmp_spans.length (); i++) |
| { |
| line_span *current = &m_line_spans[m_line_spans.length () - 1]; |
| const line_span *next = &tmp_spans[i]; |
| gcc_assert (next->m_first_line >= current->m_first_line); |
| if (next->m_first_line <= current->m_last_line + 1) |
| { |
| /* We can merge them. */ |
| if (next->m_last_line > current->m_last_line) |
| current->m_last_line = next->m_last_line; |
| } |
| else |
| { |
| /* No merger possible. */ |
| m_line_spans.safe_push (*next); |
| } |
| } |
| |
| /* Verify the result, in m_line_spans. */ |
| gcc_assert (m_line_spans.length () > 0); |
| for (unsigned int i = 1; i < m_line_spans.length (); i++) |
| { |
| const line_span *prev = &m_line_spans[i - 1]; |
| const line_span *next = &m_line_spans[i]; |
| /* The individual spans must be sane. */ |
| gcc_assert (prev->m_first_line <= prev->m_last_line); |
| gcc_assert (next->m_first_line <= next->m_last_line); |
| /* The spans must be ordered. */ |
| gcc_assert (prev->m_first_line < next->m_first_line); |
| /* There must be a gap of at least one line between separate spans. */ |
| gcc_assert ((prev->m_last_line + 1) < next->m_first_line); |
| } |
| } |
| |
| /* Attempt to print line ROW of source code, potentially colorized at any |
| ranges. |
| Return true if the line was printed, populating *LBOUNDS_OUT. |
| Return false if the source line could not be read, leaving *LBOUNDS_OUT |
| untouched. */ |
| |
| bool |
| layout::print_source_line (int row, line_bounds *lbounds_out) |
| { |
| int line_width; |
| const char *line = location_get_source_line (m_exploc.file, row, |
| &line_width); |
| if (!line) |
| return false; |
| |
| m_colorizer.set_normal_text (); |
| |
| /* We will stop printing the source line at any trailing |
| whitespace. */ |
| line_width = get_line_width_without_trailing_whitespace (line, |
| line_width); |
| line += m_x_offset; |
| |
| pp_space (m_pp); |
| int first_non_ws = INT_MAX; |
| int last_non_ws = 0; |
| int column; |
| for (column = 1 + m_x_offset; column <= line_width; column++) |
| { |
| /* Assuming colorization is enabled for the caret and underline |
| characters, we may also colorize the associated characters |
| within the source line. |
| |
| For frontends that generate range information, we color the |
| associated characters in the source line the same as the |
| carets and underlines in the annotation line, to make it easier |
| for the reader to see the pertinent code. |
| |
| For frontends that only generate carets, we don't colorize the |
| characters above them, since this would look strange (e.g. |
| colorizing just the first character in a token). */ |
| if (m_colorize_source_p) |
| { |
| bool in_range_p; |
| point_state state; |
| in_range_p = get_state_at_point (row, column, |
| 0, INT_MAX, |
| &state); |
| if (in_range_p) |
| m_colorizer.set_range (state.range_idx); |
| else |
| m_colorizer.set_normal_text (); |
| } |
| char c = *line == '\t' ? ' ' : *line; |
| if (c == '\0') |
| c = ' '; |
| if (c != ' ') |
| { |
| last_non_ws = column; |
| if (first_non_ws == INT_MAX) |
| first_non_ws = column; |
| } |
| pp_character (m_pp, c); |
| line++; |
| } |
| print_newline (); |
| |
| lbounds_out->m_first_non_ws = first_non_ws; |
| lbounds_out->m_last_non_ws = last_non_ws; |
| return true; |
| } |
| |
| /* Print a line consisting of the caret/underlines for the given |
| source line. */ |
| |
| void |
| layout::print_annotation_line (int row, const line_bounds lbounds) |
| { |
| int x_bound = get_x_bound_for_row (row, m_exploc.column, |
| lbounds.m_last_non_ws); |
| |
| pp_space (m_pp); |
| for (int column = 1 + m_x_offset; column < x_bound; column++) |
| { |
| bool in_range_p; |
| point_state state; |
| in_range_p = get_state_at_point (row, column, |
| lbounds.m_first_non_ws, |
| lbounds.m_last_non_ws, |
| &state); |
| if (in_range_p) |
| { |
| /* Within a range. Draw either the caret or an underline. */ |
| m_colorizer.set_range (state.range_idx); |
| if (state.draw_caret_p) |
| /* Draw the caret. */ |
| pp_character (m_pp, m_context->caret_chars[state.range_idx]); |
| else |
| pp_character (m_pp, '~'); |
| } |
| else |
| { |
| /* Not in a range. */ |
| m_colorizer.set_normal_text (); |
| pp_character (m_pp, ' '); |
| } |
| } |
| print_newline (); |
| } |
| |
| /* If there are any fixit hints on source line ROW within RICHLOC, print them. |
| They are printed in order, attempting to combine them onto lines, but |
| starting new lines if necessary. */ |
| |
| void |
| layout::print_any_fixits (int row, const rich_location *richloc) |
| { |
| int column = 0; |
| for (unsigned int i = 0; i < richloc->get_num_fixit_hints (); i++) |
| { |
| fixit_hint *hint = richloc->get_fixit_hint (i); |
| if (hint->affects_line_p (m_exploc.file, row)) |
| { |
| /* For now we assume each fixit hint can only touch one line. */ |
| switch (hint->get_kind ()) |
| { |
| case fixit_hint::INSERT: |
| { |
| fixit_insert *insert = static_cast <fixit_insert *> (hint); |
| /* This assumes the insertion just affects one line. */ |
| int start_column |
| = LOCATION_COLUMN (insert->get_location ()); |
| move_to_column (&column, start_column); |
| m_colorizer.set_fixit_hint (); |
| pp_string (m_pp, insert->get_string ()); |
| m_colorizer.set_normal_text (); |
| column += insert->get_length (); |
| } |
| break; |
| |
| case fixit_hint::REMOVE: |
| { |
| fixit_remove *remove = static_cast <fixit_remove *> (hint); |
| /* This assumes the removal just affects one line. */ |
| source_range src_range = remove->get_range (); |
| int start_column = LOCATION_COLUMN (src_range.m_start); |
| int finish_column = LOCATION_COLUMN (src_range.m_finish); |
| move_to_column (&column, start_column); |
| for (int column = start_column; column <= finish_column; column++) |
| { |
| m_colorizer.set_fixit_hint (); |
| pp_character (m_pp, '-'); |
| m_colorizer.set_normal_text (); |
| } |
| } |
| break; |
| |
| case fixit_hint::REPLACE: |
| { |
| fixit_replace *replace = static_cast <fixit_replace *> (hint); |
| int start_column |
| = LOCATION_COLUMN (replace->get_range ().m_start); |
| move_to_column (&column, start_column); |
| m_colorizer.set_fixit_hint (); |
| pp_string (m_pp, replace->get_string ()); |
| m_colorizer.set_normal_text (); |
| column += replace->get_length (); |
| } |
| break; |
| |
| default: |
| gcc_unreachable (); |
| } |
| } |
| } |
| |
| /* Add a trailing newline, if necessary. */ |
| move_to_column (&column, 0); |
| } |
| |
| /* Disable any colorization and emit a newline. */ |
| |
| void |
| layout::print_newline () |
| { |
| m_colorizer.set_normal_text (); |
| pp_newline (m_pp); |
| } |
| |
| /* Return true if (ROW/COLUMN) is within a range of the layout. |
| If it returns true, OUT_STATE is written to, with the |
| range index, and whether we should draw the caret at |
| (ROW/COLUMN) (as opposed to an underline). */ |
| |
| bool |
| layout::get_state_at_point (/* Inputs. */ |
| int row, int column, |
| int first_non_ws, int last_non_ws, |
| /* Outputs. */ |
| point_state *out_state) |
| { |
| layout_range *range; |
| int i; |
| FOR_EACH_VEC_ELT (m_layout_ranges, i, range) |
| { |
| if (range->contains_point (row, column)) |
| { |
| out_state->range_idx = i; |
| |
| /* Are we at the range's caret? is it visible? */ |
| out_state->draw_caret_p = false; |
| if (range->m_show_caret_p |
| && row == range->m_caret.m_line |
| && column == range->m_caret.m_column) |
| out_state->draw_caret_p = true; |
| |
| /* Within a multiline range, don't display any underline |
| in any leading or trailing whitespace on a line. |
| We do display carets, however. */ |
| if (!out_state->draw_caret_p) |
| if (column < first_non_ws || column > last_non_ws) |
| return false; |
| |
| /* We are within a range. */ |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /* Helper function for use by layout::print_line when printing the |
| annotation line under the source line. |
| Get the column beyond the rightmost one that could contain a caret or |
| range marker, given that we stop rendering at trailing whitespace. |
| ROW is the source line within the given file. |
| CARET_COLUMN is the column of range 0's caret. |
| LAST_NON_WS_COLUMN is the last column containing a non-whitespace |
| character of source (as determined when printing the source line). */ |
| |
| int |
| layout::get_x_bound_for_row (int row, int caret_column, |
| int last_non_ws_column) |
| { |
| int result = caret_column + 1; |
| |
| layout_range *range; |
| int i; |
| FOR_EACH_VEC_ELT (m_layout_ranges, i, range) |
| { |
| if (row >= range->m_start.m_line) |
| { |
| if (range->m_finish.m_line == row) |
| { |
| /* On the final line within a range; ensure that |
| we render up to the end of the range. */ |
| if (result <= range->m_finish.m_column) |
| result = range->m_finish.m_column + 1; |
| } |
| else if (row < range->m_finish.m_line) |
| { |
| /* Within a multiline range; ensure that we render up to the |
| last non-whitespace column. */ |
| if (result <= last_non_ws_column) |
| result = last_non_ws_column + 1; |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| /* Given *COLUMN as an x-coordinate, print spaces to position |
| successive output at DEST_COLUMN, printing a newline if necessary, |
| and updating *COLUMN. */ |
| |
| void |
| layout::move_to_column (int *column, int dest_column) |
| { |
| /* Start a new line if we need to. */ |
| if (*column > dest_column) |
| { |
| print_newline (); |
| *column = 0; |
| } |
| |
| while (*column < dest_column) |
| { |
| pp_space (m_pp); |
| (*column)++; |
| } |
| } |
| |
| } /* End of anonymous namespace. */ |
| |
| /* Print the physical source code corresponding to the location of |
| this diagnostic, with additional annotations. */ |
| |
| void |
| diagnostic_show_locus (diagnostic_context * context, |
| const diagnostic_info *diagnostic) |
| { |
| pp_newline (context->printer); |
| |
| if (!context->show_caret |
| || diagnostic_location (diagnostic, 0) <= BUILTINS_LOCATION |
| || diagnostic_location (diagnostic, 0) == context->last_location) |
| return; |
| |
| context->last_location = diagnostic_location (diagnostic, 0); |
| |
| const char *saved_prefix = pp_get_prefix (context->printer); |
| pp_set_prefix (context->printer, NULL); |
| |
| layout layout (context, diagnostic); |
| for (int line_span_idx = 0; line_span_idx < layout.get_num_line_spans (); |
| line_span_idx++) |
| { |
| const line_span *line_span = layout.get_line_span (line_span_idx); |
| if (layout.print_heading_for_line_span_index_p (line_span_idx)) |
| { |
| expanded_location exploc = layout.get_expanded_location (line_span); |
| context->start_span (context, exploc); |
| } |
| int last_line = line_span->get_last_line (); |
| for (int row = line_span->get_first_line (); row <= last_line; row++) |
| { |
| /* Print the source line, followed by an annotation line |
| consisting of any caret/underlines, then any fixits. |
| If the source line can't be read, print nothing. */ |
| line_bounds lbounds; |
| if (layout.print_source_line (row, &lbounds)) |
| { |
| layout.print_annotation_line (row, lbounds); |
| layout.print_any_fixits (row, diagnostic->richloc); |
| } |
| } |
| } |
| |
| pp_set_prefix (context->printer, saved_prefix); |
| } |