[deliverable/binutils-gdb.git] / gdb / tui / tui-source.c

/* TUI display source window.

   Copyright (C) 1998-2019 Free Software Foundation, Inc.

   Contributed by Hewlett-Packard Company.

   This file is part of GDB.

   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 of the License, 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, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include <ctype.h>
#include "symtab.h"
#include "frame.h"
#include "breakpoint.h"
#include "source.h"
#include "objfiles.h"
#include "filenames.h"
#include "source-cache.h"

#include "tui/tui.h"
#include "tui/tui-data.h"
#include "tui/tui-io.h"
#include "tui/tui-stack.h"
#include "tui/tui-winsource.h"
#include "tui/tui-source.h"
#include "gdb_curses.h"

/* A helper function for tui_set_source_content that extracts some
   source text from PTR.  LINE_NO is the line number; FIRST_COL is the
   first column to extract, and LINE_WIDTH is the number of characters
   to display.  Returns a string holding the desired text.  */

static std::string
copy_source_line (const char **ptr, int line_no, int first_col,
		  int line_width)
{
  const char *lineptr = *ptr;

  /* Init the line with the line number.  */
  std::string result = string_printf ("%-6d", line_no);
  int len = result.size ();
  len = len - ((len / tui_tab_width) * tui_tab_width);
  result.append (len, ' ');

  int column = 0;
  char c;
  do
    {
      int skip_bytes;

      c = *lineptr;
      if (c == '\033' && skip_ansi_escape (lineptr, &skip_bytes))
	{
	  /* We always have to preserve escapes.  */
	  result.append (lineptr, lineptr + skip_bytes);
	  lineptr += skip_bytes;
	  continue;
	}

      ++lineptr;
      ++column;

      auto process_tab = [&] ()
	{
	  int max_tab_len = tui_tab_width;

	  --column;
	  for (int j = column % max_tab_len;
	       j < max_tab_len && column < first_col + line_width;
	       column++, j++)
	    if (column >= first_col)
	      result.push_back (' ');
	};

      /* We have to process all the text in order to pick up all the
	 escapes.  */
      if (column <= first_col || column > first_col + line_width)
	{
	  if (c == '\t')
	    process_tab ();
	  continue;
	}

      if (c == '\n' || c == '\r' || c == '\0')
	{
	  /* Nothing.  */
	}
      else if (c < 040 && c != '\t')
	{
	  result.push_back ('^');
	  result.push_back (c + 0100);
	}
      else if (c == 0177)
	{
	  result.push_back ('^');
	  result.push_back ('?');
	}
      else if (c == '\t')
	process_tab ();
      else
	result.push_back (c);
    }
  while (c != '\0' && c != '\n' && c != '\r');

  if (c == '\r' && *lineptr == '\n')
    ++lineptr;
  *ptr = lineptr;

  return result;
}

/* Function to display source in the source window.  */
enum tui_status
tui_set_source_content (struct symtab *s, 
			int line_no,
			int noerror)
{
  enum tui_status ret = TUI_FAILURE;

  if (s != NULL)
    {
      int line_width, nlines;

      ret = TUI_SUCCESS;
      tui_alloc_source_buffer (TUI_SRC_WIN);
      line_width = TUI_SRC_WIN->width - 1;
      /* Take hilite (window border) into account, when
	 calculating the number of lines.  */
      nlines = (line_no + (TUI_SRC_WIN->height - 2)) - line_no;

      std::string srclines;
      if (!g_source_cache.get_source_lines (s, line_no, line_no + nlines,
					    &srclines))
	{
	  if (!noerror)
	    {
	      const char *filename = symtab_to_filename_for_display (s);
	      char *name = (char *) alloca (strlen (filename) + 100);

	      sprintf (name, "%s:%d", filename, line_no);
	      print_sys_errmsg (name, errno);
	    }
	  ret = TUI_FAILURE;
	}
      else
	{
	  int cur_line_no, cur_line;
	  struct tui_gen_win_info *locator
	    = tui_locator_win_info_ptr ();
	  struct tui_source_window_base *src
	    = (struct tui_source_window_base *) TUI_SRC_WIN;
	  const char *s_filename = symtab_to_filename_for_display (s);

	  if (TUI_SRC_WIN->title)
	    xfree (TUI_SRC_WIN->title);
	  TUI_SRC_WIN->title = xstrdup (s_filename);

	  xfree (src->fullname);
	  src->fullname = xstrdup (symtab_to_fullname (s));

	  cur_line = 0;
	  src->gdbarch = get_objfile_arch (SYMTAB_OBJFILE (s));
	  src->start_line_or_addr.loa = LOA_LINE;
	  cur_line_no = src->start_line_or_addr.u.line_no = line_no;

	  const char *iter = srclines.c_str ();
	  while (cur_line < nlines)
	    {
	      struct tui_win_element *element
		= TUI_SRC_WIN->content[cur_line];

	      std::string text;
	      if (*iter != '\0')
		text = copy_source_line (&iter, cur_line_no,
					 src->horizontal_offset,
					 line_width);

	      /* Set whether element is the execution point
		 and whether there is a break point on it.  */
	      element->which_element.source.line_or_addr.loa =
		LOA_LINE;
	      element->which_element.source.line_or_addr.u.line_no =
		cur_line_no;
	      element->which_element.source.is_exec_point =
		(filename_cmp (locator->content[0]
			       ->which_element.locator.full_name,
			       symtab_to_fullname (s)) == 0
		 && cur_line_no
		 == locator->content[0]
		 ->which_element.locator.line_no);

	      xfree (TUI_SRC_WIN->content[cur_line]
		     ->which_element.source.line);
	      TUI_SRC_WIN->content[cur_line]
		->which_element.source.line
		= xstrdup (text.c_str ());

	      cur_line++;
	      cur_line_no++;
	    }
	  TUI_SRC_WIN->content_size = nlines;
	  ret = TUI_SUCCESS;
	}
    }
  return ret;
}


/* elz: This function sets the contents of the source window to empty
   except for a line in the middle with a warning message about the
   source not being available.  This function is called by
   tui_erase_source_contents(), which in turn is invoked when the
   source files cannot be accessed.  */

void
tui_set_source_content_nil (struct tui_win_info *win_info, 
			    const char *warning_string)
{
  int line_width;
  int n_lines;
  int curr_line = 0;

  line_width = win_info->width - 1;
  n_lines = win_info->height - 2;

  /* Set to empty each line in the window, except for the one which
     contains the message.  */
  while (curr_line < win_info->content_size)
    {
      /* Set the information related to each displayed line to null:
         i.e. the line number is 0, there is no bp, it is not where
         the program is stopped.  */

      struct tui_win_element *element = win_info->content[curr_line];

      element->which_element.source.line_or_addr.loa = LOA_LINE;
      element->which_element.source.line_or_addr.u.line_no = 0;
      element->which_element.source.is_exec_point = FALSE;
      element->which_element.source.has_break = FALSE;

      /* Set the contents of the line to blank.  */
      element->which_element.source.line[0] = (char) 0;

      /* If the current line is in the middle of the screen, then we
         want to display the 'no source available' message in it.
         Note: the 'weird' arithmetic with the line width and height
         comes from the function tui_erase_source_content().  We need
         to keep the screen and the window's actual contents in
         synch.  */

      if (curr_line == (n_lines / 2 + 1))
	{
	  int xpos;
	  int warning_length = strlen (warning_string);
	  char *src_line;

	  if (warning_length >= ((line_width - 1) / 2))
	    xpos = 1;
	  else
	    xpos = (line_width - 1) / 2 - warning_length;

	  src_line = xstrprintf ("%s%s", n_spaces (xpos), warning_string);
	  xfree (element->which_element.source.line);
	  element->which_element.source.line = src_line;
	}

      curr_line++;
    }
}


/* Function to display source in the source window.  This function
   initializes the horizontal scroll to 0.  */
