[deliverable/binutils-gdb.git] / gdb / common / print-utils.c

/* Cell-based print utility routines for GDB, the GNU debugger.

   Copyright (C) 1986-2015 Free Software Foundation, Inc.

   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 "common-defs.h"
#include "print-utils.h"
/* Temporary storage using circular buffer.  */

#define NUMCELLS 16
#define CELLSIZE 50

/* Return the next entry in the circular buffer.  */

static char *
get_cell (void)
{
  static char buf[NUMCELLS][CELLSIZE];
  static int cell = 0;

  if (++cell >= NUMCELLS)
    cell = 0;
  return buf[cell];
}

static char *
decimal2str (char *sign, ULONGEST addr, int width)
{
  /* Steal code from valprint.c:print_decimal().  Should this worry
     about the real size of addr as the above does?  */
  unsigned long temp[3];
  char *str = get_cell ();
  int i = 0;

  do
    {
      temp[i] = addr % (1000 * 1000 * 1000);
      addr /= (1000 * 1000 * 1000);
      i++;
      width -= 9;
    }
  while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0])));

  width += 9;
  if (width < 0)
    width = 0;

  switch (i)
    {
    case 1:
      xsnprintf (str, CELLSIZE, "%s%0*lu", sign, width, temp[0]);
      break;
    case 2:
      xsnprintf (str, CELLSIZE, "%s%0*lu%09lu", sign, width,
		 temp[1], temp[0]);
      break;
    case 3:
      xsnprintf (str, CELLSIZE, "%s%0*lu%09lu%09lu", sign, width,
		 temp[2], temp[1], temp[0]);
      break;
    default:
      internal_error (__FILE__, __LINE__,
		      _("failed internal consistency check"));
    }

  return str;
}

static char *
octal2str (ULONGEST addr, int width)
{
  unsigned long temp[3];
  char *str = get_cell ();
  int i = 0;

  do
    {
      temp[i] = addr % (0100000 * 0100000);
      addr /= (0100000 * 0100000);
      i++;
      width -= 10;
    }
  while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0])));

  width += 10;
  if (width < 0)
    width = 0;

  switch (i)
    {
    case 1:
      if (temp[0] == 0)
	xsnprintf (str, CELLSIZE, "%*o", width, 0);
      else
	xsnprintf (str, CELLSIZE, "0%0*lo", width, temp[0]);
      break;
    case 2:
      xsnprintf (str, CELLSIZE, "0%0*lo%010lo", width, temp[1], temp[0]);
      break;
    case 3:
      xsnprintf (str, CELLSIZE, "0%0*lo%010lo%010lo", width,
		 temp[2], temp[1], temp[0]);
      break;
    default:
      internal_error (__FILE__, __LINE__,
		      _("failed internal consistency check"));
    }

  return str;
}

/* See print-utils.h.  */

char *
pulongest (ULONGEST u)
{
  return decimal2str ("", u, 0);
}

/* See print-utils.h.  */

char *
plongest (LONGEST l)
{
  if (l < 0)
    return decimal2str ("-", -l, 0);
  else
    return decimal2str ("", l, 0);
}

/* Eliminate warning from compiler on 32-bit systems.  */
static int thirty_two = 32;

/* See print-utils.h.  */

char *
phex (ULONGEST l, int sizeof_l)
{
  char *str;

  switch (sizeof_l)
    {
    case 8:
      str = get_cell ();
      xsnprintf (str, CELLSIZE, "%08lx%08lx",
		 (unsigned long) (l >> thirty_two),
		 (unsigned long) (l & 0xffffffff));
      break;
    case 4:
      str = get_cell ();
      xsnprintf (str, CELLSIZE, "%08lx", (unsigned long) l);
      break;
    case 2:
      str = get_cell ();
      xsnprintf (str, CELLSIZE, "%04x", (unsigned short) (l & 0xffff));
      break;
    default:
      str = phex (l, sizeof (l));
      break;
    }

  return str;
}

/* See print-utils.h.  */

