1 /* Copyright (C) 1995,1996,1997,1998,1999,2000,2001 Free Software Foundation, Inc.
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2, or (at your option)
8 * This program 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
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this software; see the file COPYING. If not, write to
15 * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
16 * Boston, MA 02111-1307 USA
18 * As a special exception, the Free Software Foundation gives permission
19 * for additional uses of the text contained in its release of GUILE.
21 * The exception is that, if you link the GUILE library with other files
22 * to produce an executable, this does not by itself cause the
23 * resulting executable to be covered by the GNU General Public License.
24 * Your use of that executable is in no way restricted on account of
25 * linking the GUILE library code into it.
27 * This exception does not however invalidate any other reasons why
28 * the executable file might be covered by the GNU General Public License.
30 * This exception applies only to the code released by the
31 * Free Software Foundation under the name GUILE. If you copy
32 * code from other Free Software Foundation releases into a copy of
33 * GUILE, as the General Public License permits, the exception does
34 * not apply to the code that you add in this way. To avoid misleading
35 * anyone as to the status of such modified files, you must delete
36 * this exception notice from them.
38 * If you write modifications of your own for GUILE, it is your choice
39 * whether to permit this exception to apply to your modifications.
40 * If you do not wish that, delete this exception notice. */
53 #include "libguile/_scm.h"
54 #include "libguile/eval.h"
55 #include "libguile/objects.h"
56 #include "libguile/smob.h"
57 #include "libguile/chars.h"
59 #include "libguile/keywords.h"
60 #include "libguile/root.h"
61 #include "libguile/strings.h"
63 #include "libguile/validate.h"
64 #include "libguile/ports.h"
82 #ifdef HAVE_SYS_IOCTL_H
83 #include <sys/ioctl.h>
88 #define ftruncate(fd, size) chsize (fd, size)
92 /* The port kind table --- a dynamically resized array of port types. */
95 /* scm_ptobs scm_numptob
96 * implement a dynamicly resized array of ptob records.
97 * Indexes into this table are used when generating type
98 * tags for smobjects (if you know a tag you can get an index and conversely).
100 scm_t_ptob_descriptor
*scm_ptobs
;
103 /* GC marker for a port with stream of SCM type. */
105 scm_markstream (SCM ptr
)
108 openp
= SCM_CELL_WORD_0 (ptr
) & SCM_OPN
;
110 return SCM_PACK (SCM_STREAM (ptr
));
116 * We choose to use an interface similar to the smob interface with
117 * fill_input and write as standard fields, passed to the port
118 * type constructor, and optional fields set by setters.
122 flush_port_default (SCM port SCM_UNUSED
)
127 end_input_default (SCM port SCM_UNUSED
, int offset SCM_UNUSED
)
132 scm_port_free0 (SCM port
)
138 scm_make_port_type (char *name
,
139 int (*fill_input
) (SCM port
),
140 void (*write
) (SCM port
, const void *data
, size_t size
))
143 if (255 <= scm_numptob
)
146 SCM_SYSCALL (tmp
= (char *) realloc ((char *) scm_ptobs
,
148 * sizeof (scm_t_ptob_descriptor
)));
151 scm_ptobs
= (scm_t_ptob_descriptor
*) tmp
;
153 scm_ptobs
[scm_numptob
].name
= name
;
154 scm_ptobs
[scm_numptob
].mark
= 0;
155 scm_ptobs
[scm_numptob
].free
= scm_port_free0
;
156 scm_ptobs
[scm_numptob
].print
= scm_port_print
;
157 scm_ptobs
[scm_numptob
].equalp
= 0;
158 scm_ptobs
[scm_numptob
].close
= 0;
160 scm_ptobs
[scm_numptob
].write
= write
;
161 scm_ptobs
[scm_numptob
].flush
= flush_port_default
;
163 scm_ptobs
[scm_numptob
].end_input
= end_input_default
;
164 scm_ptobs
[scm_numptob
].fill_input
= fill_input
;
165 scm_ptobs
[scm_numptob
].input_waiting
= 0;
167 scm_ptobs
[scm_numptob
].seek
= 0;
168 scm_ptobs
[scm_numptob
].truncate
= 0;
176 scm_memory_error ("scm_make_port_type");
178 /* Make a class object if Goops is present */
180 scm_make_port_classes (scm_numptob
- 1, SCM_PTOBNAME (scm_numptob
- 1));
181 return scm_tc7_port
+ (scm_numptob
- 1) * 256;
185 scm_set_port_mark (long tc
, SCM (*mark
) (SCM
))
187 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].mark
= mark
;
191 scm_set_port_free (long tc
, size_t (*free
) (SCM
))
193 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].free
= free
;
197 scm_set_port_print (long tc
, int (*print
) (SCM exp
, SCM port
,
198 scm_print_state
*pstate
))
200 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].print
= print
;
204 scm_set_port_equalp (long tc
, SCM (*equalp
) (SCM
, SCM
))
206 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].equalp
= equalp
;
210 scm_set_port_flush (long tc
, void (*flush
) (SCM port
))
212 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].flush
= flush
;
216 scm_set_port_end_input (long tc
, void (*end_input
) (SCM port
, int offset
))
218 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].end_input
= end_input
;
222 scm_set_port_close (long tc
, int (*close
) (SCM
))
224 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].close
= close
;
228 scm_set_port_seek (long tc
, off_t (*seek
) (SCM port
,
232 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].seek
= seek
;
236 scm_set_port_truncate (long tc
, void (*truncate
) (SCM port
, off_t length
))
238 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].truncate
= truncate
;
242 scm_set_port_input_waiting (long tc
, int (*input_waiting
) (SCM
))
244 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].input_waiting
= input_waiting
;
249 SCM_DEFINE (scm_char_ready_p
, "char-ready?", 0, 1, 0,
251 "Return @code{#t} if a character is ready on input @var{port}\n"
252 "and return @code{#f} otherwise. If @code{char-ready?} returns\n"
253 "@code{#t} then the next @code{read-char} operation on\n"
254 "@var{port} is guaranteed not to hang. If @var{port} is a file\n"
255 "port at end of file then @code{char-ready?} returns @code{#t}.\n"
256 "@footnote{@code{char-ready?} exists to make it possible for a\n"
257 "program to accept characters from interactive ports without\n"
258 "getting stuck waiting for input. Any input editors associated\n"
259 "with such ports must make sure that characters whose existence\n"
260 "has been asserted by @code{char-ready?} cannot be rubbed out.\n"
261 "If @code{char-ready?} were to return @code{#f} at end of file,\n"
262 "a port at end of file would be indistinguishable from an\n"
263 "interactive port that has no ready characters.}")
264 #define FUNC_NAME s_scm_char_ready_p
268 if (SCM_UNBNDP (port
))
271 SCM_VALIDATE_OPINPORT (1, port
);
273 pt
= SCM_PTAB_ENTRY (port
);
275 /* if the current read buffer is filled, or the
276 last pushed-back char has been read and the saved buffer is
277 filled, result is true. */
278 if (pt
->read_pos
< pt
->read_end
279 || (pt
->read_buf
== pt
->putback_buf
280 && pt
->saved_read_pos
< pt
->saved_read_end
))
284 scm_t_ptob_descriptor
*ptob
= &scm_ptobs
[SCM_PTOBNUM (port
)];
286 if (ptob
->input_waiting
)
287 return SCM_BOOL(ptob
->input_waiting (port
));
294 /* move up to read_len chars from port's putback and/or read buffers
295 into memory starting at dest. returns the number of chars moved. */
296 size_t scm_take_from_input_buffers (SCM port
, char *dest
, size_t read_len
)
298 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
299 size_t chars_read
= 0;
300 size_t from_buf
= min (pt
->read_end
- pt
->read_pos
, read_len
);
304 memcpy (dest
, pt
->read_pos
, from_buf
);
305 pt
->read_pos
+= from_buf
;
306 chars_read
+= from_buf
;
307 read_len
-= from_buf
;
311 /* if putback was active, try the real input buffer too. */
312 if (pt
->read_buf
== pt
->putback_buf
)
314 from_buf
= min (pt
->saved_read_end
- pt
->saved_read_pos
, read_len
);
317 memcpy (dest
, pt
->saved_read_pos
, from_buf
);
318 pt
->saved_read_pos
+= from_buf
;
319 chars_read
+= from_buf
;
325 /* Clear a port's read buffers, returning the contents. */
326 SCM_DEFINE (scm_drain_input
, "drain-input", 1, 0, 0,
328 "This procedure clears a port's input buffers, similar\n"
329 "to the way that force-output clears the output buffer. The\n"
330 "contents of the buffers are returned as a single string, e.g.,\n"
333 "(define p (open-input-file ...))\n"
334 "(drain-input p) => empty string, nothing buffered yet.\n"
335 "(unread-char (read-char p) p)\n"
336 "(drain-input p) => initial chars from p, up to the buffer size.\n"
338 "Draining the buffers may be useful for cleanly finishing\n"
339 "buffered I/O so that the file descriptor can be used directly\n"
340 "for further input.")
341 #define FUNC_NAME s_scm_drain_input
344 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
347 SCM_VALIDATE_OPINPORT (1, port
);
349 count
= pt
->read_end
- pt
->read_pos
;
350 if (pt
->read_buf
== pt
->putback_buf
)
351 count
+= pt
->saved_read_end
- pt
->saved_read_pos
;
353 result
= scm_allocate_string (count
);
354 scm_take_from_input_buffers (port
, SCM_STRING_CHARS (result
), count
);
361 /* Standard ports --- current input, output, error, and more(!). */
363 SCM_DEFINE (scm_current_input_port
, "current-input-port", 0, 0, 0,
365 "Return the current input port. This is the default port used\n"
366 "by many input procedures. Initially, @code{current-input-port}\n"
367 "returns the @dfn{standard input} in Unix and C terminology.")
368 #define FUNC_NAME s_scm_current_input_port
374 SCM_DEFINE (scm_current_output_port
, "current-output-port", 0, 0, 0,
376 "Return the current output port. This is the default port used\n"
377 "by many output procedures. Initially,\n"
378 "@code{current-output-port} returns the @dfn{standard output} in\n"
379 "Unix and C terminology.")
380 #define FUNC_NAME s_scm_current_output_port
386 SCM_DEFINE (scm_current_error_port
, "current-error-port", 0, 0, 0,
388 "Return the port to which errors and warnings should be sent (the\n"
389 "@dfn{standard error} in Unix and C terminology).")
390 #define FUNC_NAME s_scm_current_error_port
396 SCM_DEFINE (scm_current_load_port
, "current-load-port", 0, 0, 0,
398 "Return the current-load-port.\n"
399 "The load port is used internally by @code{primitive-load}.")
400 #define FUNC_NAME s_scm_current_load_port
402 return scm_cur_loadp
;
406 SCM_DEFINE (scm_set_current_input_port
, "set-current-input-port", 1, 0, 0,
408 "@deffnx {Scheme Procedure} set-current-output-port port\n"
409 "@deffnx {Scheme Procedure} set-current-error-port port\n"
410 "Change the ports returned by @code{current-input-port},\n"
411 "@code{current-output-port} and @code{current-error-port}, respectively,\n"
412 "so that they use the supplied @var{port} for input or output.")
413 #define FUNC_NAME s_scm_set_current_input_port
415 SCM oinp
= scm_cur_inp
;
416 SCM_VALIDATE_OPINPORT (1, port
);
423 SCM_DEFINE (scm_set_current_output_port
, "set-current-output-port", 1, 0, 0,
425 "Set the current default output port to @var{port}.")
426 #define FUNC_NAME s_scm_set_current_output_port
428 SCM ooutp
= scm_cur_outp
;
429 port
= SCM_COERCE_OUTPORT (port
);
430 SCM_VALIDATE_OPOUTPORT (1, port
);
437 SCM_DEFINE (scm_set_current_error_port
, "set-current-error-port", 1, 0, 0,
439 "Set the current default error port to @var{port}.")
440 #define FUNC_NAME s_scm_set_current_error_port
442 SCM oerrp
= scm_cur_errp
;
443 port
= SCM_COERCE_OUTPORT (port
);
444 SCM_VALIDATE_OPOUTPORT (1, port
);
451 /* The port table --- an array of pointers to ports. */
453 scm_t_port
**scm_i_port_table
;
455 long scm_i_port_table_size
= 0; /* Number of ports in scm_i_port_table. */
456 long scm_i_port_table_room
= 20; /* Size of the array. */
460 scm_new_port_table_entry (scm_t_bits tag
)
461 #define FUNC_NAME "scm_new_port_table_entry"
464 We initialize the cell to empty, this is in case scm_gc_calloc
465 triggers GC ; we don't want the GC to scan a half-finished Z.
468 SCM z
= scm_cons (SCM_EOL
, SCM_EOL
);
469 scm_t_port
*entry
= (scm_t_port
*) scm_gc_calloc (sizeof (scm_t_port
), "port");
470 if (scm_i_port_table_size
== scm_i_port_table_room
)
472 /* initial malloc is in gc.c. this doesn't use scm_gc_malloc etc.,
473 since it can never be freed during gc. */
474 void *newt
= scm_realloc ((char *) scm_i_port_table
,
475 (size_t) (sizeof (scm_t_port
*)
476 * scm_i_port_table_room
* 2));
477 scm_i_port_table
= (scm_t_port
**) newt
;
478 scm_i_port_table_room
*= 2;
481 entry
->entry
= scm_i_port_table_size
;
483 entry
->file_name
= SCM_BOOL_F
;
484 entry
->rw_active
= SCM_PORT_NEITHER
;
486 scm_i_port_table
[scm_i_port_table_size
] = entry
;
487 scm_i_port_table_size
++;
490 SCM_SET_CELL_TYPE(z
, tag
);
491 SCM_SETPTAB_ENTRY(z
, entry
);
497 #if SCM_ENABLE_DEPRECATED==1
499 scm_add_to_port_table (SCM port
)
501 SCM z
= scm_new_port_table_entry (scm_tc7_port
);
502 scm_t_port
* pt
= SCM_PTAB_ENTRY(z
);
505 SCM_SETCAR(z
, SCM_EOL
);
506 SCM_SETCDR(z
, SCM_EOL
);
507 SCM_SETPTAB_ENTRY (port
, pt
);
513 /* Remove a port from the table and destroy it. */
515 scm_remove_from_port_table (SCM port
)
516 #define FUNC_NAME "scm_remove_from_port_table"
518 scm_t_port
*p
= SCM_PTAB_ENTRY (port
);
521 if (i
>= scm_i_port_table_size
)
522 SCM_MISC_ERROR ("Port not in table: ~S", scm_list_1 (port
));
524 scm_gc_free (p
->putback_buf
, p
->putback_buf_size
, "putback buffer");
525 scm_gc_free (p
, sizeof (scm_t_port
), "port");
526 /* Since we have just freed slot i we can shrink the table by moving
527 the last entry to that slot... */
528 if (i
< scm_i_port_table_size
- 1)
530 scm_i_port_table
[i
] = scm_i_port_table
[scm_i_port_table_size
- 1];
531 scm_i_port_table
[i
]->entry
= i
;
533 SCM_SETPTAB_ENTRY (port
, 0);
534 scm_i_port_table_size
--;
540 /* Functions for debugging. */
542 SCM_DEFINE (scm_pt_size
, "pt-size", 0, 0, 0,
544 "Return the number of ports in the port table. @code{pt-size}\n"
545 "is only included in @code{--enable-guile-debug} builds.")
546 #define FUNC_NAME s_scm_pt_size
548 return SCM_MAKINUM (scm_i_port_table_size
);
552 SCM_DEFINE (scm_pt_member
, "pt-member", 1, 0, 0,
554 "Return the port at @var{index} in the port table.\n"
555 "@code{pt-member} is only included in\n"
556 "@code{--enable-guile-debug} builds.")
557 #define FUNC_NAME s_scm_pt_member
560 SCM_VALIDATE_INUM_COPY (1, index
, i
);
561 if (i
< 0 || i
>= scm_i_port_table_size
)
564 return scm_i_port_table
[i
]->port
;
570 scm_port_non_buffer (scm_t_port
*pt
)
572 pt
->read_pos
= pt
->read_buf
= pt
->read_end
= &pt
->shortbuf
;
573 pt
->write_buf
= pt
->write_pos
= &pt
->shortbuf
;
574 pt
->read_buf_size
= pt
->write_buf_size
= 1;
575 pt
->write_end
= pt
->write_buf
+ pt
->write_buf_size
;
579 /* Revealed counts --- an oddity inherited from SCSH. */
581 /* Find a port in the table and return its revealed count.
582 Also used by the garbage collector.
586 scm_revealed_count (SCM port
)
588 return SCM_REVEALED(port
);
593 /* Return the revealed count for a port. */
595 SCM_DEFINE (scm_port_revealed
, "port-revealed", 1, 0, 0,
597 "Return the revealed count for @var{port}.")
598 #define FUNC_NAME s_scm_port_revealed
600 port
= SCM_COERCE_OUTPORT (port
);
601 SCM_VALIDATE_OPENPORT (1, port
);
602 return SCM_MAKINUM (scm_revealed_count (port
));
606 /* Set the revealed count for a port. */
607 SCM_DEFINE (scm_set_port_revealed_x
, "set-port-revealed!", 2, 0, 0,
608 (SCM port
, SCM rcount
),
609 "Sets the revealed count for a port to a given value.\n"
610 "The return value is unspecified.")
611 #define FUNC_NAME s_scm_set_port_revealed_x
613 port
= SCM_COERCE_OUTPORT (port
);
614 SCM_VALIDATE_OPENPORT (1, port
);
615 SCM_VALIDATE_INUM (2, rcount
);
616 SCM_REVEALED (port
) = SCM_INUM (rcount
);
617 return SCM_UNSPECIFIED
;
623 /* Retrieving a port's mode. */
625 /* Return the flags that characterize a port based on the mode
626 * string used to open a file for that port.
628 * See PORT FLAGS in scm.h
632 scm_mode_bits (char *modes
)
635 | (strchr (modes
, 'r') || strchr (modes
, '+') ? SCM_RDNG
: 0)
636 | ( strchr (modes
, 'w')
637 || strchr (modes
, 'a')
638 || strchr (modes
, '+') ? SCM_WRTNG
: 0)
639 | (strchr (modes
, '0') ? SCM_BUF0
: 0)
640 | (strchr (modes
, 'l') ? SCM_BUFLINE
: 0));
644 /* Return the mode flags from an open port.
645 * Some modes such as "append" are only used when opening
646 * a file and are not returned here. */
648 SCM_DEFINE (scm_port_mode
, "port-mode", 1, 0, 0,
650 "Return the port modes associated with the open port @var{port}.\n"
651 "These will not necessarily be identical to the modes used when\n"
652 "the port was opened, since modes such as \"append\" which are\n"
653 "used only during port creation are not retained.")
654 #define FUNC_NAME s_scm_port_mode
659 port
= SCM_COERCE_OUTPORT (port
);
660 SCM_VALIDATE_OPPORT (1, port
);
661 if (SCM_CELL_WORD_0 (port
) & SCM_RDNG
) {
662 if (SCM_CELL_WORD_0 (port
) & SCM_WRTNG
)
663 strcpy (modes
, "r+");
667 else if (SCM_CELL_WORD_0 (port
) & SCM_WRTNG
)
669 if (SCM_CELL_WORD_0 (port
) & SCM_BUF0
)
671 return scm_mem2string (modes
, strlen (modes
));
680 * Call the close operation on a port object.
681 * see also scm_close.
683 SCM_DEFINE (scm_close_port
, "close-port", 1, 0, 0,
685 "Close the specified port object. Return @code{#t} if it\n"
686 "successfully closes a port or @code{#f} if it was already\n"
687 "closed. An exception may be raised if an error occurs, for\n"
688 "example when flushing buffered output. See also @ref{Ports and\n"
689 "File Descriptors, close}, for a procedure which can close file\n"
691 #define FUNC_NAME s_scm_close_port
696 port
= SCM_COERCE_OUTPORT (port
);
698 SCM_VALIDATE_PORT (1, port
);
699 if (SCM_CLOSEDP (port
))
701 i
= SCM_PTOBNUM (port
);
702 if (scm_ptobs
[i
].close
)
703 rv
= (scm_ptobs
[i
].close
) (port
);
706 scm_remove_from_port_table (port
);
707 SCM_CLR_PORT_OPEN_FLAG (port
);
708 return SCM_BOOL (rv
>= 0);
712 SCM_DEFINE (scm_close_input_port
, "close-input-port", 1, 0, 0,
714 "Close the specified input port object. The routine has no effect if\n"
715 "the file has already been closed. An exception may be raised if an\n"
716 "error occurs. The value returned is unspecified.\n\n"
717 "See also @ref{Ports and File Descriptors, close}, for a procedure\n"
718 "which can close file descriptors.")
719 #define FUNC_NAME s_scm_close_input_port
721 SCM_VALIDATE_INPUT_PORT (1, port
);
722 scm_close_port (port
);
723 return SCM_UNSPECIFIED
;
727 SCM_DEFINE (scm_close_output_port
, "close-output-port", 1, 0, 0,
729 "Close the specified output port object. The routine has no effect if\n"
730 "the file has already been closed. An exception may be raised if an\n"
731 "error occurs. The value returned is unspecified.\n\n"
732 "See also @ref{Ports and File Descriptors, close}, for a procedure\n"
733 "which can close file descriptors.")
734 #define FUNC_NAME s_scm_close_output_port
736 port
= SCM_COERCE_OUTPORT (port
);
737 SCM_VALIDATE_OUTPUT_PORT (1, port
);
738 scm_close_port (port
);
739 return SCM_UNSPECIFIED
;
743 SCM_DEFINE (scm_port_for_each
, "port-for-each", 1, 0, 0,
745 "Apply @var{proc} to each port in the Guile port table\n"
746 "in turn. The return value is unspecified. More specifically,\n"
747 "@var{proc} is applied exactly once to every port that exists\n"
748 "in the system at the time @var{port-for-each} is invoked.\n"
749 "Changes to the port table while @var{port-for-each} is running\n"
750 "have no effect as far as @var{port-for-each} is concerned.")
751 #define FUNC_NAME s_scm_port_for_each
756 SCM_VALIDATE_PROC (1, proc
);
758 /* when pre-emptive multithreading is supported, access to the port
759 table will need to be controlled by a mutex. */
761 /* Even without pre-emptive multithreading, running arbitrary code
762 while scanning the port table is unsafe because the port table
763 can change arbitrarily (from a GC, for example). So we build a
764 list in advance while blocking the GC. -mvo */
769 for (i
= 0; i
< scm_i_port_table_size
; i
++)
770 ports
= scm_cons (scm_i_port_table
[i
]->port
, ports
);
774 while (ports
!= SCM_EOL
)
776 scm_call_1 (proc
, SCM_CAR (ports
));
777 ports
= SCM_CDR (ports
);
780 return SCM_UNSPECIFIED
;
785 /* Utter miscellany. Gosh, we should clean this up some time. */
787 SCM_DEFINE (scm_input_port_p
, "input-port?", 1, 0, 0,
789 "Return @code{#t} if @var{x} is an input port, otherwise return\n"
790 "@code{#f}. Any object satisfying this predicate also satisfies\n"
792 #define FUNC_NAME s_scm_input_port_p
794 return SCM_BOOL (SCM_INPUT_PORT_P (x
));
798 SCM_DEFINE (scm_output_port_p
, "output-port?", 1, 0, 0,
800 "Return @code{#t} if @var{x} is an output port, otherwise return\n"
801 "@code{#f}. Any object satisfying this predicate also satisfies\n"
803 #define FUNC_NAME s_scm_output_port_p
805 x
= SCM_COERCE_OUTPORT (x
);
806 return SCM_BOOL (SCM_OUTPUT_PORT_P (x
));
810 SCM_DEFINE (scm_port_p
, "port?", 1, 0, 0,
812 "Return a boolean indicating whether @var{x} is a port.\n"
813 "Equivalent to @code{(or (input-port? @var{x}) (output-port?\n"
815 #define FUNC_NAME s_scm_port_p
817 return SCM_BOOL (SCM_PORTP (x
));
821 SCM_DEFINE (scm_port_closed_p
, "port-closed?", 1, 0, 0,
823 "Return @code{#t} if @var{port} is closed or @code{#f} if it is\n"
825 #define FUNC_NAME s_scm_port_closed_p
827 SCM_VALIDATE_PORT (1, port
);
828 return SCM_BOOL (!SCM_OPPORTP (port
));
832 SCM_DEFINE (scm_eof_object_p
, "eof-object?", 1, 0, 0,
834 "Return @code{#t} if @var{x} is an end-of-file object; otherwise\n"
836 #define FUNC_NAME s_scm_eof_object_p
838 return SCM_BOOL(SCM_EOF_OBJECT_P (x
));
842 SCM_DEFINE (scm_force_output
, "force-output", 0, 1, 0,
844 "Flush the specified output port, or the current output port if @var{port}\n"
845 "is omitted. The current output buffer contents are passed to the\n"
846 "underlying port implementation (e.g., in the case of fports, the\n"
847 "data will be written to the file and the output buffer will be cleared.)\n"
848 "It has no effect on an unbuffered port.\n\n"
849 "The return value is unspecified.")
850 #define FUNC_NAME s_scm_force_output
852 if (SCM_UNBNDP (port
))
856 port
= SCM_COERCE_OUTPORT (port
);
857 SCM_VALIDATE_OPOUTPORT (1, port
);
860 return SCM_UNSPECIFIED
;
864 SCM_DEFINE (scm_flush_all_ports
, "flush-all-ports", 0, 0, 0,
866 "Equivalent to calling @code{force-output} on\n"
867 "all open output ports. The return value is unspecified.")
868 #define FUNC_NAME s_scm_flush_all_ports
872 for (i
= 0; i
< scm_i_port_table_size
; i
++)
874 if (SCM_OPOUTPORTP (scm_i_port_table
[i
]->port
))
875 scm_flush (scm_i_port_table
[i
]->port
);
877 return SCM_UNSPECIFIED
;
881 SCM_DEFINE (scm_read_char
, "read-char", 0, 1, 0,
883 "Return the next character available from @var{port}, updating\n"
884 "@var{port} to point to the following character. If no more\n"
885 "characters are available, the end-of-file object is returned.")
886 #define FUNC_NAME s_scm_read_char
889 if (SCM_UNBNDP (port
))
891 SCM_VALIDATE_OPINPORT (1, port
);
895 return SCM_MAKE_CHAR (c
);
899 /* this should only be called when the read buffer is empty. it
900 tries to refill the read buffer. it returns the first char from
901 the port, which is either EOF or *(pt->read_pos). */
903 scm_fill_input (SCM port
)
905 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
907 if (pt
->read_buf
== pt
->putback_buf
)
909 /* finished reading put-back chars. */
910 pt
->read_buf
= pt
->saved_read_buf
;
911 pt
->read_pos
= pt
->saved_read_pos
;
912 pt
->read_end
= pt
->saved_read_end
;
913 pt
->read_buf_size
= pt
->saved_read_buf_size
;
914 if (pt
->read_pos
< pt
->read_end
)
915 return *(pt
->read_pos
);
917 return scm_ptobs
[SCM_PTOBNUM (port
)].fill_input (port
);
924 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
926 if (pt
->rw_active
== SCM_PORT_WRITE
)
927 /* may be marginally faster than calling scm_flush. */
928 scm_ptobs
[SCM_PTOBNUM (port
)].flush (port
);
931 pt
->rw_active
= SCM_PORT_READ
;
933 if (pt
->read_pos
>= pt
->read_end
)
935 if (scm_fill_input (port
) == EOF
)
939 c
= *(pt
->read_pos
++);
958 scm_putc (char c
, SCM port
)
960 scm_lfwrite (&c
, 1, port
);
964 scm_puts (const char *s
, SCM port
)
966 scm_lfwrite (s
, strlen (s
), port
);
971 * This function differs from scm_c_write; it updates port line and
975 scm_lfwrite (const char *ptr
, size_t size
, SCM port
)
977 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
978 scm_t_ptob_descriptor
*ptob
= &scm_ptobs
[SCM_PTOBNUM (port
)];
980 if (pt
->rw_active
== SCM_PORT_READ
)
981 scm_end_input (port
);
983 ptob
->write (port
, ptr
, size
);
985 for (; size
; ptr
++, size
--) {
989 else if (*ptr
== '\t') {
998 pt
->rw_active
= SCM_PORT_WRITE
;
1003 * Used by an application to read arbitrary number of bytes from an
1004 * SCM port. Same semantics as libc read, except that scm_c_read only
1005 * returns less than SIZE bytes if at end-of-file.
1007 * Warning: Doesn't update port line and column counts! */
1010 scm_c_read (SCM port
, void *buffer
, size_t size
)
1012 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
1013 size_t n_read
= 0, n_available
;
1015 if (pt
->rw_active
== SCM_PORT_WRITE
)
1016 scm_ptobs
[SCM_PTOBNUM (port
)].flush (port
);
1019 pt
->rw_active
= SCM_PORT_READ
;
1021 if (SCM_READ_BUFFER_EMPTY_P (pt
))
1023 if (scm_fill_input (port
) == EOF
)
1027 n_available
= pt
->read_end
- pt
->read_pos
;
1029 while (n_available
< size
)
1031 memcpy (buffer
, pt
->read_pos
, n_available
);
1032 buffer
= (char *) buffer
+ n_available
;
1033 pt
->read_pos
+= n_available
;
1034 n_read
+= n_available
;
1036 if (SCM_READ_BUFFER_EMPTY_P (pt
))
1038 if (scm_fill_input (port
) == EOF
)
1042 size
-= n_available
;
1043 n_available
= pt
->read_end
- pt
->read_pos
;
1046 memcpy (buffer
, pt
->read_pos
, size
);
1047 pt
->read_pos
+= size
;
1049 return n_read
+ size
;
1054 * Used by an application to write arbitrary number of bytes to an SCM
1055 * port. Similar semantics as libc write. However, unlike libc
1056 * write, scm_c_write writes the requested number of bytes and has no
1059 * Warning: Doesn't update port line and column counts!
1063 scm_c_write (SCM port
, const void *ptr
, size_t size
)
1065 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
1066 scm_t_ptob_descriptor
*ptob
= &scm_ptobs
[SCM_PTOBNUM (port
)];
1068 if (pt
->rw_active
== SCM_PORT_READ
)
1069 scm_end_input (port
);
1071 ptob
->write (port
, ptr
, size
);
1074 pt
->rw_active
= SCM_PORT_WRITE
;
1078 scm_flush (SCM port
)
1080 long i
= SCM_PTOBNUM (port
);
1081 (scm_ptobs
[i
].flush
) (port
);
1085 scm_end_input (SCM port
)
1088 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
1090 if (pt
->read_buf
== pt
->putback_buf
)
1092 offset
= pt
->read_end
- pt
->read_pos
;
1093 pt
->read_buf
= pt
->saved_read_buf
;
1094 pt
->read_pos
= pt
->saved_read_pos
;
1095 pt
->read_end
= pt
->saved_read_end
;
1096 pt
->read_buf_size
= pt
->saved_read_buf_size
;
1101 scm_ptobs
[SCM_PTOBNUM (port
)].end_input (port
, offset
);
1108 scm_ungetc (int c
, SCM port
)
1109 #define FUNC_NAME "scm_ungetc"
1111 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
1113 if (pt
->read_buf
== pt
->putback_buf
)
1114 /* already using the put-back buffer. */
1116 /* enlarge putback_buf if necessary. */
1117 if (pt
->read_end
== pt
->read_buf
+ pt
->read_buf_size
1118 && pt
->read_buf
== pt
->read_pos
)
1120 size_t new_size
= pt
->read_buf_size
* 2;
1121 unsigned char *tmp
= (unsigned char *)
1122 scm_gc_realloc (pt
->putback_buf
, pt
->read_buf_size
, new_size
,
1125 pt
->read_pos
= pt
->read_buf
= pt
->putback_buf
= tmp
;
1126 pt
->read_end
= pt
->read_buf
+ pt
->read_buf_size
;
1127 pt
->read_buf_size
= pt
->putback_buf_size
= new_size
;
1130 /* shift any existing bytes to buffer + 1. */
1131 if (pt
->read_pos
== pt
->read_end
)
1132 pt
->read_end
= pt
->read_buf
+ 1;
1133 else if (pt
->read_pos
!= pt
->read_buf
+ 1)
1135 int count
= pt
->read_end
- pt
->read_pos
;
1137 memmove (pt
->read_buf
+ 1, pt
->read_pos
, count
);
1138 pt
->read_end
= pt
->read_buf
+ 1 + count
;
1141 pt
->read_pos
= pt
->read_buf
;
1144 /* switch to the put-back buffer. */
1146 if (pt
->putback_buf
== NULL
)
1149 = (unsigned char *) scm_gc_malloc (SCM_INITIAL_PUTBACK_BUF_SIZE
,
1151 pt
->putback_buf_size
= SCM_INITIAL_PUTBACK_BUF_SIZE
;
1154 pt
->saved_read_buf
= pt
->read_buf
;
1155 pt
->saved_read_pos
= pt
->read_pos
;
1156 pt
->saved_read_end
= pt
->read_end
;
1157 pt
->saved_read_buf_size
= pt
->read_buf_size
;
1159 pt
->read_pos
= pt
->read_buf
= pt
->putback_buf
;
1160 pt
->read_end
= pt
->read_buf
+ 1;
1161 pt
->read_buf_size
= pt
->putback_buf_size
;
1167 pt
->rw_active
= SCM_PORT_READ
;
1171 /* What should col be in this case?
1172 * We'll leave it at -1.
1174 SCM_LINUM (port
) -= 1;
1183 scm_ungets (const char *s
, int n
, SCM port
)
1185 /* This is simple minded and inefficient, but unreading strings is
1186 * probably not a common operation, and remember that line and
1187 * column numbers have to be handled...
1189 * Please feel free to write an optimized version!
1192 scm_ungetc (s
[n
], port
);
1196 SCM_DEFINE (scm_peek_char
, "peek-char", 0, 1, 0,
1198 "Return the next character available from @var{port},\n"
1199 "@emph{without} updating @var{port} to point to the following\n"
1200 "character. If no more characters are available, the\n"
1201 "end-of-file object is returned.@footnote{The value returned by\n"
1202 "a call to @code{peek-char} is the same as the value that would\n"
1203 "have been returned by a call to @code{read-char} on the same\n"
1204 "port. The only difference is that the very next call to\n"
1205 "@code{read-char} or @code{peek-char} on that @var{port} will\n"
1206 "return the value returned by the preceding call to\n"
1207 "@code{peek-char}. In particular, a call to @code{peek-char} on\n"
1208 "an interactive port will hang waiting for input whenever a call\n"
1209 "to @code{read-char} would have hung.}")
1210 #define FUNC_NAME s_scm_peek_char
1213 if (SCM_UNBNDP (port
))
1216 SCM_VALIDATE_OPINPORT (1, port
);
1217 c
= scm_getc (port
);
1220 scm_ungetc (c
, port
);
1221 return SCM_MAKE_CHAR (c
);
1225 SCM_DEFINE (scm_unread_char
, "unread-char", 1, 1, 0,
1226 (SCM cobj
, SCM port
),
1227 "Place @var{char} in @var{port} so that it will be read by the\n"
1228 "next read operation. If called multiple times, the unread characters\n"
1229 "will be read again in last-in first-out order. If @var{port} is\n"
1230 "not supplied, the current input port is used.")
1231 #define FUNC_NAME s_scm_unread_char
1235 SCM_VALIDATE_CHAR (1, cobj
);
1236 if (SCM_UNBNDP (port
))
1239 SCM_VALIDATE_OPINPORT (2, port
);
1241 c
= SCM_CHAR (cobj
);
1243 scm_ungetc (c
, port
);
1248 SCM_DEFINE (scm_unread_string
, "unread-string", 2, 0, 0,
1249 (SCM str
, SCM port
),
1250 "Place the string @var{str} in @var{port} so that its characters will be\n"
1251 "read in subsequent read operations. If called multiple times, the\n"
1252 "unread characters will be read again in last-in first-out order. If\n"
1253 "@var{port} is not supplied, the current-input-port is used.")
1254 #define FUNC_NAME s_scm_unread_string
1256 SCM_VALIDATE_STRING (1, str
);
1257 if (SCM_UNBNDP (port
))
1260 SCM_VALIDATE_OPINPORT (2, port
);
1262 scm_ungets (SCM_STRING_CHARS (str
), SCM_STRING_LENGTH (str
), port
);
1268 SCM_DEFINE (scm_seek
, "seek", 3, 0, 0,
1269 (SCM fd_port
, SCM offset
, SCM whence
),
1270 "Sets the current position of @var{fd/port} to the integer\n"
1271 "@var{offset}, which is interpreted according to the value of\n"
1274 "One of the following variables should be supplied for\n"
1276 "@defvar SEEK_SET\n"
1277 "Seek from the beginning of the file.\n"
1279 "@defvar SEEK_CUR\n"
1280 "Seek from the current position.\n"
1282 "@defvar SEEK_END\n"
1283 "Seek from the end of the file.\n"
1285 "If @var{fd/port} is a file descriptor, the underlying system\n"
1286 "call is @code{lseek}. @var{port} may be a string port.\n"
1288 "The value returned is the new position in the file. This means\n"
1289 "that the current position of a port can be obtained using:\n"
1291 "(seek port 0 SEEK_CUR)\n"
1293 #define FUNC_NAME s_scm_seek
1299 fd_port
= SCM_COERCE_OUTPORT (fd_port
);
1301 off
= SCM_NUM2LONG (2, offset
);
1302 SCM_VALIDATE_INUM_COPY (3, whence
, how
);
1303 if (how
!= SEEK_SET
&& how
!= SEEK_CUR
&& how
!= SEEK_END
)
1304 SCM_OUT_OF_RANGE (3, whence
);
1305 if (SCM_OPPORTP (fd_port
))
1307 scm_t_ptob_descriptor
*ptob
= scm_ptobs
+ SCM_PTOBNUM (fd_port
);
1310 SCM_MISC_ERROR ("port is not seekable",
1311 scm_cons (fd_port
, SCM_EOL
));
1313 rv
= ptob
->seek (fd_port
, off
, how
);
1315 else /* file descriptor?. */
1317 SCM_VALIDATE_INUM (1, fd_port
);
1318 rv
= lseek (SCM_INUM (fd_port
), off
, how
);
1322 return scm_long2num (rv
);
1327 /* Define this function since it is not supported under Windows. */
1328 static int truncate (char *file
, int length
)
1331 if ((fdes
= open (file
, O_BINARY
| O_WRONLY
)) != -1)
1333 ret
= chsize (fdes
, length
);
1338 #endif /* __MINGW32__ */
1340 SCM_DEFINE (scm_truncate_file
, "truncate-file", 1, 1, 0,
1341 (SCM object
, SCM length
),
1342 "Truncates the object referred to by @var{object} to at most\n"
1343 "@var{length} bytes. @var{object} can be a string containing a\n"
1344 "file name or an integer file descriptor or a port.\n"
1345 "@var{length} may be omitted if @var{object} is not a file name,\n"
1346 "in which case the truncation occurs at the current port.\n"
1347 "position. The return value is unspecified.")
1348 #define FUNC_NAME s_scm_truncate_file
1353 /* object can be a port, fdes or filename. */
1355 if (SCM_UNBNDP (length
))
1357 /* must supply length if object is a filename. */
1358 if (SCM_STRINGP (object
))
1359 SCM_MISC_ERROR("must supply length if OBJECT is a filename", SCM_EOL
);
1361 length
= scm_seek (object
, SCM_INUM0
, SCM_MAKINUM (SEEK_CUR
));
1363 c_length
= SCM_NUM2LONG (2, length
);
1365 SCM_MISC_ERROR ("negative offset", SCM_EOL
);
1367 object
= SCM_COERCE_OUTPORT (object
);
1368 if (SCM_INUMP (object
))
1370 SCM_SYSCALL (rv
= ftruncate (SCM_INUM (object
), c_length
));
1372 else if (SCM_OPOUTPORTP (object
))
1374 scm_t_port
*pt
= SCM_PTAB_ENTRY (object
);
1375 scm_t_ptob_descriptor
*ptob
= scm_ptobs
+ SCM_PTOBNUM (object
);
1377 if (!ptob
->truncate
)
1378 SCM_MISC_ERROR ("port is not truncatable", SCM_EOL
);
1379 if (pt
->rw_active
== SCM_PORT_READ
)
1380 scm_end_input (object
);
1381 else if (pt
->rw_active
== SCM_PORT_WRITE
)
1382 ptob
->flush (object
);
1384 ptob
->truncate (object
, c_length
);
1389 SCM_VALIDATE_STRING (1, object
);
1390 SCM_SYSCALL (rv
= truncate (SCM_STRING_CHARS (object
), c_length
));
1394 return SCM_UNSPECIFIED
;
1398 SCM_DEFINE (scm_port_line
, "port-line", 1, 0, 0,
1400 "Return the current line number for @var{port}.")
1401 #define FUNC_NAME s_scm_port_line
1403 port
= SCM_COERCE_OUTPORT (port
);
1404 SCM_VALIDATE_OPENPORT (1, port
);
1405 return SCM_MAKINUM (SCM_LINUM (port
));
1409 SCM_DEFINE (scm_set_port_line_x
, "set-port-line!", 2, 0, 0,
1410 (SCM port
, SCM line
),
1411 "Set the current line number for @var{port} to @var{line}.")
1412 #define FUNC_NAME s_scm_set_port_line_x
1414 port
= SCM_COERCE_OUTPORT (port
);
1415 SCM_VALIDATE_OPENPORT (1, port
);
1416 SCM_VALIDATE_INUM (2, line
);
1417 SCM_PTAB_ENTRY (port
)->line_number
= SCM_INUM (line
);
1418 return SCM_UNSPECIFIED
;
1422 SCM_DEFINE (scm_port_column
, "port-column", 1, 0, 0,
1424 "@deffnx {Scheme Procedure} port-line port\n"
1425 "Return the current column number or line number of @var{port},\n"
1426 "using the current input port if none is specified. If the number is\n"
1427 "unknown, the result is #f. Otherwise, the result is a 0-origin integer\n"
1428 "- i.e. the first character of the first line is line 0, column 0.\n"
1429 "(However, when you display a file position, for example in an error\n"
1430 "message, we recommend you add 1 to get 1-origin integers. This is\n"
1431 "because lines and column numbers traditionally start with 1, and that is\n"
1432 "what non-programmers will find most natural.)")
1433 #define FUNC_NAME s_scm_port_column
1435 port
= SCM_COERCE_OUTPORT (port
);
1436 SCM_VALIDATE_OPENPORT (1, port
);
1437 return SCM_MAKINUM (SCM_COL (port
));
1441 SCM_DEFINE (scm_set_port_column_x
, "set-port-column!", 2, 0, 0,
1442 (SCM port
, SCM column
),
1443 "@deffnx {Scheme Procedure} set-port-line! port line\n"
1444 "Set the current column or line number of @var{port}, using the\n"
1445 "current input port if none is specified.")
1446 #define FUNC_NAME s_scm_set_port_column_x
1448 port
= SCM_COERCE_OUTPORT (port
);
1449 SCM_VALIDATE_OPENPORT (1, port
);
1450 SCM_VALIDATE_INUM (2, column
);
1451 SCM_PTAB_ENTRY (port
)->column_number
= SCM_INUM (column
);
1452 return SCM_UNSPECIFIED
;
1456 SCM_DEFINE (scm_port_filename
, "port-filename", 1, 0, 0,
1458 "Return the filename associated with @var{port}. This function returns\n"
1459 "the strings \"standard input\", \"standard output\" and \"standard error\"\n"
1460 "when called on the current input, output and error ports respectively.")
1461 #define FUNC_NAME s_scm_port_filename
1463 port
= SCM_COERCE_OUTPORT (port
);
1464 SCM_VALIDATE_OPENPORT (1, port
);
1465 return SCM_FILENAME (port
);
1469 SCM_DEFINE (scm_set_port_filename_x
, "set-port-filename!", 2, 0, 0,
1470 (SCM port
, SCM filename
),
1471 "Change the filename associated with @var{port}, using the current input\n"
1472 "port if none is specified. Note that this does not change the port's\n"
1473 "source of data, but only the value that is returned by\n"
1474 "@code{port-filename} and reported in diagnostic output.")
1475 #define FUNC_NAME s_scm_set_port_filename_x
1477 port
= SCM_COERCE_OUTPORT (port
);
1478 SCM_VALIDATE_OPENPORT (1, port
);
1479 /* We allow the user to set the filename to whatever he likes. */
1480 SCM_SET_FILENAME (port
, filename
);
1481 return SCM_UNSPECIFIED
;
1486 extern char * ttyname();
1490 scm_print_port_mode (SCM exp
, SCM port
)
1492 scm_puts (SCM_CLOSEDP (exp
)
1494 : (SCM_RDNG
& SCM_CELL_WORD_0 (exp
)
1495 ? (SCM_WRTNG
& SCM_CELL_WORD_0 (exp
)
1498 : (SCM_WRTNG
& SCM_CELL_WORD_0 (exp
)
1505 scm_port_print (SCM exp
, SCM port
, scm_print_state
*pstate SCM_UNUSED
)
1507 char *type
= SCM_PTOBNAME (SCM_PTOBNUM (exp
));
1510 scm_puts ("#<", port
);
1511 scm_print_port_mode (exp
, port
);
1512 scm_puts (type
, port
);
1513 scm_putc (' ', port
);
1514 scm_intprint (SCM_CELL_WORD_1 (exp
), 16, port
);
1515 scm_putc ('>', port
);
1520 scm_ports_prehistory ()
1523 scm_ptobs
= (scm_t_ptob_descriptor
*) scm_malloc (sizeof (scm_t_ptob_descriptor
));
1530 scm_t_bits scm_tc16_void_port
= 0;
1532 static int fill_input_void_port (SCM port SCM_UNUSED
)
1538 write_void_port (SCM port SCM_UNUSED
,
1539 const void *data SCM_UNUSED
,
1540 size_t size SCM_UNUSED
)
1545 scm_void_port (char *mode_str
)
1549 int mode_bits
= scm_mode_bits (mode_str
);
1550 SCM answer
= scm_new_port_table_entry (scm_tc16_void_port
);
1551 scm_t_port
* pt
= SCM_PTAB_ENTRY(answer
);
1553 scm_port_non_buffer (pt
);
1555 SCM_SETSTREAM (answer
, 0);
1556 SCM_SET_CELL_TYPE (answer
, scm_tc16_void_port
| mode_bits
);
1562 SCM_DEFINE (scm_sys_make_void_port
, "%make-void-port", 1, 0, 0,
1564 "Create and return a new void port. A void port acts like\n"
1565 "@file{/dev/null}. The @var{mode} argument\n"
1566 "specifies the input/output modes for this port: see the\n"
1567 "documentation for @code{open-file} in @ref{File Ports}.")
1568 #define FUNC_NAME s_scm_sys_make_void_port
1570 SCM_VALIDATE_STRING (1, mode
);
1571 return scm_void_port (SCM_STRING_CHARS (mode
));
1576 /* Initialization. */
1581 /* lseek() symbols. */
1582 scm_c_define ("SEEK_SET", SCM_MAKINUM (SEEK_SET
));
1583 scm_c_define ("SEEK_CUR", SCM_MAKINUM (SEEK_CUR
));
1584 scm_c_define ("SEEK_END", SCM_MAKINUM (SEEK_END
));
1586 scm_tc16_void_port
= scm_make_port_type ("void", fill_input_void_port
,
1588 #include "libguile/ports.x"