void
tui_show_symtab_source (struct gdbarch *gdbarch, struct symtab *s,
			struct tui_line_or_address line, 
			int noerror)
{
  TUI_SRC_WIN->horizontal_offset = 0;
  tui_update_source_window_as_is (TUI_SRC_WIN, gdbarch, s, line, noerror);
}


/* Answer whether the source is currently displayed in the source
   window.  */
int
tui_source_is_displayed (const char *fullname)
{
  return (TUI_SRC_WIN != NULL
	  && TUI_SRC_WIN->content_in_use 
	  && (filename_cmp (tui_locator_win_info_ptr ()->content[0]
			      ->which_element.locator.full_name,
			    fullname) == 0));
}


/* Scroll the source forward or backward vertically.  */
void
tui_source_window::do_scroll_vertical
  (enum tui_scroll_direction scroll_direction, int num_to_scroll)
{
  if (content != NULL)
    {
      struct tui_line_or_address l;
      struct symtab *s;
      struct symtab_and_line cursal = get_current_source_symtab_and_line ();

      if (cursal.symtab == NULL)
	s = find_pc_line_symtab (get_frame_pc (get_selected_frame (NULL)));
      else
	s = cursal.symtab;

      l.loa = LOA_LINE;
      if (scroll_direction == FORWARD_SCROLL)
	{
	  l.u.line_no = content[0]->which_element.source.line_or_addr.u.line_no
	    + num_to_scroll;
	  if (l.u.line_no > s->nlines)
	    /* line = s->nlines - win_info->content_size + 1; */
	    /* elz: fix for dts 23398.  */
	    l.u.line_no
	      = content[0]->which_element.source.line_or_addr.u.line_no;
	}
      else
	{
	  l.u.line_no = content[0]->which_element.source.line_or_addr.u.line_no
	    - num_to_scroll;
	  if (l.u.line_no <= 0)
	    l.u.line_no = 1;
	}

      print_source_lines (s, l.u.line_no, l.u.line_no + 1, 0);
    }
}
Commit	Line	Data
f377b406	1	/* TUI display source window.
f33c6cbf	2
42a4f53d	3	Copyright (C) 1998-2019 Free Software Foundation, Inc.
f33c6cbf	4
f377b406 SC	5	Contributed by Hewlett-Packard Company.
	6
	7	This file is part of GDB.
	8
	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
a9762ec7	11	the Free Software Foundation; either version 3 of the License, or
f377b406 SC	12	(at your option) any later version.
	13
	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
a9762ec7	20	along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c SS	21
	22	#include "defs.h"
	23	#include <ctype.h>
	24	#include "symtab.h"
	25	#include "frame.h"
	26	#include "breakpoint.h"
c2c6d25f	27	#include "source.h"
13274fc3	28	#include "objfiles.h"
a7417d46	29	#include "filenames.h"
62f29fda	30	#include "source-cache.h"
c906108c	31
d7b2e967 AC	32	#include "tui/tui.h"
d7b2e967 AC	33	#include "tui/tui-data.h"
62f29fda	34	#include "tui/tui-io.h"
d7b2e967 AC	35	#include "tui/tui-stack.h"
	36	#include "tui/tui-winsource.h"
	37	#include "tui/tui-source.h"
6a83354a	38	#include "gdb_curses.h"
c906108c	39
62f29fda TT	40	/* A helper function for tui_set_source_content that extracts some
	41	source text from PTR. LINE_NO is the line number; FIRST_COL is the
	42	first column to extract, and LINE_WIDTH is the number of characters
	43	to display. Returns a string holding the desired text. */
	44
	45	static std::string
	46	copy_source_line (const char **ptr, int line_no, int first_col,
	47	int line_width)
	48	{
	49	const char lineptr = ptr;
	50
	51	/* Init the line with the line number. */
	52	std::string result = string_printf ("%-6d", line_no);
	53	int len = result.size ();
	54	len = len - ((len / tui_tab_width) * tui_tab_width);
	55	result.append (len, ' ');
	56
	57	int column = 0;
	58	char c;
	59	do
	60	{
	61	int skip_bytes;
	62
	63	c = *lineptr;
	64	if (c == '\033' && skip_ansi_escape (lineptr, &skip_bytes))
	65	{
	66	/* We always have to preserve escapes. */
	67	result.append (lineptr, lineptr + skip_bytes);
	68	lineptr += skip_bytes;
	69	continue;
	70	}
	71
	72	++lineptr;
	73	++column;
647bb750 HD	74
	75	auto process_tab = [&] ()
	76	{
	77	int max_tab_len = tui_tab_width;
	78
	79	--column;
	80	for (int j = column % max_tab_len;
	81	j < max_tab_len && column < first_col + line_width;
	82	column++, j++)
	83	if (column >= first_col)
	84	result.push_back (' ');
	85	};
	86
62f29fda TT	87	/* We have to process all the text in order to pick up all the
62f29fda TT	88	escapes. */
647bb750 HD	89	if (column <= first_col \|\| column > first_col + line_width)
	90	{
	91	if (c == '\t')
	92	process_tab ();
	93	continue;
	94	}
62f29fda TT	95
	96	if (c == '\n' \|\| c == '\r' \|\| c == '\0')
	97	{
	98	/* Nothing. */
	99	}
	100	else if (c < 040 && c != '\t')
	101	{
	102	result.push_back ('^');
	103	result.push_back (c + 0100);
	104	}
	105	else if (c == 0177)
	106	{
	107	result.push_back ('^');
	108	result.push_back ('?');
	109	}
	110	else if (c == '\t')
647bb750	111	process_tab ();
62f29fda TT	112	else
	113	result.push_back (c);
	114	}
	115	while (c != '\0' && c != '\n' && c != '\r');
	116
	117	if (c == '\r' && *lineptr == '\n')
	118	++lineptr;
	119	*ptr = lineptr;
	120
	121	return result;
	122	}
	123
