3 * Copyright (c) 1996-2006, Nick Ing-Simmons
4 * Copyright (c) 2006, 2007, 2008 Larry Wall and others
6 * You may distribute under the terms of either the GNU General Public License
7 * or the Artistic License, as specified in the README file.
11 * Hour after hour for nearly three weary days he had jogged up and down,
12 * over passes, and through long dales, and across many streams.
14 * [pp.791-792 of _The Lord of the Rings_, V/iii: "The Muster of Rohan"]
17 /* This file contains the functions needed to implement PerlIO, which
18 * is Perl's private replacement for the C stdio library. This is used
19 * by default unless you compile with -Uuseperlio or run with
20 * PERLIO=:stdio (but don't do this unless you know what you're doing)
24 * If we have ActivePerl-like PERL_IMPLICIT_SYS then we need a dTHX to get
25 * at the dispatch tables, even when we do not need it for other reasons.
26 * Invent a dSYS macro to abstract this out
28 #ifdef PERL_IMPLICIT_SYS
38 # ifndef USE_CROSS_COMPILE
45 #define PERLIO_NOT_STDIO 0
46 #if !defined(PERLIO_IS_STDIO) && !defined(USE_SFIO)
52 * This file provides those parts of PerlIO abstraction
53 * which are not #defined in perlio.h.
54 * Which these are depends on various Configure #ifdef's
58 #define PERL_IN_PERLIO_C
61 #ifdef PERL_IMPLICIT_CONTEXT
69 /* Missing proto on LynxOS */
73 /* Call the callback or PerlIOBase, and return failure. */
74 #define Perl_PerlIO_or_Base(f, callback, base, failure, args) \
75 if (PerlIOValid(f)) { \
76 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;\
77 if (tab && tab->callback) \
78 return (*tab->callback) args; \
80 return PerlIOBase_ ## base args; \
83 SETERRNO(EBADF, SS_IVCHAN); \
86 /* Call the callback or fail, and return failure. */
87 #define Perl_PerlIO_or_fail(f, callback, failure, args) \
88 if (PerlIOValid(f)) { \
89 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;\
90 if (tab && tab->callback) \
91 return (*tab->callback) args; \
92 SETERRNO(EINVAL, LIB_INVARG); \
95 SETERRNO(EBADF, SS_IVCHAN); \
98 /* Call the callback or PerlIOBase, and be void. */
99 #define Perl_PerlIO_or_Base_void(f, callback, base, args) \
100 if (PerlIOValid(f)) { \
101 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;\
102 if (tab && tab->callback) \
103 (*tab->callback) args; \
105 PerlIOBase_ ## base args; \
108 SETERRNO(EBADF, SS_IVCHAN)
110 /* Call the callback or fail, and be void. */
111 #define Perl_PerlIO_or_fail_void(f, callback, args) \
112 if (PerlIOValid(f)) { \
113 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;\
114 if (tab && tab->callback) \
115 (*tab->callback) args; \
117 SETERRNO(EINVAL, LIB_INVARG); \
120 SETERRNO(EBADF, SS_IVCHAN)
122 #if defined(__osf__) && _XOPEN_SOURCE < 500
123 extern int fseeko(FILE *, off_t, int);
124 extern off_t ftello(FILE *);
129 EXTERN_C int perlsio_binmode(FILE *fp, int iotype, int mode);
132 perlsio_binmode(FILE *fp, int iotype, int mode)
135 * This used to be contents of do_binmode in doio.c
138 # if defined(atarist)
139 PERL_UNUSED_ARG(iotype);
142 ((FILE *) fp)->_flag |= _IOBIN;
144 ((FILE *) fp)->_flag &= ~_IOBIN;
150 PERL_UNUSED_ARG(iotype);
152 if (PerlLIO_setmode(fp, mode) != -1) {
154 if (PerlLIO_setmode(fileno(fp), mode) != -1) {
156 # if defined(WIN32) && defined(__BORLANDC__)
158 * The translation mode of the stream is maintained independent
160 * the translation mode of the fd in the Borland RTL (heavy
161 * digging through their runtime sources reveal). User has to
163 * the mode explicitly for the stream (though they don't
165 * this anywhere). GSAR 97-5-24
171 fp->flags &= ~_F_BIN;
179 # if defined(USEMYBINMODE)
181 # if defined(__CYGWIN__)
182 PERL_UNUSED_ARG(iotype);
184 if (my_binmode(fp, iotype, mode) != FALSE)
190 PERL_UNUSED_ARG(iotype);
191 PERL_UNUSED_ARG(mode);
199 #define O_ACCMODE 3 /* Assume traditional implementation */
203 PerlIO_intmode2str(int rawmode, char *mode, int *writing)
205 const int result = rawmode & O_ACCMODE;
210 ptype = IoTYPE_RDONLY;
213 ptype = IoTYPE_WRONLY;
221 *writing = (result != O_RDONLY);
223 if (result == O_RDONLY) {
227 else if (rawmode & O_APPEND) {
229 if (result != O_WRONLY)
234 if (result == O_WRONLY)
241 if (rawmode & O_BINARY)
247 #ifndef PERLIO_LAYERS
249 PerlIO_apply_layers(pTHX_ PerlIO *f, const char *mode, const char *names)
251 if (!names || !*names
252 || strEQ(names, ":crlf")
253 || strEQ(names, ":raw")
254 || strEQ(names, ":bytes")
258 Perl_croak(aTHX_ "Cannot apply \"%s\" in non-PerlIO perl", names);
266 PerlIO_destruct(pTHX)
271 PerlIO_binmode(pTHX_ PerlIO *fp, int iotype, int mode, const char *names)
274 PERL_UNUSED_ARG(iotype);
275 PERL_UNUSED_ARG(mode);
276 PERL_UNUSED_ARG(names);
279 return perlsio_binmode(fp, iotype, mode);
284 PerlIO_fdupopen(pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
286 #if defined(PERL_MICRO) || defined(__SYMBIAN32__)
289 #ifdef PERL_IMPLICIT_SYS
290 return PerlSIO_fdupopen(f);
293 return win32_fdupopen(f);
296 const int fd = PerlLIO_dup(PerlIO_fileno(f));
300 const int omode = djgpp_get_stream_mode(f);
302 const int omode = fcntl(fd, F_GETFL);
304 PerlIO_intmode2str(omode,mode,NULL);
305 /* the r+ is a hack */
306 return PerlIO_fdopen(fd, mode);
311 SETERRNO(EBADF, SS_IVCHAN);
321 * De-mux PerlIO_openn() into fdopen, freopen and fopen type entries
325 PerlIO_openn(pTHX_ const char *layers, const char *mode, int fd,
326 int imode, int perm, PerlIO *old, int narg, SV **args)
330 Perl_croak(aTHX_ "More than one argument to open");
332 if (*args == &PL_sv_undef)
333 return PerlIO_tmpfile();
335 const char *name = SvPV_nolen_const(*args);
336 if (*mode == IoTYPE_NUMERIC) {
337 fd = PerlLIO_open3(name, imode, perm);
339 return PerlIO_fdopen(fd, mode + 1);
342 return PerlIO_reopen(name, mode, old);
345 return PerlIO_open(name, mode);
350 return PerlIO_fdopen(fd, (char *) mode);
355 XS(XS_PerlIO__Layer__find)
359 Perl_croak(aTHX_ "Usage class->find(name[,load])");
361 const char * const name = SvPV_nolen_const(ST(1));
362 ST(0) = (strEQ(name, "crlf")
363 || strEQ(name, "raw")) ? &PL_sv_yes : &PL_sv_undef;
370 Perl_boot_core_PerlIO(pTHX)
372 newXS("PerlIO::Layer::find", XS_PerlIO__Layer__find, __FILE__);
378 #ifdef PERLIO_IS_STDIO
385 * Does nothing (yet) except force this file to be included in perl
386 * binary. That allows this file to force inclusion of other functions
387 * that may be required by loadable extensions e.g. for
388 * FileHandle::tmpfile
392 #undef PerlIO_tmpfile
399 #else /* PERLIO_IS_STDIO */
407 * This section is just to make sure these functions get pulled in from
411 #undef PerlIO_tmpfile
423 * Force this file to be included in perl binary. Which allows this
424 * file to force inclusion of other functions that may be required by
425 * loadable extensions e.g. for FileHandle::tmpfile
429 * Hack sfio does its own 'autoflush' on stdout in common cases. Flush
430 * results in a lot of lseek()s to regular files and lot of small
433 sfset(sfstdout, SF_SHARE, 0);
436 /* This is not the reverse of PerlIO_exportFILE(), PerlIO_releaseFILE() is. */
438 PerlIO_importFILE(FILE *stdio, const char *mode)
440 const int fd = fileno(stdio);
441 if (!mode || !*mode) {
444 return PerlIO_fdopen(fd, mode);
448 PerlIO_findFILE(PerlIO *pio)
450 const int fd = PerlIO_fileno(pio);
451 FILE * const f = fdopen(fd, "r+");
453 if (!f && errno == EINVAL)
455 if (!f && errno == EINVAL)
462 /*======================================================================================*/
464 * Implement all the PerlIO interface ourselves.
470 * We _MUST_ have <unistd.h> if we are using lseek() and may have large
477 #include <sys/mman.h>
481 PerlIO_debug(const char *fmt, ...)
486 if (!PL_perlio_debug_fd) {
487 if (!PL_tainting && PL_uid == PL_euid && PL_gid == PL_egid) {
488 const char * const s = PerlEnv_getenv("PERLIO_DEBUG");
491 = PerlLIO_open3(s, O_WRONLY | O_CREAT | O_APPEND, 0666);
493 PL_perlio_debug_fd = -1;
495 /* tainting or set*id, so ignore the environment, and ensure we
496 skip these tests next time through. */
497 PL_perlio_debug_fd = -1;
500 if (PL_perlio_debug_fd > 0) {
503 const char * const s = CopFILE(PL_curcop);
504 /* Use fixed buffer as sv_catpvf etc. needs SVs */
506 const STRLEN len1 = my_snprintf(buffer, sizeof(buffer), "%.40s:%" IVdf " ", s ? s : "(none)", (IV) CopLINE(PL_curcop));
507 const STRLEN len2 = my_vsnprintf(buffer + len1, sizeof(buffer) - len1, fmt, ap);
508 PerlLIO_write(PL_perlio_debug_fd, buffer, len1 + len2);
510 const char *s = CopFILE(PL_curcop);
512 SV * const sv = Perl_newSVpvf(aTHX_ "%s:%" IVdf " ", s ? s : "(none)",
513 (IV) CopLINE(PL_curcop));
514 Perl_sv_vcatpvf(aTHX_ sv, fmt, &ap);
516 s = SvPV_const(sv, len);
517 PerlLIO_write(PL_perlio_debug_fd, s, len);
524 /*--------------------------------------------------------------------------------------*/
527 * Inner level routines
531 * Table of pointers to the PerlIO structs (malloc'ed)
533 #define PERLIO_TABLE_SIZE 64
536 PerlIO_allocate(pTHX)
540 * Find a free slot in the table, allocating new table as necessary
545 while ((f = *last)) {
547 last = (PerlIO **) (f);
548 for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
554 Newxz(f,PERLIO_TABLE_SIZE,PerlIO);
562 #undef PerlIO_fdupopen
564 PerlIO_fdupopen(pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
566 if (PerlIOValid(f)) {
567 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
568 PerlIO_debug("fdupopen f=%p param=%p\n",(void*)f,(void*)param);
570 return (*tab->Dup)(aTHX_ PerlIO_allocate(aTHX), f, param, flags);
572 return PerlIOBase_dup(aTHX_ PerlIO_allocate(aTHX), f, param, flags);
576 SETERRNO(EBADF, SS_IVCHAN);
582 PerlIO_cleantable(pTHX_ PerlIO **tablep)
584 PerlIO * const table = *tablep;
587 PerlIO_cleantable(aTHX_(PerlIO **) & (table[0]));
588 for (i = PERLIO_TABLE_SIZE - 1; i > 0; i--) {
589 PerlIO * const f = table + i;
601 PerlIO_list_alloc(pTHX)
605 Newxz(list, 1, PerlIO_list_t);
611 PerlIO_list_free(pTHX_ PerlIO_list_t *list)
614 if (--list->refcnt == 0) {
617 for (i = 0; i < list->cur; i++)
618 SvREFCNT_dec(list->array[i].arg);
619 Safefree(list->array);
627 PerlIO_list_push(pTHX_ PerlIO_list_t *list, PerlIO_funcs *funcs, SV *arg)
633 if (list->cur >= list->len) {
636 Renew(list->array, list->len, PerlIO_pair_t);
638 Newx(list->array, list->len, PerlIO_pair_t);
640 p = &(list->array[list->cur++]);
642 if ((p->arg = arg)) {
643 SvREFCNT_inc_simple_void_NN(arg);
648 PerlIO_clone_list(pTHX_ PerlIO_list_t *proto, CLONE_PARAMS *param)
650 PerlIO_list_t *list = NULL;
653 list = PerlIO_list_alloc(aTHX);
654 for (i=0; i < proto->cur; i++) {
655 SV *arg = proto->array[i].arg;
658 arg = sv_dup(arg, param);
660 PERL_UNUSED_ARG(param);
662 PerlIO_list_push(aTHX_ list, proto->array[i].funcs, arg);
669 PerlIO_clone(pTHX_ PerlInterpreter *proto, CLONE_PARAMS *param)
672 PerlIO **table = &proto->Iperlio;
675 PL_known_layers = PerlIO_clone_list(aTHX_ proto->Iknown_layers, param);
676 PL_def_layerlist = PerlIO_clone_list(aTHX_ proto->Idef_layerlist, param);
677 PerlIO_allocate(aTHX); /* root slot is never used */
678 PerlIO_debug("Clone %p from %p\n",(void*)aTHX,(void*)proto);
679 while ((f = *table)) {
681 table = (PerlIO **) (f++);
682 for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
684 (void) fp_dup(f, 0, param);
691 PERL_UNUSED_ARG(proto);
692 PERL_UNUSED_ARG(param);
697 PerlIO_destruct(pTHX)
700 PerlIO **table = &PL_perlio;
703 PerlIO_debug("Destruct %p\n",(void*)aTHX);
705 while ((f = *table)) {
707 table = (PerlIO **) (f++);
708 for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
712 if (l->tab->kind & PERLIO_K_DESTRUCT) {
713 PerlIO_debug("Destruct popping %s\n", l->tab->name);
727 PerlIO_pop(pTHX_ PerlIO *f)
729 const PerlIOl *l = *f;
731 PerlIO_debug("PerlIO_pop f=%p %s\n", (void*)f, l->tab->name);
732 if (l->tab->Popped) {
734 * If popped returns non-zero do not free its layer structure
735 * it has either done so itself, or it is shared and still in
738 if ((*l->tab->Popped) (aTHX_ f) != 0)
746 /* Return as an array the stack of layers on a filehandle. Note that
747 * the stack is returned top-first in the array, and there are three
748 * times as many array elements as there are layers in the stack: the
749 * first element of a layer triplet is the name, the second one is the
750 * arguments, and the third one is the flags. */
753 PerlIO_get_layers(pTHX_ PerlIO *f)
756 AV * const av = newAV();
758 if (PerlIOValid(f)) {
759 PerlIOl *l = PerlIOBase(f);
762 /* There is some collusion in the implementation of
763 XS_PerlIO_get_layers - it knows that name and flags are
764 generated as fresh SVs here, and takes advantage of that to
765 "copy" them by taking a reference. If it changes here, it needs
766 to change there too. */
767 SV * const name = l->tab && l->tab->name ?
768 newSVpv(l->tab->name, 0) : &PL_sv_undef;
769 SV * const arg = l->tab && l->tab->Getarg ?
770 (*l->tab->Getarg)(aTHX_ &l, 0, 0) : &PL_sv_undef;
773 av_push(av, newSViv((IV)l->flags));
781 /*--------------------------------------------------------------------------------------*/
783 * XS Interface for perl code
787 PerlIO_find_layer(pTHX_ const char *name, STRLEN len, int load)
791 if ((SSize_t) len <= 0)
793 for (i = 0; i < PL_known_layers->cur; i++) {
794 PerlIO_funcs * const f = PL_known_layers->array[i].funcs;
795 if (memEQ(f->name, name, len) && f->name[len] == 0) {
796 PerlIO_debug("%.*s => %p\n", (int) len, name, (void*)f);
800 if (load && PL_subname && PL_def_layerlist
801 && PL_def_layerlist->cur >= 2) {
802 if (PL_in_load_module) {
803 Perl_croak(aTHX_ "Recursive call to Perl_load_module in PerlIO_find_layer");
806 SV * const pkgsv = newSVpvs("PerlIO");
807 SV * const layer = newSVpvn(name, len);
808 CV * const cv = get_cvs("PerlIO::Layer::NoWarnings", 0);
810 SAVEBOOL(PL_in_load_module);
812 SAVEGENERICSV(PL_warnhook);
813 PL_warnhook = MUTABLE_SV((SvREFCNT_inc_simple_NN(cv)));
815 PL_in_load_module = TRUE;
817 * The two SVs are magically freed by load_module
819 Perl_load_module(aTHX_ 0, pkgsv, NULL, layer, NULL);
821 return PerlIO_find_layer(aTHX_ name, len, 0);
824 PerlIO_debug("Cannot find %.*s\n", (int) len, name);
828 #ifdef USE_ATTRIBUTES_FOR_PERLIO
831 perlio_mg_set(pTHX_ SV *sv, MAGIC *mg)
834 IO * const io = GvIOn(MUTABLE_GV(SvRV(sv)));
835 PerlIO * const ifp = IoIFP(io);
836 PerlIO * const ofp = IoOFP(io);
837 Perl_warn(aTHX_ "set %" SVf " %p %p %p",
838 SVfARG(sv), (void*)io, (void*)ifp, (void*)ofp);
844 perlio_mg_get(pTHX_ SV *sv, MAGIC *mg)
847 IO * const io = GvIOn(MUTABLE_GV(SvRV(sv)));
848 PerlIO * const ifp = IoIFP(io);
849 PerlIO * const ofp = IoOFP(io);
850 Perl_warn(aTHX_ "get %" SVf " %p %p %p",
851 SVfARG(sv), (void*)io, (void*)ifp, (void*)ofp);
857 perlio_mg_clear(pTHX_ SV *sv, MAGIC *mg)
859 Perl_warn(aTHX_ "clear %" SVf, SVfARG(sv));
864 perlio_mg_free(pTHX_ SV *sv, MAGIC *mg)
866 Perl_warn(aTHX_ "free %" SVf, SVfARG(sv));
870 MGVTBL perlio_vtab = {
878 XS(XS_io_MODIFY_SCALAR_ATTRIBUTES)
881 SV * const sv = SvRV(ST(1));
882 AV * const av = newAV();
886 sv_magic(sv, MUTABLE_SV(av), PERL_MAGIC_ext, NULL, 0);
888 mg = mg_find(sv, PERL_MAGIC_ext);
889 mg->mg_virtual = &perlio_vtab;
891 Perl_warn(aTHX_ "attrib %" SVf, SVfARG(sv));
892 for (i = 2; i < items; i++) {
894 const char * const name = SvPV_const(ST(i), len);
895 SV * const layer = PerlIO_find_layer(aTHX_ name, len, 1);
897 av_push(av, SvREFCNT_inc_simple_NN(layer));
908 #endif /* USE_ATTIBUTES_FOR_PERLIO */
911 PerlIO_tab_sv(pTHX_ PerlIO_funcs *tab)
913 HV * const stash = gv_stashpvs("PerlIO::Layer", GV_ADD);
914 SV * const sv = sv_bless(newRV_noinc(newSViv(PTR2IV(tab))), stash);
918 XS(XS_PerlIO__Layer__NoWarnings)
920 /* This is used as a %SIG{__WARN__} handler to supress warnings
921 during loading of layers.
927 PerlIO_debug("warning:%s\n",SvPV_nolen_const(ST(0)));
931 XS(XS_PerlIO__Layer__find)
937 Perl_croak(aTHX_ "Usage class->find(name[,load])");
940 const char * const name = SvPV_const(ST(1), len);
941 const bool load = (items > 2) ? SvTRUE(ST(2)) : 0;
942 PerlIO_funcs * const layer = PerlIO_find_layer(aTHX_ name, len, load);
944 (layer) ? sv_2mortal(PerlIO_tab_sv(aTHX_ layer)) :
951 PerlIO_define_layer(pTHX_ PerlIO_funcs *tab)
954 if (!PL_known_layers)
955 PL_known_layers = PerlIO_list_alloc(aTHX);
956 PerlIO_list_push(aTHX_ PL_known_layers, tab, NULL);
957 PerlIO_debug("define %s %p\n", tab->name, (void*)tab);
961 PerlIO_parse_layers(pTHX_ PerlIO_list_t *av, const char *names)
965 const char *s = names;
967 while (isSPACE(*s) || *s == ':')
972 const char *as = NULL;
974 if (!isIDFIRST(*s)) {
976 * Message is consistent with how attribute lists are
977 * passed. Even though this means "foo : : bar" is
978 * seen as an invalid separator character.
980 const char q = ((*s == '\'') ? '"' : '\'');
981 Perl_ck_warner(aTHX_ packWARN(WARN_LAYER),
982 "Invalid separator character %c%c%c in PerlIO layer specification %s",
984 SETERRNO(EINVAL, LIB_INVARG);
989 } while (isALNUM(*e));
1005 * It's a nul terminated string, not allowed
1006 * to \ the terminating null. Anything other
1007 * character is passed over.
1017 Perl_ck_warner(aTHX_ packWARN(WARN_LAYER),
1018 "Argument list not closed for PerlIO layer \"%.*s\"",
1030 PerlIO_funcs * const layer =
1031 PerlIO_find_layer(aTHX_ s, llen, 1);
1035 arg = newSVpvn(as, alen);
1036 PerlIO_list_push(aTHX_ av, layer,
1037 (arg) ? arg : &PL_sv_undef);
1041 Perl_ck_warner(aTHX_ packWARN(WARN_LAYER), "Unknown PerlIO layer \"%.*s\"",
1054 PerlIO_default_buffer(pTHX_ PerlIO_list_t *av)
1057 PERLIO_FUNCS_DECL(*tab) = &PerlIO_perlio;
1058 #ifdef PERLIO_USING_CRLF
1061 if (PerlIO_stdio.Set_ptrcnt)
1062 tab = &PerlIO_stdio;
1064 PerlIO_debug("Pushing %s\n", tab->name);
1065 PerlIO_list_push(aTHX_ av, PerlIO_find_layer(aTHX_ tab->name, 0, 0),
1070 PerlIO_arg_fetch(PerlIO_list_t *av, IV n)
1072 return av->array[n].arg;
1076 PerlIO_layer_fetch(pTHX_ PerlIO_list_t *av, IV n, PerlIO_funcs *def)
1078 if (n >= 0 && n < av->cur) {
1079 PerlIO_debug("Layer %" IVdf " is %s\n", n,
1080 av->array[n].funcs->name);
1081 return av->array[n].funcs;
1084 Perl_croak(aTHX_ "panic: PerlIO layer array corrupt");
1089 PerlIOPop_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
1091 PERL_UNUSED_ARG(mode);
1092 PERL_UNUSED_ARG(arg);
1093 PERL_UNUSED_ARG(tab);
1094 if (PerlIOValid(f)) {
1096 PerlIO_pop(aTHX_ f);
1102 PERLIO_FUNCS_DECL(PerlIO_remove) = {
1103 sizeof(PerlIO_funcs),
1106 PERLIO_K_DUMMY | PERLIO_K_UTF8,
1126 NULL, /* get_base */
1127 NULL, /* get_bufsiz */
1130 NULL, /* set_ptrcnt */
1134 PerlIO_default_layers(pTHX)
1137 if (!PL_def_layerlist) {
1138 const char * const s = (PL_tainting) ? NULL : PerlEnv_getenv("PERLIO");
1139 PERLIO_FUNCS_DECL(*osLayer) = &PerlIO_unix;
1140 PL_def_layerlist = PerlIO_list_alloc(aTHX);
1141 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_unix));
1143 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_win32));
1145 osLayer = &PerlIO_win32;
1148 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_raw));
1149 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_perlio));
1150 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_stdio));
1151 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_crlf));
1153 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_mmap));
1155 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_utf8));
1156 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_remove));
1157 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_byte));
1158 PerlIO_list_push(aTHX_ PL_def_layerlist,
1159 PerlIO_find_layer(aTHX_ osLayer->name, 0, 0),
1162 PerlIO_parse_layers(aTHX_ PL_def_layerlist, s);
1165 PerlIO_default_buffer(aTHX_ PL_def_layerlist);
1168 if (PL_def_layerlist->cur < 2) {
1169 PerlIO_default_buffer(aTHX_ PL_def_layerlist);
1171 return PL_def_layerlist;
1175 Perl_boot_core_PerlIO(pTHX)
1177 #ifdef USE_ATTRIBUTES_FOR_PERLIO
1178 newXS("io::MODIFY_SCALAR_ATTRIBUTES", XS_io_MODIFY_SCALAR_ATTRIBUTES,
1181 newXS("PerlIO::Layer::find", XS_PerlIO__Layer__find, __FILE__);
1182 newXS("PerlIO::Layer::NoWarnings", XS_PerlIO__Layer__NoWarnings, __FILE__);
1186 PerlIO_default_layer(pTHX_ I32 n)
1189 PerlIO_list_t * const av = PerlIO_default_layers(aTHX);
1192 return PerlIO_layer_fetch(aTHX_ av, n, PERLIO_FUNCS_CAST(&PerlIO_stdio));
1195 #define PerlIO_default_top() PerlIO_default_layer(aTHX_ -1)
1196 #define PerlIO_default_btm() PerlIO_default_layer(aTHX_ 0)
1199 PerlIO_stdstreams(pTHX)
1203 PerlIO_allocate(aTHX);
1204 PerlIO_fdopen(0, "Ir" PERLIO_STDTEXT);
1205 PerlIO_fdopen(1, "Iw" PERLIO_STDTEXT);
1206 PerlIO_fdopen(2, "Iw" PERLIO_STDTEXT);
1211 PerlIO_push(pTHX_ PerlIO *f, PERLIO_FUNCS_DECL(*tab), const char *mode, SV *arg)
1213 if (tab->fsize != sizeof(PerlIO_funcs)) {
1215 Perl_croak(aTHX_ "Layer does not match this perl");
1219 if (tab->size < sizeof(PerlIOl)) {
1222 /* Real layer with a data area */
1225 Newxz(temp, tab->size, char);
1229 l->tab = (PerlIO_funcs*) tab;
1231 PerlIO_debug("PerlIO_push f=%p %s %s %p\n",
1232 (void*)f, tab->name,
1233 (mode) ? mode : "(Null)", (void*)arg);
1234 if (*l->tab->Pushed &&
1236 (aTHX_ f, mode, arg, (PerlIO_funcs*) tab) != 0) {
1237 PerlIO_pop(aTHX_ f);
1246 /* Pseudo-layer where push does its own stack adjust */
1247 PerlIO_debug("PerlIO_push f=%p %s %s %p\n", (void*)f, tab->name,
1248 (mode) ? mode : "(Null)", (void*)arg);
1250 (*tab->Pushed) (aTHX_ f, mode, arg, (PerlIO_funcs*) tab) != 0) {
1258 PerlIOBase_binmode(pTHX_ PerlIO *f)
1260 if (PerlIOValid(f)) {
1261 /* Is layer suitable for raw stream ? */
1262 if (PerlIOBase(f)->tab->kind & PERLIO_K_RAW) {
1263 /* Yes - turn off UTF-8-ness, to undo UTF-8 locale effects */
1264 PerlIOBase(f)->flags &= ~PERLIO_F_UTF8;
1267 /* Not suitable - pop it */
1268 PerlIO_pop(aTHX_ f);
1276 PerlIORaw_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
1278 PERL_UNUSED_ARG(mode);
1279 PERL_UNUSED_ARG(arg);
1280 PERL_UNUSED_ARG(tab);
1282 if (PerlIOValid(f)) {
1287 * Strip all layers that are not suitable for a raw stream
1290 while (t && (l = *t)) {
1291 if (l->tab->Binmode) {
1292 /* Has a handler - normal case */
1293 if ((*l->tab->Binmode)(aTHX_ t) == 0) {
1295 /* Layer still there - move down a layer */
1304 /* No handler - pop it */
1305 PerlIO_pop(aTHX_ t);
1308 if (PerlIOValid(f)) {
1309 PerlIO_debug(":raw f=%p :%s\n", (void*)f, PerlIOBase(f)->tab->name);
1317 PerlIO_apply_layera(pTHX_ PerlIO *f, const char *mode,
1318 PerlIO_list_t *layers, IV n, IV max)
1322 PerlIO_funcs * const tab = PerlIO_layer_fetch(aTHX_ layers, n, NULL);
1324 if (!PerlIO_push(aTHX_ f, tab, mode, PerlIOArg)) {
1335 PerlIO_apply_layers(pTHX_ PerlIO *f, const char *mode, const char *names)
1339 PerlIO_list_t * const layers = PerlIO_list_alloc(aTHX);
1340 code = PerlIO_parse_layers(aTHX_ layers, names);
1342 code = PerlIO_apply_layera(aTHX_ f, mode, layers, 0, layers->cur);
1344 PerlIO_list_free(aTHX_ layers);
1350 /*--------------------------------------------------------------------------------------*/
1352 * Given the abstraction above the public API functions
1356 PerlIO_binmode(pTHX_ PerlIO *f, int iotype, int mode, const char *names)
1358 PerlIO_debug("PerlIO_binmode f=%p %s %c %x %s\n", (void*)f,
1359 (PerlIOBase(f)) ? PerlIOBase(f)->tab->name : "(Null)",
1360 iotype, mode, (names) ? names : "(Null)");
1363 /* Do not flush etc. if (e.g.) switching encodings.
1364 if a pushed layer knows it needs to flush lower layers
1365 (for example :unix which is never going to call them)
1366 it can do the flush when it is pushed.
1368 return PerlIO_apply_layers(aTHX_ f, NULL, names) == 0 ? TRUE : FALSE;
1371 /* Fake 5.6 legacy of using this call to turn ON O_TEXT */
1372 #ifdef PERLIO_USING_CRLF
1373 /* Legacy binmode only has meaning if O_TEXT has a value distinct from
1374 O_BINARY so we can look for it in mode.
1376 if (!(mode & O_BINARY)) {
1378 /* FIXME?: Looking down the layer stack seems wrong,
1379 but is a way of reaching past (say) an encoding layer
1380 to flip CRLF-ness of the layer(s) below
1383 /* Perhaps we should turn on bottom-most aware layer
1384 e.g. Ilya's idea that UNIX TTY could serve
1386 if (PerlIOBase(f)->tab->kind & PERLIO_K_CANCRLF) {
1387 if (!(PerlIOBase(f)->flags & PERLIO_F_CRLF)) {
1388 /* Not in text mode - flush any pending stuff and flip it */
1390 PerlIOBase(f)->flags |= PERLIO_F_CRLF;
1392 /* Only need to turn it on in one layer so we are done */
1397 /* Not finding a CRLF aware layer presumably means we are binary
1398 which is not what was requested - so we failed
1399 We _could_ push :crlf layer but so could caller
1404 /* Legacy binmode is now _defined_ as being equivalent to pushing :raw
1405 So code that used to be here is now in PerlIORaw_pushed().
1407 return PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_raw), NULL, NULL) ? TRUE : FALSE;
1412 PerlIO__close(pTHX_ PerlIO *f)
1414 if (PerlIOValid(f)) {
1415 PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1416 if (tab && tab->Close)
1417 return (*tab->Close)(aTHX_ f);
1419 return PerlIOBase_close(aTHX_ f);
1422 SETERRNO(EBADF, SS_IVCHAN);
1428 Perl_PerlIO_close(pTHX_ PerlIO *f)
1430 const int code = PerlIO__close(aTHX_ f);
1431 while (PerlIOValid(f)) {
1432 PerlIO_pop(aTHX_ f);
1438 Perl_PerlIO_fileno(pTHX_ PerlIO *f)
1441 Perl_PerlIO_or_Base(f, Fileno, fileno, -1, (aTHX_ f));
1445 static PerlIO_funcs *
1446 PerlIO_layer_from_ref(pTHX_ SV *sv)
1450 * For any scalar type load the handler which is bundled with perl
1452 if (SvTYPE(sv) < SVt_PVAV) {
1453 PerlIO_funcs *f = PerlIO_find_layer(aTHX_ STR_WITH_LEN("scalar"), 1);
1454 /* This isn't supposed to happen, since PerlIO::scalar is core,
1455 * but could happen anyway in smaller installs or with PAR */
1457 Perl_ck_warner(aTHX_ packWARN(WARN_LAYER), "Unknown PerlIO layer \"scalar\"");
1462 * For other types allow if layer is known but don't try and load it
1464 switch (SvTYPE(sv)) {
1466 return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Array"), 0);
1468 return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Hash"), 0);
1470 return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Code"), 0);
1472 return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Glob"), 0);
1479 PerlIO_resolve_layers(pTHX_ const char *layers,
1480 const char *mode, int narg, SV **args)
1483 PerlIO_list_t *def = PerlIO_default_layers(aTHX);
1486 PerlIO_stdstreams(aTHX);
1488 SV * const arg = *args;
1490 * If it is a reference but not an object see if we have a handler
1493 if (SvROK(arg) && !sv_isobject(arg)) {
1494 PerlIO_funcs * const handler = PerlIO_layer_from_ref(aTHX_ SvRV(arg));
1496 def = PerlIO_list_alloc(aTHX);
1497 PerlIO_list_push(aTHX_ def, handler, &PL_sv_undef);
1501 * Don't fail if handler cannot be found :via(...) etc. may do
1502 * something sensible else we will just stringfy and open
1507 if (!layers || !*layers)
1508 layers = Perl_PerlIO_context_layers(aTHX_ mode);
1509 if (layers && *layers) {
1512 av = PerlIO_clone_list(aTHX_ def, NULL);
1517 if (PerlIO_parse_layers(aTHX_ av, layers) == 0) {
1521 PerlIO_list_free(aTHX_ av);
1533 PerlIO_openn(pTHX_ const char *layers, const char *mode, int fd,
1534 int imode, int perm, PerlIO *f, int narg, SV **args)
1537 if (!f && narg == 1 && *args == &PL_sv_undef) {
1538 if ((f = PerlIO_tmpfile())) {
1539 if (!layers || !*layers)
1540 layers = Perl_PerlIO_context_layers(aTHX_ mode);
1541 if (layers && *layers)
1542 PerlIO_apply_layers(aTHX_ f, mode, layers);
1546 PerlIO_list_t *layera;
1548 PerlIO_funcs *tab = NULL;
1549 if (PerlIOValid(f)) {
1551 * This is "reopen" - it is not tested as perl does not use it
1555 layera = PerlIO_list_alloc(aTHX);
1559 arg = (*l->tab->Getarg) (aTHX_ &l, NULL, 0);
1560 PerlIO_list_push(aTHX_ layera, l->tab,
1561 (arg) ? arg : &PL_sv_undef);
1563 l = *PerlIONext(&l);
1567 layera = PerlIO_resolve_layers(aTHX_ layers, mode, narg, args);
1573 * Start at "top" of layer stack
1575 n = layera->cur - 1;
1577 PerlIO_funcs * const t = PerlIO_layer_fetch(aTHX_ layera, n, NULL);
1586 * Found that layer 'n' can do opens - call it
1588 if (narg > 1 && !(tab->kind & PERLIO_K_MULTIARG)) {
1589 Perl_croak(aTHX_ "More than one argument to open(,':%s')",tab->name);
1591 PerlIO_debug("openn(%s,'%s','%s',%d,%x,%o,%p,%d,%p)\n",
1592 tab->name, layers ? layers : "(Null)", mode, fd,
1593 imode, perm, (void*)f, narg, (void*)args);
1595 f = (*tab->Open) (aTHX_ tab, layera, n, mode, fd, imode, perm,
1598 SETERRNO(EINVAL, LIB_INVARG);
1602 if (n + 1 < layera->cur) {
1604 * More layers above the one that we used to open -
1607 if (PerlIO_apply_layera(aTHX_ f, mode, layera, n + 1, layera->cur) != 0) {
1608 /* If pushing layers fails close the file */
1615 PerlIO_list_free(aTHX_ layera);
1622 Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
1624 PERL_ARGS_ASSERT_PERLIO_READ;
1626 Perl_PerlIO_or_Base(f, Read, read, -1, (aTHX_ f, vbuf, count));
1630 Perl_PerlIO_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
1632 PERL_ARGS_ASSERT_PERLIO_UNREAD;
1634 Perl_PerlIO_or_Base(f, Unread, unread, -1, (aTHX_ f, vbuf, count));
1638 Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
1640 PERL_ARGS_ASSERT_PERLIO_WRITE;
1642 Perl_PerlIO_or_fail(f, Write, -1, (aTHX_ f, vbuf, count));
1646 Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
1648 Perl_PerlIO_or_fail(f, Seek, -1, (aTHX_ f, offset, whence));
1652 Perl_PerlIO_tell(pTHX_ PerlIO *f)
1654 Perl_PerlIO_or_fail(f, Tell, -1, (aTHX_ f));
1658 Perl_PerlIO_flush(pTHX_ PerlIO *f)
1663 const PerlIO_funcs *tab = PerlIOBase(f)->tab;
1665 if (tab && tab->Flush)
1666 return (*tab->Flush) (aTHX_ f);
1668 return 0; /* If no Flush defined, silently succeed. */
1671 PerlIO_debug("Cannot flush f=%p\n", (void*)f);
1672 SETERRNO(EBADF, SS_IVCHAN);
1678 * Is it good API design to do flush-all on NULL, a potentially
1679 * errorneous input? Maybe some magical value (PerlIO*
1680 * PERLIO_FLUSH_ALL = (PerlIO*)-1;)? Yes, stdio does similar
1681 * things on fflush(NULL), but should we be bound by their design
1684 PerlIO **table = &PL_perlio;
1686 while ((f = *table)) {
1688 table = (PerlIO **) (f++);
1689 for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
1690 if (*f && PerlIO_flush(f) != 0)
1700 PerlIOBase_flush_linebuf(pTHX)
1703 PerlIO **table = &PL_perlio;
1705 while ((f = *table)) {
1707 table = (PerlIO **) (f++);
1708 for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
1711 flags & (PERLIO_F_LINEBUF | PERLIO_F_CANWRITE))
1712 == (PERLIO_F_LINEBUF | PERLIO_F_CANWRITE))
1720 Perl_PerlIO_fill(pTHX_ PerlIO *f)
1722 Perl_PerlIO_or_fail(f, Fill, -1, (aTHX_ f));
1726 PerlIO_isutf8(PerlIO *f)
1729 return (PerlIOBase(f)->flags & PERLIO_F_UTF8) != 0;
1731 SETERRNO(EBADF, SS_IVCHAN);
1737 Perl_PerlIO_eof(pTHX_ PerlIO *f)
1739 Perl_PerlIO_or_Base(f, Eof, eof, -1, (aTHX_ f));
1743 Perl_PerlIO_error(pTHX_ PerlIO *f)
1745 Perl_PerlIO_or_Base(f, Error, error, -1, (aTHX_ f));
1749 Perl_PerlIO_clearerr(pTHX_ PerlIO *f)
1751 Perl_PerlIO_or_Base_void(f, Clearerr, clearerr, (aTHX_ f));
1755 Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f)
1757 Perl_PerlIO_or_Base_void(f, Setlinebuf, setlinebuf, (aTHX_ f));
1761 PerlIO_has_base(PerlIO *f)
1763 if (PerlIOValid(f)) {
1764 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1767 return (tab->Get_base != NULL);
1774 PerlIO_fast_gets(PerlIO *f)
1776 if (PerlIOValid(f)) {
1777 if (PerlIOBase(f)->flags & PERLIO_F_FASTGETS) {
1778 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1781 return (tab->Set_ptrcnt != NULL);
1789 PerlIO_has_cntptr(PerlIO *f)
1791 if (PerlIOValid(f)) {
1792 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1795 return (tab->Get_ptr != NULL && tab->Get_cnt != NULL);
1802 PerlIO_canset_cnt(PerlIO *f)
1804 if (PerlIOValid(f)) {
1805 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1808 return (tab->Set_ptrcnt != NULL);
1815 Perl_PerlIO_get_base(pTHX_ PerlIO *f)
1817 Perl_PerlIO_or_fail(f, Get_base, NULL, (aTHX_ f));
1821 Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f)
1823 Perl_PerlIO_or_fail(f, Get_bufsiz, -1, (aTHX_ f));
1827 Perl_PerlIO_get_ptr(pTHX_ PerlIO *f)
1829 Perl_PerlIO_or_fail(f, Get_ptr, NULL, (aTHX_ f));
1833 Perl_PerlIO_get_cnt(pTHX_ PerlIO *f)
1835 Perl_PerlIO_or_fail(f, Get_cnt, -1, (aTHX_ f));
1839 Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, int cnt)
1841 Perl_PerlIO_or_fail_void(f, Set_ptrcnt, (aTHX_ f, NULL, cnt));
1845 Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, int cnt)
1847 Perl_PerlIO_or_fail_void(f, Set_ptrcnt, (aTHX_ f, ptr, cnt));
1851 /*--------------------------------------------------------------------------------------*/
1853 * utf8 and raw dummy layers
1857 PerlIOUtf8_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
1859 PERL_UNUSED_CONTEXT;
1860 PERL_UNUSED_ARG(mode);
1861 PERL_UNUSED_ARG(arg);
1862 if (PerlIOValid(f)) {
1863 if (tab->kind & PERLIO_K_UTF8)
1864 PerlIOBase(f)->flags |= PERLIO_F_UTF8;
1866 PerlIOBase(f)->flags &= ~PERLIO_F_UTF8;
1872 PERLIO_FUNCS_DECL(PerlIO_utf8) = {
1873 sizeof(PerlIO_funcs),
1876 PERLIO_K_DUMMY | PERLIO_K_UTF8,
1896 NULL, /* get_base */
1897 NULL, /* get_bufsiz */
1900 NULL, /* set_ptrcnt */
1903 PERLIO_FUNCS_DECL(PerlIO_byte) = {
1904 sizeof(PerlIO_funcs),
1927 NULL, /* get_base */
1928 NULL, /* get_bufsiz */
1931 NULL, /* set_ptrcnt */
1935 PerlIORaw_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
1936 IV n, const char *mode, int fd, int imode, int perm,
1937 PerlIO *old, int narg, SV **args)
1939 PerlIO_funcs * const tab = PerlIO_default_btm();
1940 PERL_UNUSED_ARG(self);
1941 if (tab && tab->Open)
1942 return (*tab->Open) (aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
1944 SETERRNO(EINVAL, LIB_INVARG);
1948 PERLIO_FUNCS_DECL(PerlIO_raw) = {
1949 sizeof(PerlIO_funcs),
1972 NULL, /* get_base */
1973 NULL, /* get_bufsiz */
1976 NULL, /* set_ptrcnt */
1978 /*--------------------------------------------------------------------------------------*/
1979 /*--------------------------------------------------------------------------------------*/
1981 * "Methods" of the "base class"
1985 PerlIOBase_fileno(pTHX_ PerlIO *f)
1987 return PerlIOValid(f) ? PerlIO_fileno(PerlIONext(f)) : -1;
1991 PerlIO_modestr(PerlIO * f, char *buf)
1994 if (PerlIOValid(f)) {
1995 const IV flags = PerlIOBase(f)->flags;
1996 if (flags & PERLIO_F_APPEND) {
1998 if (flags & PERLIO_F_CANREAD) {
2002 else if (flags & PERLIO_F_CANREAD) {
2004 if (flags & PERLIO_F_CANWRITE)
2007 else if (flags & PERLIO_F_CANWRITE) {
2009 if (flags & PERLIO_F_CANREAD) {
2013 #ifdef PERLIO_USING_CRLF
2014 if (!(flags & PERLIO_F_CRLF))
2024 PerlIOBase_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
2026 PerlIOl * const l = PerlIOBase(f);
2027 PERL_UNUSED_CONTEXT;
2028 PERL_UNUSED_ARG(arg);
2030 l->flags &= ~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE |
2031 PERLIO_F_TRUNCATE | PERLIO_F_APPEND);
2032 if (tab->Set_ptrcnt != NULL)
2033 l->flags |= PERLIO_F_FASTGETS;
2035 if (*mode == IoTYPE_NUMERIC || *mode == IoTYPE_IMPLICIT)
2039 l->flags |= PERLIO_F_CANREAD;
2042 l->flags |= PERLIO_F_APPEND | PERLIO_F_CANWRITE;
2045 l->flags |= PERLIO_F_TRUNCATE | PERLIO_F_CANWRITE;
2048 SETERRNO(EINVAL, LIB_INVARG);
2054 l->flags |= PERLIO_F_CANREAD | PERLIO_F_CANWRITE;
2057 l->flags &= ~PERLIO_F_CRLF;
2060 l->flags |= PERLIO_F_CRLF;
2063 SETERRNO(EINVAL, LIB_INVARG);
2070 l->flags |= l->next->flags &
2071 (PERLIO_F_CANREAD | PERLIO_F_CANWRITE | PERLIO_F_TRUNCATE |
2076 PerlIO_debug("PerlIOBase_pushed f=%p %s %s fl=%08" UVxf " (%s)\n",
2077 (void*)f, PerlIOBase(f)->tab->name, (omode) ? omode : "(Null)",
2078 l->flags, PerlIO_modestr(f, temp));
2084 PerlIOBase_popped(pTHX_ PerlIO *f)
2086 PERL_UNUSED_CONTEXT;
2092 PerlIOBase_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
2095 * Save the position as current head considers it
2097 const Off_t old = PerlIO_tell(f);
2098 PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_pending), "r", NULL);
2099 PerlIOSelf(f, PerlIOBuf)->posn = old;
2100 return PerlIOBuf_unread(aTHX_ f, vbuf, count);
2104 PerlIOBase_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
2106 STDCHAR *buf = (STDCHAR *) vbuf;
2108 if (!(PerlIOBase(f)->flags & PERLIO_F_CANREAD)) {
2109 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
2110 SETERRNO(EBADF, SS_IVCHAN);
2116 SSize_t avail = PerlIO_get_cnt(f);
2119 take = ((SSize_t)count < avail) ? (SSize_t)count : avail;
2121 STDCHAR *ptr = PerlIO_get_ptr(f);
2122 Copy(ptr, buf, take, STDCHAR);
2123 PerlIO_set_ptrcnt(f, ptr + take, (avail -= take));
2126 if (avail == 0) /* set_ptrcnt could have reset avail */
2129 if (count > 0 && avail <= 0) {
2130 if (PerlIO_fill(f) != 0)
2135 return (buf - (STDCHAR *) vbuf);
2141 PerlIOBase_noop_ok(pTHX_ PerlIO *f)
2143 PERL_UNUSED_CONTEXT;
2149 PerlIOBase_noop_fail(pTHX_ PerlIO *f)
2151 PERL_UNUSED_CONTEXT;
2157 PerlIOBase_close(pTHX_ PerlIO *f)
2160 if (PerlIOValid(f)) {
2161 PerlIO *n = PerlIONext(f);
2162 code = PerlIO_flush(f);
2163 PerlIOBase(f)->flags &=
2164 ~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE | PERLIO_F_OPEN);
2165 while (PerlIOValid(n)) {
2166 const PerlIO_funcs * const tab = PerlIOBase(n)->tab;
2167 if (tab && tab->Close) {
2168 if ((*tab->Close)(aTHX_ n) != 0)
2173 PerlIOBase(n)->flags &=
2174 ~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE | PERLIO_F_OPEN);
2180 SETERRNO(EBADF, SS_IVCHAN);
2186 PerlIOBase_eof(pTHX_ PerlIO *f)
2188 PERL_UNUSED_CONTEXT;
2189 if (PerlIOValid(f)) {
2190 return (PerlIOBase(f)->flags & PERLIO_F_EOF) != 0;
2196 PerlIOBase_error(pTHX_ PerlIO *f)
2198 PERL_UNUSED_CONTEXT;
2199 if (PerlIOValid(f)) {
2200 return (PerlIOBase(f)->flags & PERLIO_F_ERROR) != 0;
2206 PerlIOBase_clearerr(pTHX_ PerlIO *f)
2208 if (PerlIOValid(f)) {
2209 PerlIO * const n = PerlIONext(f);
2210 PerlIOBase(f)->flags &= ~(PERLIO_F_ERROR | PERLIO_F_EOF);
2217 PerlIOBase_setlinebuf(pTHX_ PerlIO *f)
2219 PERL_UNUSED_CONTEXT;
2220 if (PerlIOValid(f)) {
2221 PerlIOBase(f)->flags |= PERLIO_F_LINEBUF;
2226 PerlIO_sv_dup(pTHX_ SV *arg, CLONE_PARAMS *param)
2232 arg = sv_dup(arg, param);
2233 SvREFCNT_inc_simple_void_NN(arg);
2237 return newSVsv(arg);
2240 PERL_UNUSED_ARG(param);
2241 return newSVsv(arg);
2246 PerlIOBase_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
2248 PerlIO * const nexto = PerlIONext(o);
2249 if (PerlIOValid(nexto)) {
2250 const PerlIO_funcs * const tab = PerlIOBase(nexto)->tab;
2251 if (tab && tab->Dup)
2252 f = (*tab->Dup)(aTHX_ f, nexto, param, flags);
2254 f = PerlIOBase_dup(aTHX_ f, nexto, param, flags);
2257 PerlIO_funcs * const self = PerlIOBase(o)->tab;
2260 PerlIO_debug("PerlIOBase_dup %s f=%p o=%p param=%p\n",
2261 self->name, (void*)f, (void*)o, (void*)param);
2263 arg = (*self->Getarg)(aTHX_ o, param, flags);
2264 f = PerlIO_push(aTHX_ f, self, PerlIO_modestr(o,buf), arg);
2265 if (PerlIOBase(o)->flags & PERLIO_F_UTF8)
2266 PerlIOBase(f)->flags |= PERLIO_F_UTF8;
2272 /* PL_perlio_fd_refcnt[] is in intrpvar.h */
2274 /* Must be called with PL_perlio_mutex locked. */
2276 S_more_refcounted_fds(pTHX_ const int new_fd) {
2278 const int old_max = PL_perlio_fd_refcnt_size;
2279 const int new_max = 16 + (new_fd & ~15);
2282 PerlIO_debug("More fds - old=%d, need %d, new=%d\n",
2283 old_max, new_fd, new_max);
2285 if (new_fd < old_max) {
2289 assert (new_max > new_fd);
2291 /* Use plain realloc() since we need this memory to be really
2292 * global and visible to all the interpreters and/or threads. */
2293 new_array = (int*) realloc(PL_perlio_fd_refcnt, new_max * sizeof(int));
2297 MUTEX_UNLOCK(&PL_perlio_mutex);
2299 /* Can't use PerlIO to write as it allocates memory */
2300 PerlLIO_write(PerlIO_fileno(Perl_error_log),
2301 PL_no_mem, strlen(PL_no_mem));
2305 PL_perlio_fd_refcnt_size = new_max;
2306 PL_perlio_fd_refcnt = new_array;
2308 PerlIO_debug("Zeroing %p, %d\n",
2309 (void*)(new_array + old_max),
2312 Zero(new_array + old_max, new_max - old_max, int);
2319 /* MUTEX_INIT(&PL_perlio_mutex) is done in PERL_SYS_INIT3(). */
2320 PERL_UNUSED_CONTEXT;
2324 PerlIOUnix_refcnt_inc(int fd)
2331 MUTEX_LOCK(&PL_perlio_mutex);
2333 if (fd >= PL_perlio_fd_refcnt_size)
2334 S_more_refcounted_fds(aTHX_ fd);
2336 PL_perlio_fd_refcnt[fd]++;
2337 if (PL_perlio_fd_refcnt[fd] <= 0) {
2338 Perl_croak(aTHX_ "refcnt_inc: fd %d: %d <= 0\n",
2339 fd, PL_perlio_fd_refcnt[fd]);
2341 PerlIO_debug("refcnt_inc: fd %d refcnt=%d\n",
2342 fd, PL_perlio_fd_refcnt[fd]);
2345 MUTEX_UNLOCK(&PL_perlio_mutex);
2348 Perl_croak(aTHX_ "refcnt_inc: fd %d < 0\n", fd);
2353 PerlIOUnix_refcnt_dec(int fd)
2360 MUTEX_LOCK(&PL_perlio_mutex);
2362 if (fd >= PL_perlio_fd_refcnt_size) {
2363 Perl_croak(aTHX_ "refcnt_dec: fd %d >= refcnt_size %d\n",
2364 fd, PL_perlio_fd_refcnt_size);
2366 if (PL_perlio_fd_refcnt[fd] <= 0) {
2367 Perl_croak(aTHX_ "refcnt_dec: fd %d: %d <= 0\n",
2368 fd, PL_perlio_fd_refcnt[fd]);
2370 cnt = --PL_perlio_fd_refcnt[fd];
2371 PerlIO_debug("refcnt_dec: fd %d refcnt=%d\n", fd, cnt);
2373 MUTEX_UNLOCK(&PL_perlio_mutex);
2376 Perl_croak(aTHX_ "refcnt_dec: fd %d < 0\n", fd);
2382 PerlIO_cleanup(pTHX)
2387 PerlIO_debug("Cleanup layers for %p\n",(void*)aTHX);
2389 PerlIO_debug("Cleanup layers\n");
2392 /* Raise STDIN..STDERR refcount so we don't close them */
2393 for (i=0; i < 3; i++)
2394 PerlIOUnix_refcnt_inc(i);
2395 PerlIO_cleantable(aTHX_ &PL_perlio);
2396 /* Restore STDIN..STDERR refcount */
2397 for (i=0; i < 3; i++)
2398 PerlIOUnix_refcnt_dec(i);
2400 if (PL_known_layers) {
2401 PerlIO_list_free(aTHX_ PL_known_layers);
2402 PL_known_layers = NULL;
2404 if (PL_def_layerlist) {
2405 PerlIO_list_free(aTHX_ PL_def_layerlist);
2406 PL_def_layerlist = NULL;
2410 void PerlIO_teardown(void) /* Call only from PERL_SYS_TERM(). */
2414 /* XXX we can't rely on an interpreter being present at this late stage,
2415 XXX so we can't use a function like PerlLIO_write that relies on one
2416 being present (at least in win32) :-(.
2421 /* By now all filehandles should have been closed, so any
2422 * stray (non-STD-)filehandles indicate *possible* (PerlIO)
2424 #define PERLIO_TEARDOWN_MESSAGE_BUF_SIZE 64
2425 #define PERLIO_TEARDOWN_MESSAGE_FD 2
2426 char buf[PERLIO_TEARDOWN_MESSAGE_BUF_SIZE];
2428 for (i = 3; i < PL_perlio_fd_refcnt_size; i++) {
2429 if (PL_perlio_fd_refcnt[i]) {
2431 my_snprintf(buf, sizeof(buf),
2432 "PerlIO_teardown: fd %d refcnt=%d\n",
2433 i, PL_perlio_fd_refcnt[i]);
2434 PerlLIO_write(PERLIO_TEARDOWN_MESSAGE_FD, buf, len);
2440 /* Not bothering with PL_perlio_mutex since by now
2441 * all the interpreters are gone. */
2442 if (PL_perlio_fd_refcnt_size /* Assuming initial size of zero. */
2443 && PL_perlio_fd_refcnt) {
2444 free(PL_perlio_fd_refcnt); /* To match realloc() in S_more_refcounted_fds(). */
2445 PL_perlio_fd_refcnt = NULL;
2446 PL_perlio_fd_refcnt_size = 0;
2450 /*--------------------------------------------------------------------------------------*/
2452 * Bottom-most level for UNIX-like case
2456 struct _PerlIO base; /* The generic part */
2457 int fd; /* UNIX like file descriptor */
2458 int oflags; /* open/fcntl flags */
2462 PerlIOUnix_oflags(const char *mode)
2465 if (*mode == IoTYPE_IMPLICIT || *mode == IoTYPE_NUMERIC)
2470 if (*++mode == '+') {
2477 oflags = O_CREAT | O_TRUNC;
2478 if (*++mode == '+') {
2487 oflags = O_CREAT | O_APPEND;
2488 if (*++mode == '+') {
2501 else if (*mode == 't') {
2503 oflags &= ~O_BINARY;
2507 * Always open in binary mode
2510 if (*mode || oflags == -1) {
2511 SETERRNO(EINVAL, LIB_INVARG);
2518 PerlIOUnix_fileno(pTHX_ PerlIO *f)
2520 PERL_UNUSED_CONTEXT;
2521 return PerlIOSelf(f, PerlIOUnix)->fd;
2525 PerlIOUnix_setfd(pTHX_ PerlIO *f, int fd, int imode)
2527 PerlIOUnix * const s = PerlIOSelf(f, PerlIOUnix);
2530 if (PerlLIO_fstat(fd, &st) == 0) {
2531 if (!S_ISREG(st.st_mode)) {
2532 PerlIO_debug("%d is not regular file\n",fd);
2533 PerlIOBase(f)->flags |= PERLIO_F_NOTREG;
2536 PerlIO_debug("%d _is_ a regular file\n",fd);
2542 PerlIOUnix_refcnt_inc(fd);
2543 PERL_UNUSED_CONTEXT;
2547 PerlIOUnix_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
2549 IV code = PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
2550 if (*PerlIONext(f)) {
2551 /* We never call down so do any pending stuff now */
2552 PerlIO_flush(PerlIONext(f));
2554 * XXX could (or should) we retrieve the oflags from the open file
2555 * handle rather than believing the "mode" we are passed in? XXX
2556 * Should the value on NULL mode be 0 or -1?
2558 PerlIOUnix_setfd(aTHX_ f, PerlIO_fileno(PerlIONext(f)),
2559 mode ? PerlIOUnix_oflags(mode) : -1);
2561 PerlIOBase(f)->flags |= PERLIO_F_OPEN;
2567 PerlIOUnix_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
2569 const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
2571 PERL_UNUSED_CONTEXT;
2572 if (PerlIOBase(f)->flags & PERLIO_F_NOTREG) {
2574 SETERRNO(ESPIPE, LIB_INVARG);
2576 SETERRNO(EINVAL, LIB_INVARG);
2580 new_loc = PerlLIO_lseek(fd, offset, whence);
2581 if (new_loc == (Off_t) - 1)
2583 PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
2588 PerlIOUnix_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
2589 IV n, const char *mode, int fd, int imode,
2590 int perm, PerlIO *f, int narg, SV **args)
2592 if (PerlIOValid(f)) {
2593 if (PerlIOBase(f)->flags & PERLIO_F_OPEN)
2594 (*PerlIOBase(f)->tab->Close)(aTHX_ f);
2597 if (*mode == IoTYPE_NUMERIC)
2600 imode = PerlIOUnix_oflags(mode);
2602 perm = 0777; /* preserve RMS defaults, ACL inheritance, etc. */
2608 const char *path = SvPV_nolen_const(*args);
2609 fd = PerlLIO_open3(path, imode, perm);
2613 if (*mode == IoTYPE_IMPLICIT)
2616 f = PerlIO_allocate(aTHX);
2618 if (!PerlIOValid(f)) {
2619 if (!(f = PerlIO_push(aTHX_ f, self, mode, PerlIOArg))) {
2623 PerlIOUnix_setfd(aTHX_ f, fd, imode);
2624 PerlIOBase(f)->flags |= PERLIO_F_OPEN;
2625 if (*mode == IoTYPE_APPEND)
2626 PerlIOUnix_seek(aTHX_ f, 0, SEEK_END);
2633 * FIXME: pop layers ???
2641 PerlIOUnix_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
2643 const PerlIOUnix * const os = PerlIOSelf(o, PerlIOUnix);
2645 if (flags & PERLIO_DUP_FD) {
2646 fd = PerlLIO_dup(fd);
2649 f = PerlIOBase_dup(aTHX_ f, o, param, flags);
2651 /* If all went well overwrite fd in dup'ed lay with the dup()'ed fd */
2652 PerlIOUnix_setfd(aTHX_ f, fd, os->oflags);
2661 PerlIOUnix_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
2664 const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
2665 #ifdef PERLIO_STD_SPECIAL
2667 return PERLIO_STD_IN(fd, vbuf, count);
2669 if (!(PerlIOBase(f)->flags & PERLIO_F_CANREAD) ||
2670 PerlIOBase(f)->flags & (PERLIO_F_EOF|PERLIO_F_ERROR)) {
2674 const SSize_t len = PerlLIO_read(fd, vbuf, count);
2675 if (len >= 0 || errno != EINTR) {
2677 if (errno != EAGAIN) {
2678 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
2681 else if (len == 0 && count != 0) {
2682 PerlIOBase(f)->flags |= PERLIO_F_EOF;
2693 PerlIOUnix_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
2696 const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
2697 #ifdef PERLIO_STD_SPECIAL
2698 if (fd == 1 || fd == 2)
2699 return PERLIO_STD_OUT(fd, vbuf, count);
2702 const SSize_t len = PerlLIO_write(fd, vbuf, count);
2703 if (len >= 0 || errno != EINTR) {
2705 if (errno != EAGAIN) {
2706 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
2717 PerlIOUnix_tell(pTHX_ PerlIO *f)
2719 PERL_UNUSED_CONTEXT;
2721 return PerlLIO_lseek(PerlIOSelf(f, PerlIOUnix)->fd, 0, SEEK_CUR);
2726 PerlIOUnix_close(pTHX_ PerlIO *f)
2729 const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
2731 if (PerlIOBase(f)->flags & PERLIO_F_OPEN) {
2732 if (PerlIOUnix_refcnt_dec(fd) > 0) {
2733 PerlIOBase(f)->flags &= ~PERLIO_F_OPEN;
2738 SETERRNO(EBADF,SS_IVCHAN);
2741 while (PerlLIO_close(fd) != 0) {
2742 if (errno != EINTR) {
2749 PerlIOBase(f)->flags &= ~PERLIO_F_OPEN;
2754 PERLIO_FUNCS_DECL(PerlIO_unix) = {
2755 sizeof(PerlIO_funcs),
2762 PerlIOBase_binmode, /* binmode */
2772 PerlIOBase_noop_ok, /* flush */
2773 PerlIOBase_noop_fail, /* fill */
2776 PerlIOBase_clearerr,
2777 PerlIOBase_setlinebuf,
2778 NULL, /* get_base */
2779 NULL, /* get_bufsiz */
2782 NULL, /* set_ptrcnt */
2785 /*--------------------------------------------------------------------------------------*/
2790 #if defined(VMS) && !defined(STDIO_BUFFER_WRITABLE)
2791 /* perl5.8 - This ensures the last minute VMS ungetc fix is not
2792 broken by the last second glibc 2.3 fix
2794 #define STDIO_BUFFER_WRITABLE
2799 struct _PerlIO base;
2800 FILE *stdio; /* The stream */
2804 PerlIOStdio_fileno(pTHX_ PerlIO *f)
2806 PERL_UNUSED_CONTEXT;
2808 if (PerlIOValid(f)) {
2809 FILE * const s = PerlIOSelf(f, PerlIOStdio)->stdio;
2811 return PerlSIO_fileno(s);
2818 PerlIOStdio_mode(const char *mode, char *tmode)
2820 char * const ret = tmode;
2826 #if defined(PERLIO_USING_CRLF) || defined(__CYGWIN__)
2834 PerlIOStdio_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
2837 if (PerlIOValid(f) && PerlIOValid(n = PerlIONext(f))) {
2838 PerlIO_funcs * const toptab = PerlIOBase(n)->tab;
2839 if (toptab == tab) {
2840 /* Top is already stdio - pop self (duplicate) and use original */
2841 PerlIO_pop(aTHX_ f);
2844 const int fd = PerlIO_fileno(n);
2847 if (fd >= 0 && (stdio = PerlSIO_fdopen(fd,
2848 mode = PerlIOStdio_mode(mode, tmode)))) {
2849 PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
2850 /* We never call down so do any pending stuff now */
2851 PerlIO_flush(PerlIONext(f));
2858 return PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
2863 PerlIO_importFILE(FILE *stdio, const char *mode)
2869 if (!mode || !*mode) {
2870 /* We need to probe to see how we can open the stream
2871 so start with read/write and then try write and read
2872 we dup() so that we can fclose without loosing the fd.
2874 Note that the errno value set by a failing fdopen
2875 varies between stdio implementations.
2877 const int fd = PerlLIO_dup(fileno(stdio));
2878 FILE *f2 = PerlSIO_fdopen(fd, (mode = "r+"));
2880 f2 = PerlSIO_fdopen(fd, (mode = "w"));
2883 f2 = PerlSIO_fdopen(fd, (mode = "r"));
2886 /* Don't seem to be able to open */
2892 if ((f = PerlIO_push(aTHX_(f = PerlIO_allocate(aTHX)), PERLIO_FUNCS_CAST(&PerlIO_stdio), mode, NULL))) {
2893 s = PerlIOSelf(f, PerlIOStdio);
2895 PerlIOUnix_refcnt_inc(fileno(stdio));
2902 PerlIOStdio_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
2903 IV n, const char *mode, int fd, int imode,
2904 int perm, PerlIO *f, int narg, SV **args)
2907 if (PerlIOValid(f)) {
2908 const char * const path = SvPV_nolen_const(*args);
2909 PerlIOStdio * const s = PerlIOSelf(f, PerlIOStdio);
2911 PerlIOUnix_refcnt_dec(fileno(s->stdio));
2912 stdio = PerlSIO_freopen(path, (mode = PerlIOStdio_mode(mode, tmode)),
2917 PerlIOUnix_refcnt_inc(fileno(s->stdio));
2922 const char * const path = SvPV_nolen_const(*args);
2923 if (*mode == IoTYPE_NUMERIC) {
2925 fd = PerlLIO_open3(path, imode, perm);
2929 bool appended = FALSE;
2931 /* Cygwin wants its 'b' early. */
2933 mode = PerlIOStdio_mode(mode, tmode);
2935 stdio = PerlSIO_fopen(path, mode);
2938 f = PerlIO_allocate(aTHX);
2941 mode = PerlIOStdio_mode(mode, tmode);
2942 f = PerlIO_push(aTHX_ f, self, mode, PerlIOArg);
2944 PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
2945 PerlIOUnix_refcnt_inc(fileno(stdio));
2947 PerlSIO_fclose(stdio);
2959 if (*mode == IoTYPE_IMPLICIT) {
2966 stdio = PerlSIO_stdin;
2969 stdio = PerlSIO_stdout;
2972 stdio = PerlSIO_stderr;
2977 stdio = PerlSIO_fdopen(fd, mode =
2978 PerlIOStdio_mode(mode, tmode));
2982 f = PerlIO_allocate(aTHX);
2984 if ((f = PerlIO_push(aTHX_ f, self, mode, PerlIOArg))) {
2985 PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
2986 PerlIOUnix_refcnt_inc(fileno(stdio));
2996 PerlIOStdio_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
2998 /* This assumes no layers underneath - which is what
2999 happens, but is not how I remember it. NI-S 2001/10/16
3001 if ((f = PerlIOBase_dup(aTHX_ f, o, param, flags))) {
3002 FILE *stdio = PerlIOSelf(o, PerlIOStdio)->stdio;
3003 const int fd = fileno(stdio);
3005 if (flags & PERLIO_DUP_FD) {
3006 const int dfd = PerlLIO_dup(fileno(stdio));
3008 stdio = PerlSIO_fdopen(dfd, PerlIO_modestr(o,mode));
3013 /* FIXME: To avoid messy error recovery if dup fails
3014 re-use the existing stdio as though flag was not set
3018 stdio = PerlSIO_fdopen(fd, PerlIO_modestr(o,mode));
3020 PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
3022 PerlIOUnix_refcnt_inc(fileno(stdio));
3029 PerlIOStdio_invalidate_fileno(pTHX_ FILE *f)
3031 PERL_UNUSED_CONTEXT;
3033 /* XXX this could use PerlIO_canset_fileno() and
3034 * PerlIO_set_fileno() support from Configure
3036 # if defined(__UCLIBC__)
3037 /* uClibc must come before glibc because it defines __GLIBC__ as well. */
3040 # elif defined(__GLIBC__)
3041 /* There may be a better way for GLIBC:
3042 - libio.h defines a flag to not close() on cleanup
3046 # elif defined(__sun__)
3049 # elif defined(__hpux)
3053 /* Next one ->_file seems to be a reasonable fallback, i.e. if
3054 your platform does not have special entry try this one.
3055 [For OSF only have confirmation for Tru64 (alpha)
3056 but assume other OSFs will be similar.]
3058 # elif defined(_AIX) || defined(__osf__) || defined(__irix__)
3061 # elif defined(__FreeBSD__)
3062 /* There may be a better way on FreeBSD:
3063 - we could insert a dummy func in the _close function entry
3064 f->_close = (int (*)(void *)) dummy_close;
3068 # elif defined(__OpenBSD__)
3069 /* There may be a better way on OpenBSD:
3070 - we could insert a dummy func in the _close function entry
3071 f->_close = (int (*)(void *)) dummy_close;
3075 # elif defined(__EMX__)
3076 /* f->_flags &= ~_IOOPEN; */ /* Will leak stream->_buffer */
3079 # elif defined(__CYGWIN__)
3080 /* There may be a better way on CYGWIN:
3081 - we could insert a dummy func in the _close function entry
3082 f->_close = (int (*)(void *)) dummy_close;
3086 # elif defined(WIN32)
3087 # if defined(__BORLANDC__)
3088 f->fd = PerlLIO_dup(fileno(f));
3089 # elif defined(UNDER_CE)
3090 /* WIN_CE does not have access to FILE internals, it hardly has FILE
3099 /* Sarathy's code did this - we fall back to a dup/dup2 hack
3100 (which isn't thread safe) instead
3102 # error "Don't know how to set FILE.fileno on your platform"
3110 PerlIOStdio_close(pTHX_ PerlIO *f)
3112 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3118 const int fd = fileno(stdio);
3126 #ifdef SOCKS5_VERSION_NAME
3127 /* Socks lib overrides close() but stdio isn't linked to
3128 that library (though we are) - so we must call close()
3129 on sockets on stdio's behalf.
3132 Sock_size_t optlen = sizeof(int);
3133 if (getsockopt(fd, SOL_SOCKET, SO_TYPE, (void *) &optval, &optlen) == 0)
3136 /* Test for -1, as *BSD stdio (at least) on fclose sets the FILE* such
3137 that a subsequent fileno() on it returns -1. Don't want to croak()
3138 from within PerlIOUnix_refcnt_dec() if some buggy caller code is
3139 trying to close an already closed handle which somehow it still has
3140 a reference to. (via.xs, I'm looking at you). */
3141 if (fd != -1 && PerlIOUnix_refcnt_dec(fd) > 0) {
3142 /* File descriptor still in use */
3146 /* For STD* handles, don't close stdio, since we shared the FILE *, too. */
3147 if (stdio == stdin) /* Some stdios are buggy fflush-ing inputs */
3149 if (stdio == stdout || stdio == stderr)
3150 return PerlIO_flush(f);
3151 /* Tricky - must fclose(stdio) to free memory but not close(fd)
3152 Use Sarathy's trick from maint-5.6 to invalidate the
3153 fileno slot of the FILE *
3155 result = PerlIO_flush(f);
3157 invalidate = PerlIOStdio_invalidate_fileno(aTHX_ stdio);
3160 MUTEX_LOCK(&PL_perlio_mutex);
3161 /* Right. We need a mutex here because for a brief while we
3162 will have the situation that fd is actually closed. Hence if
3163 a second thread were to get into this block, its dup() would
3164 likely return our fd as its dupfd. (after all, it is closed)
3165 Then if we get to the dup2() first, we blat the fd back
3166 (messing up its temporary as a side effect) only for it to
3167 then close its dupfd (== our fd) in its close(dupfd) */
3169 /* There is, of course, a race condition, that any other thread
3170 trying to input/output/whatever on this fd will be stuffed
3171 for the duration of this little manoeuvrer. Perhaps we
3172 should hold an IO mutex for the duration of every IO
3173 operation if we know that invalidate doesn't work on this
3174 platform, but that would suck, and could kill performance.
3176 Except that correctness trumps speed.
3177 Advice from klortho #11912. */
3179 dupfd = PerlLIO_dup(fd);
3182 MUTEX_UNLOCK(&PL_perlio_mutex);
3183 /* Oh cXap. This isn't going to go well. Not sure if we can
3184 recover from here, or if closing this particular FILE *
3185 is a good idea now. */
3190 SAVE_ERRNO; /* This is here only to silence compiler warnings */
3192 result = PerlSIO_fclose(stdio);
3193 /* We treat error from stdio as success if we invalidated
3194 errno may NOT be expected EBADF
3196 if (invalidate && result != 0) {
3200 #ifdef SOCKS5_VERSION_NAME
3201 /* in SOCKS' case, let close() determine return value */
3205 PerlLIO_dup2(dupfd,fd);
3206 PerlLIO_close(dupfd);
3208 MUTEX_UNLOCK(&PL_perlio_mutex);
3216 PerlIOStdio_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
3219 FILE * const s = PerlIOSelf(f, PerlIOStdio)->stdio;
3223 STDCHAR *buf = (STDCHAR *) vbuf;
3225 * Perl is expecting PerlIO_getc() to fill the buffer Linux's
3226 * stdio does not do that for fread()
3228 const int ch = PerlSIO_fgetc(s);
3235 got = PerlSIO_fread(vbuf, 1, count, s);
3236 if (got == 0 && PerlSIO_ferror(s))
3238 if (got >= 0 || errno != EINTR)
3241 SETERRNO(0,0); /* just in case */
3247 PerlIOStdio_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
3250 FILE * const s = PerlIOSelf(f, PerlIOStdio)->stdio;
3252 #ifdef STDIO_BUFFER_WRITABLE
3253 if (PerlIO_fast_gets(f) && PerlIO_has_base(f)) {
3254 STDCHAR *buf = ((STDCHAR *) vbuf) + count;
3255 STDCHAR *base = PerlIO_get_base(f);
3256 SSize_t cnt = PerlIO_get_cnt(f);
3257 STDCHAR *ptr = PerlIO_get_ptr(f);
3258 SSize_t avail = ptr - base;
3260 if (avail > count) {
3264 Move(buf-avail,ptr,avail,STDCHAR);
3267 PerlIO_set_ptrcnt(f,ptr,cnt+avail);
3268 if (PerlSIO_feof(s) && unread >= 0)
3269 PerlSIO_clearerr(s);
3274 if (PerlIO_has_cntptr(f)) {
3275 /* We can get pointer to buffer but not its base
3276 Do ungetc() but check chars are ending up in the
3279 STDCHAR *eptr = (STDCHAR*)PerlSIO_get_ptr(s);
3280 STDCHAR *buf = ((STDCHAR *) vbuf) + count;
3282 const int ch = *--buf & 0xFF;
3283 if (ungetc(ch,s) != ch) {
3284 /* ungetc did not work */
3287 if ((STDCHAR*)PerlSIO_get_ptr(s) != --eptr || ((*eptr & 0xFF) != ch)) {
3288 /* Did not change pointer as expected */
3289 fgetc(s); /* get char back again */
3299 unread += PerlIOBase_unread(aTHX_ f, vbuf, count);
3305 PerlIOStdio_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
3310 got = PerlSIO_fwrite(vbuf, 1, count,
3311 PerlIOSelf(f, PerlIOStdio)->stdio);
3312 if (got >= 0 || errno != EINTR)
3315 SETERRNO(0,0); /* just in case */
3321 PerlIOStdio_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
3323 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3324 PERL_UNUSED_CONTEXT;
3326 return PerlSIO_fseek(stdio, offset, whence);
3330 PerlIOStdio_tell(pTHX_ PerlIO *f)
3332 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3333 PERL_UNUSED_CONTEXT;
3335 return PerlSIO_ftell(stdio);
3339 PerlIOStdio_flush(pTHX_ PerlIO *f)
3341 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3342 PERL_UNUSED_CONTEXT;
3344 if (PerlIOBase(f)->flags & PERLIO_F_CANWRITE) {
3345 return PerlSIO_fflush(stdio);
3351 * FIXME: This discards ungetc() and pre-read stuff which is not
3352 * right if this is just a "sync" from a layer above Suspect right
3353 * design is to do _this_ but not have layer above flush this
3354 * layer read-to-read
3357 * Not writeable - sync by attempting a seek
3360 if (PerlSIO_fseek(stdio, (Off_t) 0, SEEK_CUR) != 0)
3368 PerlIOStdio_eof(pTHX_ PerlIO *f)
3370 PERL_UNUSED_CONTEXT;
3372 return PerlSIO_feof(PerlIOSelf(f, PerlIOStdio)->stdio);
3376 PerlIOStdio_error(pTHX_ PerlIO *f)
3378 PERL_UNUSED_CONTEXT;
3380 return PerlSIO_ferror(PerlIOSelf(f, PerlIOStdio)->stdio);
3384 PerlIOStdio_clearerr(pTHX_ PerlIO *f)
3386 PERL_UNUSED_CONTEXT;
3388 PerlSIO_clearerr(PerlIOSelf(f, PerlIOStdio)->stdio);
3392 PerlIOStdio_setlinebuf(pTHX_ PerlIO *f)
3394 PERL_UNUSED_CONTEXT;
3396 #ifdef HAS_SETLINEBUF
3397 PerlSIO_setlinebuf(PerlIOSelf(f, PerlIOStdio)->stdio);
3399 PerlSIO_setvbuf(PerlIOSelf(f, PerlIOStdio)->stdio, NULL, _IOLBF, 0);
3405 PerlIOStdio_get_base(pTHX_ PerlIO *f)
3407 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3408 return (STDCHAR*)PerlSIO_get_base(stdio);
3412 PerlIOStdio_get_bufsiz(pTHX_ PerlIO *f)
3414 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3415 return PerlSIO_get_bufsiz(stdio);
3419 #ifdef USE_STDIO_PTR
3421 PerlIOStdio_get_ptr(pTHX_ PerlIO *f)
3423 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3424 return (STDCHAR*)PerlSIO_get_ptr(stdio);
3428 PerlIOStdio_get_cnt(pTHX_ PerlIO *f)
3430 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3431 return PerlSIO_get_cnt(stdio);
3435 PerlIOStdio_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
3437 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3439 #ifdef STDIO_PTR_LVALUE
3440 PerlSIO_set_ptr(stdio, ptr); /* LHS STDCHAR* cast non-portable */
3441 #ifdef STDIO_PTR_LVAL_SETS_CNT
3442 assert(PerlSIO_get_cnt(stdio) == (cnt));
3444 #if (!defined(STDIO_PTR_LVAL_NOCHANGE_CNT))
3446 * Setting ptr _does_ change cnt - we are done
3450 #else /* STDIO_PTR_LVALUE */
3452 #endif /* STDIO_PTR_LVALUE */
3455 * Now (or only) set cnt
3457 #ifdef STDIO_CNT_LVALUE
3458 PerlSIO_set_cnt(stdio, cnt);
3459 #else /* STDIO_CNT_LVALUE */
3460 #if (defined(STDIO_PTR_LVALUE) && defined(STDIO_PTR_LVAL_SETS_CNT))
3461 PerlSIO_set_ptr(stdio,
3462 PerlSIO_get_ptr(stdio) + (PerlSIO_get_cnt(stdio) -
3464 #else /* STDIO_PTR_LVAL_SETS_CNT */
3466 #endif /* STDIO_PTR_LVAL_SETS_CNT */
3467 #endif /* STDIO_CNT_LVALUE */
3474 PerlIOStdio_fill(pTHX_ PerlIO *f)
3476 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3478 PERL_UNUSED_CONTEXT;
3481 * fflush()ing read-only streams can cause trouble on some stdio-s
3483 if ((PerlIOBase(f)->flags & PERLIO_F_CANWRITE)) {
3484 if (PerlSIO_fflush(stdio) != 0)
3488 c = PerlSIO_fgetc(stdio);
3491 if (! PerlSIO_ferror(stdio) || errno != EINTR)
3497 #if (defined(STDIO_PTR_LVALUE) && (defined(STDIO_CNT_LVALUE) || defined(STDIO_PTR_LVAL_SETS_CNT)))
3499 #ifdef STDIO_BUFFER_WRITABLE
3500 if (PerlIO_fast_gets(f) && PerlIO_has_base(f)) {
3501 /* Fake ungetc() to the real buffer in case system's ungetc
3504 STDCHAR *base = (STDCHAR*)PerlSIO_get_base(stdio);
3505 SSize_t cnt = PerlSIO_get_cnt(stdio);
3506 STDCHAR *ptr = (STDCHAR*)PerlSIO_get_ptr(stdio);
3507 if (ptr == base+1) {
3508 *--ptr = (STDCHAR) c;
3509 PerlIOStdio_set_ptrcnt(aTHX_ f,ptr,cnt+1);
3510 if (PerlSIO_feof(stdio))
3511 PerlSIO_clearerr(stdio);
3517 if (PerlIO_has_cntptr(f)) {
3519 if (PerlIOStdio_unread(aTHX_ f,&ch,1) == 1) {
3526 /* An ungetc()d char is handled separately from the regular
3527 * buffer, so we stuff it in the buffer ourselves.
3528 * Should never get called as should hit code above
3530 *(--((*stdio)->_ptr)) = (unsigned char) c;
3533 /* If buffer snoop scheme above fails fall back to
3536 if (PerlSIO_ungetc(c, stdio) != c)
3544 PERLIO_FUNCS_DECL(PerlIO_stdio) = {
3545 sizeof(PerlIO_funcs),
3547 sizeof(PerlIOStdio),
3548 PERLIO_K_BUFFERED|PERLIO_K_RAW,
3552 PerlIOBase_binmode, /* binmode */
3566 PerlIOStdio_clearerr,
3567 PerlIOStdio_setlinebuf,
3569 PerlIOStdio_get_base,
3570 PerlIOStdio_get_bufsiz,
3575 #ifdef USE_STDIO_PTR
3576 PerlIOStdio_get_ptr,
3577 PerlIOStdio_get_cnt,
3578 # if defined(HAS_FAST_STDIO) && defined(USE_FAST_STDIO)
3579 PerlIOStdio_set_ptrcnt,
3582 # endif /* HAS_FAST_STDIO && USE_FAST_STDIO */
3587 #endif /* USE_STDIO_PTR */
3590 /* Note that calls to PerlIO_exportFILE() are reversed using
3591 * PerlIO_releaseFILE(), not importFILE. */
3593 PerlIO_exportFILE(PerlIO * f, const char *mode)
3597 if (PerlIOValid(f)) {
3600 if (!mode || !*mode) {
3601 mode = PerlIO_modestr(f, buf);
3603 stdio = PerlSIO_fdopen(PerlIO_fileno(f), mode);
3607 /* De-link any lower layers so new :stdio sticks */
3609 if ((f2 = PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_stdio), buf, NULL))) {
3610 PerlIOStdio *s = PerlIOSelf((f = f2), PerlIOStdio);
3612 PerlIOUnix_refcnt_inc(fileno(stdio));
3613 /* Link previous lower layers under new one */
3617 /* restore layers list */
3627 PerlIO_findFILE(PerlIO *f)
3632 if (l->tab == &PerlIO_stdio) {
3633 PerlIOStdio *s = PerlIOSelf(&l, PerlIOStdio);
3636 l = *PerlIONext(&l);
3638 /* Uses fallback "mode" via PerlIO_modestr() in PerlIO_exportFILE */
3639 /* However, we're not really exporting a FILE * to someone else (who
3640 becomes responsible for closing it, or calling PerlIO_releaseFILE())
3641 So we need to undo its refernce count increase on the underlying file
3642 descriptor. We have to do this, because if the loop above returns you
3643 the FILE *, then *it* didn't increase any reference count. So there's
3644 only one way to be consistent. */
3645 stdio = PerlIO_exportFILE(f, NULL);
3647 const int fd = fileno(stdio);
3649 PerlIOUnix_refcnt_dec(fd);
3654 /* Use this to reverse PerlIO_exportFILE calls. */
3656 PerlIO_releaseFILE(PerlIO *p, FILE *f)
3661 if (l->tab == &PerlIO_stdio) {
3662 PerlIOStdio *s = PerlIOSelf(&l, PerlIOStdio);
3663 if (s->stdio == f) {
3665 const int fd = fileno(f);
3667 PerlIOUnix_refcnt_dec(fd);
3668 PerlIO_pop(aTHX_ p);
3677 /*--------------------------------------------------------------------------------------*/
3679 * perlio buffer layer
3683 PerlIOBuf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
3685 PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
3686 const int fd = PerlIO_fileno(f);
3687 if (fd >= 0 && PerlLIO_isatty(fd)) {
3688 PerlIOBase(f)->flags |= PERLIO_F_LINEBUF | PERLIO_F_TTY;
3690 if (*PerlIONext(f)) {
3691 const Off_t posn = PerlIO_tell(PerlIONext(f));
3692 if (posn != (Off_t) - 1) {
3696 return PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
3700 PerlIOBuf_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
3701 IV n, const char *mode, int fd, int imode, int perm,
3702 PerlIO *f, int narg, SV **args)
3704 if (PerlIOValid(f)) {
3705 PerlIO *next = PerlIONext(f);
3707 PerlIO_layer_fetch(aTHX_ layers, n - 1, PerlIOBase(next)->tab);
3708 if (tab && tab->Open)
3710 (*tab->Open)(aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
3712 if (!next || (*PerlIOBase(f)->tab->Pushed) (aTHX_ f, mode, PerlIOArg, self) != 0) {
3717 PerlIO_funcs *tab = PerlIO_layer_fetch(aTHX_ layers, n - 1, PerlIO_default_btm());
3719 if (*mode == IoTYPE_IMPLICIT) {
3725 if (tab && tab->Open)
3726 f = (*tab->Open)(aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
3729 SETERRNO(EINVAL, LIB_INVARG);
3731 if (PerlIO_push(aTHX_ f, self, mode, PerlIOArg) == 0) {
3733 * if push fails during open, open fails. close will pop us.
3738 fd = PerlIO_fileno(f);
3739 if (init && fd == 2) {
3741 * Initial stderr is unbuffered
3743 PerlIOBase(f)->flags |= PERLIO_F_UNBUF;
3745 #ifdef PERLIO_USING_CRLF
3746 # ifdef PERLIO_IS_BINMODE_FD
3747 if (PERLIO_IS_BINMODE_FD(fd))
3748 PerlIO_binmode(aTHX_ f, '<'/*not used*/, O_BINARY, NULL);
3752 * do something about failing setmode()? --jhi
3754 PerlLIO_setmode(fd, O_BINARY);
3763 * This "flush" is akin to sfio's sync in that it handles files in either
3764 * read or write state. For write state, we put the postponed data through
3765 * the next layers. For read state, we seek() the next layers to the
3766 * offset given by current position in the buffer, and discard the buffer
3767 * state (XXXX supposed to be for seek()able buffers only, but now it is done
3768 * in any case?). Then the pass the stick further in chain.
3771 PerlIOBuf_flush(pTHX_ PerlIO *f)
3773 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
3775 PerlIO *n = PerlIONext(f);
3776 if (PerlIOBase(f)->flags & PERLIO_F_WRBUF) {
3778 * write() the buffer
3780 const STDCHAR *buf = b->buf;
3781 const STDCHAR *p = buf;
3782 while (p < b->ptr) {
3783 SSize_t count = PerlIO_write(n, p, b->ptr - p);
3787 else if (count < 0 || PerlIO_error(n)) {
3788 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
3793 b->posn += (p - buf);
3795 else if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
3796 STDCHAR *buf = PerlIO_get_base(f);
3798 * Note position change
3800 b->posn += (b->ptr - buf);
3801 if (b->ptr < b->end) {
3802 /* We did not consume all of it - try and seek downstream to
3803 our logical position
3805 if (PerlIOValid(n) && PerlIO_seek(n, b->posn, SEEK_SET) == 0) {
3806 /* Reload n as some layers may pop themselves on seek */
3807 b->posn = PerlIO_tell(n = PerlIONext(f));
3810 /* Seek failed (e.g. pipe or tty). Do NOT clear buffer or pre-read
3811 data is lost for good - so return saying "ok" having undone
3814 b->posn -= (b->ptr - buf);
3819 b->ptr = b->end = b->buf;
3820 PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF | PERLIO_F_WRBUF);
3821 /* We check for Valid because of dubious decision to make PerlIO_flush(NULL) flush all */
3822 if (PerlIOValid(n) && PerlIO_flush(n) != 0)
3827 /* This discards the content of the buffer after b->ptr, and rereads
3828 * the buffer from the position off in the layer downstream; here off
3829 * is at offset corresponding to b->ptr - b->buf.
3832 PerlIOBuf_fill(pTHX_ PerlIO *f)
3834 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
3835 PerlIO *n = PerlIONext(f);
3838 * Down-stream flush is defined not to loose read data so is harmless.
3839 * we would not normally be fill'ing if there was data left in anycase.
3841 if (PerlIO_flush(f) != 0) /* XXXX Check that its seek() succeeded?! */
3843 if (PerlIOBase(f)->flags & PERLIO_F_TTY)
3844 PerlIOBase_flush_linebuf(aTHX);
3847 PerlIO_get_base(f); /* allocate via vtable */
3849 assert(b->buf); /* The b->buf does get allocated via the vtable system. */
3851 b->ptr = b->end = b->buf;
3853 if (!PerlIOValid(n)) {
3854 PerlIOBase(f)->flags |= PERLIO_F_EOF;
3858 if (PerlIO_fast_gets(n)) {
3860 * Layer below is also buffered. We do _NOT_ want to call its
3861 * ->Read() because that will loop till it gets what we asked for
3862 * which may hang on a pipe etc. Instead take anything it has to
3863 * hand, or ask it to fill _once_.
3865 avail = PerlIO_get_cnt(n);
3867 avail = PerlIO_fill(n);
3869 avail = PerlIO_get_cnt(n);
3871 if (!PerlIO_error(n) && PerlIO_eof(n))
3876 STDCHAR *ptr = PerlIO_get_ptr(n);
3877 const SSize_t cnt = avail;
3878 if (avail > (SSize_t)b->bufsiz)
3880 Copy(ptr, b->buf, avail, STDCHAR);
3881 PerlIO_set_ptrcnt(n, ptr + avail, cnt - avail);
3885 avail = PerlIO_read(n, b->ptr, b->bufsiz);
3889 PerlIOBase(f)->flags |= PERLIO_F_EOF;
3891 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
3894 b->end = b->buf + avail;
3895 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
3900 PerlIOBuf_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
3902 if (PerlIOValid(f)) {
3903 const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
3906 return PerlIOBase_read(aTHX_ f, vbuf, count);
3912 PerlIOBuf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
3914 const STDCHAR *buf = (const STDCHAR *) vbuf + count;
3915 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
3918 if (PerlIOBase(f)->flags & PERLIO_F_WRBUF)
3923 if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
3925 * Buffer is already a read buffer, we can overwrite any chars
3926 * which have been read back to buffer start
3928 avail = (b->ptr - b->buf);
3932 * Buffer is idle, set it up so whole buffer is available for
3936 b->end = b->buf + avail;
3938 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
3940 * Buffer extends _back_ from where we are now
3942 b->posn -= b->bufsiz;
3944 if (avail > (SSize_t) count) {
3946 * If we have space for more than count, just move count
3954 * In simple stdio-like ungetc() case chars will be already
3957 if (buf != b->ptr) {
3958 Copy(buf, b->ptr, avail, STDCHAR);
3962 PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
3966 unread += PerlIOBase_unread(aTHX_ f, vbuf, count);
3972 PerlIOBuf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
3974 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
3975 const STDCHAR *buf = (const STDCHAR *) vbuf;
3976 const STDCHAR *flushptr = buf;
3980 if (!(PerlIOBase(f)->flags & PERLIO_F_CANWRITE))
3982 if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
3983 if (PerlIO_flush(f) != 0) {
3987 if (PerlIOBase(f)->flags & PERLIO_F_LINEBUF) {
3988 flushptr = buf + count;
3989 while (flushptr > buf && *(flushptr - 1) != '\n')
3993 SSize_t avail = b->bufsiz - (b->ptr - b->buf);
3994 if ((SSize_t) count < avail)
3996 if (flushptr > buf && flushptr <= buf + avail)
3997 avail = flushptr - buf;
3998 PerlIOBase(f)->flags |= PERLIO_F_WRBUF;
4000 Copy(buf, b->ptr, avail, STDCHAR);
4005 if (buf == flushptr)
4008 if (b->ptr >= (b->buf + b->bufsiz))
4011 if (PerlIOBase(f)->flags & PERLIO_F_UNBUF)
4017 PerlIOBuf_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
4020 if ((code = PerlIO_flush(f)) == 0) {
4021 PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
4022 code = PerlIO_seek(PerlIONext(f), offset, whence);
4024 PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
4025 b->posn = PerlIO_tell(PerlIONext(f));
4032 PerlIOBuf_tell(pTHX_ PerlIO *f)
4034 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4036 * b->posn is file position where b->buf was read, or will be written
4038 Off_t posn = b->posn;
4039 if ((PerlIOBase(f)->flags & PERLIO_F_APPEND) &&
4040 (PerlIOBase(f)->flags & PERLIO_F_WRBUF)) {
4042 /* As O_APPEND files are normally shared in some sense it is better
4047 /* when file is NOT shared then this is sufficient */
4048 PerlIO_seek(PerlIONext(f),0, SEEK_END);
4050 posn = b->posn = PerlIO_tell(PerlIONext(f));
4054 * If buffer is valid adjust position by amount in buffer
4056 posn += (b->ptr - b->buf);
4062 PerlIOBuf_popped(pTHX_ PerlIO *f)
4064 const IV code = PerlIOBase_popped(aTHX_ f);
4065 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4066 if (b->buf && b->buf != (STDCHAR *) & b->oneword) {
4069 b->ptr = b->end = b->buf = NULL;
4070 PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF | PERLIO_F_WRBUF);
4075 PerlIOBuf_close(pTHX_ PerlIO *f)
4077 const IV code = PerlIOBase_close(aTHX_ f);
4078 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4079 if (b->buf && b->buf != (STDCHAR *) & b->oneword) {
4082 b->ptr = b->end = b->buf = NULL;
4083 PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF | PERLIO_F_WRBUF);
4088 PerlIOBuf_get_ptr(pTHX_ PerlIO *f)
4090 const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4097 PerlIOBuf_get_cnt(pTHX_ PerlIO *f)
4099 const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4102 if (PerlIOBase(f)->flags & PERLIO_F_RDBUF)
4103 return (b->end - b->ptr);
4108 PerlIOBuf_get_base(pTHX_ PerlIO *f)
4110 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4111 PERL_UNUSED_CONTEXT;
4116 Newxz(b->buf,b->bufsiz, STDCHAR);
4118 b->buf = (STDCHAR *) & b->oneword;
4119 b->bufsiz = sizeof(b->oneword);
4121 b->end = b->ptr = b->buf;
4127 PerlIOBuf_bufsiz(pTHX_ PerlIO *f)
4129 const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4132 return (b->end - b->buf);
4136 PerlIOBuf_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
4138 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4140 PERL_UNUSED_ARG(cnt);
4145 assert(PerlIO_get_cnt(f) == cnt);
4146 assert(b->ptr >= b->buf);
4147 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
4151 PerlIOBuf_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
4153 return PerlIOBase_dup(aTHX_ f, o, param, flags);
4158 PERLIO_FUNCS_DECL(PerlIO_perlio) = {
4159 sizeof(PerlIO_funcs),
4162 PERLIO_K_BUFFERED|PERLIO_K_RAW,
4166 PerlIOBase_binmode, /* binmode */
4180 PerlIOBase_clearerr,
4181 PerlIOBase_setlinebuf,
4186 PerlIOBuf_set_ptrcnt,
4189 /*--------------------------------------------------------------------------------------*/
4191 * Temp layer to hold unread chars when cannot do it any other way
4195 PerlIOPending_fill(pTHX_ PerlIO *f)
4198 * Should never happen
4205 PerlIOPending_close(pTHX_ PerlIO *f)
4208 * A tad tricky - flush pops us, then we close new top
4211 return PerlIO_close(f);
4215 PerlIOPending_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
4218 * A tad tricky - flush pops us, then we seek new top
4221 return PerlIO_seek(f, offset, whence);
4226 PerlIOPending_flush(pTHX_ PerlIO *f)
4228 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4229 if (b->buf && b->buf != (STDCHAR *) & b->oneword) {
4233 PerlIO_pop(aTHX_ f);
4238 PerlIOPending_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
4244 PerlIOBuf_set_ptrcnt(aTHX_ f, ptr, cnt);
4249 PerlIOPending_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
4251 const IV code = PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
4252 PerlIOl * const l = PerlIOBase(f);
4254 * Our PerlIO_fast_gets must match what we are pushed on, or sv_gets()
4255 * etc. get muddled when it changes mid-string when we auto-pop.
4257 l->flags = (l->flags & ~(PERLIO_F_FASTGETS | PERLIO_F_UTF8)) |
4258 (PerlIOBase(PerlIONext(f))->
4259 flags & (PERLIO_F_FASTGETS | PERLIO_F_UTF8));
4264 PerlIOPending_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
4266 SSize_t avail = PerlIO_get_cnt(f);
4268 if ((SSize_t)count < avail)
4271 got = PerlIOBuf_read(aTHX_ f, vbuf, avail);
4272 if (got >= 0 && got < (SSize_t)count) {
4273 const SSize_t more =
4274 PerlIO_read(f, ((STDCHAR *) vbuf) + got, count - got);
4275 if (more >= 0 || got == 0)
4281 PERLIO_FUNCS_DECL(PerlIO_pending) = {
4282 sizeof(PerlIO_funcs),
4285 PERLIO_K_BUFFERED|PERLIO_K_RAW, /* not sure about RAW here */
4286 PerlIOPending_pushed,
4289 PerlIOBase_binmode, /* binmode */
4298 PerlIOPending_close,
4299 PerlIOPending_flush,
4303 PerlIOBase_clearerr,
4304 PerlIOBase_setlinebuf,
4309 PerlIOPending_set_ptrcnt,
4314 /*--------------------------------------------------------------------------------------*/
4316 * crlf - translation On read translate CR,LF to "\n" we do this by
4317 * overriding ptr/cnt entries to hand back a line at a time and keeping a
4318 * record of which nl we "lied" about. On write translate "\n" to CR,LF
4320 * c->nl points on the first byte of CR LF pair when it is temporarily
4321 * replaced by LF, or to the last CR of the buffer. In the former case
4322 * the caller thinks that the buffer ends at c->nl + 1, in the latter
4323 * that it ends at c->nl; these two cases can be distinguished by
4324 * *c->nl. c->nl is set during _getcnt() call, and unset during
4325 * _unread() and _flush() calls.
4326 * It only matters for read operations.
4330 PerlIOBuf base; /* PerlIOBuf stuff */
4331 STDCHAR *nl; /* Position of crlf we "lied" about in the
4335 /* Inherit the PERLIO_F_UTF8 flag from previous layer.
4336 * Otherwise the :crlf layer would always revert back to
4340 S_inherit_utf8_flag(PerlIO *f)
4342 PerlIO *g = PerlIONext(f);
4343 if (PerlIOValid(g)) {
4344 if (PerlIOBase(g)->flags & PERLIO_F_UTF8) {
4345 PerlIOBase(f)->flags |= PERLIO_F_UTF8;
4351 PerlIOCrlf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
4354 PerlIOBase(f)->flags |= PERLIO_F_CRLF;
4355 code = PerlIOBuf_pushed(aTHX_ f, mode, arg, tab);
4357 PerlIO_debug("PerlIOCrlf_pushed f=%p %s %s fl=%08" UVxf "\n",
4358 (void*)f, PerlIOBase(f)->tab->name, (mode) ? mode : "(Null)",
4359 PerlIOBase(f)->flags);
4362 /* Enable the first CRLF capable layer you can find, but if none
4363 * found, the one we just pushed is fine. This results in at
4364 * any given moment at most one CRLF-capable layer being enabled
4365 * in the whole layer stack. */
4366 PerlIO *g = PerlIONext(f);
4367 while (PerlIOValid(g)) {
4368 PerlIOl *b = PerlIOBase(g);
4369 if (b && b->tab == &PerlIO_crlf) {
4370 if (!(b->flags & PERLIO_F_CRLF))
4371 b->flags |= PERLIO_F_CRLF;
4372 S_inherit_utf8_flag(g);
4373 PerlIO_pop(aTHX_ f);
4379 S_inherit_utf8_flag(f);
4385 PerlIOCrlf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
4387 PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
4388 if (c->nl) { /* XXXX Shouldn't it be done only if b->ptr > c->nl? */
4392 if (!(PerlIOBase(f)->flags & PERLIO_F_CRLF))
4393 return PerlIOBuf_unread(aTHX_ f, vbuf, count);
4395 const STDCHAR *buf = (const STDCHAR *) vbuf + count;
4396 PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
4398 if (PerlIOBase(f)->flags & PERLIO_F_WRBUF)
4403 if (!(PerlIOBase(f)->flags & PERLIO_F_RDBUF)) {
4404 b->end = b->ptr = b->buf + b->bufsiz;
4405 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
4406 b->posn -= b->bufsiz;
4408 while (count > 0 && b->ptr > b->buf) {
4409 const int ch = *--buf;
4411 if (b->ptr - 2 >= b->buf) {
4418 /* If b->ptr - 1 == b->buf, we are undoing reading 0xa */
4419 *--(b->ptr) = 0xa; /* Works even if 0xa == '\r' */
4435 /* XXXX This code assumes that buffer size >=2, but does not check it... */
4437 PerlIOCrlf_get_cnt(pTHX_ PerlIO *f)
4439 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4442 if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
4443 PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
4444 if ((PerlIOBase(f)->flags & PERLIO_F_CRLF) && (!c->nl || *c->nl == 0xd)) {
4445 STDCHAR *nl = (c->nl) ? c->nl : b->ptr;
4447 while (nl < b->end && *nl != 0xd)
4449 if (nl < b->end && *nl == 0xd) {
4451 if (nl + 1 < b->end) {
4458 * Not CR,LF but just CR
4466 * Blast - found CR as last char in buffer
4471 * They may not care, defer work as long as
4475 return (nl - b->ptr);
4479 b->ptr++; /* say we have read it as far as
4480 * flush() is concerned */
4481 b->buf++; /* Leave space in front of buffer */
4482 /* Note as we have moved buf up flush's
4484 will naturally make posn point at CR
4486 b->bufsiz--; /* Buffer is thus smaller */
4487 code = PerlIO_fill(f); /* Fetch some more */
4488 b->bufsiz++; /* Restore size for next time */
4489 b->buf--; /* Point at space */
4490 b->ptr = nl = b->buf; /* Which is what we hand
4492 *nl = 0xd; /* Fill in the CR */
4494 goto test; /* fill() call worked */
4496 * CR at EOF - just fall through
4498 /* Should we clear EOF though ??? */
4503 return (((c->nl) ? (c->nl + 1) : b->end) - b->ptr);
4509 PerlIOCrlf_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
4511 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4512 PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
4518 if (ptr == b->end && *c->nl == 0xd) {
4519 /* Defered CR at end of buffer case - we lied about count */
4532 * Test code - delete when it works ...
4534 IV flags = PerlIOBase(f)->flags;
4535 STDCHAR *chk = (c->nl) ? (c->nl+1) : b->end;
4536 if (ptr+cnt == c->nl && c->nl+1 == b->end && *c->nl == 0xd) {
4537 /* Defered CR at end of buffer case - we lied about count */
4543 Perl_croak(aTHX_ "ptr wrong %p != %p fl=%08" UVxf
4544 " nl=%p e=%p for %d", (void*)ptr, (void*)chk,
4545 flags, c->nl, b->end, cnt);
4552 * They have taken what we lied about
4560 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
4564 PerlIOCrlf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
4566 if (!(PerlIOBase(f)->flags & PERLIO_F_CRLF))
4567 return PerlIOBuf_write(aTHX_ f, vbuf, count);
4569 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4570 const STDCHAR *buf = (const STDCHAR *) vbuf;
4571 const STDCHAR * const ebuf = buf + count;
4574 if (!(PerlIOBase(f)->flags & PERLIO_F_CANWRITE))
4576 while (buf < ebuf) {
4577 const STDCHAR * const eptr = b->buf + b->bufsiz;
4578 PerlIOBase(f)->flags |= PERLIO_F_WRBUF;
4579 while (buf < ebuf && b->ptr < eptr) {
4581 if ((b->ptr + 2) > eptr) {
4589 *(b->ptr)++ = 0xd; /* CR */
4590 *(b->ptr)++ = 0xa; /* LF */
4592 if (PerlIOBase(f)->flags & PERLIO_F_LINEBUF) {
4599 *(b->ptr)++ = *buf++;
4601 if (b->ptr >= eptr) {
4607 if (PerlIOBase(f)->flags & PERLIO_F_UNBUF)
4609 return (buf - (STDCHAR *) vbuf);
4614 PerlIOCrlf_flush(pTHX_ PerlIO *f)
4616 PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
4621 return PerlIOBuf_flush(aTHX_ f);
4625 PerlIOCrlf_binmode(pTHX_ PerlIO *f)
4627 if ((PerlIOBase(f)->flags & PERLIO_F_CRLF)) {
4628 /* In text mode - flush any pending stuff and flip it */
4629 PerlIOBase(f)->flags &= ~PERLIO_F_CRLF;
4630 #ifndef PERLIO_USING_CRLF
4631 /* CRLF is unusual case - if this is just the :crlf layer pop it */
4632 PerlIO_pop(aTHX_ f);
4638 PERLIO_FUNCS_DECL(PerlIO_crlf) = {
4639 sizeof(PerlIO_funcs),
4642 PERLIO_K_BUFFERED | PERLIO_K_CANCRLF | PERLIO_K_RAW,
4644 PerlIOBuf_popped, /* popped */
4646 PerlIOCrlf_binmode, /* binmode */
4650 PerlIOBuf_read, /* generic read works with ptr/cnt lies */
4651 PerlIOCrlf_unread, /* Put CR,LF in buffer for each '\n' */
4652 PerlIOCrlf_write, /* Put CR,LF in buffer for each '\n' */
4660 PerlIOBase_clearerr,
4661 PerlIOBase_setlinebuf,
4666 PerlIOCrlf_set_ptrcnt,
4670 /*--------------------------------------------------------------------------------------*/
4672 * mmap as "buffer" layer
4676 PerlIOBuf base; /* PerlIOBuf stuff */
4677 Mmap_t mptr; /* Mapped address */
4678 Size_t len; /* mapped length */
4679 STDCHAR *bbuf; /* malloced buffer if map fails */
4683 PerlIOMmap_map(pTHX_ PerlIO *f)
4686 PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4687 const IV flags = PerlIOBase(f)->flags;
4691 if (flags & PERLIO_F_CANREAD) {
4692 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4693 const int fd = PerlIO_fileno(f);
4695 code = Fstat(fd, &st);
4696 if (code == 0 && S_ISREG(st.st_mode)) {
4697 SSize_t len = st.st_size - b->posn;
4700 if (PL_mmap_page_size <= 0)
4701 Perl_croak(aTHX_ "panic: bad pagesize %" IVdf,
4705 * This is a hack - should never happen - open should
4708 b->posn = PerlIO_tell(PerlIONext(f));
4710 posn = (b->posn / PL_mmap_page_size) * PL_mmap_page_size;
4711 len = st.st_size - posn;
4712 m->mptr = (Mmap_t)mmap(NULL, len, PROT_READ, MAP_SHARED, fd, posn);
4713 if (m->mptr && m->mptr != (Mmap_t) - 1) {
4714 #if 0 && defined(HAS_MADVISE) && defined(MADV_SEQUENTIAL)
4715 madvise(m->mptr, len, MADV_SEQUENTIAL);
4717 #if 0 && defined(HAS_MADVISE) && defined(MADV_WILLNEED)
4718 madvise(m->mptr, len, MADV_WILLNEED);
4720 PerlIOBase(f)->flags =
4721 (flags & ~PERLIO_F_EOF) | PERLIO_F_RDBUF;
4722 b->end = ((STDCHAR *) m->mptr) + len;
4723 b->buf = ((STDCHAR *) m->mptr) + (b->posn - posn);
4732 PerlIOBase(f)->flags =
4733 flags | PERLIO_F_EOF | PERLIO_F_RDBUF;
4735 b->ptr = b->end = b->ptr;
4744 PerlIOMmap_unmap(pTHX_ PerlIO *f)
4746 PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4749 PerlIOBuf * const b = &m->base;
4751 /* The munmap address argument is tricky: depending on the
4752 * standard it is either "void *" or "caddr_t" (which is
4753 * usually "char *" (signed or unsigned). If we cast it
4754 * to "void *", those that have it caddr_t and an uptight
4755 * C++ compiler, will freak out. But casting it as char*
4756 * should work. Maybe. (Using Mmap_t figured out by
4757 * Configure doesn't always work, apparently.) */
4758 code = munmap((char*)m->mptr, m->len);
4762 if (PerlIO_seek(PerlIONext(f), b->posn, SEEK_SET) != 0)
4765 b->ptr = b->end = b->buf;
4766 PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF | PERLIO_F_WRBUF);
4772 PerlIOMmap_get_base(pTHX_ PerlIO *f)
4774 PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4775 PerlIOBuf * const b = &m->base;
4776 if (b->buf && (PerlIOBase(f)->flags & PERLIO_F_RDBUF)) {
4778 * Already have a readbuffer in progress
4784 * We have a write buffer or flushed PerlIOBuf read buffer
4786 m->bbuf = b->buf; /* save it in case we need it again */
4787 b->buf = NULL; /* Clear to trigger below */
4790 PerlIOMmap_map(aTHX_ f); /* Try and map it */
4793 * Map did not work - recover PerlIOBuf buffer if we have one
4798 b->ptr = b->end = b->buf;
4801 return PerlIOBuf_get_base(aTHX_ f);
4805 PerlIOMmap_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
4807 PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4808 PerlIOBuf * const b = &m->base;
4809 if (PerlIOBase(f)->flags & PERLIO_F_WRBUF)
4811 if (b->ptr && (b->ptr - count) >= b->buf
4812 && memEQ(b->ptr - count, vbuf, count)) {
4814 PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
4819 * Loose the unwritable mapped buffer
4823 * If flush took the "buffer" see if we have one from before
4825 if (!b->buf && m->bbuf)
4828 PerlIOBuf_get_base(aTHX_ f);
4832 return PerlIOBuf_unread(aTHX_ f, vbuf, count);
4836 PerlIOMmap_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
4838 PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4839 PerlIOBuf * const b = &m->base;
4841 if (!b->buf || !(PerlIOBase(f)->flags & PERLIO_F_WRBUF)) {
4843 * No, or wrong sort of, buffer
4846 if (PerlIOMmap_unmap(aTHX_ f) != 0)
4850 * If unmap took the "buffer" see if we have one from before
4852 if (!b->buf && m->bbuf)
4855 PerlIOBuf_get_base(aTHX_ f);
4859 return PerlIOBuf_write(aTHX_ f, vbuf, count);
4863 PerlIOMmap_flush(pTHX_ PerlIO *f)
4865 PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4866 PerlIOBuf * const b = &m->base;
4867 IV code = PerlIOBuf_flush(aTHX_ f);
4869 * Now we are "synced" at PerlIOBuf level
4876 if (PerlIOMmap_unmap(aTHX_ f) != 0)
4881 * We seem to have a PerlIOBuf buffer which was not mapped
4882 * remember it in case we need one later
4891 PerlIOMmap_fill(pTHX_ PerlIO *f)
4893 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4894 IV code = PerlIO_flush(f);
4895 if (code == 0 && !b->buf) {
4896 code = PerlIOMmap_map(aTHX_ f);
4898 if (code == 0 && !(PerlIOBase(f)->flags & PERLIO_F_RDBUF)) {
4899 code = PerlIOBuf_fill(aTHX_ f);
4905 PerlIOMmap_close(pTHX_ PerlIO *f)
4907 PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4908 PerlIOBuf * const b = &m->base;
4909 IV code = PerlIO_flush(f);
4913 b->ptr = b->end = b->buf;
4915 if (PerlIOBuf_close(aTHX_ f) != 0)
4921 PerlIOMmap_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
4923 return PerlIOBase_dup(aTHX_ f, o, param, flags);
4927 PERLIO_FUNCS_DECL(PerlIO_mmap) = {
4928 sizeof(PerlIO_funcs),
4931 PERLIO_K_BUFFERED|PERLIO_K_RAW,
4935 PerlIOBase_binmode, /* binmode */
4949 PerlIOBase_clearerr,
4950 PerlIOBase_setlinebuf,
4951 PerlIOMmap_get_base,
4955 PerlIOBuf_set_ptrcnt,
4958 #endif /* HAS_MMAP */
4961 Perl_PerlIO_stdin(pTHX)
4965 PerlIO_stdstreams(aTHX);
4967 return &PL_perlio[1];
4971 Perl_PerlIO_stdout(pTHX)
4975 PerlIO_stdstreams(aTHX);
4977 return &PL_perlio[2];
4981 Perl_PerlIO_stderr(pTHX)
4985 PerlIO_stdstreams(aTHX);
4987 return &PL_perlio[3];
4990 /*--------------------------------------------------------------------------------------*/
4993 PerlIO_getname(PerlIO *f, char *buf)
4998 bool exported = FALSE;
4999 FILE *stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
5001 stdio = PerlIO_exportFILE(f,0);
5005 name = fgetname(stdio, buf);
5006 if (exported) PerlIO_releaseFILE(f,stdio);
5011 PERL_UNUSED_ARG(buf);
5012 Perl_croak(aTHX_ "Don't know how to get file name");
5018 /*--------------------------------------------------------------------------------------*/
5020 * Functions which can be called on any kind of PerlIO implemented in
5024 #undef PerlIO_fdopen
5026 PerlIO_fdopen(int fd, const char *mode)
5029 return PerlIO_openn(aTHX_ NULL, mode, fd, 0, 0, NULL, 0, NULL);
5034 PerlIO_open(const char *path, const char *mode)
5037 SV *name = sv_2mortal(newSVpv(path, 0));
5038 return PerlIO_openn(aTHX_ NULL, mode, -1, 0, 0, NULL, 1, &name);
5041 #undef Perlio_reopen
5043 PerlIO_reopen(const char *path, const char *mode, PerlIO *f)
5046 SV *name = sv_2mortal(newSVpv(path,0));
5047 return PerlIO_openn(aTHX_ NULL, mode, -1, 0, 0, f, 1, &name);
5052 PerlIO_getc(PerlIO *f)
5056 if ( 1 == PerlIO_read(f, buf, 1) ) {
5057 return (unsigned char) buf[0];
5062 #undef PerlIO_ungetc
5064 PerlIO_ungetc(PerlIO *f, int ch)
5069 if (PerlIO_unread(f, &buf, 1) == 1)
5077 PerlIO_putc(PerlIO *f, int ch)
5081 return PerlIO_write(f, &buf, 1);
5086 PerlIO_puts(PerlIO *f, const char *s)
5089 return PerlIO_write(f, s, strlen(s));
5092 #undef PerlIO_rewind
5094 PerlIO_rewind(PerlIO *f)
5097 PerlIO_seek(f, (Off_t) 0, SEEK_SET);
5101 #undef PerlIO_vprintf
5103 PerlIO_vprintf(PerlIO *f, const char *fmt, va_list ap)
5112 Perl_va_copy(ap, apc);
5113 sv = vnewSVpvf(fmt, &apc);
5115 sv = vnewSVpvf(fmt, &ap);
5117 s = SvPV_const(sv, len);
5118 wrote = PerlIO_write(f, s, len);
5123 #undef PerlIO_printf
5125 PerlIO_printf(PerlIO *f, const char *fmt, ...)
5130 result = PerlIO_vprintf(f, fmt, ap);
5135 #undef PerlIO_stdoutf
5137 PerlIO_stdoutf(const char *fmt, ...)
5143 result = PerlIO_vprintf(PerlIO_stdout(), fmt, ap);
5148 #undef PerlIO_tmpfile
5150 PerlIO_tmpfile(void)
5155 const int fd = win32_tmpfd();
5157 f = PerlIO_fdopen(fd, "w+b");
5159 # if defined(HAS_MKSTEMP) && ! defined(VMS) && ! defined(OS2)
5161 char tempname[] = "/tmp/PerlIO_XXXXXX";
5162 const char * const tmpdir = PL_tainting ? NULL : PerlEnv_getenv("TMPDIR");
5165 * I have no idea how portable mkstemp() is ... NI-S
5167 if (tmpdir && *tmpdir) {
5168 /* if TMPDIR is set and not empty, we try that first */
5169 sv = newSVpv(tmpdir, 0);
5170 sv_catpv(sv, tempname + 4);
5171 fd = mkstemp(SvPVX(sv));
5175 /* else we try /tmp */
5176 fd = mkstemp(tempname);
5179 f = PerlIO_fdopen(fd, "w+");
5181 PerlIOBase(f)->flags |= PERLIO_F_TEMP;
5182 PerlLIO_unlink(sv ? SvPVX_const(sv) : tempname);
5185 # else /* !HAS_MKSTEMP, fallback to stdio tmpfile(). */
5186 FILE * const stdio = PerlSIO_tmpfile();
5189 f = PerlIO_fdopen(fileno(stdio), "w+");
5191 # endif /* else HAS_MKSTEMP */
5192 #endif /* else WIN32 */
5199 #endif /* USE_SFIO */
5200 #endif /* PERLIO_IS_STDIO */
5202 /*======================================================================================*/
5204 * Now some functions in terms of above which may be needed even if we are
5205 * not in true PerlIO mode
5208 Perl_PerlIO_context_layers(pTHX_ const char *mode)
5211 const char *direction = NULL;
5214 * Need to supply default layer info from open.pm
5220 if (mode && mode[0] != 'r') {
5221 if (PL_curcop->cop_hints & HINT_LEXICAL_IO_OUT)
5222 direction = "open>";
5224 if (PL_curcop->cop_hints & HINT_LEXICAL_IO_IN)
5225 direction = "open<";
5230 layers = Perl_refcounted_he_fetch(aTHX_ PL_curcop->cop_hints_hash,
5231 0, direction, 5, 0, 0);
5234 return SvOK(layers) ? SvPV_nolen_const(layers) : NULL;
5239 #undef PerlIO_setpos
5241 PerlIO_setpos(PerlIO *f, SV *pos)
5246 const Off_t * const posn = (Off_t *) SvPV(pos, len);
5247 if (f && len == sizeof(Off_t))
5248 return PerlIO_seek(f, *posn, SEEK_SET);
5250 SETERRNO(EINVAL, SS_IVCHAN);
5254 #undef PerlIO_setpos
5256 PerlIO_setpos(PerlIO *f, SV *pos)
5261 Fpos_t * const fpos = (Fpos_t *) SvPV(pos, len);
5262 if (f && len == sizeof(Fpos_t)) {
5263 #if defined(USE_64_BIT_STDIO) && defined(USE_FSETPOS64)
5264 return fsetpos64(f, fpos);
5266 return fsetpos(f, fpos);
5270 SETERRNO(EINVAL, SS_IVCHAN);
5276 #undef PerlIO_getpos
5278 PerlIO_getpos(PerlIO *f, SV *pos)
5281 Off_t posn = PerlIO_tell(f);
5282 sv_setpvn(pos, (char *) &posn, sizeof(posn));
5283 return (posn == (Off_t) - 1) ? -1 : 0;
5286 #undef PerlIO_getpos
5288 PerlIO_getpos(PerlIO *f, SV *pos)
5293 #if defined(USE_64_BIT_STDIO) && defined(USE_FSETPOS64)
5294 code = fgetpos64(f, &fpos);
5296 code = fgetpos(f, &fpos);
5298 sv_setpvn(pos, (char *) &fpos, sizeof(fpos));
5303 #if (defined(PERLIO_IS_STDIO) || !defined(USE_SFIO)) && !defined(HAS_VPRINTF)
5306 vprintf(char *pat, char *args)
5308 _doprnt(pat, args, stdout);
5309 return 0; /* wrong, but perl doesn't use the return
5314 vfprintf(FILE *fd, char *pat, char *args)
5316 _doprnt(pat, args, fd);
5317 return 0; /* wrong, but perl doesn't use the return
5323 #ifndef PerlIO_vsprintf
5325 PerlIO_vsprintf(char *s, int n, const char *fmt, va_list ap)
5328 const int val = my_vsnprintf(s, n > 0 ? n : 0, fmt, ap);
5329 PERL_UNUSED_CONTEXT;
5331 #ifndef PERL_MY_VSNPRINTF_GUARDED
5332 if (val < 0 || (n > 0 ? val >= n : 0)) {
5333 Perl_croak(aTHX_ "panic: my_vsnprintf overflow in PerlIO_vsprintf\n");
5340 #ifndef PerlIO_sprintf
5342 PerlIO_sprintf(char *s, int n, const char *fmt, ...)
5347 result = PerlIO_vsprintf(s, n, fmt, ap);
5355 * c-indentation-style: bsd
5357 * indent-tabs-mode: t
5360 * ex: set ts=8 sts=4 sw=4 noet: