-/* Copyright (C) 1995-1999 Free Software Foundation, Inc.
+/* Copyright (C) 1995-1999,2000,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
\f
-#include <stdio.h>
-#include "_scm.h"
-#include "chars.h"
-#include "genio.h"
-#include "smob.h"
-#include "eval.h"
-#include "macros.h"
-#include "procprop.h"
-#include "read.h"
-#include "weaks.h"
-#include "unif.h"
-#include "alist.h"
-#include "struct.h"
-#include "objects.h"
-#include "strports.h"
-
-#include "scm_validate.h"
-#include "print.h"
+#include <errno.h>
+
+#include "libguile/_scm.h"
+#include "libguile/chars.h"
+#include "libguile/continuations.h"
+#include "libguile/smob.h"
+#include "libguile/eval.h"
+#include "libguile/macros.h"
+#include "libguile/procprop.h"
+#include "libguile/read.h"
+#include "libguile/weaks.h"
+#include "libguile/unif.h"
+#include "libguile/alist.h"
+#include "libguile/struct.h"
+#include "libguile/objects.h"
+#include "libguile/ports.h"
+#include "libguile/root.h"
+#include "libguile/strings.h"
+#include "libguile/strports.h"
+#include "libguile/vectors.h"
+
+#include "libguile/validate.h"
+#include "libguile/print.h"
\f
/* {Names of immediate symbols}
};
scm_option scm_print_opts[] = {
- { SCM_OPTION_SCM, "closure-hook", SCM_BOOL_F,
- "Hook for printing closures." },
+ { SCM_OPTION_SCM, "closure-hook", SCM_UNPACK (SCM_BOOL_F),
+ "Hook for printing closures (should handle macros as well)." },
{ SCM_OPTION_BOOLEAN, "source", 0,
"Print closures with source." }
};
SCM_DEFINE (scm_print_options, "print-options-interface", 0, 1, 0,
(SCM setting),
-"")
+ "Option interface for the print options. Instead of using\n"
+ "this procedure directly, use the procedures\n"
+ "@code{print-enable}, @code{print-disable}, @code{print-set!}\n"
+ "and @code{print-options}.")
#define FUNC_NAME s_scm_print_options
{
SCM ans = scm_options (setting,
/* Detection of circular references.
*
* Due to other constraints in the implementation, this code has bad
- * time complexity (O (depth * N)), The printer code will be
- * completely rewritten before next release of Guile. The new code
- * will be O(N).
+ * time complexity (O (depth * N)), The printer code can be
+ * rewritten to be O(N).
*/
#define PUSH_REF(pstate, obj) \
do { \
do { \
register unsigned long i; \
for (i = 0; i < pstate->top; ++i) \
- if (pstate->ref_stack[i] == (obj)) \
+ if (SCM_EQ_P (pstate->ref_stack[i], (obj))) \
goto label; \
if (pstate->fancyp) \
{ \
SCM_DEFINE (scm_current_pstate, "current-pstate", 0, 0, 0,
(),
-"")
+ "Return the current-pstate -- the cadr of the\n"
+ "@code{print_state_pool}. @code{current-pstate} is only\n"
+ "included in @code{--enable-guile-debug} builds.")
#define FUNC_NAME s_scm_current_pstate
{
- return SCM_CADR (print_state_pool);
+ if (SCM_NNULLP (SCM_CDR (print_state_pool)))
+ return SCM_CADR (print_state_pool);
+ else
+ return SCM_BOOL_F;
}
#undef FUNC_NAME
SCM_INUM0,
SCM_EOL);
scm_print_state *pstate = SCM_PRINT_STATE (print_state);
- pstate->ref_vect = scm_make_vector (SCM_MAKINUM (PSTATE_SIZE),
- SCM_UNDEFINED);
+ pstate->ref_vect = scm_c_make_vector (PSTATE_SIZE, SCM_UNDEFINED);
pstate->ref_stack = SCM_VELTS (pstate->ref_vect);
- pstate->ceiling = SCM_LENGTH (pstate->ref_vect);
+ pstate->ceiling = SCM_VECTOR_LENGTH (pstate->ref_vect);
return print_state;
}
SCM
scm_make_print_state ()
{
- SCM answer = 0;
+ SCM answer = SCM_BOOL_F;
/* First try to allocate a print state from the pool */
SCM_DEFER_INTS;
}
SCM_ALLOW_INTS;
- return answer ? answer : make_print_state ();
+ return SCM_FALSEP (answer) ? make_print_state () : answer;
}
void
pstate->revealed = 0;
SCM_NEWCELL (handle);
SCM_DEFER_INTS;
- SCM_SETCAR (handle, print_state);
- SCM_SETCDR (handle, SCM_CDR (print_state_pool));
+ SCM_SET_CELL_WORD_0 (handle, print_state);
+ SCM_SET_CELL_WORD_1 (handle, SCM_CDR (print_state_pool));
SCM_SETCDR (print_state_pool, handle);
SCM_ALLOW_INTS;
}
static void
grow_ref_stack (scm_print_state *pstate)
{
- int new_size = 2 * pstate->ceiling;
- scm_vector_set_length_x (pstate->ref_vect, SCM_MAKINUM (new_size));
- pstate->ref_stack = SCM_VELTS (pstate->ref_vect);
+ unsigned long int old_size = SCM_VECTOR_LENGTH (pstate->ref_vect);
+ SCM *old_elts = SCM_VELTS (pstate->ref_vect);
+ unsigned long int new_size = 2 * pstate->ceiling;
+ SCM new_vect = scm_c_make_vector (new_size, SCM_UNDEFINED);
+ SCM *new_elts = SCM_VELTS (new_vect);
+ unsigned long int i;
+
+ for (i = 0; i != old_size; ++i)
+ new_elts [i] = old_elts [i];
+
+ pstate->ref_vect = new_vect;
+ pstate->ref_stack = new_elts;
pstate->ceiling = new_size;
}
while (i > 0)
{
if (SCM_NCONSP (pstate->ref_stack[i - 1])
- || SCM_CDR (pstate->ref_stack[i - 1]) != pstate->ref_stack[i])
+ || !SCM_EQ_P (SCM_CDR (pstate->ref_stack[i - 1]),
+ pstate->ref_stack[i]))
break;
--i;
}
self = i;
}
for (i = pstate->top - 1; 1; --i)
- if (pstate->ref_stack[i] == ref)
+ if (SCM_EQ_P (pstate->ref_stack[i], ref))
break;
scm_putc ('#', port);
scm_intprint (i - self, 10, port);
SCM_GPROC(s_write, "write", 1, 1, 0, scm_write, g_write);
SCM_GPROC(s_display, "display", 1, 1, 0, scm_display, g_display);
+
void
scm_iprin1 (SCM exp, SCM port, scm_print_state *pstate)
{
taloop:
- switch (7 & (int) exp)
+ switch (SCM_ITAG3 (exp))
{
- case 2:
- case 6:
+ case scm_tc3_closure:
+ case scm_tc3_tc7_1:
+ case scm_tc3_tc7_2:
+ /* These tc3 tags should never occur in an immediate value. They are
+ * only used in cell types of non-immediates, i. e. the value returned
+ * by SCM_CELL_TYPE (exp) can use these tags.
+ */
+ scm_ipruk ("immediate", exp, port);
+ break;
+ case scm_tc3_int_1:
+ case scm_tc3_int_2:
scm_intprint (SCM_INUM (exp), 10, port);
break;
- case 4:
- if (SCM_ICHRP (exp))
+ case scm_tc3_imm24:
+ if (SCM_CHARP (exp))
{
- register long i;
+ long i = SCM_CHAR (exp);
- i = SCM_ICHR (exp);
if (SCM_WRITINGP (pstate))
{
scm_puts ("#\\", port);
if ((i >= 0) && (i <= ' ') && scm_charnames[i])
scm_puts (scm_charnames[i], port);
+#ifndef EBCDIC
+ else if (i == '\177')
+ scm_puts (scm_charnames[scm_n_charnames - 1], port);
+#endif
else if (i < 0 || i > '\177')
scm_intprint (i, 8, port);
else
else if (SCM_ILOCP (exp))
{
scm_puts ("#@", port);
- scm_intprint ((long) SCM_IFRAME (exp), 10, port);
+ scm_intprint (SCM_IFRAME (exp), 10, port);
scm_putc (SCM_ICDRP (exp) ? '-' : '+', port);
- scm_intprint ((long) SCM_IDIST (exp), 10, port);
+ scm_intprint (SCM_IDIST (exp), 10, port);
}
else
- goto idef;
+ {
+ /* unknown immediate value */
+ scm_ipruk ("immediate", exp, port);
+ }
break;
- case 1:
+ case scm_tc3_cons_gloc:
/* gloc */
scm_puts ("#@", port);
- exp = SCM_CAR (exp - 1);
+ exp = SCM_GLOC_SYM (exp);
goto taloop;
- default:
- idef:
- scm_ipruk ("immediate", exp, port);
- break;
- case 0:
+ case scm_tc3_cons:
switch (SCM_TYP7 (exp))
{
case scm_tcs_cons_gloc:
- if (SCM_CDR (SCM_CAR (exp) - 1L) == 0)
+ if (SCM_STRUCT_VTABLE_DATA (exp) [scm_vtable_index_vcell] == 0)
{
ENTER_NESTED_DATA (pstate, exp, circref);
if (SCM_OBJ_CLASS_FLAGS (exp) & SCM_CLASSF_GOOPS)
goto print_struct;
SCM_NEWSMOB (pwps,
scm_tc16_port_with_ps,
- scm_cons (port, pstate->handle));
+ SCM_UNPACK (scm_cons (port, pstate->handle)));
scm_call_generic_2 (print, exp, pwps);
}
else
circref:
print_circref (port, pstate, exp);
break;
- macros:
- if (!SCM_CLOSUREP (SCM_CDR (exp)))
- goto prinmacro;
case scm_tcs_closures:
- /* The user supplied print closure procedure must handle
- macro closures as well. */
if (SCM_FALSEP (scm_procedure_p (SCM_PRINT_CLOSURE))
|| SCM_FALSEP (scm_printer_apply (SCM_PRINT_CLOSURE,
exp, port, pstate)))
- {
- SCM name, code, env;
- if (SCM_TYP16 (exp) == scm_tc16_macro)
- {
- /* Printing a macro. */
- prinmacro:
- name = scm_macro_name (exp);
- if (!SCM_CLOSUREP (SCM_CDR (exp)))
- {
- code = env = 0;
- scm_puts ("#<primitive-", port);
- }
- else
- {
- code = SCM_CODE (SCM_CDR (exp));
- env = SCM_ENV (SCM_CDR (exp));
- scm_puts ("#<", port);
- }
- if (SCM_CAR (exp) & (3L << 16))
- scm_puts ("macro", port);
- else
- scm_puts ("syntax", port);
- if (SCM_CAR (exp) & (2L << 16))
- scm_putc ('!', port);
- }
- else
- {
- /* Printing a closure. */
- name = scm_procedure_name (exp);
- code = SCM_CODE (exp);
- env = SCM_ENV (exp);
- scm_puts ("#<procedure", port);
- }
- if (SCM_ROSTRINGP (name))
- {
- scm_putc (' ', port);
- scm_puts (SCM_ROCHARS (name), port);
- }
- if (code)
- {
- if (SCM_PRINT_SOURCE_P)
- {
- code = scm_unmemocopy (code,
- SCM_EXTEND_ENV (SCM_CAR (code),
- SCM_EOL,
- env));
- ENTER_NESTED_DATA (pstate, exp, circref);
- scm_iprlist (" ", code, '>', port, pstate);
- EXIT_NESTED_DATA (pstate);
- }
- else
- {
- if (SCM_TYP16 (exp) != scm_tc16_macro)
- {
- scm_putc (' ', port);
- scm_iprin1 (SCM_CAR (code), port, pstate);
- }
- scm_putc ('>', port);
- }
- }
- else
+ {
+ SCM formals = SCM_CLOSURE_FORMALS (exp);
+ scm_puts ("#<procedure", port);
+ scm_putc (' ', port);
+ scm_iprin1 (scm_procedure_name (exp), port, pstate);
+ scm_putc (' ', port);
+ if (SCM_PRINT_SOURCE_P)
+ {
+ SCM env = SCM_ENV (exp);
+ SCM xenv = SCM_EXTEND_ENV (formals, SCM_EOL, env);
+ SCM src = scm_unmemocopy (SCM_CODE (exp), xenv);
+ ENTER_NESTED_DATA (pstate, exp, circref);
+ scm_iprin1 (src, port, pstate);
+ EXIT_NESTED_DATA (pstate);
+ }
+ else
+ scm_iprin1 (formals, port, pstate);
scm_putc ('>', port);
- }
+ }
break;
case scm_tc7_substring:
case scm_tc7_string:
scm_sizet i;
scm_putc ('"', port);
- for (i = 0; i < SCM_ROLENGTH (exp); ++i)
- switch (SCM_ROCHARS (exp)[i])
+ for (i = 0; i < SCM_STRING_LENGTH (exp); ++i)
+ switch (SCM_STRING_CHARS (exp)[i])
{
case '"':
case '\\':
scm_putc ('\\', port);
default:
- scm_putc (SCM_ROCHARS (exp)[i], port);
+ scm_putc (SCM_STRING_CHARS (exp)[i], port);
}
scm_putc ('"', port);
break;
}
else
- scm_lfwrite (SCM_ROCHARS (exp), (scm_sizet) SCM_ROLENGTH (exp),
- port);
+ scm_lfwrite (SCM_STRING_CHARS (exp), SCM_STRING_LENGTH (exp), port);
break;
- case scm_tcs_symbols:
+ case scm_tc7_symbol:
{
int pos;
int end;
int maybe_weird;
int mw_pos = 0;
- len = SCM_LENGTH (exp);
- str = SCM_CHARS (exp);
- scm_remember (&exp);
+ len = SCM_SYMBOL_LENGTH (exp);
+ str = SCM_SYMBOL_CHARS (exp);
pos = 0;
weird = 0;
maybe_weird = 0;
}
if (pos < end)
scm_lfwrite (str + pos, end - pos, port);
+ scm_remember_upto_here_1 (exp);
if (weird)
scm_lfwrite ("}#", 2, port);
break;
common_vector_printer:
{
register long i;
- int last = SCM_LENGTH (exp) - 1;
+ int last = SCM_VECTOR_LENGTH (exp) - 1;
int cutp = 0;
- if (pstate->fancyp && SCM_LENGTH (exp) > pstate->length)
+ if (pstate->fancyp && SCM_VECTOR_LENGTH (exp) > pstate->length)
{
last = pstate->length - 1;
cutp = 1;
? "#<primitive-generic "
: "#<primitive-procedure ",
port);
- scm_puts (SCM_CHARS (SCM_SNAME (exp)), port);
+ scm_puts (SCM_SYMBOL_CHARS (SCM_SNAME (exp)), port);
scm_putc ('>', port);
break;
#ifdef CCLO
case scm_tc7_cclo:
{
SCM proc = SCM_CCLO_SUBR (exp);
- if (proc == scm_f_gsubr_apply)
+ if (SCM_EQ_P (proc, scm_f_gsubr_apply))
{
/* Print gsubrs as primitives */
SCM name = scm_procedure_name (exp);
if (SCM_NFALSEP (name))
{
scm_putc (' ', port);
- scm_puts (SCM_CHARS (name), port);
+ scm_puts (SCM_SYMBOL_CHARS (name), port);
}
}
else
if (SCM_NFALSEP (name))
{
scm_putc (' ', port);
- scm_puts (SCM_ROCHARS (name), port);
+ scm_display (name, port);
}
}
scm_putc ('>', port);
break;
- case scm_tc7_contin:
- scm_puts ("#<continuation ", port);
- scm_intprint (SCM_LENGTH (exp), 10, port);
- scm_puts (" @ ", port);
- scm_intprint ((long) SCM_CHARS (exp), 16, port);
- scm_putc ('>', port);
- break;
case scm_tc7_port:
{
register long i = SCM_PTOBNUM (exp);
goto punk;
}
case scm_tc7_smob:
- {
- register long i;
- ENTER_NESTED_DATA (pstate, exp, circref);
- i = SCM_SMOBNUM (exp);
- if (i < scm_numsmob && scm_smobs[i].print
- && (scm_smobs[i].print) (exp, port, pstate))
- {
- EXIT_NESTED_DATA (pstate);
- break;
- }
- EXIT_NESTED_DATA (pstate);
- /* Macros have their print field set to NULL. They are
- handled at the same place as closures in order to achieve
- non-redundancy. Placing the condition here won't slow
- down printing of other smobs. */
- if (SCM_TYP16 (exp) == scm_tc16_macro)
- goto macros;
- }
+ ENTER_NESTED_DATA (pstate, exp, circref);
+ SCM_SMOB_DESCRIPTOR (exp).print (exp, port, pstate);
+ EXIT_NESTED_DATA (pstate);
+ break;
default:
punk:
scm_ipruk ("type", exp, port);
SCM_SETCDR (print_state_pool, SCM_CDDR (print_state_pool));
}
SCM_ALLOW_INTS;
- if (handle == SCM_BOOL_F)
+ if (SCM_FALSEP (handle))
handle = scm_cons (make_print_state (), SCM_EOL);
pstate_scm = SCM_CAR (handle);
}
/* Return print state to pool if it has been created above and
hasn't escaped to Scheme. */
- if (handle != SCM_BOOL_F && !pstate->revealed)
+ if (!SCM_FALSEP (handle) && !pstate->revealed)
{
SCM_DEFER_INTS;
SCM_SETCDR (handle, SCM_CDR (print_state_pool));
if (SCM_CELLP (ptr))
{
scm_puts (" (0x", port);
- scm_intprint (SCM_CAR (ptr), 16, port);
+ scm_intprint (SCM_CELL_WORD_0 (ptr), 16, port);
scm_puts (" . 0x", port);
- scm_intprint (SCM_CDR (ptr), 16, port);
+ scm_intprint (SCM_CELL_WORD_1 (ptr), 16, port);
scm_puts (") @", port);
}
scm_puts (" 0x", port);
- scm_intprint (ptr, 16, port);
+ scm_intprint (SCM_UNPACK (ptr), 16, port);
scm_putc ('>', port);
}
-/* Print a list.
- */
-
+/* Print a list. The list may be either a list of ordinary data, or it may be
+ a list that represents code. Lists that represent code may contain gloc
+ cells.
+ */
void
scm_iprlist (char *hdr,SCM exp,int tlr,SCM port,scm_print_state *pstate)
{
tortoise = exp;
while (SCM_ECONSP (hare))
{
- if (hare == tortoise)
+ if (SCM_EQ_P (hare, tortoise))
goto fancy_printing;
hare = SCM_CDR (hare);
if (SCM_IMP (hare) || SCM_NECONSP (hare))
/* No cdr cycles intrinsic to this list */
scm_iprin1 (SCM_CAR (exp), port, pstate);
- exp = SCM_CDR (exp);
- for (; SCM_NIMP (exp); exp = SCM_CDR (exp))
+ for (exp = SCM_CDR (exp); SCM_ECONSP (exp); exp = SCM_CDR (exp))
{
register int i;
- if (SCM_NECONSP (exp))
- break;
for (i = floor; i >= 0; --i)
- if (pstate->ref_stack[i] == exp)
+ if (SCM_EQ_P (pstate->ref_stack[i], exp))
goto circref;
PUSH_REF (pstate, exp);
scm_putc (' ', port);
/* CHECK_INTS; */
scm_iprin1 (SCM_CAR (exp), port, pstate);
}
- if (SCM_NNULLP (exp))
+ if (!SCM_NULLP (exp))
{
scm_puts (" . ", port);
scm_iprin1 (exp, port, pstate);
scm_iprin1 (SCM_CAR (exp), port, pstate);
exp = SCM_CDR (exp); --n;
- for (; SCM_NIMP (exp); exp = SCM_CDR (exp))
+ for (; SCM_ECONSP (exp); exp = SCM_CDR (exp))
{
register unsigned long i;
- if (SCM_NECONSP (exp))
- break;
for (i = 0; i < pstate->top; ++i)
- if (pstate->ref_stack[i] == exp)
+ if (SCM_EQ_P (pstate->ref_stack[i], exp))
goto fancy_circref;
if (pstate->fancyp)
{
SCM_DEFINE (scm_simple_format, "simple-format", 2, 0, 1,
(SCM destination, SCM message, SCM args),
-"Write MESSAGE to DESTINATION, defaulting to `current-output-port'.
-MESSAGE can contain ~A (was %s) and ~S (was %S) escapes. When printed,
-the escapes are replaced with corresponding members of ARGS:
-~A formats using `display' and ~S formats using `write'.
-If DESTINATION is #t, then use the `current-output-port',
-if DESTINATION is #f, then return a string containing the formatted text.
-Does not add a trailing newline.")
+ "Write @var{message} to @var{destination}, defaulting to\n"
+ "the current output port.\n"
+ "@var{message} can contain @code{~A} (was @code{%s}) and\n"
+ "@code{~S} (was @code{%S}) escapes. When printed,\n"
+ "the escapes are replaced with corresponding members of\n"
+ "@var{ARGS}:\n"
+ "@code{~A} formats using @code{display} and @code{~S} formats\n"
+ "using @code{write}.\n"
+ "If @var{destination} is @code{#t}, then use the current output\n"
+ "port, if @var{destination} is @code{#f}, then return a string\n"
+ "containing the formatted text. Does not add a trailing newline.")
#define FUNC_NAME s_scm_simple_format
{
SCM answer = SCM_UNSPECIFIED;
int fReturnString = 0;
int writingp;
char *start;
+ char *end;
char *p;
- if (SCM_BOOL_T == destination) {
- destination = scm_cur_outp;
- } else if (SCM_BOOL_F == destination) {
- fReturnString = 1;
- destination = scm_mkstrport (SCM_INUM0,
- scm_make_string (SCM_INUM0, SCM_UNDEFINED),
- SCM_OPN | SCM_WRTNG,
- FUNC_NAME);
- } else {
- SCM_VALIDATE_OPORT_VALUE (1,destination);
- }
- SCM_VALIDATE_STRING(2,message);
- SCM_VALIDATE_LIST(3,args);
+ if (SCM_EQ_P (destination, SCM_BOOL_T))
+ {
+ destination = scm_cur_outp;
+ }
+ else if (SCM_FALSEP (destination))
+ {
+ fReturnString = 1;
+ destination = scm_mkstrport (SCM_INUM0,
+ scm_make_string (SCM_INUM0, SCM_UNDEFINED),
+ SCM_OPN | SCM_WRTNG,
+ FUNC_NAME);
+ }
+ else
+ {
+ SCM_VALIDATE_OPORT_VALUE (1, destination);
+ destination = SCM_COERCE_OUTPORT (destination);
+ }
+ SCM_VALIDATE_STRING (2, message);
+ SCM_VALIDATE_REST_ARGUMENT (args);
- SCM_COERCE_SUBSTR (message);
- start = SCM_ROCHARS (message);
- for (p = start; *p != '\0'; ++p)
+ start = SCM_STRING_CHARS (message);
+ end = start + SCM_STRING_LENGTH (message);
+ for (p = start; p != end; ++p)
if (*p == '~')
{
- if (SCM_IMP (args) || SCM_NCONSP (args))
+ if (!SCM_CONSP (args))
+ continue;
+
+ if (++p == end)
continue;
- ++p;
- if (*p == 'A')
+ if (*p == 'A' || *p == 'a')
writingp = 0;
- else if (*p == 'S')
+ else if (*p == 'S' || *p == 's')
writingp = 1;
else
continue;
if (fReturnString)
answer = scm_strport_to_string (destination);
- return answer;
+ return scm_return_first (answer, message);
}
#undef FUNC_NAME
SCM_DEFINE (scm_newline, "newline", 0, 1, 0,
- (SCM port),
-"")
+ (SCM port),
+ "Send a newline to @var{port}.")
#define FUNC_NAME s_scm_newline
{
if (SCM_UNBNDP (port))
#undef FUNC_NAME
SCM_DEFINE (scm_write_char, "write-char", 1, 1, 0,
- (SCM chr, SCM port),
-"")
+ (SCM chr, SCM port),
+ "Send character @var{chr} to @var{port}.")
#define FUNC_NAME s_scm_write_char
{
if (SCM_UNBNDP (port))
port = scm_cur_outp;
- SCM_VALIDATE_ICHR (1,chr);
+ SCM_VALIDATE_CHAR (1,chr);
SCM_VALIDATE_OPORT_VALUE (2,port);
- scm_putc ((int) SCM_ICHR (chr), SCM_COERCE_OUTPORT (port));
+ scm_putc ((int) SCM_CHAR (chr), SCM_COERCE_OUTPORT (port));
#ifdef HAVE_PIPE
# ifdef EPIPE
if (EPIPE == errno)
* escaped to Scheme and thus has to be freed by the GC.
*/
-long scm_tc16_port_with_ps;
+scm_bits_t scm_tc16_port_with_ps;
/* Print exactly as the port itself would */
static int
-print_port_with_ps (SCM obj, SCM port, scm_print_state *pstate)
+port_with_ps_print (SCM obj, SCM port, scm_print_state *pstate)
{
obj = SCM_PORT_WITH_PS_PORT (obj);
return scm_ptobs[SCM_PTOBNUM (obj)].print (obj, port, pstate);
{
SCM pwps;
SCM pair = scm_cons (port, pstate->handle);
- SCM_NEWSMOB (pwps, scm_tc16_port_with_ps, pair);
+ SCM_NEWSMOB (pwps, scm_tc16_port_with_ps, SCM_UNPACK (pair));
pstate->revealed = 1;
return scm_apply (proc, exp, scm_cons (pwps, scm_listofnull));
}
SCM_DEFINE (scm_port_with_print_state, "port-with-print-state", 2, 0, 0,
(SCM port, SCM pstate),
-"")
+ "Create a new port which behaves like @var{port}, but with an\n"
+ "included print state @var{pstate}.")
#define FUNC_NAME s_scm_port_with_print_state
{
SCM pwps;
SCM_VALIDATE_OPORT_VALUE (1,port);
SCM_VALIDATE_PRINTSTATE (2,pstate);
port = SCM_COERCE_OUTPORT (port);
- SCM_NEWSMOB (pwps, scm_tc16_port_with_ps, scm_cons (port, pstate));
+ SCM_NEWSMOB (pwps, scm_tc16_port_with_ps, SCM_UNPACK (scm_cons (port, pstate)));
return pwps;
}
#undef FUNC_NAME
SCM_DEFINE (scm_get_print_state, "get-print-state", 1, 0, 0,
(SCM port),
-"")
+ "Return the print state of the port @var{port}. If @var{port}\n"
+ "has no associated print state, @code{#f} is returned.")
#define FUNC_NAME s_scm_get_print_state
{
if (SCM_PORT_WITH_PS_P (port))
return SCM_PORT_WITH_PS_PS (port);
- if (SCM_OUTPORTP (port))
+ if (SCM_OUTPUT_PORT_P (port))
return SCM_BOOL_F;
- RETURN_SCM_WTA (1,port);
+ SCM_WRONG_TYPE_ARG (1, port);
}
#undef FUNC_NAME
SCM vtable, layout, type;
scm_init_opts (scm_print_options, scm_print_opts, SCM_N_PRINT_OPTIONS);
- vtable = scm_make_vtable_vtable (scm_make_struct_layout (scm_nullstr),
- SCM_INUM0,
- SCM_EOL);
+ vtable = scm_make_vtable_vtable (scm_nullstr, SCM_INUM0, SCM_EOL);
layout = scm_make_struct_layout (scm_makfrom0str (SCM_PRINT_STATE_LAYOUT));
type = scm_make_struct (vtable, SCM_INUM0, SCM_LIST1 (layout));
- scm_set_struct_vtable_name_x (type, SCM_CAR (scm_intern0 ("print-state")));
+ scm_set_struct_vtable_name_x (type, scm_str2symbol ("print-state"));
print_state_pool = scm_permanent_object (scm_cons (type, SCM_EOL));
scm_print_state_vtable = type;
/* Don't want to bind a wrapper class in GOOPS, so pass 0 as arg1. */
scm_tc16_port_with_ps = scm_make_smob_type (0, 0);
scm_set_smob_mark (scm_tc16_port_with_ps, scm_markcdr);
- scm_set_smob_print (scm_tc16_port_with_ps, print_port_with_ps);
+ scm_set_smob_print (scm_tc16_port_with_ps, port_with_ps_print);
-#include "print.x"
+#ifndef SCM_MAGIC_SNARFER
+#include "libguile/print.x"
+#endif
}
+
+/*
+ Local Variables:
+ c-file-style: "gnu"
+ End:
+*/
HCoop / bpt / guile.git / blobdiff