1 /* Copyright (C) 1995,1996,1997,1998,1999,2000,2001, 2003, 2004 Free Software Foundation, Inc.
3 * This library is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU Lesser General Public
5 * License as published by the Free Software Foundation; either
6 * version 2.1 of the License, or (at your option) any later version.
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * Lesser General Public License for more details.
13 * You should have received a copy of the GNU Lesser General Public
14 * License along with this library; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29 #include "libguile/_scm.h"
30 #include "libguile/async.h"
31 #include "libguile/eval.h"
32 #include "libguile/objects.h"
33 #include "libguile/goops.h"
34 #include "libguile/smob.h"
35 #include "libguile/chars.h"
36 #include "libguile/dynwind.h"
38 #include "libguile/keywords.h"
39 #include "libguile/root.h"
40 #include "libguile/strings.h"
41 #include "libguile/mallocs.h"
42 #include "libguile/validate.h"
43 #include "libguile/ports.h"
44 #include "libguile/vectors.h"
45 #include "libguile/fluids.h"
63 #ifdef HAVE_SYS_IOCTL_H
64 #include <sys/ioctl.h>
69 #define ftruncate(fd, size) chsize (fd, size)
73 /* The port kind table --- a dynamically resized array of port types. */
76 /* scm_ptobs scm_numptob
77 * implement a dynamicly resized array of ptob records.
78 * Indexes into this table are used when generating type
79 * tags for smobjects (if you know a tag you can get an index and conversely).
81 scm_t_ptob_descriptor
*scm_ptobs
;
84 /* GC marker for a port with stream of SCM type. */
86 scm_markstream (SCM ptr
)
89 openp
= SCM_CELL_WORD_0 (ptr
) & SCM_OPN
;
91 return SCM_PACK (SCM_STREAM (ptr
));
97 * We choose to use an interface similar to the smob interface with
98 * fill_input and write as standard fields, passed to the port
99 * type constructor, and optional fields set by setters.
103 flush_port_default (SCM port SCM_UNUSED
)
108 end_input_default (SCM port SCM_UNUSED
, int offset SCM_UNUSED
)
113 scm_port_free0 (SCM port
)
119 scm_make_port_type (char *name
,
120 int (*fill_input
) (SCM port
),
121 void (*write
) (SCM port
, const void *data
, size_t size
))
124 if (255 <= scm_numptob
)
126 SCM_CRITICAL_SECTION_START
;
127 SCM_SYSCALL (tmp
= (char *) realloc ((char *) scm_ptobs
,
129 * sizeof (scm_t_ptob_descriptor
)));
132 scm_ptobs
= (scm_t_ptob_descriptor
*) tmp
;
134 scm_ptobs
[scm_numptob
].name
= name
;
135 scm_ptobs
[scm_numptob
].mark
= 0;
136 scm_ptobs
[scm_numptob
].free
= scm_port_free0
;
137 scm_ptobs
[scm_numptob
].print
= scm_port_print
;
138 scm_ptobs
[scm_numptob
].equalp
= 0;
139 scm_ptobs
[scm_numptob
].close
= 0;
141 scm_ptobs
[scm_numptob
].write
= write
;
142 scm_ptobs
[scm_numptob
].flush
= flush_port_default
;
144 scm_ptobs
[scm_numptob
].end_input
= end_input_default
;
145 scm_ptobs
[scm_numptob
].fill_input
= fill_input
;
146 scm_ptobs
[scm_numptob
].input_waiting
= 0;
148 scm_ptobs
[scm_numptob
].seek
= 0;
149 scm_ptobs
[scm_numptob
].truncate
= 0;
153 SCM_CRITICAL_SECTION_END
;
157 scm_memory_error ("scm_make_port_type");
159 /* Make a class object if Goops is present */
161 scm_make_port_classes (scm_numptob
- 1, SCM_PTOBNAME (scm_numptob
- 1));
162 return scm_tc7_port
+ (scm_numptob
- 1) * 256;
166 scm_set_port_mark (long tc
, SCM (*mark
) (SCM
))
168 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].mark
= mark
;
172 scm_set_port_free (long tc
, size_t (*free
) (SCM
))
174 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].free
= free
;
178 scm_set_port_print (long tc
, int (*print
) (SCM exp
, SCM port
,
179 scm_print_state
*pstate
))
181 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].print
= print
;
185 scm_set_port_equalp (long tc
, SCM (*equalp
) (SCM
, SCM
))
187 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].equalp
= equalp
;
191 scm_set_port_flush (long tc
, void (*flush
) (SCM port
))
193 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].flush
= flush
;
197 scm_set_port_end_input (long tc
, void (*end_input
) (SCM port
, int offset
))
199 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].end_input
= end_input
;
203 scm_set_port_close (long tc
, int (*close
) (SCM
))
205 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].close
= close
;
209 scm_set_port_seek (long tc
, off_t (*seek
) (SCM port
,
213 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].seek
= seek
;
217 scm_set_port_truncate (long tc
, void (*truncate
) (SCM port
, off_t length
))
219 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].truncate
= truncate
;
223 scm_set_port_input_waiting (long tc
, int (*input_waiting
) (SCM
))
225 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].input_waiting
= input_waiting
;
230 SCM_DEFINE (scm_char_ready_p
, "char-ready?", 0, 1, 0,
232 "Return @code{#t} if a character is ready on input @var{port}\n"
233 "and return @code{#f} otherwise. If @code{char-ready?} returns\n"
234 "@code{#t} then the next @code{read-char} operation on\n"
235 "@var{port} is guaranteed not to hang. If @var{port} is a file\n"
236 "port at end of file then @code{char-ready?} returns @code{#t}.\n"
238 "@code{char-ready?} exists to make it possible for a\n"
239 "program to accept characters from interactive ports without\n"
240 "getting stuck waiting for input. Any input editors associated\n"
241 "with such ports must make sure that characters whose existence\n"
242 "has been asserted by @code{char-ready?} cannot be rubbed out.\n"
243 "If @code{char-ready?} were to return @code{#f} at end of file,\n"
244 "a port at end of file would be indistinguishable from an\n"
245 "interactive port that has no ready characters.")
246 #define FUNC_NAME s_scm_char_ready_p
250 if (SCM_UNBNDP (port
))
251 port
= scm_current_input_port ();
253 SCM_VALIDATE_OPINPORT (1, port
);
255 pt
= SCM_PTAB_ENTRY (port
);
257 /* if the current read buffer is filled, or the
258 last pushed-back char has been read and the saved buffer is
259 filled, result is true. */
260 if (pt
->read_pos
< pt
->read_end
261 || (pt
->read_buf
== pt
->putback_buf
262 && pt
->saved_read_pos
< pt
->saved_read_end
))
266 scm_t_ptob_descriptor
*ptob
= &scm_ptobs
[SCM_PTOBNUM (port
)];
268 if (ptob
->input_waiting
)
269 return scm_from_bool(ptob
->input_waiting (port
));
276 /* move up to read_len chars from port's putback and/or read buffers
277 into memory starting at dest. returns the number of chars moved. */
278 size_t scm_take_from_input_buffers (SCM port
, char *dest
, size_t read_len
)
280 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
281 size_t chars_read
= 0;
282 size_t from_buf
= min (pt
->read_end
- pt
->read_pos
, read_len
);
286 memcpy (dest
, pt
->read_pos
, from_buf
);
287 pt
->read_pos
+= from_buf
;
288 chars_read
+= from_buf
;
289 read_len
-= from_buf
;
293 /* if putback was active, try the real input buffer too. */
294 if (pt
->read_buf
== pt
->putback_buf
)
296 from_buf
= min (pt
->saved_read_end
- pt
->saved_read_pos
, read_len
);
299 memcpy (dest
, pt
->saved_read_pos
, from_buf
);
300 pt
->saved_read_pos
+= from_buf
;
301 chars_read
+= from_buf
;
307 /* Clear a port's read buffers, returning the contents. */
308 SCM_DEFINE (scm_drain_input
, "drain-input", 1, 0, 0,
310 "This procedure clears a port's input buffers, similar\n"
311 "to the way that force-output clears the output buffer. The\n"
312 "contents of the buffers are returned as a single string, e.g.,\n"
315 "(define p (open-input-file ...))\n"
316 "(drain-input p) => empty string, nothing buffered yet.\n"
317 "(unread-char (read-char p) p)\n"
318 "(drain-input p) => initial chars from p, up to the buffer size.\n"
320 "Draining the buffers may be useful for cleanly finishing\n"
321 "buffered I/O so that the file descriptor can be used directly\n"
322 "for further input.")
323 #define FUNC_NAME s_scm_drain_input
330 SCM_VALIDATE_OPINPORT (1, port
);
331 pt
= SCM_PTAB_ENTRY (port
);
333 count
= pt
->read_end
- pt
->read_pos
;
334 if (pt
->read_buf
== pt
->putback_buf
)
335 count
+= pt
->saved_read_end
- pt
->saved_read_pos
;
337 result
= scm_i_make_string (count
, &data
);
338 scm_take_from_input_buffers (port
, data
, count
);
344 /* Standard ports --- current input, output, error, and more(!). */
346 static SCM cur_inport_fluid
;
347 static SCM cur_outport_fluid
;
348 static SCM cur_errport_fluid
;
349 static SCM cur_loadport_fluid
;
351 SCM_DEFINE (scm_current_input_port
, "current-input-port", 0, 0, 0,
353 "Return the current input port. This is the default port used\n"
354 "by many input procedures. Initially, @code{current-input-port}\n"
355 "returns the @dfn{standard input} in Unix and C terminology.")
356 #define FUNC_NAME s_scm_current_input_port
358 return scm_fluid_ref (cur_inport_fluid
);
362 SCM_DEFINE (scm_current_output_port
, "current-output-port", 0, 0, 0,
364 "Return the current output port. This is the default port used\n"
365 "by many output procedures. Initially,\n"
366 "@code{current-output-port} returns the @dfn{standard output} in\n"
367 "Unix and C terminology.")
368 #define FUNC_NAME s_scm_current_output_port
370 return scm_fluid_ref (cur_outport_fluid
);
374 SCM_DEFINE (scm_current_error_port
, "current-error-port", 0, 0, 0,
376 "Return the port to which errors and warnings should be sent (the\n"
377 "@dfn{standard error} in Unix and C terminology).")
378 #define FUNC_NAME s_scm_current_error_port
380 return scm_fluid_ref (cur_errport_fluid
);
384 SCM_DEFINE (scm_current_load_port
, "current-load-port", 0, 0, 0,
386 "Return the current-load-port.\n"
387 "The load port is used internally by @code{primitive-load}.")
388 #define FUNC_NAME s_scm_current_load_port
390 return scm_fluid_ref (cur_loadport_fluid
);
394 SCM_DEFINE (scm_set_current_input_port
, "set-current-input-port", 1, 0, 0,
396 "@deffnx {Scheme Procedure} set-current-output-port port\n"
397 "@deffnx {Scheme Procedure} set-current-error-port port\n"
398 "Change the ports returned by @code{current-input-port},\n"
399 "@code{current-output-port} and @code{current-error-port}, respectively,\n"
400 "so that they use the supplied @var{port} for input or output.")
401 #define FUNC_NAME s_scm_set_current_input_port
403 SCM oinp
= scm_fluid_ref (cur_inport_fluid
);
404 SCM_VALIDATE_OPINPORT (1, port
);
405 scm_fluid_set_x (cur_inport_fluid
, port
);
411 SCM_DEFINE (scm_set_current_output_port
, "set-current-output-port", 1, 0, 0,
413 "Set the current default output port to @var{port}.")
414 #define FUNC_NAME s_scm_set_current_output_port
416 SCM ooutp
= scm_fluid_ref (cur_outport_fluid
);
417 port
= SCM_COERCE_OUTPORT (port
);
418 SCM_VALIDATE_OPOUTPORT (1, port
);
419 scm_fluid_set_x (cur_outport_fluid
, port
);
425 SCM_DEFINE (scm_set_current_error_port
, "set-current-error-port", 1, 0, 0,
427 "Set the current default error port to @var{port}.")
428 #define FUNC_NAME s_scm_set_current_error_port
430 SCM oerrp
= scm_fluid_ref (cur_errport_fluid
);
431 port
= SCM_COERCE_OUTPORT (port
);
432 SCM_VALIDATE_OPOUTPORT (1, port
);
433 scm_fluid_set_x (cur_errport_fluid
, port
);
439 scm_dynwind_current_input_port (SCM port
)
440 #define FUNC_NAME NULL
442 SCM_VALIDATE_OPINPORT (1, port
);
443 scm_dynwind_fluid (cur_inport_fluid
, port
);
448 scm_dynwind_current_output_port (SCM port
)
449 #define FUNC_NAME NULL
451 port
= SCM_COERCE_OUTPORT (port
);
452 SCM_VALIDATE_OPOUTPORT (1, port
);
453 scm_dynwind_fluid (cur_outport_fluid
, port
);
458 scm_dynwind_current_error_port (SCM port
)
459 #define FUNC_NAME NULL
461 port
= SCM_COERCE_OUTPORT (port
);
462 SCM_VALIDATE_OPOUTPORT (1, port
);
463 scm_dynwind_fluid (cur_errport_fluid
, port
);
468 scm_i_dynwind_current_load_port (SCM port
)
470 scm_dynwind_fluid (cur_loadport_fluid
, port
);
474 /* The port table --- an array of pointers to ports. */
476 scm_t_port
**scm_i_port_table
;
478 long scm_i_port_table_size
= 0; /* Number of ports in scm_i_port_table. */
479 long scm_i_port_table_room
= 20; /* Size of the array. */
481 scm_i_pthread_mutex_t scm_i_port_table_mutex
= SCM_I_PTHREAD_MUTEX_INITIALIZER
;
483 /* This function is not and should not be thread safe. */
486 scm_new_port_table_entry (scm_t_bits tag
)
487 #define FUNC_NAME "scm_new_port_table_entry"
490 We initialize the cell to empty, this is in case scm_gc_calloc
491 triggers GC ; we don't want the GC to scan a half-finished Z.
494 SCM z
= scm_cons (SCM_EOL
, SCM_EOL
);
495 scm_t_port
*entry
= (scm_t_port
*) scm_gc_calloc (sizeof (scm_t_port
), "port");
496 if (scm_i_port_table_size
== scm_i_port_table_room
)
498 /* initial malloc is in gc.c. this doesn't use scm_gc_malloc etc.,
499 since it can never be freed during gc. */
500 void *newt
= scm_realloc ((char *) scm_i_port_table
,
501 (size_t) (sizeof (scm_t_port
*)
502 * scm_i_port_table_room
* 2));
503 scm_i_port_table
= (scm_t_port
**) newt
;
504 scm_i_port_table_room
*= 2;
507 entry
->entry
= scm_i_port_table_size
;
509 entry
->file_name
= SCM_BOOL_F
;
510 entry
->rw_active
= SCM_PORT_NEITHER
;
512 scm_i_port_table
[scm_i_port_table_size
] = entry
;
513 scm_i_port_table_size
++;
516 SCM_SET_CELL_TYPE(z
, tag
);
517 SCM_SETPTAB_ENTRY(z
, entry
);
523 #if SCM_ENABLE_DEPRECATED==1
525 scm_add_to_port_table (SCM port
)
527 SCM z
= scm_new_port_table_entry (scm_tc7_port
);
528 scm_t_port
* pt
= SCM_PTAB_ENTRY(z
);
531 SCM_SETCAR(z
, SCM_EOL
);
532 SCM_SETCDR(z
, SCM_EOL
);
533 SCM_SETPTAB_ENTRY (port
, pt
);
539 /* Remove a port from the table and destroy it. */
541 /* This function is not and should not be thread safe. */
544 scm_remove_from_port_table (SCM port
)
545 #define FUNC_NAME "scm_remove_from_port_table"
547 scm_t_port
*p
= SCM_PTAB_ENTRY (port
);
550 if (i
>= scm_i_port_table_size
)
551 SCM_MISC_ERROR ("Port not in table: ~S", scm_list_1 (port
));
553 scm_gc_free (p
->putback_buf
, p
->putback_buf_size
, "putback buffer");
554 scm_gc_free (p
, sizeof (scm_t_port
), "port");
555 /* Since we have just freed slot i we can shrink the table by moving
556 the last entry to that slot... */
557 if (i
< scm_i_port_table_size
- 1)
559 scm_i_port_table
[i
] = scm_i_port_table
[scm_i_port_table_size
- 1];
560 scm_i_port_table
[i
]->entry
= i
;
562 SCM_SETPTAB_ENTRY (port
, 0);
563 scm_i_port_table_size
--;
569 /* Functions for debugging. */
571 SCM_DEFINE (scm_pt_size
, "pt-size", 0, 0, 0,
573 "Return the number of ports in the port table. @code{pt-size}\n"
574 "is only included in @code{--enable-guile-debug} builds.")
575 #define FUNC_NAME s_scm_pt_size
577 return scm_from_int (scm_i_port_table_size
);
581 SCM_DEFINE (scm_pt_member
, "pt-member", 1, 0, 0,
583 "Return the port at @var{index} in the port table.\n"
584 "@code{pt-member} is only included in\n"
585 "@code{--enable-guile-debug} builds.")
586 #define FUNC_NAME s_scm_pt_member
588 size_t i
= scm_to_size_t (index
);
589 if (i
>= scm_i_port_table_size
)
592 return scm_i_port_table
[i
]->port
;
598 scm_port_non_buffer (scm_t_port
*pt
)
600 pt
->read_pos
= pt
->read_buf
= pt
->read_end
= &pt
->shortbuf
;
601 pt
->write_buf
= pt
->write_pos
= &pt
->shortbuf
;
602 pt
->read_buf_size
= pt
->write_buf_size
= 1;
603 pt
->write_end
= pt
->write_buf
+ pt
->write_buf_size
;
607 /* Revealed counts --- an oddity inherited from SCSH. */
609 /* Find a port in the table and return its revealed count.
610 Also used by the garbage collector.
614 scm_revealed_count (SCM port
)
616 return SCM_REVEALED(port
);
621 /* Return the revealed count for a port. */
623 SCM_DEFINE (scm_port_revealed
, "port-revealed", 1, 0, 0,
625 "Return the revealed count for @var{port}.")
626 #define FUNC_NAME s_scm_port_revealed
628 port
= SCM_COERCE_OUTPORT (port
);
629 SCM_VALIDATE_OPENPORT (1, port
);
630 return scm_from_int (scm_revealed_count (port
));
634 /* Set the revealed count for a port. */
635 SCM_DEFINE (scm_set_port_revealed_x
, "set-port-revealed!", 2, 0, 0,
636 (SCM port
, SCM rcount
),
637 "Sets the revealed count for a port to a given value.\n"
638 "The return value is unspecified.")
639 #define FUNC_NAME s_scm_set_port_revealed_x
641 port
= SCM_COERCE_OUTPORT (port
);
642 SCM_VALIDATE_OPENPORT (1, port
);
643 SCM_REVEALED (port
) = scm_to_int (rcount
);
644 return SCM_UNSPECIFIED
;
650 /* Retrieving a port's mode. */
652 /* Return the flags that characterize a port based on the mode
653 * string used to open a file for that port.
655 * See PORT FLAGS in scm.h
659 scm_i_mode_bits_n (const char *modes
, size_t n
)
662 | (memchr (modes
, 'r', n
) || memchr (modes
, '+', n
) ? SCM_RDNG
: 0)
663 | ( memchr (modes
, 'w', n
)
664 || memchr (modes
, 'a', n
)
665 || memchr (modes
, '+', n
) ? SCM_WRTNG
: 0)
666 | (memchr (modes
, '0', n
) ? SCM_BUF0
: 0)
667 | (memchr (modes
, 'l', n
) ? SCM_BUFLINE
: 0));
671 scm_mode_bits (char *modes
)
673 return scm_i_mode_bits_n (modes
, strlen (modes
));
677 scm_i_mode_bits (SCM modes
)
681 if (!scm_is_string (modes
))
682 scm_wrong_type_arg_msg (NULL
, 0, modes
, "string");
684 bits
= scm_i_mode_bits_n (scm_i_string_chars (modes
),
685 scm_i_string_length (modes
));
686 scm_remember_upto_here_1 (modes
);
690 /* Return the mode flags from an open port.
691 * Some modes such as "append" are only used when opening
692 * a file and are not returned here. */
694 SCM_DEFINE (scm_port_mode
, "port-mode", 1, 0, 0,
696 "Return the port modes associated with the open port @var{port}.\n"
697 "These will not necessarily be identical to the modes used when\n"
698 "the port was opened, since modes such as \"append\" which are\n"
699 "used only during port creation are not retained.")
700 #define FUNC_NAME s_scm_port_mode
705 port
= SCM_COERCE_OUTPORT (port
);
706 SCM_VALIDATE_OPPORT (1, port
);
707 if (SCM_CELL_WORD_0 (port
) & SCM_RDNG
) {
708 if (SCM_CELL_WORD_0 (port
) & SCM_WRTNG
)
709 strcpy (modes
, "r+");
713 else if (SCM_CELL_WORD_0 (port
) & SCM_WRTNG
)
715 if (SCM_CELL_WORD_0 (port
) & SCM_BUF0
)
717 return scm_from_locale_string (modes
);
726 * Call the close operation on a port object.
727 * see also scm_close.
729 SCM_DEFINE (scm_close_port
, "close-port", 1, 0, 0,
731 "Close the specified port object. Return @code{#t} if it\n"
732 "successfully closes a port or @code{#f} if it was already\n"
733 "closed. An exception may be raised if an error occurs, for\n"
734 "example when flushing buffered output. See also @ref{Ports and\n"
735 "File Descriptors, close}, for a procedure which can close file\n"
737 #define FUNC_NAME s_scm_close_port
742 port
= SCM_COERCE_OUTPORT (port
);
744 SCM_VALIDATE_PORT (1, port
);
745 if (SCM_CLOSEDP (port
))
747 i
= SCM_PTOBNUM (port
);
748 if (scm_ptobs
[i
].close
)
749 rv
= (scm_ptobs
[i
].close
) (port
);
752 scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex
);
753 scm_remove_from_port_table (port
);
754 scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex
);
755 SCM_CLR_PORT_OPEN_FLAG (port
);
756 return scm_from_bool (rv
>= 0);
760 SCM_DEFINE (scm_close_input_port
, "close-input-port", 1, 0, 0,
762 "Close the specified input port object. The routine has no effect if\n"
763 "the file has already been closed. An exception may be raised if an\n"
764 "error occurs. The value returned is unspecified.\n\n"
765 "See also @ref{Ports and File Descriptors, close}, for a procedure\n"
766 "which can close file descriptors.")
767 #define FUNC_NAME s_scm_close_input_port
769 SCM_VALIDATE_INPUT_PORT (1, port
);
770 scm_close_port (port
);
771 return SCM_UNSPECIFIED
;
775 SCM_DEFINE (scm_close_output_port
, "close-output-port", 1, 0, 0,
777 "Close the specified output port object. The routine has no effect if\n"
778 "the file has already been closed. An exception may be raised if an\n"
779 "error occurs. The value returned is unspecified.\n\n"
780 "See also @ref{Ports and File Descriptors, close}, for a procedure\n"
781 "which can close file descriptors.")
782 #define FUNC_NAME s_scm_close_output_port
784 port
= SCM_COERCE_OUTPORT (port
);
785 SCM_VALIDATE_OUTPUT_PORT (1, port
);
786 scm_close_port (port
);
787 return SCM_UNSPECIFIED
;
792 scm_c_port_for_each (void (*proc
)(void *data
, SCM p
), void *data
)
798 /* Even without pre-emptive multithreading, running arbitrary code
799 while scanning the port table is unsafe because the port table
800 can change arbitrarily (from a GC, for example). So we first
801 collect the ports into a vector. -mvo */
803 scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex
);
804 n
= scm_i_port_table_size
;
805 scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex
);
807 ports
= scm_c_make_vector (n
, SCM_BOOL_F
);
809 scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex
);
810 if (n
> scm_i_port_table_size
)
811 n
= scm_i_port_table_size
;
812 for (i
= 0; i
< n
; i
++)
813 SCM_SIMPLE_VECTOR_SET (ports
, i
, scm_i_port_table
[i
]->port
);
814 scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex
);
816 for (i
= 0; i
< n
; i
++)
817 proc (data
, SCM_SIMPLE_VECTOR_REF (ports
, i
));
820 SCM_DEFINE (scm_port_for_each
, "port-for-each", 1, 0, 0,
822 "Apply @var{proc} to each port in the Guile port table\n"
823 "in turn. The return value is unspecified. More specifically,\n"
824 "@var{proc} is applied exactly once to every port that exists\n"
825 "in the system at the time @var{port-for-each} is invoked.\n"
826 "Changes to the port table while @var{port-for-each} is running\n"
827 "have no effect as far as @var{port-for-each} is concerned.")
828 #define FUNC_NAME s_scm_port_for_each
830 SCM_VALIDATE_PROC (1, proc
);
832 scm_c_port_for_each ((void (*)(void*,SCM
))scm_call_1
, proc
);
833 return SCM_UNSPECIFIED
;
839 /* Utter miscellany. Gosh, we should clean this up some time. */
841 SCM_DEFINE (scm_input_port_p
, "input-port?", 1, 0, 0,
843 "Return @code{#t} if @var{x} is an input port, otherwise return\n"
844 "@code{#f}. Any object satisfying this predicate also satisfies\n"
846 #define FUNC_NAME s_scm_input_port_p
848 return scm_from_bool (SCM_INPUT_PORT_P (x
));
852 SCM_DEFINE (scm_output_port_p
, "output-port?", 1, 0, 0,
854 "Return @code{#t} if @var{x} is an output port, otherwise return\n"
855 "@code{#f}. Any object satisfying this predicate also satisfies\n"
857 #define FUNC_NAME s_scm_output_port_p
859 x
= SCM_COERCE_OUTPORT (x
);
860 return scm_from_bool (SCM_OUTPUT_PORT_P (x
));
864 SCM_DEFINE (scm_port_p
, "port?", 1, 0, 0,
866 "Return a boolean indicating whether @var{x} is a port.\n"
867 "Equivalent to @code{(or (input-port? @var{x}) (output-port?\n"
869 #define FUNC_NAME s_scm_port_p
871 return scm_from_bool (SCM_PORTP (x
));
875 SCM_DEFINE (scm_port_closed_p
, "port-closed?", 1, 0, 0,
877 "Return @code{#t} if @var{port} is closed or @code{#f} if it is\n"
879 #define FUNC_NAME s_scm_port_closed_p
881 SCM_VALIDATE_PORT (1, port
);
882 return scm_from_bool (!SCM_OPPORTP (port
));
886 SCM_DEFINE (scm_eof_object_p
, "eof-object?", 1, 0, 0,
888 "Return @code{#t} if @var{x} is an end-of-file object; otherwise\n"
890 #define FUNC_NAME s_scm_eof_object_p
892 return scm_from_bool(SCM_EOF_OBJECT_P (x
));
896 SCM_DEFINE (scm_force_output
, "force-output", 0, 1, 0,
898 "Flush the specified output port, or the current output port if @var{port}\n"
899 "is omitted. The current output buffer contents are passed to the\n"
900 "underlying port implementation (e.g., in the case of fports, the\n"
901 "data will be written to the file and the output buffer will be cleared.)\n"
902 "It has no effect on an unbuffered port.\n\n"
903 "The return value is unspecified.")
904 #define FUNC_NAME s_scm_force_output
906 if (SCM_UNBNDP (port
))
907 port
= scm_current_output_port ();
910 port
= SCM_COERCE_OUTPORT (port
);
911 SCM_VALIDATE_OPOUTPORT (1, port
);
914 return SCM_UNSPECIFIED
;
918 SCM_DEFINE (scm_flush_all_ports
, "flush-all-ports", 0, 0, 0,
920 "Equivalent to calling @code{force-output} on\n"
921 "all open output ports. The return value is unspecified.")
922 #define FUNC_NAME s_scm_flush_all_ports
926 scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex
);
927 for (i
= 0; i
< scm_i_port_table_size
; i
++)
929 if (SCM_OPOUTPORTP (scm_i_port_table
[i
]->port
))
930 scm_flush (scm_i_port_table
[i
]->port
);
932 scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex
);
933 return SCM_UNSPECIFIED
;
937 SCM_DEFINE (scm_read_char
, "read-char", 0, 1, 0,
939 "Return the next character available from @var{port}, updating\n"
940 "@var{port} to point to the following character. If no more\n"
941 "characters are available, the end-of-file object is returned.")
942 #define FUNC_NAME s_scm_read_char
945 if (SCM_UNBNDP (port
))
946 port
= scm_current_input_port ();
947 SCM_VALIDATE_OPINPORT (1, port
);
951 return SCM_MAKE_CHAR (c
);
955 /* this should only be called when the read buffer is empty. it
956 tries to refill the read buffer. it returns the first char from
957 the port, which is either EOF or *(pt->read_pos). */
959 scm_fill_input (SCM port
)
961 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
963 if (pt
->read_buf
== pt
->putback_buf
)
965 /* finished reading put-back chars. */
966 pt
->read_buf
= pt
->saved_read_buf
;
967 pt
->read_pos
= pt
->saved_read_pos
;
968 pt
->read_end
= pt
->saved_read_end
;
969 pt
->read_buf_size
= pt
->saved_read_buf_size
;
970 if (pt
->read_pos
< pt
->read_end
)
971 return *(pt
->read_pos
);
973 return scm_ptobs
[SCM_PTOBNUM (port
)].fill_input (port
);
980 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
982 if (pt
->rw_active
== SCM_PORT_WRITE
)
983 /* may be marginally faster than calling scm_flush. */
984 scm_ptobs
[SCM_PTOBNUM (port
)].flush (port
);
987 pt
->rw_active
= SCM_PORT_READ
;
989 if (pt
->read_pos
>= pt
->read_end
)
991 if (scm_fill_input (port
) == EOF
)
995 c
= *(pt
->read_pos
++);
1022 scm_putc (char c
, SCM port
)
1024 SCM_ASSERT_TYPE (SCM_OPOUTPORTP (port
), port
, 0, NULL
, "output port");
1025 scm_lfwrite (&c
, 1, port
);
1029 scm_puts (const char *s
, SCM port
)
1031 SCM_ASSERT_TYPE (SCM_OPOUTPORTP (port
), port
, 0, NULL
, "output port");
1032 scm_lfwrite (s
, strlen (s
), port
);
1037 * This function differs from scm_c_write; it updates port line and
1041 scm_lfwrite (const char *ptr
, size_t size
, SCM port
)
1043 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
1044 scm_t_ptob_descriptor
*ptob
= &scm_ptobs
[SCM_PTOBNUM (port
)];
1046 if (pt
->rw_active
== SCM_PORT_READ
)
1047 scm_end_input (port
);
1049 ptob
->write (port
, ptr
, size
);
1051 for (; size
; ptr
++, size
--) {
1054 else if (*ptr
== '\b') {
1057 else if (*ptr
== '\n') {
1060 else if (*ptr
== '\r') {
1063 else if (*ptr
== '\t') {
1072 pt
->rw_active
= SCM_PORT_WRITE
;
1077 * Used by an application to read arbitrary number of bytes from an
1078 * SCM port. Same semantics as libc read, except that scm_c_read only
1079 * returns less than SIZE bytes if at end-of-file.
1081 * Warning: Doesn't update port line and column counts! */
1084 scm_c_read (SCM port
, void *buffer
, size_t size
)
1086 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
1087 size_t n_read
= 0, n_available
;
1089 if (pt
->rw_active
== SCM_PORT_WRITE
)
1090 scm_ptobs
[SCM_PTOBNUM (port
)].flush (port
);
1093 pt
->rw_active
= SCM_PORT_READ
;
1095 if (SCM_READ_BUFFER_EMPTY_P (pt
))
1097 if (scm_fill_input (port
) == EOF
)
1101 n_available
= pt
->read_end
- pt
->read_pos
;
1103 while (n_available
< size
)
1105 memcpy (buffer
, pt
->read_pos
, n_available
);
1106 buffer
= (char *) buffer
+ n_available
;
1107 pt
->read_pos
+= n_available
;
1108 n_read
+= n_available
;
1110 if (SCM_READ_BUFFER_EMPTY_P (pt
))
1112 if (scm_fill_input (port
) == EOF
)
1116 size
-= n_available
;
1117 n_available
= pt
->read_end
- pt
->read_pos
;
1120 memcpy (buffer
, pt
->read_pos
, size
);
1121 pt
->read_pos
+= size
;
1123 return n_read
+ size
;
1128 * Used by an application to write arbitrary number of bytes to an SCM
1129 * port. Similar semantics as libc write. However, unlike libc
1130 * write, scm_c_write writes the requested number of bytes and has no
1133 * Warning: Doesn't update port line and column counts!
1137 scm_c_write (SCM port
, const void *ptr
, size_t size
)
1139 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
1140 scm_t_ptob_descriptor
*ptob
= &scm_ptobs
[SCM_PTOBNUM (port
)];
1142 if (pt
->rw_active
== SCM_PORT_READ
)
1143 scm_end_input (port
);
1145 ptob
->write (port
, ptr
, size
);
1148 pt
->rw_active
= SCM_PORT_WRITE
;
1152 scm_flush (SCM port
)
1154 long i
= SCM_PTOBNUM (port
);
1155 (scm_ptobs
[i
].flush
) (port
);
1159 scm_end_input (SCM port
)
1162 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
1164 if (pt
->read_buf
== pt
->putback_buf
)
1166 offset
= pt
->read_end
- pt
->read_pos
;
1167 pt
->read_buf
= pt
->saved_read_buf
;
1168 pt
->read_pos
= pt
->saved_read_pos
;
1169 pt
->read_end
= pt
->saved_read_end
;
1170 pt
->read_buf_size
= pt
->saved_read_buf_size
;
1175 scm_ptobs
[SCM_PTOBNUM (port
)].end_input (port
, offset
);
1182 scm_ungetc (int c
, SCM port
)
1183 #define FUNC_NAME "scm_ungetc"
1185 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
1187 if (pt
->read_buf
== pt
->putback_buf
)
1188 /* already using the put-back buffer. */
1190 /* enlarge putback_buf if necessary. */
1191 if (pt
->read_end
== pt
->read_buf
+ pt
->read_buf_size
1192 && pt
->read_buf
== pt
->read_pos
)
1194 size_t new_size
= pt
->read_buf_size
* 2;
1195 unsigned char *tmp
= (unsigned char *)
1196 scm_gc_realloc (pt
->putback_buf
, pt
->read_buf_size
, new_size
,
1199 pt
->read_pos
= pt
->read_buf
= pt
->putback_buf
= tmp
;
1200 pt
->read_end
= pt
->read_buf
+ pt
->read_buf_size
;
1201 pt
->read_buf_size
= pt
->putback_buf_size
= new_size
;
1204 /* shift any existing bytes to buffer + 1. */
1205 if (pt
->read_pos
== pt
->read_end
)
1206 pt
->read_end
= pt
->read_buf
+ 1;
1207 else if (pt
->read_pos
!= pt
->read_buf
+ 1)
1209 int count
= pt
->read_end
- pt
->read_pos
;
1211 memmove (pt
->read_buf
+ 1, pt
->read_pos
, count
);
1212 pt
->read_end
= pt
->read_buf
+ 1 + count
;
1215 pt
->read_pos
= pt
->read_buf
;
1218 /* switch to the put-back buffer. */
1220 if (pt
->putback_buf
== NULL
)
1223 = (unsigned char *) scm_gc_malloc (SCM_INITIAL_PUTBACK_BUF_SIZE
,
1225 pt
->putback_buf_size
= SCM_INITIAL_PUTBACK_BUF_SIZE
;
1228 pt
->saved_read_buf
= pt
->read_buf
;
1229 pt
->saved_read_pos
= pt
->read_pos
;
1230 pt
->saved_read_end
= pt
->read_end
;
1231 pt
->saved_read_buf_size
= pt
->read_buf_size
;
1233 pt
->read_pos
= pt
->read_buf
= pt
->putback_buf
;
1234 pt
->read_end
= pt
->read_buf
+ 1;
1235 pt
->read_buf_size
= pt
->putback_buf_size
;
1241 pt
->rw_active
= SCM_PORT_READ
;
1245 /* What should col be in this case?
1246 * We'll leave it at -1.
1248 SCM_LINUM (port
) -= 1;
1257 scm_ungets (const char *s
, int n
, SCM port
)
1259 /* This is simple minded and inefficient, but unreading strings is
1260 * probably not a common operation, and remember that line and
1261 * column numbers have to be handled...
1263 * Please feel free to write an optimized version!
1266 scm_ungetc (s
[n
], port
);
1270 SCM_DEFINE (scm_peek_char
, "peek-char", 0, 1, 0,
1272 "Return the next character available from @var{port},\n"
1273 "@emph{without} updating @var{port} to point to the following\n"
1274 "character. If no more characters are available, the\n"
1275 "end-of-file object is returned.\n"
1277 "The value returned by\n"
1278 "a call to @code{peek-char} is the same as the value that would\n"
1279 "have been returned by a call to @code{read-char} on the same\n"
1280 "port. The only difference is that the very next call to\n"
1281 "@code{read-char} or @code{peek-char} on that @var{port} will\n"
1282 "return the value returned by the preceding call to\n"
1283 "@code{peek-char}. In particular, a call to @code{peek-char} on\n"
1284 "an interactive port will hang waiting for input whenever a call\n"
1285 "to @code{read-char} would have hung.")
1286 #define FUNC_NAME s_scm_peek_char
1289 if (SCM_UNBNDP (port
))
1290 port
= scm_current_input_port ();
1292 SCM_VALIDATE_OPINPORT (1, port
);
1293 column
= SCM_COL(port
);
1294 c
= scm_getc (port
);
1297 scm_ungetc (c
, port
);
1298 SCM_COL(port
) = column
;
1299 return SCM_MAKE_CHAR (c
);
1303 SCM_DEFINE (scm_unread_char
, "unread-char", 1, 1, 0,
1304 (SCM cobj
, SCM port
),
1305 "Place @var{char} in @var{port} so that it will be read by the\n"
1306 "next read operation. If called multiple times, the unread characters\n"
1307 "will be read again in last-in first-out order. If @var{port} is\n"
1308 "not supplied, the current input port is used.")
1309 #define FUNC_NAME s_scm_unread_char
1313 SCM_VALIDATE_CHAR (1, cobj
);
1314 if (SCM_UNBNDP (port
))
1315 port
= scm_current_input_port ();
1317 SCM_VALIDATE_OPINPORT (2, port
);
1319 c
= SCM_CHAR (cobj
);
1321 scm_ungetc (c
, port
);
1326 SCM_DEFINE (scm_unread_string
, "unread-string", 2, 0, 0,
1327 (SCM str
, SCM port
),
1328 "Place the string @var{str} in @var{port} so that its characters will be\n"
1329 "read in subsequent read operations. If called multiple times, the\n"
1330 "unread characters will be read again in last-in first-out order. If\n"
1331 "@var{port} is not supplied, the current-input-port is used.")
1332 #define FUNC_NAME s_scm_unread_string
1334 SCM_VALIDATE_STRING (1, str
);
1335 if (SCM_UNBNDP (port
))
1336 port
= scm_current_input_port ();
1338 SCM_VALIDATE_OPINPORT (2, port
);
1340 scm_ungets (scm_i_string_chars (str
), scm_i_string_length (str
), port
);
1346 SCM_DEFINE (scm_seek
, "seek", 3, 0, 0,
1347 (SCM fd_port
, SCM offset
, SCM whence
),
1348 "Sets the current position of @var{fd/port} to the integer\n"
1349 "@var{offset}, which is interpreted according to the value of\n"
1352 "One of the following variables should be supplied for\n"
1354 "@defvar SEEK_SET\n"
1355 "Seek from the beginning of the file.\n"
1357 "@defvar SEEK_CUR\n"
1358 "Seek from the current position.\n"
1360 "@defvar SEEK_END\n"
1361 "Seek from the end of the file.\n"
1363 "If @var{fd/port} is a file descriptor, the underlying system\n"
1364 "call is @code{lseek}. @var{port} may be a string port.\n"
1366 "The value returned is the new position in the file. This means\n"
1367 "that the current position of a port can be obtained using:\n"
1369 "(seek port 0 SEEK_CUR)\n"
1371 #define FUNC_NAME s_scm_seek
1377 fd_port
= SCM_COERCE_OUTPORT (fd_port
);
1379 if (sizeof (off_t
) == sizeof (scm_t_intmax
))
1380 off
= scm_to_intmax (offset
);
1382 off
= scm_to_long (offset
);
1383 how
= scm_to_int (whence
);
1385 if (how
!= SEEK_SET
&& how
!= SEEK_CUR
&& how
!= SEEK_END
)
1386 SCM_OUT_OF_RANGE (3, whence
);
1387 if (SCM_OPPORTP (fd_port
))
1389 scm_t_ptob_descriptor
*ptob
= scm_ptobs
+ SCM_PTOBNUM (fd_port
);
1392 SCM_MISC_ERROR ("port is not seekable",
1393 scm_cons (fd_port
, SCM_EOL
));
1395 rv
= ptob
->seek (fd_port
, off
, how
);
1397 else /* file descriptor?. */
1399 rv
= lseek (scm_to_int (fd_port
), off
, how
);
1403 return scm_from_intmax (rv
);
1408 /* Define this function since it is not supported under Windows. */
1409 static int truncate (char *file
, int length
)
1412 if ((fdes
= open (file
, O_BINARY
| O_WRONLY
)) != -1)
1414 ret
= chsize (fdes
, length
);
1419 #endif /* __MINGW32__ */
1421 SCM_DEFINE (scm_truncate_file
, "truncate-file", 1, 1, 0,
1422 (SCM object
, SCM length
),
1423 "Truncates the object referred to by @var{object} to at most\n"
1424 "@var{length} bytes. @var{object} can be a string containing a\n"
1425 "file name or an integer file descriptor or a port.\n"
1426 "@var{length} may be omitted if @var{object} is not a file name,\n"
1427 "in which case the truncation occurs at the current port\n"
1428 "position. The return value is unspecified.")
1429 #define FUNC_NAME s_scm_truncate_file
1434 /* object can be a port, fdes or filename. */
1436 if (SCM_UNBNDP (length
))
1438 /* must supply length if object is a filename. */
1439 if (scm_is_string (object
))
1440 SCM_MISC_ERROR("must supply length if OBJECT is a filename", SCM_EOL
);
1442 length
= scm_seek (object
, SCM_INUM0
, scm_from_int (SEEK_CUR
));
1444 c_length
= scm_to_size_t (length
);
1446 object
= SCM_COERCE_OUTPORT (object
);
1447 if (scm_is_integer (object
))
1449 SCM_SYSCALL (rv
= ftruncate (scm_to_int (object
), c_length
));
1451 else if (SCM_OPOUTPORTP (object
))
1453 scm_t_port
*pt
= SCM_PTAB_ENTRY (object
);
1454 scm_t_ptob_descriptor
*ptob
= scm_ptobs
+ SCM_PTOBNUM (object
);
1456 if (!ptob
->truncate
)
1457 SCM_MISC_ERROR ("port is not truncatable", SCM_EOL
);
1458 if (pt
->rw_active
== SCM_PORT_READ
)
1459 scm_end_input (object
);
1460 else if (pt
->rw_active
== SCM_PORT_WRITE
)
1461 ptob
->flush (object
);
1463 ptob
->truncate (object
, c_length
);
1468 char *str
= scm_to_locale_string (object
);
1470 SCM_SYSCALL (rv
= truncate (str
, c_length
));
1477 return SCM_UNSPECIFIED
;
1481 SCM_DEFINE (scm_port_line
, "port-line", 1, 0, 0,
1483 "Return the current line number for @var{port}.\n"
1485 "The first line of a file is 0. But you might want to add 1\n"
1486 "when printing line numbers, since starting from 1 is\n"
1487 "traditional in error messages, and likely to be more natural to\n"
1489 #define FUNC_NAME s_scm_port_line
1491 port
= SCM_COERCE_OUTPORT (port
);
1492 SCM_VALIDATE_OPENPORT (1, port
);
1493 return scm_from_int (SCM_LINUM (port
));
1497 SCM_DEFINE (scm_set_port_line_x
, "set-port-line!", 2, 0, 0,
1498 (SCM port
, SCM line
),
1499 "Set the current line number for @var{port} to @var{line}. The\n"
1500 "first line of a file is 0.")
1501 #define FUNC_NAME s_scm_set_port_line_x
1503 port
= SCM_COERCE_OUTPORT (port
);
1504 SCM_VALIDATE_OPENPORT (1, port
);
1505 SCM_PTAB_ENTRY (port
)->line_number
= scm_to_int (line
);
1506 return SCM_UNSPECIFIED
;
1510 SCM_DEFINE (scm_port_column
, "port-column", 1, 0, 0,
1512 "Return the current column number of @var{port}.\n"
1513 "If the number is\n"
1514 "unknown, the result is #f. Otherwise, the result is a 0-origin integer\n"
1515 "- i.e. the first character of the first line is line 0, column 0.\n"
1516 "(However, when you display a file position, for example in an error\n"
1517 "message, we recommend you add 1 to get 1-origin integers. This is\n"
1518 "because lines and column numbers traditionally start with 1, and that is\n"
1519 "what non-programmers will find most natural.)")
1520 #define FUNC_NAME s_scm_port_column
1522 port
= SCM_COERCE_OUTPORT (port
);
1523 SCM_VALIDATE_OPENPORT (1, port
);
1524 return scm_from_int (SCM_COL (port
));
1528 SCM_DEFINE (scm_set_port_column_x
, "set-port-column!", 2, 0, 0,
1529 (SCM port
, SCM column
),
1530 "Set the current column of @var{port}. Before reading the first\n"
1531 "character on a line the column should be 0.")
1532 #define FUNC_NAME s_scm_set_port_column_x
1534 port
= SCM_COERCE_OUTPORT (port
);
1535 SCM_VALIDATE_OPENPORT (1, port
);
1536 SCM_PTAB_ENTRY (port
)->column_number
= scm_to_int (column
);
1537 return SCM_UNSPECIFIED
;
1541 SCM_DEFINE (scm_port_filename
, "port-filename", 1, 0, 0,
1543 "Return the filename associated with @var{port}. This function returns\n"
1544 "the strings \"standard input\", \"standard output\" and \"standard error\"\n"
1545 "when called on the current input, output and error ports respectively.")
1546 #define FUNC_NAME s_scm_port_filename
1548 port
= SCM_COERCE_OUTPORT (port
);
1549 SCM_VALIDATE_OPENPORT (1, port
);
1550 return SCM_FILENAME (port
);
1554 SCM_DEFINE (scm_set_port_filename_x
, "set-port-filename!", 2, 0, 0,
1555 (SCM port
, SCM filename
),
1556 "Change the filename associated with @var{port}, using the current input\n"
1557 "port if none is specified. Note that this does not change the port's\n"
1558 "source of data, but only the value that is returned by\n"
1559 "@code{port-filename} and reported in diagnostic output.")
1560 #define FUNC_NAME s_scm_set_port_filename_x
1562 port
= SCM_COERCE_OUTPORT (port
);
1563 SCM_VALIDATE_OPENPORT (1, port
);
1564 /* We allow the user to set the filename to whatever he likes. */
1565 SCM_SET_FILENAME (port
, filename
);
1566 return SCM_UNSPECIFIED
;
1571 scm_print_port_mode (SCM exp
, SCM port
)
1573 scm_puts (SCM_CLOSEDP (exp
)
1575 : (SCM_RDNG
& SCM_CELL_WORD_0 (exp
)
1576 ? (SCM_WRTNG
& SCM_CELL_WORD_0 (exp
)
1579 : (SCM_WRTNG
& SCM_CELL_WORD_0 (exp
)
1586 scm_port_print (SCM exp
, SCM port
, scm_print_state
*pstate SCM_UNUSED
)
1588 char *type
= SCM_PTOBNAME (SCM_PTOBNUM (exp
));
1591 scm_puts ("#<", port
);
1592 scm_print_port_mode (exp
, port
);
1593 scm_puts (type
, port
);
1594 scm_putc (' ', port
);
1595 scm_uintprint (SCM_CELL_WORD_1 (exp
), 16, port
);
1596 scm_putc ('>', port
);
1601 scm_ports_prehistory ()
1604 scm_ptobs
= (scm_t_ptob_descriptor
*) scm_malloc (sizeof (scm_t_ptob_descriptor
));
1611 scm_t_bits scm_tc16_void_port
= 0;
1613 static int fill_input_void_port (SCM port SCM_UNUSED
)
1619 write_void_port (SCM port SCM_UNUSED
,
1620 const void *data SCM_UNUSED
,
1621 size_t size SCM_UNUSED
)
1626 scm_i_void_port (long mode_bits
)
1628 scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex
);
1630 SCM answer
= scm_new_port_table_entry (scm_tc16_void_port
);
1631 scm_t_port
* pt
= SCM_PTAB_ENTRY(answer
);
1633 scm_port_non_buffer (pt
);
1635 SCM_SETSTREAM (answer
, 0);
1636 SCM_SET_CELL_TYPE (answer
, scm_tc16_void_port
| mode_bits
);
1637 scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex
);
1643 scm_void_port (char *mode_str
)
1645 return scm_i_void_port (scm_mode_bits (mode_str
));
1648 SCM_DEFINE (scm_sys_make_void_port
, "%make-void-port", 1, 0, 0,
1650 "Create and return a new void port. A void port acts like\n"
1651 "@file{/dev/null}. The @var{mode} argument\n"
1652 "specifies the input/output modes for this port: see the\n"
1653 "documentation for @code{open-file} in @ref{File Ports}.")
1654 #define FUNC_NAME s_scm_sys_make_void_port
1656 return scm_i_void_port (scm_i_mode_bits (mode
));
1661 /* Initialization. */
1666 /* lseek() symbols. */
1667 scm_c_define ("SEEK_SET", scm_from_int (SEEK_SET
));
1668 scm_c_define ("SEEK_CUR", scm_from_int (SEEK_CUR
));
1669 scm_c_define ("SEEK_END", scm_from_int (SEEK_END
));
1671 scm_tc16_void_port
= scm_make_port_type ("void", fill_input_void_port
,
1674 cur_inport_fluid
= scm_permanent_object (scm_make_fluid ());
1675 cur_outport_fluid
= scm_permanent_object (scm_make_fluid ());
1676 cur_errport_fluid
= scm_permanent_object (scm_make_fluid ());
1677 cur_loadport_fluid
= scm_permanent_object (scm_make_fluid ());
1679 #include "libguile/ports.x"