char *
phex_nz (ULONGEST l, int sizeof_l)
{
  char *str;

  switch (sizeof_l)
    {
    case 8:
      {
	unsigned long high = (unsigned long) (l >> thirty_two);

	str = get_cell ();
	if (high == 0)
	  xsnprintf (str, CELLSIZE, "%lx",
		     (unsigned long) (l & 0xffffffff));
	else
	  xsnprintf (str, CELLSIZE, "%lx%08lx", high,
		     (unsigned long) (l & 0xffffffff));
	break;
      }
    case 4:
      str = get_cell ();
      xsnprintf (str, CELLSIZE, "%lx", (unsigned long) l);
      break;
    case 2:
      str = get_cell ();
      xsnprintf (str, CELLSIZE, "%x", (unsigned short) (l & 0xffff));
      break;
    default:
      str = phex_nz (l, sizeof (l));
      break;
    }

  return str;
}

/* See print-utils.h.  */

char *
hex_string (LONGEST num)
{
  char *result = get_cell ();

  xsnprintf (result, CELLSIZE, "0x%s", phex_nz (num, sizeof (num)));
  return result;
}

/* See print-utils.h.  */

char *
hex_string_custom (LONGEST num, int width)
{
  char *result = get_cell ();
  char *result_end = result + CELLSIZE - 1;
  const char *hex = phex_nz (num, sizeof (num));
  int hex_len = strlen (hex);

  if (hex_len > width)
    width = hex_len;
  if (width + 2 >= CELLSIZE)
    internal_error (__FILE__, __LINE__, _("\
hex_string_custom: insufficient space to store result"));

  strcpy (result_end - width - 2, "0x");
  memset (result_end - width, '0', width);
  strcpy (result_end - hex_len, hex);
  return result_end - width - 2;
}

/* See print-utils.h.  */

char *
int_string (LONGEST val, int radix, int is_signed, int width, 
	    int use_c_format)
{
  switch (radix) 
    {
    case 16:
      {
	char *result;

	if (width == 0)
	  result = hex_string (val);
	else
	  result = hex_string_custom (val, width);
	if (! use_c_format)
	  result += 2;
	return result;
      }
    case 10:
      {
	if (is_signed && val < 0)
	  return decimal2str ("-", -val, width);
	else
	  return decimal2str ("", val, width);
      }
    case 8:
      {
	char *result = octal2str (val, width);

	if (use_c_format || val == 0)
	  return result;
	else
	  return result + 1;
      }
    default:
      internal_error (__FILE__, __LINE__,
		      _("failed internal consistency check"));
    }
}	

/* See print-utils.h.  */

const char *
core_addr_to_string (const CORE_ADDR addr)
{
  char *str = get_cell ();

  strcpy (str, "0x");
  strcat (str, phex (addr, sizeof (addr)));
  return str;
}

/* See print-utils.h.  */

const char *
core_addr_to_string_nz (const CORE_ADDR addr)
{
  char *str = get_cell ();

  strcpy (str, "0x");
  strcat (str, phex_nz (addr, sizeof (addr)));
  return str;
}

/* See print-utils.h.  */

