3 * Copyright (c) 1996-2006, Nick Ing-Simmons
4 * Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011 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 #define PerlIO_lockcnt(f) (((PerlIOl*)(f))->head->flags)
75 /* Call the callback or PerlIOBase, and return failure. */
76 #define Perl_PerlIO_or_Base(f, callback, base, failure, args) \
77 if (PerlIOValid(f)) { \
78 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;\
79 if (tab && tab->callback) \
80 return (*tab->callback) args; \
82 return PerlIOBase_ ## base args; \
85 SETERRNO(EBADF, SS_IVCHAN); \
88 /* Call the callback or fail, and return failure. */
89 #define Perl_PerlIO_or_fail(f, callback, failure, args) \
90 if (PerlIOValid(f)) { \
91 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;\
92 if (tab && tab->callback) \
93 return (*tab->callback) args; \
94 SETERRNO(EINVAL, LIB_INVARG); \
97 SETERRNO(EBADF, SS_IVCHAN); \
100 /* Call the callback or PerlIOBase, and be void. */
101 #define Perl_PerlIO_or_Base_void(f, callback, base, args) \
102 if (PerlIOValid(f)) { \
103 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;\
104 if (tab && tab->callback) \
105 (*tab->callback) args; \
107 PerlIOBase_ ## base args; \
110 SETERRNO(EBADF, SS_IVCHAN)
112 /* Call the callback or fail, and be void. */
113 #define Perl_PerlIO_or_fail_void(f, callback, args) \
114 if (PerlIOValid(f)) { \
115 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;\
116 if (tab && tab->callback) \
117 (*tab->callback) args; \
119 SETERRNO(EINVAL, LIB_INVARG); \
122 SETERRNO(EBADF, SS_IVCHAN)
124 #if defined(__osf__) && _XOPEN_SOURCE < 500
125 extern int fseeko(FILE *, off_t, int);
126 extern off_t ftello(FILE *);
131 EXTERN_C int perlsio_binmode(FILE *fp, int iotype, int mode);
134 perlsio_binmode(FILE *fp, int iotype, int mode)
137 * This used to be contents of do_binmode in doio.c
140 # if defined(atarist)
141 PERL_UNUSED_ARG(iotype);
144 ((FILE *) fp)->_flag |= _IOBIN;
146 ((FILE *) fp)->_flag &= ~_IOBIN;
152 PERL_UNUSED_ARG(iotype);
154 if (PerlLIO_setmode(fp, mode) != -1) {
156 if (PerlLIO_setmode(fileno(fp), mode) != -1) {
164 # if defined(USEMYBINMODE)
166 # if defined(__CYGWIN__)
167 PERL_UNUSED_ARG(iotype);
169 if (my_binmode(fp, iotype, mode) != FALSE)
175 PERL_UNUSED_ARG(iotype);
176 PERL_UNUSED_ARG(mode);
184 #define O_ACCMODE 3 /* Assume traditional implementation */
188 PerlIO_intmode2str(int rawmode, char *mode, int *writing)
190 const int result = rawmode & O_ACCMODE;
195 ptype = IoTYPE_RDONLY;
198 ptype = IoTYPE_WRONLY;
206 *writing = (result != O_RDONLY);
208 if (result == O_RDONLY) {
212 else if (rawmode & O_APPEND) {
214 if (result != O_WRONLY)
219 if (result == O_WRONLY)
226 if (rawmode & O_BINARY)
232 #ifndef PERLIO_LAYERS
234 PerlIO_apply_layers(pTHX_ PerlIO *f, const char *mode, const char *names)
236 if (!names || !*names
237 || strEQ(names, ":crlf")
238 || strEQ(names, ":raw")
239 || strEQ(names, ":bytes")
243 Perl_croak(aTHX_ "Cannot apply \"%s\" in non-PerlIO perl", names);
251 PerlIO_destruct(pTHX)
256 PerlIO_binmode(pTHX_ PerlIO *fp, int iotype, int mode, const char *names)
259 PERL_UNUSED_ARG(iotype);
260 PERL_UNUSED_ARG(mode);
261 PERL_UNUSED_ARG(names);
264 return perlsio_binmode(fp, iotype, mode);
269 PerlIO_fdupopen(pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
271 #if defined(PERL_MICRO) || defined(__SYMBIAN32__)
274 #ifdef PERL_IMPLICIT_SYS
275 return PerlSIO_fdupopen(f);
278 return win32_fdupopen(f);
281 const int fd = PerlLIO_dup(PerlIO_fileno(f));
285 const int omode = djgpp_get_stream_mode(f);
287 const int omode = fcntl(fd, F_GETFL);
289 PerlIO_intmode2str(omode,mode,NULL);
290 /* the r+ is a hack */
291 return PerlIO_fdopen(fd, mode);
296 SETERRNO(EBADF, SS_IVCHAN);
306 * De-mux PerlIO_openn() into fdopen, freopen and fopen type entries
310 PerlIO_openn(pTHX_ const char *layers, const char *mode, int fd,
311 int imode, int perm, PerlIO *old, int narg, SV **args)
315 Perl_croak(aTHX_ "More than one argument to open");
317 if (*args == &PL_sv_undef)
318 return PerlIO_tmpfile();
320 const char *name = SvPV_nolen_const(*args);
321 if (*mode == IoTYPE_NUMERIC) {
322 fd = PerlLIO_open3(name, imode, perm);
324 return PerlIO_fdopen(fd, mode + 1);
327 return PerlIO_reopen(name, mode, old);
330 return PerlIO_open(name, mode);
335 return PerlIO_fdopen(fd, (char *) mode);
340 XS(XS_PerlIO__Layer__find)
344 Perl_croak(aTHX_ "Usage class->find(name[,load])");
346 const char * const name = SvPV_nolen_const(ST(1));
347 ST(0) = (strEQ(name, "crlf")
348 || strEQ(name, "raw")) ? &PL_sv_yes : &PL_sv_undef;
355 Perl_boot_core_PerlIO(pTHX)
357 newXS("PerlIO::Layer::find", XS_PerlIO__Layer__find, __FILE__);
363 #ifdef PERLIO_IS_STDIO
370 * Does nothing (yet) except force this file to be included in perl
371 * binary. That allows this file to force inclusion of other functions
372 * that may be required by loadable extensions e.g. for
373 * FileHandle::tmpfile
377 #undef PerlIO_tmpfile
384 #else /* PERLIO_IS_STDIO */
392 * This section is just to make sure these functions get pulled in from
396 #undef PerlIO_tmpfile
408 * Force this file to be included in perl binary. Which allows this
409 * file to force inclusion of other functions that may be required by
410 * loadable extensions e.g. for FileHandle::tmpfile
414 * Hack sfio does its own 'autoflush' on stdout in common cases. Flush
415 * results in a lot of lseek()s to regular files and lot of small
418 sfset(sfstdout, SF_SHARE, 0);
421 /* This is not the reverse of PerlIO_exportFILE(), PerlIO_releaseFILE() is. */
423 PerlIO_importFILE(FILE *stdio, const char *mode)
425 const int fd = fileno(stdio);
426 if (!mode || !*mode) {
429 return PerlIO_fdopen(fd, mode);
433 PerlIO_findFILE(PerlIO *pio)
435 const int fd = PerlIO_fileno(pio);
436 FILE * const f = fdopen(fd, "r+");
438 if (!f && errno == EINVAL)
440 if (!f && errno == EINVAL)
447 /*======================================================================================*/
449 * Implement all the PerlIO interface ourselves.
455 PerlIO_debug(const char *fmt, ...)
460 if (!PL_perlio_debug_fd) {
461 if (!PL_tainting && PL_uid == PL_euid && PL_gid == PL_egid) {
462 const char * const s = PerlEnv_getenv("PERLIO_DEBUG");
465 = PerlLIO_open3(s, O_WRONLY | O_CREAT | O_APPEND, 0666);
467 PL_perlio_debug_fd = -1;
469 /* tainting or set*id, so ignore the environment, and ensure we
470 skip these tests next time through. */
471 PL_perlio_debug_fd = -1;
474 if (PL_perlio_debug_fd > 0) {
477 const char * const s = CopFILE(PL_curcop);
478 /* Use fixed buffer as sv_catpvf etc. needs SVs */
480 const STRLEN len1 = my_snprintf(buffer, sizeof(buffer), "%.40s:%" IVdf " ", s ? s : "(none)", (IV) CopLINE(PL_curcop));
481 const STRLEN len2 = my_vsnprintf(buffer + len1, sizeof(buffer) - len1, fmt, ap);
482 PerlLIO_write(PL_perlio_debug_fd, buffer, len1 + len2);
484 const char *s = CopFILE(PL_curcop);
486 SV * const sv = Perl_newSVpvf(aTHX_ "%s:%" IVdf " ", s ? s : "(none)",
487 (IV) CopLINE(PL_curcop));
488 Perl_sv_vcatpvf(aTHX_ sv, fmt, &ap);
490 s = SvPV_const(sv, len);
491 PerlLIO_write(PL_perlio_debug_fd, s, len);
498 /*--------------------------------------------------------------------------------------*/
501 * Inner level routines
504 /* check that the head field of each layer points back to the head */
507 # define VERIFY_HEAD(f) PerlIO_verify_head(aTHX_ f)
509 PerlIO_verify_head(pTHX_ PerlIO *f)
515 p = head = PerlIOBase(f)->head;
518 assert(p->head == head);
519 if (p == (PerlIOl*)f)
526 # define VERIFY_HEAD(f)
531 * Table of pointers to the PerlIO structs (malloc'ed)
533 #define PERLIO_TABLE_SIZE 64
536 PerlIO_init_table(pTHX)
540 Newxz(PL_perlio, PERLIO_TABLE_SIZE, PerlIOl);
546 PerlIO_allocate(pTHX)
550 * Find a free slot in the table, allocating new table as necessary
555 while ((f = *last)) {
557 last = (PerlIOl **) (f);
558 for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
559 if (!((++f)->next)) {
560 f->flags = 0; /* lockcnt */
567 Newxz(f,PERLIO_TABLE_SIZE,PerlIOl);
571 *last = (PerlIOl*) f++;
572 f->flags = 0; /* lockcnt */
578 #undef PerlIO_fdupopen
580 PerlIO_fdupopen(pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
582 if (PerlIOValid(f)) {
583 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
584 PerlIO_debug("fdupopen f=%p param=%p\n",(void*)f,(void*)param);
586 return (*tab->Dup)(aTHX_ PerlIO_allocate(aTHX), f, param, flags);
588 return PerlIOBase_dup(aTHX_ PerlIO_allocate(aTHX), f, param, flags);
592 SETERRNO(EBADF, SS_IVCHAN);
598 PerlIO_cleantable(pTHX_ PerlIOl **tablep)
600 PerlIOl * const table = *tablep;
603 PerlIO_cleantable(aTHX_(PerlIOl **) & (table[0]));
604 for (i = PERLIO_TABLE_SIZE - 1; i > 0; i--) {
605 PerlIOl * const f = table + i;
607 PerlIO_close(&(f->next));
617 PerlIO_list_alloc(pTHX)
621 Newxz(list, 1, PerlIO_list_t);
627 PerlIO_list_free(pTHX_ PerlIO_list_t *list)
630 if (--list->refcnt == 0) {
633 for (i = 0; i < list->cur; i++)
634 SvREFCNT_dec(list->array[i].arg);
635 Safefree(list->array);
643 PerlIO_list_push(pTHX_ PerlIO_list_t *list, PerlIO_funcs *funcs, SV *arg)
649 if (list->cur >= list->len) {
652 Renew(list->array, list->len, PerlIO_pair_t);
654 Newx(list->array, list->len, PerlIO_pair_t);
656 p = &(list->array[list->cur++]);
658 if ((p->arg = arg)) {
659 SvREFCNT_inc_simple_void_NN(arg);
664 PerlIO_clone_list(pTHX_ PerlIO_list_t *proto, CLONE_PARAMS *param)
666 PerlIO_list_t *list = NULL;
669 list = PerlIO_list_alloc(aTHX);
670 for (i=0; i < proto->cur; i++) {
671 SV *arg = proto->array[i].arg;
674 arg = sv_dup(arg, param);
676 PERL_UNUSED_ARG(param);
678 PerlIO_list_push(aTHX_ list, proto->array[i].funcs, arg);
685 PerlIO_clone(pTHX_ PerlInterpreter *proto, CLONE_PARAMS *param)
688 PerlIOl **table = &proto->Iperlio;
691 PL_known_layers = PerlIO_clone_list(aTHX_ proto->Iknown_layers, param);
692 PL_def_layerlist = PerlIO_clone_list(aTHX_ proto->Idef_layerlist, param);
693 PerlIO_init_table(aTHX);
694 PerlIO_debug("Clone %p from %p\n",(void*)aTHX,(void*)proto);
695 while ((f = *table)) {
697 table = (PerlIOl **) (f++);
698 for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
700 (void) fp_dup(&(f->next), 0, param);
707 PERL_UNUSED_ARG(proto);
708 PERL_UNUSED_ARG(param);
713 PerlIO_destruct(pTHX)
716 PerlIOl **table = &PL_perlio;
719 PerlIO_debug("Destruct %p\n",(void*)aTHX);
721 while ((f = *table)) {
723 table = (PerlIOl **) (f++);
724 for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
725 PerlIO *x = &(f->next);
728 if (l->tab && l->tab->kind & PERLIO_K_DESTRUCT) {
729 PerlIO_debug("Destruct popping %s\n", l->tab->name);
743 PerlIO_pop(pTHX_ PerlIO *f)
745 const PerlIOl *l = *f;
748 PerlIO_debug("PerlIO_pop f=%p %s\n", (void*)f,
749 l->tab ? l->tab->name : "(Null)");
750 if (l->tab && l->tab->Popped) {
752 * If popped returns non-zero do not free its layer structure
753 * it has either done so itself, or it is shared and still in
756 if ((*l->tab->Popped) (aTHX_ f) != 0)
759 if (PerlIO_lockcnt(f)) {
760 /* we're in use; defer freeing the structure */
761 PerlIOBase(f)->flags = PERLIO_F_CLEARED;
762 PerlIOBase(f)->tab = NULL;
772 /* Return as an array the stack of layers on a filehandle. Note that
773 * the stack is returned top-first in the array, and there are three
774 * times as many array elements as there are layers in the stack: the
775 * first element of a layer triplet is the name, the second one is the
776 * arguments, and the third one is the flags. */
779 PerlIO_get_layers(pTHX_ PerlIO *f)
782 AV * const av = newAV();
784 if (PerlIOValid(f)) {
785 PerlIOl *l = PerlIOBase(f);
788 /* There is some collusion in the implementation of
789 XS_PerlIO_get_layers - it knows that name and flags are
790 generated as fresh SVs here, and takes advantage of that to
791 "copy" them by taking a reference. If it changes here, it needs
792 to change there too. */
793 SV * const name = l->tab && l->tab->name ?
794 newSVpv(l->tab->name, 0) : &PL_sv_undef;
795 SV * const arg = l->tab && l->tab->Getarg ?
796 (*l->tab->Getarg)(aTHX_ &l, 0, 0) : &PL_sv_undef;
799 av_push(av, newSViv((IV)l->flags));
807 /*--------------------------------------------------------------------------------------*/
809 * XS Interface for perl code
813 PerlIO_find_layer(pTHX_ const char *name, STRLEN len, int load)
817 if ((SSize_t) len <= 0)
819 for (i = 0; i < PL_known_layers->cur; i++) {
820 PerlIO_funcs * const f = PL_known_layers->array[i].funcs;
821 if (memEQ(f->name, name, len) && f->name[len] == 0) {
822 PerlIO_debug("%.*s => %p\n", (int) len, name, (void*)f);
826 if (load && PL_subname && PL_def_layerlist
827 && PL_def_layerlist->cur >= 2) {
828 if (PL_in_load_module) {
829 Perl_croak(aTHX_ "Recursive call to Perl_load_module in PerlIO_find_layer");
832 SV * const pkgsv = newSVpvs("PerlIO");
833 SV * const layer = newSVpvn(name, len);
834 CV * const cv = get_cvs("PerlIO::Layer::NoWarnings", 0);
836 SAVEBOOL(PL_in_load_module);
838 SAVEGENERICSV(PL_warnhook);
839 PL_warnhook = MUTABLE_SV((SvREFCNT_inc_simple_NN(cv)));
841 PL_in_load_module = TRUE;
843 * The two SVs are magically freed by load_module
845 Perl_load_module(aTHX_ 0, pkgsv, NULL, layer, NULL);
847 return PerlIO_find_layer(aTHX_ name, len, 0);
850 PerlIO_debug("Cannot find %.*s\n", (int) len, name);
854 #ifdef USE_ATTRIBUTES_FOR_PERLIO
857 perlio_mg_set(pTHX_ SV *sv, MAGIC *mg)
860 IO * const io = GvIOn(MUTABLE_GV(SvRV(sv)));
861 PerlIO * const ifp = IoIFP(io);
862 PerlIO * const ofp = IoOFP(io);
863 Perl_warn(aTHX_ "set %" SVf " %p %p %p",
864 SVfARG(sv), (void*)io, (void*)ifp, (void*)ofp);
870 perlio_mg_get(pTHX_ SV *sv, MAGIC *mg)
873 IO * const io = GvIOn(MUTABLE_GV(SvRV(sv)));
874 PerlIO * const ifp = IoIFP(io);
875 PerlIO * const ofp = IoOFP(io);
876 Perl_warn(aTHX_ "get %" SVf " %p %p %p",
877 SVfARG(sv), (void*)io, (void*)ifp, (void*)ofp);
883 perlio_mg_clear(pTHX_ SV *sv, MAGIC *mg)
885 Perl_warn(aTHX_ "clear %" SVf, SVfARG(sv));
890 perlio_mg_free(pTHX_ SV *sv, MAGIC *mg)
892 Perl_warn(aTHX_ "free %" SVf, SVfARG(sv));
896 MGVTBL perlio_vtab = {
904 XS(XS_io_MODIFY_SCALAR_ATTRIBUTES)
907 SV * const sv = SvRV(ST(1));
908 AV * const av = newAV();
912 sv_magic(sv, MUTABLE_SV(av), PERL_MAGIC_ext, NULL, 0);
914 mg = mg_find(sv, PERL_MAGIC_ext);
915 mg->mg_virtual = &perlio_vtab;
917 Perl_warn(aTHX_ "attrib %" SVf, SVfARG(sv));
918 for (i = 2; i < items; i++) {
920 const char * const name = SvPV_const(ST(i), len);
921 SV * const layer = PerlIO_find_layer(aTHX_ name, len, 1);
923 av_push(av, SvREFCNT_inc_simple_NN(layer));
934 #endif /* USE_ATTIBUTES_FOR_PERLIO */
937 PerlIO_tab_sv(pTHX_ PerlIO_funcs *tab)
939 HV * const stash = gv_stashpvs("PerlIO::Layer", GV_ADD);
940 SV * const sv = sv_bless(newRV_noinc(newSViv(PTR2IV(tab))), stash);
944 XS(XS_PerlIO__Layer__NoWarnings)
946 /* This is used as a %SIG{__WARN__} handler to suppress warnings
947 during loading of layers.
953 PerlIO_debug("warning:%s\n",SvPV_nolen_const(ST(0)));
957 XS(XS_PerlIO__Layer__find)
963 Perl_croak(aTHX_ "Usage class->find(name[,load])");
966 const char * const name = SvPV_const(ST(1), len);
967 const bool load = (items > 2) ? SvTRUE(ST(2)) : 0;
968 PerlIO_funcs * const layer = PerlIO_find_layer(aTHX_ name, len, load);
970 (layer) ? sv_2mortal(PerlIO_tab_sv(aTHX_ layer)) :
977 PerlIO_define_layer(pTHX_ PerlIO_funcs *tab)
980 if (!PL_known_layers)
981 PL_known_layers = PerlIO_list_alloc(aTHX);
982 PerlIO_list_push(aTHX_ PL_known_layers, tab, NULL);
983 PerlIO_debug("define %s %p\n", tab->name, (void*)tab);
987 PerlIO_parse_layers(pTHX_ PerlIO_list_t *av, const char *names)
991 const char *s = names;
993 while (isSPACE(*s) || *s == ':')
998 const char *as = NULL;
1000 if (!isIDFIRST(*s)) {
1002 * Message is consistent with how attribute lists are
1003 * passed. Even though this means "foo : : bar" is
1004 * seen as an invalid separator character.
1006 const char q = ((*s == '\'') ? '"' : '\'');
1007 Perl_ck_warner(aTHX_ packWARN(WARN_LAYER),
1008 "Invalid separator character %c%c%c in PerlIO layer specification %s",
1010 SETERRNO(EINVAL, LIB_INVARG);
1015 } while (isALNUM(*e));
1024 alen = (e - 1) - as;
1031 * It's a nul terminated string, not allowed
1032 * to \ the terminating null. Anything other
1033 * character is passed over.
1043 Perl_ck_warner(aTHX_ packWARN(WARN_LAYER),
1044 "Argument list not closed for PerlIO layer \"%.*s\"",
1056 PerlIO_funcs * const layer =
1057 PerlIO_find_layer(aTHX_ s, llen, 1);
1061 arg = newSVpvn(as, alen);
1062 PerlIO_list_push(aTHX_ av, layer,
1063 (arg) ? arg : &PL_sv_undef);
1067 Perl_ck_warner(aTHX_ packWARN(WARN_LAYER), "Unknown PerlIO layer \"%.*s\"",
1080 PerlIO_default_buffer(pTHX_ PerlIO_list_t *av)
1083 PERLIO_FUNCS_DECL(*tab) = &PerlIO_perlio;
1084 #ifdef PERLIO_USING_CRLF
1087 if (PerlIO_stdio.Set_ptrcnt)
1088 tab = &PerlIO_stdio;
1090 PerlIO_debug("Pushing %s\n", tab->name);
1091 PerlIO_list_push(aTHX_ av, PerlIO_find_layer(aTHX_ tab->name, 0, 0),
1096 PerlIO_arg_fetch(PerlIO_list_t *av, IV n)
1098 return av->array[n].arg;
1102 PerlIO_layer_fetch(pTHX_ PerlIO_list_t *av, IV n, PerlIO_funcs *def)
1104 if (n >= 0 && n < av->cur) {
1105 PerlIO_debug("Layer %" IVdf " is %s\n", n,
1106 av->array[n].funcs->name);
1107 return av->array[n].funcs;
1110 Perl_croak(aTHX_ "panic: PerlIO layer array corrupt");
1115 PerlIOPop_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
1117 PERL_UNUSED_ARG(mode);
1118 PERL_UNUSED_ARG(arg);
1119 PERL_UNUSED_ARG(tab);
1120 if (PerlIOValid(f)) {
1122 PerlIO_pop(aTHX_ f);
1128 PERLIO_FUNCS_DECL(PerlIO_remove) = {
1129 sizeof(PerlIO_funcs),
1132 PERLIO_K_DUMMY | PERLIO_K_UTF8,
1152 NULL, /* get_base */
1153 NULL, /* get_bufsiz */
1156 NULL, /* set_ptrcnt */
1160 PerlIO_default_layers(pTHX)
1163 if (!PL_def_layerlist) {
1164 const char * const s = (PL_tainting) ? NULL : PerlEnv_getenv("PERLIO");
1165 PERLIO_FUNCS_DECL(*osLayer) = &PerlIO_unix;
1166 PL_def_layerlist = PerlIO_list_alloc(aTHX);
1167 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_unix));
1169 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_win32));
1171 osLayer = &PerlIO_win32;
1174 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_raw));
1175 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_perlio));
1176 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_stdio));
1177 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_crlf));
1178 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_utf8));
1179 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_remove));
1180 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_byte));
1181 PerlIO_list_push(aTHX_ PL_def_layerlist,
1182 PerlIO_find_layer(aTHX_ osLayer->name, 0, 0),
1185 PerlIO_parse_layers(aTHX_ PL_def_layerlist, s);
1188 PerlIO_default_buffer(aTHX_ PL_def_layerlist);
1191 if (PL_def_layerlist->cur < 2) {
1192 PerlIO_default_buffer(aTHX_ PL_def_layerlist);
1194 return PL_def_layerlist;
1198 Perl_boot_core_PerlIO(pTHX)
1200 #ifdef USE_ATTRIBUTES_FOR_PERLIO
1201 newXS("io::MODIFY_SCALAR_ATTRIBUTES", XS_io_MODIFY_SCALAR_ATTRIBUTES,
1204 newXS("PerlIO::Layer::find", XS_PerlIO__Layer__find, __FILE__);
1205 newXS("PerlIO::Layer::NoWarnings", XS_PerlIO__Layer__NoWarnings, __FILE__);
1209 PerlIO_default_layer(pTHX_ I32 n)
1212 PerlIO_list_t * const av = PerlIO_default_layers(aTHX);
1215 return PerlIO_layer_fetch(aTHX_ av, n, PERLIO_FUNCS_CAST(&PerlIO_stdio));
1218 #define PerlIO_default_top() PerlIO_default_layer(aTHX_ -1)
1219 #define PerlIO_default_btm() PerlIO_default_layer(aTHX_ 0)
1222 PerlIO_stdstreams(pTHX)
1226 PerlIO_init_table(aTHX);
1227 PerlIO_fdopen(0, "Ir" PERLIO_STDTEXT);
1228 PerlIO_fdopen(1, "Iw" PERLIO_STDTEXT);
1229 PerlIO_fdopen(2, "Iw" PERLIO_STDTEXT);
1234 PerlIO_push(pTHX_ PerlIO *f, PERLIO_FUNCS_DECL(*tab), const char *mode, SV *arg)
1237 if (tab->fsize != sizeof(PerlIO_funcs)) {
1239 "%s (%"UVuf") does not match %s (%"UVuf")",
1240 "PerlIO layer function table size", (UV)tab->fsize,
1241 "size expected by this perl", (UV)sizeof(PerlIO_funcs) );
1245 if (tab->size < sizeof(PerlIOl)) {
1247 "%s (%"UVuf") smaller than %s (%"UVuf")",
1248 "PerlIO layer instance size", (UV)tab->size,
1249 "size expected by this perl", (UV)sizeof(PerlIOl) );
1251 /* Real layer with a data area */
1254 Newxz(temp, tab->size, char);
1258 l->tab = (PerlIO_funcs*) tab;
1259 l->head = ((PerlIOl*)f)->head;
1261 PerlIO_debug("PerlIO_push f=%p %s %s %p\n",
1262 (void*)f, tab->name,
1263 (mode) ? mode : "(Null)", (void*)arg);
1264 if (*l->tab->Pushed &&
1266 (aTHX_ f, mode, arg, (PerlIO_funcs*) tab) != 0) {
1267 PerlIO_pop(aTHX_ f);
1276 /* Pseudo-layer where push does its own stack adjust */
1277 PerlIO_debug("PerlIO_push f=%p %s %s %p\n", (void*)f, tab->name,
1278 (mode) ? mode : "(Null)", (void*)arg);
1280 (*tab->Pushed) (aTHX_ f, mode, arg, (PerlIO_funcs*) tab) != 0) {
1288 PerlIOBase_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
1289 IV n, const char *mode, int fd, int imode, int perm,
1290 PerlIO *old, int narg, SV **args)
1292 PerlIO_funcs * const tab = PerlIO_layer_fetch(aTHX_ layers, n - 1, PerlIO_default_layer(aTHX_ 0));
1293 if (tab && tab->Open) {
1294 PerlIO* ret = (*tab->Open)(aTHX_ tab, layers, n - 1, mode, fd, imode, perm, old, narg, args);
1295 if (ret && PerlIO_push(aTHX_ ret, self, mode, PerlIOArg) == NULL) {
1301 SETERRNO(EINVAL, LIB_INVARG);
1306 PerlIOBase_binmode(pTHX_ PerlIO *f)
1308 if (PerlIOValid(f)) {
1309 /* Is layer suitable for raw stream ? */
1310 if (PerlIOBase(f)->tab && PerlIOBase(f)->tab->kind & PERLIO_K_RAW) {
1311 /* Yes - turn off UTF-8-ness, to undo UTF-8 locale effects */
1312 PerlIOBase(f)->flags &= ~PERLIO_F_UTF8;
1315 /* Not suitable - pop it */
1316 PerlIO_pop(aTHX_ f);
1324 PerlIORaw_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
1326 PERL_UNUSED_ARG(mode);
1327 PERL_UNUSED_ARG(arg);
1328 PERL_UNUSED_ARG(tab);
1330 if (PerlIOValid(f)) {
1335 * Strip all layers that are not suitable for a raw stream
1338 while (t && (l = *t)) {
1339 if (l->tab && l->tab->Binmode) {
1340 /* Has a handler - normal case */
1341 if ((*l->tab->Binmode)(aTHX_ t) == 0) {
1343 /* Layer still there - move down a layer */
1352 /* No handler - pop it */
1353 PerlIO_pop(aTHX_ t);
1356 if (PerlIOValid(f)) {
1357 PerlIO_debug(":raw f=%p :%s\n", (void*)f,
1358 PerlIOBase(f)->tab ? PerlIOBase(f)->tab->name : "(Null)");
1366 PerlIO_apply_layera(pTHX_ PerlIO *f, const char *mode,
1367 PerlIO_list_t *layers, IV n, IV max)
1371 PerlIO_funcs * const tab = PerlIO_layer_fetch(aTHX_ layers, n, NULL);
1373 if (!PerlIO_push(aTHX_ f, tab, mode, PerlIOArg)) {
1384 PerlIO_apply_layers(pTHX_ PerlIO *f, const char *mode, const char *names)
1388 save_scalar(PL_errgv);
1390 PerlIO_list_t * const layers = PerlIO_list_alloc(aTHX);
1391 code = PerlIO_parse_layers(aTHX_ layers, names);
1393 code = PerlIO_apply_layera(aTHX_ f, mode, layers, 0, layers->cur);
1395 PerlIO_list_free(aTHX_ layers);
1402 /*--------------------------------------------------------------------------------------*/
1404 * Given the abstraction above the public API functions
1408 PerlIO_binmode(pTHX_ PerlIO *f, int iotype, int mode, const char *names)
1410 PerlIO_debug("PerlIO_binmode f=%p %s %c %x %s\n", (void*)f,
1411 (PerlIOBase(f) && PerlIOBase(f)->tab) ?
1412 PerlIOBase(f)->tab->name : "(Null)",
1413 iotype, mode, (names) ? names : "(Null)");
1416 /* Do not flush etc. if (e.g.) switching encodings.
1417 if a pushed layer knows it needs to flush lower layers
1418 (for example :unix which is never going to call them)
1419 it can do the flush when it is pushed.
1421 return PerlIO_apply_layers(aTHX_ f, NULL, names) == 0 ? TRUE : FALSE;
1424 /* Fake 5.6 legacy of using this call to turn ON O_TEXT */
1425 #ifdef PERLIO_USING_CRLF
1426 /* Legacy binmode only has meaning if O_TEXT has a value distinct from
1427 O_BINARY so we can look for it in mode.
1429 if (!(mode & O_BINARY)) {
1431 /* FIXME?: Looking down the layer stack seems wrong,
1432 but is a way of reaching past (say) an encoding layer
1433 to flip CRLF-ness of the layer(s) below
1436 /* Perhaps we should turn on bottom-most aware layer
1437 e.g. Ilya's idea that UNIX TTY could serve
1439 if (PerlIOBase(f)->tab &&
1440 PerlIOBase(f)->tab->kind & PERLIO_K_CANCRLF)
1442 if (!(PerlIOBase(f)->flags & PERLIO_F_CRLF)) {
1443 /* Not in text mode - flush any pending stuff and flip it */
1445 PerlIOBase(f)->flags |= PERLIO_F_CRLF;
1447 /* Only need to turn it on in one layer so we are done */
1452 /* Not finding a CRLF aware layer presumably means we are binary
1453 which is not what was requested - so we failed
1454 We _could_ push :crlf layer but so could caller
1459 /* Legacy binmode is now _defined_ as being equivalent to pushing :raw
1460 So code that used to be here is now in PerlIORaw_pushed().
1462 return PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_raw), NULL, NULL) ? TRUE : FALSE;
1467 PerlIO__close(pTHX_ PerlIO *f)
1469 if (PerlIOValid(f)) {
1470 PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1471 if (tab && tab->Close)
1472 return (*tab->Close)(aTHX_ f);
1474 return PerlIOBase_close(aTHX_ f);
1477 SETERRNO(EBADF, SS_IVCHAN);
1483 Perl_PerlIO_close(pTHX_ PerlIO *f)
1485 const int code = PerlIO__close(aTHX_ f);
1486 while (PerlIOValid(f)) {
1487 PerlIO_pop(aTHX_ f);
1488 if (PerlIO_lockcnt(f))
1489 /* we're in use; the 'pop' deferred freeing the structure */
1496 Perl_PerlIO_fileno(pTHX_ PerlIO *f)
1499 Perl_PerlIO_or_Base(f, Fileno, fileno, -1, (aTHX_ f));
1503 static PerlIO_funcs *
1504 PerlIO_layer_from_ref(pTHX_ SV *sv)
1508 * For any scalar type load the handler which is bundled with perl
1510 if (SvTYPE(sv) < SVt_PVAV && (!isGV_with_GP(sv) || SvFAKE(sv))) {
1511 PerlIO_funcs *f = PerlIO_find_layer(aTHX_ STR_WITH_LEN("scalar"), 1);
1512 /* This isn't supposed to happen, since PerlIO::scalar is core,
1513 * but could happen anyway in smaller installs or with PAR */
1515 /* diag_listed_as: Unknown PerlIO layer "%s" */
1516 Perl_ck_warner(aTHX_ packWARN(WARN_LAYER), "Unknown PerlIO layer \"scalar\"");
1521 * For other types allow if layer is known but don't try and load it
1523 switch (SvTYPE(sv)) {
1525 return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Array"), 0);
1527 return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Hash"), 0);
1529 return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Code"), 0);
1531 return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Glob"), 0);
1538 PerlIO_resolve_layers(pTHX_ const char *layers,
1539 const char *mode, int narg, SV **args)
1542 PerlIO_list_t *def = PerlIO_default_layers(aTHX);
1545 PerlIO_stdstreams(aTHX);
1547 SV * const arg = *args;
1549 * If it is a reference but not an object see if we have a handler
1552 if (SvROK(arg) && !sv_isobject(arg)) {
1553 PerlIO_funcs * const handler = PerlIO_layer_from_ref(aTHX_ SvRV(arg));
1555 def = PerlIO_list_alloc(aTHX);
1556 PerlIO_list_push(aTHX_ def, handler, &PL_sv_undef);
1560 * Don't fail if handler cannot be found :via(...) etc. may do
1561 * something sensible else we will just stringfy and open
1566 if (!layers || !*layers)
1567 layers = Perl_PerlIO_context_layers(aTHX_ mode);
1568 if (layers && *layers) {
1571 av = PerlIO_clone_list(aTHX_ def, NULL);
1576 if (PerlIO_parse_layers(aTHX_ av, layers) == 0) {
1580 PerlIO_list_free(aTHX_ av);
1592 PerlIO_openn(pTHX_ const char *layers, const char *mode, int fd,
1593 int imode, int perm, PerlIO *f, int narg, SV **args)
1596 if (!f && narg == 1 && *args == &PL_sv_undef) {
1597 if ((f = PerlIO_tmpfile())) {
1598 if (!layers || !*layers)
1599 layers = Perl_PerlIO_context_layers(aTHX_ mode);
1600 if (layers && *layers)
1601 PerlIO_apply_layers(aTHX_ f, mode, layers);
1605 PerlIO_list_t *layera;
1607 PerlIO_funcs *tab = NULL;
1608 if (PerlIOValid(f)) {
1610 * This is "reopen" - it is not tested as perl does not use it
1614 layera = PerlIO_list_alloc(aTHX);
1617 if (l->tab && l->tab->Getarg)
1618 arg = (*l->tab->Getarg) (aTHX_ &l, NULL, 0);
1619 PerlIO_list_push(aTHX_ layera, l->tab,
1620 (arg) ? arg : &PL_sv_undef);
1622 l = *PerlIONext(&l);
1626 layera = PerlIO_resolve_layers(aTHX_ layers, mode, narg, args);
1632 * Start at "top" of layer stack
1634 n = layera->cur - 1;
1636 PerlIO_funcs * const t = PerlIO_layer_fetch(aTHX_ layera, n, NULL);
1645 * Found that layer 'n' can do opens - call it
1647 if (narg > 1 && !(tab->kind & PERLIO_K_MULTIARG)) {
1648 Perl_croak(aTHX_ "More than one argument to open(,':%s')",tab->name);
1650 PerlIO_debug("openn(%s,'%s','%s',%d,%x,%o,%p,%d,%p)\n",
1651 tab->name, layers ? layers : "(Null)", mode, fd,
1652 imode, perm, (void*)f, narg, (void*)args);
1654 f = (*tab->Open) (aTHX_ tab, layera, n, mode, fd, imode, perm,
1657 SETERRNO(EINVAL, LIB_INVARG);
1661 if (n + 1 < layera->cur) {
1663 * More layers above the one that we used to open -
1666 if (PerlIO_apply_layera(aTHX_ f, mode, layera, n + 1, layera->cur) != 0) {
1667 /* If pushing layers fails close the file */
1674 PerlIO_list_free(aTHX_ layera);
1681 Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
1683 PERL_ARGS_ASSERT_PERLIO_READ;
1685 Perl_PerlIO_or_Base(f, Read, read, -1, (aTHX_ f, vbuf, count));
1689 Perl_PerlIO_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
1691 PERL_ARGS_ASSERT_PERLIO_UNREAD;
1693 Perl_PerlIO_or_Base(f, Unread, unread, -1, (aTHX_ f, vbuf, count));
1697 Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
1699 PERL_ARGS_ASSERT_PERLIO_WRITE;
1701 Perl_PerlIO_or_fail(f, Write, -1, (aTHX_ f, vbuf, count));
1705 Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
1707 Perl_PerlIO_or_fail(f, Seek, -1, (aTHX_ f, offset, whence));
1711 Perl_PerlIO_tell(pTHX_ PerlIO *f)
1713 Perl_PerlIO_or_fail(f, Tell, -1, (aTHX_ f));
1717 Perl_PerlIO_flush(pTHX_ PerlIO *f)
1722 const PerlIO_funcs *tab = PerlIOBase(f)->tab;
1724 if (tab && tab->Flush)
1725 return (*tab->Flush) (aTHX_ f);
1727 return 0; /* If no Flush defined, silently succeed. */
1730 PerlIO_debug("Cannot flush f=%p\n", (void*)f);
1731 SETERRNO(EBADF, SS_IVCHAN);
1737 * Is it good API design to do flush-all on NULL, a potentially
1738 * erroneous input? Maybe some magical value (PerlIO*
1739 * PERLIO_FLUSH_ALL = (PerlIO*)-1;)? Yes, stdio does similar
1740 * things on fflush(NULL), but should we be bound by their design
1743 PerlIOl **table = &PL_perlio;
1746 while ((ff = *table)) {
1748 table = (PerlIOl **) (ff++);
1749 for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
1750 if (ff->next && PerlIO_flush(&(ff->next)) != 0)
1760 PerlIOBase_flush_linebuf(pTHX)
1763 PerlIOl **table = &PL_perlio;
1765 while ((f = *table)) {
1767 table = (PerlIOl **) (f++);
1768 for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
1770 && (PerlIOBase(&(f->next))->
1771 flags & (PERLIO_F_LINEBUF | PERLIO_F_CANWRITE))
1772 == (PERLIO_F_LINEBUF | PERLIO_F_CANWRITE))
1773 PerlIO_flush(&(f->next));
1780 Perl_PerlIO_fill(pTHX_ PerlIO *f)
1782 Perl_PerlIO_or_fail(f, Fill, -1, (aTHX_ f));
1786 PerlIO_isutf8(PerlIO *f)
1789 return (PerlIOBase(f)->flags & PERLIO_F_UTF8) != 0;
1791 SETERRNO(EBADF, SS_IVCHAN);
1797 Perl_PerlIO_eof(pTHX_ PerlIO *f)
1799 Perl_PerlIO_or_Base(f, Eof, eof, -1, (aTHX_ f));
1803 Perl_PerlIO_error(pTHX_ PerlIO *f)
1805 Perl_PerlIO_or_Base(f, Error, error, -1, (aTHX_ f));
1809 Perl_PerlIO_clearerr(pTHX_ PerlIO *f)
1811 Perl_PerlIO_or_Base_void(f, Clearerr, clearerr, (aTHX_ f));
1815 Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f)
1817 Perl_PerlIO_or_Base_void(f, Setlinebuf, setlinebuf, (aTHX_ f));
1821 PerlIO_has_base(PerlIO *f)
1823 if (PerlIOValid(f)) {
1824 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1827 return (tab->Get_base != NULL);
1834 PerlIO_fast_gets(PerlIO *f)
1836 if (PerlIOValid(f)) {
1837 if (PerlIOBase(f)->flags & PERLIO_F_FASTGETS) {
1838 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1841 return (tab->Set_ptrcnt != NULL);
1849 PerlIO_has_cntptr(PerlIO *f)
1851 if (PerlIOValid(f)) {
1852 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1855 return (tab->Get_ptr != NULL && tab->Get_cnt != NULL);
1862 PerlIO_canset_cnt(PerlIO *f)
1864 if (PerlIOValid(f)) {
1865 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1868 return (tab->Set_ptrcnt != NULL);
1875 Perl_PerlIO_get_base(pTHX_ PerlIO *f)
1877 Perl_PerlIO_or_fail(f, Get_base, NULL, (aTHX_ f));
1881 Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f)
1883 Perl_PerlIO_or_fail(f, Get_bufsiz, -1, (aTHX_ f));
1887 Perl_PerlIO_get_ptr(pTHX_ PerlIO *f)
1889 Perl_PerlIO_or_fail(f, Get_ptr, NULL, (aTHX_ f));
1893 Perl_PerlIO_get_cnt(pTHX_ PerlIO *f)
1895 Perl_PerlIO_or_fail(f, Get_cnt, -1, (aTHX_ f));
1899 Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, int cnt)
1901 Perl_PerlIO_or_fail_void(f, Set_ptrcnt, (aTHX_ f, NULL, cnt));
1905 Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, int cnt)
1907 Perl_PerlIO_or_fail_void(f, Set_ptrcnt, (aTHX_ f, ptr, cnt));
1911 /*--------------------------------------------------------------------------------------*/
1913 * utf8 and raw dummy layers
1917 PerlIOUtf8_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
1919 PERL_UNUSED_CONTEXT;
1920 PERL_UNUSED_ARG(mode);
1921 PERL_UNUSED_ARG(arg);
1922 if (PerlIOValid(f)) {
1923 if (tab && tab->kind & PERLIO_K_UTF8)
1924 PerlIOBase(f)->flags |= PERLIO_F_UTF8;
1926 PerlIOBase(f)->flags &= ~PERLIO_F_UTF8;
1932 PERLIO_FUNCS_DECL(PerlIO_utf8) = {
1933 sizeof(PerlIO_funcs),
1936 PERLIO_K_DUMMY | PERLIO_K_UTF8 | PERLIO_K_MULTIARG,
1956 NULL, /* get_base */
1957 NULL, /* get_bufsiz */
1960 NULL, /* set_ptrcnt */
1963 PERLIO_FUNCS_DECL(PerlIO_byte) = {
1964 sizeof(PerlIO_funcs),
1967 PERLIO_K_DUMMY | PERLIO_K_MULTIARG,
1987 NULL, /* get_base */
1988 NULL, /* get_bufsiz */
1991 NULL, /* set_ptrcnt */
1994 PERLIO_FUNCS_DECL(PerlIO_raw) = {
1995 sizeof(PerlIO_funcs),
2018 NULL, /* get_base */
2019 NULL, /* get_bufsiz */
2022 NULL, /* set_ptrcnt */
2024 /*--------------------------------------------------------------------------------------*/
2025 /*--------------------------------------------------------------------------------------*/
2027 * "Methods" of the "base class"
2031 PerlIOBase_fileno(pTHX_ PerlIO *f)
2033 return PerlIOValid(f) ? PerlIO_fileno(PerlIONext(f)) : -1;
2037 PerlIO_modestr(PerlIO * f, char *buf)
2040 if (PerlIOValid(f)) {
2041 const IV flags = PerlIOBase(f)->flags;
2042 if (flags & PERLIO_F_APPEND) {
2044 if (flags & PERLIO_F_CANREAD) {
2048 else if (flags & PERLIO_F_CANREAD) {
2050 if (flags & PERLIO_F_CANWRITE)
2053 else if (flags & PERLIO_F_CANWRITE) {
2055 if (flags & PERLIO_F_CANREAD) {
2059 #ifdef PERLIO_USING_CRLF
2060 if (!(flags & PERLIO_F_CRLF))
2070 PerlIOBase_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
2072 PerlIOl * const l = PerlIOBase(f);
2073 PERL_UNUSED_CONTEXT;
2074 PERL_UNUSED_ARG(arg);
2076 l->flags &= ~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE |
2077 PERLIO_F_TRUNCATE | PERLIO_F_APPEND);
2078 if (tab && tab->Set_ptrcnt != NULL)
2079 l->flags |= PERLIO_F_FASTGETS;
2081 if (*mode == IoTYPE_NUMERIC || *mode == IoTYPE_IMPLICIT)
2085 l->flags |= PERLIO_F_CANREAD;
2088 l->flags |= PERLIO_F_APPEND | PERLIO_F_CANWRITE;
2091 l->flags |= PERLIO_F_TRUNCATE | PERLIO_F_CANWRITE;
2094 SETERRNO(EINVAL, LIB_INVARG);
2100 l->flags |= PERLIO_F_CANREAD | PERLIO_F_CANWRITE;
2103 l->flags &= ~PERLIO_F_CRLF;
2106 l->flags |= PERLIO_F_CRLF;
2109 SETERRNO(EINVAL, LIB_INVARG);
2116 l->flags |= l->next->flags &
2117 (PERLIO_F_CANREAD | PERLIO_F_CANWRITE | PERLIO_F_TRUNCATE |
2122 PerlIO_debug("PerlIOBase_pushed f=%p %s %s fl=%08" UVxf " (%s)\n",
2123 (void*)f, PerlIOBase(f)->tab->name, (omode) ? omode : "(Null)",
2124 l->flags, PerlIO_modestr(f, temp));
2130 PerlIOBase_popped(pTHX_ PerlIO *f)
2132 PERL_UNUSED_CONTEXT;
2138 PerlIOBase_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
2141 * Save the position as current head considers it
2143 const Off_t old = PerlIO_tell(f);
2144 PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_pending), "r", NULL);
2145 PerlIOSelf(f, PerlIOBuf)->posn = old;
2146 return PerlIOBuf_unread(aTHX_ f, vbuf, count);
2150 PerlIOBase_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
2152 STDCHAR *buf = (STDCHAR *) vbuf;
2154 if (!(PerlIOBase(f)->flags & PERLIO_F_CANREAD)) {
2155 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
2156 SETERRNO(EBADF, SS_IVCHAN);
2162 SSize_t avail = PerlIO_get_cnt(f);
2165 take = ((SSize_t)count < avail) ? (SSize_t)count : avail;
2167 STDCHAR *ptr = PerlIO_get_ptr(f);
2168 Copy(ptr, buf, take, STDCHAR);
2169 PerlIO_set_ptrcnt(f, ptr + take, (avail -= take));
2172 if (avail == 0) /* set_ptrcnt could have reset avail */
2175 if (count > 0 && avail <= 0) {
2176 if (PerlIO_fill(f) != 0)
2181 return (buf - (STDCHAR *) vbuf);
2187 PerlIOBase_noop_ok(pTHX_ PerlIO *f)
2189 PERL_UNUSED_CONTEXT;
2195 PerlIOBase_noop_fail(pTHX_ PerlIO *f)
2197 PERL_UNUSED_CONTEXT;
2203 PerlIOBase_close(pTHX_ PerlIO *f)
2206 if (PerlIOValid(f)) {
2207 PerlIO *n = PerlIONext(f);
2208 code = PerlIO_flush(f);
2209 PerlIOBase(f)->flags &=
2210 ~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE | PERLIO_F_OPEN);
2211 while (PerlIOValid(n)) {
2212 const PerlIO_funcs * const tab = PerlIOBase(n)->tab;
2213 if (tab && tab->Close) {
2214 if ((*tab->Close)(aTHX_ n) != 0)
2219 PerlIOBase(n)->flags &=
2220 ~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE | PERLIO_F_OPEN);
2226 SETERRNO(EBADF, SS_IVCHAN);
2232 PerlIOBase_eof(pTHX_ PerlIO *f)
2234 PERL_UNUSED_CONTEXT;
2235 if (PerlIOValid(f)) {
2236 return (PerlIOBase(f)->flags & PERLIO_F_EOF) != 0;
2242 PerlIOBase_error(pTHX_ PerlIO *f)
2244 PERL_UNUSED_CONTEXT;
2245 if (PerlIOValid(f)) {
2246 return (PerlIOBase(f)->flags & PERLIO_F_ERROR) != 0;
2252 PerlIOBase_clearerr(pTHX_ PerlIO *f)
2254 if (PerlIOValid(f)) {
2255 PerlIO * const n = PerlIONext(f);
2256 PerlIOBase(f)->flags &= ~(PERLIO_F_ERROR | PERLIO_F_EOF);
2263 PerlIOBase_setlinebuf(pTHX_ PerlIO *f)
2265 PERL_UNUSED_CONTEXT;
2266 if (PerlIOValid(f)) {
2267 PerlIOBase(f)->flags |= PERLIO_F_LINEBUF;
2272 PerlIO_sv_dup(pTHX_ SV *arg, CLONE_PARAMS *param)
2278 arg = sv_dup(arg, param);
2279 SvREFCNT_inc_simple_void_NN(arg);
2283 return newSVsv(arg);
2286 PERL_UNUSED_ARG(param);
2287 return newSVsv(arg);
2292 PerlIOBase_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
2294 PerlIO * const nexto = PerlIONext(o);
2295 if (PerlIOValid(nexto)) {
2296 const PerlIO_funcs * const tab = PerlIOBase(nexto)->tab;
2297 if (tab && tab->Dup)
2298 f = (*tab->Dup)(aTHX_ f, nexto, param, flags);
2300 f = PerlIOBase_dup(aTHX_ f, nexto, param, flags);
2303 PerlIO_funcs * const self = PerlIOBase(o)->tab;
2306 PerlIO_debug("PerlIOBase_dup %s f=%p o=%p param=%p\n",
2307 self ? self->name : "(Null)",
2308 (void*)f, (void*)o, (void*)param);
2309 if (self && self->Getarg)
2310 arg = (*self->Getarg)(aTHX_ o, param, flags);
2311 f = PerlIO_push(aTHX_ f, self, PerlIO_modestr(o,buf), arg);
2312 if (PerlIOBase(o)->flags & PERLIO_F_UTF8)
2313 PerlIOBase(f)->flags |= PERLIO_F_UTF8;
2319 /* PL_perlio_fd_refcnt[] is in intrpvar.h */
2321 /* Must be called with PL_perlio_mutex locked. */
2323 S_more_refcounted_fds(pTHX_ const int new_fd) {
2325 const int old_max = PL_perlio_fd_refcnt_size;
2326 const int new_max = 16 + (new_fd & ~15);
2329 PerlIO_debug("More fds - old=%d, need %d, new=%d\n",
2330 old_max, new_fd, new_max);
2332 if (new_fd < old_max) {
2336 assert (new_max > new_fd);
2338 /* Use plain realloc() since we need this memory to be really
2339 * global and visible to all the interpreters and/or threads. */
2340 new_array = (int*) realloc(PL_perlio_fd_refcnt, new_max * sizeof(int));
2344 MUTEX_UNLOCK(&PL_perlio_mutex);
2346 /* Can't use PerlIO to write as it allocates memory */
2347 PerlLIO_write(PerlIO_fileno(Perl_error_log),
2348 PL_no_mem, strlen(PL_no_mem));
2352 PL_perlio_fd_refcnt_size = new_max;
2353 PL_perlio_fd_refcnt = new_array;
2355 PerlIO_debug("Zeroing %p, %d\n",
2356 (void*)(new_array + old_max),
2359 Zero(new_array + old_max, new_max - old_max, int);
2366 /* MUTEX_INIT(&PL_perlio_mutex) is done in PERL_SYS_INIT3(). */
2367 PERL_UNUSED_CONTEXT;
2371 PerlIOUnix_refcnt_inc(int fd)
2378 MUTEX_LOCK(&PL_perlio_mutex);
2380 if (fd >= PL_perlio_fd_refcnt_size)
2381 S_more_refcounted_fds(aTHX_ fd);
2383 PL_perlio_fd_refcnt[fd]++;
2384 if (PL_perlio_fd_refcnt[fd] <= 0) {
2385 /* diag_listed_as: refcnt_inc: fd %d%s */
2386 Perl_croak(aTHX_ "refcnt_inc: fd %d: %d <= 0\n",
2387 fd, PL_perlio_fd_refcnt[fd]);
2389 PerlIO_debug("refcnt_inc: fd %d refcnt=%d\n",
2390 fd, PL_perlio_fd_refcnt[fd]);
2393 MUTEX_UNLOCK(&PL_perlio_mutex);
2396 /* diag_listed_as: refcnt_inc: fd %d%s */
2397 Perl_croak(aTHX_ "refcnt_inc: fd %d < 0\n", fd);
2402 PerlIOUnix_refcnt_dec(int fd)
2409 MUTEX_LOCK(&PL_perlio_mutex);
2411 if (fd >= PL_perlio_fd_refcnt_size) {
2412 /* diag_listed_as: refcnt_dec: fd %d%s */
2413 Perl_croak(aTHX_ "refcnt_dec: fd %d >= refcnt_size %d\n",
2414 fd, PL_perlio_fd_refcnt_size);
2416 if (PL_perlio_fd_refcnt[fd] <= 0) {
2417 /* diag_listed_as: refcnt_dec: fd %d%s */
2418 Perl_croak(aTHX_ "refcnt_dec: fd %d: %d <= 0\n",
2419 fd, PL_perlio_fd_refcnt[fd]);
2421 cnt = --PL_perlio_fd_refcnt[fd];
2422 PerlIO_debug("refcnt_dec: fd %d refcnt=%d\n", fd, cnt);
2424 MUTEX_UNLOCK(&PL_perlio_mutex);
2427 /* diag_listed_as: refcnt_dec: fd %d%s */
2428 Perl_croak(aTHX_ "refcnt_dec: fd %d < 0\n", fd);
2434 PerlIOUnix_refcnt(int fd)
2441 MUTEX_LOCK(&PL_perlio_mutex);
2443 if (fd >= PL_perlio_fd_refcnt_size) {
2444 /* diag_listed_as: refcnt: fd %d%s */
2445 Perl_croak(aTHX_ "refcnt: fd %d >= refcnt_size %d\n",
2446 fd, PL_perlio_fd_refcnt_size);
2448 if (PL_perlio_fd_refcnt[fd] <= 0) {
2449 /* diag_listed_as: refcnt: fd %d%s */
2450 Perl_croak(aTHX_ "refcnt: fd %d: %d <= 0\n",
2451 fd, PL_perlio_fd_refcnt[fd]);
2453 cnt = PL_perlio_fd_refcnt[fd];
2455 MUTEX_UNLOCK(&PL_perlio_mutex);
2458 /* diag_listed_as: refcnt: fd %d%s */
2459 Perl_croak(aTHX_ "refcnt: fd %d < 0\n", fd);
2465 PerlIO_cleanup(pTHX)
2470 PerlIO_debug("Cleanup layers for %p\n",(void*)aTHX);
2472 PerlIO_debug("Cleanup layers\n");
2475 /* Raise STDIN..STDERR refcount so we don't close them */
2476 for (i=0; i < 3; i++)
2477 PerlIOUnix_refcnt_inc(i);
2478 PerlIO_cleantable(aTHX_ &PL_perlio);
2479 /* Restore STDIN..STDERR refcount */
2480 for (i=0; i < 3; i++)
2481 PerlIOUnix_refcnt_dec(i);
2483 if (PL_known_layers) {
2484 PerlIO_list_free(aTHX_ PL_known_layers);
2485 PL_known_layers = NULL;
2487 if (PL_def_layerlist) {
2488 PerlIO_list_free(aTHX_ PL_def_layerlist);
2489 PL_def_layerlist = NULL;
2493 void PerlIO_teardown(void) /* Call only from PERL_SYS_TERM(). */
2497 /* XXX we can't rely on an interpreter being present at this late stage,
2498 XXX so we can't use a function like PerlLIO_write that relies on one
2499 being present (at least in win32) :-(.
2504 /* By now all filehandles should have been closed, so any
2505 * stray (non-STD-)filehandles indicate *possible* (PerlIO)
2507 #define PERLIO_TEARDOWN_MESSAGE_BUF_SIZE 64
2508 #define PERLIO_TEARDOWN_MESSAGE_FD 2
2509 char buf[PERLIO_TEARDOWN_MESSAGE_BUF_SIZE];
2511 for (i = 3; i < PL_perlio_fd_refcnt_size; i++) {
2512 if (PL_perlio_fd_refcnt[i]) {
2514 my_snprintf(buf, sizeof(buf),
2515 "PerlIO_teardown: fd %d refcnt=%d\n",
2516 i, PL_perlio_fd_refcnt[i]);
2517 PerlLIO_write(PERLIO_TEARDOWN_MESSAGE_FD, buf, len);
2523 /* Not bothering with PL_perlio_mutex since by now
2524 * all the interpreters are gone. */
2525 if (PL_perlio_fd_refcnt_size /* Assuming initial size of zero. */
2526 && PL_perlio_fd_refcnt) {
2527 free(PL_perlio_fd_refcnt); /* To match realloc() in S_more_refcounted_fds(). */
2528 PL_perlio_fd_refcnt = NULL;
2529 PL_perlio_fd_refcnt_size = 0;
2533 /*--------------------------------------------------------------------------------------*/
2535 * Bottom-most level for UNIX-like case
2539 struct _PerlIO base; /* The generic part */
2540 int fd; /* UNIX like file descriptor */
2541 int oflags; /* open/fcntl flags */
2545 S_lockcnt_dec(pTHX_ const void* f)
2547 PerlIO_lockcnt((PerlIO*)f)--;
2551 /* call the signal handler, and if that handler happens to clear
2552 * this handle, free what we can and return true */
2555 S_perlio_async_run(pTHX_ PerlIO* f) {
2557 SAVEDESTRUCTOR_X(S_lockcnt_dec, (void*)f);
2558 PerlIO_lockcnt(f)++;
2560 if ( !(PerlIOBase(f)->flags & PERLIO_F_CLEARED) ) {
2564 /* we've just run some perl-level code that could have done
2565 * anything, including closing the file or clearing this layer.
2566 * If so, free any lower layers that have already been
2567 * cleared, then return an error. */
2568 while (PerlIOValid(f) &&
2569 (PerlIOBase(f)->flags & PERLIO_F_CLEARED))
2571 const PerlIOl *l = *f;
2580 PerlIOUnix_oflags(const char *mode)
2583 if (*mode == IoTYPE_IMPLICIT || *mode == IoTYPE_NUMERIC)
2588 if (*++mode == '+') {
2595 oflags = O_CREAT | O_TRUNC;
2596 if (*++mode == '+') {
2605 oflags = O_CREAT | O_APPEND;
2606 if (*++mode == '+') {
2619 else if (*mode == 't') {
2621 oflags &= ~O_BINARY;
2625 * Always open in binary mode
2628 if (*mode || oflags == -1) {
2629 SETERRNO(EINVAL, LIB_INVARG);
2636 PerlIOUnix_fileno(pTHX_ PerlIO *f)
2638 PERL_UNUSED_CONTEXT;
2639 return PerlIOSelf(f, PerlIOUnix)->fd;
2643 PerlIOUnix_setfd(pTHX_ PerlIO *f, int fd, int imode)
2645 PerlIOUnix * const s = PerlIOSelf(f, PerlIOUnix);
2648 if (PerlLIO_fstat(fd, &st) == 0) {
2649 if (!S_ISREG(st.st_mode)) {
2650 PerlIO_debug("%d is not regular file\n",fd);
2651 PerlIOBase(f)->flags |= PERLIO_F_NOTREG;
2654 PerlIO_debug("%d _is_ a regular file\n",fd);
2660 PerlIOUnix_refcnt_inc(fd);
2661 PERL_UNUSED_CONTEXT;
2665 PerlIOUnix_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
2667 IV code = PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
2668 if (*PerlIONext(f)) {
2669 /* We never call down so do any pending stuff now */
2670 PerlIO_flush(PerlIONext(f));
2672 * XXX could (or should) we retrieve the oflags from the open file
2673 * handle rather than believing the "mode" we are passed in? XXX
2674 * Should the value on NULL mode be 0 or -1?
2676 PerlIOUnix_setfd(aTHX_ f, PerlIO_fileno(PerlIONext(f)),
2677 mode ? PerlIOUnix_oflags(mode) : -1);
2679 PerlIOBase(f)->flags |= PERLIO_F_OPEN;
2685 PerlIOUnix_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
2687 const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
2689 PERL_UNUSED_CONTEXT;
2690 if (PerlIOBase(f)->flags & PERLIO_F_NOTREG) {
2692 SETERRNO(ESPIPE, LIB_INVARG);
2694 SETERRNO(EINVAL, LIB_INVARG);
2698 new_loc = PerlLIO_lseek(fd, offset, whence);
2699 if (new_loc == (Off_t) - 1)
2701 PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
2706 PerlIOUnix_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
2707 IV n, const char *mode, int fd, int imode,
2708 int perm, PerlIO *f, int narg, SV **args)
2710 if (PerlIOValid(f)) {
2711 if (PerlIOBase(f)->tab && PerlIOBase(f)->flags & PERLIO_F_OPEN)
2712 (*PerlIOBase(f)->tab->Close)(aTHX_ f);
2715 if (*mode == IoTYPE_NUMERIC)
2718 imode = PerlIOUnix_oflags(mode);
2720 perm = 0777; /* preserve RMS defaults, ACL inheritance, etc. */
2726 const char *path = SvPV_nolen_const(*args);
2727 fd = PerlLIO_open3(path, imode, perm);
2731 if (*mode == IoTYPE_IMPLICIT)
2734 f = PerlIO_allocate(aTHX);
2736 if (!PerlIOValid(f)) {
2737 if (!(f = PerlIO_push(aTHX_ f, self, mode, PerlIOArg))) {
2741 PerlIOUnix_setfd(aTHX_ f, fd, imode);
2742 PerlIOBase(f)->flags |= PERLIO_F_OPEN;
2743 if (*mode == IoTYPE_APPEND)
2744 PerlIOUnix_seek(aTHX_ f, 0, SEEK_END);
2751 * FIXME: pop layers ???
2759 PerlIOUnix_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
2761 const PerlIOUnix * const os = PerlIOSelf(o, PerlIOUnix);
2763 if (flags & PERLIO_DUP_FD) {
2764 fd = PerlLIO_dup(fd);
2767 f = PerlIOBase_dup(aTHX_ f, o, param, flags);
2769 /* If all went well overwrite fd in dup'ed lay with the dup()'ed fd */
2770 PerlIOUnix_setfd(aTHX_ f, fd, os->oflags);
2779 PerlIOUnix_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
2783 if (PerlIO_lockcnt(f)) /* in use: abort ungracefully */
2785 fd = PerlIOSelf(f, PerlIOUnix)->fd;
2786 #ifdef PERLIO_STD_SPECIAL
2788 return PERLIO_STD_IN(fd, vbuf, count);
2790 if (!(PerlIOBase(f)->flags & PERLIO_F_CANREAD) ||
2791 PerlIOBase(f)->flags & (PERLIO_F_EOF|PERLIO_F_ERROR)) {
2795 const SSize_t len = PerlLIO_read(fd, vbuf, count);
2796 if (len >= 0 || errno != EINTR) {
2798 if (errno != EAGAIN) {
2799 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
2802 else if (len == 0 && count != 0) {
2803 PerlIOBase(f)->flags |= PERLIO_F_EOF;
2809 if (PL_sig_pending && S_perlio_async_run(aTHX_ f))
2816 PerlIOUnix_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
2820 if (PerlIO_lockcnt(f)) /* in use: abort ungracefully */
2822 fd = PerlIOSelf(f, PerlIOUnix)->fd;
2823 #ifdef PERLIO_STD_SPECIAL
2824 if (fd == 1 || fd == 2)
2825 return PERLIO_STD_OUT(fd, vbuf, count);
2828 const SSize_t len = PerlLIO_write(fd, vbuf, count);
2829 if (len >= 0 || errno != EINTR) {
2831 if (errno != EAGAIN) {
2832 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
2838 if (PL_sig_pending && S_perlio_async_run(aTHX_ f))
2845 PerlIOUnix_tell(pTHX_ PerlIO *f)
2847 PERL_UNUSED_CONTEXT;
2849 return PerlLIO_lseek(PerlIOSelf(f, PerlIOUnix)->fd, 0, SEEK_CUR);
2854 PerlIOUnix_close(pTHX_ PerlIO *f)
2857 const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
2859 if (PerlIOBase(f)->flags & PERLIO_F_OPEN) {
2860 if (PerlIOUnix_refcnt_dec(fd) > 0) {
2861 PerlIOBase(f)->flags &= ~PERLIO_F_OPEN;
2866 SETERRNO(EBADF,SS_IVCHAN);
2869 while (PerlLIO_close(fd) != 0) {
2870 if (errno != EINTR) {
2875 if (PL_sig_pending && S_perlio_async_run(aTHX_ f))
2879 PerlIOBase(f)->flags &= ~PERLIO_F_OPEN;
2884 PERLIO_FUNCS_DECL(PerlIO_unix) = {
2885 sizeof(PerlIO_funcs),
2892 PerlIOBase_binmode, /* binmode */
2902 PerlIOBase_noop_ok, /* flush */
2903 PerlIOBase_noop_fail, /* fill */
2906 PerlIOBase_clearerr,
2907 PerlIOBase_setlinebuf,
2908 NULL, /* get_base */
2909 NULL, /* get_bufsiz */
2912 NULL, /* set_ptrcnt */
2915 /*--------------------------------------------------------------------------------------*/
2920 #if defined(VMS) && !defined(STDIO_BUFFER_WRITABLE)
2921 /* perl5.8 - This ensures the last minute VMS ungetc fix is not
2922 broken by the last second glibc 2.3 fix
2924 #define STDIO_BUFFER_WRITABLE
2929 struct _PerlIO base;
2930 FILE *stdio; /* The stream */
2934 PerlIOStdio_fileno(pTHX_ PerlIO *f)
2936 PERL_UNUSED_CONTEXT;
2938 if (PerlIOValid(f)) {
2939 FILE * const s = PerlIOSelf(f, PerlIOStdio)->stdio;
2941 return PerlSIO_fileno(s);
2948 PerlIOStdio_mode(const char *mode, char *tmode)
2950 char * const ret = tmode;
2956 #if defined(PERLIO_USING_CRLF) || defined(__CYGWIN__)
2964 PerlIOStdio_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
2967 if (PerlIOValid(f) && PerlIOValid(n = PerlIONext(f))) {
2968 PerlIO_funcs * const toptab = PerlIOBase(n)->tab;
2969 if (toptab == tab) {
2970 /* Top is already stdio - pop self (duplicate) and use original */
2971 PerlIO_pop(aTHX_ f);
2974 const int fd = PerlIO_fileno(n);
2977 if (fd >= 0 && (stdio = PerlSIO_fdopen(fd,
2978 mode = PerlIOStdio_mode(mode, tmode)))) {
2979 PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
2980 /* We never call down so do any pending stuff now */
2981 PerlIO_flush(PerlIONext(f));
2988 return PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
2993 PerlIO_importFILE(FILE *stdio, const char *mode)
2999 if (!mode || !*mode) {
3000 /* We need to probe to see how we can open the stream
3001 so start with read/write and then try write and read
3002 we dup() so that we can fclose without loosing the fd.
3004 Note that the errno value set by a failing fdopen
3005 varies between stdio implementations.
3007 const int fd = PerlLIO_dup(fileno(stdio));
3008 FILE *f2 = PerlSIO_fdopen(fd, (mode = "r+"));
3010 f2 = PerlSIO_fdopen(fd, (mode = "w"));
3013 f2 = PerlSIO_fdopen(fd, (mode = "r"));
3016 /* Don't seem to be able to open */
3022 if ((f = PerlIO_push(aTHX_(f = PerlIO_allocate(aTHX)), PERLIO_FUNCS_CAST(&PerlIO_stdio), mode, NULL))) {
3023 s = PerlIOSelf(f, PerlIOStdio);
3025 PerlIOUnix_refcnt_inc(fileno(stdio));
3032 PerlIOStdio_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
3033 IV n, const char *mode, int fd, int imode,
3034 int perm, PerlIO *f, int narg, SV **args)
3037 if (PerlIOValid(f)) {
3038 const char * const path = SvPV_nolen_const(*args);
3039 PerlIOStdio * const s = PerlIOSelf(f, PerlIOStdio);
3041 PerlIOUnix_refcnt_dec(fileno(s->stdio));
3042 stdio = PerlSIO_freopen(path, (mode = PerlIOStdio_mode(mode, tmode)),
3047 PerlIOUnix_refcnt_inc(fileno(s->stdio));
3052 const char * const path = SvPV_nolen_const(*args);
3053 if (*mode == IoTYPE_NUMERIC) {
3055 fd = PerlLIO_open3(path, imode, perm);
3059 bool appended = FALSE;
3061 /* Cygwin wants its 'b' early. */
3063 mode = PerlIOStdio_mode(mode, tmode);
3065 stdio = PerlSIO_fopen(path, mode);
3068 f = PerlIO_allocate(aTHX);
3071 mode = PerlIOStdio_mode(mode, tmode);
3072 f = PerlIO_push(aTHX_ f, self, mode, PerlIOArg);
3074 PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
3075 PerlIOUnix_refcnt_inc(fileno(stdio));
3077 PerlSIO_fclose(stdio);
3089 if (*mode == IoTYPE_IMPLICIT) {
3096 stdio = PerlSIO_stdin;
3099 stdio = PerlSIO_stdout;
3102 stdio = PerlSIO_stderr;
3107 stdio = PerlSIO_fdopen(fd, mode =
3108 PerlIOStdio_mode(mode, tmode));
3112 f = PerlIO_allocate(aTHX);
3114 if ((f = PerlIO_push(aTHX_ f, self, mode, PerlIOArg))) {
3115 PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
3116 PerlIOUnix_refcnt_inc(fileno(stdio));
3126 PerlIOStdio_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
3128 /* This assumes no layers underneath - which is what
3129 happens, but is not how I remember it. NI-S 2001/10/16
3131 if ((f = PerlIOBase_dup(aTHX_ f, o, param, flags))) {
3132 FILE *stdio = PerlIOSelf(o, PerlIOStdio)->stdio;
3133 const int fd = fileno(stdio);
3135 if (flags & PERLIO_DUP_FD) {
3136 const int dfd = PerlLIO_dup(fileno(stdio));
3138 stdio = PerlSIO_fdopen(dfd, PerlIO_modestr(o,mode));
3143 /* FIXME: To avoid messy error recovery if dup fails
3144 re-use the existing stdio as though flag was not set
3148 stdio = PerlSIO_fdopen(fd, PerlIO_modestr(o,mode));
3150 PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
3152 PerlIOUnix_refcnt_inc(fileno(stdio));
3159 PerlIOStdio_invalidate_fileno(pTHX_ FILE *f)
3161 PERL_UNUSED_CONTEXT;
3163 /* XXX this could use PerlIO_canset_fileno() and
3164 * PerlIO_set_fileno() support from Configure
3166 # if defined(__UCLIBC__)
3167 /* uClibc must come before glibc because it defines __GLIBC__ as well. */
3170 # elif defined(__GLIBC__)
3171 /* There may be a better way for GLIBC:
3172 - libio.h defines a flag to not close() on cleanup
3176 # elif defined(__sun__)
3179 # elif defined(__hpux)
3183 /* Next one ->_file seems to be a reasonable fallback, i.e. if
3184 your platform does not have special entry try this one.
3185 [For OSF only have confirmation for Tru64 (alpha)
3186 but assume other OSFs will be similar.]
3188 # elif defined(_AIX) || defined(__osf__) || defined(__irix__)
3191 # elif defined(__FreeBSD__)
3192 /* There may be a better way on FreeBSD:
3193 - we could insert a dummy func in the _close function entry
3194 f->_close = (int (*)(void *)) dummy_close;
3198 # elif defined(__OpenBSD__)
3199 /* There may be a better way on OpenBSD:
3200 - we could insert a dummy func in the _close function entry
3201 f->_close = (int (*)(void *)) dummy_close;
3205 # elif defined(__EMX__)
3206 /* f->_flags &= ~_IOOPEN; */ /* Will leak stream->_buffer */
3209 # elif defined(__CYGWIN__)
3210 /* There may be a better way on CYGWIN:
3211 - we could insert a dummy func in the _close function entry
3212 f->_close = (int (*)(void *)) dummy_close;
3216 # elif defined(WIN32)
3217 # if defined(UNDER_CE)
3218 /* WIN_CE does not have access to FILE internals, it hardly has FILE
3227 /* Sarathy's code did this - we fall back to a dup/dup2 hack
3228 (which isn't thread safe) instead
3230 # error "Don't know how to set FILE.fileno on your platform"
3238 PerlIOStdio_close(pTHX_ PerlIO *f)
3240 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3246 const int fd = fileno(stdio);
3254 #ifdef SOCKS5_VERSION_NAME
3255 /* Socks lib overrides close() but stdio isn't linked to
3256 that library (though we are) - so we must call close()
3257 on sockets on stdio's behalf.
3260 Sock_size_t optlen = sizeof(int);
3261 if (getsockopt(fd, SOL_SOCKET, SO_TYPE, (void *) &optval, &optlen) == 0)
3264 /* Test for -1, as *BSD stdio (at least) on fclose sets the FILE* such
3265 that a subsequent fileno() on it returns -1. Don't want to croak()
3266 from within PerlIOUnix_refcnt_dec() if some buggy caller code is
3267 trying to close an already closed handle which somehow it still has
3268 a reference to. (via.xs, I'm looking at you). */
3269 if (fd != -1 && PerlIOUnix_refcnt_dec(fd) > 0) {
3270 /* File descriptor still in use */
3274 /* For STD* handles, don't close stdio, since we shared the FILE *, too. */
3275 if (stdio == stdin) /* Some stdios are buggy fflush-ing inputs */
3277 if (stdio == stdout || stdio == stderr)
3278 return PerlIO_flush(f);
3279 /* Tricky - must fclose(stdio) to free memory but not close(fd)
3280 Use Sarathy's trick from maint-5.6 to invalidate the
3281 fileno slot of the FILE *
3283 result = PerlIO_flush(f);
3285 invalidate = PerlIOStdio_invalidate_fileno(aTHX_ stdio);
3288 MUTEX_LOCK(&PL_perlio_mutex);
3289 /* Right. We need a mutex here because for a brief while we
3290 will have the situation that fd is actually closed. Hence if
3291 a second thread were to get into this block, its dup() would
3292 likely return our fd as its dupfd. (after all, it is closed)
3293 Then if we get to the dup2() first, we blat the fd back
3294 (messing up its temporary as a side effect) only for it to
3295 then close its dupfd (== our fd) in its close(dupfd) */
3297 /* There is, of course, a race condition, that any other thread
3298 trying to input/output/whatever on this fd will be stuffed
3299 for the duration of this little manoeuvrer. Perhaps we
3300 should hold an IO mutex for the duration of every IO
3301 operation if we know that invalidate doesn't work on this
3302 platform, but that would suck, and could kill performance.
3304 Except that correctness trumps speed.
3305 Advice from klortho #11912. */
3307 dupfd = PerlLIO_dup(fd);
3310 MUTEX_UNLOCK(&PL_perlio_mutex);
3311 /* Oh cXap. This isn't going to go well. Not sure if we can
3312 recover from here, or if closing this particular FILE *
3313 is a good idea now. */
3318 SAVE_ERRNO; /* This is here only to silence compiler warnings */
3320 result = PerlSIO_fclose(stdio);
3321 /* We treat error from stdio as success if we invalidated
3322 errno may NOT be expected EBADF
3324 if (invalidate && result != 0) {
3328 #ifdef SOCKS5_VERSION_NAME
3329 /* in SOCKS' case, let close() determine return value */
3333 PerlLIO_dup2(dupfd,fd);
3334 PerlLIO_close(dupfd);
3336 MUTEX_UNLOCK(&PL_perlio_mutex);
3344 PerlIOStdio_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
3349 if (PerlIO_lockcnt(f)) /* in use: abort ungracefully */
3351 s = PerlIOSelf(f, PerlIOStdio)->stdio;
3354 STDCHAR *buf = (STDCHAR *) vbuf;
3356 * Perl is expecting PerlIO_getc() to fill the buffer Linux's
3357 * stdio does not do that for fread()
3359 const int ch = PerlSIO_fgetc(s);
3366 got = PerlSIO_fread(vbuf, 1, count, s);
3367 if (got == 0 && PerlSIO_ferror(s))
3369 if (got >= 0 || errno != EINTR)
3371 if (PL_sig_pending && S_perlio_async_run(aTHX_ f))
3373 SETERRNO(0,0); /* just in case */
3379 PerlIOStdio_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
3382 FILE * const s = PerlIOSelf(f, PerlIOStdio)->stdio;
3384 #ifdef STDIO_BUFFER_WRITABLE
3385 if (PerlIO_fast_gets(f) && PerlIO_has_base(f)) {
3386 STDCHAR *buf = ((STDCHAR *) vbuf) + count;
3387 STDCHAR *base = PerlIO_get_base(f);
3388 SSize_t cnt = PerlIO_get_cnt(f);
3389 STDCHAR *ptr = PerlIO_get_ptr(f);
3390 SSize_t avail = ptr - base;
3392 if (avail > count) {
3396 Move(buf-avail,ptr,avail,STDCHAR);
3399 PerlIO_set_ptrcnt(f,ptr,cnt+avail);
3400 if (PerlSIO_feof(s) && unread >= 0)
3401 PerlSIO_clearerr(s);
3406 if (PerlIO_has_cntptr(f)) {
3407 /* We can get pointer to buffer but not its base
3408 Do ungetc() but check chars are ending up in the
3411 STDCHAR *eptr = (STDCHAR*)PerlSIO_get_ptr(s);
3412 STDCHAR *buf = ((STDCHAR *) vbuf) + count;
3414 const int ch = *--buf & 0xFF;
3415 if (ungetc(ch,s) != ch) {
3416 /* ungetc did not work */
3419 if ((STDCHAR*)PerlSIO_get_ptr(s) != --eptr || ((*eptr & 0xFF) != ch)) {
3420 /* Did not change pointer as expected */
3421 fgetc(s); /* get char back again */
3431 unread += PerlIOBase_unread(aTHX_ f, vbuf, count);
3437 PerlIOStdio_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
3441 if (PerlIO_lockcnt(f)) /* in use: abort ungracefully */
3444 got = PerlSIO_fwrite(vbuf, 1, count,
3445 PerlIOSelf(f, PerlIOStdio)->stdio);
3446 if (got >= 0 || errno != EINTR)
3448 if (PL_sig_pending && S_perlio_async_run(aTHX_ f))
3450 SETERRNO(0,0); /* just in case */
3456 PerlIOStdio_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
3458 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3459 PERL_UNUSED_CONTEXT;
3461 return PerlSIO_fseek(stdio, offset, whence);
3465 PerlIOStdio_tell(pTHX_ PerlIO *f)
3467 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3468 PERL_UNUSED_CONTEXT;
3470 return PerlSIO_ftell(stdio);
3474 PerlIOStdio_flush(pTHX_ PerlIO *f)
3476 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3477 PERL_UNUSED_CONTEXT;
3479 if (PerlIOBase(f)->flags & PERLIO_F_CANWRITE) {
3480 return PerlSIO_fflush(stdio);
3486 * FIXME: This discards ungetc() and pre-read stuff which is not
3487 * right if this is just a "sync" from a layer above Suspect right
3488 * design is to do _this_ but not have layer above flush this
3489 * layer read-to-read
3492 * Not writeable - sync by attempting a seek
3495 if (PerlSIO_fseek(stdio, (Off_t) 0, SEEK_CUR) != 0)
3503 PerlIOStdio_eof(pTHX_ PerlIO *f)
3505 PERL_UNUSED_CONTEXT;
3507 return PerlSIO_feof(PerlIOSelf(f, PerlIOStdio)->stdio);
3511 PerlIOStdio_error(pTHX_ PerlIO *f)
3513 PERL_UNUSED_CONTEXT;
3515 return PerlSIO_ferror(PerlIOSelf(f, PerlIOStdio)->stdio);
3519 PerlIOStdio_clearerr(pTHX_ PerlIO *f)
3521 PERL_UNUSED_CONTEXT;
3523 PerlSIO_clearerr(PerlIOSelf(f, PerlIOStdio)->stdio);
3527 PerlIOStdio_setlinebuf(pTHX_ PerlIO *f)
3529 PERL_UNUSED_CONTEXT;
3531 #ifdef HAS_SETLINEBUF
3532 PerlSIO_setlinebuf(PerlIOSelf(f, PerlIOStdio)->stdio);
3534 PerlSIO_setvbuf(PerlIOSelf(f, PerlIOStdio)->stdio, NULL, _IOLBF, 0);
3540 PerlIOStdio_get_base(pTHX_ PerlIO *f)
3542 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3543 return (STDCHAR*)PerlSIO_get_base(stdio);
3547 PerlIOStdio_get_bufsiz(pTHX_ PerlIO *f)
3549 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3550 return PerlSIO_get_bufsiz(stdio);
3554 #ifdef USE_STDIO_PTR
3556 PerlIOStdio_get_ptr(pTHX_ PerlIO *f)
3558 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3559 return (STDCHAR*)PerlSIO_get_ptr(stdio);
3563 PerlIOStdio_get_cnt(pTHX_ PerlIO *f)
3565 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3566 return PerlSIO_get_cnt(stdio);
3570 PerlIOStdio_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
3572 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3574 #ifdef STDIO_PTR_LVALUE
3575 PerlSIO_set_ptr(stdio, ptr); /* LHS STDCHAR* cast non-portable */
3576 #ifdef STDIO_PTR_LVAL_SETS_CNT
3577 assert(PerlSIO_get_cnt(stdio) == (cnt));
3579 #if (!defined(STDIO_PTR_LVAL_NOCHANGE_CNT))
3581 * Setting ptr _does_ change cnt - we are done
3585 #else /* STDIO_PTR_LVALUE */
3587 #endif /* STDIO_PTR_LVALUE */
3590 * Now (or only) set cnt
3592 #ifdef STDIO_CNT_LVALUE
3593 PerlSIO_set_cnt(stdio, cnt);
3594 #else /* STDIO_CNT_LVALUE */
3595 #if (defined(STDIO_PTR_LVALUE) && defined(STDIO_PTR_LVAL_SETS_CNT))
3596 PerlSIO_set_ptr(stdio,
3597 PerlSIO_get_ptr(stdio) + (PerlSIO_get_cnt(stdio) -
3599 #else /* STDIO_PTR_LVAL_SETS_CNT */
3601 #endif /* STDIO_PTR_LVAL_SETS_CNT */
3602 #endif /* STDIO_CNT_LVALUE */
3609 PerlIOStdio_fill(pTHX_ PerlIO *f)
3613 PERL_UNUSED_CONTEXT;
3614 if (PerlIO_lockcnt(f)) /* in use: abort ungracefully */
3616 stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3619 * fflush()ing read-only streams can cause trouble on some stdio-s
3621 if ((PerlIOBase(f)->flags & PERLIO_F_CANWRITE)) {
3622 if (PerlSIO_fflush(stdio) != 0)
3626 c = PerlSIO_fgetc(stdio);
3629 if (! PerlSIO_ferror(stdio) || errno != EINTR)
3631 if (PL_sig_pending && S_perlio_async_run(aTHX_ f))
3636 #if (defined(STDIO_PTR_LVALUE) && (defined(STDIO_CNT_LVALUE) || defined(STDIO_PTR_LVAL_SETS_CNT)))
3638 #ifdef STDIO_BUFFER_WRITABLE
3639 if (PerlIO_fast_gets(f) && PerlIO_has_base(f)) {
3640 /* Fake ungetc() to the real buffer in case system's ungetc
3643 STDCHAR *base = (STDCHAR*)PerlSIO_get_base(stdio);
3644 SSize_t cnt = PerlSIO_get_cnt(stdio);
3645 STDCHAR *ptr = (STDCHAR*)PerlSIO_get_ptr(stdio);
3646 if (ptr == base+1) {
3647 *--ptr = (STDCHAR) c;
3648 PerlIOStdio_set_ptrcnt(aTHX_ f,ptr,cnt+1);
3649 if (PerlSIO_feof(stdio))
3650 PerlSIO_clearerr(stdio);
3656 if (PerlIO_has_cntptr(f)) {
3658 if (PerlIOStdio_unread(aTHX_ f,&ch,1) == 1) {
3665 /* An ungetc()d char is handled separately from the regular
3666 * buffer, so we stuff it in the buffer ourselves.
3667 * Should never get called as should hit code above
3669 *(--((*stdio)->_ptr)) = (unsigned char) c;
3672 /* If buffer snoop scheme above fails fall back to
3675 if (PerlSIO_ungetc(c, stdio) != c)
3683 PERLIO_FUNCS_DECL(PerlIO_stdio) = {
3684 sizeof(PerlIO_funcs),
3686 sizeof(PerlIOStdio),
3687 PERLIO_K_BUFFERED|PERLIO_K_RAW,
3691 PerlIOBase_binmode, /* binmode */
3705 PerlIOStdio_clearerr,
3706 PerlIOStdio_setlinebuf,
3708 PerlIOStdio_get_base,
3709 PerlIOStdio_get_bufsiz,
3714 #ifdef USE_STDIO_PTR
3715 PerlIOStdio_get_ptr,
3716 PerlIOStdio_get_cnt,
3717 # if defined(HAS_FAST_STDIO) && defined(USE_FAST_STDIO)
3718 PerlIOStdio_set_ptrcnt,
3721 # endif /* HAS_FAST_STDIO && USE_FAST_STDIO */
3726 #endif /* USE_STDIO_PTR */
3729 /* Note that calls to PerlIO_exportFILE() are reversed using
3730 * PerlIO_releaseFILE(), not importFILE. */
3732 PerlIO_exportFILE(PerlIO * f, const char *mode)
3736 if (PerlIOValid(f)) {
3739 if (!mode || !*mode) {
3740 mode = PerlIO_modestr(f, buf);
3742 stdio = PerlSIO_fdopen(PerlIO_fileno(f), mode);
3746 /* De-link any lower layers so new :stdio sticks */
3748 if ((f2 = PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_stdio), buf, NULL))) {
3749 PerlIOStdio *s = PerlIOSelf((f = f2), PerlIOStdio);
3751 PerlIOUnix_refcnt_inc(fileno(stdio));
3752 /* Link previous lower layers under new one */
3756 /* restore layers list */
3766 PerlIO_findFILE(PerlIO *f)
3771 if (l->tab == &PerlIO_stdio) {
3772 PerlIOStdio *s = PerlIOSelf(&l, PerlIOStdio);
3775 l = *PerlIONext(&l);
3777 /* Uses fallback "mode" via PerlIO_modestr() in PerlIO_exportFILE */
3778 /* However, we're not really exporting a FILE * to someone else (who
3779 becomes responsible for closing it, or calling PerlIO_releaseFILE())
3780 So we need to undo its reference count increase on the underlying file
3781 descriptor. We have to do this, because if the loop above returns you
3782 the FILE *, then *it* didn't increase any reference count. So there's
3783 only one way to be consistent. */
3784 stdio = PerlIO_exportFILE(f, NULL);
3786 const int fd = fileno(stdio);
3788 PerlIOUnix_refcnt_dec(fd);
3793 /* Use this to reverse PerlIO_exportFILE calls. */
3795 PerlIO_releaseFILE(PerlIO *p, FILE *f)
3800 if (l->tab == &PerlIO_stdio) {
3801 PerlIOStdio *s = PerlIOSelf(&l, PerlIOStdio);
3802 if (s->stdio == f) {
3804 const int fd = fileno(f);
3806 PerlIOUnix_refcnt_dec(fd);
3807 PerlIO_pop(aTHX_ p);
3816 /*--------------------------------------------------------------------------------------*/
3818 * perlio buffer layer
3822 PerlIOBuf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
3824 PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
3825 const int fd = PerlIO_fileno(f);
3826 if (fd >= 0 && PerlLIO_isatty(fd)) {
3827 PerlIOBase(f)->flags |= PERLIO_F_LINEBUF | PERLIO_F_TTY;
3829 if (*PerlIONext(f)) {
3830 const Off_t posn = PerlIO_tell(PerlIONext(f));
3831 if (posn != (Off_t) - 1) {
3835 return PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
3839 PerlIOBuf_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
3840 IV n, const char *mode, int fd, int imode, int perm,
3841 PerlIO *f, int narg, SV **args)
3843 if (PerlIOValid(f)) {
3844 PerlIO *next = PerlIONext(f);
3846 PerlIO_layer_fetch(aTHX_ layers, n - 1, PerlIOBase(next)->tab);
3847 if (tab && tab->Open)
3849 (*tab->Open)(aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
3851 if (!next || (*PerlIOBase(f)->tab->Pushed) (aTHX_ f, mode, PerlIOArg, self) != 0) {
3856 PerlIO_funcs *tab = PerlIO_layer_fetch(aTHX_ layers, n - 1, PerlIO_default_btm());
3858 if (*mode == IoTYPE_IMPLICIT) {
3864 if (tab && tab->Open)
3865 f = (*tab->Open)(aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
3868 SETERRNO(EINVAL, LIB_INVARG);
3870 if (PerlIO_push(aTHX_ f, self, mode, PerlIOArg) == 0) {
3872 * if push fails during open, open fails. close will pop us.
3877 fd = PerlIO_fileno(f);
3878 if (init && fd == 2) {
3880 * Initial stderr is unbuffered
3882 PerlIOBase(f)->flags |= PERLIO_F_UNBUF;
3884 #ifdef PERLIO_USING_CRLF
3885 # ifdef PERLIO_IS_BINMODE_FD
3886 if (PERLIO_IS_BINMODE_FD(fd))
3887 PerlIO_binmode(aTHX_ f, '<'/*not used*/, O_BINARY, NULL);
3891 * do something about failing setmode()? --jhi
3893 PerlLIO_setmode(fd, O_BINARY);
3897 /* Enable line buffering with record-oriented regular files
3898 * so we don't introduce an extraneous record boundary when
3899 * the buffer fills up.
3901 if (PerlIOBase(f)->flags & PERLIO_F_CANWRITE) {
3903 if (PerlLIO_fstat(fd, &st) == 0
3904 && S_ISREG(st.st_mode)
3905 && (st.st_fab_rfm == FAB$C_VAR
3906 || st.st_fab_rfm == FAB$C_VFC)) {
3907 PerlIOBase(f)->flags |= PERLIO_F_LINEBUF;
3918 * This "flush" is akin to sfio's sync in that it handles files in either
3919 * read or write state. For write state, we put the postponed data through
3920 * the next layers. For read state, we seek() the next layers to the
3921 * offset given by current position in the buffer, and discard the buffer
3922 * state (XXXX supposed to be for seek()able buffers only, but now it is done
3923 * in any case?). Then the pass the stick further in chain.
3926 PerlIOBuf_flush(pTHX_ PerlIO *f)
3928 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
3930 PerlIO *n = PerlIONext(f);
3931 if (PerlIOBase(f)->flags & PERLIO_F_WRBUF) {
3933 * write() the buffer
3935 const STDCHAR *buf = b->buf;
3936 const STDCHAR *p = buf;
3937 while (p < b->ptr) {
3938 SSize_t count = PerlIO_write(n, p, b->ptr - p);
3942 else if (count < 0 || PerlIO_error(n)) {
3943 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
3948 b->posn += (p - buf);
3950 else if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
3951 STDCHAR *buf = PerlIO_get_base(f);
3953 * Note position change
3955 b->posn += (b->ptr - buf);
3956 if (b->ptr < b->end) {
3957 /* We did not consume all of it - try and seek downstream to
3958 our logical position
3960 if (PerlIOValid(n) && PerlIO_seek(n, b->posn, SEEK_SET) == 0) {
3961 /* Reload n as some layers may pop themselves on seek */
3962 b->posn = PerlIO_tell(n = PerlIONext(f));
3965 /* Seek failed (e.g. pipe or tty). Do NOT clear buffer or pre-read
3966 data is lost for good - so return saying "ok" having undone
3969 b->posn -= (b->ptr - buf);
3974 b->ptr = b->end = b->buf;
3975 PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF | PERLIO_F_WRBUF);
3976 /* We check for Valid because of dubious decision to make PerlIO_flush(NULL) flush all */
3977 if (PerlIOValid(n) && PerlIO_flush(n) != 0)
3982 /* This discards the content of the buffer after b->ptr, and rereads
3983 * the buffer from the position off in the layer downstream; here off
3984 * is at offset corresponding to b->ptr - b->buf.
3987 PerlIOBuf_fill(pTHX_ PerlIO *f)
3989 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
3990 PerlIO *n = PerlIONext(f);
3993 * Down-stream flush is defined not to loose read data so is harmless.
3994 * we would not normally be fill'ing if there was data left in anycase.
3996 if (PerlIO_flush(f) != 0) /* XXXX Check that its seek() succeeded?! */
3998 if (PerlIOBase(f)->flags & PERLIO_F_TTY)
3999 PerlIOBase_flush_linebuf(aTHX);
4002 PerlIO_get_base(f); /* allocate via vtable */
4004 assert(b->buf); /* The b->buf does get allocated via the vtable system. */
4006 b->ptr = b->end = b->buf;
4008 if (!PerlIOValid(n)) {
4009 PerlIOBase(f)->flags |= PERLIO_F_EOF;
4013 if (PerlIO_fast_gets(n)) {
4015 * Layer below is also buffered. We do _NOT_ want to call its
4016 * ->Read() because that will loop till it gets what we asked for
4017 * which may hang on a pipe etc. Instead take anything it has to
4018 * hand, or ask it to fill _once_.
4020 avail = PerlIO_get_cnt(n);
4022 avail = PerlIO_fill(n);
4024 avail = PerlIO_get_cnt(n);
4026 if (!PerlIO_error(n) && PerlIO_eof(n))
4031 STDCHAR *ptr = PerlIO_get_ptr(n);
4032 const SSize_t cnt = avail;
4033 if (avail > (SSize_t)b->bufsiz)
4035 Copy(ptr, b->buf, avail, STDCHAR);
4036 PerlIO_set_ptrcnt(n, ptr + avail, cnt - avail);
4040 avail = PerlIO_read(n, b->ptr, b->bufsiz);
4044 PerlIOBase(f)->flags |= PERLIO_F_EOF;
4046 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
4049 b->end = b->buf + avail;
4050 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
4055 PerlIOBuf_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
4057 if (PerlIOValid(f)) {
4058 const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4061 return PerlIOBase_read(aTHX_ f, vbuf, count);
4067 PerlIOBuf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
4069 const STDCHAR *buf = (const STDCHAR *) vbuf + count;
4070 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4073 if (PerlIOBase(f)->flags & PERLIO_F_WRBUF)
4078 if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
4080 * Buffer is already a read buffer, we can overwrite any chars
4081 * which have been read back to buffer start
4083 avail = (b->ptr - b->buf);
4087 * Buffer is idle, set it up so whole buffer is available for
4091 b->end = b->buf + avail;
4093 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
4095 * Buffer extends _back_ from where we are now
4097 b->posn -= b->bufsiz;
4099 if (avail > (SSize_t) count) {
4101 * If we have space for more than count, just move count
4109 * In simple stdio-like ungetc() case chars will be already
4112 if (buf != b->ptr) {
4113 Copy(buf, b->ptr, avail, STDCHAR);
4117 PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
4121 unread += PerlIOBase_unread(aTHX_ f, vbuf, count);
4127 PerlIOBuf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
4129 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4130 const STDCHAR *buf = (const STDCHAR *) vbuf;
4131 const STDCHAR *flushptr = buf;
4135 if (!(PerlIOBase(f)->flags & PERLIO_F_CANWRITE))
4137 if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
4138 if (PerlIO_flush(f) != 0) {
4142 if (PerlIOBase(f)->flags & PERLIO_F_LINEBUF) {
4143 flushptr = buf + count;
4144 while (flushptr > buf && *(flushptr - 1) != '\n')
4148 SSize_t avail = b->bufsiz - (b->ptr - b->buf);
4149 if ((SSize_t) count < avail)
4151 if (flushptr > buf && flushptr <= buf + avail)
4152 avail = flushptr - buf;
4153 PerlIOBase(f)->flags |= PERLIO_F_WRBUF;
4155 Copy(buf, b->ptr, avail, STDCHAR);
4160 if (buf == flushptr)
4163 if (b->ptr >= (b->buf + b->bufsiz))
4164 if (PerlIO_flush(f) == -1)
4167 if (PerlIOBase(f)->flags & PERLIO_F_UNBUF)
4173 PerlIOBuf_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
4176 if ((code = PerlIO_flush(f)) == 0) {
4177 PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
4178 code = PerlIO_seek(PerlIONext(f), offset, whence);
4180 PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
4181 b->posn = PerlIO_tell(PerlIONext(f));
4188 PerlIOBuf_tell(pTHX_ PerlIO *f)
4190 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4192 * b->posn is file position where b->buf was read, or will be written
4194 Off_t posn = b->posn;
4195 if ((PerlIOBase(f)->flags & PERLIO_F_APPEND) &&
4196 (PerlIOBase(f)->flags & PERLIO_F_WRBUF)) {
4198 /* As O_APPEND files are normally shared in some sense it is better
4203 /* when file is NOT shared then this is sufficient */
4204 PerlIO_seek(PerlIONext(f),0, SEEK_END);
4206 posn = b->posn = PerlIO_tell(PerlIONext(f));
4210 * If buffer is valid adjust position by amount in buffer
4212 posn += (b->ptr - b->buf);
4218 PerlIOBuf_popped(pTHX_ PerlIO *f)
4220 const IV code = PerlIOBase_popped(aTHX_ f);
4221 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4222 if (b->buf && b->buf != (STDCHAR *) & b->oneword) {
4225 b->ptr = b->end = b->buf = NULL;
4226 PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF | PERLIO_F_WRBUF);
4231 PerlIOBuf_close(pTHX_ PerlIO *f)
4233 const IV code = PerlIOBase_close(aTHX_ f);
4234 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4235 if (b->buf && b->buf != (STDCHAR *) & b->oneword) {
4238 b->ptr = b->end = b->buf = NULL;
4239 PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF | PERLIO_F_WRBUF);
4244 PerlIOBuf_get_ptr(pTHX_ PerlIO *f)
4246 const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4253 PerlIOBuf_get_cnt(pTHX_ PerlIO *f)
4255 const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4258 if (PerlIOBase(f)->flags & PERLIO_F_RDBUF)
4259 return (b->end - b->ptr);
4264 PerlIOBuf_get_base(pTHX_ PerlIO *f)
4266 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4267 PERL_UNUSED_CONTEXT;
4271 b->bufsiz = PERLIOBUF_DEFAULT_BUFSIZ;
4272 Newxz(b->buf,b->bufsiz, STDCHAR);
4274 b->buf = (STDCHAR *) & b->oneword;
4275 b->bufsiz = sizeof(b->oneword);
4277 b->end = b->ptr = b->buf;
4283 PerlIOBuf_bufsiz(pTHX_ PerlIO *f)
4285 const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4288 return (b->end - b->buf);
4292 PerlIOBuf_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
4294 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4296 PERL_UNUSED_ARG(cnt);
4301 assert(PerlIO_get_cnt(f) == cnt);
4302 assert(b->ptr >= b->buf);
4303 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
4307 PerlIOBuf_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
4309 return PerlIOBase_dup(aTHX_ f, o, param, flags);
4314 PERLIO_FUNCS_DECL(PerlIO_perlio) = {
4315 sizeof(PerlIO_funcs),
4318 PERLIO_K_BUFFERED|PERLIO_K_RAW,
4322 PerlIOBase_binmode, /* binmode */
4336 PerlIOBase_clearerr,
4337 PerlIOBase_setlinebuf,
4342 PerlIOBuf_set_ptrcnt,
4345 /*--------------------------------------------------------------------------------------*/
4347 * Temp layer to hold unread chars when cannot do it any other way
4351 PerlIOPending_fill(pTHX_ PerlIO *f)
4354 * Should never happen
4361 PerlIOPending_close(pTHX_ PerlIO *f)
4364 * A tad tricky - flush pops us, then we close new top
4367 return PerlIO_close(f);
4371 PerlIOPending_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
4374 * A tad tricky - flush pops us, then we seek new top
4377 return PerlIO_seek(f, offset, whence);
4382 PerlIOPending_flush(pTHX_ PerlIO *f)
4384 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4385 if (b->buf && b->buf != (STDCHAR *) & b->oneword) {
4389 PerlIO_pop(aTHX_ f);
4394 PerlIOPending_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
4400 PerlIOBuf_set_ptrcnt(aTHX_ f, ptr, cnt);
4405 PerlIOPending_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
4407 const IV code = PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
4408 PerlIOl * const l = PerlIOBase(f);
4410 * Our PerlIO_fast_gets must match what we are pushed on, or sv_gets()
4411 * etc. get muddled when it changes mid-string when we auto-pop.
4413 l->flags = (l->flags & ~(PERLIO_F_FASTGETS | PERLIO_F_UTF8)) |
4414 (PerlIOBase(PerlIONext(f))->
4415 flags & (PERLIO_F_FASTGETS | PERLIO_F_UTF8));
4420 PerlIOPending_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
4422 SSize_t avail = PerlIO_get_cnt(f);
4424 if ((SSize_t)count < avail)
4427 got = PerlIOBuf_read(aTHX_ f, vbuf, avail);
4428 if (got >= 0 && got < (SSize_t)count) {
4429 const SSize_t more =
4430 PerlIO_read(f, ((STDCHAR *) vbuf) + got, count - got);
4431 if (more >= 0 || got == 0)
4437 PERLIO_FUNCS_DECL(PerlIO_pending) = {
4438 sizeof(PerlIO_funcs),
4441 PERLIO_K_BUFFERED|PERLIO_K_RAW, /* not sure about RAW here */
4442 PerlIOPending_pushed,
4445 PerlIOBase_binmode, /* binmode */
4454 PerlIOPending_close,
4455 PerlIOPending_flush,
4459 PerlIOBase_clearerr,
4460 PerlIOBase_setlinebuf,
4465 PerlIOPending_set_ptrcnt,
4470 /*--------------------------------------------------------------------------------------*/
4472 * crlf - translation On read translate CR,LF to "\n" we do this by
4473 * overriding ptr/cnt entries to hand back a line at a time and keeping a
4474 * record of which nl we "lied" about. On write translate "\n" to CR,LF
4476 * c->nl points on the first byte of CR LF pair when it is temporarily
4477 * replaced by LF, or to the last CR of the buffer. In the former case
4478 * the caller thinks that the buffer ends at c->nl + 1, in the latter
4479 * that it ends at c->nl; these two cases can be distinguished by
4480 * *c->nl. c->nl is set during _getcnt() call, and unset during
4481 * _unread() and _flush() calls.
4482 * It only matters for read operations.
4486 PerlIOBuf base; /* PerlIOBuf stuff */
4487 STDCHAR *nl; /* Position of crlf we "lied" about in the
4491 /* Inherit the PERLIO_F_UTF8 flag from previous layer.
4492 * Otherwise the :crlf layer would always revert back to
4496 S_inherit_utf8_flag(PerlIO *f)
4498 PerlIO *g = PerlIONext(f);
4499 if (PerlIOValid(g)) {
4500 if (PerlIOBase(g)->flags & PERLIO_F_UTF8) {
4501 PerlIOBase(f)->flags |= PERLIO_F_UTF8;
4507 PerlIOCrlf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
4510 PerlIOBase(f)->flags |= PERLIO_F_CRLF;
4511 code = PerlIOBuf_pushed(aTHX_ f, mode, arg, tab);
4513 PerlIO_debug("PerlIOCrlf_pushed f=%p %s %s fl=%08" UVxf "\n",
4514 (void*)f, PerlIOBase(f)->tab->name, (mode) ? mode : "(Null)",
4515 PerlIOBase(f)->flags);
4518 /* If the old top layer is a CRLF layer, reactivate it (if
4519 * necessary) and remove this new layer from the stack */
4520 PerlIO *g = PerlIONext(f);
4521 if (PerlIOValid(g)) {
4522 PerlIOl *b = PerlIOBase(g);
4523 if (b && b->tab == &PerlIO_crlf) {
4524 if (!(b->flags & PERLIO_F_CRLF))
4525 b->flags |= PERLIO_F_CRLF;
4526 S_inherit_utf8_flag(g);
4527 PerlIO_pop(aTHX_ f);
4532 S_inherit_utf8_flag(f);
4538 PerlIOCrlf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
4540 PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
4541 if (c->nl) { /* XXXX Shouldn't it be done only if b->ptr > c->nl? */
4545 if (!(PerlIOBase(f)->flags & PERLIO_F_CRLF))
4546 return PerlIOBuf_unread(aTHX_ f, vbuf, count);
4548 const STDCHAR *buf = (const STDCHAR *) vbuf + count;
4549 PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
4551 if (PerlIOBase(f)->flags & PERLIO_F_WRBUF)
4556 if (!(PerlIOBase(f)->flags & PERLIO_F_RDBUF)) {
4557 b->end = b->ptr = b->buf + b->bufsiz;
4558 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
4559 b->posn -= b->bufsiz;
4561 while (count > 0 && b->ptr > b->buf) {
4562 const int ch = *--buf;
4564 if (b->ptr - 2 >= b->buf) {
4571 /* If b->ptr - 1 == b->buf, we are undoing reading 0xa */
4572 *--(b->ptr) = 0xa; /* Works even if 0xa == '\r' */
4588 /* XXXX This code assumes that buffer size >=2, but does not check it... */
4590 PerlIOCrlf_get_cnt(pTHX_ PerlIO *f)
4592 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4595 if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
4596 PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
4597 if ((PerlIOBase(f)->flags & PERLIO_F_CRLF) && (!c->nl || *c->nl == 0xd)) {
4598 STDCHAR *nl = (c->nl) ? c->nl : b->ptr;
4600 while (nl < b->end && *nl != 0xd)
4602 if (nl < b->end && *nl == 0xd) {
4604 if (nl + 1 < b->end) {
4611 * Not CR,LF but just CR
4619 * Blast - found CR as last char in buffer
4624 * They may not care, defer work as long as
4628 return (nl - b->ptr);
4632 b->ptr++; /* say we have read it as far as
4633 * flush() is concerned */
4634 b->buf++; /* Leave space in front of buffer */
4635 /* Note as we have moved buf up flush's
4637 will naturally make posn point at CR
4639 b->bufsiz--; /* Buffer is thus smaller */
4640 code = PerlIO_fill(f); /* Fetch some more */
4641 b->bufsiz++; /* Restore size for next time */
4642 b->buf--; /* Point at space */
4643 b->ptr = nl = b->buf; /* Which is what we hand
4645 *nl = 0xd; /* Fill in the CR */
4647 goto test; /* fill() call worked */
4649 * CR at EOF - just fall through
4651 /* Should we clear EOF though ??? */
4656 return (((c->nl) ? (c->nl + 1) : b->end) - b->ptr);
4662 PerlIOCrlf_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
4664 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4665 PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
4671 if (ptr == b->end && *c->nl == 0xd) {
4672 /* Deferred CR at end of buffer case - we lied about count */
4685 * Test code - delete when it works ...
4687 IV flags = PerlIOBase(f)->flags;
4688 STDCHAR *chk = (c->nl) ? (c->nl+1) : b->end;
4689 if (ptr+cnt == c->nl && c->nl+1 == b->end && *c->nl == 0xd) {
4690 /* Deferred CR at end of buffer case - we lied about count */
4696 Perl_croak(aTHX_ "ptr wrong %p != %p fl=%08" UVxf
4697 " nl=%p e=%p for %d", (void*)ptr, (void*)chk,
4698 flags, c->nl, b->end, cnt);
4705 * They have taken what we lied about
4713 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
4717 PerlIOCrlf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
4719 if (!(PerlIOBase(f)->flags & PERLIO_F_CRLF))
4720 return PerlIOBuf_write(aTHX_ f, vbuf, count);
4722 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4723 const STDCHAR *buf = (const STDCHAR *) vbuf;
4724 const STDCHAR * const ebuf = buf + count;
4727 if (!(PerlIOBase(f)->flags & PERLIO_F_CANWRITE))
4729 while (buf < ebuf) {
4730 const STDCHAR * const eptr = b->buf + b->bufsiz;
4731 PerlIOBase(f)->flags |= PERLIO_F_WRBUF;
4732 while (buf < ebuf && b->ptr < eptr) {
4734 if ((b->ptr + 2) > eptr) {
4742 *(b->ptr)++ = 0xd; /* CR */
4743 *(b->ptr)++ = 0xa; /* LF */
4745 if (PerlIOBase(f)->flags & PERLIO_F_LINEBUF) {
4752 *(b->ptr)++ = *buf++;
4754 if (b->ptr >= eptr) {
4760 if (PerlIOBase(f)->flags & PERLIO_F_UNBUF)
4762 return (buf - (STDCHAR *) vbuf);
4767 PerlIOCrlf_flush(pTHX_ PerlIO *f)
4769 PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
4774 return PerlIOBuf_flush(aTHX_ f);
4778 PerlIOCrlf_binmode(pTHX_ PerlIO *f)
4780 if ((PerlIOBase(f)->flags & PERLIO_F_CRLF)) {
4781 /* In text mode - flush any pending stuff and flip it */
4782 PerlIOBase(f)->flags &= ~PERLIO_F_CRLF;
4783 #ifndef PERLIO_USING_CRLF
4784 /* CRLF is unusual case - if this is just the :crlf layer pop it */
4785 PerlIO_pop(aTHX_ f);
4791 PERLIO_FUNCS_DECL(PerlIO_crlf) = {
4792 sizeof(PerlIO_funcs),
4795 PERLIO_K_BUFFERED | PERLIO_K_CANCRLF | PERLIO_K_RAW,
4797 PerlIOBuf_popped, /* popped */
4799 PerlIOCrlf_binmode, /* binmode */
4803 PerlIOBuf_read, /* generic read works with ptr/cnt lies */
4804 PerlIOCrlf_unread, /* Put CR,LF in buffer for each '\n' */
4805 PerlIOCrlf_write, /* Put CR,LF in buffer for each '\n' */
4813 PerlIOBase_clearerr,
4814 PerlIOBase_setlinebuf,
4819 PerlIOCrlf_set_ptrcnt,
4823 Perl_PerlIO_stdin(pTHX)
4827 PerlIO_stdstreams(aTHX);
4829 return (PerlIO*)&PL_perlio[1];
4833 Perl_PerlIO_stdout(pTHX)
4837 PerlIO_stdstreams(aTHX);
4839 return (PerlIO*)&PL_perlio[2];
4843 Perl_PerlIO_stderr(pTHX)
4847 PerlIO_stdstreams(aTHX);
4849 return (PerlIO*)&PL_perlio[3];
4852 /*--------------------------------------------------------------------------------------*/
4855 PerlIO_getname(PerlIO *f, char *buf)
4860 bool exported = FALSE;
4861 FILE *stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
4863 stdio = PerlIO_exportFILE(f,0);
4867 name = fgetname(stdio, buf);
4868 if (exported) PerlIO_releaseFILE(f,stdio);
4873 PERL_UNUSED_ARG(buf);
4874 Perl_croak(aTHX_ "Don't know how to get file name");
4880 /*--------------------------------------------------------------------------------------*/
4882 * Functions which can be called on any kind of PerlIO implemented in
4886 #undef PerlIO_fdopen
4888 PerlIO_fdopen(int fd, const char *mode)
4891 return PerlIO_openn(aTHX_ NULL, mode, fd, 0, 0, NULL, 0, NULL);
4896 PerlIO_open(const char *path, const char *mode)
4899 SV *name = sv_2mortal(newSVpv(path, 0));
4900 return PerlIO_openn(aTHX_ NULL, mode, -1, 0, 0, NULL, 1, &name);
4903 #undef Perlio_reopen
4905 PerlIO_reopen(const char *path, const char *mode, PerlIO *f)
4908 SV *name = sv_2mortal(newSVpv(path,0));
4909 return PerlIO_openn(aTHX_ NULL, mode, -1, 0, 0, f, 1, &name);
4914 PerlIO_getc(PerlIO *f)
4918 if ( 1 == PerlIO_read(f, buf, 1) ) {
4919 return (unsigned char) buf[0];
4924 #undef PerlIO_ungetc
4926 PerlIO_ungetc(PerlIO *f, int ch)
4931 if (PerlIO_unread(f, &buf, 1) == 1)
4939 PerlIO_putc(PerlIO *f, int ch)
4943 return PerlIO_write(f, &buf, 1);
4948 PerlIO_puts(PerlIO *f, const char *s)
4951 return PerlIO_write(f, s, strlen(s));
4954 #undef PerlIO_rewind
4956 PerlIO_rewind(PerlIO *f)
4959 PerlIO_seek(f, (Off_t) 0, SEEK_SET);
4963 #undef PerlIO_vprintf
4965 PerlIO_vprintf(PerlIO *f, const char *fmt, va_list ap)
4974 Perl_va_copy(ap, apc);
4975 sv = vnewSVpvf(fmt, &apc);
4977 sv = vnewSVpvf(fmt, &ap);
4979 s = SvPV_const(sv, len);
4980 wrote = PerlIO_write(f, s, len);
4985 #undef PerlIO_printf
4987 PerlIO_printf(PerlIO *f, const char *fmt, ...)
4992 result = PerlIO_vprintf(f, fmt, ap);
4997 #undef PerlIO_stdoutf
4999 PerlIO_stdoutf(const char *fmt, ...)
5005 result = PerlIO_vprintf(PerlIO_stdout(), fmt, ap);
5010 #undef PerlIO_tmpfile
5012 PerlIO_tmpfile(void)
5017 const int fd = win32_tmpfd();
5019 f = PerlIO_fdopen(fd, "w+b");
5021 # if defined(HAS_MKSTEMP) && ! defined(VMS) && ! defined(OS2)
5023 char tempname[] = "/tmp/PerlIO_XXXXXX";
5024 const char * const tmpdir = PL_tainting ? NULL : PerlEnv_getenv("TMPDIR");
5027 * I have no idea how portable mkstemp() is ... NI-S
5029 if (tmpdir && *tmpdir) {
5030 /* if TMPDIR is set and not empty, we try that first */
5031 sv = newSVpv(tmpdir, 0);
5032 sv_catpv(sv, tempname + 4);
5033 fd = mkstemp(SvPVX(sv));
5037 /* else we try /tmp */
5038 fd = mkstemp(tempname);
5041 f = PerlIO_fdopen(fd, "w+");
5043 PerlIOBase(f)->flags |= PERLIO_F_TEMP;
5044 PerlLIO_unlink(sv ? SvPVX_const(sv) : tempname);
5047 # else /* !HAS_MKSTEMP, fallback to stdio tmpfile(). */
5048 FILE * const stdio = PerlSIO_tmpfile();
5051 f = PerlIO_fdopen(fileno(stdio), "w+");
5053 # endif /* else HAS_MKSTEMP */
5054 #endif /* else WIN32 */
5061 #endif /* USE_SFIO */
5062 #endif /* PERLIO_IS_STDIO */
5064 /*======================================================================================*/
5066 * Now some functions in terms of above which may be needed even if we are
5067 * not in true PerlIO mode
5070 Perl_PerlIO_context_layers(pTHX_ const char *mode)
5073 const char *direction = NULL;
5076 * Need to supply default layer info from open.pm
5082 if (mode && mode[0] != 'r') {
5083 if (PL_curcop->cop_hints & HINT_LEXICAL_IO_OUT)
5084 direction = "open>";
5086 if (PL_curcop->cop_hints & HINT_LEXICAL_IO_IN)
5087 direction = "open<";
5092 layers = cop_hints_fetch_pvn(PL_curcop, direction, 5, 0, 0);
5095 return SvOK(layers) ? SvPV_nolen_const(layers) : NULL;
5100 #undef PerlIO_setpos
5102 PerlIO_setpos(PerlIO *f, SV *pos)
5107 const Off_t * const posn = (Off_t *) SvPV(pos, len);
5108 if (f && len == sizeof(Off_t))
5109 return PerlIO_seek(f, *posn, SEEK_SET);
5111 SETERRNO(EINVAL, SS_IVCHAN);
5115 #undef PerlIO_setpos
5117 PerlIO_setpos(PerlIO *f, SV *pos)
5122 Fpos_t * const fpos = (Fpos_t *) SvPV(pos, len);
5123 if (f && len == sizeof(Fpos_t)) {
5124 #if defined(USE_64_BIT_STDIO) && defined(USE_FSETPOS64)
5125 return fsetpos64(f, fpos);
5127 return fsetpos(f, fpos);
5131 SETERRNO(EINVAL, SS_IVCHAN);
5137 #undef PerlIO_getpos
5139 PerlIO_getpos(PerlIO *f, SV *pos)
5142 Off_t posn = PerlIO_tell(f);
5143 sv_setpvn(pos, (char *) &posn, sizeof(posn));
5144 return (posn == (Off_t) - 1) ? -1 : 0;
5147 #undef PerlIO_getpos
5149 PerlIO_getpos(PerlIO *f, SV *pos)
5154 #if defined(USE_64_BIT_STDIO) && defined(USE_FSETPOS64)
5155 code = fgetpos64(f, &fpos);
5157 code = fgetpos(f, &fpos);
5159 sv_setpvn(pos, (char *) &fpos, sizeof(fpos));
5164 #if (defined(PERLIO_IS_STDIO) || !defined(USE_SFIO)) && !defined(HAS_VPRINTF)
5167 vprintf(char *pat, char *args)
5169 _doprnt(pat, args, stdout);
5170 return 0; /* wrong, but perl doesn't use the return
5175 vfprintf(FILE *fd, char *pat, char *args)
5177 _doprnt(pat, args, fd);
5178 return 0; /* wrong, but perl doesn't use the return
5184 #ifndef PerlIO_vsprintf
5186 PerlIO_vsprintf(char *s, int n, const char *fmt, va_list ap)
5189 const int val = my_vsnprintf(s, n > 0 ? n : 0, fmt, ap);
5190 PERL_UNUSED_CONTEXT;
5192 #ifndef PERL_MY_VSNPRINTF_GUARDED
5193 if (val < 0 || (n > 0 ? val >= n : 0)) {
5194 Perl_croak(aTHX_ "panic: my_vsnprintf overflow in PerlIO_vsprintf\n");
5201 #ifndef PerlIO_sprintf
5203 PerlIO_sprintf(char *s, int n, const char *fmt, ...)
5208 result = PerlIO_vsprintf(s, n, fmt, ap);
5216 * c-indentation-style: bsd
5218 * indent-tabs-mode: t
5221 * ex: set ts=8 sts=4 sw=4 noet: