[deliverable/binutils-gdb.git] / gdb / scm-valprint.c

/* Scheme/Guile language support routines for GDB, the GNU debugger.
   Copyright 1995, 1996, 1998, 1999, 2000, 2001
   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 2 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, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "expression.h"
#include "parser-defs.h"
#include "language.h"
#include "value.h"
#include "scm-lang.h"
#include "valprint.h"
#include "gdbcore.h"

/* FIXME: Should be in a header file that we import. */
extern int c_val_print (struct type *, char *, int, CORE_ADDR,
			struct ui_file *, int, int, int,
			enum val_prettyprint);

static void scm_ipruk (char *, LONGEST, struct ui_file *);
static void scm_scmlist_print (LONGEST, struct ui_file *, int, int,
			       int, enum val_prettyprint);
static int scm_inferior_print (LONGEST, struct ui_file *, int, int,
			       int, enum val_prettyprint);

/* Prints the SCM value VALUE by invoking the inferior, if appropraite.
   Returns >= 0 on succes;  retunr -1 if the inferior cannot/should not
   print VALUE. */

static int
scm_inferior_print (LONGEST value, struct ui_file *stream, int format,
		    int deref_ref, int recurse, enum val_prettyprint pretty)
{
  return -1;
}

/* {Names of immediate symbols}
 * This table must agree with the declarations in scm.h: {Immediate Symbols}.*/

static char *scm_isymnames[] =
{
  /* This table must agree with the declarations */
  "and",
  "begin",
  "case",
  "cond",
  "do",
  "if",
  "lambda",
  "let",
  "let*",
  "letrec",
  "or",
  "quote",
  "set!",
  "define",
#if 0
  "literal-variable-ref",
  "literal-variable-set!",
#endif
  "apply",
  "call-with-current-continuation",

 /* user visible ISYMS */
 /* other keywords */
 /* Flags */

  "#f",
  "#t",
  "#<undefined>",
  "#<eof>",
  "()",
  "#<unspecified>"
};

static void
scm_scmlist_print (LONGEST svalue, struct ui_file *stream, int format,
		   int deref_ref, int recurse, enum val_prettyprint pretty)
{
  unsigned int more = print_max;
  if (recurse > 6)
    {
      fputs_filtered ("...", stream);
      return;
    }
  scm_scmval_print (SCM_CAR (svalue), stream, format,
		    deref_ref, recurse + 1, pretty);
  svalue = SCM_CDR (svalue);
  for (; SCM_NIMP (svalue); svalue = SCM_CDR (svalue))
    {
      if (SCM_NECONSP (svalue))
	break;
      fputs_filtered (" ", stream);
      if (--more == 0)
	{
	  fputs_filtered ("...", stream);
	  return;
	}
      scm_scmval_print (SCM_CAR (svalue), stream, format,
			deref_ref, recurse + 1, pretty);
    }
  if (SCM_NNULLP (svalue))
    {
      fputs_filtered (" . ", stream);
      scm_scmval_print (svalue, stream, format,
			deref_ref, recurse + 1, pretty);
    }
}

static void
scm_ipruk (char *hdr, LONGEST ptr, struct ui_file *stream)
{
  fprintf_filtered (stream, "#<unknown-%s", hdr);
#define SCM_SIZE TYPE_LENGTH (builtin_type_scm)
  if (SCM_CELLP (ptr))
    fprintf_filtered (stream, " (0x%lx . 0x%lx) @",
		      (long) SCM_CAR (ptr), (long) SCM_CDR (ptr));
  fprintf_filtered (stream, " 0x%s>", paddr_nz (ptr));
}

void
scm_scmval_print (LONGEST svalue, struct ui_file *stream, int format,
		  int deref_ref, int recurse, enum val_prettyprint pretty)
{
taloop:
  switch (7 & (int) svalue)
    {
    case 2:
    case 6:
      print_longest (stream, format ? format : 'd', 1, svalue >> 2);
      break;
    case 4:
      if (SCM_ICHRP (svalue))
	{
	  svalue = SCM_ICHR (svalue);
	  scm_printchar (svalue, stream);
	  break;
	}
      else if (SCM_IFLAGP (svalue)
	       && (SCM_ISYMNUM (svalue)
		   < (sizeof scm_isymnames / sizeof (char *))))
	{
	  fputs_filtered (SCM_ISYMCHARS (svalue), stream);
	  break;
	}
      else if (SCM_ILOCP (svalue))
	{
	  fprintf_filtered (stream, "#@%ld%c%ld",
			    (long) SCM_IFRAME (svalue),
			    SCM_ICDRP (svalue) ? '-' : '+',
			    (long) SCM_IDIST (svalue));
	  break;
	}
      else
	goto idef;
      break;
    case 1:
      /* gloc */
      svalue = SCM_CAR (svalue - 1);
      goto taloop;
    default:
    idef:
      scm_ipruk ("immediate", svalue, stream);
      break;
    case 0:

      switch (SCM_TYP7 (svalue))
	{
	case scm_tcs_cons_gloc:
	  if (SCM_CDR (SCM_CAR (svalue) - 1L) == 0)
	    {
#if 0
	      SCM name;
#endif
	      fputs_filtered ("#<latte ", stream);
#if 1
	      fputs_filtered ("???", stream);
#else
	      name = ((SCM n *) (STRUCT_TYPE (exp)))[struct_i_name];
	      scm_lfwrite (CHARS (name),
			   (sizet) sizeof (char),
			     (sizet) LENGTH (name),
			   port);
#endif
	      fprintf_filtered (stream, " #X%s>", paddr_nz (svalue));
	      break;
	    }
	case scm_tcs_cons_imcar:
	case scm_tcs_cons_nimcar:
	  fputs_filtered ("(", stream);
	  scm_scmlist_print (svalue, stream, format,
			     deref_ref, recurse + 1, pretty);
	  fputs_filtered (")", stream);
	  break;
	case scm_tcs_closures:
	  fputs_filtered ("#<CLOSURE ", stream);
	  scm_scmlist_print (SCM_CODE (svalue), stream, format,
			     deref_ref, recurse + 1, pretty);
	  fputs_filtered (">", stream);
	  break;
	case scm_tc7_string:
	  {
	    int len = SCM_LENGTH (svalue);
	    CORE_ADDR addr = (CORE_ADDR) SCM_CDR (svalue);
	    int i;
	    int done = 0;
	    int buf_size;
	    char buffer[64];
	    int truncate = print_max && len > (int) print_max;
	    if (truncate)
	      len = print_max;
	    fputs_filtered ("\"", stream);
	    for (; done < len; done += buf_size)
	      {
		buf_size = min (len - done, 64);
		read_memory (addr + done, buffer, buf_size);

		for (i = 0; i < buf_size; ++i)
		  switch (buffer[i])
		    {
		    case '\"':
		    case '\\':
		      fputs_filtered ("\\", stream);
		    default:
		      fprintf_filtered (stream, "%c", buffer[i]);
		    }
	      }
	    fputs_filtered (truncate ? "...\"" : "\"", stream);
	    break;
	  }
	  break;
	case scm_tcs_symbols:
	  {
	    int len = SCM_LENGTH (svalue);

	    char *str = (char *) alloca (len);
	    read_memory (SCM_CDR (svalue), str, len + 1);
	    /* Should handle weird characters FIXME */
	    str[len] = '\0';
	    fputs_filtered (str, stream);
	    break;
	  }
	case scm_tc7_vector:
	  {
	    int len = SCM_LENGTH (svalue);
	    int i;
	    LONGEST elements = SCM_CDR (svalue);
	    fputs_filtered ("#(", stream);
	    for (i = 0; i < len; ++i)
	      {
		if (i > 0)
		  fputs_filtered (" ", stream);
		scm_scmval_print (scm_get_field (elements, i), stream, format,
				  deref_ref, recurse + 1, pretty);
	      }
	    fputs_filtered (")", stream);
	  }
	  break;
#if 0
	case tc7_lvector:
	  {
	    SCM result;
	    SCM hook;
	    hook = scm_get_lvector_hook (exp, LV_PRINT_FN);
	    if (hook == BOOL_F)
	      {
		scm_puts ("#<locked-vector ", port);
		scm_intprint (CDR (exp), 16, port);
		scm_puts (">", port);
	      }
	    else
	      {
		result
		  = scm_apply (hook,
			       scm_listify (exp, port, 
					    (writing ? BOOL_T : BOOL_F),
					    SCM_UNDEFINED),
			       EOL);
		if (result == BOOL_F)
		  goto punk;
	      }
	    break;
	  }
	  break;
	case tc7_bvect:
	case tc7_ivect:
	case tc7_uvect:
	case tc7_fvect:
	case tc7_dvect:
	case tc7_cvect:
	  scm_raprin1 (exp, port, writing);
	  break;
#endif
	case scm_tcs_subrs:
	  {
	    int index = SCM_CAR (svalue) >> 8;
#if 1
	    char str[20];
	    sprintf (str, "#%d", index);
#else
	    char *str = index ? SCM_CHARS (scm_heap_org + index) : "";
#define SCM_CHARS(x) ((char *)(SCM_CDR(x)))
	    char *str = CHARS (SNAME (exp));
#endif
	    fprintf_filtered (stream, "#<primitive-procedure %s>",
			      str);
	  }
	  break;
#if 0
#ifdef CCLO
	case tc7_cclo:
	  scm_puts ("#<compiled-closure ", port);
	  scm_iprin1 (CCLO_SUBR (exp), port, writing);
	  scm_putc ('>', port);
	  break;
#endif
	case tc7_contin:
	  fprintf_filtered (stream, "#<continuation %d @ #X%lx >",
			    LENGTH (svalue),
			    (long) CHARS (svalue));
	  break;
	case tc7_port:
	  i = PTOBNUM (exp);
	  if (i < scm_numptob 
	      && scm_ptobs[i].print 
	      && (scm_ptobs[i].print) (exp, port, writing))
	    break;
	  goto punk;
	case tc7_smob:
	  i = SMOBNUM (exp);
	  if (i < scm_numsmob && scm_smobs[i].print
	      && (scm_smobs[i].print) (exp, port, writing))
	    break;
	  goto punk;
#endif
	default:
#if 0
	punk:
#endif
	  scm_ipruk ("type", svalue, stream);
	}
      break;
    }
}

int
scm_val_print (struct type *type, char *valaddr, int embedded_offset,
	       CORE_ADDR address, struct ui_file *stream, int format,
	       int deref_ref, int recurse, enum val_prettyprint pretty)
{
  if (is_scmvalue_type (type))
    {
      LONGEST svalue = extract_signed_integer (valaddr, TYPE_LENGTH (type));
      if (scm_inferior_print (svalue, stream, format,
			      deref_ref, recurse, pretty) >= 0)
	{
	}
      else
	{
	  scm_scmval_print (svalue, stream, format,
			    deref_ref, recurse, pretty);
	}

      gdb_flush (stream);
      return (0);
    }
  else
    {
      return c_val_print (type, valaddr, 0, address, stream, format,
			  deref_ref, recurse, pretty);
    }
}

int
scm_value_print (struct value *val, struct ui_file *stream, int format,
		 enum val_prettyprint pretty)
{
  return (val_print (value_type (val), VALUE_CONTENTS (val), 0,
		     VALUE_ADDRESS (val), stream, format, 1, 0, pretty));
}
Commit	Line	Data
c906108c	1	/* Scheme/Guile language support routines for GDB, the GNU debugger.
6943961c AC	2	Copyright 1995, 1996, 1998, 1999, 2000, 2001
6943961c AC	3	Free Software Foundation, Inc.
c906108c	4
c5aa993b	5	This file is part of GDB.
c906108c	6
c5aa993b JM	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 2 of the License, or
	10	(at your option) any later version.
c906108c	11
c5aa993b JM	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.
c906108c	16
c5aa993b JM	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 59 Temple Place - Suite 330,
	20	Boston, MA 02111-1307, USA. */
c906108c SS	21
	22	#include "defs.h"
	23	#include "symtab.h"
	24	#include "gdbtypes.h"
	25	#include "expression.h"
	26	#include "parser-defs.h"
	27	#include "language.h"
	28	#include "value.h"
	29	#include "scm-lang.h"
	30	#include "valprint.h"
	31	#include "gdbcore.h"
	32
	33	/* FIXME: Should be in a header file that we import. */
d9fcf2fb JM	34	extern int c_val_print (struct type , char , int, CORE_ADDR,
	35	struct ui_file *, int, int, int,
	36	enum val_prettyprint);
c906108c	37
d9fcf2fb JM	38	static void scm_ipruk (char , LONGEST, struct ui_file );
	39	static void scm_scmlist_print (LONGEST, struct ui_file *, int, int,
	40	int, enum val_prettyprint);
	41	static int scm_inferior_print (LONGEST, struct ui_file *, int, int,
	42	int, enum val_prettyprint);
c906108c SS	43
	44	/* Prints the SCM value VALUE by invoking the inferior, if appropraite.
	45	Returns >= 0 on succes; retunr -1 if the inferior cannot/should not
	46	print VALUE. */
	47
	48	static int
fba45db2 KB	49	scm_inferior_print (LONGEST value, struct ui_file *stream, int format,
fba45db2 KB	50	int deref_ref, int recurse, enum val_prettyprint pretty)
c906108c SS	51	{
	52	return -1;
	53	}
	54
	55	/* {Names of immediate symbols}
	56	* This table must agree with the declarations in scm.h: {Immediate Symbols}.*/
	57
	58	static char *scm_isymnames[] =
	59	{
	60	/* This table must agree with the declarations */
	61	"and",
	62	"begin",
	63	"case",
	64	"cond",
	65	"do",
	66	"if",
	67	"lambda",
	68	"let",
	69	"let*",
	70	"letrec",
	71	"or",
	72	"quote",
	73	"set!",
	74	"define",
	75	#if 0
	76	"literal-variable-ref",
	77	"literal-variable-set!",
	78	#endif
	79	"apply",
	80	"call-with-current-continuation",
	81
	82	/* user visible ISYMS */
	83	/* other keywords */
	84	/* Flags */
	85
	86	"#f",
	87	"#t",
	88	"#<undefined>",
	89	"#<eof>",
	90	"()",
	91	"#<unspecified>"
	92	};
	93
	94	static void
fba45db2 KB	95	scm_scmlist_print (LONGEST svalue, struct ui_file *stream, int format,
fba45db2 KB	96	int deref_ref, int recurse, enum val_prettyprint pretty)
c906108c SS	97	{
	98	unsigned int more = print_max;
	99	if (recurse > 6)
	100	{
	101	fputs_filtered ("...", stream);
	102	return;
	103	}
	104	scm_scmval_print (SCM_CAR (svalue), stream, format,
	105	deref_ref, recurse + 1, pretty);
	106	svalue = SCM_CDR (svalue);
	107	for (; SCM_NIMP (svalue); svalue = SCM_CDR (svalue))
	108	{
	109	if (SCM_NECONSP (svalue))
	110	break;
	111	fputs_filtered (" ", stream);
	112	if (--more == 0)
	113	{
	114	fputs_filtered ("...", stream);
	115	return;
	116	}
	117	scm_scmval_print (SCM_CAR (svalue), stream, format,
	118	deref_ref, recurse + 1, pretty);
	119	}
	120	if (SCM_NNULLP (svalue))
	121	{
	122	fputs_filtered (" . ", stream);
	123	scm_scmval_print (svalue, stream, format,
	124	deref_ref, recurse + 1, pretty);
	125	}
	126	}
	127
	128	static void
fba45db2	129	scm_ipruk (char hdr, LONGEST ptr, struct ui_file stream)
c906108c SS	130	{
	131	fprintf_filtered (stream, "#<unknown-%s", hdr);
	132	#define SCM_SIZE TYPE_LENGTH (builtin_type_scm)
	133	if (SCM_CELLP (ptr))
	134	fprintf_filtered (stream, " (0x%lx . 0x%lx) @",
	135	(long) SCM_CAR (ptr), (long) SCM_CDR (ptr));
d4f3574e	136	fprintf_filtered (stream, " 0x%s>", paddr_nz (ptr));
c906108c SS	137	}
	138
	139	void
