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 "%s (%d) does not match %s (%d)",
1216 "PerlIO layer function table size", tab->fsize,
1217 "size expected by this perl", sizeof(PerlIO_funcs) );
1221 if (tab->size < sizeof(PerlIOl)) {
1223 "%s (%d) smaller than %s (%d)",
1224 "PerlIO layer instance size", tab->size,
1225 "size expected by this perl", sizeof(PerlIOl) );
1227 /* Real layer with a data area */
1230 Newxz(temp, tab->size, char);
1234 l->tab = (PerlIO_funcs*) tab;
1236 PerlIO_debug("PerlIO_push f=%p %s %s %p\n",
1237 (void*)f, tab->name,
1238 (mode) ? mode : "(Null)", (void*)arg);
1239 if (*l->tab->Pushed &&
1241 (aTHX_ f, mode, arg, (PerlIO_funcs*) tab) != 0) {
1242 PerlIO_pop(aTHX_ f);
1251 /* Pseudo-layer where push does its own stack adjust */
1252 PerlIO_debug("PerlIO_push f=%p %s %s %p\n", (void*)f, tab->name,
1253 (mode) ? mode : "(Null)", (void*)arg);
1255 (*tab->Pushed) (aTHX_ f, mode, arg, (PerlIO_funcs*) tab) != 0) {
1263 PerlIOBase_binmode(pTHX_ PerlIO *f)
1265 if (PerlIOValid(f)) {
1266 /* Is layer suitable for raw stream ? */
1267 if (PerlIOBase(f)->tab->kind & PERLIO_K_RAW) {
1268 /* Yes - turn off UTF-8-ness, to undo UTF-8 locale effects */
1269 PerlIOBase(f)->flags &= ~PERLIO_F_UTF8;
1272 /* Not suitable - pop it */
1273 PerlIO_pop(aTHX_ f);
1281 PerlIORaw_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
1283 PERL_UNUSED_ARG(mode);
1284 PERL_UNUSED_ARG(arg);
1285 PERL_UNUSED_ARG(tab);
1287 if (PerlIOValid(f)) {
1292 * Strip all layers that are not suitable for a raw stream
1295 while (t && (l = *t)) {
1296 if (l->tab->Binmode) {
1297 /* Has a handler - normal case */
1298 if ((*l->tab->Binmode)(aTHX_ t) == 0) {
1300 /* Layer still there - move down a layer */
1309 /* No handler - pop it */
1310 PerlIO_pop(aTHX_ t);
1313 if (PerlIOValid(f)) {
1314 PerlIO_debug(":raw f=%p :%s\n", (void*)f, PerlIOBase(f)->tab->name);
1322 PerlIO_apply_layera(pTHX_ PerlIO *f, const char *mode,
1323 PerlIO_list_t *layers, IV n, IV max)
1327 PerlIO_funcs * const tab = PerlIO_layer_fetch(aTHX_ layers, n, NULL);
1329 if (!PerlIO_push(aTHX_ f, tab, mode, PerlIOArg)) {
1340 PerlIO_apply_layers(pTHX_ PerlIO *f, const char *mode, const char *names)
1344 save_scalar(PL_errgv);
1346 PerlIO_list_t * const layers = PerlIO_list_alloc(aTHX);
1347 code = PerlIO_parse_layers(aTHX_ layers, names);
1349 code = PerlIO_apply_layera(aTHX_ f, mode, layers, 0, layers->cur);
1351 PerlIO_list_free(aTHX_ layers);
1358 /*--------------------------------------------------------------------------------------*/
1360 * Given the abstraction above the public API functions
1364 PerlIO_binmode(pTHX_ PerlIO *f, int iotype, int mode, const char *names)
1366 PerlIO_debug("PerlIO_binmode f=%p %s %c %x %s\n", (void*)f,
1367 (PerlIOBase(f)) ? PerlIOBase(f)->tab->name : "(Null)",
1368 iotype, mode, (names) ? names : "(Null)");
1371 /* Do not flush etc. if (e.g.) switching encodings.
1372 if a pushed layer knows it needs to flush lower layers
1373 (for example :unix which is never going to call them)
1374 it can do the flush when it is pushed.
1376 return PerlIO_apply_layers(aTHX_ f, NULL, names) == 0 ? TRUE : FALSE;
1379 /* Fake 5.6 legacy of using this call to turn ON O_TEXT */
1380 #ifdef PERLIO_USING_CRLF
1381 /* Legacy binmode only has meaning if O_TEXT has a value distinct from
1382 O_BINARY so we can look for it in mode.
1384 if (!(mode & O_BINARY)) {
1386 /* FIXME?: Looking down the layer stack seems wrong,
1387 but is a way of reaching past (say) an encoding layer
1388 to flip CRLF-ness of the layer(s) below
1391 /* Perhaps we should turn on bottom-most aware layer
1392 e.g. Ilya's idea that UNIX TTY could serve
1394 if (PerlIOBase(f)->tab->kind & PERLIO_K_CANCRLF) {
1395 if (!(PerlIOBase(f)->flags & PERLIO_F_CRLF)) {
1396 /* Not in text mode - flush any pending stuff and flip it */
1398 PerlIOBase(f)->flags |= PERLIO_F_CRLF;
1400 /* Only need to turn it on in one layer so we are done */
1405 /* Not finding a CRLF aware layer presumably means we are binary
1406 which is not what was requested - so we failed
1407 We _could_ push :crlf layer but so could caller
1412 /* Legacy binmode is now _defined_ as being equivalent to pushing :raw
1413 So code that used to be here is now in PerlIORaw_pushed().
1415 return PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_raw), NULL, NULL) ? TRUE : FALSE;
1420 PerlIO__close(pTHX_ PerlIO *f)
1422 if (PerlIOValid(f)) {
1423 PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1424 if (tab && tab->Close)
1425 return (*tab->Close)(aTHX_ f);
1427 return PerlIOBase_close(aTHX_ f);
1430 SETERRNO(EBADF, SS_IVCHAN);
1436 Perl_PerlIO_close(pTHX_ PerlIO *f)
1438 const int code = PerlIO__close(aTHX_ f);
1439 while (PerlIOValid(f)) {
1440 PerlIO_pop(aTHX_ f);
1446 Perl_PerlIO_fileno(pTHX_ PerlIO *f)
1449 Perl_PerlIO_or_Base(f, Fileno, fileno, -1, (aTHX_ f));
1453 static PerlIO_funcs *
1454 PerlIO_layer_from_ref(pTHX_ SV *sv)
1458 * For any scalar type load the handler which is bundled with perl
1460 if (SvTYPE(sv) < SVt_PVAV && (!isGV_with_GP(sv) || SvFAKE(sv))) {
1461 PerlIO_funcs *f = PerlIO_find_layer(aTHX_ STR_WITH_LEN("scalar"), 1);
1462 /* This isn't supposed to happen, since PerlIO::scalar is core,
1463 * but could happen anyway in smaller installs or with PAR */
1465 Perl_ck_warner(aTHX_ packWARN(WARN_LAYER), "Unknown PerlIO layer \"scalar\"");
1470 * For other types allow if layer is known but don't try and load it
1472 switch (SvTYPE(sv)) {
1474 return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Array"), 0);
1476 return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Hash"), 0);
1478 return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Code"), 0);
1480 return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Glob"), 0);
1487 PerlIO_resolve_layers(pTHX_ const char *layers,
1488 const char *mode, int narg, SV **args)
1491 PerlIO_list_t *def = PerlIO_default_layers(aTHX);
1494 PerlIO_stdstreams(aTHX);
1496 SV * const arg = *args;
1498 * If it is a reference but not an object see if we have a handler
1501 if (SvROK(arg) && !sv_isobject(arg)) {
1502 PerlIO_funcs * const handler = PerlIO_layer_from_ref(aTHX_ SvRV(arg));
1504 def = PerlIO_list_alloc(aTHX);
1505 PerlIO_list_push(aTHX_ def, handler, &PL_sv_undef);
1509 * Don't fail if handler cannot be found :via(...) etc. may do
1510 * something sensible else we will just stringfy and open
1515 if (!layers || !*layers)
1516 layers = Perl_PerlIO_context_layers(aTHX_ mode);
1517 if (layers && *layers) {
1520 av = PerlIO_clone_list(aTHX_ def, NULL);
1525 if (PerlIO_parse_layers(aTHX_ av, layers) == 0) {
1529 PerlIO_list_free(aTHX_ av);
1541 PerlIO_openn(pTHX_ const char *layers, const char *mode, int fd,
1542 int imode, int perm, PerlIO *f, int narg, SV **args)
1545 if (!f && narg == 1 && *args == &PL_sv_undef) {
1546 if ((f = PerlIO_tmpfile())) {
1547 if (!layers || !*layers)
1548 layers = Perl_PerlIO_context_layers(aTHX_ mode);
1549 if (layers && *layers)
1550 PerlIO_apply_layers(aTHX_ f, mode, layers);
1554 PerlIO_list_t *layera;
1556 PerlIO_funcs *tab = NULL;
1557 if (PerlIOValid(f)) {
1559 * This is "reopen" - it is not tested as perl does not use it
1563 layera = PerlIO_list_alloc(aTHX);
1567 arg = (*l->tab->Getarg) (aTHX_ &l, NULL, 0);
1568 PerlIO_list_push(aTHX_ layera, l->tab,
1569 (arg) ? arg : &PL_sv_undef);
1571 l = *PerlIONext(&l);
1575 layera = PerlIO_resolve_layers(aTHX_ layers, mode, narg, args);
1581 * Start at "top" of layer stack
1583 n = layera->cur - 1;
1585 PerlIO_funcs * const t = PerlIO_layer_fetch(aTHX_ layera, n, NULL);
1594 * Found that layer 'n' can do opens - call it
1596 if (narg > 1 && !(tab->kind & PERLIO_K_MULTIARG)) {
1597 Perl_croak(aTHX_ "More than one argument to open(,':%s')",tab->name);
1599 PerlIO_debug("openn(%s,'%s','%s',%d,%x,%o,%p,%d,%p)\n",
1600 tab->name, layers ? layers : "(Null)", mode, fd,
1601 imode, perm, (void*)f, narg, (void*)args);
1603 f = (*tab->Open) (aTHX_ tab, layera, n, mode, fd, imode, perm,
1606 SETERRNO(EINVAL, LIB_INVARG);
1610 if (n + 1 < layera->cur) {
1612 * More layers above the one that we used to open -
1615 if (PerlIO_apply_layera(aTHX_ f, mode, layera, n + 1, layera->cur) != 0) {
1616 /* If pushing layers fails close the file */
1623 PerlIO_list_free(aTHX_ layera);
1630 Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
1632 PERL_ARGS_ASSERT_PERLIO_READ;
1634 Perl_PerlIO_or_Base(f, Read, read, -1, (aTHX_ f, vbuf, count));
1638 Perl_PerlIO_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
1640 PERL_ARGS_ASSERT_PERLIO_UNREAD;
1642 Perl_PerlIO_or_Base(f, Unread, unread, -1, (aTHX_ f, vbuf, count));
1646 Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
1648 PERL_ARGS_ASSERT_PERLIO_WRITE;
1650 Perl_PerlIO_or_fail(f, Write, -1, (aTHX_ f, vbuf, count));
1654 Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
1656 Perl_PerlIO_or_fail(f, Seek, -1, (aTHX_ f, offset, whence));
1660 Perl_PerlIO_tell(pTHX_ PerlIO *f)
1662 Perl_PerlIO_or_fail(f, Tell, -1, (aTHX_ f));
1666 Perl_PerlIO_flush(pTHX_ PerlIO *f)
1671 const PerlIO_funcs *tab = PerlIOBase(f)->tab;
1673 if (tab && tab->Flush)
1674 return (*tab->Flush) (aTHX_ f);
1676 return 0; /* If no Flush defined, silently succeed. */
1679 PerlIO_debug("Cannot flush f=%p\n", (void*)f);
1680 SETERRNO(EBADF, SS_IVCHAN);
1686 * Is it good API design to do flush-all on NULL, a potentially
1687 * errorneous input? Maybe some magical value (PerlIO*
1688 * PERLIO_FLUSH_ALL = (PerlIO*)-1;)? Yes, stdio does similar
1689 * things on fflush(NULL), but should we be bound by their design
1692 PerlIO **table = &PL_perlio;
1694 while ((f = *table)) {
1696 table = (PerlIO **) (f++);
1697 for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
1698 if (*f && PerlIO_flush(f) != 0)
1708 PerlIOBase_flush_linebuf(pTHX)
1711 PerlIO **table = &PL_perlio;
1713 while ((f = *table)) {
1715 table = (PerlIO **) (f++);
1716 for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
1719 flags & (PERLIO_F_LINEBUF | PERLIO_F_CANWRITE))
1720 == (PERLIO_F_LINEBUF | PERLIO_F_CANWRITE))
1728 Perl_PerlIO_fill(pTHX_ PerlIO *f)
1730 Perl_PerlIO_or_fail(f, Fill, -1, (aTHX_ f));
1734 PerlIO_isutf8(PerlIO *f)
1737 return (PerlIOBase(f)->flags & PERLIO_F_UTF8) != 0;
1739 SETERRNO(EBADF, SS_IVCHAN);
1745 Perl_PerlIO_eof(pTHX_ PerlIO *f)
1747 Perl_PerlIO_or_Base(f, Eof, eof, -1, (aTHX_ f));
1751 Perl_PerlIO_error(pTHX_ PerlIO *f)
1753 Perl_PerlIO_or_Base(f, Error, error, -1, (aTHX_ f));
1757 Perl_PerlIO_clearerr(pTHX_ PerlIO *f)
1759 Perl_PerlIO_or_Base_void(f, Clearerr, clearerr, (aTHX_ f));
1763 Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f)
1765 Perl_PerlIO_or_Base_void(f, Setlinebuf, setlinebuf, (aTHX_ f));
1769 PerlIO_has_base(PerlIO *f)
1771 if (PerlIOValid(f)) {
1772 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1775 return (tab->Get_base != NULL);
1782 PerlIO_fast_gets(PerlIO *f)
1784 if (PerlIOValid(f)) {
1785 if (PerlIOBase(f)->flags & PERLIO_F_FASTGETS) {
1786 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1789 return (tab->Set_ptrcnt != NULL);
1797 PerlIO_has_cntptr(PerlIO *f)
1799 if (PerlIOValid(f)) {
1800 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1803 return (tab->Get_ptr != NULL && tab->Get_cnt != NULL);
1810 PerlIO_canset_cnt(PerlIO *f)
1812 if (PerlIOValid(f)) {
1813 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1816 return (tab->Set_ptrcnt != NULL);
1823 Perl_PerlIO_get_base(pTHX_ PerlIO *f)
1825 Perl_PerlIO_or_fail(f, Get_base, NULL, (aTHX_ f));
1829 Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f)
1831 Perl_PerlIO_or_fail(f, Get_bufsiz, -1, (aTHX_ f));
1835 Perl_PerlIO_get_ptr(pTHX_ PerlIO *f)
1837 Perl_PerlIO_or_fail(f, Get_ptr, NULL, (aTHX_ f));
1841 Perl_PerlIO_get_cnt(pTHX_ PerlIO *f)
1843 Perl_PerlIO_or_fail(f, Get_cnt, -1, (aTHX_ f));
1847 Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, int cnt)
1849 Perl_PerlIO_or_fail_void(f, Set_ptrcnt, (aTHX_ f, NULL, cnt));
1853 Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, int cnt)
1855 Perl_PerlIO_or_fail_void(f, Set_ptrcnt, (aTHX_ f, ptr, cnt));
1859 /*--------------------------------------------------------------------------------------*/
1861 * utf8 and raw dummy layers
1865 PerlIOUtf8_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
1867 PERL_UNUSED_CONTEXT;
1868 PERL_UNUSED_ARG(mode);
1869 PERL_UNUSED_ARG(arg);
1870 if (PerlIOValid(f)) {
1871 if (tab->kind & PERLIO_K_UTF8)
1872 PerlIOBase(f)->flags |= PERLIO_F_UTF8;
1874 PerlIOBase(f)->flags &= ~PERLIO_F_UTF8;
1880 PERLIO_FUNCS_DECL(PerlIO_utf8) = {
1881 sizeof(PerlIO_funcs),
1884 PERLIO_K_DUMMY | PERLIO_K_UTF8,
1904 NULL, /* get_base */
1905 NULL, /* get_bufsiz */
1908 NULL, /* set_ptrcnt */
1911 PERLIO_FUNCS_DECL(PerlIO_byte) = {
1912 sizeof(PerlIO_funcs),
1935 NULL, /* get_base */
1936 NULL, /* get_bufsiz */
1939 NULL, /* set_ptrcnt */
1943 PerlIORaw_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
1944 IV n, const char *mode, int fd, int imode, int perm,
1945 PerlIO *old, int narg, SV **args)
1947 PerlIO_funcs * const tab = PerlIO_default_btm();
1948 PERL_UNUSED_ARG(self);
1949 if (tab && tab->Open)
1950 return (*tab->Open) (aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
1952 SETERRNO(EINVAL, LIB_INVARG);
1956 PERLIO_FUNCS_DECL(PerlIO_raw) = {
1957 sizeof(PerlIO_funcs),
1980 NULL, /* get_base */
1981 NULL, /* get_bufsiz */
1984 NULL, /* set_ptrcnt */
1986 /*--------------------------------------------------------------------------------------*/
1987 /*--------------------------------------------------------------------------------------*/
1989 * "Methods" of the "base class"
1993 PerlIOBase_fileno(pTHX_ PerlIO *f)
1995 return PerlIOValid(f) ? PerlIO_fileno(PerlIONext(f)) : -1;
1999 PerlIO_modestr(PerlIO * f, char *buf)
2002 if (PerlIOValid(f)) {
2003 const IV flags = PerlIOBase(f)->flags;
2004 if (flags & PERLIO_F_APPEND) {
2006 if (flags & PERLIO_F_CANREAD) {
2010 else if (flags & PERLIO_F_CANREAD) {
2012 if (flags & PERLIO_F_CANWRITE)
2015 else if (flags & PERLIO_F_CANWRITE) {
2017 if (flags & PERLIO_F_CANREAD) {
2021 #ifdef PERLIO_USING_CRLF
2022 if (!(flags & PERLIO_F_CRLF))
2032 PerlIOBase_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
2034 PerlIOl * const l = PerlIOBase(f);
2035 PERL_UNUSED_CONTEXT;
2036 PERL_UNUSED_ARG(arg);
2038 l->flags &= ~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE |
2039 PERLIO_F_TRUNCATE | PERLIO_F_APPEND);
2040 if (tab->Set_ptrcnt != NULL)
2041 l->flags |= PERLIO_F_FASTGETS;
2043 if (*mode == IoTYPE_NUMERIC || *mode == IoTYPE_IMPLICIT)
2047 l->flags |= PERLIO_F_CANREAD;
2050 l->flags |= PERLIO_F_APPEND | PERLIO_F_CANWRITE;
2053 l->flags |= PERLIO_F_TRUNCATE | PERLIO_F_CANWRITE;
2056 SETERRNO(EINVAL, LIB_INVARG);
2062 l->flags |= PERLIO_F_CANREAD | PERLIO_F_CANWRITE;
2065 l->flags &= ~PERLIO_F_CRLF;
2068 l->flags |= PERLIO_F_CRLF;
2071 SETERRNO(EINVAL, LIB_INVARG);
2078 l->flags |= l->next->flags &
2079 (PERLIO_F_CANREAD | PERLIO_F_CANWRITE | PERLIO_F_TRUNCATE |
2084 PerlIO_debug("PerlIOBase_pushed f=%p %s %s fl=%08" UVxf " (%s)\n",
2085 (void*)f, PerlIOBase(f)->tab->name, (omode) ? omode : "(Null)",
2086 l->flags, PerlIO_modestr(f, temp));
2092 PerlIOBase_popped(pTHX_ PerlIO *f)
2094 PERL_UNUSED_CONTEXT;
2100 PerlIOBase_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
2103 * Save the position as current head considers it
2105 const Off_t old = PerlIO_tell(f);
2106 PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_pending), "r", NULL);
2107 PerlIOSelf(f, PerlIOBuf)->posn = old;
2108 return PerlIOBuf_unread(aTHX_ f, vbuf, count);
2112 PerlIOBase_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
2114 STDCHAR *buf = (STDCHAR *) vbuf;
2116 if (!(PerlIOBase(f)->flags & PERLIO_F_CANREAD)) {
2117 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
2118 SETERRNO(EBADF, SS_IVCHAN);
2124 SSize_t avail = PerlIO_get_cnt(f);
2127 take = ((SSize_t)count < avail) ? (SSize_t)count : avail;
2129 STDCHAR *ptr = PerlIO_get_ptr(f);
2130 Copy(ptr, buf, take, STDCHAR);
2131 PerlIO_set_ptrcnt(f, ptr + take, (avail -= take));
2134 if (avail == 0) /* set_ptrcnt could have reset avail */
2137 if (count > 0 && avail <= 0) {
2138 if (PerlIO_fill(f) != 0)
2143 return (buf - (STDCHAR *) vbuf);
2149 PerlIOBase_noop_ok(pTHX_ PerlIO *f)
2151 PERL_UNUSED_CONTEXT;
2157 PerlIOBase_noop_fail(pTHX_ PerlIO *f)
2159 PERL_UNUSED_CONTEXT;
2165 PerlIOBase_close(pTHX_ PerlIO *f)
2168 if (PerlIOValid(f)) {
2169 PerlIO *n = PerlIONext(f);
2170 code = PerlIO_flush(f);
2171 PerlIOBase(f)->flags &=
2172 ~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE | PERLIO_F_OPEN);
2173 while (PerlIOValid(n)) {
2174 const PerlIO_funcs * const tab = PerlIOBase(n)->tab;
2175 if (tab && tab->Close) {
2176 if ((*tab->Close)(aTHX_ n) != 0)
2181 PerlIOBase(n)->flags &=
2182 ~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE | PERLIO_F_OPEN);
2188 SETERRNO(EBADF, SS_IVCHAN);
2194 PerlIOBase_eof(pTHX_ PerlIO *f)
2196 PERL_UNUSED_CONTEXT;
2197 if (PerlIOValid(f)) {
2198 return (PerlIOBase(f)->flags & PERLIO_F_EOF) != 0;
2204 PerlIOBase_error(pTHX_ PerlIO *f)
2206 PERL_UNUSED_CONTEXT;
2207 if (PerlIOValid(f)) {
2208 return (PerlIOBase(f)->flags & PERLIO_F_ERROR) != 0;
2214 PerlIOBase_clearerr(pTHX_ PerlIO *f)
2216 if (PerlIOValid(f)) {
2217 PerlIO * const n = PerlIONext(f);
2218 PerlIOBase(f)->flags &= ~(PERLIO_F_ERROR | PERLIO_F_EOF);
2225 PerlIOBase_setlinebuf(pTHX_ PerlIO *f)
2227 PERL_UNUSED_CONTEXT;
2228 if (PerlIOValid(f)) {
2229 PerlIOBase(f)->flags |= PERLIO_F_LINEBUF;
2234 PerlIO_sv_dup(pTHX_ SV *arg, CLONE_PARAMS *param)
2240 arg = sv_dup(arg, param);
2241 SvREFCNT_inc_simple_void_NN(arg);
2245 return newSVsv(arg);
2248 PERL_UNUSED_ARG(param);
2249 return newSVsv(arg);
2254 PerlIOBase_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
2256 PerlIO * const nexto = PerlIONext(o);
2257 if (PerlIOValid(nexto)) {
2258 const PerlIO_funcs * const tab = PerlIOBase(nexto)->tab;
2259 if (tab && tab->Dup)
2260 f = (*tab->Dup)(aTHX_ f, nexto, param, flags);
2262 f = PerlIOBase_dup(aTHX_ f, nexto, param, flags);
2265 PerlIO_funcs * const self = PerlIOBase(o)->tab;
2268 PerlIO_debug("PerlIOBase_dup %s f=%p o=%p param=%p\n",
2269 self->name, (void*)f, (void*)o, (void*)param);
2271 arg = (*self->Getarg)(aTHX_ o, param, flags);
2272 f = PerlIO_push(aTHX_ f, self, PerlIO_modestr(o,buf), arg);
2273 if (PerlIOBase(o)->flags & PERLIO_F_UTF8)
2274 PerlIOBase(f)->flags |= PERLIO_F_UTF8;
2280 /* PL_perlio_fd_refcnt[] is in intrpvar.h */
2282 /* Must be called with PL_perlio_mutex locked. */
2284 S_more_refcounted_fds(pTHX_ const int new_fd) {
2286 const int old_max = PL_perlio_fd_refcnt_size;
2287 const int new_max = 16 + (new_fd & ~15);
2290 PerlIO_debug("More fds - old=%d, need %d, new=%d\n",
2291 old_max, new_fd, new_max);
2293 if (new_fd < old_max) {
2297 assert (new_max > new_fd);
2299 /* Use plain realloc() since we need this memory to be really
2300 * global and visible to all the interpreters and/or threads. */
2301 new_array = (int*) realloc(PL_perlio_fd_refcnt, new_max * sizeof(int));
2305 MUTEX_UNLOCK(&PL_perlio_mutex);
2307 /* Can't use PerlIO to write as it allocates memory */
2308 PerlLIO_write(PerlIO_fileno(Perl_error_log),
2309 PL_no_mem, strlen(PL_no_mem));
2313 PL_perlio_fd_refcnt_size = new_max;
2314 PL_perlio_fd_refcnt = new_array;
2316 PerlIO_debug("Zeroing %p, %d\n",
2317 (void*)(new_array + old_max),
2320 Zero(new_array + old_max, new_max - old_max, int);
2327 /* MUTEX_INIT(&PL_perlio_mutex) is done in PERL_SYS_INIT3(). */
2328 PERL_UNUSED_CONTEXT;
2332 PerlIOUnix_refcnt_inc(int fd)
2339 MUTEX_LOCK(&PL_perlio_mutex);
2341 if (fd >= PL_perlio_fd_refcnt_size)
2342 S_more_refcounted_fds(aTHX_ fd);
2344 PL_perlio_fd_refcnt[fd]++;
2345 if (PL_perlio_fd_refcnt[fd] <= 0) {
2346 Perl_croak(aTHX_ "refcnt_inc: fd %d: %d <= 0\n",
2347 fd, PL_perlio_fd_refcnt[fd]);
2349 PerlIO_debug("refcnt_inc: fd %d refcnt=%d\n",
2350 fd, PL_perlio_fd_refcnt[fd]);
2353 MUTEX_UNLOCK(&PL_perlio_mutex);
2356 Perl_croak(aTHX_ "refcnt_inc: fd %d < 0\n", fd);
2361 PerlIOUnix_refcnt_dec(int fd)
2368 MUTEX_LOCK(&PL_perlio_mutex);
2370 if (fd >= PL_perlio_fd_refcnt_size) {
2371 Perl_croak(aTHX_ "refcnt_dec: fd %d >= refcnt_size %d\n",
2372 fd, PL_perlio_fd_refcnt_size);
2374 if (PL_perlio_fd_refcnt[fd] <= 0) {
2375 Perl_croak(aTHX_ "refcnt_dec: fd %d: %d <= 0\n",
2376 fd, PL_perlio_fd_refcnt[fd]);
2378 cnt = --PL_perlio_fd_refcnt[fd];
2379 PerlIO_debug("refcnt_dec: fd %d refcnt=%d\n", fd, cnt);
2381 MUTEX_UNLOCK(&PL_perlio_mutex);
2384 Perl_croak(aTHX_ "refcnt_dec: fd %d < 0\n", fd);
2390 PerlIO_cleanup(pTHX)
2395 PerlIO_debug("Cleanup layers for %p\n",(void*)aTHX);
2397 PerlIO_debug("Cleanup layers\n");
2400 /* Raise STDIN..STDERR refcount so we don't close them */
2401 for (i=0; i < 3; i++)
2402 PerlIOUnix_refcnt_inc(i);
2403 PerlIO_cleantable(aTHX_ &PL_perlio);
2404 /* Restore STDIN..STDERR refcount */
2405 for (i=0; i < 3; i++)
2406 PerlIOUnix_refcnt_dec(i);
2408 if (PL_known_layers) {
2409 PerlIO_list_free(aTHX_ PL_known_layers);
2410 PL_known_layers = NULL;
2412 if (PL_def_layerlist) {
2413 PerlIO_list_free(aTHX_ PL_def_layerlist);
2414 PL_def_layerlist = NULL;
2418 void PerlIO_teardown(void) /* Call only from PERL_SYS_TERM(). */
2422 /* XXX we can't rely on an interpreter being present at this late stage,
2423 XXX so we can't use a function like PerlLIO_write that relies on one
2424 being present (at least in win32) :-(.
2429 /* By now all filehandles should have been closed, so any
2430 * stray (non-STD-)filehandles indicate *possible* (PerlIO)
2432 #define PERLIO_TEARDOWN_MESSAGE_BUF_SIZE 64
2433 #define PERLIO_TEARDOWN_MESSAGE_FD 2
2434 char buf[PERLIO_TEARDOWN_MESSAGE_BUF_SIZE];
2436 for (i = 3; i < PL_perlio_fd_refcnt_size; i++) {
2437 if (PL_perlio_fd_refcnt[i]) {
2439 my_snprintf(buf, sizeof(buf),
2440 "PerlIO_teardown: fd %d refcnt=%d\n",
2441 i, PL_perlio_fd_refcnt[i]);
2442 PerlLIO_write(PERLIO_TEARDOWN_MESSAGE_FD, buf, len);
2448 /* Not bothering with PL_perlio_mutex since by now
2449 * all the interpreters are gone. */
2450 if (PL_perlio_fd_refcnt_size /* Assuming initial size of zero. */
2451 && PL_perlio_fd_refcnt) {
2452 free(PL_perlio_fd_refcnt); /* To match realloc() in S_more_refcounted_fds(). */
2453 PL_perlio_fd_refcnt = NULL;
2454 PL_perlio_fd_refcnt_size = 0;
2458 /*--------------------------------------------------------------------------------------*/
2460 * Bottom-most level for UNIX-like case
2464 struct _PerlIO base; /* The generic part */
2465 int fd; /* UNIX like file descriptor */
2466 int oflags; /* open/fcntl flags */
2470 PerlIOUnix_oflags(const char *mode)
2473 if (*mode == IoTYPE_IMPLICIT || *mode == IoTYPE_NUMERIC)
2478 if (*++mode == '+') {
2485 oflags = O_CREAT | O_TRUNC;
2486 if (*++mode == '+') {
2495 oflags = O_CREAT | O_APPEND;
2496 if (*++mode == '+') {
2509 else if (*mode == 't') {
2511 oflags &= ~O_BINARY;
2515 * Always open in binary mode
2518 if (*mode || oflags == -1) {
2519 SETERRNO(EINVAL, LIB_INVARG);
2526 PerlIOUnix_fileno(pTHX_ PerlIO *f)
2528 PERL_UNUSED_CONTEXT;
2529 return PerlIOSelf(f, PerlIOUnix)->fd;
2533 PerlIOUnix_setfd(pTHX_ PerlIO *f, int fd, int imode)
2535 PerlIOUnix * const s = PerlIOSelf(f, PerlIOUnix);
2538 if (PerlLIO_fstat(fd, &st) == 0) {
2539 if (!S_ISREG(st.st_mode)) {
2540 PerlIO_debug("%d is not regular file\n",fd);
2541 PerlIOBase(f)->flags |= PERLIO_F_NOTREG;
2544 PerlIO_debug("%d _is_ a regular file\n",fd);
2550 PerlIOUnix_refcnt_inc(fd);
2551 PERL_UNUSED_CONTEXT;
2555 PerlIOUnix_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
2557 IV code = PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
2558 if (*PerlIONext(f)) {
2559 /* We never call down so do any pending stuff now */
2560 PerlIO_flush(PerlIONext(f));
2562 * XXX could (or should) we retrieve the oflags from the open file
2563 * handle rather than believing the "mode" we are passed in? XXX
2564 * Should the value on NULL mode be 0 or -1?
2566 PerlIOUnix_setfd(aTHX_ f, PerlIO_fileno(PerlIONext(f)),
2567 mode ? PerlIOUnix_oflags(mode) : -1);
2569 PerlIOBase(f)->flags |= PERLIO_F_OPEN;
2575 PerlIOUnix_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
2577 const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
2579 PERL_UNUSED_CONTEXT;
2580 if (PerlIOBase(f)->flags & PERLIO_F_NOTREG) {
2582 SETERRNO(ESPIPE, LIB_INVARG);
2584 SETERRNO(EINVAL, LIB_INVARG);
2588 new_loc = PerlLIO_lseek(fd, offset, whence);
2589 if (new_loc == (Off_t) - 1)
2591 PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
2596 PerlIOUnix_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
2597 IV n, const char *mode, int fd, int imode,
2598 int perm, PerlIO *f, int narg, SV **args)
2600 if (PerlIOValid(f)) {
2601 if (PerlIOBase(f)->flags & PERLIO_F_OPEN)
2602 (*PerlIOBase(f)->tab->Close)(aTHX_ f);
2605 if (*mode == IoTYPE_NUMERIC)
2608 imode = PerlIOUnix_oflags(mode);
2610 perm = 0777; /* preserve RMS defaults, ACL inheritance, etc. */
2616 const char *path = SvPV_nolen_const(*args);
2617 fd = PerlLIO_open3(path, imode, perm);
2621 if (*mode == IoTYPE_IMPLICIT)
2624 f = PerlIO_allocate(aTHX);
2626 if (!PerlIOValid(f)) {
2627 if (!(f = PerlIO_push(aTHX_ f, self, mode, PerlIOArg))) {
2631 PerlIOUnix_setfd(aTHX_ f, fd, imode);
2632 PerlIOBase(f)->flags |= PERLIO_F_OPEN;
2633 if (*mode == IoTYPE_APPEND)
2634 PerlIOUnix_seek(aTHX_ f, 0, SEEK_END);
2641 * FIXME: pop layers ???
2649 PerlIOUnix_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
2651 const PerlIOUnix * const os = PerlIOSelf(o, PerlIOUnix);
2653 if (flags & PERLIO_DUP_FD) {
2654 fd = PerlLIO_dup(fd);
2657 f = PerlIOBase_dup(aTHX_ f, o, param, flags);
2659 /* If all went well overwrite fd in dup'ed lay with the dup()'ed fd */
2660 PerlIOUnix_setfd(aTHX_ f, fd, os->oflags);
2669 PerlIOUnix_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
2672 const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
2673 #ifdef PERLIO_STD_SPECIAL
2675 return PERLIO_STD_IN(fd, vbuf, count);
2677 if (!(PerlIOBase(f)->flags & PERLIO_F_CANREAD) ||
2678 PerlIOBase(f)->flags & (PERLIO_F_EOF|PERLIO_F_ERROR)) {
2682 const SSize_t len = PerlLIO_read(fd, vbuf, count);
2683 if (len >= 0 || errno != EINTR) {
2685 if (errno != EAGAIN) {
2686 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
2689 else if (len == 0 && count != 0) {
2690 PerlIOBase(f)->flags |= PERLIO_F_EOF;
2701 PerlIOUnix_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
2704 const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
2705 #ifdef PERLIO_STD_SPECIAL
2706 if (fd == 1 || fd == 2)
2707 return PERLIO_STD_OUT(fd, vbuf, count);
2710 const SSize_t len = PerlLIO_write(fd, vbuf, count);
2711 if (len >= 0 || errno != EINTR) {
2713 if (errno != EAGAIN) {
2714 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
2725 PerlIOUnix_tell(pTHX_ PerlIO *f)
2727 PERL_UNUSED_CONTEXT;
2729 return PerlLIO_lseek(PerlIOSelf(f, PerlIOUnix)->fd, 0, SEEK_CUR);
2734 PerlIOUnix_close(pTHX_ PerlIO *f)
2737 const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
2739 if (PerlIOBase(f)->flags & PERLIO_F_OPEN) {
2740 if (PerlIOUnix_refcnt_dec(fd) > 0) {
2741 PerlIOBase(f)->flags &= ~PERLIO_F_OPEN;
2746 SETERRNO(EBADF,SS_IVCHAN);
2749 while (PerlLIO_close(fd) != 0) {
2750 if (errno != EINTR) {
2757 PerlIOBase(f)->flags &= ~PERLIO_F_OPEN;
2762 PERLIO_FUNCS_DECL(PerlIO_unix) = {
2763 sizeof(PerlIO_funcs),
2770 PerlIOBase_binmode, /* binmode */
2780 PerlIOBase_noop_ok, /* flush */
2781 PerlIOBase_noop_fail, /* fill */
2784 PerlIOBase_clearerr,
2785 PerlIOBase_setlinebuf,
2786 NULL, /* get_base */
2787 NULL, /* get_bufsiz */
2790 NULL, /* set_ptrcnt */
2793 /*--------------------------------------------------------------------------------------*/
2798 #if defined(VMS) && !defined(STDIO_BUFFER_WRITABLE)
2799 /* perl5.8 - This ensures the last minute VMS ungetc fix is not
2800 broken by the last second glibc 2.3 fix
2802 #define STDIO_BUFFER_WRITABLE
2807 struct _PerlIO base;
2808 FILE *stdio; /* The stream */
2812 PerlIOStdio_fileno(pTHX_ PerlIO *f)
2814 PERL_UNUSED_CONTEXT;
2816 if (PerlIOValid(f)) {
2817 FILE * const s = PerlIOSelf(f, PerlIOStdio)->stdio;
2819 return PerlSIO_fileno(s);
2826 PerlIOStdio_mode(const char *mode, char *tmode)
2828 char * const ret = tmode;
2834 #if defined(PERLIO_USING_CRLF) || defined(__CYGWIN__)
2842 PerlIOStdio_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
2845 if (PerlIOValid(f) && PerlIOValid(n = PerlIONext(f))) {
2846 PerlIO_funcs * const toptab = PerlIOBase(n)->tab;
2847 if (toptab == tab) {
2848 /* Top is already stdio - pop self (duplicate) and use original */
2849 PerlIO_pop(aTHX_ f);
2852 const int fd = PerlIO_fileno(n);
2855 if (fd >= 0 && (stdio = PerlSIO_fdopen(fd,
2856 mode = PerlIOStdio_mode(mode, tmode)))) {
2857 PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
2858 /* We never call down so do any pending stuff now */
2859 PerlIO_flush(PerlIONext(f));
2866 return PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
2871 PerlIO_importFILE(FILE *stdio, const char *mode)
2877 if (!mode || !*mode) {
2878 /* We need to probe to see how we can open the stream
2879 so start with read/write and then try write and read
2880 we dup() so that we can fclose without loosing the fd.
2882 Note that the errno value set by a failing fdopen
2883 varies between stdio implementations.
2885 const int fd = PerlLIO_dup(fileno(stdio));
2886 FILE *f2 = PerlSIO_fdopen(fd, (mode = "r+"));
2888 f2 = PerlSIO_fdopen(fd, (mode = "w"));
2891 f2 = PerlSIO_fdopen(fd, (mode = "r"));
2894 /* Don't seem to be able to open */
2900 if ((f = PerlIO_push(aTHX_(f = PerlIO_allocate(aTHX)), PERLIO_FUNCS_CAST(&PerlIO_stdio), mode, NULL))) {
2901 s = PerlIOSelf(f, PerlIOStdio);
2903 PerlIOUnix_refcnt_inc(fileno(stdio));
2910 PerlIOStdio_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
2911 IV n, const char *mode, int fd, int imode,
2912 int perm, PerlIO *f, int narg, SV **args)
2915 if (PerlIOValid(f)) {
2916 const char * const path = SvPV_nolen_const(*args);
2917 PerlIOStdio * const s = PerlIOSelf(f, PerlIOStdio);
2919 PerlIOUnix_refcnt_dec(fileno(s->stdio));
2920 stdio = PerlSIO_freopen(path, (mode = PerlIOStdio_mode(mode, tmode)),
2925 PerlIOUnix_refcnt_inc(fileno(s->stdio));
2930 const char * const path = SvPV_nolen_const(*args);
2931 if (*mode == IoTYPE_NUMERIC) {
2933 fd = PerlLIO_open3(path, imode, perm);
2937 bool appended = FALSE;
2939 /* Cygwin wants its 'b' early. */
2941 mode = PerlIOStdio_mode(mode, tmode);
2943 stdio = PerlSIO_fopen(path, mode);
2946 f = PerlIO_allocate(aTHX);
2949 mode = PerlIOStdio_mode(mode, tmode);
2950 f = PerlIO_push(aTHX_ f, self, mode, PerlIOArg);
2952 PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
2953 PerlIOUnix_refcnt_inc(fileno(stdio));
2955 PerlSIO_fclose(stdio);
2967 if (*mode == IoTYPE_IMPLICIT) {
2974 stdio = PerlSIO_stdin;
2977 stdio = PerlSIO_stdout;
2980 stdio = PerlSIO_stderr;
2985 stdio = PerlSIO_fdopen(fd, mode =
2986 PerlIOStdio_mode(mode, tmode));
2990 f = PerlIO_allocate(aTHX);
2992 if ((f = PerlIO_push(aTHX_ f, self, mode, PerlIOArg))) {
2993 PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
2994 PerlIOUnix_refcnt_inc(fileno(stdio));
3004 PerlIOStdio_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
3006 /* This assumes no layers underneath - which is what
3007 happens, but is not how I remember it. NI-S 2001/10/16
3009 if ((f = PerlIOBase_dup(aTHX_ f, o, param, flags))) {
3010 FILE *stdio = PerlIOSelf(o, PerlIOStdio)->stdio;
3011 const int fd = fileno(stdio);
3013 if (flags & PERLIO_DUP_FD) {
3014 const int dfd = PerlLIO_dup(fileno(stdio));
3016 stdio = PerlSIO_fdopen(dfd, PerlIO_modestr(o,mode));
3021 /* FIXME: To avoid messy error recovery if dup fails
3022 re-use the existing stdio as though flag was not set
3026 stdio = PerlSIO_fdopen(fd, PerlIO_modestr(o,mode));
3028 PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
3030 PerlIOUnix_refcnt_inc(fileno(stdio));
3037 PerlIOStdio_invalidate_fileno(pTHX_ FILE *f)
3039 PERL_UNUSED_CONTEXT;
3041 /* XXX this could use PerlIO_canset_fileno() and
3042 * PerlIO_set_fileno() support from Configure
3044 # if defined(__UCLIBC__)
3045 /* uClibc must come before glibc because it defines __GLIBC__ as well. */
3048 # elif defined(__GLIBC__)
3049 /* There may be a better way for GLIBC:
3050 - libio.h defines a flag to not close() on cleanup
3054 # elif defined(__sun__)
3057 # elif defined(__hpux)
3061 /* Next one ->_file seems to be a reasonable fallback, i.e. if
3062 your platform does not have special entry try this one.
3063 [For OSF only have confirmation for Tru64 (alpha)
3064 but assume other OSFs will be similar.]
3066 # elif defined(_AIX) || defined(__osf__) || defined(__irix__)
3069 # elif defined(__FreeBSD__)
3070 /* There may be a better way on FreeBSD:
3071 - we could insert a dummy func in the _close function entry
3072 f->_close = (int (*)(void *)) dummy_close;
3076 # elif defined(__OpenBSD__)
3077 /* There may be a better way on OpenBSD:
3078 - we could insert a dummy func in the _close function entry
3079 f->_close = (int (*)(void *)) dummy_close;
3083 # elif defined(__EMX__)
3084 /* f->_flags &= ~_IOOPEN; */ /* Will leak stream->_buffer */
3087 # elif defined(__CYGWIN__)
3088 /* There may be a better way on CYGWIN:
3089 - we could insert a dummy func in the _close function entry
3090 f->_close = (int (*)(void *)) dummy_close;
3094 # elif defined(WIN32)
3095 # if defined(__BORLANDC__)
3096 f->fd = PerlLIO_dup(fileno(f));
3097 # elif defined(UNDER_CE)
3098 /* WIN_CE does not have access to FILE internals, it hardly has FILE
3107 /* Sarathy's code did this - we fall back to a dup/dup2 hack
3108 (which isn't thread safe) instead
3110 # error "Don't know how to set FILE.fileno on your platform"
3118 PerlIOStdio_close(pTHX_ PerlIO *f)
3120 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3126 const int fd = fileno(stdio);
3134 #ifdef SOCKS5_VERSION_NAME
3135 /* Socks lib overrides close() but stdio isn't linked to
3136 that library (though we are) - so we must call close()
3137 on sockets on stdio's behalf.
3140 Sock_size_t optlen = sizeof(int);
3141 if (getsockopt(fd, SOL_SOCKET, SO_TYPE, (void *) &optval, &optlen) == 0)
3144 /* Test for -1, as *BSD stdio (at least) on fclose sets the FILE* such
3145 that a subsequent fileno() on it returns -1. Don't want to croak()
3146 from within PerlIOUnix_refcnt_dec() if some buggy caller code is
3147 trying to close an already closed handle which somehow it still has
3148 a reference to. (via.xs, I'm looking at you). */
3149 if (fd != -1 && PerlIOUnix_refcnt_dec(fd) > 0) {
3150 /* File descriptor still in use */
3154 /* For STD* handles, don't close stdio, since we shared the FILE *, too. */
3155 if (stdio == stdin) /* Some stdios are buggy fflush-ing inputs */
3157 if (stdio == stdout || stdio == stderr)
3158 return PerlIO_flush(f);
3159 /* Tricky - must fclose(stdio) to free memory but not close(fd)
3160 Use Sarathy's trick from maint-5.6 to invalidate the
3161 fileno slot of the FILE *
3163 result = PerlIO_flush(f);
3165 invalidate = PerlIOStdio_invalidate_fileno(aTHX_ stdio);
3168 MUTEX_LOCK(&PL_perlio_mutex);
3169 /* Right. We need a mutex here because for a brief while we
3170 will have the situation that fd is actually closed. Hence if
3171 a second thread were to get into this block, its dup() would
3172 likely return our fd as its dupfd. (after all, it is closed)
3173 Then if we get to the dup2() first, we blat the fd back
3174 (messing up its temporary as a side effect) only for it to
3175 then close its dupfd (== our fd) in its close(dupfd) */
3177 /* There is, of course, a race condition, that any other thread
3178 trying to input/output/whatever on this fd will be stuffed
3179 for the duration of this little manoeuvrer. Perhaps we
3180 should hold an IO mutex for the duration of every IO
3181 operation if we know that invalidate doesn't work on this
3182 platform, but that would suck, and could kill performance.
3184 Except that correctness trumps speed.
3185 Advice from klortho #11912. */
3187 dupfd = PerlLIO_dup(fd);
3190 MUTEX_UNLOCK(&PL_perlio_mutex);
3191 /* Oh cXap. This isn't going to go well. Not sure if we can
3192 recover from here, or if closing this particular FILE *
3193 is a good idea now. */
3198 SAVE_ERRNO; /* This is here only to silence compiler warnings */
3200 result = PerlSIO_fclose(stdio);
3201 /* We treat error from stdio as success if we invalidated
3202 errno may NOT be expected EBADF
3204 if (invalidate && result != 0) {
3208 #ifdef SOCKS5_VERSION_NAME
3209 /* in SOCKS' case, let close() determine return value */
3213 PerlLIO_dup2(dupfd,fd);
3214 PerlLIO_close(dupfd);
3216 MUTEX_UNLOCK(&PL_perlio_mutex);
3224 PerlIOStdio_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
3227 FILE * const s = PerlIOSelf(f, PerlIOStdio)->stdio;
3231 STDCHAR *buf = (STDCHAR *) vbuf;
3233 * Perl is expecting PerlIO_getc() to fill the buffer Linux's
3234 * stdio does not do that for fread()
3236 const int ch = PerlSIO_fgetc(s);
3243 got = PerlSIO_fread(vbuf, 1, count, s);
3244 if (got == 0 && PerlSIO_ferror(s))
3246 if (got >= 0 || errno != EINTR)
3249 SETERRNO(0,0); /* just in case */
3255 PerlIOStdio_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
3258 FILE * const s = PerlIOSelf(f, PerlIOStdio)->stdio;
3260 #ifdef STDIO_BUFFER_WRITABLE
3261 if (PerlIO_fast_gets(f) && PerlIO_has_base(f)) {
3262 STDCHAR *buf = ((STDCHAR *) vbuf) + count;
3263 STDCHAR *base = PerlIO_get_base(f);
3264 SSize_t cnt = PerlIO_get_cnt(f);
3265 STDCHAR *ptr = PerlIO_get_ptr(f);
3266 SSize_t avail = ptr - base;
3268 if (avail > count) {
3272 Move(buf-avail,ptr,avail,STDCHAR);
3275 PerlIO_set_ptrcnt(f,ptr,cnt+avail);
3276 if (PerlSIO_feof(s) && unread >= 0)
3277 PerlSIO_clearerr(s);
3282 if (PerlIO_has_cntptr(f)) {
3283 /* We can get pointer to buffer but not its base
3284 Do ungetc() but check chars are ending up in the
3287 STDCHAR *eptr = (STDCHAR*)PerlSIO_get_ptr(s);
3288 STDCHAR *buf = ((STDCHAR *) vbuf) + count;
3290 const int ch = *--buf & 0xFF;
3291 if (ungetc(ch,s) != ch) {
3292 /* ungetc did not work */
3295 if ((STDCHAR*)PerlSIO_get_ptr(s) != --eptr || ((*eptr & 0xFF) != ch)) {
3296 /* Did not change pointer as expected */
3297 fgetc(s); /* get char back again */
3307 unread += PerlIOBase_unread(aTHX_ f, vbuf, count);
3313 PerlIOStdio_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
3318 got = PerlSIO_fwrite(vbuf, 1, count,
3319 PerlIOSelf(f, PerlIOStdio)->stdio);
3320 if (got >= 0 || errno != EINTR)
3323 SETERRNO(0,0); /* just in case */
3329 PerlIOStdio_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
3331 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3332 PERL_UNUSED_CONTEXT;
3334 return PerlSIO_fseek(stdio, offset, whence);
3338 PerlIOStdio_tell(pTHX_ PerlIO *f)
3340 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3341 PERL_UNUSED_CONTEXT;
3343 return PerlSIO_ftell(stdio);
3347 PerlIOStdio_flush(pTHX_ PerlIO *f)
3349 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3350 PERL_UNUSED_CONTEXT;
3352 if (PerlIOBase(f)->flags & PERLIO_F_CANWRITE) {
3353 return PerlSIO_fflush(stdio);
3359 * FIXME: This discards ungetc() and pre-read stuff which is not
3360 * right if this is just a "sync" from a layer above Suspect right
3361 * design is to do _this_ but not have layer above flush this
3362 * layer read-to-read
3365 * Not writeable - sync by attempting a seek
3368 if (PerlSIO_fseek(stdio, (Off_t) 0, SEEK_CUR) != 0)
3376 PerlIOStdio_eof(pTHX_ PerlIO *f)
3378 PERL_UNUSED_CONTEXT;
3380 return PerlSIO_feof(PerlIOSelf(f, PerlIOStdio)->stdio);
3384 PerlIOStdio_error(pTHX_ PerlIO *f)
3386 PERL_UNUSED_CONTEXT;
3388 return PerlSIO_ferror(PerlIOSelf(f, PerlIOStdio)->stdio);
3392 PerlIOStdio_clearerr(pTHX_ PerlIO *f)
3394 PERL_UNUSED_CONTEXT;
3396 PerlSIO_clearerr(PerlIOSelf(f, PerlIOStdio)->stdio);
3400 PerlIOStdio_setlinebuf(pTHX_ PerlIO *f)
3402 PERL_UNUSED_CONTEXT;
3404 #ifdef HAS_SETLINEBUF
3405 PerlSIO_setlinebuf(PerlIOSelf(f, PerlIOStdio)->stdio);
3407 PerlSIO_setvbuf(PerlIOSelf(f, PerlIOStdio)->stdio, NULL, _IOLBF, 0);
3413 PerlIOStdio_get_base(pTHX_ PerlIO *f)
3415 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3416 return (STDCHAR*)PerlSIO_get_base(stdio);
3420 PerlIOStdio_get_bufsiz(pTHX_ PerlIO *f)
3422 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3423 return PerlSIO_get_bufsiz(stdio);
3427 #ifdef USE_STDIO_PTR
3429 PerlIOStdio_get_ptr(pTHX_ PerlIO *f)
3431 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3432 return (STDCHAR*)PerlSIO_get_ptr(stdio);
3436 PerlIOStdio_get_cnt(pTHX_ PerlIO *f)
3438 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3439 return PerlSIO_get_cnt(stdio);
3443 PerlIOStdio_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
3445 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3447 #ifdef STDIO_PTR_LVALUE
3448 PerlSIO_set_ptr(stdio, ptr); /* LHS STDCHAR* cast non-portable */
3449 #ifdef STDIO_PTR_LVAL_SETS_CNT
3450 assert(PerlSIO_get_cnt(stdio) == (cnt));
3452 #if (!defined(STDIO_PTR_LVAL_NOCHANGE_CNT))
3454 * Setting ptr _does_ change cnt - we are done
3458 #else /* STDIO_PTR_LVALUE */
3460 #endif /* STDIO_PTR_LVALUE */
3463 * Now (or only) set cnt
3465 #ifdef STDIO_CNT_LVALUE
3466 PerlSIO_set_cnt(stdio, cnt);
3467 #else /* STDIO_CNT_LVALUE */
3468 #if (defined(STDIO_PTR_LVALUE) && defined(STDIO_PTR_LVAL_SETS_CNT))
3469 PerlSIO_set_ptr(stdio,
3470 PerlSIO_get_ptr(stdio) + (PerlSIO_get_cnt(stdio) -
3472 #else /* STDIO_PTR_LVAL_SETS_CNT */
3474 #endif /* STDIO_PTR_LVAL_SETS_CNT */
3475 #endif /* STDIO_CNT_LVALUE */
3482 PerlIOStdio_fill(pTHX_ PerlIO *f)
3484 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3486 PERL_UNUSED_CONTEXT;
3489 * fflush()ing read-only streams can cause trouble on some stdio-s
3491 if ((PerlIOBase(f)->flags & PERLIO_F_CANWRITE)) {
3492 if (PerlSIO_fflush(stdio) != 0)
3496 c = PerlSIO_fgetc(stdio);
3499 if (! PerlSIO_ferror(stdio) || errno != EINTR)
3505 #if (defined(STDIO_PTR_LVALUE) && (defined(STDIO_CNT_LVALUE) || defined(STDIO_PTR_LVAL_SETS_CNT)))
3507 #ifdef STDIO_BUFFER_WRITABLE
3508 if (PerlIO_fast_gets(f) && PerlIO_has_base(f)) {
3509 /* Fake ungetc() to the real buffer in case system's ungetc
3512 STDCHAR *base = (STDCHAR*)PerlSIO_get_base(stdio);
3513 SSize_t cnt = PerlSIO_get_cnt(stdio);
3514 STDCHAR *ptr = (STDCHAR*)PerlSIO_get_ptr(stdio);
3515 if (ptr == base+1) {
3516 *--ptr = (STDCHAR) c;
3517 PerlIOStdio_set_ptrcnt(aTHX_ f,ptr,cnt+1);
3518 if (PerlSIO_feof(stdio))
3519 PerlSIO_clearerr(stdio);
3525 if (PerlIO_has_cntptr(f)) {
3527 if (PerlIOStdio_unread(aTHX_ f,&ch,1) == 1) {
3534 /* An ungetc()d char is handled separately from the regular
3535 * buffer, so we stuff it in the buffer ourselves.
3536 * Should never get called as should hit code above
3538 *(--((*stdio)->_ptr)) = (unsigned char) c;
3541 /* If buffer snoop scheme above fails fall back to
3544 if (PerlSIO_ungetc(c, stdio) != c)
3552 PERLIO_FUNCS_DECL(PerlIO_stdio) = {
3553 sizeof(PerlIO_funcs),
3555 sizeof(PerlIOStdio),
3556 PERLIO_K_BUFFERED|PERLIO_K_RAW,
3560 PerlIOBase_binmode, /* binmode */
3574 PerlIOStdio_clearerr,
3575 PerlIOStdio_setlinebuf,
3577 PerlIOStdio_get_base,
3578 PerlIOStdio_get_bufsiz,
3583 #ifdef USE_STDIO_PTR
3584 PerlIOStdio_get_ptr,
3585 PerlIOStdio_get_cnt,
3586 # if defined(HAS_FAST_STDIO) && defined(USE_FAST_STDIO)
3587 PerlIOStdio_set_ptrcnt,
3590 # endif /* HAS_FAST_STDIO && USE_FAST_STDIO */
3595 #endif /* USE_STDIO_PTR */
3598 /* Note that calls to PerlIO_exportFILE() are reversed using
3599 * PerlIO_releaseFILE(), not importFILE. */
3601 PerlIO_exportFILE(PerlIO * f, const char *mode)
3605 if (PerlIOValid(f)) {
3608 if (!mode || !*mode) {
3609 mode = PerlIO_modestr(f, buf);
3611 stdio = PerlSIO_fdopen(PerlIO_fileno(f), mode);
3615 /* De-link any lower layers so new :stdio sticks */
3617 if ((f2 = PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_stdio), buf, NULL))) {
3618 PerlIOStdio *s = PerlIOSelf((f = f2), PerlIOStdio);
3620 PerlIOUnix_refcnt_inc(fileno(stdio));
3621 /* Link previous lower layers under new one */
3625 /* restore layers list */
3635 PerlIO_findFILE(PerlIO *f)
3640 if (l->tab == &PerlIO_stdio) {
3641 PerlIOStdio *s = PerlIOSelf(&l, PerlIOStdio);
3644 l = *PerlIONext(&l);
3646 /* Uses fallback "mode" via PerlIO_modestr() in PerlIO_exportFILE */
3647 /* However, we're not really exporting a FILE * to someone else (who
3648 becomes responsible for closing it, or calling PerlIO_releaseFILE())
3649 So we need to undo its refernce count increase on the underlying file
3650 descriptor. We have to do this, because if the loop above returns you
3651 the FILE *, then *it* didn't increase any reference count. So there's
3652 only one way to be consistent. */
3653 stdio = PerlIO_exportFILE(f, NULL);
3655 const int fd = fileno(stdio);
3657 PerlIOUnix_refcnt_dec(fd);
3662 /* Use this to reverse PerlIO_exportFILE calls. */
3664 PerlIO_releaseFILE(PerlIO *p, FILE *f)
3669 if (l->tab == &PerlIO_stdio) {
3670 PerlIOStdio *s = PerlIOSelf(&l, PerlIOStdio);
3671 if (s->stdio == f) {
3673 const int fd = fileno(f);
3675 PerlIOUnix_refcnt_dec(fd);
3676 PerlIO_pop(aTHX_ p);
3685 /*--------------------------------------------------------------------------------------*/
3687 * perlio buffer layer
3691 PerlIOBuf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
3693 PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
3694 const int fd = PerlIO_fileno(f);
3695 if (fd >= 0 && PerlLIO_isatty(fd)) {
3696 PerlIOBase(f)->flags |= PERLIO_F_LINEBUF | PERLIO_F_TTY;
3698 if (*PerlIONext(f)) {
3699 const Off_t posn = PerlIO_tell(PerlIONext(f));
3700 if (posn != (Off_t) - 1) {
3704 return PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
3708 PerlIOBuf_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
3709 IV n, const char *mode, int fd, int imode, int perm,
3710 PerlIO *f, int narg, SV **args)
3712 if (PerlIOValid(f)) {
3713 PerlIO *next = PerlIONext(f);
3715 PerlIO_layer_fetch(aTHX_ layers, n - 1, PerlIOBase(next)->tab);
3716 if (tab && tab->Open)
3718 (*tab->Open)(aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
3720 if (!next || (*PerlIOBase(f)->tab->Pushed) (aTHX_ f, mode, PerlIOArg, self) != 0) {
3725 PerlIO_funcs *tab = PerlIO_layer_fetch(aTHX_ layers, n - 1, PerlIO_default_btm());
3727 if (*mode == IoTYPE_IMPLICIT) {
3733 if (tab && tab->Open)
3734 f = (*tab->Open)(aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
3737 SETERRNO(EINVAL, LIB_INVARG);
3739 if (PerlIO_push(aTHX_ f, self, mode, PerlIOArg) == 0) {
3741 * if push fails during open, open fails. close will pop us.
3746 fd = PerlIO_fileno(f);
3747 if (init && fd == 2) {
3749 * Initial stderr is unbuffered
3751 PerlIOBase(f)->flags |= PERLIO_F_UNBUF;
3753 #ifdef PERLIO_USING_CRLF
3754 # ifdef PERLIO_IS_BINMODE_FD
3755 if (PERLIO_IS_BINMODE_FD(fd))
3756 PerlIO_binmode(aTHX_ f, '<'/*not used*/, O_BINARY, NULL);
3760 * do something about failing setmode()? --jhi
3762 PerlLIO_setmode(fd, O_BINARY);
3771 * This "flush" is akin to sfio's sync in that it handles files in either
3772 * read or write state. For write state, we put the postponed data through
3773 * the next layers. For read state, we seek() the next layers to the
3774 * offset given by current position in the buffer, and discard the buffer
3775 * state (XXXX supposed to be for seek()able buffers only, but now it is done
3776 * in any case?). Then the pass the stick further in chain.
3779 PerlIOBuf_flush(pTHX_ PerlIO *f)
3781 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
3783 PerlIO *n = PerlIONext(f);
3784 if (PerlIOBase(f)->flags & PERLIO_F_WRBUF) {
3786 * write() the buffer
3788 const STDCHAR *buf = b->buf;
3789 const STDCHAR *p = buf;
3790 while (p < b->ptr) {
3791 SSize_t count = PerlIO_write(n, p, b->ptr - p);
3795 else if (count < 0 || PerlIO_error(n)) {
3796 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
3801 b->posn += (p - buf);
3803 else if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
3804 STDCHAR *buf = PerlIO_get_base(f);
3806 * Note position change
3808 b->posn += (b->ptr - buf);
3809 if (b->ptr < b->end) {
3810 /* We did not consume all of it - try and seek downstream to
3811 our logical position
3813 if (PerlIOValid(n) && PerlIO_seek(n, b->posn, SEEK_SET) == 0) {
3814 /* Reload n as some layers may pop themselves on seek */
3815 b->posn = PerlIO_tell(n = PerlIONext(f));
3818 /* Seek failed (e.g. pipe or tty). Do NOT clear buffer or pre-read
3819 data is lost for good - so return saying "ok" having undone
3822 b->posn -= (b->ptr - buf);
3827 b->ptr = b->end = b->buf;
3828 PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF | PERLIO_F_WRBUF);
3829 /* We check for Valid because of dubious decision to make PerlIO_flush(NULL) flush all */
3830 if (PerlIOValid(n) && PerlIO_flush(n) != 0)
3835 /* This discards the content of the buffer after b->ptr, and rereads
3836 * the buffer from the position off in the layer downstream; here off
3837 * is at offset corresponding to b->ptr - b->buf.
3840 PerlIOBuf_fill(pTHX_ PerlIO *f)
3842 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
3843 PerlIO *n = PerlIONext(f);
3846 * Down-stream flush is defined not to loose read data so is harmless.
3847 * we would not normally be fill'ing if there was data left in anycase.
3849 if (PerlIO_flush(f) != 0) /* XXXX Check that its seek() succeeded?! */
3851 if (PerlIOBase(f)->flags & PERLIO_F_TTY)
3852 PerlIOBase_flush_linebuf(aTHX);
3855 PerlIO_get_base(f); /* allocate via vtable */
3857 assert(b->buf); /* The b->buf does get allocated via the vtable system. */
3859 b->ptr = b->end = b->buf;
3861 if (!PerlIOValid(n)) {
3862 PerlIOBase(f)->flags |= PERLIO_F_EOF;
3866 if (PerlIO_fast_gets(n)) {
3868 * Layer below is also buffered. We do _NOT_ want to call its
3869 * ->Read() because that will loop till it gets what we asked for
3870 * which may hang on a pipe etc. Instead take anything it has to
3871 * hand, or ask it to fill _once_.
3873 avail = PerlIO_get_cnt(n);
3875 avail = PerlIO_fill(n);
3877 avail = PerlIO_get_cnt(n);
3879 if (!PerlIO_error(n) && PerlIO_eof(n))
3884 STDCHAR *ptr = PerlIO_get_ptr(n);
3885 const SSize_t cnt = avail;
3886 if (avail > (SSize_t)b->bufsiz)
3888 Copy(ptr, b->buf, avail, STDCHAR);
3889 PerlIO_set_ptrcnt(n, ptr + avail, cnt - avail);
3893 avail = PerlIO_read(n, b->ptr, b->bufsiz);
3897 PerlIOBase(f)->flags |= PERLIO_F_EOF;
3899 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
3902 b->end = b->buf + avail;
3903 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
3908 PerlIOBuf_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
3910 if (PerlIOValid(f)) {
3911 const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
3914 return PerlIOBase_read(aTHX_ f, vbuf, count);
3920 PerlIOBuf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
3922 const STDCHAR *buf = (const STDCHAR *) vbuf + count;
3923 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
3926 if (PerlIOBase(f)->flags & PERLIO_F_WRBUF)
3931 if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
3933 * Buffer is already a read buffer, we can overwrite any chars
3934 * which have been read back to buffer start
3936 avail = (b->ptr - b->buf);
3940 * Buffer is idle, set it up so whole buffer is available for
3944 b->end = b->buf + avail;
3946 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
3948 * Buffer extends _back_ from where we are now
3950 b->posn -= b->bufsiz;
3952 if (avail > (SSize_t) count) {
3954 * If we have space for more than count, just move count
3962 * In simple stdio-like ungetc() case chars will be already
3965 if (buf != b->ptr) {
3966 Copy(buf, b->ptr, avail, STDCHAR);
3970 PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
3974 unread += PerlIOBase_unread(aTHX_ f, vbuf, count);
3980 PerlIOBuf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
3982 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
3983 const STDCHAR *buf = (const STDCHAR *) vbuf;
3984 const STDCHAR *flushptr = buf;
3988 if (!(PerlIOBase(f)->flags & PERLIO_F_CANWRITE))
3990 if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
3991 if (PerlIO_flush(f) != 0) {
3995 if (PerlIOBase(f)->flags & PERLIO_F_LINEBUF) {
3996 flushptr = buf + count;
3997 while (flushptr > buf && *(flushptr - 1) != '\n')
4001 SSize_t avail = b->bufsiz - (b->ptr - b->buf);
4002 if ((SSize_t) count < avail)
4004 if (flushptr > buf && flushptr <= buf + avail)
4005 avail = flushptr - buf;
4006 PerlIOBase(f)->flags |= PERLIO_F_WRBUF;
4008 Copy(buf, b->ptr, avail, STDCHAR);
4013 if (buf == flushptr)
4016 if (b->ptr >= (b->buf + b->bufsiz))
4019 if (PerlIOBase(f)->flags & PERLIO_F_UNBUF)
4025 PerlIOBuf_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
4028 if ((code = PerlIO_flush(f)) == 0) {
4029 PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
4030 code = PerlIO_seek(PerlIONext(f), offset, whence);
4032 PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
4033 b->posn = PerlIO_tell(PerlIONext(f));
4040 PerlIOBuf_tell(pTHX_ PerlIO *f)
4042 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4044 * b->posn is file position where b->buf was read, or will be written
4046 Off_t posn = b->posn;
4047 if ((PerlIOBase(f)->flags & PERLIO_F_APPEND) &&
4048 (PerlIOBase(f)->flags & PERLIO_F_WRBUF)) {
4050 /* As O_APPEND files are normally shared in some sense it is better
4055 /* when file is NOT shared then this is sufficient */
4056 PerlIO_seek(PerlIONext(f),0, SEEK_END);
4058 posn = b->posn = PerlIO_tell(PerlIONext(f));
4062 * If buffer is valid adjust position by amount in buffer
4064 posn += (b->ptr - b->buf);
4070 PerlIOBuf_popped(pTHX_ PerlIO *f)
4072 const IV code = PerlIOBase_popped(aTHX_ f);
4073 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4074 if (b->buf && b->buf != (STDCHAR *) & b->oneword) {
4077 b->ptr = b->end = b->buf = NULL;
4078 PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF | PERLIO_F_WRBUF);
4083 PerlIOBuf_close(pTHX_ PerlIO *f)
4085 const IV code = PerlIOBase_close(aTHX_ f);
4086 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4087 if (b->buf && b->buf != (STDCHAR *) & b->oneword) {
4090 b->ptr = b->end = b->buf = NULL;
4091 PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF | PERLIO_F_WRBUF);
4096 PerlIOBuf_get_ptr(pTHX_ PerlIO *f)
4098 const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4105 PerlIOBuf_get_cnt(pTHX_ PerlIO *f)
4107 const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4110 if (PerlIOBase(f)->flags & PERLIO_F_RDBUF)
4111 return (b->end - b->ptr);
4116 PerlIOBuf_get_base(pTHX_ PerlIO *f)
4118 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4119 PERL_UNUSED_CONTEXT;
4123 b->bufsiz = PERLIOBUF_DEFAULT_BUFSIZ;
4124 Newxz(b->buf,b->bufsiz, STDCHAR);
4126 b->buf = (STDCHAR *) & b->oneword;
4127 b->bufsiz = sizeof(b->oneword);
4129 b->end = b->ptr = b->buf;
4135 PerlIOBuf_bufsiz(pTHX_ PerlIO *f)
4137 const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4140 return (b->end - b->buf);
4144 PerlIOBuf_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
4146 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4148 PERL_UNUSED_ARG(cnt);
4153 assert(PerlIO_get_cnt(f) == cnt);
4154 assert(b->ptr >= b->buf);
4155 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
4159 PerlIOBuf_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
4161 return PerlIOBase_dup(aTHX_ f, o, param, flags);
4166 PERLIO_FUNCS_DECL(PerlIO_perlio) = {
4167 sizeof(PerlIO_funcs),
4170 PERLIO_K_BUFFERED|PERLIO_K_RAW,
4174 PerlIOBase_binmode, /* binmode */
4188 PerlIOBase_clearerr,
4189 PerlIOBase_setlinebuf,
4194 PerlIOBuf_set_ptrcnt,
4197 /*--------------------------------------------------------------------------------------*/
4199 * Temp layer to hold unread chars when cannot do it any other way
4203 PerlIOPending_fill(pTHX_ PerlIO *f)
4206 * Should never happen
4213 PerlIOPending_close(pTHX_ PerlIO *f)
4216 * A tad tricky - flush pops us, then we close new top
4219 return PerlIO_close(f);
4223 PerlIOPending_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
4226 * A tad tricky - flush pops us, then we seek new top
4229 return PerlIO_seek(f, offset, whence);
4234 PerlIOPending_flush(pTHX_ PerlIO *f)
4236 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4237 if (b->buf && b->buf != (STDCHAR *) & b->oneword) {
4241 PerlIO_pop(aTHX_ f);
4246 PerlIOPending_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
4252 PerlIOBuf_set_ptrcnt(aTHX_ f, ptr, cnt);
4257 PerlIOPending_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
4259 const IV code = PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
4260 PerlIOl * const l = PerlIOBase(f);
4262 * Our PerlIO_fast_gets must match what we are pushed on, or sv_gets()
4263 * etc. get muddled when it changes mid-string when we auto-pop.
4265 l->flags = (l->flags & ~(PERLIO_F_FASTGETS | PERLIO_F_UTF8)) |
4266 (PerlIOBase(PerlIONext(f))->
4267 flags & (PERLIO_F_FASTGETS | PERLIO_F_UTF8));
4272 PerlIOPending_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
4274 SSize_t avail = PerlIO_get_cnt(f);
4276 if ((SSize_t)count < avail)
4279 got = PerlIOBuf_read(aTHX_ f, vbuf, avail);
4280 if (got >= 0 && got < (SSize_t)count) {
4281 const SSize_t more =
4282 PerlIO_read(f, ((STDCHAR *) vbuf) + got, count - got);
4283 if (more >= 0 || got == 0)
4289 PERLIO_FUNCS_DECL(PerlIO_pending) = {
4290 sizeof(PerlIO_funcs),
4293 PERLIO_K_BUFFERED|PERLIO_K_RAW, /* not sure about RAW here */
4294 PerlIOPending_pushed,
4297 PerlIOBase_binmode, /* binmode */
4306 PerlIOPending_close,
4307 PerlIOPending_flush,
4311 PerlIOBase_clearerr,
4312 PerlIOBase_setlinebuf,
4317 PerlIOPending_set_ptrcnt,
4322 /*--------------------------------------------------------------------------------------*/
4324 * crlf - translation On read translate CR,LF to "\n" we do this by
4325 * overriding ptr/cnt entries to hand back a line at a time and keeping a
4326 * record of which nl we "lied" about. On write translate "\n" to CR,LF
4328 * c->nl points on the first byte of CR LF pair when it is temporarily
4329 * replaced by LF, or to the last CR of the buffer. In the former case
4330 * the caller thinks that the buffer ends at c->nl + 1, in the latter
4331 * that it ends at c->nl; these two cases can be distinguished by
4332 * *c->nl. c->nl is set during _getcnt() call, and unset during
4333 * _unread() and _flush() calls.
4334 * It only matters for read operations.
4338 PerlIOBuf base; /* PerlIOBuf stuff */
4339 STDCHAR *nl; /* Position of crlf we "lied" about in the
4343 /* Inherit the PERLIO_F_UTF8 flag from previous layer.
4344 * Otherwise the :crlf layer would always revert back to
4348 S_inherit_utf8_flag(PerlIO *f)
4350 PerlIO *g = PerlIONext(f);
4351 if (PerlIOValid(g)) {
4352 if (PerlIOBase(g)->flags & PERLIO_F_UTF8) {
4353 PerlIOBase(f)->flags |= PERLIO_F_UTF8;
4359 PerlIOCrlf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
4362 PerlIOBase(f)->flags |= PERLIO_F_CRLF;
4363 code = PerlIOBuf_pushed(aTHX_ f, mode, arg, tab);
4365 PerlIO_debug("PerlIOCrlf_pushed f=%p %s %s fl=%08" UVxf "\n",
4366 (void*)f, PerlIOBase(f)->tab->name, (mode) ? mode : "(Null)",
4367 PerlIOBase(f)->flags);
4370 /* Enable the first CRLF capable layer you can find, but if none
4371 * found, the one we just pushed is fine. This results in at
4372 * any given moment at most one CRLF-capable layer being enabled
4373 * in the whole layer stack. */
4374 PerlIO *g = PerlIONext(f);
4375 while (PerlIOValid(g)) {
4376 PerlIOl *b = PerlIOBase(g);
4377 if (b && b->tab == &PerlIO_crlf) {
4378 if (!(b->flags & PERLIO_F_CRLF))
4379 b->flags |= PERLIO_F_CRLF;
4380 S_inherit_utf8_flag(g);
4381 PerlIO_pop(aTHX_ f);
4387 S_inherit_utf8_flag(f);
4393 PerlIOCrlf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
4395 PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
4396 if (c->nl) { /* XXXX Shouldn't it be done only if b->ptr > c->nl? */
4400 if (!(PerlIOBase(f)->flags & PERLIO_F_CRLF))
4401 return PerlIOBuf_unread(aTHX_ f, vbuf, count);
4403 const STDCHAR *buf = (const STDCHAR *) vbuf + count;
4404 PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
4406 if (PerlIOBase(f)->flags & PERLIO_F_WRBUF)
4411 if (!(PerlIOBase(f)->flags & PERLIO_F_RDBUF)) {
4412 b->end = b->ptr = b->buf + b->bufsiz;
4413 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
4414 b->posn -= b->bufsiz;
4416 while (count > 0 && b->ptr > b->buf) {
4417 const int ch = *--buf;
4419 if (b->ptr - 2 >= b->buf) {
4426 /* If b->ptr - 1 == b->buf, we are undoing reading 0xa */
4427 *--(b->ptr) = 0xa; /* Works even if 0xa == '\r' */
4443 /* XXXX This code assumes that buffer size >=2, but does not check it... */
4445 PerlIOCrlf_get_cnt(pTHX_ PerlIO *f)
4447 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4450 if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
4451 PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
4452 if ((PerlIOBase(f)->flags & PERLIO_F_CRLF) && (!c->nl || *c->nl == 0xd)) {
4453 STDCHAR *nl = (c->nl) ? c->nl : b->ptr;
4455 while (nl < b->end && *nl != 0xd)
4457 if (nl < b->end && *nl == 0xd) {
4459 if (nl + 1 < b->end) {
4466 * Not CR,LF but just CR
4474 * Blast - found CR as last char in buffer
4479 * They may not care, defer work as long as
4483 return (nl - b->ptr);
4487 b->ptr++; /* say we have read it as far as
4488 * flush() is concerned */
4489 b->buf++; /* Leave space in front of buffer */
4490 /* Note as we have moved buf up flush's
4492 will naturally make posn point at CR
4494 b->bufsiz--; /* Buffer is thus smaller */
4495 code = PerlIO_fill(f); /* Fetch some more */
4496 b->bufsiz++; /* Restore size for next time */
4497 b->buf--; /* Point at space */
4498 b->ptr = nl = b->buf; /* Which is what we hand
4500 *nl = 0xd; /* Fill in the CR */
4502 goto test; /* fill() call worked */
4504 * CR at EOF - just fall through
4506 /* Should we clear EOF though ??? */
4511 return (((c->nl) ? (c->nl + 1) : b->end) - b->ptr);
4517 PerlIOCrlf_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
4519 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4520 PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
4526 if (ptr == b->end && *c->nl == 0xd) {
4527 /* Defered CR at end of buffer case - we lied about count */
4540 * Test code - delete when it works ...
4542 IV flags = PerlIOBase(f)->flags;
4543 STDCHAR *chk = (c->nl) ? (c->nl+1) : b->end;
4544 if (ptr+cnt == c->nl && c->nl+1 == b->end && *c->nl == 0xd) {
4545 /* Defered CR at end of buffer case - we lied about count */
4551 Perl_croak(aTHX_ "ptr wrong %p != %p fl=%08" UVxf
4552 " nl=%p e=%p for %d", (void*)ptr, (void*)chk,
4553 flags, c->nl, b->end, cnt);
4560 * They have taken what we lied about
4568 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
4572 PerlIOCrlf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
4574 if (!(PerlIOBase(f)->flags & PERLIO_F_CRLF))
4575 return PerlIOBuf_write(aTHX_ f, vbuf, count);
4577 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4578 const STDCHAR *buf = (const STDCHAR *) vbuf;
4579 const STDCHAR * const ebuf = buf + count;
4582 if (!(PerlIOBase(f)->flags & PERLIO_F_CANWRITE))
4584 while (buf < ebuf) {
4585 const STDCHAR * const eptr = b->buf + b->bufsiz;
4586 PerlIOBase(f)->flags |= PERLIO_F_WRBUF;
4587 while (buf < ebuf && b->ptr < eptr) {
4589 if ((b->ptr + 2) > eptr) {
4597 *(b->ptr)++ = 0xd; /* CR */
4598 *(b->ptr)++ = 0xa; /* LF */
4600 if (PerlIOBase(f)->flags & PERLIO_F_LINEBUF) {
4607 *(b->ptr)++ = *buf++;
4609 if (b->ptr >= eptr) {
4615 if (PerlIOBase(f)->flags & PERLIO_F_UNBUF)
4617 return (buf - (STDCHAR *) vbuf);
4622 PerlIOCrlf_flush(pTHX_ PerlIO *f)
4624 PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
4629 return PerlIOBuf_flush(aTHX_ f);
4633 PerlIOCrlf_binmode(pTHX_ PerlIO *f)
4635 if ((PerlIOBase(f)->flags & PERLIO_F_CRLF)) {
4636 /* In text mode - flush any pending stuff and flip it */
4637 PerlIOBase(f)->flags &= ~PERLIO_F_CRLF;
4638 #ifndef PERLIO_USING_CRLF
4639 /* CRLF is unusual case - if this is just the :crlf layer pop it */
4640 PerlIO_pop(aTHX_ f);
4646 PERLIO_FUNCS_DECL(PerlIO_crlf) = {
4647 sizeof(PerlIO_funcs),
4650 PERLIO_K_BUFFERED | PERLIO_K_CANCRLF | PERLIO_K_RAW,
4652 PerlIOBuf_popped, /* popped */
4654 PerlIOCrlf_binmode, /* binmode */
4658 PerlIOBuf_read, /* generic read works with ptr/cnt lies */
4659 PerlIOCrlf_unread, /* Put CR,LF in buffer for each '\n' */
4660 PerlIOCrlf_write, /* Put CR,LF in buffer for each '\n' */
4668 PerlIOBase_clearerr,
4669 PerlIOBase_setlinebuf,
4674 PerlIOCrlf_set_ptrcnt,
4678 /*--------------------------------------------------------------------------------------*/
4680 * mmap as "buffer" layer
4684 PerlIOBuf base; /* PerlIOBuf stuff */
4685 Mmap_t mptr; /* Mapped address */
4686 Size_t len; /* mapped length */
4687 STDCHAR *bbuf; /* malloced buffer if map fails */
4691 PerlIOMmap_map(pTHX_ PerlIO *f)
4694 PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4695 const IV flags = PerlIOBase(f)->flags;
4699 if (flags & PERLIO_F_CANREAD) {
4700 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4701 const int fd = PerlIO_fileno(f);
4703 code = Fstat(fd, &st);
4704 if (code == 0 && S_ISREG(st.st_mode)) {
4705 SSize_t len = st.st_size - b->posn;
4708 if (PL_mmap_page_size <= 0)
4709 Perl_croak(aTHX_ "panic: bad pagesize %" IVdf,
4713 * This is a hack - should never happen - open should
4716 b->posn = PerlIO_tell(PerlIONext(f));
4718 posn = (b->posn / PL_mmap_page_size) * PL_mmap_page_size;
4719 len = st.st_size - posn;
4720 m->mptr = (Mmap_t)mmap(NULL, len, PROT_READ, MAP_SHARED, fd, posn);
4721 if (m->mptr && m->mptr != (Mmap_t) - 1) {
4722 #if 0 && defined(HAS_MADVISE) && defined(MADV_SEQUENTIAL)
4723 madvise(m->mptr, len, MADV_SEQUENTIAL);
4725 #if 0 && defined(HAS_MADVISE) && defined(MADV_WILLNEED)
4726 madvise(m->mptr, len, MADV_WILLNEED);
4728 PerlIOBase(f)->flags =
4729 (flags & ~PERLIO_F_EOF) | PERLIO_F_RDBUF;
4730 b->end = ((STDCHAR *) m->mptr) + len;
4731 b->buf = ((STDCHAR *) m->mptr) + (b->posn - posn);
4740 PerlIOBase(f)->flags =
4741 flags | PERLIO_F_EOF | PERLIO_F_RDBUF;
4743 b->ptr = b->end = b->ptr;
4752 PerlIOMmap_unmap(pTHX_ PerlIO *f)
4754 PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4757 PerlIOBuf * const b = &m->base;
4759 /* The munmap address argument is tricky: depending on the
4760 * standard it is either "void *" or "caddr_t" (which is
4761 * usually "char *" (signed or unsigned). If we cast it
4762 * to "void *", those that have it caddr_t and an uptight
4763 * C++ compiler, will freak out. But casting it as char*
4764 * should work. Maybe. (Using Mmap_t figured out by
4765 * Configure doesn't always work, apparently.) */
4766 code = munmap((char*)m->mptr, m->len);
4770 if (PerlIO_seek(PerlIONext(f), b->posn, SEEK_SET) != 0)
4773 b->ptr = b->end = b->buf;
4774 PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF | PERLIO_F_WRBUF);
4780 PerlIOMmap_get_base(pTHX_ PerlIO *f)
4782 PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4783 PerlIOBuf * const b = &m->base;
4784 if (b->buf && (PerlIOBase(f)->flags & PERLIO_F_RDBUF)) {
4786 * Already have a readbuffer in progress
4792 * We have a write buffer or flushed PerlIOBuf read buffer
4794 m->bbuf = b->buf; /* save it in case we need it again */
4795 b->buf = NULL; /* Clear to trigger below */
4798 PerlIOMmap_map(aTHX_ f); /* Try and map it */
4801 * Map did not work - recover PerlIOBuf buffer if we have one
4806 b->ptr = b->end = b->buf;
4809 return PerlIOBuf_get_base(aTHX_ f);
4813 PerlIOMmap_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
4815 PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4816 PerlIOBuf * const b = &m->base;
4817 if (PerlIOBase(f)->flags & PERLIO_F_WRBUF)
4819 if (b->ptr && (b->ptr - count) >= b->buf
4820 && memEQ(b->ptr - count, vbuf, count)) {
4822 PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
4827 * Loose the unwritable mapped buffer
4831 * If flush took the "buffer" see if we have one from before
4833 if (!b->buf && m->bbuf)
4836 PerlIOBuf_get_base(aTHX_ f);
4840 return PerlIOBuf_unread(aTHX_ f, vbuf, count);
4844 PerlIOMmap_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
4846 PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4847 PerlIOBuf * const b = &m->base;
4849 if (!b->buf || !(PerlIOBase(f)->flags & PERLIO_F_WRBUF)) {
4851 * No, or wrong sort of, buffer
4854 if (PerlIOMmap_unmap(aTHX_ f) != 0)
4858 * If unmap took the "buffer" see if we have one from before
4860 if (!b->buf && m->bbuf)
4863 PerlIOBuf_get_base(aTHX_ f);
4867 return PerlIOBuf_write(aTHX_ f, vbuf, count);
4871 PerlIOMmap_flush(pTHX_ PerlIO *f)
4873 PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4874 PerlIOBuf * const b = &m->base;
4875 IV code = PerlIOBuf_flush(aTHX_ f);
4877 * Now we are "synced" at PerlIOBuf level
4884 if (PerlIOMmap_unmap(aTHX_ f) != 0)
4889 * We seem to have a PerlIOBuf buffer which was not mapped
4890 * remember it in case we need one later
4899 PerlIOMmap_fill(pTHX_ PerlIO *f)
4901 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4902 IV code = PerlIO_flush(f);
4903 if (code == 0 && !b->buf) {
4904 code = PerlIOMmap_map(aTHX_ f);
4906 if (code == 0 && !(PerlIOBase(f)->flags & PERLIO_F_RDBUF)) {
4907 code = PerlIOBuf_fill(aTHX_ f);
4913 PerlIOMmap_close(pTHX_ PerlIO *f)
4915 PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4916 PerlIOBuf * const b = &m->base;
4917 IV code = PerlIO_flush(f);
4921 b->ptr = b->end = b->buf;
4923 if (PerlIOBuf_close(aTHX_ f) != 0)
4929 PerlIOMmap_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
4931 return PerlIOBase_dup(aTHX_ f, o, param, flags);
4935 PERLIO_FUNCS_DECL(PerlIO_mmap) = {
4936 sizeof(PerlIO_funcs),
4939 PERLIO_K_BUFFERED|PERLIO_K_RAW,
4943 PerlIOBase_binmode, /* binmode */
4957 PerlIOBase_clearerr,
4958 PerlIOBase_setlinebuf,
4959 PerlIOMmap_get_base,
4963 PerlIOBuf_set_ptrcnt,
4966 #endif /* HAS_MMAP */
4969 Perl_PerlIO_stdin(pTHX)
4973 PerlIO_stdstreams(aTHX);
4975 return &PL_perlio[1];
4979 Perl_PerlIO_stdout(pTHX)
4983 PerlIO_stdstreams(aTHX);
4985 return &PL_perlio[2];
4989 Perl_PerlIO_stderr(pTHX)
4993 PerlIO_stdstreams(aTHX);
4995 return &PL_perlio[3];
4998 /*--------------------------------------------------------------------------------------*/
5001 PerlIO_getname(PerlIO *f, char *buf)
5006 bool exported = FALSE;
5007 FILE *stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
5009 stdio = PerlIO_exportFILE(f,0);
5013 name = fgetname(stdio, buf);
5014 if (exported) PerlIO_releaseFILE(f,stdio);
5019 PERL_UNUSED_ARG(buf);
5020 Perl_croak(aTHX_ "Don't know how to get file name");
5026 /*--------------------------------------------------------------------------------------*/
5028 * Functions which can be called on any kind of PerlIO implemented in
5032 #undef PerlIO_fdopen
5034 PerlIO_fdopen(int fd, const char *mode)
5037 return PerlIO_openn(aTHX_ NULL, mode, fd, 0, 0, NULL, 0, NULL);
5042 PerlIO_open(const char *path, const char *mode)
5045 SV *name = sv_2mortal(newSVpv(path, 0));
5046 return PerlIO_openn(aTHX_ NULL, mode, -1, 0, 0, NULL, 1, &name);
5049 #undef Perlio_reopen
5051 PerlIO_reopen(const char *path, const char *mode, PerlIO *f)
5054 SV *name = sv_2mortal(newSVpv(path,0));
5055 return PerlIO_openn(aTHX_ NULL, mode, -1, 0, 0, f, 1, &name);
5060 PerlIO_getc(PerlIO *f)
5064 if ( 1 == PerlIO_read(f, buf, 1) ) {
5065 return (unsigned char) buf[0];
5070 #undef PerlIO_ungetc
5072 PerlIO_ungetc(PerlIO *f, int ch)
5077 if (PerlIO_unread(f, &buf, 1) == 1)
5085 PerlIO_putc(PerlIO *f, int ch)
5089 return PerlIO_write(f, &buf, 1);
5094 PerlIO_puts(PerlIO *f, const char *s)
5097 return PerlIO_write(f, s, strlen(s));
5100 #undef PerlIO_rewind
5102 PerlIO_rewind(PerlIO *f)
5105 PerlIO_seek(f, (Off_t) 0, SEEK_SET);
5109 #undef PerlIO_vprintf
5111 PerlIO_vprintf(PerlIO *f, const char *fmt, va_list ap)
5120 Perl_va_copy(ap, apc);
5121 sv = vnewSVpvf(fmt, &apc);
5123 sv = vnewSVpvf(fmt, &ap);
5125 s = SvPV_const(sv, len);
5126 wrote = PerlIO_write(f, s, len);
5131 #undef PerlIO_printf
5133 PerlIO_printf(PerlIO *f, const char *fmt, ...)
5138 result = PerlIO_vprintf(f, fmt, ap);
5143 #undef PerlIO_stdoutf
5145 PerlIO_stdoutf(const char *fmt, ...)
5151 result = PerlIO_vprintf(PerlIO_stdout(), fmt, ap);
5156 #undef PerlIO_tmpfile
5158 PerlIO_tmpfile(void)
5163 const int fd = win32_tmpfd();
5165 f = PerlIO_fdopen(fd, "w+b");
5167 # if defined(HAS_MKSTEMP) && ! defined(VMS) && ! defined(OS2)
5169 char tempname[] = "/tmp/PerlIO_XXXXXX";
5170 const char * const tmpdir = PL_tainting ? NULL : PerlEnv_getenv("TMPDIR");
5173 * I have no idea how portable mkstemp() is ... NI-S
5175 if (tmpdir && *tmpdir) {
5176 /* if TMPDIR is set and not empty, we try that first */
5177 sv = newSVpv(tmpdir, 0);
5178 sv_catpv(sv, tempname + 4);
5179 fd = mkstemp(SvPVX(sv));
5183 /* else we try /tmp */
5184 fd = mkstemp(tempname);
5187 f = PerlIO_fdopen(fd, "w+");
5189 PerlIOBase(f)->flags |= PERLIO_F_TEMP;
5190 PerlLIO_unlink(sv ? SvPVX_const(sv) : tempname);
5193 # else /* !HAS_MKSTEMP, fallback to stdio tmpfile(). */
5194 FILE * const stdio = PerlSIO_tmpfile();
5197 f = PerlIO_fdopen(fileno(stdio), "w+");
5199 # endif /* else HAS_MKSTEMP */
5200 #endif /* else WIN32 */
5207 #endif /* USE_SFIO */
5208 #endif /* PERLIO_IS_STDIO */
5210 /*======================================================================================*/
5212 * Now some functions in terms of above which may be needed even if we are
5213 * not in true PerlIO mode
5216 Perl_PerlIO_context_layers(pTHX_ const char *mode)
5219 const char *direction = NULL;
5222 * Need to supply default layer info from open.pm
5228 if (mode && mode[0] != 'r') {
5229 if (PL_curcop->cop_hints & HINT_LEXICAL_IO_OUT)
5230 direction = "open>";
5232 if (PL_curcop->cop_hints & HINT_LEXICAL_IO_IN)
5233 direction = "open<";
5238 layers = cop_hints_fetch_pvn(PL_curcop, direction, 5, 0, 0);
5241 return SvOK(layers) ? SvPV_nolen_const(layers) : NULL;
5246 #undef PerlIO_setpos
5248 PerlIO_setpos(PerlIO *f, SV *pos)
5253 const Off_t * const posn = (Off_t *) SvPV(pos, len);
5254 if (f && len == sizeof(Off_t))
5255 return PerlIO_seek(f, *posn, SEEK_SET);
5257 SETERRNO(EINVAL, SS_IVCHAN);
5261 #undef PerlIO_setpos
5263 PerlIO_setpos(PerlIO *f, SV *pos)
5268 Fpos_t * const fpos = (Fpos_t *) SvPV(pos, len);
5269 if (f && len == sizeof(Fpos_t)) {
5270 #if defined(USE_64_BIT_STDIO) && defined(USE_FSETPOS64)
5271 return fsetpos64(f, fpos);
5273 return fsetpos(f, fpos);
5277 SETERRNO(EINVAL, SS_IVCHAN);
5283 #undef PerlIO_getpos
5285 PerlIO_getpos(PerlIO *f, SV *pos)
5288 Off_t posn = PerlIO_tell(f);
5289 sv_setpvn(pos, (char *) &posn, sizeof(posn));
5290 return (posn == (Off_t) - 1) ? -1 : 0;
5293 #undef PerlIO_getpos
5295 PerlIO_getpos(PerlIO *f, SV *pos)
5300 #if defined(USE_64_BIT_STDIO) && defined(USE_FSETPOS64)
5301 code = fgetpos64(f, &fpos);
5303 code = fgetpos(f, &fpos);
5305 sv_setpvn(pos, (char *) &fpos, sizeof(fpos));
5310 #if (defined(PERLIO_IS_STDIO) || !defined(USE_SFIO)) && !defined(HAS_VPRINTF)
5313 vprintf(char *pat, char *args)
5315 _doprnt(pat, args, stdout);
5316 return 0; /* wrong, but perl doesn't use the return
5321 vfprintf(FILE *fd, char *pat, char *args)
5323 _doprnt(pat, args, fd);
5324 return 0; /* wrong, but perl doesn't use the return
5330 #ifndef PerlIO_vsprintf
5332 PerlIO_vsprintf(char *s, int n, const char *fmt, va_list ap)
5335 const int val = my_vsnprintf(s, n > 0 ? n : 0, fmt, ap);
5336 PERL_UNUSED_CONTEXT;
5338 #ifndef PERL_MY_VSNPRINTF_GUARDED
5339 if (val < 0 || (n > 0 ? val >= n : 0)) {
5340 Perl_croak(aTHX_ "panic: my_vsnprintf overflow in PerlIO_vsprintf\n");
5347 #ifndef PerlIO_sprintf
5349 PerlIO_sprintf(char *s, int n, const char *fmt, ...)
5354 result = PerlIO_vsprintf(s, n, fmt, ap);
5362 * c-indentation-style: bsd
5364 * indent-tabs-mode: t
5367 * ex: set ts=8 sts=4 sw=4 noet: