1 /* Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
2 * 2004, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013,
3 * 2014 Free Software Foundation, Inc.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public License
7 * as published by the Free Software Foundation; either version 3 of
8 * the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 #define _LARGEFILE64_SOURCE /* ask for stat64 etc */
24 #define _GNU_SOURCE /* ask for LONG_LONG_MAX/LONG_LONG_MIN */
40 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
45 #include <sys/types.h>
47 #include <sys/select.h>
49 #include <full-write.h>
51 #include "libguile/_scm.h"
52 #include "libguile/strings.h"
53 #include "libguile/validate.h"
54 #include "libguile/gc.h"
55 #include "libguile/posix.h"
56 #include "libguile/dynwind.h"
57 #include "libguile/hashtab.h"
59 #include "libguile/fports.h"
60 #include "libguile/ports-internal.h"
62 #if SIZEOF_OFF_T == SIZEOF_INT
63 #define OFF_T_MAX INT_MAX
64 #define OFF_T_MIN INT_MIN
65 #elif SIZEOF_OFF_T == SIZEOF_LONG
66 #define OFF_T_MAX LONG_MAX
67 #define OFF_T_MIN LONG_MIN
68 #elif SIZEOF_OFF_T == SIZEOF_LONG_LONG
69 #define OFF_T_MAX LONG_LONG_MAX
70 #define OFF_T_MIN LONG_LONG_MIN
72 #error Oops, unknown OFF_T size
75 scm_t_bits scm_tc16_fport
;
78 /* default buffer size, used if the O/S won't supply a value. */
79 static const size_t default_buffer_size
= 1024;
81 /* Create FPORT buffers with specified sizes (or -1 to use default size
82 or 0 for no buffer.) */
84 scm_fport_buffer_add (SCM port
, long read_size
, long write_size
)
85 #define FUNC_NAME "scm_fport_buffer_add"
87 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
89 if (read_size
== -1 || write_size
== -1)
92 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
94 scm_t_fport
*fp
= SCM_FSTREAM (port
);
96 default_size
= (fstat (fp
->fdes
, &st
) == -1) ? default_buffer_size
99 default_size
= default_buffer_size
;
102 read_size
= default_size
;
103 if (write_size
== -1)
104 write_size
= default_size
;
107 if (SCM_INPUT_PORT_P (port
) && read_size
> 0)
109 pt
->read_buf
= scm_gc_malloc_pointerless (read_size
, "port buffer");
110 pt
->read_pos
= pt
->read_end
= pt
->read_buf
;
111 pt
->read_buf_size
= read_size
;
115 pt
->read_pos
= pt
->read_buf
= pt
->read_end
= &pt
->shortbuf
;
116 pt
->read_buf_size
= 1;
119 if (SCM_OUTPUT_PORT_P (port
) && write_size
> 0)
121 pt
->write_buf
= scm_gc_malloc_pointerless (write_size
, "port buffer");
122 pt
->write_pos
= pt
->write_buf
;
123 pt
->write_buf_size
= write_size
;
127 pt
->write_buf
= pt
->write_pos
= &pt
->shortbuf
;
128 pt
->write_buf_size
= 1;
131 pt
->write_end
= pt
->write_buf
+ pt
->write_buf_size
;
132 if (read_size
> 0 || write_size
> 0)
133 SCM_SET_CELL_WORD_0 (port
, SCM_CELL_WORD_0 (port
) & ~SCM_BUF0
);
135 SCM_SET_CELL_WORD_0 (port
, SCM_CELL_WORD_0 (port
) | SCM_BUF0
);
139 SCM_DEFINE (scm_setvbuf
, "setvbuf", 2, 1, 0,
140 (SCM port
, SCM mode
, SCM size
),
141 "Set the buffering mode for @var{port}. @var{mode} can be:\n"
148 "block buffered, using a newly allocated buffer of @var{size} bytes.\n"
149 "If @var{size} is omitted, a default size will be used.\n"
151 "Only certain types of ports are supported, most importantly\n"
153 #define FUNC_NAME s_scm_setvbuf
160 scm_t_ptob_descriptor
*ptob
;
162 port
= SCM_COERCE_OUTPORT (port
);
164 SCM_VALIDATE_OPENPORT (1, port
);
165 ptob
= SCM_PORT_DESCRIPTOR (port
);
167 if (ptob
->setvbuf
== NULL
)
168 scm_wrong_type_arg_msg (FUNC_NAME
, 1, port
,
169 "port that supports 'setvbuf'");
171 cmode
= scm_to_int (mode
);
172 if (cmode
!= _IONBF
&& cmode
!= _IOFBF
&& cmode
!= _IOLBF
)
173 scm_out_of_range (FUNC_NAME
, mode
);
177 SCM_SET_CELL_WORD_0 (port
, SCM_CELL_WORD_0 (port
) | SCM_BUFLINE
);
181 SCM_SET_CELL_WORD_0 (port
,
182 SCM_CELL_WORD_0 (port
) & ~(scm_t_bits
) SCM_BUFLINE
);
184 if (SCM_UNBNDP (size
))
193 csize
= scm_to_int (size
);
194 if (csize
< 0 || (cmode
== _IONBF
&& csize
> 0))
195 scm_out_of_range (FUNC_NAME
, size
);
198 pt
= SCM_PTAB_ENTRY (port
);
200 if (SCM_INPUT_PORT_P (port
))
202 /* Drain pending input from PORT. Don't use `scm_drain_input' since
203 it returns a string, whereas we want binary input here. */
204 ndrained
= pt
->read_end
- pt
->read_pos
;
205 if (pt
->read_buf
== pt
->putback_buf
)
206 ndrained
+= pt
->saved_read_end
- pt
->saved_read_pos
;
210 drained
= scm_gc_malloc_pointerless (ndrained
, "file port");
211 scm_take_from_input_buffers (port
, drained
, ndrained
);
217 if (SCM_OUTPUT_PORT_P (port
))
218 scm_flush_unlocked (port
);
220 if (pt
->read_buf
== pt
->putback_buf
)
222 pt
->read_buf
= pt
->saved_read_buf
;
223 pt
->read_pos
= pt
->saved_read_pos
;
224 pt
->read_end
= pt
->saved_read_end
;
225 pt
->read_buf_size
= pt
->saved_read_buf_size
;
228 ptob
->setvbuf (port
, csize
, csize
);
231 /* Put DRAINED back to PORT. */
232 scm_unget_bytes ((unsigned char *) drained
, ndrained
, port
);
234 return SCM_UNSPECIFIED
;
238 /* Move ports with the specified file descriptor to new descriptors,
239 * resetting the revealed count to 0.
242 scm_i_evict_port (void *closure
, SCM port
)
244 int fd
= * (int*) closure
;
246 if (SCM_FPORTP (port
))
251 /* XXX: In some cases, we can encounter a port with no associated ptab
253 p
= SCM_PTAB_ENTRY (port
);
254 fp
= (p
!= NULL
) ? (scm_t_fport
*) p
->stream
: NULL
;
256 if ((fp
!= NULL
) && (fp
->fdes
== fd
))
260 scm_syserror ("scm_evict_ports");
261 scm_set_port_revealed_x (port
, scm_from_int (0));
267 scm_evict_ports (int fd
)
269 scm_c_port_for_each (scm_i_evict_port
, (void *) &fd
);
273 SCM_DEFINE (scm_file_port_p
, "file-port?", 1, 0, 0,
275 "Determine whether @var{obj} is a port that is related to a file.")
276 #define FUNC_NAME s_scm_file_port_p
278 return scm_from_bool (SCM_FPORTP (obj
));
283 static SCM sys_file_port_name_canonicalization
;
284 SCM_SYMBOL (sym_relative
, "relative");
285 SCM_SYMBOL (sym_absolute
, "absolute");
288 fport_canonicalize_filename (SCM filename
)
290 SCM mode
= scm_fluid_ref (sys_file_port_name_canonicalization
);
292 if (!scm_is_string (filename
))
296 else if (scm_is_eq (mode
, sym_relative
))
300 path
= scm_variable_ref (scm_c_module_lookup (scm_the_root_module (),
302 rel
= scm_i_relativize_path (filename
, path
);
304 return scm_is_true (rel
) ? rel
: filename
;
306 else if (scm_is_eq (mode
, sym_absolute
))
310 str
= scm_to_locale_string (filename
);
311 canon
= canonicalize_file_name (str
);
314 return canon
? scm_take_locale_string (canon
) : filename
;
322 /* scm_open_file_with_encoding
323 Return a new port open on a given file.
325 The mode string must match the pattern: [rwa+]** which
326 is interpreted in the usual unix way.
328 Unless binary mode is requested, the character encoding of the new
329 port is determined as follows: First, if GUESS_ENCODING is true,
330 'file-encoding' is used to guess the encoding of the file. If
331 GUESS_ENCODING is false or if 'file-encoding' fails, ENCODING is used
332 unless it is also false. As a last resort, the default port encoding
333 is used. It is an error to pass a non-false GUESS_ENCODING or
334 ENCODING if binary mode is requested.
336 Return the new port. */
338 scm_open_file_with_encoding (SCM filename
, SCM mode
,
339 SCM guess_encoding
, SCM encoding
)
340 #define FUNC_NAME "open-file"
343 int fdes
, flags
= 0, binary
= 0;
344 unsigned int retries
;
345 char *file
, *md
, *ptr
;
347 if (SCM_UNLIKELY (!(scm_is_false (encoding
) || scm_is_string (encoding
))))
348 scm_wrong_type_arg_msg (FUNC_NAME
, 0, encoding
,
349 "encoding to be string or false");
351 scm_dynwind_begin (0);
353 file
= scm_to_locale_string (filename
);
354 scm_dynwind_free (file
);
356 md
= scm_to_locale_string (mode
);
357 scm_dynwind_free (md
);
365 flags
|= O_WRONLY
| O_CREAT
| O_TRUNC
;
368 flags
|= O_WRONLY
| O_CREAT
| O_APPEND
;
371 scm_out_of_range (FUNC_NAME
, mode
);
379 flags
= (flags
& ~(O_RDONLY
| O_WRONLY
)) | O_RDWR
;
383 #if defined (O_BINARY)
387 case '0': /* unbuffered: handled later. */
388 case 'l': /* line buffered: handled during output. */
391 scm_out_of_range (FUNC_NAME
, mode
);
396 for (retries
= 0, fdes
= -1;
397 fdes
< 0 && retries
< 2;
400 SCM_SYSCALL (fdes
= open_or_open64 (file
, flags
, 0666));
405 if (en
== EMFILE
&& retries
== 0)
406 /* Run the GC in case it collects open file ports that are no
407 longer referenced. */
408 scm_i_gc (FUNC_NAME
);
410 SCM_SYSERROR_MSG ("~A: ~S",
411 scm_cons (scm_strerror (scm_from_int (en
)),
412 scm_cons (filename
, SCM_EOL
)), en
);
416 /* Create a port from this file descriptor. The port's encoding is initially
417 %default-port-encoding. */
418 port
= scm_i_fdes_to_port (fdes
, scm_i_mode_bits (mode
),
419 fport_canonicalize_filename (filename
));
423 if (scm_is_true (encoding
))
424 scm_misc_error (FUNC_NAME
,
425 "Encoding specified on a binary port",
426 scm_list_1 (encoding
));
427 if (scm_is_true (guess_encoding
))
428 scm_misc_error (FUNC_NAME
,
429 "Request to guess encoding on a binary port",
432 /* Use the binary-friendly ISO-8859-1 encoding. */
433 scm_i_set_port_encoding_x (port
, NULL
);
439 if (scm_is_true (guess_encoding
))
441 if (SCM_INPUT_PORT_P (port
))
442 enc
= scm_i_scan_for_encoding (port
);
444 scm_misc_error (FUNC_NAME
,
445 "Request to guess encoding on an output-only port",
449 if (!enc
&& scm_is_true (encoding
))
451 char *buf
= scm_to_latin1_string (encoding
);
452 enc
= scm_gc_strdup (buf
, "encoding");
457 scm_i_set_port_encoding_x (port
, enc
);
467 scm_open_file (SCM filename
, SCM mode
)
469 return scm_open_file_with_encoding (filename
, mode
, SCM_BOOL_F
, SCM_BOOL_F
);
472 /* We can't define these using SCM_KEYWORD, because keywords have not
473 yet been initialized when scm_init_fports is called. */
474 static SCM k_guess_encoding
= SCM_UNDEFINED
;
475 static SCM k_encoding
= SCM_UNDEFINED
;
477 SCM_INTERNAL SCM
scm_i_open_file (SCM
, SCM
, SCM
);
479 SCM_DEFINE (scm_i_open_file
, "open-file", 2, 0, 1,
480 (SCM filename
, SCM mode
, SCM keyword_args
),
481 "Open the file whose name is @var{filename}, and return a port\n"
482 "representing that file. The attributes of the port are\n"
483 "determined by the @var{mode} string. The way in which this is\n"
484 "interpreted is similar to C stdio. The first character must be\n"
485 "one of the following:\n"
488 "Open an existing file for input.\n"
490 "Open a file for output, creating it if it doesn't already exist\n"
491 "or removing its contents if it does.\n"
493 "Open a file for output, creating it if it doesn't already\n"
494 "exist. All writes to the port will go to the end of the file.\n"
495 "The \"append mode\" can be turned off while the port is in use\n"
496 "@pxref{Ports and File Descriptors, fcntl}\n"
498 "The following additional characters can be appended:\n"
501 "Open the underlying file in binary mode, if supported by the system.\n"
502 "Also, open the file using the binary-compatible character encoding\n"
503 "\"ISO-8859-1\", ignoring the default port encoding.\n"
505 "Open the port for both input and output. E.g., @code{r+}: open\n"
506 "an existing file for both input and output.\n"
508 "Create an \"unbuffered\" port. In this case input and output\n"
509 "operations are passed directly to the underlying port\n"
510 "implementation without additional buffering. This is likely to\n"
511 "slow down I/O operations. The buffering mode can be changed\n"
512 "while a port is in use @pxref{Ports and File Descriptors,\n"
515 "Add line-buffering to the port. The port output buffer will be\n"
516 "automatically flushed whenever a newline character is written.\n"
518 "In theory we could create read/write ports which were buffered\n"
519 "in one direction only. However this isn't included in the\n"
520 "current interfaces. If a file cannot be opened with the access\n"
521 "requested, @code{open-file} throws an exception.")
522 #define FUNC_NAME s_scm_i_open_file
524 SCM encoding
= SCM_BOOL_F
;
525 SCM guess_encoding
= SCM_BOOL_F
;
527 scm_c_bind_keyword_arguments (FUNC_NAME
, keyword_args
, 0,
528 k_guess_encoding
, &guess_encoding
,
529 k_encoding
, &encoding
,
532 return scm_open_file_with_encoding (filename
, mode
,
533 guess_encoding
, encoding
);
538 /* Building Guile ports from a file descriptor. */
540 /* Build a Scheme port from an open file descriptor `fdes'.
541 MODE indicates whether FILE is open for reading or writing; it uses
542 the same notation as open-file's second argument.
543 NAME is a string to be used as the port's filename.
546 scm_i_fdes_to_port (int fdes
, long mode_bits
, SCM name
)
547 #define FUNC_NAME "scm_fdes_to_port"
552 /* Test that fdes is valid. */
554 int flags
= fcntl (fdes
, F_GETFL
, 0);
559 && ((flags
!= O_WRONLY
&& (mode_bits
& SCM_WRTNG
))
560 || (flags
!= O_RDONLY
&& (mode_bits
& SCM_RDNG
))))
562 SCM_MISC_ERROR ("requested file mode not available on fdes", SCM_EOL
);
565 /* If we don't have F_GETFL, as on mingw, at least we can test that
566 it is a valid file descriptor. */
568 if (fstat (fdes
, &st
) != 0)
572 fp
= (scm_t_fport
*) scm_gc_malloc_pointerless (sizeof (scm_t_fport
),
576 port
= scm_c_make_port (scm_tc16_fport
, mode_bits
, (scm_t_bits
)fp
);
578 SCM_PTAB_ENTRY (port
)->rw_random
= SCM_FDES_RANDOM_P (fdes
);
580 if (mode_bits
& SCM_BUF0
)
581 scm_fport_buffer_add (port
, 0, 0);
583 scm_fport_buffer_add (port
, -1, -1);
585 SCM_SET_FILENAME (port
, name
);
592 scm_fdes_to_port (int fdes
, char *mode
, SCM name
)
594 return scm_i_fdes_to_port (fdes
, scm_mode_bits (mode
), name
);
597 /* Return a lower bound on the number of bytes available for input. */
599 fport_input_waiting (SCM port
)
601 int fdes
= SCM_FSTREAM (port
)->fdes
;
603 struct pollfd pollfd
= { fdes
, POLLIN
, 0 };
605 if (poll (&pollfd
, 1, 0) < 0)
606 scm_syserror ("fport_input_waiting");
608 return pollfd
.revents
& POLLIN
? 1 : 0;
614 /* Revealed counts --- an oddity inherited from SCSH. */
616 #define SCM_REVEALED(x) (SCM_FSTREAM(x)->revealed)
618 static SCM revealed_ports
= SCM_EOL
;
619 static scm_i_pthread_mutex_t revealed_lock
= SCM_I_PTHREAD_MUTEX_INITIALIZER
;
621 /* Find a port in the table and return its revealed count.
622 Also used by the garbage collector.
625 scm_revealed_count (SCM port
)
629 scm_i_pthread_mutex_lock (&revealed_lock
);
630 ret
= SCM_REVEALED (port
);
631 scm_i_pthread_mutex_unlock (&revealed_lock
);
636 SCM_DEFINE (scm_port_revealed
, "port-revealed", 1, 0, 0,
638 "Return the revealed count for @var{port}.")
639 #define FUNC_NAME s_scm_port_revealed
641 port
= SCM_COERCE_OUTPORT (port
);
642 SCM_VALIDATE_OPFPORT (1, port
);
643 return scm_from_int (scm_revealed_count (port
));
647 /* Set the revealed count for a port. */
648 SCM_DEFINE (scm_set_port_revealed_x
, "set-port-revealed!", 2, 0, 0,
649 (SCM port
, SCM rcount
),
650 "Sets the revealed count for a port to a given value.\n"
651 "The return value is unspecified.")
652 #define FUNC_NAME s_scm_set_port_revealed_x
656 port
= SCM_COERCE_OUTPORT (port
);
657 SCM_VALIDATE_OPFPORT (1, port
);
659 r
= scm_to_int (rcount
);
661 scm_i_pthread_mutex_lock (&revealed_lock
);
663 prev
= SCM_REVEALED (port
);
664 SCM_REVEALED (port
) = r
;
667 revealed_ports
= scm_cons (port
, revealed_ports
);
669 revealed_ports
= scm_delq_x (port
, revealed_ports
);
671 scm_i_pthread_mutex_unlock (&revealed_lock
);
673 return SCM_UNSPECIFIED
;
677 /* Set the revealed count for a port. */
678 SCM_DEFINE (scm_adjust_port_revealed_x
, "adjust-port-revealed!", 2, 0, 0,
679 (SCM port
, SCM addend
),
680 "Add @var{addend} to the revealed count of @var{port}.\n"
681 "The return value is unspecified.")
682 #define FUNC_NAME s_scm_adjust_port_revealed_x
686 port
= SCM_COERCE_OUTPORT (port
);
687 SCM_VALIDATE_OPFPORT (1, port
);
689 a
= scm_to_int (addend
);
691 return SCM_UNSPECIFIED
;
693 scm_i_pthread_mutex_lock (&revealed_lock
);
695 SCM_REVEALED (port
) += a
;
696 if (SCM_REVEALED (port
) == a
)
697 revealed_ports
= scm_cons (port
, revealed_ports
);
698 else if (!SCM_REVEALED (port
))
699 revealed_ports
= scm_delq_x (port
, revealed_ports
);
701 scm_i_pthread_mutex_unlock (&revealed_lock
);
703 return SCM_UNSPECIFIED
;
710 fport_print (SCM exp
, SCM port
, scm_print_state
*pstate SCM_UNUSED
)
712 scm_puts_unlocked ("#<", port
);
713 scm_print_port_mode (exp
, port
);
714 if (SCM_OPFPORTP (exp
))
717 SCM name
= SCM_FILENAME (exp
);
718 if (scm_is_string (name
) || scm_is_symbol (name
))
719 scm_display (name
, port
);
721 scm_puts_unlocked (SCM_PTOBNAME (SCM_PTOBNUM (exp
)), port
);
722 scm_putc_unlocked (' ', port
);
723 fdes
= (SCM_FSTREAM (exp
))->fdes
;
725 #if (defined HAVE_TTYNAME) && (defined HAVE_POSIX)
727 scm_display (scm_ttyname (exp
), port
);
729 #endif /* HAVE_TTYNAME */
730 scm_intprint (fdes
, 10, port
);
734 scm_puts_unlocked (SCM_PTOBNAME (SCM_PTOBNUM (exp
)), port
);
735 scm_putc_unlocked (' ', port
);
736 scm_uintprint ((scm_t_bits
) SCM_PTAB_ENTRY (exp
), 16, port
);
738 scm_putc_unlocked ('>', port
);
742 static void fport_flush (SCM port
);
744 /* fill a port's read-buffer with a single read. returns the first
745 char or EOF if end of file. */
747 fport_fill_input (SCM port
)
750 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
751 scm_t_fport
*fp
= SCM_FSTREAM (port
);
753 SCM_SYSCALL (count
= read (fp
->fdes
, pt
->read_buf
, pt
->read_buf_size
));
755 scm_syserror ("fport_fill_input");
757 return (scm_t_wchar
) EOF
;
760 pt
->read_pos
= pt
->read_buf
;
761 pt
->read_end
= pt
->read_buf
+ count
;
762 return *pt
->read_buf
;
767 fport_seek (SCM port
, scm_t_off offset
, int whence
)
769 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
770 scm_t_fport
*fp
= SCM_FSTREAM (port
);
772 off_t_or_off64_t result
;
774 if (pt
->rw_active
== SCM_PORT_WRITE
)
776 if (offset
!= 0 || whence
!= SEEK_CUR
)
779 result
= rv
= lseek_or_lseek64 (fp
->fdes
, offset
, whence
);
783 /* read current position without disturbing the buffer. */
784 rv
= lseek_or_lseek64 (fp
->fdes
, offset
, whence
);
785 result
= rv
+ (pt
->write_pos
- pt
->write_buf
);
788 else if (pt
->rw_active
== SCM_PORT_READ
)
790 if (offset
!= 0 || whence
!= SEEK_CUR
)
792 /* could expand to avoid a second seek. */
793 scm_end_input_unlocked (port
);
794 result
= rv
= lseek_or_lseek64 (fp
->fdes
, offset
, whence
);
798 /* read current position without disturbing the buffer
799 (particularly the unread-char buffer). */
800 rv
= lseek_or_lseek64 (fp
->fdes
, offset
, whence
);
801 result
= rv
- (pt
->read_end
- pt
->read_pos
);
803 if (pt
->read_buf
== pt
->putback_buf
)
804 result
-= pt
->saved_read_end
- pt
->saved_read_pos
;
807 else /* SCM_PORT_NEITHER */
809 result
= rv
= lseek_or_lseek64 (fp
->fdes
, offset
, whence
);
813 scm_syserror ("fport_seek");
819 fport_truncate (SCM port
, scm_t_off length
)
821 scm_t_fport
*fp
= SCM_FSTREAM (port
);
823 if (ftruncate (fp
->fdes
, length
) == -1)
824 scm_syserror ("ftruncate");
828 fport_write (SCM port
, const void *data
, size_t size
)
829 #define FUNC_NAME "fport_write"
831 /* this procedure tries to minimize the number of writes/flushes. */
832 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
834 if (pt
->write_buf
== &pt
->shortbuf
835 || (pt
->write_pos
== pt
->write_buf
&& size
>= pt
->write_buf_size
))
837 /* Unbuffered port, or port with empty buffer and data won't fit in
839 if (full_write (SCM_FPORT_FDES (port
), data
, size
) < size
)
846 scm_t_off space
= pt
->write_end
- pt
->write_pos
;
850 /* data fits in buffer. */
851 memcpy (pt
->write_pos
, data
, size
);
852 pt
->write_pos
+= size
;
853 if (pt
->write_pos
== pt
->write_end
)
856 /* we can skip the line-buffering check if nothing's buffered. */
862 memcpy (pt
->write_pos
, data
, space
);
863 pt
->write_pos
= pt
->write_end
;
866 const void *ptr
= ((const char *) data
) + space
;
867 size_t remaining
= size
- space
;
869 if (size
>= pt
->write_buf_size
)
871 if (full_write (SCM_FPORT_FDES (port
), ptr
, remaining
)
878 memcpy (pt
->write_pos
, ptr
, remaining
);
879 pt
->write_pos
+= remaining
;
884 /* handle line buffering. */
885 if ((SCM_CELL_WORD_0 (port
) & SCM_BUFLINE
) && memchr (data
, '\n', size
))
892 fport_flush (SCM port
)
895 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
896 scm_t_fport
*fp
= SCM_FSTREAM (port
);
897 size_t count
= pt
->write_pos
- pt
->write_buf
;
899 written
= full_write (fp
->fdes
, pt
->write_buf
, count
);
901 scm_syserror ("scm_flush");
903 pt
->write_pos
= pt
->write_buf
;
904 pt
->rw_active
= SCM_PORT_NEITHER
;
907 /* clear the read buffer and adjust the file position for unread bytes. */
909 fport_end_input (SCM port
, int offset
)
911 scm_t_fport
*fp
= SCM_FSTREAM (port
);
912 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
914 offset
+= pt
->read_end
- pt
->read_pos
;
918 pt
->read_pos
= pt
->read_end
;
919 /* will throw error if unread-char used at beginning of file
920 then attempting to write. seems correct. */
921 if (lseek (fp
->fdes
, -offset
, SEEK_CUR
) == -1)
922 scm_syserror ("fport_end_input");
924 pt
->rw_active
= SCM_PORT_NEITHER
;
928 close_the_fd (void *data
)
930 scm_t_fport
*fp
= data
;
933 /* There's already one exception. That's probably enough! */
938 fport_close (SCM port
)
940 scm_t_fport
*fp
= SCM_FSTREAM (port
);
943 scm_dynwind_begin (0);
944 scm_dynwind_unwind_handler (close_the_fd
, fp
, 0);
948 scm_port_non_buffer (SCM_PTAB_ENTRY (port
));
950 rv
= close (fp
->fdes
);
952 /* It's not useful to retry after EINTR, as the file descriptor is
953 in an undefined state. See http://lwn.net/Articles/365294/.
954 Instead just throw an error if close fails, trusting that the fd
956 scm_syserror ("fport_close");
962 fport_free (SCM port
)
971 scm_t_bits tc
= scm_make_port_type ("file", fport_fill_input
, fport_write
);
973 scm_set_port_free (tc
, fport_free
);
974 scm_set_port_print (tc
, fport_print
);
975 scm_set_port_flush (tc
, fport_flush
);
976 scm_set_port_end_input (tc
, fport_end_input
);
977 scm_set_port_close (tc
, fport_close
);
978 scm_set_port_seek (tc
, fport_seek
);
979 scm_set_port_truncate (tc
, fport_truncate
);
980 scm_set_port_input_waiting (tc
, fport_input_waiting
);
981 scm_set_port_setvbuf (tc
, scm_fport_buffer_add
);
986 /* We can't initialize the keywords from 'scm_init_fports', because
987 keywords haven't yet been initialized at that point. */
989 scm_init_fports_keywords ()
991 k_guess_encoding
= scm_from_latin1_keyword ("guess-encoding");
992 k_encoding
= scm_from_latin1_keyword ("encoding");
998 scm_tc16_fport
= scm_make_fptob ();
1000 scm_c_define ("_IOFBF", scm_from_int (_IOFBF
));
1001 scm_c_define ("_IOLBF", scm_from_int (_IOLBF
));
1002 scm_c_define ("_IONBF", scm_from_int (_IONBF
));
1004 sys_file_port_name_canonicalization
= scm_make_fluid ();
1005 scm_c_define ("%file-port-name-canonicalization",
1006 sys_file_port_name_canonicalization
);
1008 #include "libguile/fports.x"