fba45db2 KB	140	scm_scmval_print (LONGEST svalue, struct ui_file *stream, int format,
fba45db2 KB	141	int deref_ref, int recurse, enum val_prettyprint pretty)
c906108c	142	{
c5aa993b	143	taloop:
c906108c SS	144	switch (7 & (int) svalue)
	145	{
	146	case 2:
	147	case 6:
	148	print_longest (stream, format ? format : 'd', 1, svalue >> 2);
	149	break;
	150	case 4:
	151	if (SCM_ICHRP (svalue))
	152	{
	153	svalue = SCM_ICHR (svalue);
	154	scm_printchar (svalue, stream);
	155	break;
	156	}
	157	else if (SCM_IFLAGP (svalue)
	158	&& (SCM_ISYMNUM (svalue)
	159	< (sizeof scm_isymnames / sizeof (char *))))
	160	{
	161	fputs_filtered (SCM_ISYMCHARS (svalue), stream);
	162	break;
	163	}
	164	else if (SCM_ILOCP (svalue))
	165	{
	166	fprintf_filtered (stream, "#@%ld%c%ld",
	167	(long) SCM_IFRAME (svalue),
	168	SCM_ICDRP (svalue) ? '-' : '+',
	169	(long) SCM_IDIST (svalue));
	170	break;
	171	}
	172	else
	173	goto idef;
	174	break;
	175	case 1:
	176	/* gloc */
	177	svalue = SCM_CAR (svalue - 1);
	178	goto taloop;
	179	default:
	180	idef:
	181	scm_ipruk ("immediate", svalue, stream);
	182	break;
	183	case 0:
	184
	185	switch (SCM_TYP7 (svalue))
	186	{
	187	case scm_tcs_cons_gloc:
	188	if (SCM_CDR (SCM_CAR (svalue) - 1L) == 0)
	189	{
	190	#if 0
	191	SCM name;
	192	#endif
	193	fputs_filtered ("#<latte ", stream);
	194	#if 1
	195	fputs_filtered ("???", stream);
	196	#else
c5aa993b	197	name = ((SCM n *) (STRUCT_TYPE (exp)))[struct_i_name];
c906108c SS	198	scm_lfwrite (CHARS (name),
c906108c SS	199	(sizet) sizeof (char),
c5aa993b	200	(sizet) LENGTH (name),
c906108c SS	201	port);
c906108c SS	202	#endif
d4f3574e	203	fprintf_filtered (stream, " #X%s>", paddr_nz (svalue));
c906108c SS	204	break;
	205	}
	206	case scm_tcs_cons_imcar:
	207	case scm_tcs_cons_nimcar:
	208	fputs_filtered ("(", stream);
	209	scm_scmlist_print (svalue, stream, format,
	210	deref_ref, recurse + 1, pretty);
	211	fputs_filtered (")", stream);
	212	break;
	213	case scm_tcs_closures:
	214	fputs_filtered ("#<CLOSURE ", stream);
	215	scm_scmlist_print (SCM_CODE (svalue), stream, format,
	216	deref_ref, recurse + 1, pretty);
	217	fputs_filtered (">", stream);
	218	break;
	219	case scm_tc7_string:
	220	{
	221	int len = SCM_LENGTH (svalue);
	222	CORE_ADDR addr = (CORE_ADDR) SCM_CDR (svalue);
	223	int i;
	224	int done = 0;
	225	int buf_size;
	226	char buffer[64];
	227	int truncate = print_max && len > (int) print_max;
	228	if (truncate)
	229	len = print_max;
	230	fputs_filtered ("\"", stream);
	231	for (; done < len; done += buf_size)
	232	{
	233	buf_size = min (len - done, 64);
	234	read_memory (addr + done, buffer, buf_size);
c5aa993b	235
c906108c SS	236	for (i = 0; i < buf_size; ++i)
	237	switch (buffer[i])
	238	{
	239	case '\"':
	240	case '\\':
	241	fputs_filtered ("\\", stream);
	242	default:
	243	fprintf_filtered (stream, "%c", buffer[i]);
	244	}
	245	}
	246	fputs_filtered (truncate ? "...\"" : "\"", stream);
	247	break;
	248	}
	249	break;
	250	case scm_tcs_symbols:
	251	{
	252	int len = SCM_LENGTH (svalue);
	253
c5aa993b	254	char str = (char ) alloca (len);
c906108c SS	255	read_memory (SCM_CDR (svalue), str, len + 1);
	256	/* Should handle weird characters FIXME */
	257	str[len] = '\0';
	258	fputs_filtered (str, stream);
	259	break;
	260	}
	261	case scm_tc7_vector:
	262	{
	263	int len = SCM_LENGTH (svalue);
	264	int i;
c5aa993b	265	LONGEST elements = SCM_CDR (svalue);
c906108c SS	266	fputs_filtered ("#(", stream);
	267	for (i = 0; i < len; ++i)
	268	{
	269	if (i > 0)
	270	fputs_filtered (" ", stream);
	271	scm_scmval_print (scm_get_field (elements, i), stream, format,
	272	deref_ref, recurse + 1, pretty);
	273	}
	274	fputs_filtered (")", stream);
	275	}
	276	break;
	277	#if 0
	278	case tc7_lvector:
	279	{
	280	SCM result;
	281	SCM hook;
	282	hook = scm_get_lvector_hook (exp, LV_PRINT_FN);
	283	if (hook == BOOL_F)
	284	{
	285	scm_puts ("#<locked-vector ", port);
c5aa993b	286	scm_intprint (CDR (exp), 16, port);
c906108c SS	287	scm_puts (">", port);
	288	}
	289	else
	290	{
	291	result
	292	= scm_apply (hook,
41ccc9f6 MS	293	scm_listify (exp, port,
	294	(writing ? BOOL_T : BOOL_F),
	295	SCM_UNDEFINED),
c906108c SS	296	EOL);
	297	if (result == BOOL_F)
	298	goto punk;
	299	}
	300	break;
	301	}
	302	break;
	303	case tc7_bvect:
	304	case tc7_ivect:
	305	case tc7_uvect:
	306	case tc7_fvect:
	307	case tc7_dvect:
	308	case tc7_cvect:
	309	scm_raprin1 (exp, port, writing);
	310	break;
	311	#endif
	312	case scm_tcs_subrs:
	313	{
	314	int index = SCM_CAR (svalue) >> 8;
	315	#if 1
	316	char str[20];
	317	sprintf (str, "#%d", index);
	318	#else
c5aa993b	319	char *str = index ? SCM_CHARS (scm_heap_org + index) : "";
c906108c SS	320	#define SCM_CHARS(x) ((char *)(SCM_CDR(x)))
	321	char *str = CHARS (SNAME (exp));
	322	#endif
	323	fprintf_filtered (stream, "#<primitive-procedure %s>",
	324	str);
	325	}
	326	break;
	327	#if 0
	328	#ifdef CCLO
	329	case tc7_cclo:
	330	scm_puts ("#<compiled-closure ", port);
	331	scm_iprin1 (CCLO_SUBR (exp), port, writing);
	332	scm_putc ('>', port);
	333	break;
	334	#endif
	335	case tc7_contin:
	336	fprintf_filtered (stream, "#<continuation %d @ #X%lx >",
	337	LENGTH (svalue),
	338	(long) CHARS (svalue));
	339	break;
	340	case tc7_port:
	341	i = PTOBNUM (exp);
41ccc9f6 MS	342	if (i < scm_numptob
	343	&& scm_ptobs[i].print
	344	&& (scm_ptobs[i].print) (exp, port, writing))
c906108c SS	345	break;
	346	goto punk;
	347	case tc7_smob:
	348	i = SMOBNUM (exp);
	349	if (i < scm_numsmob && scm_smobs[i].print
	350	&& (scm_smobs[i].print) (exp, port, writing))
	351	break;
	352	goto punk;
	353	#endif
	354	default:
	355	#if 0
	356	punk:
	357	#endif
	358	scm_ipruk ("type", svalue, stream);
	359	}
	360	break;
	361	}
	362	}
	363
	364	int