const char *
host_address_to_string (const void *addr)
{
  char *str = get_cell ();

  xsnprintf (str, CELLSIZE, "0x%s", phex_nz ((uintptr_t) addr, sizeof (addr)));
  return str;
}
Commit	Line	Data
01fd3ea5 TT	1	/* Cell-based print utility routines for GDB, the GNU debugger.
01fd3ea5 TT	2
32d0add0	3	Copyright (C) 1986-2015 Free Software Foundation, Inc.
01fd3ea5 TT	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 3 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	19
727605ca	20	#include "common-defs.h"
01fd3ea5	21	#include "print-utils.h"
01fd3ea5 TT	22	/* Temporary storage using circular buffer. */
	23
	24	#define NUMCELLS 16
	25	#define CELLSIZE 50
	26
	27	/* Return the next entry in the circular buffer. */
	28
	29	static char *
	30	get_cell (void)
	31	{
	32	static char buf[NUMCELLS][CELLSIZE];
	33	static int cell = 0;
	34
	35	if (++cell >= NUMCELLS)
	36	cell = 0;
	37	return buf[cell];
	38	}
	39
	40	static char *
	41	decimal2str (char *sign, ULONGEST addr, int width)
	42	{
	43	/* Steal code from valprint.c:print_decimal(). Should this worry
	44	about the real size of addr as the above does? */
	45	unsigned long temp[3];
	46	char *str = get_cell ();
	47	int i = 0;
	48
	49	do
	50	{
	51	temp[i] = addr % (1000 * 1000 * 1000);
	52	addr /= (1000 * 1000 * 1000);
	53	i++;
	54	width -= 9;
	55	}
	56	while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0])));
	57
	58	width += 9;
	59	if (width < 0)
	60	width = 0;
	61
	62	switch (i)
	63	{
	64	case 1:
	65	xsnprintf (str, CELLSIZE, "%s%0*lu", sign, width, temp[0]);
	66	break;
	67	case 2:
	68	xsnprintf (str, CELLSIZE, "%s%0*lu%09lu", sign, width,
	69	temp[1], temp[0]);
	70	break;
	71	case 3:
	72	xsnprintf (str, CELLSIZE, "%s%0*lu%09lu%09lu", sign, width,
	73	temp[2], temp[1], temp[0]);
	74	break;
	75	default:
	76	internal_error (__FILE__, __LINE__,
	77	_("failed internal consistency check"));
	78	}
	79
	80	return str;
	81	}
	82
	83	static char *
	84	octal2str (ULONGEST addr, int width)
	85	{
86	unsigned long temp[3];
87	char *str = get_cell ();
88	int i = 0;
89
90	do
91	{
92	temp[i] = addr % (0100000 * 0100000);
93	addr /= (0100000 * 0100000);
94	i++;
95	width -= 10;
96	}
97	while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0])));
98
99	width += 10;
100	if (width < 0)
101	width = 0;
102
103	switch (i)
104	{
105	case 1:
106	if (temp[0] == 0)
107	xsnprintf (str, CELLSIZE, "%*o", width, 0);
108	else
109	xsnprintf (str, CELLSIZE, "0%0*lo", width, temp[0]);
110	break;
111	case 2:
112	xsnprintf (str, CELLSIZE, "0%0*lo%010lo", width, temp[1], temp[0]);
113	break;
114	case 3:
115	xsnprintf (str, CELLSIZE, "0%0*lo%010lo%010lo", width,
116	temp[2], temp[1], temp[0]);
117	break;
118	default:
119	internal_error (__FILE__, __LINE__,
120	_("failed internal consistency check"));
121	}
122
123	return str;
124	}
125
126	/* See print-utils.h. */
127
128	char *
129	pulongest (ULONGEST u)
130	{
131	return decimal2str ("", u, 0);
132	}
133
134	/* See print-utils.h. */
135
136	char *
137	plongest (LONGEST l)
138	{
139	if (l < 0)
140	return decimal2str ("-", -l, 0);
141	else
142	return decimal2str ("", l, 0);
143	}
144
145	/* Eliminate warning from compiler on 32-bit systems. */
146	static int thirty_two = 32;
147
148	/* See print-utils.h. */
149
150	char *
151	phex (ULONGEST l, int sizeof_l)
152	{
153	char *str;
154
155	switch (sizeof_l)
156	{
157	case 8:
158	str = get_cell ();
159	xsnprintf (str, CELLSIZE, "%08lx%08lx",
160	(unsigned long) (l >> thirty_two),
161	(unsigned long) (l & 0xffffffff));
162	break;
163	case 4:
164	str = get_cell ();
165	xsnprintf (str, CELLSIZE, "%08lx", (unsigned long) l);
166	break;
167	case 2:
168	str = get_cell ();
169	xsnprintf (str, CELLSIZE, "%04x", (unsigned short) (l & 0xffff));
170	break;
171	default:
172	str = phex (l, sizeof (l));
173	break;
174	}
175
176	return str;
177	}
178
179	/* See print-utils.h. */
180
181	char *
182	phex_nz (ULONGEST l, int sizeof_l)
183	{
184	char *str;
185
186	switch (sizeof_l)
187	{
188	case 8:
189	{
190	unsigned long high = (unsigned long) (l >> thirty_two);
191
192	str = get_cell ();
193	if (high == 0)
194	xsnprintf (str, CELLSIZE, "%lx",
195	(unsigned long) (l & 0xffffffff));
196	else
197	xsnprintf (str, CELLSIZE, "%lx%08lx", high,
198	(unsigned long) (l & 0xffffffff));
199	break;
200	}
201	case 4:
202	str = get_cell ();
203	xsnprintf (str, CELLSIZE, "%lx", (unsigned long) l);
204	break;
205	case 2:
206	str = get_cell ();
207	xsnprintf (str, CELLSIZE, "%x", (unsigned short) (l & 0xffff));
208	break;
209	default:
210	str = phex_nz (l, sizeof (l));
211	break;
212	}
213
214	return str;
215	}
216
217	/* See print-utils.h. */
218
219	char *
220	hex_string (LONGEST num)
221	{
222	char *result = get_cell ();
223
224	xsnprintf (result, CELLSIZE, "0x%s", phex_nz (num, sizeof (num)));
225	return result;
226	}
227
228	/* See print-utils.h. */
229
230	char *
231	hex_string_custom (LONGEST num, int width)
232	{
233	char *result = get_cell ();
234	char *result_end = result + CELLSIZE - 1;
235	const char *hex = phex_nz (num, sizeof (num));
236	int hex_len = strlen (hex);
237
238	if (hex_len > width)
239	width = hex_len;
240	if (width + 2 >= CELLSIZE)
241	internal_error (__FILE__, __LINE__, _("\
242	hex_string_custom: insufficient space to store result"));
243
244	strcpy (result_end - width - 2, "0x");
245	memset (result_end - width, '0', width);
246	strcpy (result_end - hex_len, hex);
247	return result_end - width - 2;
248	}
249
250	/* See print-utils.h. */
251
252	char *
253	int_string (LONGEST val, int radix, int is_signed, int width,
254	int use_c_format)
255	{
256	switch (radix)
257	{
258	case 16:
259	{
260	char *result;
261
262	if (width == 0)
263	result = hex_string (val);
264	else
265	result = hex_string_custom (val, width);
266	if (! use_c_format)
267	result += 2;
268	return result;
269	}
270	case 10:
271	{
272	if (is_signed && val < 0)
273	return decimal2str ("-", -val, width);
274	else
275	return decimal2str ("", val, width);
276	}
277	case 8:
278	{
279	char *result = octal2str (val, width);
280
281	if (use_c_format \|\| val == 0)
282	return result;
283	else
284	return result + 1;
285	}
286	default:
287	internal_error (__FILE__, __LINE__,
288	_("failed internal consistency check"));
289	}
290	}
291
292	/* See print-utils.h. */
293
294	const char *
295	core_addr_to_string (const CORE_ADDR addr)
296	{
297	char *str = get_cell ();
298
299	strcpy (str, "0x");
300	strcat (str, phex (addr, sizeof (addr)));
301	return str;
302	}
303
304	/* See print-utils.h. */
305
306	const char *
307	core_addr_to_string_nz (const CORE_ADDR addr)
308	{
309	char *str = get_cell ();
310
311	strcpy (str, "0x");
312	strcat (str, phex_nz (addr, sizeof (addr)));
313	return str;
314	}
315
316	/* See print-utils.h. */
317
318	const char *
319	host_address_to_string (const void *addr)
320	{
321	char *str = get_cell ();
322
323	xsnprintf (str, CELLSIZE, "0x%s", phex_nz ((uintptr_t) addr, sizeof (addr)));
324	return str;
325	}