98427f35	124	/* Function to display source in the source window. */
a358af15	125	enum tui_status
08ef48c5 MS	126	tui_set_source_content (struct symtab *s,
	127	int line_no,
	128	int noerror)
c906108c	129	{
22940a24	130	enum tui_status ret = TUI_FAILURE;
c906108c	131
cafb3438	132	if (s != NULL)
c906108c	133	{
62f29fda	134	int line_width, nlines;
c906108c	135
29d2c474 TT	136	ret = TUI_SUCCESS;
	137	tui_alloc_source_buffer (TUI_SRC_WIN);
	138	line_width = TUI_SRC_WIN->width - 1;
	139	/* Take hilite (window border) into account, when
	140	calculating the number of lines. */
	141	nlines = (line_no + (TUI_SRC_WIN->height - 2)) - line_no;
	142
	143	std::string srclines;
	144	if (!g_source_cache.get_source_lines (s, line_no, line_no + nlines,
	145	&srclines))
c906108c	146	{
29d2c474	147	if (!noerror)
c906108c	148	{
29d2c474 TT	149	const char *filename = symtab_to_filename_for_display (s);
	150	char name = (char ) alloca (strlen (filename) + 100);
	151
	152	sprintf (name, "%s:%d", filename, line_no);
	153	print_sys_errmsg (name, errno);
c906108c	154	}
29d2c474 TT	155	ret = TUI_FAILURE;
	156	}
	157	else
	158	{
	159	int cur_line_no, cur_line;
	160	struct tui_gen_win_info *locator
	161	= tui_locator_win_info_ptr ();
	162	struct tui_source_window_base *src
	163	= (struct tui_source_window_base *) TUI_SRC_WIN;
	164	const char *s_filename = symtab_to_filename_for_display (s);
	165
	166	if (TUI_SRC_WIN->title)
	167	xfree (TUI_SRC_WIN->title);
	168	TUI_SRC_WIN->title = xstrdup (s_filename);
	169
	170	xfree (src->fullname);
	171	src->fullname = xstrdup (symtab_to_fullname (s));
	172
	173	cur_line = 0;
	174	src->gdbarch = get_objfile_arch (SYMTAB_OBJFILE (s));
	175	src->start_line_or_addr.loa = LOA_LINE;
	176	cur_line_no = src->start_line_or_addr.u.line_no = line_no;
	177
	178	const char *iter = srclines.c_str ();
	179	while (cur_line < nlines)
c906108c	180	{
29d2c474 TT	181	struct tui_win_element *element
	182	= TUI_SRC_WIN->content[cur_line];
	183
	184	std::string text;
	185	if (*iter != '\0')
	186	text = copy_source_line (&iter, cur_line_no,
	187	src->horizontal_offset,
	188	line_width);
	189
	190	/* Set whether element is the execution point
	191	and whether there is a break point on it. */
	192	element->which_element.source.line_or_addr.loa =
	193	LOA_LINE;
	194	element->which_element.source.line_or_addr.u.line_no =
	195	cur_line_no;
	196	element->which_element.source.is_exec_point =
	197	(filename_cmp (locator->content[0]
	198	->which_element.locator.full_name,
	199	symtab_to_fullname (s)) == 0
	200	&& cur_line_no
	201	== locator->content[0]
	202	->which_element.locator.line_no);
	203
	204	xfree (TUI_SRC_WIN->content[cur_line]
	205	->which_element.source.line);
	206	TUI_SRC_WIN->content[cur_line]
	207	->which_element.source.line
	208	= xstrdup (text.c_str ());
	209
	210	cur_line++;
	211	cur_line_no++;
c906108c	212	}
29d2c474 TT	213	TUI_SRC_WIN->content_size = nlines;
29d2c474 TT	214	ret = TUI_SUCCESS;
c906108c SS	215	}
	216	}
	217	return ret;
98427f35	218	}
c906108c SS	219
c906108c SS	220
1cc6d956	221	/* elz: This function sets the contents of the source window to empty
c906108c	222	except for a line in the middle with a warning message about the
1cc6d956	223	source not being available. This function is called by
6ba8e26f AC	224	tui_erase_source_contents(), which in turn is invoked when the
6ba8e26f AC	225	source files cannot be accessed. */
c906108c SS	226
c906108c SS	227	void
08ef48c5	228	tui_set_source_content_nil (struct tui_win_info *win_info,
a121b7c1	229	const char *warning_string)
c906108c	230	{
6ba8e26f AC	231	int line_width;
6ba8e26f AC	232	int n_lines;
c906108c SS	233	int curr_line = 0;
c906108c SS	234
cb2ce893 TT	235	line_width = win_info->width - 1;
cb2ce893 TT	236	n_lines = win_info->height - 2;
c906108c	237
1cc6d956 MS	238	/* Set to empty each line in the window, except for the one which
1cc6d956 MS	239	contains the message. */
cb2ce893	240	while (curr_line < win_info->content_size)
c906108c	241	{
1cc6d956 MS	242	/* Set the information related to each displayed line to null:
	243	i.e. the line number is 0, there is no bp, it is not where
	244	the program is stopped. */
c906108c	245
cb2ce893	246	struct tui_win_element *element = win_info->content[curr_line];
1c5313c5	247
362c05fe AS	248	element->which_element.source.line_or_addr.loa = LOA_LINE;
362c05fe AS	249	element->which_element.source.line_or_addr.u.line_no = 0;
6d012f14 AC	250	element->which_element.source.is_exec_point = FALSE;
6d012f14 AC	251	element->which_element.source.has_break = FALSE;
c906108c	252
1cc6d956	253	/* Set the contents of the line to blank. */
6d012f14	254	element->which_element.source.line[0] = (char) 0;
c906108c	255
1cc6d956	256	/* If the current line is in the middle of the screen, then we
6ba8e26f AC	257	want to display the 'no source available' message in it.
6ba8e26f AC	258	Note: the 'weird' arithmetic with the line width and height
1cc6d956 MS	259	comes from the function tui_erase_source_content(). We need
	260	to keep the screen and the window's actual contents in
	261	synch. */
c906108c	262
6ba8e26f	263	if (curr_line == (n_lines / 2 + 1))
c906108c	264	{
c906108c SS	265	int xpos;
c906108c SS	266	int warning_length = strlen (warning_string);
6ba8e26f	267	char *src_line;
c906108c	268
6ba8e26f	269	if (warning_length >= ((line_width - 1) / 2))
c906108c SS	270	xpos = 1;
c906108c SS	271	else
6ba8e26f	272	xpos = (line_width - 1) / 2 - warning_length;
c906108c	273
0c820d67 TT	274	src_line = xstrprintf ("%s%s", n_spaces (xpos), warning_string);
	275	xfree (element->which_element.source.line);
	276	element->which_element.source.line = src_line;
	277	}
c906108c SS	278
c906108c SS	279	curr_line++;
0c820d67	280	}
98427f35	281	}
c906108c SS	282
c906108c SS	283
98427f35 SC	284	/* Function to display source in the source window. This function
98427f35 SC	285	initializes the horizontal scroll to 0. */
c906108c	286	void
13274fc3	287	tui_show_symtab_source (struct gdbarch gdbarch, struct symtab s,
08ef48c5 MS	288	struct tui_line_or_address line,
08ef48c5 MS	289	int noerror)
c906108c	290	{
e6e41501	291	TUI_SRC_WIN->horizontal_offset = 0;
13274fc3	292	tui_update_source_window_as_is (TUI_SRC_WIN, gdbarch, s, line, noerror);
98427f35	293	}
c906108c	294
c906108c	295
a358af15 AC	296	/* Answer whether the source is currently displayed in the source
a358af15 AC	297	window. */
c906108c	298	int
56d397a3	299	tui_source_is_displayed (const char *fullname)
c906108c	300	{
f629cd75	301	return (TUI_SRC_WIN != NULL
cb2ce893	302	&& TUI_SRC_WIN->content_in_use
63ed8182 PP	303	&& (filename_cmp (tui_locator_win_info_ptr ()->content[0]
63ed8182 PP	304	->which_element.locator.full_name,
56d397a3	305	fullname) == 0));
98427f35	306	}
c906108c SS	307
c906108c SS	308
98427f35	309	/* Scroll the source forward or backward vertically. */
c906108c	310	void
13446e05 TT	311	tui_source_window::do_scroll_vertical
13446e05 TT	312	(enum tui_scroll_direction scroll_direction, int num_to_scroll)
c906108c	313	{
cb2ce893	314	if (content != NULL)
c906108c	315	{
362c05fe	316	struct tui_line_or_address l;
c906108c	317	struct symtab *s;
52575520	318	struct symtab_and_line cursal = get_current_source_symtab_and_line ();
c906108c	319
cafb3438	320	if (cursal.symtab == NULL)
34248c3a	321	s = find_pc_line_symtab (get_frame_pc (get_selected_frame (NULL)));
c906108c	322	else
52575520	323	s = cursal.symtab;
c906108c	324
362c05fe	325	l.loa = LOA_LINE;
6ba8e26f	326	if (scroll_direction == FORWARD_SCROLL)
c906108c	327	{
362c05fe AS	328	l.u.line_no = content[0]->which_element.source.line_or_addr.u.line_no
	329	+ num_to_scroll;
	330	if (l.u.line_no > s->nlines)
cb2ce893	331	/* line = s->nlines - win_info->content_size + 1; */
1cc6d956	332	/* elz: fix for dts 23398. */
9a2b4c1b MS	333	l.u.line_no
9a2b4c1b MS	334	= content[0]->which_element.source.line_or_addr.u.line_no;
c906108c SS	335	}
	336	else
	337	{
362c05fe AS	338	l.u.line_no = content[0]->which_element.source.line_or_addr.u.line_no
	339	- num_to_scroll;
	340	if (l.u.line_no <= 0)
	341	l.u.line_no = 1;
c906108c	342	}
27229e99	343
362c05fe	344	print_source_lines (s, l.u.line_no, l.u.line_no + 1, 0);
c906108c	345	}
98427f35	346	}