fba45db2 KB	365	scm_val_print (struct type type, char valaddr, int embedded_offset,
	366	CORE_ADDR address, struct ui_file *stream, int format,
	367	int deref_ref, int recurse, enum val_prettyprint pretty)
c906108c SS	368	{
	369	if (is_scmvalue_type (type))
	370	{
	371	LONGEST svalue = extract_signed_integer (valaddr, TYPE_LENGTH (type));
	372	if (scm_inferior_print (svalue, stream, format,
	373	deref_ref, recurse, pretty) >= 0)
	374	{
	375	}
	376	else
	377	{
	378	scm_scmval_print (svalue, stream, format,
c5aa993b	379	deref_ref, recurse, pretty);
c906108c SS	380	}
	381
	382	gdb_flush (stream);
	383	return (0);
	384	}
	385	else
	386	{
	387	return c_val_print (type, valaddr, 0, address, stream, format,
	388	deref_ref, recurse, pretty);
	389	}
	390	}
	391
	392	int
6943961c	393	scm_value_print (struct value val, struct ui_file stream, int format,
fba45db2	394	enum val_prettyprint pretty)
c906108c	395	{
df407dfe	396	return (val_print (value_type (val), VALUE_CONTENTS (val), 0,
c906108c SS	397	VALUE_ADDRESS (val), stream, format, 1, 0, pretty));
c906108c SS	398	}