2 @c This is part of the GNU Guile Reference Manual.
3 @c Copyright (C) 1996, 1997, 2000, 2001, 2002, 2003, 2004, 2007, 2009,
4 @c 2010, 2011 Free Software Foundation, Inc.
5 @c See the file guile.texi for copying conditions.
8 @section Input and Output
11 * Ports:: The idea of the port abstraction.
12 * Reading:: Procedures for reading from a port.
13 * Writing:: Procedures for writing to a port.
14 * Closing:: Procedures to close a port.
15 * Random Access:: Moving around a random access port.
16 * Line/Delimited:: Read and write lines or delimited text.
17 * Block Reading and Writing:: Reading and writing blocks of text.
18 * Default Ports:: Defaults for input, output and errors.
19 * Port Types:: Types of port and how to make them.
20 * R6RS I/O Ports:: The R6RS port API.
21 * I/O Extensions:: Using and extending ports in C.
29 Sequential input/output in Scheme is represented by operations on a
30 @dfn{port}. This chapter explains the operations that Guile provides
31 for working with ports.
33 Ports are created by opening, for instance @code{open-file} for a file
34 (@pxref{File Ports}). Characters can be read from an input port and
35 written to an output port, or both on an input/output port. A port
36 can be closed (@pxref{Closing}) when no longer required, after which
37 any attempt to read or write is an error.
39 The formal definition of a port is very generic: an input port is
40 simply ``an object which can deliver characters on demand,'' and an
41 output port is ``an object which can accept characters.'' Because
42 this definition is so loose, it is easy to write functions that
43 simulate ports in software. @dfn{Soft ports} and @dfn{string ports}
44 are two interesting and powerful examples of this technique.
45 (@pxref{Soft Ports}, and @ref{String Ports}.)
47 Ports are garbage collected in the usual way (@pxref{Memory
48 Management}), and will be closed at that time if not already closed.
49 In this case any errors occurring in the close will not be reported.
50 Usually a program will want to explicitly close so as to be sure all
51 its operations have been successful. Of course if a program has
52 abandoned something due to an error or other condition then closing
53 problems are probably not of interest.
55 It is strongly recommended that file ports be closed explicitly when
56 no longer required. Most systems have limits on how many files can be
57 open, both on a per-process and a system-wide basis. A program that
58 uses many files should take care not to hit those limits. The same
59 applies to similar system resources such as pipes and sockets.
61 Note that automatic garbage collection is triggered only by memory
62 consumption, not by file or other resource usage, so a program cannot
63 rely on that to keep it away from system limits. An explicit call to
64 @code{gc} can of course be relied on to pick up unreferenced ports.
65 If program flow makes it hard to be certain when to close then this
66 may be an acceptable way to control resource usage.
68 All file access uses the ``LFS'' large file support functions when
69 available, so files bigger than 2 Gbytes (@math{2^31} bytes) can be
70 read and written on a 32-bit system.
72 Each port has an associated character encoding that controls how bytes
73 read from the port are converted to characters and string and controls
74 how characters and strings written to the port are converted to bytes.
75 When ports are created, they inherit their character encoding from the
76 current locale, but, that can be modified after the port is created.
78 Currently, the ports only work with @emph{non-modal} encodings. Most
79 encodings are non-modal, meaning that the conversion of bytes to a
80 string doesn't depend on its context: the same byte sequence will always
81 return the same string. A couple of modal encodings are in common use,
82 like ISO-2022-JP and ISO-2022-KR, and they are not yet supported.
84 Each port also has an associated conversion strategy: what to do when
85 a Guile character can't be converted to the port's encoded character
86 representation for output. There are three possible strategies: to
87 raise an error, to replace the character with a hex escape, or to
88 replace the character with a substitute character.
91 @deffn {Scheme Procedure} input-port? x
92 @deffnx {C Function} scm_input_port_p (x)
93 Return @code{#t} if @var{x} is an input port, otherwise return
94 @code{#f}. Any object satisfying this predicate also satisfies
99 @deffn {Scheme Procedure} output-port? x
100 @deffnx {C Function} scm_output_port_p (x)
101 Return @code{#t} if @var{x} is an output port, otherwise return
102 @code{#f}. Any object satisfying this predicate also satisfies
106 @deffn {Scheme Procedure} port? x
107 @deffnx {C Function} scm_port_p (x)
108 Return a boolean indicating whether @var{x} is a port.
109 Equivalent to @code{(or (input-port? @var{x}) (output-port?
113 @deffn {Scheme Procedure} set-port-encoding! port enc
114 @deffnx {C Function} scm_set_port_encoding_x (port, enc)
115 Sets the character encoding that will be used to interpret all port I/O.
116 @var{enc} is a string containing the name of an encoding. Valid
117 encoding names are those
118 @url{http://www.iana.org/assignments/character-sets, defined by IANA}.
121 @defvr {Scheme Variable} %default-port-encoding
122 A fluid containing @code{#f} or the name of the encoding to
123 be used by default for newly created ports (@pxref{Fluids and Dynamic
124 States}). The value @code{#f} is equivalent to @code{"ISO-8859-1"}.
126 New ports are created with the encoding appropriate for the current
127 locale if @code{setlocale} has been called or the value specified by
128 this fluid otherwise.
131 @deffn {Scheme Procedure} port-encoding port
132 @deffnx {C Function} scm_port_encoding (port)
133 Returns, as a string, the character encoding that @var{port} uses to interpret
134 its input and output. The value @code{#f} is equivalent to @code{"ISO-8859-1"}.
137 @deffn {Scheme Procedure} set-port-conversion-strategy! port sym
138 @deffnx {C Function} scm_set_port_conversion_strategy_x (port, sym)
139 Sets the behavior of the interpreter when outputting a character that
140 is not representable in the port's current encoding. @var{sym} can be
141 either @code{'error}, @code{'substitute}, or @code{'escape}. If it is
142 @code{'error}, an error will be thrown when an nonconvertible character
143 is encountered. If it is @code{'substitute}, then nonconvertible
144 characters will be replaced with approximate characters, or with
145 question marks if no approximately correct character is available. If
146 it is @code{'escape}, it will appear as a hex escape when output.
148 If @var{port} is an open port, the conversion error behavior
149 is set for that port. If it is @code{#f}, it is set as the
150 default behavior for any future ports that get created in
154 @deffn {Scheme Procedure} port-conversion-strategy port
155 @deffnx {C Function} scm_port_conversion_strategy (port)
156 Returns the behavior of the port when outputting a character that is
157 not representable in the port's current encoding. It returns the
158 symbol @code{error} if unrepresentable characters should cause
159 exceptions, @code{substitute} if the port should try to replace
160 unrepresentable characters with question marks or approximate
161 characters, or @code{escape} if unrepresentable characters should be
162 converted to string escapes.
164 If @var{port} is @code{#f}, then the current default behavior will be
165 returned. New ports will have this default behavior when they are
169 @deffn {Scheme Variable} %default-port-conversion-strategy
170 The fluid that defines the conversion strategy for newly created ports,
171 and for other conversion routines such as @code{scm_to_stringn},
172 @code{scm_from_stringn}, @code{string->pointer}, and
173 @code{pointer->string}.
175 Its value must be one of the symbols described above, with the same
176 semantics: @code{'error}, @code{'substitute}, or @code{'escape}.
178 When Guile starts, its value is @code{'substitute}.
180 Note that @code{(set-port-conversion-strategy! #f @var{sym})} is
181 equivalent to @code{(fluid-set! %default-port-conversion-strategy
190 [Generic procedures for reading from ports.]
192 These procedures pertain to reading characters and strings from
193 ports. To read general S-expressions from ports, @xref{Scheme Read}.
196 @cindex End of file object
197 @deffn {Scheme Procedure} eof-object? x
198 @deffnx {C Function} scm_eof_object_p (x)
199 Return @code{#t} if @var{x} is an end-of-file object; otherwise
204 @deffn {Scheme Procedure} char-ready? [port]
205 @deffnx {C Function} scm_char_ready_p (port)
206 Return @code{#t} if a character is ready on input @var{port}
207 and return @code{#f} otherwise. If @code{char-ready?} returns
208 @code{#t} then the next @code{read-char} operation on
209 @var{port} is guaranteed not to hang. If @var{port} is a file
210 port at end of file then @code{char-ready?} returns @code{#t}.
212 @code{char-ready?} exists to make it possible for a
213 program to accept characters from interactive ports without
214 getting stuck waiting for input. Any input editors associated
215 with such ports must make sure that characters whose existence
216 has been asserted by @code{char-ready?} cannot be rubbed out.
217 If @code{char-ready?} were to return @code{#f} at end of file,
218 a port at end of file would be indistinguishable from an
219 interactive port that has no ready characters.
223 @deffn {Scheme Procedure} read-char [port]
224 @deffnx {C Function} scm_read_char (port)
225 Return the next character available from @var{port}, updating
226 @var{port} to point to the following character. If no more
227 characters are available, the end-of-file object is returned.
229 When @var{port}'s data cannot be decoded according to its
230 character encoding, a @code{decoding-error} is raised and
231 @var{port} points past the erroneous byte sequence.
234 @deftypefn {C Function} size_t scm_c_read (SCM port, void *buffer, size_t size)
235 Read up to @var{size} bytes from @var{port} and store them in
236 @var{buffer}. The return value is the number of bytes actually read,
237 which can be less than @var{size} if end-of-file has been reached.
239 Note that this function does not update @code{port-line} and
240 @code{port-column} below.
244 @deffn {Scheme Procedure} peek-char [port]
245 @deffnx {C Function} scm_peek_char (port)
246 Return the next character available from @var{port},
247 @emph{without} updating @var{port} to point to the following
248 character. If no more characters are available, the
249 end-of-file object is returned.
251 The value returned by
252 a call to @code{peek-char} is the same as the value that would
253 have been returned by a call to @code{read-char} on the same
254 port. The only difference is that the very next call to
255 @code{read-char} or @code{peek-char} on that @var{port} will
256 return the value returned by the preceding call to
257 @code{peek-char}. In particular, a call to @code{peek-char} on
258 an interactive port will hang waiting for input whenever a call
259 to @code{read-char} would have hung.
261 As for @code{read-char}, a @code{decoding-error} may be raised
262 if such a situation occurs. However, unlike with @code{read-char},
263 @var{port} still points at the beginning of the erroneous byte
264 sequence when the error is raised.
267 @deffn {Scheme Procedure} unread-char cobj [port]
268 @deffnx {C Function} scm_unread_char (cobj, port)
269 Place character @var{cobj} in @var{port} so that it will be read by the
270 next read operation. If called multiple times, the unread characters
271 will be read again in last-in first-out order. If @var{port} is
272 not supplied, the current input port is used.
275 @deffn {Scheme Procedure} unread-string str port
276 @deffnx {C Function} scm_unread_string (str, port)
277 Place the string @var{str} in @var{port} so that its characters will
278 be read from left-to-right as the next characters from @var{port}
279 during subsequent read operations. If called multiple times, the
280 unread characters will be read again in last-in first-out order. If
281 @var{port} is not supplied, the @code{current-input-port} is used.
284 @deffn {Scheme Procedure} drain-input port
285 @deffnx {C Function} scm_drain_input (port)
286 This procedure clears a port's input buffers, similar
287 to the way that force-output clears the output buffer. The
288 contents of the buffers are returned as a single string, e.g.,
291 (define p (open-input-file ...))
292 (drain-input p) => empty string, nothing buffered yet.
293 (unread-char (read-char p) p)
294 (drain-input p) => initial chars from p, up to the buffer size.
297 Draining the buffers may be useful for cleanly finishing
298 buffered I/O so that the file descriptor can be used directly
302 @deffn {Scheme Procedure} port-column port
303 @deffnx {Scheme Procedure} port-line port
304 @deffnx {C Function} scm_port_column (port)
305 @deffnx {C Function} scm_port_line (port)
306 Return the current column number or line number of @var{port}.
308 unknown, the result is #f. Otherwise, the result is a 0-origin integer
309 - i.e.@: the first character of the first line is line 0, column 0.
310 (However, when you display a file position, for example in an error
311 message, we recommend you add 1 to get 1-origin integers. This is
312 because lines and column numbers traditionally start with 1, and that is
313 what non-programmers will find most natural.)
316 @deffn {Scheme Procedure} set-port-column! port column
317 @deffnx {Scheme Procedure} set-port-line! port line
318 @deffnx {C Function} scm_set_port_column_x (port, column)
319 @deffnx {C Function} scm_set_port_line_x (port, line)
320 Set the current column or line number of @var{port}.
327 [Generic procedures for writing to ports.]
329 These procedures are for writing characters and strings to
330 ports. For more information on writing arbitrary Scheme objects to
331 ports, @xref{Scheme Write}.
333 @deffn {Scheme Procedure} get-print-state port
334 @deffnx {C Function} scm_get_print_state (port)
335 Return the print state of the port @var{port}. If @var{port}
336 has no associated print state, @code{#f} is returned.
340 @deffn {Scheme Procedure} newline [port]
341 @deffnx {C Function} scm_newline (port)
342 Send a newline to @var{port}.
343 If @var{port} is omitted, send to the current output port.
346 @deffn {Scheme Procedure} port-with-print-state port [pstate]
347 @deffnx {C Function} scm_port_with_print_state (port, pstate)
348 Create a new port which behaves like @var{port}, but with an
349 included print state @var{pstate}. @var{pstate} is optional.
350 If @var{pstate} isn't supplied and @var{port} already has
351 a print state, the old print state is reused.
354 @deffn {Scheme Procedure} simple-format destination message . args
355 @deffnx {C Function} scm_simple_format (destination, message, args)
356 Write @var{message} to @var{destination}, defaulting to
357 the current output port.
358 @var{message} can contain @code{~A} (was @code{%s}) and
359 @code{~S} (was @code{%S}) escapes. When printed,
360 the escapes are replaced with corresponding members of
362 @code{~A} formats using @code{display} and @code{~S} formats
364 If @var{destination} is @code{#t}, then use the current output
365 port, if @var{destination} is @code{#f}, then return a string
366 containing the formatted text. Does not add a trailing newline.
370 @deffn {Scheme Procedure} write-char chr [port]
371 @deffnx {C Function} scm_write_char (chr, port)
372 Send character @var{chr} to @var{port}.
375 @deftypefn {C Function} void scm_c_write (SCM port, const void *buffer, size_t size)
376 Write @var{size} bytes at @var{buffer} to @var{port}.
378 Note that this function does not update @code{port-line} and
379 @code{port-column} (@pxref{Reading}).
383 @deffn {Scheme Procedure} force-output [port]
384 @deffnx {C Function} scm_force_output (port)
385 Flush the specified output port, or the current output port if @var{port}
386 is omitted. The current output buffer contents are passed to the
387 underlying port implementation (e.g., in the case of fports, the
388 data will be written to the file and the output buffer will be cleared.)
389 It has no effect on an unbuffered port.
391 The return value is unspecified.
394 @deffn {Scheme Procedure} flush-all-ports
395 @deffnx {C Function} scm_flush_all_ports ()
396 Equivalent to calling @code{force-output} on
397 all open output ports. The return value is unspecified.
403 @cindex Closing ports
406 @deffn {Scheme Procedure} close-port port
407 @deffnx {C Function} scm_close_port (port)
408 Close the specified port object. Return @code{#t} if it
409 successfully closes a port or @code{#f} if it was already
410 closed. An exception may be raised if an error occurs, for
411 example when flushing buffered output. See also @ref{Ports and
412 File Descriptors, close}, for a procedure which can close file
416 @deffn {Scheme Procedure} close-input-port port
417 @deffnx {Scheme Procedure} close-output-port port
418 @deffnx {C Function} scm_close_input_port (port)
419 @deffnx {C Function} scm_close_output_port (port)
420 @rnindex close-input-port
421 @rnindex close-output-port
422 Close the specified input or output @var{port}. An exception may be
423 raised if an error occurs while closing. If @var{port} is already
424 closed, nothing is done. The return value is unspecified.
426 See also @ref{Ports and File Descriptors, close}, for a procedure
427 which can close file descriptors.
430 @deffn {Scheme Procedure} port-closed? port
431 @deffnx {C Function} scm_port_closed_p (port)
432 Return @code{#t} if @var{port} is closed or @code{#f} if it is
438 @subsection Random Access
439 @cindex Random access, ports
440 @cindex Port, random access
442 @deffn {Scheme Procedure} seek fd_port offset whence
443 @deffnx {C Function} scm_seek (fd_port, offset, whence)
444 Sets the current position of @var{fd_port} to the integer
445 @var{offset}, which is interpreted according to the value of
448 One of the following variables should be supplied for
451 Seek from the beginning of the file.
454 Seek from the current position.
457 Seek from the end of the file.
459 If @var{fd_port} is a file descriptor, the underlying system
460 call is @code{lseek}. @var{port} may be a string port.
462 The value returned is the new position in the file. This means
463 that the current position of a port can be obtained using:
465 (seek port 0 SEEK_CUR)
469 @deffn {Scheme Procedure} ftell fd_port
470 @deffnx {C Function} scm_ftell (fd_port)
471 Return an integer representing the current position of
472 @var{fd_port}, measured from the beginning. Equivalent to:
475 (seek port 0 SEEK_CUR)
481 @deffn {Scheme Procedure} truncate-file file [length]
482 @deffnx {C Function} scm_truncate_file (file, length)
483 Truncate @var{file} to @var{length} bytes. @var{file} can be a
484 filename string, a port object, or an integer file descriptor. The
485 return value is unspecified.
487 For a port or file descriptor @var{length} can be omitted, in which
488 case the file is truncated at the current position (per @code{ftell}
491 On most systems a file can be extended by giving a length greater than
492 the current size, but this is not mandatory in the POSIX standard.
496 @subsection Line Oriented and Delimited Text
497 @cindex Line input/output
498 @cindex Port, line input/output
500 The delimited-I/O module can be accessed with:
503 (use-modules (ice-9 rdelim))
506 It can be used to read or write lines of text, or read text delimited by
507 a specified set of characters. It's similar to the @code{(scsh rdelim)}
508 module from guile-scsh, but does not use multiple values or character
509 sets and has an extra procedure @code{write-line}.
511 @c begin (scm-doc-string "rdelim.scm" "read-line")
512 @deffn {Scheme Procedure} read-line [port] [handle-delim]
513 Return a line of text from @var{port} if specified, otherwise from the
514 value returned by @code{(current-input-port)}. Under Unix, a line of text
515 is terminated by the first end-of-line character or by end-of-file.
517 If @var{handle-delim} is specified, it should be one of the following
521 Discard the terminating delimiter. This is the default, but it will
522 be impossible to tell whether the read terminated with a delimiter or
525 Append the terminating delimiter (if any) to the returned string.
527 Push the terminating delimiter (if any) back on to the port.
529 Return a pair containing the string read from the port and the
530 terminating delimiter or end-of-file object.
533 Like @code{read-char}, this procedure can throw to @code{decoding-error}
534 (@pxref{Reading, @code{read-char}}).
537 @c begin (scm-doc-string "rdelim.scm" "read-line!")
538 @deffn {Scheme Procedure} read-line! buf [port]
539 Read a line of text into the supplied string @var{buf} and return the
540 number of characters added to @var{buf}. If @var{buf} is filled, then
541 @code{#f} is returned.
542 Read from @var{port} if
543 specified, otherwise from the value returned by @code{(current-input-port)}.
546 @c begin (scm-doc-string "rdelim.scm" "read-delimited")
547 @deffn {Scheme Procedure} read-delimited delims [port] [handle-delim]
548 Read text until one of the characters in the string @var{delims} is found
549 or end-of-file is reached. Read from @var{port} if supplied, otherwise
550 from the value returned by @code{(current-input-port)}.
551 @var{handle-delim} takes the same values as described for @code{read-line}.
554 @c begin (scm-doc-string "rdelim.scm" "read-delimited!")
555 @deffn {Scheme Procedure} read-delimited! delims buf [port] [handle-delim] [start] [end]
556 Read text into the supplied string @var{buf}.
558 If a delimiter was found, return the number of characters written,
559 except if @var{handle-delim} is @code{split}, in which case the return
560 value is a pair, as noted above.
562 As a special case, if @var{port} was already at end-of-stream, the EOF
563 object is returned. Also, if no characters were written because the
564 buffer was full, @code{#f} is returned.
566 It's something of a wacky interface, to be honest.
569 @deffn {Scheme Procedure} write-line obj [port]
570 @deffnx {C Function} scm_write_line (obj, port)
571 Display @var{obj} and a newline character to @var{port}. If
572 @var{port} is not specified, @code{(current-output-port)} is
573 used. This function is equivalent to:
580 In the past, Guile did not have a procedure that would just read out all
581 of the characters from a port. As a workaround, many people just called
582 @code{read-delimited} with no delimiters, knowing that would produce the
583 behavior they wanted. This prompted Guile developers to add some
584 routines that would read all characters from a port. So it is that
585 @code{(ice-9 rdelim)} is also the home for procedures that can reading
588 @deffn {Scheme Procedure} read-string [port] [count]
589 Read all of the characters out of @var{port} and return them as a
590 string. If the @var{count} is present, treat it as a limit to the
591 number of characters to read.
593 By default, read from the current input port, with no size limit on the
594 result. This procedure always returns a string, even if no characters
598 @deffn {Scheme Procedure} read-string! buf [port] [start] [end]
599 Fill @var{buf} with characters read from @var{port}, defaulting to the
600 current input port. Return the number of characters read.
602 If @var{start} or @var{end} are specified, store data only into the
603 substring of @var{str} bounded by @var{start} and @var{end} (which
604 default to the beginning and end of the string, respectively).
607 Some of the aforementioned I/O functions rely on the following C
608 primitives. These will mainly be of interest to people hacking Guile
611 @deffn {Scheme Procedure} %read-delimited! delims str gobble [port [start [end]]]
612 @deffnx {C Function} scm_read_delimited_x (delims, str, gobble, port, start, end)
613 Read characters from @var{port} into @var{str} until one of the
614 characters in the @var{delims} string is encountered. If
615 @var{gobble} is true, discard the delimiter character;
616 otherwise, leave it in the input stream for the next read. If
617 @var{port} is not specified, use the value of
618 @code{(current-input-port)}. If @var{start} or @var{end} are
619 specified, store data only into the substring of @var{str}
620 bounded by @var{start} and @var{end} (which default to the
621 beginning and end of the string, respectively).
623 Return a pair consisting of the delimiter that terminated the
624 string and the number of characters read. If reading stopped
625 at the end of file, the delimiter returned is the
626 @var{eof-object}; if the string was filled without encountering
627 a delimiter, this value is @code{#f}.
630 @deffn {Scheme Procedure} %read-line [port]
631 @deffnx {C Function} scm_read_line (port)
632 Read a newline-terminated line from @var{port}, allocating storage as
633 necessary. The newline terminator (if any) is removed from the string,
634 and a pair consisting of the line and its delimiter is returned. The
635 delimiter may be either a newline or the @var{eof-object}; if
636 @code{%read-line} is called at the end of file, it returns the pair
637 @code{(#<eof> . #<eof>)}.
640 @node Block Reading and Writing
641 @subsection Block reading and writing
642 @cindex Block read/write
643 @cindex Port, block read/write
645 The Block-string-I/O module can be accessed with:
648 (use-modules (ice-9 rw))
651 It currently contains procedures that help to implement the
652 @code{(scsh rw)} module in guile-scsh.
654 @deffn {Scheme Procedure} read-string!/partial str [port_or_fdes [start [end]]]
655 @deffnx {C Function} scm_read_string_x_partial (str, port_or_fdes, start, end)
656 Read characters from a port or file descriptor into a
657 string @var{str}. A port must have an underlying file
658 descriptor --- a so-called fport. This procedure is
659 scsh-compatible and can efficiently read large strings.
664 attempt to fill the entire string, unless the @var{start}
665 and/or @var{end} arguments are supplied. i.e., @var{start}
666 defaults to 0 and @var{end} defaults to
667 @code{(string-length str)}
669 use the current input port if @var{port_or_fdes} is not
672 return fewer than the requested number of characters in some
673 cases, e.g., on end of file, if interrupted by a signal, or if
674 not all the characters are immediately available.
676 wait indefinitely for some input if no characters are
678 unless the port is in non-blocking mode.
680 read characters from the port's input buffers if available,
681 instead from the underlying file descriptor.
683 return @code{#f} if end-of-file is encountered before reading
684 any characters, otherwise return the number of characters
687 return 0 if the port is in non-blocking mode and no characters
688 are immediately available.
690 return 0 if the request is for 0 bytes, with no
695 @deffn {Scheme Procedure} write-string/partial str [port_or_fdes [start [end]]]
696 @deffnx {C Function} scm_write_string_partial (str, port_or_fdes, start, end)
697 Write characters from a string @var{str} to a port or file
698 descriptor. A port must have an underlying file descriptor
699 --- a so-called fport. This procedure is
700 scsh-compatible and can efficiently write large strings.
705 attempt to write the entire string, unless the @var{start}
706 and/or @var{end} arguments are supplied. i.e., @var{start}
707 defaults to 0 and @var{end} defaults to
708 @code{(string-length str)}
710 use the current output port if @var{port_of_fdes} is not
713 in the case of a buffered port, store the characters in the
714 port's output buffer, if all will fit. If they will not fit
715 then any existing buffered characters will be flushed
717 to write the new characters directly to the underlying file
718 descriptor. If the port is in non-blocking mode and
719 buffered characters can not be flushed immediately, then an
720 @code{EAGAIN} system-error exception will be raised (Note:
721 scsh does not support the use of non-blocking buffered ports.)
723 write fewer than the requested number of
724 characters in some cases, e.g., if interrupted by a signal or
725 if not all of the output can be accepted immediately.
727 wait indefinitely for at least one character
728 from @var{str} to be accepted by the port, unless the port is
729 in non-blocking mode.
731 return the number of characters accepted by the port.
733 return 0 if the port is in non-blocking mode and can not accept
734 at least one character from @var{str} immediately
736 return 0 immediately if the request size is 0 bytes.
741 @subsection Default Ports for Input, Output and Errors
742 @cindex Default ports
743 @cindex Port, default
745 @rnindex current-input-port
746 @deffn {Scheme Procedure} current-input-port
747 @deffnx {C Function} scm_current_input_port ()
748 @cindex standard input
749 Return the current input port. This is the default port used
750 by many input procedures.
752 Initially this is the @dfn{standard input} in Unix and C terminology.
753 When the standard input is a tty the port is unbuffered, otherwise
756 Unbuffered input is good if an application runs an interactive
757 subprocess, since any type-ahead input won't go into Guile's buffer
758 and be unavailable to the subprocess.
760 Note that Guile buffering is completely separate from the tty ``line
761 discipline''. In the usual cooked mode on a tty Guile only sees a
762 line of input once the user presses @key{Return}.
765 @rnindex current-output-port
766 @deffn {Scheme Procedure} current-output-port
767 @deffnx {C Function} scm_current_output_port ()
768 @cindex standard output
769 Return the current output port. This is the default port used
770 by many output procedures.
772 Initially this is the @dfn{standard output} in Unix and C terminology.
773 When the standard output is a tty this port is unbuffered, otherwise
776 Unbuffered output to a tty is good for ensuring progress output or a
777 prompt is seen. But an application which always prints whole lines
778 could change to line buffered, or an application with a lot of output
779 could go fully buffered and perhaps make explicit @code{force-output}
780 calls (@pxref{Writing}) at selected points.
783 @deffn {Scheme Procedure} current-error-port
784 @deffnx {C Function} scm_current_error_port ()
785 @cindex standard error output
786 Return the port to which errors and warnings should be sent.
788 Initially this is the @dfn{standard error} in Unix and C terminology.
789 When the standard error is a tty this port is unbuffered, otherwise
793 @deffn {Scheme Procedure} set-current-input-port port
794 @deffnx {Scheme Procedure} set-current-output-port port
795 @deffnx {Scheme Procedure} set-current-error-port port
796 @deffnx {C Function} scm_set_current_input_port (port)
797 @deffnx {C Function} scm_set_current_output_port (port)
798 @deffnx {C Function} scm_set_current_error_port (port)
799 Change the ports returned by @code{current-input-port},
800 @code{current-output-port} and @code{current-error-port}, respectively,
801 so that they use the supplied @var{port} for input or output.
804 @deftypefn {C Function} void scm_dynwind_current_input_port (SCM port)
805 @deftypefnx {C Function} void scm_dynwind_current_output_port (SCM port)
806 @deftypefnx {C Function} void scm_dynwind_current_error_port (SCM port)
807 These functions must be used inside a pair of calls to
808 @code{scm_dynwind_begin} and @code{scm_dynwind_end} (@pxref{Dynamic
809 Wind}). During the dynwind context, the indicated port is set to
812 More precisely, the current port is swapped with a `backup' value
813 whenever the dynwind context is entered or left. The backup value is
814 initialized with the @var{port} argument.
818 @subsection Types of Port
819 @cindex Types of ports
822 [Types of port; how to make them.]
825 * File Ports:: Ports on an operating system file.
826 * String Ports:: Ports on a Scheme string.
827 * Soft Ports:: Ports on arbitrary Scheme procedures.
828 * Void Ports:: Ports on nothing at all.
833 @subsubsection File Ports
837 The following procedures are used to open file ports.
838 See also @ref{Ports and File Descriptors, open}, for an interface
839 to the Unix @code{open} system call.
841 Most systems have limits on how many files can be open, so it's
842 strongly recommended that file ports be closed explicitly when no
843 longer required (@pxref{Ports}).
845 @deffn {Scheme Procedure} open-file filename mode
846 @deffnx {C Function} scm_open_file (filename, mode)
847 Open the file whose name is @var{filename}, and return a port
848 representing that file. The attributes of the port are
849 determined by the @var{mode} string. The way in which this is
850 interpreted is similar to C stdio. The first character must be
851 one of the following:
855 Open an existing file for input.
857 Open a file for output, creating it if it doesn't already exist
858 or removing its contents if it does.
860 Open a file for output, creating it if it doesn't already
861 exist. All writes to the port will go to the end of the file.
862 The "append mode" can be turned off while the port is in use
863 @pxref{Ports and File Descriptors, fcntl}
866 The following additional characters can be appended:
870 Open the port for both input and output. E.g., @code{r+}: open
871 an existing file for both input and output.
873 Create an "unbuffered" port. In this case input and output
874 operations are passed directly to the underlying port
875 implementation without additional buffering. This is likely to
876 slow down I/O operations. The buffering mode can be changed
877 while a port is in use @pxref{Ports and File Descriptors,
880 Add line-buffering to the port. The port output buffer will be
881 automatically flushed whenever a newline character is written.
883 Use binary mode, ensuring that each byte in the file will be read as one
886 To provide this property, the file will be opened with the 8-bit
887 character encoding "ISO-8859-1", ignoring any coding declaration or port
888 encoding. @xref{Ports}, for more information on port encodings.
890 Note that while it is possible to read and write binary data as
891 characters or strings, it is usually better to treat bytes as octets,
892 and byte sequences as bytevectors. @xref{R6RS Binary Input}, and
893 @ref{R6RS Binary Output}, for more.
895 This option had another historical meaning, for DOS compatibility: in
896 the default (textual) mode, DOS reads a CR-LF sequence as one LF byte.
897 The @code{b} flag prevents this from happening, adding @code{O_BINARY}
898 to the underlying @code{open} call. Still, the flag is generally useful
899 because of its port encoding ramifications.
902 If a file cannot be opened with the access
903 requested, @code{open-file} throws an exception.
905 When the file is opened, this procedure will scan for a coding
906 declaration (@pxref{Character Encoding of Source Files}). If a coding
907 declaration is found, it will be used to interpret the file. Otherwise,
908 the port's encoding will be used. To suppress this behavior, open the
909 file in binary mode and then set the port encoding explicitly using
910 @code{set-port-encoding!}.
912 In theory we could create read/write ports which were buffered
913 in one direction only. However this isn't included in the
917 @rnindex open-input-file
918 @deffn {Scheme Procedure} open-input-file filename
919 Open @var{filename} for input. Equivalent to
921 (open-file @var{filename} "r")
925 @rnindex open-output-file
926 @deffn {Scheme Procedure} open-output-file filename
927 Open @var{filename} for output. Equivalent to
929 (open-file @var{filename} "w")
933 @deffn {Scheme Procedure} call-with-input-file filename proc
934 @deffnx {Scheme Procedure} call-with-output-file filename proc
935 @rnindex call-with-input-file
936 @rnindex call-with-output-file
937 Open @var{filename} for input or output, and call @code{(@var{proc}
938 port)} with the resulting port. Return the value returned by
939 @var{proc}. @var{filename} is opened as per @code{open-input-file} or
940 @code{open-output-file} respectively, and an error is signaled if it
943 When @var{proc} returns, the port is closed. If @var{proc} does not
944 return (e.g.@: if it throws an error), then the port might not be
945 closed automatically, though it will be garbage collected in the usual
946 way if not otherwise referenced.
949 @deffn {Scheme Procedure} with-input-from-file filename thunk
950 @deffnx {Scheme Procedure} with-output-to-file filename thunk
951 @deffnx {Scheme Procedure} with-error-to-file filename thunk
952 @rnindex with-input-from-file
953 @rnindex with-output-to-file
954 Open @var{filename} and call @code{(@var{thunk})} with the new port
955 setup as respectively the @code{current-input-port},
956 @code{current-output-port}, or @code{current-error-port}. Return the
957 value returned by @var{thunk}. @var{filename} is opened as per
958 @code{open-input-file} or @code{open-output-file} respectively, and an
959 error is signaled if it cannot be opened.
961 When @var{thunk} returns, the port is closed and the previous setting
962 of the respective current port is restored.
964 The current port setting is managed with @code{dynamic-wind}, so the
965 previous value is restored no matter how @var{thunk} exits (eg.@: an
966 exception), and if @var{thunk} is re-entered (via a captured
967 continuation) then it's set again to the @var{filename} port.
969 The port is closed when @var{thunk} returns normally, but not when
970 exited via an exception or new continuation. This ensures it's still
971 ready for use if @var{thunk} is re-entered by a captured continuation.
972 Of course the port is always garbage collected and closed in the usual
973 way when no longer referenced anywhere.
976 @deffn {Scheme Procedure} port-mode port
977 @deffnx {C Function} scm_port_mode (port)
978 Return the port modes associated with the open port @var{port}.
979 These will not necessarily be identical to the modes used when
980 the port was opened, since modes such as "append" which are
981 used only during port creation are not retained.
984 @deffn {Scheme Procedure} port-filename port
985 @deffnx {C Function} scm_port_filename (port)
986 Return the filename associated with @var{port}, or @code{#f} if no
987 filename is associated with the port.
989 @var{port} must be open, @code{port-filename} cannot be used once the
993 @deffn {Scheme Procedure} set-port-filename! port filename
994 @deffnx {C Function} scm_set_port_filename_x (port, filename)
995 Change the filename associated with @var{port}, using the current input
996 port if none is specified. Note that this does not change the port's
997 source of data, but only the value that is returned by
998 @code{port-filename} and reported in diagnostic output.
1001 @deffn {Scheme Procedure} file-port? obj
1002 @deffnx {C Function} scm_file_port_p (obj)
1003 Determine whether @var{obj} is a port that is related to a file.
1008 @subsubsection String Ports
1010 @cindex Port, string
1012 The following allow string ports to be opened by analogy to R4RS
1013 file port facilities:
1015 With string ports, the port-encoding is treated differently than other
1016 types of ports. When string ports are created, they do not inherit a
1017 character encoding from the current locale. They are given a
1018 default locale that allows them to handle all valid string characters.
1019 Typically one should not modify a string port's character encoding
1020 away from its default.
1022 @deffn {Scheme Procedure} call-with-output-string proc
1023 @deffnx {C Function} scm_call_with_output_string (proc)
1024 Calls the one-argument procedure @var{proc} with a newly created output
1025 port. When the function returns, the string composed of the characters
1026 written into the port is returned. @var{proc} should not close the port.
1028 Note that which characters can be written to a string port depend on the port's
1029 encoding. The default encoding of string ports is specified by the
1030 @code{%default-port-encoding} fluid (@pxref{Ports,
1031 @code{%default-port-encoding}}). For instance, it is an error to write Greek
1032 letter alpha to an ISO-8859-1-encoded string port since this character cannot be
1033 represented with ISO-8859-1:
1036 (define alpha (integer->char #x03b1)) ; GREEK SMALL LETTER ALPHA
1038 (with-fluids ((%default-port-encoding "ISO-8859-1"))
1039 (call-with-output-string
1041 (display alpha p))))
1044 Throw to key `encoding-error'
1047 Changing the string port's encoding to a Unicode-capable encoding such as UTF-8
1051 @deffn {Scheme Procedure} call-with-input-string string proc
1052 @deffnx {C Function} scm_call_with_input_string (string, proc)
1053 Calls the one-argument procedure @var{proc} with a newly
1054 created input port from which @var{string}'s contents may be
1055 read. The value yielded by the @var{proc} is returned.
1058 @deffn {Scheme Procedure} with-output-to-string thunk
1059 Calls the zero-argument procedure @var{thunk} with the current output
1060 port set temporarily to a new string port. It returns a string
1061 composed of the characters written to the current output.
1063 See @code{call-with-output-string} above for character encoding considerations.
1066 @deffn {Scheme Procedure} with-input-from-string string thunk
1067 Calls the zero-argument procedure @var{thunk} with the current input
1068 port set temporarily to a string port opened on the specified
1069 @var{string}. The value yielded by @var{thunk} is returned.
1072 @deffn {Scheme Procedure} open-input-string str
1073 @deffnx {C Function} scm_open_input_string (str)
1074 Take a string and return an input port that delivers characters
1075 from the string. The port can be closed by
1076 @code{close-input-port}, though its storage will be reclaimed
1077 by the garbage collector if it becomes inaccessible.
1080 @deffn {Scheme Procedure} open-output-string
1081 @deffnx {C Function} scm_open_output_string ()
1082 Return an output port that will accumulate characters for
1083 retrieval by @code{get-output-string}. The port can be closed
1084 by the procedure @code{close-output-port}, though its storage
1085 will be reclaimed by the garbage collector if it becomes
1089 @deffn {Scheme Procedure} get-output-string port
1090 @deffnx {C Function} scm_get_output_string (port)
1091 Given an output port created by @code{open-output-string},
1092 return a string consisting of the characters that have been
1093 output to the port so far.
1095 @code{get-output-string} must be used before closing @var{port}, once
1096 closed the string cannot be obtained.
1099 A string port can be used in many procedures which accept a port
1100 but which are not dependent on implementation details of fports.
1101 E.g., seeking and truncating will work on a string port,
1102 but trying to extract the file descriptor number will fail.
1106 @subsubsection Soft Ports
1110 A @dfn{soft-port} is a port based on a vector of procedures capable of
1111 accepting or delivering characters. It allows emulation of I/O ports.
1113 @deffn {Scheme Procedure} make-soft-port pv modes
1114 @deffnx {C Function} scm_make_soft_port (pv, modes)
1115 Return a port capable of receiving or delivering characters as
1116 specified by the @var{modes} string (@pxref{File Ports,
1117 open-file}). @var{pv} must be a vector of length 5 or 6. Its
1118 components are as follows:
1122 procedure accepting one character for output
1124 procedure accepting a string for output
1126 thunk for flushing output
1128 thunk for getting one character
1130 thunk for closing port (not by garbage collection)
1132 (if present and not @code{#f}) thunk for computing the number of
1133 characters that can be read from the port without blocking.
1136 For an output-only port only elements 0, 1, 2, and 4 need be
1137 procedures. For an input-only port only elements 3 and 4 need
1138 be procedures. Thunks 2 and 4 can instead be @code{#f} if
1139 there is no useful operation for them to perform.
1141 If thunk 3 returns @code{#f} or an @code{eof-object}
1142 (@pxref{Input, eof-object?, ,r5rs, The Revised^5 Report on
1143 Scheme}) it indicates that the port has reached end-of-file.
1147 (define stdout (current-output-port))
1148 (define p (make-soft-port
1150 (lambda (c) (write c stdout))
1151 (lambda (s) (display s stdout))
1152 (lambda () (display "." stdout))
1153 (lambda () (char-upcase (read-char)))
1154 (lambda () (display "@@" stdout)))
1157 (write p p) @result{} #<input-output: soft 8081e20>
1163 @subsubsection Void Ports
1167 This kind of port causes any data to be discarded when written to, and
1168 always returns the end-of-file object when read from.
1170 @deffn {Scheme Procedure} %make-void-port mode
1171 @deffnx {C Function} scm_sys_make_void_port (mode)
1172 Create and return a new void port. A void port acts like
1173 @file{/dev/null}. The @var{mode} argument
1174 specifies the input/output modes for this port: see the
1175 documentation for @code{open-file} in @ref{File Ports}.
1179 @node R6RS I/O Ports
1180 @subsection R6RS I/O Ports
1185 The I/O port API of the @uref{http://www.r6rs.org/, Revised Report^6 on
1186 the Algorithmic Language Scheme (R6RS)} is provided by the @code{(rnrs
1187 io ports)} module. It provides features, such as binary I/O and Unicode
1188 string I/O, that complement or refine Guile's historical port API
1189 presented above (@pxref{Input and Output}). Note that R6RS ports are not
1190 disjoint from Guile's native ports, so Guile-specific procedures will
1191 work on ports created using the R6RS API, and vice versa.
1193 The text in this section is taken from the R6RS standard libraries
1194 document, with only minor adaptions for inclusion in this manual. The
1195 Guile developers offer their thanks to the R6RS editors for having
1196 provided the report's text under permissive conditions making this
1199 @c FIXME: Update description when implemented.
1200 @emph{Note}: The implementation of this R6RS API is not complete yet.
1203 * R6RS File Names:: File names.
1204 * R6RS File Options:: Options for opening files.
1205 * R6RS Buffer Modes:: Influencing buffering behavior.
1206 * R6RS Transcoders:: Influencing port encoding.
1207 * R6RS End-of-File:: The end-of-file object.
1208 * R6RS Port Manipulation:: Manipulating R6RS ports.
1209 * R6RS Input Ports:: Input Ports.
1210 * R6RS Binary Input:: Binary input.
1211 * R6RS Textual Input:: Textual input.
1212 * R6RS Output Ports:: Output Ports.
1213 * R6RS Binary Output:: Binary output.
1214 * R6RS Textual Output:: Textual output.
1217 A subset of the @code{(rnrs io ports)} module is provided by the
1218 @code{(ice-9 binary-ports)} module. It contains binary input/output
1219 procedures and does not rely on R6RS support.
1221 @node R6RS File Names
1222 @subsubsection File Names
1224 Some of the procedures described in this chapter accept a file name as an
1225 argument. Valid values for such a file name include strings that name a file
1226 using the native notation of file system paths on an implementation's
1227 underlying operating system, and may include implementation-dependent
1230 A @var{filename} parameter name means that the
1231 corresponding argument must be a file name.
1233 @node R6RS File Options
1234 @subsubsection File Options
1235 @cindex file options
1237 When opening a file, the various procedures in this library accept a
1238 @code{file-options} object that encapsulates flags to specify how the
1239 file is to be opened. A @code{file-options} object is an enum-set
1240 (@pxref{rnrs enums}) over the symbols constituting valid file options.
1242 A @var{file-options} parameter name means that the corresponding
1243 argument must be a file-options object.
1245 @deffn {Scheme Syntax} file-options @var{file-options-symbol} ...
1247 Each @var{file-options-symbol} must be a symbol.
1249 The @code{file-options} syntax returns a file-options object that
1250 encapsulates the specified options.
1252 When supplied to an operation that opens a file for output, the
1253 file-options object returned by @code{(file-options)} specifies that the
1254 file is created if it does not exist and an exception with condition
1255 type @code{&i/o-file-already-exists} is raised if it does exist. The
1256 following standard options can be included to modify the default
1261 If the file does not already exist, it is not created;
1262 instead, an exception with condition type @code{&i/o-file-does-not-exist}
1264 If the file already exists, the exception with condition type
1265 @code{&i/o-file-already-exists} is not raised
1266 and the file is truncated to zero length.
1268 If the file already exists, the exception with condition type
1269 @code{&i/o-file-already-exists} is not raised,
1270 even if @code{no-create} is not included,
1271 and the file is truncated to zero length.
1273 If the file already exists and the exception with condition type
1274 @code{&i/o-file-already-exists} has been inhibited by inclusion of
1275 @code{no-create} or @code{no-fail}, the file is not truncated, but
1276 the port's current position is still set to the beginning of the
1280 These options have no effect when a file is opened only for input.
1281 Symbols other than those listed above may be used as
1282 @var{file-options-symbol}s; they have implementation-specific meaning,
1286 Only the name of @var{file-options-symbol} is significant.
1290 @node R6RS Buffer Modes
1291 @subsubsection Buffer Modes
1293 Each port has an associated buffer mode. For an output port, the
1294 buffer mode defines when an output operation flushes the buffer
1295 associated with the output port. For an input port, the buffer mode
1296 defines how much data will be read to satisfy read operations. The
1297 possible buffer modes are the symbols @code{none} for no buffering,
1298 @code{line} for flushing upon line endings and reading up to line
1299 endings, or other implementation-dependent behavior,
1300 and @code{block} for arbitrary buffering. This section uses
1301 the parameter name @var{buffer-mode} for arguments that must be
1302 buffer-mode symbols.
1304 If two ports are connected to the same mutable source, both ports
1305 are unbuffered, and reading a byte or character from that shared
1306 source via one of the two ports would change the bytes or characters
1307 seen via the other port, a lookahead operation on one port will
1308 render the peeked byte or character inaccessible via the other port,
1309 while a subsequent read operation on the peeked port will see the
1310 peeked byte or character even though the port is otherwise unbuffered.
1312 In other words, the semantics of buffering is defined in terms of side
1313 effects on shared mutable sources, and a lookahead operation has the
1314 same side effect on the shared source as a read operation.
1316 @deffn {Scheme Syntax} buffer-mode @var{buffer-mode-symbol}
1318 @var{buffer-mode-symbol} must be a symbol whose name is one of
1319 @code{none}, @code{line}, and @code{block}. The result is the
1320 corresponding symbol, and specifies the associated buffer mode.
1323 Only the name of @var{buffer-mode-symbol} is significant.
1327 @deffn {Scheme Procedure} buffer-mode? obj
1328 Returns @code{#t} if the argument is a valid buffer-mode symbol, and
1329 returns @code{#f} otherwise.
1332 @node R6RS Transcoders
1333 @subsubsection Transcoders
1335 @cindex end-of-line style
1338 @cindex textual port
1340 Several different Unicode encoding schemes describe standard ways to
1341 encode characters and strings as byte sequences and to decode those
1342 sequences. Within this document, a @dfn{codec} is an immutable Scheme
1343 object that represents a Unicode or similar encoding scheme.
1345 An @dfn{end-of-line style} is a symbol that, if it is not @code{none},
1346 describes how a textual port transcodes representations of line endings.
1348 A @dfn{transcoder} is an immutable Scheme object that combines a codec
1349 with an end-of-line style and a method for handling decoding errors.
1350 Each transcoder represents some specific bidirectional (but not
1351 necessarily lossless), possibly stateful translation between byte
1352 sequences and Unicode characters and strings. Every transcoder can
1353 operate in the input direction (bytes to characters) or in the output
1354 direction (characters to bytes). A @var{transcoder} parameter name
1355 means that the corresponding argument must be a transcoder.
1357 A @dfn{binary port} is a port that supports binary I/O, does not have an
1358 associated transcoder and does not support textual I/O. A @dfn{textual
1359 port} is a port that supports textual I/O, and does not support binary
1360 I/O. A textual port may or may not have an associated transcoder.
1362 @deffn {Scheme Procedure} latin-1-codec
1363 @deffnx {Scheme Procedure} utf-8-codec
1364 @deffnx {Scheme Procedure} utf-16-codec
1366 These are predefined codecs for the ISO 8859-1, UTF-8, and UTF-16
1369 A call to any of these procedures returns a value that is equal in the
1370 sense of @code{eqv?} to the result of any other call to the same
1374 @deffn {Scheme Syntax} eol-style @var{eol-style-symbol}
1376 @var{eol-style-symbol} should be a symbol whose name is one of
1377 @code{lf}, @code{cr}, @code{crlf}, @code{nel}, @code{crnel}, @code{ls},
1380 The form evaluates to the corresponding symbol. If the name of
1381 @var{eol-style-symbol} is not one of these symbols, the effect and
1382 result are implementation-dependent; in particular, the result may be an
1383 eol-style symbol acceptable as an @var{eol-style} argument to
1384 @code{make-transcoder}. Otherwise, an exception is raised.
1386 All eol-style symbols except @code{none} describe a specific
1387 line-ending encoding:
1395 carriage return, linefeed
1399 carriage return, next line
1404 For a textual port with a transcoder, and whose transcoder has an
1405 eol-style symbol @code{none}, no conversion occurs. For a textual input
1406 port, any eol-style symbol other than @code{none} means that all of the
1407 above line-ending encodings are recognized and are translated into a
1408 single linefeed. For a textual output port, @code{none} and @code{lf}
1409 are equivalent. Linefeed characters are encoded according to the
1410 specified eol-style symbol, and all other characters that participate in
1411 possible line endings are encoded as is.
1414 Only the name of @var{eol-style-symbol} is significant.
1418 @deffn {Scheme Procedure} native-eol-style
1419 Returns the default end-of-line style of the underlying platform, e.g.,
1420 @code{lf} on Unix and @code{crlf} on Windows.
1423 @deffn {Condition Type} &i/o-decoding
1424 @deffnx {Scheme Procedure} make-i/o-decoding-error port
1425 @deffnx {Scheme Procedure} i/o-decoding-error? obj
1427 This condition type could be defined by
1430 (define-condition-type &i/o-decoding &i/o-port
1431 make-i/o-decoding-error i/o-decoding-error?)
1434 An exception with this type is raised when one of the operations for
1435 textual input from a port encounters a sequence of bytes that cannot be
1436 translated into a character or string by the input direction of the
1439 When such an exception is raised, the port's position is past the
1443 @deffn {Condition Type} &i/o-encoding
1444 @deffnx {Scheme Procedure} make-i/o-encoding-error port char
1445 @deffnx {Scheme Procedure} i/o-encoding-error? obj
1446 @deffnx {Scheme Procedure} i/o-encoding-error-char condition
1448 This condition type could be defined by
1451 (define-condition-type &i/o-encoding &i/o-port
1452 make-i/o-encoding-error i/o-encoding-error?
1453 (char i/o-encoding-error-char))
1456 An exception with this type is raised when one of the operations for
1457 textual output to a port encounters a character that cannot be
1458 translated into bytes by the output direction of the port's transcoder.
1459 @var{char} is the character that could not be encoded.
1462 @deffn {Scheme Syntax} error-handling-mode @var{error-handling-mode-symbol}
1464 @var{error-handling-mode-symbol} should be a symbol whose name is one of
1465 @code{ignore}, @code{raise}, and @code{replace}. The form evaluates to
1466 the corresponding symbol. If @var{error-handling-mode-symbol} is not
1467 one of these identifiers, effect and result are
1468 implementation-dependent: The result may be an error-handling-mode
1469 symbol acceptable as a @var{handling-mode} argument to
1470 @code{make-transcoder}. If it is not acceptable as a
1471 @var{handling-mode} argument to @code{make-transcoder}, an exception is
1475 Only the name of @var{error-handling-mode-symbol} is significant.
1478 The error-handling mode of a transcoder specifies the behavior
1479 of textual I/O operations in the presence of encoding or decoding
1482 If a textual input operation encounters an invalid or incomplete
1483 character encoding, and the error-handling mode is @code{ignore}, an
1484 appropriate number of bytes of the invalid encoding are ignored and
1485 decoding continues with the following bytes.
1487 If the error-handling mode is @code{replace}, the replacement
1488 character U+FFFD is injected into the data stream, an appropriate
1489 number of bytes are ignored, and decoding
1490 continues with the following bytes.
1492 If the error-handling mode is @code{raise}, an exception with condition
1493 type @code{&i/o-decoding} is raised.
1495 If a textual output operation encounters a character it cannot encode,
1496 and the error-handling mode is @code{ignore}, the character is ignored
1497 and encoding continues with the next character. If the error-handling
1498 mode is @code{replace}, a codec-specific replacement character is
1499 emitted by the transcoder, and encoding continues with the next
1500 character. The replacement character is U+FFFD for transcoders whose
1501 codec is one of the Unicode encodings, but is the @code{?} character
1502 for the Latin-1 encoding. If the error-handling mode is @code{raise},
1503 an exception with condition type @code{&i/o-encoding} is raised.
1506 @deffn {Scheme Procedure} make-transcoder codec
1507 @deffnx {Scheme Procedure} make-transcoder codec eol-style
1508 @deffnx {Scheme Procedure} make-transcoder codec eol-style handling-mode
1510 @var{codec} must be a codec; @var{eol-style}, if present, an eol-style
1511 symbol; and @var{handling-mode}, if present, an error-handling-mode
1514 @var{eol-style} may be omitted, in which case it defaults to the native
1515 end-of-line style of the underlying platform. @var{handling-mode} may
1516 be omitted, in which case it defaults to @code{replace}. The result is
1517 a transcoder with the behavior specified by its arguments.
1520 @deffn {Scheme procedure} native-transcoder
1521 Returns an implementation-dependent transcoder that represents a
1522 possibly locale-dependent ``native'' transcoding.
1525 @deffn {Scheme Procedure} transcoder-codec transcoder
1526 @deffnx {Scheme Procedure} transcoder-eol-style transcoder
1527 @deffnx {Scheme Procedure} transcoder-error-handling-mode transcoder
1529 These are accessors for transcoder objects; when applied to a
1530 transcoder returned by @code{make-transcoder}, they return the
1531 @var{codec}, @var{eol-style}, and @var{handling-mode} arguments,
1535 @deffn {Scheme Procedure} bytevector->string bytevector transcoder
1537 Returns the string that results from transcoding the
1538 @var{bytevector} according to the input direction of the transcoder.
1541 @deffn {Scheme Procedure} string->bytevector string transcoder
1543 Returns the bytevector that results from transcoding the
1544 @var{string} according to the output direction of the transcoder.
1547 @node R6RS End-of-File
1548 @subsubsection The End-of-File Object
1553 R5RS' @code{eof-object?} procedure is provided by the @code{(rnrs io
1556 @deffn {Scheme Procedure} eof-object? obj
1557 @deffnx {C Function} scm_eof_object_p (obj)
1558 Return true if @var{obj} is the end-of-file (EOF) object.
1561 In addition, the following procedure is provided:
1563 @deffn {Scheme Procedure} eof-object
1564 @deffnx {C Function} scm_eof_object ()
1565 Return the end-of-file (EOF) object.
1568 (eof-object? (eof-object))
1574 @node R6RS Port Manipulation
1575 @subsubsection Port Manipulation
1577 The procedures listed below operate on any kind of R6RS I/O port.
1579 @deffn {Scheme Procedure} port? obj
1580 Returns @code{#t} if the argument is a port, and returns @code{#f}
1584 @deffn {Scheme Procedure} port-transcoder port
1585 Returns the transcoder associated with @var{port} if @var{port} is
1586 textual and has an associated transcoder, and returns @code{#f} if
1587 @var{port} is binary or does not have an associated transcoder.
1590 @deffn {Scheme Procedure} binary-port? port
1591 Return @code{#t} if @var{port} is a @dfn{binary port}, suitable for
1592 binary data input/output.
1594 Note that internally Guile does not differentiate between binary and
1595 textual ports, unlike the R6RS. Thus, this procedure returns true when
1596 @var{port} does not have an associated encoding---i.e., when
1597 @code{(port-encoding @var{port})} is @code{#f} (@pxref{Ports,
1598 port-encoding}). This is the case for ports returned by R6RS procedures
1599 such as @code{open-bytevector-input-port} and
1600 @code{make-custom-binary-output-port}.
1602 However, Guile currently does not prevent use of textual I/O procedures
1603 such as @code{display} or @code{read-char} with binary ports. Doing so
1604 ``upgrades'' the port from binary to textual, under the ISO-8859-1
1605 encoding. Likewise, Guile does not prevent use of
1606 @code{set-port-encoding!} on a binary port, which also turns it into a
1610 @deffn {Scheme Procedure} textual-port? port
1611 Always return @code{#t}, as all ports can be used for textual I/O in
1615 @deffn {Scheme Procedure} transcoded-port binary-port transcoder
1616 The @code{transcoded-port} procedure
1617 returns a new textual port with the specified @var{transcoder}.
1618 Otherwise the new textual port's state is largely the same as
1619 that of @var{binary-port}.
1620 If @var{binary-port} is an input port, the new textual
1621 port will be an input port and
1622 will transcode the bytes that have not yet been read from
1624 If @var{binary-port} is an output port, the new textual
1625 port will be an output port and
1626 will transcode output characters into bytes that are
1627 written to the byte sink represented by @var{binary-port}.
1629 As a side effect, however, @code{transcoded-port}
1630 closes @var{binary-port} in
1631 a special way that allows the new textual port to continue to
1632 use the byte source or sink represented by @var{binary-port},
1633 even though @var{binary-port} itself is closed and cannot
1634 be used by the input and output operations described in this
1638 @deffn {Scheme Procedure} port-position port
1639 If @var{port} supports it (see below), return the offset (an integer)
1640 indicating where the next octet will be read from/written to in
1641 @var{port}. If @var{port} does not support this operation, an error
1642 condition is raised.
1644 This is similar to Guile's @code{seek} procedure with the
1645 @code{SEEK_CUR} argument (@pxref{Random Access}).
1648 @deffn {Scheme Procedure} port-has-port-position? port
1649 Return @code{#t} is @var{port} supports @code{port-position}.
1652 @deffn {Scheme Procedure} set-port-position! port offset
1653 If @var{port} supports it (see below), set the position where the next
1654 octet will be read from/written to @var{port} to @var{offset} (an
1655 integer). If @var{port} does not support this operation, an error
1656 condition is raised.
1658 This is similar to Guile's @code{seek} procedure with the
1659 @code{SEEK_SET} argument (@pxref{Random Access}).
1662 @deffn {Scheme Procedure} port-has-set-port-position!? port
1663 Return @code{#t} is @var{port} supports @code{set-port-position!}.
1666 @deffn {Scheme Procedure} call-with-port port proc
1667 Call @var{proc}, passing it @var{port} and closing @var{port} upon exit
1668 of @var{proc}. Return the return values of @var{proc}.
1671 @node R6RS Input Ports
1672 @subsubsection Input Ports
1674 @deffn {Scheme Procedure} input-port? obj
1675 Returns @code{#t} if the argument is an input port (or a combined input
1676 and output port), and returns @code{#f} otherwise.
1679 @deffn {Scheme Procedure} port-eof? input-port
1681 if the @code{lookahead-u8} procedure (if @var{input-port} is a binary port)
1682 or the @code{lookahead-char} procedure (if @var{input-port} is a textual port)
1684 the end-of-file object, and @code{#f} otherwise.
1685 The operation may block indefinitely if no data is available
1686 but the port cannot be determined to be at end of file.
1689 @deffn {Scheme Procedure} open-file-input-port filename
1690 @deffnx {Scheme Procedure} open-file-input-port filename file-options
1691 @deffnx {Scheme Procedure} open-file-input-port filename file-options buffer-mode
1692 @deffnx {Scheme Procedure} open-file-input-port filename file-options buffer-mode maybe-transcoder
1693 @var{maybe-transcoder} must be either a transcoder or @code{#f}.
1695 The @code{open-file-input-port} procedure returns an
1696 input port for the named file. The @var{file-options} and
1697 @var{maybe-transcoder} arguments are optional.
1699 The @var{file-options} argument, which may determine
1700 various aspects of the returned port (@pxref{R6RS File Options}),
1701 defaults to the value of @code{(file-options)}.
1703 The @var{buffer-mode} argument, if supplied,
1704 must be one of the symbols that name a buffer mode.
1705 The @var{buffer-mode} argument defaults to @code{block}.
1707 If @var{maybe-transcoder} is a transcoder, it becomes the transcoder associated
1708 with the returned port.
1710 If @var{maybe-transcoder} is @code{#f} or absent,
1711 the port will be a binary port and will support the
1712 @code{port-position} and @code{set-port-position!} operations.
1713 Otherwise the port will be a textual port, and whether it supports
1714 the @code{port-position} and @code{set-port-position!} operations
1715 is implementation-dependent (and possibly transcoder-dependent).
1718 @deffn {Scheme Procedure} standard-input-port
1719 Returns a fresh binary input port connected to standard input. Whether
1720 the port supports the @code{port-position} and @code{set-port-position!}
1721 operations is implementation-dependent.
1724 @deffn {Scheme Procedure} current-input-port
1725 This returns a default textual port for input. Normally, this default
1726 port is associated with standard input, but can be dynamically
1727 re-assigned using the @code{with-input-from-file} procedure from the
1728 @code{io simple (6)} library (@pxref{rnrs io simple}). The port may or
1729 may not have an associated transcoder; if it does, the transcoder is
1730 implementation-dependent.
1733 @node R6RS Binary Input
1734 @subsubsection Binary Input
1736 @cindex binary input
1738 R6RS binary input ports can be created with the procedures described
1741 @deffn {Scheme Procedure} open-bytevector-input-port bv [transcoder]
1742 @deffnx {C Function} scm_open_bytevector_input_port (bv, transcoder)
1743 Return an input port whose contents are drawn from bytevector @var{bv}
1744 (@pxref{Bytevectors}).
1746 @c FIXME: Update description when implemented.
1747 The @var{transcoder} argument is currently not supported.
1750 @cindex custom binary input ports
1752 @deffn {Scheme Procedure} make-custom-binary-input-port id read! get-position set-position! close
1753 @deffnx {C Function} scm_make_custom_binary_input_port (id, read!, get-position, set-position!, close)
1754 Return a new custom binary input port@footnote{This is similar in spirit
1755 to Guile's @dfn{soft ports} (@pxref{Soft Ports}).} named @var{id} (a
1756 string) whose input is drained by invoking @var{read!} and passing it a
1757 bytevector, an index where bytes should be written, and the number of
1758 bytes to read. The @code{read!} procedure must return an integer
1759 indicating the number of bytes read, or @code{0} to indicate the
1762 Optionally, if @var{get-position} is not @code{#f}, it must be a thunk
1763 that will be called when @code{port-position} is invoked on the custom
1764 binary port and should return an integer indicating the position within
1765 the underlying data stream; if @var{get-position} was not supplied, the
1766 returned port does not support @code{port-position}.
1768 Likewise, if @var{set-position!} is not @code{#f}, it should be a
1769 one-argument procedure. When @code{set-port-position!} is invoked on the
1770 custom binary input port, @var{set-position!} is passed an integer
1771 indicating the position of the next byte is to read.
1773 Finally, if @var{close} is not @code{#f}, it must be a thunk. It is
1774 invoked when the custom binary input port is closed.
1776 Using a custom binary input port, the @code{open-bytevector-input-port}
1777 procedure could be implemented as follows:
1780 (define (open-bytevector-input-port source)
1782 (define length (bytevector-length source))
1784 (define (read! bv start count)
1785 (let ((count (min count (- length position))))
1786 (bytevector-copy! source position
1788 (set! position (+ position count))
1791 (define (get-position) position)
1793 (define (set-position! new-position)
1794 (set! position new-position))
1796 (make-custom-binary-input-port "the port" read!
1800 (read (open-bytevector-input-port (string->utf8 "hello")))
1805 @cindex binary input
1806 Binary input is achieved using the procedures below:
1808 @deffn {Scheme Procedure} get-u8 port
1809 @deffnx {C Function} scm_get_u8 (port)
1810 Return an octet read from @var{port}, a binary input port, blocking as
1811 necessary, or the end-of-file object.
1814 @deffn {Scheme Procedure} lookahead-u8 port
1815 @deffnx {C Function} scm_lookahead_u8 (port)
1816 Like @code{get-u8} but does not update @var{port}'s position to point
1820 @deffn {Scheme Procedure} get-bytevector-n port count
1821 @deffnx {C Function} scm_get_bytevector_n (port, count)
1822 Read @var{count} octets from @var{port}, blocking as necessary and
1823 return a bytevector containing the octets read. If fewer bytes are
1824 available, a bytevector smaller than @var{count} is returned.
1827 @deffn {Scheme Procedure} get-bytevector-n! port bv start count
1828 @deffnx {C Function} scm_get_bytevector_n_x (port, bv, start, count)
1829 Read @var{count} bytes from @var{port} and store them in @var{bv}
1830 starting at index @var{start}. Return either the number of bytes
1831 actually read or the end-of-file object.
1834 @deffn {Scheme Procedure} get-bytevector-some port
1835 @deffnx {C Function} scm_get_bytevector_some (port)
1836 Read from @var{port}, blocking as necessary, until bytes are available
1837 or an end-of-file is reached. Return either the end-of-file object or a
1838 new bytevector containing some of the available bytes (at least one),
1839 and update the port position to point just past these bytes.
1842 @deffn {Scheme Procedure} get-bytevector-all port
1843 @deffnx {C Function} scm_get_bytevector_all (port)
1844 Read from @var{port}, blocking as necessary, until the end-of-file is
1845 reached. Return either a new bytevector containing the data read or the
1846 end-of-file object (if no data were available).
1849 @node R6RS Textual Input
1850 @subsubsection Textual Input
1852 @deffn {Scheme Procedure} get-char textual-input-port
1853 Reads from @var{textual-input-port}, blocking as necessary, until a
1854 complete character is available from @var{textual-input-port},
1855 or until an end of file is reached.
1857 If a complete character is available before the next end of file,
1858 @code{get-char} returns that character and updates the input port to
1859 point past the character. If an end of file is reached before any
1860 character is read, @code{get-char} returns the end-of-file object.
1863 @deffn {Scheme Procedure} lookahead-char textual-input-port
1864 The @code{lookahead-char} procedure is like @code{get-char}, but it does
1865 not update @var{textual-input-port} to point past the character.
1868 @deffn {Scheme Procedure} get-string-n textual-input-port count
1870 @var{count} must be an exact, non-negative integer object, representing
1871 the number of characters to be read.
1873 The @code{get-string-n} procedure reads from @var{textual-input-port},
1874 blocking as necessary, until @var{count} characters are available, or
1875 until an end of file is reached.
1877 If @var{count} characters are available before end of file,
1878 @code{get-string-n} returns a string consisting of those @var{count}
1879 characters. If fewer characters are available before an end of file, but
1880 one or more characters can be read, @code{get-string-n} returns a string
1881 containing those characters. In either case, the input port is updated
1882 to point just past the characters read. If no characters can be read
1883 before an end of file, the end-of-file object is returned.
1886 @deffn {Scheme Procedure} get-string-n! textual-input-port string start count
1888 @var{start} and @var{count} must be exact, non-negative integer objects,
1889 with @var{count} representing the number of characters to be read.
1890 @var{string} must be a string with at least $@var{start} + @var{count}$
1893 The @code{get-string-n!} procedure reads from @var{textual-input-port}
1894 in the same manner as @code{get-string-n}. If @var{count} characters
1895 are available before an end of file, they are written into @var{string}
1896 starting at index @var{start}, and @var{count} is returned. If fewer
1897 characters are available before an end of file, but one or more can be
1898 read, those characters are written into @var{string} starting at index
1899 @var{start} and the number of characters actually read is returned as an
1900 exact integer object. If no characters can be read before an end of
1901 file, the end-of-file object is returned.
1904 @deffn {Scheme Procedure} get-string-all textual-input-port count
1905 Reads from @var{textual-input-port} until an end of file, decoding
1906 characters in the same manner as @code{get-string-n} and
1907 @code{get-string-n!}.
1909 If characters are available before the end of file, a string containing
1910 all the characters decoded from that data are returned. If no character
1911 precedes the end of file, the end-of-file object is returned.
1914 @deffn {Scheme Procedure} get-line textual-input-port
1915 Reads from @var{textual-input-port} up to and including the linefeed
1916 character or end of file, decoding characters in the same manner as
1917 @code{get-string-n} and @code{get-string-n!}.
1919 If a linefeed character is read, a string containing all of the text up
1920 to (but not including) the linefeed character is returned, and the port
1921 is updated to point just past the linefeed character. If an end of file
1922 is encountered before any linefeed character is read, but some
1923 characters have been read and decoded as characters, a string containing
1924 those characters is returned. If an end of file is encountered before
1925 any characters are read, the end-of-file object is returned.
1928 The end-of-line style, if not @code{none}, will cause all line endings
1929 to be read as linefeed characters. @xref{R6RS Transcoders}.
1933 @deffn {Scheme Procedure} get-datum textual-input-port count
1934 Reads an external representation from @var{textual-input-port} and returns the
1935 datum it represents. The @code{get-datum} procedure returns the next
1936 datum that can be parsed from the given @var{textual-input-port}, updating
1937 @var{textual-input-port} to point exactly past the end of the external
1938 representation of the object.
1940 Any @emph{interlexeme space} (comment or whitespace, @pxref{Scheme
1941 Syntax}) in the input is first skipped. If an end of file occurs after
1942 the interlexeme space, the end-of-file object (@pxref{R6RS End-of-File})
1945 If a character inconsistent with an external representation is
1946 encountered in the input, an exception with condition types
1947 @code{&lexical} and @code{&i/o-read} is raised. Also, if the end of
1948 file is encountered after the beginning of an external representation,
1949 but the external representation is incomplete and therefore cannot be
1950 parsed, an exception with condition types @code{&lexical} and
1951 @code{&i/o-read} is raised.
1954 @node R6RS Output Ports
1955 @subsubsection Output Ports
1957 @deffn {Scheme Procedure} output-port? obj
1958 Returns @code{#t} if the argument is an output port (or a
1959 combined input and output port), @code{#f} otherwise.
1962 @deffn {Scheme Procedure} flush-output-port port
1963 Flushes any buffered output from the buffer of @var{output-port} to the
1964 underlying file, device, or object. The @code{flush-output-port}
1965 procedure returns an unspecified values.
1968 @deffn {Scheme Procedure} open-file-output-port filename
1969 @deffnx {Scheme Procedure} open-file-output-port filename file-options
1970 @deffnx {Scheme Procedure} open-file-output-port filename file-options buffer-mode
1971 @deffnx {Scheme Procedure} open-file-output-port filename file-options buffer-mode maybe-transcoder
1973 @var{maybe-transcoder} must be either a transcoder or @code{#f}.
1975 The @code{open-file-output-port} procedure returns an output port for the named file.
1977 The @var{file-options} argument, which may determine various aspects of
1978 the returned port (@pxref{R6RS File Options}), defaults to the value of
1979 @code{(file-options)}.
1981 The @var{buffer-mode} argument, if supplied,
1982 must be one of the symbols that name a buffer mode.
1983 The @var{buffer-mode} argument defaults to @code{block}.
1985 If @var{maybe-transcoder} is a transcoder, it becomes the transcoder
1986 associated with the port.
1988 If @var{maybe-transcoder} is @code{#f} or absent,
1989 the port will be a binary port and will support the
1990 @code{port-position} and @code{set-port-position!} operations.
1991 Otherwise the port will be a textual port, and whether it supports
1992 the @code{port-position} and @code{set-port-position!} operations
1993 is implementation-dependent (and possibly transcoder-dependent).
1996 @deffn {Scheme Procedure} standard-output-port
1997 @deffnx {Scheme Procedure} standard-error-port
1998 Returns a fresh binary output port connected to the standard output or
1999 standard error respectively. Whether the port supports the
2000 @code{port-position} and @code{set-port-position!} operations is
2001 implementation-dependent.
2004 @deffn {Scheme Procedure} current-output-port
2005 @deffnx {Scheme Procedure} current-error-port
2006 These return default textual ports for regular output and error output.
2007 Normally, these default ports are associated with standard output, and
2008 standard error, respectively. The return value of
2009 @code{current-output-port} can be dynamically re-assigned using the
2010 @code{with-output-to-file} procedure from the @code{io simple (6)}
2011 library (@pxref{rnrs io simple}). A port returned by one of these
2012 procedures may or may not have an associated transcoder; if it does, the
2013 transcoder is implementation-dependent.
2016 @node R6RS Binary Output
2017 @subsubsection Binary Output
2019 Binary output ports can be created with the procedures below.
2021 @deffn {Scheme Procedure} open-bytevector-output-port [transcoder]
2022 @deffnx {C Function} scm_open_bytevector_output_port (transcoder)
2023 Return two values: a binary output port and a procedure. The latter
2024 should be called with zero arguments to obtain a bytevector containing
2025 the data accumulated by the port, as illustrated below.
2030 (open-bytevector-output-port))
2031 (lambda (port get-bytevector)
2032 (display "hello" port)
2035 @result{} #vu8(104 101 108 108 111)
2038 @c FIXME: Update description when implemented.
2039 The @var{transcoder} argument is currently not supported.
2042 @cindex custom binary output ports
2044 @deffn {Scheme Procedure} make-custom-binary-output-port id write! get-position set-position! close
2045 @deffnx {C Function} scm_make_custom_binary_output_port (id, write!, get-position, set-position!, close)
2046 Return a new custom binary output port named @var{id} (a string) whose
2047 output is sunk by invoking @var{write!} and passing it a bytevector, an
2048 index where bytes should be read from this bytevector, and the number of
2049 bytes to be ``written''. The @code{write!} procedure must return an
2050 integer indicating the number of bytes actually written; when it is
2051 passed @code{0} as the number of bytes to write, it should behave as
2052 though an end-of-file was sent to the byte sink.
2054 The other arguments are as for @code{make-custom-binary-input-port}
2055 (@pxref{R6RS Binary Input, @code{make-custom-binary-input-port}}).
2058 @cindex binary output
2059 Writing to a binary output port can be done using the following
2062 @deffn {Scheme Procedure} put-u8 port octet
2063 @deffnx {C Function} scm_put_u8 (port, octet)
2064 Write @var{octet}, an integer in the 0--255 range, to @var{port}, a
2068 @deffn {Scheme Procedure} put-bytevector port bv [start [count]]
2069 @deffnx {C Function} scm_put_bytevector (port, bv, start, count)
2070 Write the contents of @var{bv} to @var{port}, optionally starting at
2071 index @var{start} and limiting to @var{count} octets.
2074 @node R6RS Textual Output
2075 @subsubsection Textual Output
2077 @deffn {Scheme Procedure} put-char port char
2078 Writes @var{char} to the port. The @code{put-char} procedure returns
2081 @deffn {Scheme Procedure} put-string port string
2082 @deffnx {Scheme Procedure} put-string port string start
2083 @deffnx {Scheme Procedure} put-string port string start count
2085 @var{start} and @var{count} must be non-negative exact integer objects.
2086 @var{string} must have a length of at least @math{@var{start} +
2087 @var{count}}. @var{start} defaults to 0. @var{count} defaults to
2088 @math{@code{(string-length @var{string})} - @var{start}}$. The
2089 @code{put-string} procedure writes the @var{count} characters of
2090 @var{string} starting at index @var{start} to the port. The
2091 @code{put-string} procedure returns an unspecified value.
2094 @deffn {Scheme Procedure} put-datum textual-output-port datum
2095 @var{datum} should be a datum value. The @code{put-datum} procedure
2096 writes an external representation of @var{datum} to
2097 @var{textual-output-port}. The specific external representation is
2098 implementation-dependent. However, whenever possible, an implementation
2099 should produce a representation for which @code{get-datum}, when reading
2100 the representation, will return an object equal (in the sense of
2101 @code{equal?}) to @var{datum}.
2104 Not all datums may allow producing an external representation for which
2105 @code{get-datum} will produce an object that is equal to the
2106 original. Specifically, NaNs contained in @var{datum} may make
2111 The @code{put-datum} procedure merely writes the external
2112 representation, but no trailing delimiter. If @code{put-datum} is
2113 used to write several subsequent external representations to an
2114 output port, care should be taken to delimit them properly so they can
2115 be read back in by subsequent calls to @code{get-datum}.
2119 @node I/O Extensions
2120 @subsection Using and Extending Ports in C
2123 * C Port Interface:: Using ports from C.
2124 * Port Implementation:: How to implement a new port type in C.
2128 @node C Port Interface
2129 @subsubsection C Port Interface
2130 @cindex C port interface
2131 @cindex Port, C interface
2133 This section describes how to use Scheme ports from C.
2135 @subsubheading Port basics
2138 @tindex scm_ptob_descriptor
2140 @findex SCM_PTAB_ENTRY
2143 There are two main data structures. A port type object (ptob) is of
2144 type @code{scm_ptob_descriptor}. A port instance is of type
2145 @code{scm_port}. Given an @code{SCM} variable which points to a port,
2146 the corresponding C port object can be obtained using the
2147 @code{SCM_PTAB_ENTRY} macro. The ptob can be obtained by using
2148 @code{SCM_PTOBNUM} to give an index into the @code{scm_ptobs}
2151 @subsubheading Port buffers
2153 An input port always has a read buffer and an output port always has a
2154 write buffer. However the size of these buffers is not guaranteed to be
2155 more than one byte (e.g., the @code{shortbuf} field in @code{scm_port}
2156 which is used when no other buffer is allocated). The way in which the
2157 buffers are allocated depends on the implementation of the ptob. For
2158 example in the case of an fport, buffers may be allocated with malloc
2159 when the port is created, but in the case of an strport the underlying
2160 string is used as the buffer.
2162 @subsubheading The @code{rw_random} flag
2164 Special treatment is required for ports which can be seeked at random.
2165 Before various operations, such as seeking the port or changing from
2166 input to output on a bidirectional port or vice versa, the port
2167 implementation must be given a chance to update its state. The write
2168 buffer is updated by calling the @code{flush} ptob procedure and the
2169 input buffer is updated by calling the @code{end_input} ptob procedure.
2170 In the case of an fport, @code{flush} causes buffered output to be
2171 written to the file descriptor, while @code{end_input} causes the
2172 descriptor position to be adjusted to account for buffered input which
2175 The special treatment must be performed if the @code{rw_random} flag in
2176 the port is non-zero.
2178 @subsubheading The @code{rw_active} variable
2180 The @code{rw_active} variable in the port is only used if
2181 @code{rw_random} is set. It's defined as an enum with the following
2186 the read buffer may have unread data.
2188 @item SCM_PORT_WRITE
2189 the write buffer may have unwritten data.
2191 @item SCM_PORT_NEITHER
2192 neither the write nor the read buffer has data.
2195 @subsubheading Reading from a port.
2197 To read from a port, it's possible to either call existing libguile
2198 procedures such as @code{scm_getc} and @code{scm_read_line} or to read
2199 data from the read buffer directly. Reading from the buffer involves
2200 the following steps:
2204 Flush output on the port, if @code{rw_active} is @code{SCM_PORT_WRITE}.
2207 Fill the read buffer, if it's empty, using @code{scm_fill_input}.
2209 @item Read the data from the buffer and update the read position in
2210 the buffer. Steps 2) and 3) may be repeated as many times as required.
2212 @item Set rw_active to @code{SCM_PORT_READ} if @code{rw_random} is set.
2214 @item update the port's line and column counts.
2217 @subsubheading Writing to a port.
2219 To write data to a port, calling @code{scm_lfwrite} should be sufficient for
2220 most purposes. This takes care of the following steps:
2224 End input on the port, if @code{rw_active} is @code{SCM_PORT_READ}.
2227 Pass the data to the ptob implementation using the @code{write} ptob
2228 procedure. The advantage of using the ptob @code{write} instead of
2229 manipulating the write buffer directly is that it allows the data to be
2230 written in one operation even if the port is using the single-byte
2234 Set @code{rw_active} to @code{SCM_PORT_WRITE} if @code{rw_random}
2239 @node Port Implementation
2240 @subsubsection Port Implementation
2241 @cindex Port implementation
2243 This section describes how to implement a new port type in C.
2245 As described in the previous section, a port type object (ptob) is
2246 a structure of type @code{scm_ptob_descriptor}. A ptob is created by
2247 calling @code{scm_make_port_type}.
2249 @deftypefun scm_t_bits scm_make_port_type (char *name, int (*fill_input) (SCM port), void (*write) (SCM port, const void *data, size_t size))
2250 Return a new port type object. The @var{name}, @var{fill_input} and
2251 @var{write} parameters are initial values for those port type fields,
2252 as described below. The other fields are initialized with default
2253 values and can be changed later.
2256 All of the elements of the ptob, apart from @code{name}, are procedures
2257 which collectively implement the port behaviour. Creating a new port
2258 type mostly involves writing these procedures.
2262 A pointer to a NUL terminated string: the name of the port type. This
2263 is the only element of @code{scm_ptob_descriptor} which is not
2264 a procedure. Set via the first argument to @code{scm_make_port_type}.
2267 Called during garbage collection to mark any SCM objects that a port
2268 object may contain. It doesn't need to be set unless the port has
2269 @code{SCM} components. Set using
2271 @deftypefun void scm_set_port_mark (scm_t_bits tc, SCM (*mark) (SCM port))
2275 Called when the port is collected during gc. It
2276 should free any resources used by the port.
2279 @deftypefun void scm_set_port_free (scm_t_bits tc, size_t (*free) (SCM port))
2283 Called when @code{write} is called on the port object, to print a
2284 port description. E.g., for an fport it may produce something like:
2285 @code{#<input: /etc/passwd 3>}. Set using
2287 @deftypefun void scm_set_port_print (scm_t_bits tc, int (*print) (SCM port, SCM dest_port, scm_print_state *pstate))
2288 The first argument @var{port} is the object being printed, the second
2289 argument @var{dest_port} is where its description should go.
2293 Not used at present. Set using
2295 @deftypefun void scm_set_port_equalp (scm_t_bits tc, SCM (*equalp) (SCM, SCM))
2299 Called when the port is closed, unless it was collected during gc. It
2300 should free any resources used by the port.
2303 @deftypefun void scm_set_port_close (scm_t_bits tc, int (*close) (SCM port))
2307 Accept data which is to be written using the port. The port implementation
2308 may choose to buffer the data instead of processing it directly.
2309 Set via the third argument to @code{scm_make_port_type}.
2312 Complete the processing of buffered output data. Reset the value of
2313 @code{rw_active} to @code{SCM_PORT_NEITHER}.
2316 @deftypefun void scm_set_port_flush (scm_t_bits tc, void (*flush) (SCM port))
2320 Perform any synchronization required when switching from input to output
2321 on the port. Reset the value of @code{rw_active} to @code{SCM_PORT_NEITHER}.
2324 @deftypefun void scm_set_port_end_input (scm_t_bits tc, void (*end_input) (SCM port, int offset))
2328 Read new data into the read buffer and return the first character. It
2329 can be assumed that the read buffer is empty when this procedure is called.
2330 Set via the second argument to @code{scm_make_port_type}.
2333 Return a lower bound on the number of bytes that could be read from the
2334 port without blocking. It can be assumed that the current state of
2335 @code{rw_active} is @code{SCM_PORT_NEITHER}.
2338 @deftypefun void scm_set_port_input_waiting (scm_t_bits tc, int (*input_waiting) (SCM port))
2342 Set the current position of the port. The procedure can not make
2343 any assumptions about the value of @code{rw_active} when it's
2344 called. It can reset the buffers first if desired by using something
2348 if (pt->rw_active == SCM_PORT_READ)
2349 scm_end_input (port);
2350 else if (pt->rw_active == SCM_PORT_WRITE)
2354 However note that this will have the side effect of discarding any data
2355 in the unread-char buffer, in addition to any side effects from the
2356 @code{end_input} and @code{flush} ptob procedures. This is undesirable
2357 when seek is called to measure the current position of the port, i.e.,
2358 @code{(seek p 0 SEEK_CUR)}. The libguile fport and string port
2359 implementations take care to avoid this problem.
2361 The procedure is set using
2363 @deftypefun void scm_set_port_seek (scm_t_bits tc, scm_t_off (*seek) (SCM port, scm_t_off offset, int whence))
2367 Truncate the port data to be specified length. It can be assumed that the
2368 current state of @code{rw_active} is @code{SCM_PORT_NEITHER}.
2371 @deftypefun void scm_set_port_truncate (scm_t_bits tc, void (*truncate) (SCM port, scm_t_off length))
2377 @c TeX-master: "guile.texi"