1 /* Copyright (C) 1995,1996,1997,1998,1999,2000,2001, 2003, 2004, 2006 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
22 #define _LARGEFILE64_SOURCE /* ask for stat64 etc */
33 #include "libguile/_scm.h"
34 #include "libguile/async.h"
35 #include "libguile/eval.h"
36 #include "libguile/objects.h"
37 #include "libguile/goops.h"
38 #include "libguile/smob.h"
39 #include "libguile/chars.h"
40 #include "libguile/dynwind.h"
42 #include "libguile/keywords.h"
43 #include "libguile/root.h"
44 #include "libguile/strings.h"
45 #include "libguile/mallocs.h"
46 #include "libguile/validate.h"
47 #include "libguile/ports.h"
48 #include "libguile/vectors.h"
49 #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 tmp
= (char *) scm_gc_realloc ((char *) scm_ptobs
,
128 scm_numptob
* sizeof (scm_t_ptob_descriptor
),
130 * sizeof (scm_t_ptob_descriptor
),
134 scm_ptobs
= (scm_t_ptob_descriptor
*) tmp
;
136 scm_ptobs
[scm_numptob
].name
= name
;
137 scm_ptobs
[scm_numptob
].mark
= 0;
138 scm_ptobs
[scm_numptob
].free
= scm_port_free0
;
139 scm_ptobs
[scm_numptob
].print
= scm_port_print
;
140 scm_ptobs
[scm_numptob
].equalp
= 0;
141 scm_ptobs
[scm_numptob
].close
= 0;
143 scm_ptobs
[scm_numptob
].write
= write
;
144 scm_ptobs
[scm_numptob
].flush
= flush_port_default
;
146 scm_ptobs
[scm_numptob
].end_input
= end_input_default
;
147 scm_ptobs
[scm_numptob
].fill_input
= fill_input
;
148 scm_ptobs
[scm_numptob
].input_waiting
= 0;
150 scm_ptobs
[scm_numptob
].seek
= 0;
151 scm_ptobs
[scm_numptob
].truncate
= 0;
155 SCM_CRITICAL_SECTION_END
;
159 scm_memory_error ("scm_make_port_type");
161 /* Make a class object if Goops is present */
163 scm_make_port_classes (scm_numptob
- 1, SCM_PTOBNAME (scm_numptob
- 1));
164 return scm_tc7_port
+ (scm_numptob
- 1) * 256;
168 scm_set_port_mark (scm_t_bits tc
, SCM (*mark
) (SCM
))
170 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].mark
= mark
;
174 scm_set_port_free (scm_t_bits tc
, size_t (*free
) (SCM
))
176 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].free
= free
;
180 scm_set_port_print (scm_t_bits tc
, int (*print
) (SCM exp
, SCM port
,
181 scm_print_state
*pstate
))
183 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].print
= print
;
187 scm_set_port_equalp (scm_t_bits tc
, SCM (*equalp
) (SCM
, SCM
))
189 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].equalp
= equalp
;
193 scm_set_port_flush (scm_t_bits tc
, void (*flush
) (SCM port
))
195 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].flush
= flush
;
199 scm_set_port_end_input (scm_t_bits tc
, void (*end_input
) (SCM port
, int offset
))
201 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].end_input
= end_input
;
205 scm_set_port_close (scm_t_bits tc
, int (*close
) (SCM
))
207 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].close
= close
;
211 scm_set_port_seek (scm_t_bits tc
, off_t (*seek
) (SCM port
,
215 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].seek
= seek
;
219 scm_set_port_truncate (scm_t_bits tc
, void (*truncate
) (SCM port
, off_t length
))
221 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].truncate
= truncate
;
225 scm_set_port_input_waiting (scm_t_bits tc
, int (*input_waiting
) (SCM
))
227 scm_ptobs
[SCM_TC2PTOBNUM (tc
)].input_waiting
= input_waiting
;
232 SCM_DEFINE (scm_char_ready_p
, "char-ready?", 0, 1, 0,
234 "Return @code{#t} if a character is ready on input @var{port}\n"
235 "and return @code{#f} otherwise. If @code{char-ready?} returns\n"
236 "@code{#t} then the next @code{read-char} operation on\n"
237 "@var{port} is guaranteed not to hang. If @var{port} is a file\n"
238 "port at end of file then @code{char-ready?} returns @code{#t}.\n"
240 "@code{char-ready?} exists to make it possible for a\n"
241 "program to accept characters from interactive ports without\n"
242 "getting stuck waiting for input. Any input editors associated\n"
243 "with such ports must make sure that characters whose existence\n"
244 "has been asserted by @code{char-ready?} cannot be rubbed out.\n"
245 "If @code{char-ready?} were to return @code{#f} at end of file,\n"
246 "a port at end of file would be indistinguishable from an\n"
247 "interactive port that has no ready characters.")
248 #define FUNC_NAME s_scm_char_ready_p
252 if (SCM_UNBNDP (port
))
253 port
= scm_current_input_port ();
255 SCM_VALIDATE_OPINPORT (1, port
);
257 pt
= SCM_PTAB_ENTRY (port
);
259 /* if the current read buffer is filled, or the
260 last pushed-back char has been read and the saved buffer is
261 filled, result is true. */
262 if (pt
->read_pos
< pt
->read_end
263 || (pt
->read_buf
== pt
->putback_buf
264 && pt
->saved_read_pos
< pt
->saved_read_end
))
268 scm_t_ptob_descriptor
*ptob
= &scm_ptobs
[SCM_PTOBNUM (port
)];
270 if (ptob
->input_waiting
)
271 return scm_from_bool(ptob
->input_waiting (port
));
278 /* move up to read_len chars from port's putback and/or read buffers
279 into memory starting at dest. returns the number of chars moved. */
280 size_t scm_take_from_input_buffers (SCM port
, char *dest
, size_t read_len
)
282 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
283 size_t chars_read
= 0;
284 size_t from_buf
= min (pt
->read_end
- pt
->read_pos
, read_len
);
288 memcpy (dest
, pt
->read_pos
, from_buf
);
289 pt
->read_pos
+= from_buf
;
290 chars_read
+= from_buf
;
291 read_len
-= from_buf
;
295 /* if putback was active, try the real input buffer too. */
296 if (pt
->read_buf
== pt
->putback_buf
)
298 from_buf
= min (pt
->saved_read_end
- pt
->saved_read_pos
, read_len
);
301 memcpy (dest
, pt
->saved_read_pos
, from_buf
);
302 pt
->saved_read_pos
+= from_buf
;
303 chars_read
+= from_buf
;
309 /* Clear a port's read buffers, returning the contents. */
310 SCM_DEFINE (scm_drain_input
, "drain-input", 1, 0, 0,
312 "This procedure clears a port's input buffers, similar\n"
313 "to the way that force-output clears the output buffer. The\n"
314 "contents of the buffers are returned as a single string, e.g.,\n"
317 "(define p (open-input-file ...))\n"
318 "(drain-input p) => empty string, nothing buffered yet.\n"
319 "(unread-char (read-char p) p)\n"
320 "(drain-input p) => initial chars from p, up to the buffer size.\n"
322 "Draining the buffers may be useful for cleanly finishing\n"
323 "buffered I/O so that the file descriptor can be used directly\n"
324 "for further input.")
325 #define FUNC_NAME s_scm_drain_input
332 SCM_VALIDATE_OPINPORT (1, port
);
333 pt
= SCM_PTAB_ENTRY (port
);
335 count
= pt
->read_end
- pt
->read_pos
;
336 if (pt
->read_buf
== pt
->putback_buf
)
337 count
+= pt
->saved_read_end
- pt
->saved_read_pos
;
339 result
= scm_i_make_string (count
, &data
);
340 scm_take_from_input_buffers (port
, data
, count
);
346 /* Standard ports --- current input, output, error, and more(!). */
348 static SCM cur_inport_fluid
;
349 static SCM cur_outport_fluid
;
350 static SCM cur_errport_fluid
;
351 static SCM cur_loadport_fluid
;
353 SCM_DEFINE (scm_current_input_port
, "current-input-port", 0, 0, 0,
355 "Return the current input port. This is the default port used\n"
356 "by many input procedures. Initially, @code{current-input-port}\n"
357 "returns the @dfn{standard input} in Unix and C terminology.")
358 #define FUNC_NAME s_scm_current_input_port
360 return scm_fluid_ref (cur_inport_fluid
);
364 SCM_DEFINE (scm_current_output_port
, "current-output-port", 0, 0, 0,
366 "Return the current output port. This is the default port used\n"
367 "by many output procedures. Initially,\n"
368 "@code{current-output-port} returns the @dfn{standard output} in\n"
369 "Unix and C terminology.")
370 #define FUNC_NAME s_scm_current_output_port
372 return scm_fluid_ref (cur_outport_fluid
);
376 SCM_DEFINE (scm_current_error_port
, "current-error-port", 0, 0, 0,
378 "Return the port to which errors and warnings should be sent (the\n"
379 "@dfn{standard error} in Unix and C terminology).")
380 #define FUNC_NAME s_scm_current_error_port
382 return scm_fluid_ref (cur_errport_fluid
);
386 SCM_DEFINE (scm_current_load_port
, "current-load-port", 0, 0, 0,
388 "Return the current-load-port.\n"
389 "The load port is used internally by @code{primitive-load}.")
390 #define FUNC_NAME s_scm_current_load_port
392 return scm_fluid_ref (cur_loadport_fluid
);
396 SCM_DEFINE (scm_set_current_input_port
, "set-current-input-port", 1, 0, 0,
398 "@deffnx {Scheme Procedure} set-current-output-port port\n"
399 "@deffnx {Scheme Procedure} set-current-error-port port\n"
400 "Change the ports returned by @code{current-input-port},\n"
401 "@code{current-output-port} and @code{current-error-port}, respectively,\n"
402 "so that they use the supplied @var{port} for input or output.")
403 #define FUNC_NAME s_scm_set_current_input_port
405 SCM oinp
= scm_fluid_ref (cur_inport_fluid
);
406 SCM_VALIDATE_OPINPORT (1, port
);
407 scm_fluid_set_x (cur_inport_fluid
, port
);
413 SCM_DEFINE (scm_set_current_output_port
, "set-current-output-port", 1, 0, 0,
415 "Set the current default output port to @var{port}.")
416 #define FUNC_NAME s_scm_set_current_output_port
418 SCM ooutp
= scm_fluid_ref (cur_outport_fluid
);
419 port
= SCM_COERCE_OUTPORT (port
);
420 SCM_VALIDATE_OPOUTPORT (1, port
);
421 scm_fluid_set_x (cur_outport_fluid
, port
);
427 SCM_DEFINE (scm_set_current_error_port
, "set-current-error-port", 1, 0, 0,
429 "Set the current default error port to @var{port}.")
430 #define FUNC_NAME s_scm_set_current_error_port
432 SCM oerrp
= scm_fluid_ref (cur_errport_fluid
);
433 port
= SCM_COERCE_OUTPORT (port
);
434 SCM_VALIDATE_OPOUTPORT (1, port
);
435 scm_fluid_set_x (cur_errport_fluid
, port
);
441 scm_dynwind_current_input_port (SCM port
)
442 #define FUNC_NAME NULL
444 SCM_VALIDATE_OPINPORT (1, port
);
445 scm_dynwind_fluid (cur_inport_fluid
, port
);
450 scm_dynwind_current_output_port (SCM port
)
451 #define FUNC_NAME NULL
453 port
= SCM_COERCE_OUTPORT (port
);
454 SCM_VALIDATE_OPOUTPORT (1, port
);
455 scm_dynwind_fluid (cur_outport_fluid
, port
);
460 scm_dynwind_current_error_port (SCM port
)
461 #define FUNC_NAME NULL
463 port
= SCM_COERCE_OUTPORT (port
);
464 SCM_VALIDATE_OPOUTPORT (1, port
);
465 scm_dynwind_fluid (cur_errport_fluid
, port
);
470 scm_i_dynwind_current_load_port (SCM port
)
472 scm_dynwind_fluid (cur_loadport_fluid
, port
);
476 /* The port table --- an array of pointers to ports. */
478 scm_t_port
**scm_i_port_table
= NULL
;
480 long scm_i_port_table_size
= 0; /* Number of ports in SCM_I_PORT_TABLE. */
481 long scm_i_port_table_room
= 20; /* Actual size of the array. */
483 scm_i_pthread_mutex_t scm_i_port_table_mutex
= SCM_I_PTHREAD_MUTEX_INITIALIZER
;
485 /* This function is not and should not be thread safe. */
488 scm_new_port_table_entry (scm_t_bits tag
)
489 #define FUNC_NAME "scm_new_port_table_entry"
492 We initialize the cell to empty, this is in case scm_gc_calloc
493 triggers GC ; we don't want the GC to scan a half-finished Z.
496 SCM z
= scm_cons (SCM_EOL
, SCM_EOL
);
497 scm_t_port
*entry
= (scm_t_port
*) scm_gc_calloc (sizeof (scm_t_port
), "port");
498 if (scm_i_port_table_size
== scm_i_port_table_room
)
500 /* initial malloc is in gc.c. this doesn't use scm_gc_malloc etc.,
501 since it can never be freed during gc. */
502 /* XXX (Ludo): Why not do it actually? */
503 size_t new_size
= scm_i_port_table_room
* 2;
504 void *newt
= scm_gc_realloc ((char *) scm_i_port_table
,
505 scm_i_port_table_room
* sizeof (scm_t_port
*),
506 new_size
* sizeof (scm_t_port
*),
508 scm_i_port_table
= (scm_t_port
**) newt
;
509 scm_i_port_table_room
= new_size
;
512 entry
->entry
= scm_i_port_table_size
;
514 entry
->file_name
= SCM_BOOL_F
;
515 entry
->rw_active
= SCM_PORT_NEITHER
;
517 scm_i_port_table
[scm_i_port_table_size
] = entry
;
518 scm_i_port_table_size
++;
521 SCM_SET_CELL_TYPE(z
, tag
);
522 SCM_SETPTAB_ENTRY(z
, entry
);
528 #if SCM_ENABLE_DEPRECATED==1
530 scm_add_to_port_table (SCM port
)
532 SCM z
= scm_new_port_table_entry (scm_tc7_port
);
533 scm_t_port
* pt
= SCM_PTAB_ENTRY(z
);
536 SCM_SETCAR(z
, SCM_EOL
);
537 SCM_SETCDR(z
, SCM_EOL
);
538 SCM_SETPTAB_ENTRY (port
, pt
);
544 /* Remove a port from the table and destroy it. */
546 /* This function is not and should not be thread safe. */
549 scm_remove_from_port_table (SCM port
)
550 #define FUNC_NAME "scm_remove_from_port_table"
552 scm_t_port
*p
= SCM_PTAB_ENTRY (port
);
555 if (i
>= scm_i_port_table_size
)
556 SCM_MISC_ERROR ("Port not in table: ~S", scm_list_1 (port
));
558 scm_gc_free (p
->putback_buf
, p
->putback_buf_size
, "putback buffer");
559 scm_gc_free (p
, sizeof (scm_t_port
), "port");
560 /* Since we have just freed slot i we can shrink the table by moving
561 the last entry to that slot... */
562 if (i
< scm_i_port_table_size
- 1)
564 scm_i_port_table
[i
] = scm_i_port_table
[scm_i_port_table_size
- 1];
565 scm_i_port_table
[i
]->entry
= i
;
567 SCM_SETPTAB_ENTRY (port
, 0);
568 scm_i_port_table_size
--;
574 /* Functions for debugging. */
576 SCM_DEFINE (scm_pt_size
, "pt-size", 0, 0, 0,
578 "Return the number of ports in the port table. @code{pt-size}\n"
579 "is only included in @code{--enable-guile-debug} builds.")
580 #define FUNC_NAME s_scm_pt_size
582 return scm_from_int (scm_i_port_table_size
);
586 SCM_DEFINE (scm_pt_member
, "pt-member", 1, 0, 0,
588 "Return the port at @var{index} in the port table.\n"
589 "@code{pt-member} is only included in\n"
590 "@code{--enable-guile-debug} builds.")
591 #define FUNC_NAME s_scm_pt_member
593 size_t i
= scm_to_size_t (index
);
594 if (i
>= scm_i_port_table_size
)
597 return scm_i_port_table
[i
]->port
;
603 scm_port_non_buffer (scm_t_port
*pt
)
605 pt
->read_pos
= pt
->read_buf
= pt
->read_end
= &pt
->shortbuf
;
606 pt
->write_buf
= pt
->write_pos
= &pt
->shortbuf
;
607 pt
->read_buf_size
= pt
->write_buf_size
= 1;
608 pt
->write_end
= pt
->write_buf
+ pt
->write_buf_size
;
612 /* Revealed counts --- an oddity inherited from SCSH. */
614 /* Find a port in the table and return its revealed count.
615 Also used by the garbage collector.
619 scm_revealed_count (SCM port
)
621 return SCM_REVEALED(port
);
626 /* Return the revealed count for a port. */
628 SCM_DEFINE (scm_port_revealed
, "port-revealed", 1, 0, 0,
630 "Return the revealed count for @var{port}.")
631 #define FUNC_NAME s_scm_port_revealed
633 port
= SCM_COERCE_OUTPORT (port
);
634 SCM_VALIDATE_OPENPORT (1, port
);
635 return scm_from_int (scm_revealed_count (port
));
639 /* Set the revealed count for a port. */
640 SCM_DEFINE (scm_set_port_revealed_x
, "set-port-revealed!", 2, 0, 0,
641 (SCM port
, SCM rcount
),
642 "Sets the revealed count for a port to a given value.\n"
643 "The return value is unspecified.")
644 #define FUNC_NAME s_scm_set_port_revealed_x
646 port
= SCM_COERCE_OUTPORT (port
);
647 SCM_VALIDATE_OPENPORT (1, port
);
648 SCM_REVEALED (port
) = scm_to_int (rcount
);
649 return SCM_UNSPECIFIED
;
655 /* Retrieving a port's mode. */
657 /* Return the flags that characterize a port based on the mode
658 * string used to open a file for that port.
660 * See PORT FLAGS in scm.h
664 scm_i_mode_bits_n (const char *modes
, size_t n
)
667 | (memchr (modes
, 'r', n
) || memchr (modes
, '+', n
) ? SCM_RDNG
: 0)
668 | ( memchr (modes
, 'w', n
)
669 || memchr (modes
, 'a', n
)
670 || memchr (modes
, '+', n
) ? SCM_WRTNG
: 0)
671 | (memchr (modes
, '0', n
) ? SCM_BUF0
: 0)
672 | (memchr (modes
, 'l', n
) ? SCM_BUFLINE
: 0));
676 scm_mode_bits (char *modes
)
678 return scm_i_mode_bits_n (modes
, strlen (modes
));
682 scm_i_mode_bits (SCM modes
)
686 if (!scm_is_string (modes
))
687 scm_wrong_type_arg_msg (NULL
, 0, modes
, "string");
689 bits
= scm_i_mode_bits_n (scm_i_string_chars (modes
),
690 scm_i_string_length (modes
));
691 scm_remember_upto_here_1 (modes
);
695 /* Return the mode flags from an open port.
696 * Some modes such as "append" are only used when opening
697 * a file and are not returned here. */
699 SCM_DEFINE (scm_port_mode
, "port-mode", 1, 0, 0,
701 "Return the port modes associated with the open port @var{port}.\n"
702 "These will not necessarily be identical to the modes used when\n"
703 "the port was opened, since modes such as \"append\" which are\n"
704 "used only during port creation are not retained.")
705 #define FUNC_NAME s_scm_port_mode
710 port
= SCM_COERCE_OUTPORT (port
);
711 SCM_VALIDATE_OPPORT (1, port
);
712 if (SCM_CELL_WORD_0 (port
) & SCM_RDNG
) {
713 if (SCM_CELL_WORD_0 (port
) & SCM_WRTNG
)
714 strcpy (modes
, "r+");
718 else if (SCM_CELL_WORD_0 (port
) & SCM_WRTNG
)
720 if (SCM_CELL_WORD_0 (port
) & SCM_BUF0
)
722 return scm_from_locale_string (modes
);
731 * Call the close operation on a port object.
732 * see also scm_close.
734 SCM_DEFINE (scm_close_port
, "close-port", 1, 0, 0,
736 "Close the specified port object. Return @code{#t} if it\n"
737 "successfully closes a port or @code{#f} if it was already\n"
738 "closed. An exception may be raised if an error occurs, for\n"
739 "example when flushing buffered output. See also @ref{Ports and\n"
740 "File Descriptors, close}, for a procedure which can close file\n"
742 #define FUNC_NAME s_scm_close_port
747 port
= SCM_COERCE_OUTPORT (port
);
749 SCM_VALIDATE_PORT (1, port
);
750 if (SCM_CLOSEDP (port
))
752 i
= SCM_PTOBNUM (port
);
753 if (scm_ptobs
[i
].close
)
754 rv
= (scm_ptobs
[i
].close
) (port
);
757 scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex
);
758 scm_remove_from_port_table (port
);
759 scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex
);
760 SCM_CLR_PORT_OPEN_FLAG (port
);
761 return scm_from_bool (rv
>= 0);
765 SCM_DEFINE (scm_close_input_port
, "close-input-port", 1, 0, 0,
767 "Close the specified input port object. The routine has no effect if\n"
768 "the file has already been closed. An exception may be raised if an\n"
769 "error occurs. The value returned is unspecified.\n\n"
770 "See also @ref{Ports and File Descriptors, close}, for a procedure\n"
771 "which can close file descriptors.")
772 #define FUNC_NAME s_scm_close_input_port
774 SCM_VALIDATE_INPUT_PORT (1, port
);
775 scm_close_port (port
);
776 return SCM_UNSPECIFIED
;
780 SCM_DEFINE (scm_close_output_port
, "close-output-port", 1, 0, 0,
782 "Close the specified output port object. The routine has no effect if\n"
783 "the file has already been closed. An exception may be raised if an\n"
784 "error occurs. The value returned is unspecified.\n\n"
785 "See also @ref{Ports and File Descriptors, close}, for a procedure\n"
786 "which can close file descriptors.")
787 #define FUNC_NAME s_scm_close_output_port
789 port
= SCM_COERCE_OUTPORT (port
);
790 SCM_VALIDATE_OUTPUT_PORT (1, port
);
791 scm_close_port (port
);
792 return SCM_UNSPECIFIED
;
797 scm_c_port_for_each (void (*proc
)(void *data
, SCM p
), void *data
)
803 /* Even without pre-emptive multithreading, running arbitrary code
804 while scanning the port table is unsafe because the port table
805 can change arbitrarily (from a GC, for example). So we first
806 collect the ports into a vector. -mvo */
808 scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex
);
809 n
= scm_i_port_table_size
;
810 scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex
);
812 ports
= scm_c_make_vector (n
, SCM_BOOL_F
);
814 scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex
);
815 if (n
> scm_i_port_table_size
)
816 n
= scm_i_port_table_size
;
817 for (i
= 0; i
< n
; i
++)
818 SCM_SIMPLE_VECTOR_SET (ports
, i
, scm_i_port_table
[i
]->port
);
819 scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex
);
821 for (i
= 0; i
< n
; i
++)
822 proc (data
, SCM_SIMPLE_VECTOR_REF (ports
, i
));
824 scm_remember_upto_here_1 (ports
);
827 SCM_DEFINE (scm_port_for_each
, "port-for-each", 1, 0, 0,
829 "Apply @var{proc} to each port in the Guile port table\n"
830 "in turn. The return value is unspecified. More specifically,\n"
831 "@var{proc} is applied exactly once to every port that exists\n"
832 "in the system at the time @var{port-for-each} is invoked.\n"
833 "Changes to the port table while @var{port-for-each} is running\n"
834 "have no effect as far as @var{port-for-each} is concerned.")
835 #define FUNC_NAME s_scm_port_for_each
837 SCM_VALIDATE_PROC (1, proc
);
839 scm_c_port_for_each ((void (*)(void*,SCM
))scm_call_1
, proc
);
840 return SCM_UNSPECIFIED
;
846 /* Utter miscellany. Gosh, we should clean this up some time. */
848 SCM_DEFINE (scm_input_port_p
, "input-port?", 1, 0, 0,
850 "Return @code{#t} if @var{x} is an input port, otherwise return\n"
851 "@code{#f}. Any object satisfying this predicate also satisfies\n"
853 #define FUNC_NAME s_scm_input_port_p
855 return scm_from_bool (SCM_INPUT_PORT_P (x
));
859 SCM_DEFINE (scm_output_port_p
, "output-port?", 1, 0, 0,
861 "Return @code{#t} if @var{x} is an output port, otherwise return\n"
862 "@code{#f}. Any object satisfying this predicate also satisfies\n"
864 #define FUNC_NAME s_scm_output_port_p
866 x
= SCM_COERCE_OUTPORT (x
);
867 return scm_from_bool (SCM_OUTPUT_PORT_P (x
));
871 SCM_DEFINE (scm_port_p
, "port?", 1, 0, 0,
873 "Return a boolean indicating whether @var{x} is a port.\n"
874 "Equivalent to @code{(or (input-port? @var{x}) (output-port?\n"
876 #define FUNC_NAME s_scm_port_p
878 return scm_from_bool (SCM_PORTP (x
));
882 SCM_DEFINE (scm_port_closed_p
, "port-closed?", 1, 0, 0,
884 "Return @code{#t} if @var{port} is closed or @code{#f} if it is\n"
886 #define FUNC_NAME s_scm_port_closed_p
888 SCM_VALIDATE_PORT (1, port
);
889 return scm_from_bool (!SCM_OPPORTP (port
));
893 SCM_DEFINE (scm_eof_object_p
, "eof-object?", 1, 0, 0,
895 "Return @code{#t} if @var{x} is an end-of-file object; otherwise\n"
897 #define FUNC_NAME s_scm_eof_object_p
899 return scm_from_bool(SCM_EOF_OBJECT_P (x
));
903 SCM_DEFINE (scm_force_output
, "force-output", 0, 1, 0,
905 "Flush the specified output port, or the current output port if @var{port}\n"
906 "is omitted. The current output buffer contents are passed to the\n"
907 "underlying port implementation (e.g., in the case of fports, the\n"
908 "data will be written to the file and the output buffer will be cleared.)\n"
909 "It has no effect on an unbuffered port.\n\n"
910 "The return value is unspecified.")
911 #define FUNC_NAME s_scm_force_output
913 if (SCM_UNBNDP (port
))
914 port
= scm_current_output_port ();
917 port
= SCM_COERCE_OUTPORT (port
);
918 SCM_VALIDATE_OPOUTPORT (1, port
);
921 return SCM_UNSPECIFIED
;
925 SCM_DEFINE (scm_flush_all_ports
, "flush-all-ports", 0, 0, 0,
927 "Equivalent to calling @code{force-output} on\n"
928 "all open output ports. The return value is unspecified.")
929 #define FUNC_NAME s_scm_flush_all_ports
933 scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex
);
934 for (i
= 0; i
< scm_i_port_table_size
; i
++)
936 if (SCM_OPOUTPORTP (scm_i_port_table
[i
]->port
))
937 scm_flush (scm_i_port_table
[i
]->port
);
939 scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex
);
940 return SCM_UNSPECIFIED
;
944 SCM_DEFINE (scm_read_char
, "read-char", 0, 1, 0,
946 "Return the next character available from @var{port}, updating\n"
947 "@var{port} to point to the following character. If no more\n"
948 "characters are available, the end-of-file object is returned.")
949 #define FUNC_NAME s_scm_read_char
952 if (SCM_UNBNDP (port
))
953 port
= scm_current_input_port ();
954 SCM_VALIDATE_OPINPORT (1, port
);
958 return SCM_MAKE_CHAR (c
);
962 /* this should only be called when the read buffer is empty. it
963 tries to refill the read buffer. it returns the first char from
964 the port, which is either EOF or *(pt->read_pos). */
966 scm_fill_input (SCM port
)
968 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
970 if (pt
->read_buf
== pt
->putback_buf
)
972 /* finished reading put-back chars. */
973 pt
->read_buf
= pt
->saved_read_buf
;
974 pt
->read_pos
= pt
->saved_read_pos
;
975 pt
->read_end
= pt
->saved_read_end
;
976 pt
->read_buf_size
= pt
->saved_read_buf_size
;
977 if (pt
->read_pos
< pt
->read_end
)
978 return *(pt
->read_pos
);
980 return scm_ptobs
[SCM_PTOBNUM (port
)].fill_input (port
);
987 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
989 if (pt
->rw_active
== SCM_PORT_WRITE
)
990 /* may be marginally faster than calling scm_flush. */
991 scm_ptobs
[SCM_PTOBNUM (port
)].flush (port
);
994 pt
->rw_active
= SCM_PORT_READ
;
996 if (pt
->read_pos
>= pt
->read_end
)
998 if (scm_fill_input (port
) == EOF
)
1002 c
= *(pt
->read_pos
++);
1029 scm_putc (char c
, SCM port
)
1031 SCM_ASSERT_TYPE (SCM_OPOUTPORTP (port
), port
, 0, NULL
, "output port");
1032 scm_lfwrite (&c
, 1, port
);
1036 scm_puts (const char *s
, SCM port
)
1038 SCM_ASSERT_TYPE (SCM_OPOUTPORTP (port
), port
, 0, NULL
, "output port");
1039 scm_lfwrite (s
, strlen (s
), port
);
1044 * This function differs from scm_c_write; it updates port line and
1048 scm_lfwrite (const char *ptr
, size_t size
, SCM port
)
1050 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
1051 scm_t_ptob_descriptor
*ptob
= &scm_ptobs
[SCM_PTOBNUM (port
)];
1053 if (pt
->rw_active
== SCM_PORT_READ
)
1054 scm_end_input (port
);
1056 ptob
->write (port
, ptr
, size
);
1058 for (; size
; ptr
++, size
--) {
1061 else if (*ptr
== '\b') {
1064 else if (*ptr
== '\n') {
1067 else if (*ptr
== '\r') {
1070 else if (*ptr
== '\t') {
1079 pt
->rw_active
= SCM_PORT_WRITE
;
1084 * Used by an application to read arbitrary number of bytes from an
1085 * SCM port. Same semantics as libc read, except that scm_c_read only
1086 * returns less than SIZE bytes if at end-of-file.
1088 * Warning: Doesn't update port line and column counts! */
1091 scm_c_read (SCM port
, void *buffer
, size_t size
)
1093 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
1094 size_t n_read
= 0, n_available
;
1096 if (pt
->rw_active
== SCM_PORT_WRITE
)
1097 scm_ptobs
[SCM_PTOBNUM (port
)].flush (port
);
1100 pt
->rw_active
= SCM_PORT_READ
;
1102 if (SCM_READ_BUFFER_EMPTY_P (pt
))
1104 if (scm_fill_input (port
) == EOF
)
1108 n_available
= pt
->read_end
- pt
->read_pos
;
1110 while (n_available
< size
)
1112 memcpy (buffer
, pt
->read_pos
, n_available
);
1113 buffer
= (char *) buffer
+ n_available
;
1114 pt
->read_pos
+= n_available
;
1115 n_read
+= n_available
;
1117 if (SCM_READ_BUFFER_EMPTY_P (pt
))
1119 if (scm_fill_input (port
) == EOF
)
1123 size
-= n_available
;
1124 n_available
= pt
->read_end
- pt
->read_pos
;
1127 memcpy (buffer
, pt
->read_pos
, size
);
1128 pt
->read_pos
+= size
;
1130 return n_read
+ size
;
1135 * Used by an application to write arbitrary number of bytes to an SCM
1136 * port. Similar semantics as libc write. However, unlike libc
1137 * write, scm_c_write writes the requested number of bytes and has no
1140 * Warning: Doesn't update port line and column counts!
1144 scm_c_write (SCM port
, const void *ptr
, size_t size
)
1146 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
1147 scm_t_ptob_descriptor
*ptob
= &scm_ptobs
[SCM_PTOBNUM (port
)];
1149 if (pt
->rw_active
== SCM_PORT_READ
)
1150 scm_end_input (port
);
1152 ptob
->write (port
, ptr
, size
);
1155 pt
->rw_active
= SCM_PORT_WRITE
;
1159 scm_flush (SCM port
)
1161 long i
= SCM_PTOBNUM (port
);
1162 assert ((i
>= 0) && (i
< scm_i_port_table_size
));
1163 (scm_ptobs
[i
].flush
) (port
);
1167 scm_end_input (SCM port
)
1170 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
1172 if (pt
->read_buf
== pt
->putback_buf
)
1174 offset
= pt
->read_end
- pt
->read_pos
;
1175 pt
->read_buf
= pt
->saved_read_buf
;
1176 pt
->read_pos
= pt
->saved_read_pos
;
1177 pt
->read_end
= pt
->saved_read_end
;
1178 pt
->read_buf_size
= pt
->saved_read_buf_size
;
1183 scm_ptobs
[SCM_PTOBNUM (port
)].end_input (port
, offset
);
1190 scm_ungetc (int c
, SCM port
)
1191 #define FUNC_NAME "scm_ungetc"
1193 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
1195 if (pt
->read_buf
== pt
->putback_buf
)
1196 /* already using the put-back buffer. */
1198 /* enlarge putback_buf if necessary. */
1199 if (pt
->read_end
== pt
->read_buf
+ pt
->read_buf_size
1200 && pt
->read_buf
== pt
->read_pos
)
1202 size_t new_size
= pt
->read_buf_size
* 2;
1203 unsigned char *tmp
= (unsigned char *)
1204 /* XXX: Can we use `GC_REALLOC' with `GC_MALLOC_ATOMIC'-allocated
1206 scm_gc_realloc (pt
->putback_buf
, pt
->read_buf_size
, new_size
,
1209 pt
->read_pos
= pt
->read_buf
= pt
->putback_buf
= tmp
;
1210 pt
->read_end
= pt
->read_buf
+ pt
->read_buf_size
;
1211 pt
->read_buf_size
= pt
->putback_buf_size
= new_size
;
1214 /* shift any existing bytes to buffer + 1. */
1215 if (pt
->read_pos
== pt
->read_end
)
1216 pt
->read_end
= pt
->read_buf
+ 1;
1217 else if (pt
->read_pos
!= pt
->read_buf
+ 1)
1219 int count
= pt
->read_end
- pt
->read_pos
;
1221 memmove (pt
->read_buf
+ 1, pt
->read_pos
, count
);
1222 pt
->read_end
= pt
->read_buf
+ 1 + count
;
1225 pt
->read_pos
= pt
->read_buf
;
1228 /* switch to the put-back buffer. */
1230 if (pt
->putback_buf
== NULL
)
1233 = (unsigned char *) scm_gc_malloc_pointerless
1234 (SCM_INITIAL_PUTBACK_BUF_SIZE
, "putback buffer");
1235 pt
->putback_buf_size
= SCM_INITIAL_PUTBACK_BUF_SIZE
;
1238 pt
->saved_read_buf
= pt
->read_buf
;
1239 pt
->saved_read_pos
= pt
->read_pos
;
1240 pt
->saved_read_end
= pt
->read_end
;
1241 pt
->saved_read_buf_size
= pt
->read_buf_size
;
1243 pt
->read_pos
= pt
->read_buf
= pt
->putback_buf
;
1244 pt
->read_end
= pt
->read_buf
+ 1;
1245 pt
->read_buf_size
= pt
->putback_buf_size
;
1251 pt
->rw_active
= SCM_PORT_READ
;
1255 /* What should col be in this case?
1256 * We'll leave it at -1.
1258 SCM_LINUM (port
) -= 1;
1267 scm_ungets (const char *s
, int n
, SCM port
)
1269 /* This is simple minded and inefficient, but unreading strings is
1270 * probably not a common operation, and remember that line and
1271 * column numbers have to be handled...
1273 * Please feel free to write an optimized version!
1276 scm_ungetc (s
[n
], port
);
1280 SCM_DEFINE (scm_peek_char
, "peek-char", 0, 1, 0,
1282 "Return the next character available from @var{port},\n"
1283 "@emph{without} updating @var{port} to point to the following\n"
1284 "character. If no more characters are available, the\n"
1285 "end-of-file object is returned.\n"
1287 "The value returned by\n"
1288 "a call to @code{peek-char} is the same as the value that would\n"
1289 "have been returned by a call to @code{read-char} on the same\n"
1290 "port. The only difference is that the very next call to\n"
1291 "@code{read-char} or @code{peek-char} on that @var{port} will\n"
1292 "return the value returned by the preceding call to\n"
1293 "@code{peek-char}. In particular, a call to @code{peek-char} on\n"
1294 "an interactive port will hang waiting for input whenever a call\n"
1295 "to @code{read-char} would have hung.")
1296 #define FUNC_NAME s_scm_peek_char
1299 if (SCM_UNBNDP (port
))
1300 port
= scm_current_input_port ();
1302 SCM_VALIDATE_OPINPORT (1, port
);
1303 column
= SCM_COL(port
);
1304 c
= scm_getc (port
);
1307 scm_ungetc (c
, port
);
1308 SCM_COL(port
) = column
;
1309 return SCM_MAKE_CHAR (c
);
1313 SCM_DEFINE (scm_unread_char
, "unread-char", 1, 1, 0,
1314 (SCM cobj
, SCM port
),
1315 "Place @var{char} in @var{port} so that it will be read by the\n"
1316 "next read operation. If called multiple times, the unread characters\n"
1317 "will be read again in last-in first-out order. If @var{port} is\n"
1318 "not supplied, the current input port is used.")
1319 #define FUNC_NAME s_scm_unread_char
1323 SCM_VALIDATE_CHAR (1, cobj
);
1324 if (SCM_UNBNDP (port
))
1325 port
= scm_current_input_port ();
1327 SCM_VALIDATE_OPINPORT (2, port
);
1329 c
= SCM_CHAR (cobj
);
1331 scm_ungetc (c
, port
);
1336 SCM_DEFINE (scm_unread_string
, "unread-string", 2, 0, 0,
1337 (SCM str
, SCM port
),
1338 "Place the string @var{str} in @var{port} so that its characters will be\n"
1339 "read in subsequent read operations. If called multiple times, the\n"
1340 "unread characters will be read again in last-in first-out order. If\n"
1341 "@var{port} is not supplied, the current-input-port is used.")
1342 #define FUNC_NAME s_scm_unread_string
1344 SCM_VALIDATE_STRING (1, str
);
1345 if (SCM_UNBNDP (port
))
1346 port
= scm_current_input_port ();
1348 SCM_VALIDATE_OPINPORT (2, port
);
1350 scm_ungets (scm_i_string_chars (str
), scm_i_string_length (str
), port
);
1356 SCM_DEFINE (scm_seek
, "seek", 3, 0, 0,
1357 (SCM fd_port
, SCM offset
, SCM whence
),
1358 "Sets the current position of @var{fd/port} to the integer\n"
1359 "@var{offset}, which is interpreted according to the value of\n"
1362 "One of the following variables should be supplied for\n"
1364 "@defvar SEEK_SET\n"
1365 "Seek from the beginning of the file.\n"
1367 "@defvar SEEK_CUR\n"
1368 "Seek from the current position.\n"
1370 "@defvar SEEK_END\n"
1371 "Seek from the end of the file.\n"
1373 "If @var{fd/port} is a file descriptor, the underlying system\n"
1374 "call is @code{lseek}. @var{port} may be a string port.\n"
1376 "The value returned is the new position in the file. This means\n"
1377 "that the current position of a port can be obtained using:\n"
1379 "(seek port 0 SEEK_CUR)\n"
1381 #define FUNC_NAME s_scm_seek
1385 fd_port
= SCM_COERCE_OUTPORT (fd_port
);
1387 how
= scm_to_int (whence
);
1388 if (how
!= SEEK_SET
&& how
!= SEEK_CUR
&& how
!= SEEK_END
)
1389 SCM_OUT_OF_RANGE (3, whence
);
1391 if (SCM_OPPORTP (fd_port
))
1393 scm_t_ptob_descriptor
*ptob
= scm_ptobs
+ SCM_PTOBNUM (fd_port
);
1394 off_t off
= scm_to_off_t (offset
);
1398 SCM_MISC_ERROR ("port is not seekable",
1399 scm_cons (fd_port
, SCM_EOL
));
1401 rv
= ptob
->seek (fd_port
, off
, how
);
1402 return scm_from_off_t (rv
);
1404 else /* file descriptor?. */
1406 off_t_or_off64_t off
= scm_to_off_t_or_off64_t (offset
);
1407 off_t_or_off64_t rv
;
1408 rv
= lseek_or_lseek64 (scm_to_int (fd_port
), off
, how
);
1411 return scm_from_off_t_or_off64_t (rv
);
1417 /* Define this function since it is not supported under Windows. */
1418 static int truncate (char *file
, int length
)
1421 if ((fdes
= open (file
, O_BINARY
| O_WRONLY
)) != -1)
1423 ret
= chsize (fdes
, length
);
1428 #endif /* __MINGW32__ */
1430 SCM_DEFINE (scm_truncate_file
, "truncate-file", 1, 1, 0,
1431 (SCM object
, SCM length
),
1432 "Truncates the object referred to by @var{object} to at most\n"
1433 "@var{length} bytes. @var{object} can be a string containing a\n"
1434 "file name or an integer file descriptor or a port.\n"
1435 "@var{length} may be omitted if @var{object} is not a file name,\n"
1436 "in which case the truncation occurs at the current port\n"
1437 "position. The return value is unspecified.")
1438 #define FUNC_NAME s_scm_truncate_file
1442 /* "object" can be a port, fdes or filename.
1444 Negative "length" makes no sense, but it's left to truncate() or
1445 ftruncate() to give back an error for that (normally EINVAL).
1448 if (SCM_UNBNDP (length
))
1450 /* must supply length if object is a filename. */
1451 if (scm_is_string (object
))
1452 SCM_MISC_ERROR("must supply length if OBJECT is a filename", SCM_EOL
);
1454 length
= scm_seek (object
, SCM_INUM0
, scm_from_int (SEEK_CUR
));
1457 object
= SCM_COERCE_OUTPORT (object
);
1458 if (scm_is_integer (object
))
1460 off_t_or_off64_t c_length
= scm_to_off_t_or_off64_t (length
);
1461 SCM_SYSCALL (rv
= ftruncate_or_ftruncate64 (scm_to_int (object
),
1464 else if (SCM_OPOUTPORTP (object
))
1466 off_t c_length
= scm_to_off_t (length
);
1467 scm_t_port
*pt
= SCM_PTAB_ENTRY (object
);
1468 scm_t_ptob_descriptor
*ptob
= scm_ptobs
+ SCM_PTOBNUM (object
);
1470 if (!ptob
->truncate
)
1471 SCM_MISC_ERROR ("port is not truncatable", SCM_EOL
);
1472 if (pt
->rw_active
== SCM_PORT_READ
)
1473 scm_end_input (object
);
1474 else if (pt
->rw_active
== SCM_PORT_WRITE
)
1475 ptob
->flush (object
);
1477 ptob
->truncate (object
, c_length
);
1482 off_t_or_off64_t c_length
= scm_to_off_t_or_off64_t (length
);
1483 char *str
= scm_to_locale_string (object
);
1485 SCM_SYSCALL (rv
= truncate_or_truncate64 (str
, c_length
));
1492 return SCM_UNSPECIFIED
;
1496 SCM_DEFINE (scm_port_line
, "port-line", 1, 0, 0,
1498 "Return the current line number for @var{port}.\n"
1500 "The first line of a file is 0. But you might want to add 1\n"
1501 "when printing line numbers, since starting from 1 is\n"
1502 "traditional in error messages, and likely to be more natural to\n"
1504 #define FUNC_NAME s_scm_port_line
1506 port
= SCM_COERCE_OUTPORT (port
);
1507 SCM_VALIDATE_OPENPORT (1, port
);
1508 return scm_from_int (SCM_LINUM (port
));
1512 SCM_DEFINE (scm_set_port_line_x
, "set-port-line!", 2, 0, 0,
1513 (SCM port
, SCM line
),
1514 "Set the current line number for @var{port} to @var{line}. The\n"
1515 "first line of a file is 0.")
1516 #define FUNC_NAME s_scm_set_port_line_x
1518 port
= SCM_COERCE_OUTPORT (port
);
1519 SCM_VALIDATE_OPENPORT (1, port
);
1520 SCM_PTAB_ENTRY (port
)->line_number
= scm_to_int (line
);
1521 return SCM_UNSPECIFIED
;
1525 SCM_DEFINE (scm_port_column
, "port-column", 1, 0, 0,
1527 "Return the current column number of @var{port}.\n"
1528 "If the number is\n"
1529 "unknown, the result is #f. Otherwise, the result is a 0-origin integer\n"
1530 "- i.e. the first character of the first line is line 0, column 0.\n"
1531 "(However, when you display a file position, for example in an error\n"
1532 "message, we recommend you add 1 to get 1-origin integers. This is\n"
1533 "because lines and column numbers traditionally start with 1, and that is\n"
1534 "what non-programmers will find most natural.)")
1535 #define FUNC_NAME s_scm_port_column
1537 port
= SCM_COERCE_OUTPORT (port
);
1538 SCM_VALIDATE_OPENPORT (1, port
);
1539 return scm_from_int (SCM_COL (port
));
1543 SCM_DEFINE (scm_set_port_column_x
, "set-port-column!", 2, 0, 0,
1544 (SCM port
, SCM column
),
1545 "Set the current column of @var{port}. Before reading the first\n"
1546 "character on a line the column should be 0.")
1547 #define FUNC_NAME s_scm_set_port_column_x
1549 port
= SCM_COERCE_OUTPORT (port
);
1550 SCM_VALIDATE_OPENPORT (1, port
);
1551 SCM_PTAB_ENTRY (port
)->column_number
= scm_to_int (column
);
1552 return SCM_UNSPECIFIED
;
1556 SCM_DEFINE (scm_port_filename
, "port-filename", 1, 0, 0,
1558 "Return the filename associated with @var{port}. This function returns\n"
1559 "the strings \"standard input\", \"standard output\" and \"standard error\"\n"
1560 "when called on the current input, output and error ports respectively.")
1561 #define FUNC_NAME s_scm_port_filename
1563 port
= SCM_COERCE_OUTPORT (port
);
1564 SCM_VALIDATE_OPENPORT (1, port
);
1565 return SCM_FILENAME (port
);
1569 SCM_DEFINE (scm_set_port_filename_x
, "set-port-filename!", 2, 0, 0,
1570 (SCM port
, SCM filename
),
1571 "Change the filename associated with @var{port}, using the current input\n"
1572 "port if none is specified. Note that this does not change the port's\n"
1573 "source of data, but only the value that is returned by\n"
1574 "@code{port-filename} and reported in diagnostic output.")
1575 #define FUNC_NAME s_scm_set_port_filename_x
1577 port
= SCM_COERCE_OUTPORT (port
);
1578 SCM_VALIDATE_OPENPORT (1, port
);
1579 /* We allow the user to set the filename to whatever he likes. */
1580 SCM_SET_FILENAME (port
, filename
);
1581 return SCM_UNSPECIFIED
;
1586 scm_print_port_mode (SCM exp
, SCM port
)
1588 scm_puts (SCM_CLOSEDP (exp
)
1590 : (SCM_RDNG
& SCM_CELL_WORD_0 (exp
)
1591 ? (SCM_WRTNG
& SCM_CELL_WORD_0 (exp
)
1594 : (SCM_WRTNG
& SCM_CELL_WORD_0 (exp
)
1601 scm_port_print (SCM exp
, SCM port
, scm_print_state
*pstate SCM_UNUSED
)
1603 char *type
= SCM_PTOBNAME (SCM_PTOBNUM (exp
));
1606 scm_puts ("#<", port
);
1607 scm_print_port_mode (exp
, port
);
1608 scm_puts (type
, port
);
1609 scm_putc (' ', port
);
1610 scm_uintprint (SCM_CELL_WORD_1 (exp
), 16, port
);
1611 scm_putc ('>', port
);
1616 scm_ports_prehistory ()
1621 scm_i_port_table
= scm_gc_malloc (scm_i_port_table_room
1622 * sizeof (scm_t_port
*),
1630 scm_t_bits scm_tc16_void_port
= 0;
1632 static int fill_input_void_port (SCM port SCM_UNUSED
)
1638 write_void_port (SCM port SCM_UNUSED
,
1639 const void *data SCM_UNUSED
,
1640 size_t size SCM_UNUSED
)
1645 scm_i_void_port (long mode_bits
)
1647 scm_i_scm_pthread_mutex_lock (&scm_i_port_table_mutex
);
1649 SCM answer
= scm_new_port_table_entry (scm_tc16_void_port
);
1650 scm_t_port
* pt
= SCM_PTAB_ENTRY(answer
);
1652 scm_port_non_buffer (pt
);
1654 SCM_SETSTREAM (answer
, 0);
1655 SCM_SET_CELL_TYPE (answer
, scm_tc16_void_port
| mode_bits
);
1656 scm_i_pthread_mutex_unlock (&scm_i_port_table_mutex
);
1662 scm_void_port (char *mode_str
)
1664 return scm_i_void_port (scm_mode_bits (mode_str
));
1667 SCM_DEFINE (scm_sys_make_void_port
, "%make-void-port", 1, 0, 0,
1669 "Create and return a new void port. A void port acts like\n"
1670 "@file{/dev/null}. The @var{mode} argument\n"
1671 "specifies the input/output modes for this port: see the\n"
1672 "documentation for @code{open-file} in @ref{File Ports}.")
1673 #define FUNC_NAME s_scm_sys_make_void_port
1675 return scm_i_void_port (scm_i_mode_bits (mode
));
1680 /* Initialization. */
1685 /* lseek() symbols. */
1686 scm_c_define ("SEEK_SET", scm_from_int (SEEK_SET
));
1687 scm_c_define ("SEEK_CUR", scm_from_int (SEEK_CUR
));
1688 scm_c_define ("SEEK_END", scm_from_int (SEEK_END
));
1690 scm_tc16_void_port
= scm_make_port_type ("void", fill_input_void_port
,
1693 cur_inport_fluid
= scm_permanent_object (scm_make_fluid ());
1694 cur_outport_fluid
= scm_permanent_object (scm_make_fluid ());
1695 cur_errport_fluid
= scm_permanent_object (scm_make_fluid ());
1696 cur_loadport_fluid
= scm_permanent_object (scm_make_fluid ());
1698 #include "libguile/ports.x"