X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/0555b2b0658b3543d19d3fed65724628f43e0191..9a085840b61c988c67da62e325f4b1facaf9783d:/perlio.c

diff --git a/perlio.c b/perlio.c
index e6de36f..df4ddc0 100644
--- a/perlio.c
+++ b/perlio.c
@@ -1,5 +1,5 @@
 /*
- * perlio.c Copyright (c) 1996-2002, Nick Ing-Simmons You may distribute
+ * perlio.c Copyright (c) 1996-2005, Nick Ing-Simmons You may distribute
  * under the terms of either the GNU General Public License or the
  * Artistic License, as specified in the README file.
  */
@@ -9,6 +9,12 @@
  * over passes, and through long dales, and across many streams.
  */
 
+/* This file contains the functions needed to implement PerlIO, which
+ * is Perl's private replacement for the C stdio library. This is used
+ * by default unless you compile with -Uuseperlio or run with
+ * PERLIO=:stdio (but don't do this unless you know what you're doing)
+ */
+
 /*
  * If we have ActivePerl-like PERL_IMPLICIT_SYS then we need a dTHX to get
  * at the dispatch tables, even when we do not need it for other reasons.
@@ -50,6 +56,63 @@
 
 #include "XSUB.h"
 
+#define PERLIO_MAX_REFCOUNTABLE_FD 2048
+
+#ifdef __Lynx__
+/* Missing proto on LynxOS */
+int mkstemp(char*);
+#endif
+
+/* Call the callback or PerlIOBase, and return failure. */
+#define Perl_PerlIO_or_Base(f, callback, base, failure, args) 	\
+	if (PerlIOValid(f)) {					\
+		const PerlIO_funcs *tab = PerlIOBase(f)->tab;	\
+		if (tab && tab->callback)			\
+			return (*tab->callback) args;		\
+		else						\
+			return PerlIOBase_ ## base args;	\
+	}							\
+	else							\
+		SETERRNO(EBADF, SS_IVCHAN);			\
+	return failure
+
+/* Call the callback or fail, and return failure. */
+#define Perl_PerlIO_or_fail(f, callback, failure, args) 	\
+	if (PerlIOValid(f)) {					\
+		const PerlIO_funcs *tab = PerlIOBase(f)->tab;	\
+		if (tab && tab->callback)			\
+			return (*tab->callback) args;		\
+		SETERRNO(EINVAL, LIB_INVARG);			\
+	}							\
+	else							\
+		SETERRNO(EBADF, SS_IVCHAN);			\
+	return failure
+
+/* Call the callback or PerlIOBase, and be void. */
+#define Perl_PerlIO_or_Base_void(f, callback, base, args) 	\
+	if (PerlIOValid(f)) {					\
+		const PerlIO_funcs *tab = PerlIOBase(f)->tab;	\
+		if (tab && tab->callback)			\
+			(*tab->callback) args;			\
+		else						\
+			PerlIOBase_ ## base args;		\
+	}							\
+	else							\
+		SETERRNO(EBADF, SS_IVCHAN)
+
+/* Call the callback or fail, and be void. */
+#define Perl_PerlIO_or_fail_void(f, callback, args) 		\
+	if (PerlIOValid(f)) {					\
+		const PerlIO_funcs *tab = PerlIOBase(f)->tab;	\
+		if (tab && tab->callback)			\
+			(*tab->callback) args;			\
+		else						\
+			SETERRNO(EINVAL, LIB_INVARG);		\
+	}							\
+	else							\
+		SETERRNO(EBADF, SS_IVCHAN)
+
+#ifndef USE_SFIO
 int
 perlsio_binmode(FILE *fp, int iotype, int mode)
 {
@@ -100,10 +163,14 @@ perlsio_binmode(FILE *fp, int iotype, int mode)
     else
 	return 0;
 #  else
+    (void)fp;
+    (void)iotype;
+    (void)mode;
     return 1;
 #  endif
 #endif
 }
+#endif /* sfio */
 
 #ifndef O_ACCMODE
 #define O_ACCMODE 3             /* Assume traditional implementation */
@@ -112,7 +179,7 @@ perlsio_binmode(FILE *fp, int iotype, int mode)
 int
 PerlIO_intmode2str(int rawmode, char *mode, int *writing)
 {
-    int result = rawmode & O_ACCMODE;
+    const int result = rawmode & O_ACCMODE;
     int ix = 0;
     int ptype;
     switch (result) {
@@ -181,6 +248,9 @@ int
 PerlIO_binmode(pTHX_ PerlIO *fp, int iotype, int mode, const char *names)
 {
 #ifdef USE_SFIO
+    (void)iotype;
+    (void)mode;
+    (void)names;
     return 1;
 #else
     return perlsio_binmode(fp, iotype, mode);
@@ -190,7 +260,7 @@ PerlIO_binmode(pTHX_ PerlIO *fp, int iotype, int mode, const char *names)
 PerlIO *
 PerlIO_fdupopen(pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
 {
-#ifdef PERL_MICRO
+#if defined(PERL_MICRO) || defined(SYMBIAN)
     return NULL;
 #else
 #ifdef PERL_IMPLICIT_SYS
@@ -200,7 +270,7 @@ PerlIO_fdupopen(pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
     return win32_fdupopen(f);
 #else
     if (f) {
-	int fd = PerlLIO_dup(PerlIO_fileno(f));
+	const int fd = PerlLIO_dup(PerlIO_fileno(f));
 	if (fd >= 0) {
 	    char mode[8];
 	    int omode = fcntl(fd, F_GETFL);
@@ -238,11 +308,11 @@ PerlIO_openn(pTHX_ const char *layers, const char *mode, int fd,
 	if (*args == &PL_sv_undef)
 	    return PerlIO_tmpfile();
 	else {
-	    char *name = SvPV_nolen(*args);
-	    if (*mode == '#') {
+	    const char *name = SvPV_nolen_const(*args);
+	    if (*mode == IoTYPE_NUMERIC) {
 		fd = PerlLIO_open3(name, imode, perm);
 		if (fd >= 0)
-		    return PerlIO_fdopen(fd, (char *) mode + 1);
+		    return PerlIO_fdopen(fd, mode + 1);
 	    }
 	    else if (old) {
 		return PerlIO_reopen(name, mode, old);
@@ -264,7 +334,7 @@ XS(XS_PerlIO__Layer__find)
     if (items < 2)
 	Perl_croak(aTHX_ "Usage class->find(name[,load])");
     else {
-	char *name = SvPV_nolen(ST(1));
+	const char *name = SvPV_nolen_const(ST(1));
 	ST(0) = (strEQ(name, "crlf")
 		 || strEQ(name, "raw")) ? &PL_sv_yes : &PL_sv_undef;
 	XSRETURN(1);
@@ -341,7 +411,7 @@ PerlIO_init(pTHX)
 PerlIO *
 PerlIO_importFILE(FILE *stdio, const char *mode)
 {
-    int fd = fileno(stdio);
+    const int fd = fileno(stdio);
     if (!mode || !*mode) {
 	mode = "r+";
     }
@@ -351,8 +421,8 @@ PerlIO_importFILE(FILE *stdio, const char *mode)
 FILE *
 PerlIO_findFILE(PerlIO *pio)
 {
-    int fd = PerlIO_fileno(pio);
-    FILE *f = fdopen(fd, "r+");
+    const int fd = PerlIO_fileno(pio);
+    FILE * const f = fdopen(fd, "r+");
     PerlIO_flush(pio);
     if (!f && errno == EINVAL)
 	f = fdopen(fd, "w");
@@ -381,51 +451,41 @@ PerlIO_findFILE(PerlIO *pio)
 #include <sys/mman.h>
 #endif
 
-
-void PerlIO_debug(const char *fmt, ...)
-    __attribute__ ((format(__printf__, 1, 2)));
-
 void
 PerlIO_debug(const char *fmt, ...)
 {
-    static int dbg = 0;
     va_list ap;
     dSYS;
     va_start(ap, fmt);
-    if (!dbg) {
-	char *s = PerlEnv_getenv("PERLIO_DEBUG");
+    if (!PL_perlio_debug_fd && !PL_tainting && PL_uid == PL_euid && PL_gid == PL_egid) {
+        const char *s = PerlEnv_getenv("PERLIO_DEBUG");
 	if (s && *s)
-	    dbg = PerlLIO_open3(s, O_WRONLY | O_CREAT | O_APPEND, 0666);
+	    PL_perlio_debug_fd = PerlLIO_open3(s, O_WRONLY | O_CREAT | O_APPEND, 0666);
 	else
-	    dbg = -1;
+	    PL_perlio_debug_fd = -1;
     }
-    if (dbg > 0) {
+    if (PL_perlio_debug_fd > 0) {
 	dTHX;
+	const char *s = CopFILE(PL_curcop);
+	STRLEN len;
 #ifdef USE_ITHREADS
 	/* Use fixed buffer as sv_catpvf etc. needs SVs */
 	char buffer[1024];
-	char *s;
-	STRLEN len;
-	s = CopFILE(PL_curcop);
 	if (!s)
 	    s = "(none)";
-	sprintf(buffer, "%s:%" IVdf " ", s, (IV) CopLINE(PL_curcop));
-	len = strlen(buffer);
+	len = sprintf(buffer, "%.40s:%" IVdf " ", s, (IV) CopLINE(PL_curcop));
 	vsprintf(buffer+len, fmt, ap);
-	PerlLIO_write(dbg, buffer, strlen(buffer));
+	PerlLIO_write(PL_perlio_debug_fd, buffer, strlen(buffer));
 #else
 	SV *sv = newSVpvn("", 0);
-	char *s;
-	STRLEN len;
-	s = CopFILE(PL_curcop);
 	if (!s)
 	    s = "(none)";
 	Perl_sv_catpvf(aTHX_ sv, "%s:%" IVdf " ", s,
 		       (IV) CopLINE(PL_curcop));
 	Perl_sv_vcatpvf(aTHX_ sv, fmt, &ap);
 
-	s = SvPV(sv, len);
-	PerlLIO_write(dbg, s, len);
+	s = SvPV_const(sv, len);
+	PerlLIO_write(PL_perlio_debug_fd, s, len);
 	SvREFCNT_dec(sv);
 #endif
     }
@@ -474,16 +534,18 @@ PerlIO *
 PerlIO_fdupopen(pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
 {
     if (PerlIOValid(f)) {
-	PerlIO_funcs *tab = PerlIOBase(f)->tab;
-	PerlIO *new;
+	const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
 	PerlIO_debug("fdupopen f=%p param=%p\n",(void*)f,(void*)param);
-	new = (*tab->Dup)(aTHX_ PerlIO_allocate(aTHX),f,param, flags);
-	return new;
-    }
-    else {
-	SETERRNO(EBADF, SS_IVCHAN);
-	return NULL;
+	if (tab && tab->Dup)
+	     return (*tab->Dup)(aTHX_ PerlIO_allocate(aTHX), f, param, flags);
+	else {
+	     return PerlIOBase_dup(aTHX_ PerlIO_allocate(aTHX), f, param, flags);
+	}
     }
+    else
+	 SETERRNO(EBADF, SS_IVCHAN);
+
+    return NULL;
 }
 
 void
@@ -546,7 +608,7 @@ PerlIO_list_push(pTHX_ PerlIO_list_t *list, PerlIO_funcs *funcs, SV *arg)
     p = &(list->array[list->cur++]);
     p->funcs = funcs;
     if ((p->arg = arg)) {
-	SvREFCNT_inc(arg);
+	(void)SvREFCNT_inc(arg);
     }
 }
 
@@ -640,6 +702,35 @@ PerlIO_pop(pTHX_ PerlIO *f)
     }
 }
 
+/* Return as an array the stack of layers on a filehandle.  Note that
+ * the stack is returned top-first in the array, and there are three
+ * times as many array elements as there are layers in the stack: the
+ * first element of a layer triplet is the name, the second one is the
+ * arguments, and the third one is the flags. */
+
+AV *
+PerlIO_get_layers(pTHX_ PerlIO *f)
+{
+     AV *av = newAV();
+
+     if (PerlIOValid(f)) {
+	  PerlIOl *l = PerlIOBase(f);
+
+	  while (l) {
+	       SV *name = l->tab && l->tab->name ?
+		    newSVpv(l->tab->name, 0) : &PL_sv_undef;
+	       SV *arg = l->tab && l->tab->Getarg ?
+		    (*l->tab->Getarg)(aTHX_ &l, 0, 0) : &PL_sv_undef;
+	       av_push(av, name);
+	       av_push(av, arg);
+	       av_push(av, newSViv((IV)l->flags));
+	       l = l->next;
+	  }
+     }
+
+     return av;
+}
+
 /*--------------------------------------------------------------------------------------*/
 /*
  * XS Interface for perl code
@@ -648,12 +739,13 @@ PerlIO_pop(pTHX_ PerlIO *f)
 PerlIO_funcs *
 PerlIO_find_layer(pTHX_ const char *name, STRLEN len, int load)
 {
+    dVAR;
     IV i;
     if ((SSize_t) len <= 0)
 	len = strlen(name);
     for (i = 0; i < PL_known_layers->cur; i++) {
 	PerlIO_funcs *f = PL_known_layers->array[i].funcs;
-	if (memEQ(f->name, name, len)) {
+	if (memEQ(f->name, name, len) && f->name[len] == 0) {
 	    PerlIO_debug("%.*s => %p\n", (int) len, name, (void*)f);
 	    return f;
 	}
@@ -670,7 +762,8 @@ PerlIO_find_layer(pTHX_ const char *name, STRLEN len, int load)
     	    ENTER;
 	    SAVEINT(PL_in_load_module);
 	    if (cv) {
-	        SAVESPTR(PL_warnhook);
+		SAVEGENERICSV(PL_warnhook);
+		(void)SvREFCNT_inc(cv);
 		PL_warnhook = (SV *) cv;
 	    }
 	    PL_in_load_module++;
@@ -751,7 +844,7 @@ XS(XS_io_MODIFY_SCALAR_ATTRIBUTES)
     Perl_warn(aTHX_ "attrib %" SVf, sv);
     for (i = 2; i < items; i++) {
 	STRLEN len;
-	const char *name = SvPV(ST(i), len);
+	const char *name = SvPV_const(ST(i), len);
 	SV *layer = PerlIO_find_layer(aTHX_ name, len, 1);
 	if (layer) {
 	    av_push(av, SvREFCNT_inc(layer));
@@ -777,12 +870,12 @@ PerlIO_tab_sv(pTHX_ PerlIO_funcs *tab)
 
 XS(XS_PerlIO__Layer__NoWarnings)
 {
-    /* This is used as a %SIG{__WARN__} handler to supress warnings 
+    /* This is used as a %SIG{__WARN__} handler to supress warnings
        during loading of layers.
      */
     dXSARGS;
     if (items)
-    	PerlIO_debug("warning:%s\n",SvPV_nolen(ST(0)));
+    	PerlIO_debug("warning:%s\n",SvPV_nolen_const(ST(0)));
     XSRETURN(0);
 }
 
@@ -792,9 +885,9 @@ XS(XS_PerlIO__Layer__find)
     if (items < 2)
 	Perl_croak(aTHX_ "Usage class->find(name[,load])");
     else {
-	STRLEN len = 0;
-	char *name = SvPV(ST(1), len);
-	bool load = (items > 2) ? SvTRUE(ST(2)) : 0;
+	STRLEN len;
+	const char *name = SvPV_const(ST(1), len);
+	const bool load = (items > 2) ? SvTRUE(ST(2)) : 0;
 	PerlIO_funcs *layer = PerlIO_find_layer(aTHX_ name, len, load);
 	ST(0) =
 	    (layer) ? sv_2mortal(PerlIO_tab_sv(aTHX_ layer)) :
@@ -831,10 +924,10 @@ PerlIO_parse_layers(pTHX_ PerlIO_list_t *av, const char *names)
 		     * passed. Even though this means "foo : : bar" is
 		     * seen as an invalid separator character.
 		     */
-		    char q = ((*s == '\'') ? '"' : '\'');
+		    const char q = ((*s == '\'') ? '"' : '\'');
 		    if (ckWARN(WARN_LAYER))
 			Perl_warner(aTHX_ packWARN(WARN_LAYER),
-			      "perlio: invalid separator character %c%c%c in layer specification list %s",
+			      "Invalid separator character %c%c%c in PerlIO layer specification %s",
 			      q, *s, q, s);
 		    SETERRNO(EINVAL, LIB_INVARG);
 		    return -1;
@@ -871,7 +964,7 @@ PerlIO_parse_layers(pTHX_ PerlIO_list_t *av, const char *names)
 			    e--;
 			    if (ckWARN(WARN_LAYER))
 				Perl_warner(aTHX_ packWARN(WARN_LAYER),
-				      "perlio: argument list not closed for layer \"%.*s\"",
+				      "Argument list not closed for PerlIO layer \"%.*s\"",
 				      (int) (e - s), s);
 			    return -1;
 			default:
@@ -883,7 +976,7 @@ PerlIO_parse_layers(pTHX_ PerlIO_list_t *av, const char *names)
 		    }
 		}
 		if (e > s) {
-		    bool warn_layer = ckWARN(WARN_LAYER);
+		    const bool warn_layer = ckWARN(WARN_LAYER);
 		    PerlIO_funcs *layer =
 			PerlIO_find_layer(aTHX_ s, llen, 1);
 		    if (layer) {
@@ -894,7 +987,7 @@ PerlIO_parse_layers(pTHX_ PerlIO_list_t *av, const char *names)
 		    }
 		    else {
 			if (warn_layer)
-			    Perl_warner(aTHX_ packWARN(WARN_LAYER), "perlio: unknown layer \"%.*s\"",
+			    Perl_warner(aTHX_ packWARN(WARN_LAYER), "Unknown PerlIO layer \"%.*s\"",
 				  (int) llen, s);
 			return -1;
 		    }
@@ -909,7 +1002,7 @@ PerlIO_parse_layers(pTHX_ PerlIO_list_t *av, const char *names)
 void
 PerlIO_default_buffer(pTHX_ PerlIO_list_t *av)
 {
-    PerlIO_funcs *tab = &PerlIO_perlio;
+    PERLIO_FUNCS_DECL(*tab) = &PerlIO_perlio;
 #ifdef PERLIO_USING_CRLF
     tab = &PerlIO_crlf;
 #else
@@ -943,6 +1036,9 @@ PerlIO_layer_fetch(pTHX_ PerlIO_list_t *av, IV n, PerlIO_funcs *def)
 IV
 PerlIOPop_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
 {
+    (void)mode;
+    (void)arg;
+    (void)tab;
     if (PerlIOValid(f)) {
 	PerlIO_flush(f);
 	PerlIO_pop(aTHX_ f);
@@ -951,7 +1047,7 @@ PerlIOPop_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
     return -1;
 }
 
-PerlIO_funcs PerlIO_remove = {
+PERLIO_FUNCS_DECL(PerlIO_remove) = {
     sizeof(PerlIO_funcs),
     "pop",
     0,
@@ -967,6 +1063,8 @@ PerlIO_funcs PerlIO_remove = {
     NULL,
     NULL,
     NULL,
+    NULL,
+    NULL,
     NULL,                       /* flush */
     NULL,                       /* fill */
     NULL,
@@ -985,25 +1083,25 @@ PerlIO_default_layers(pTHX)
 {
     if (!PL_def_layerlist) {
 	const char *s = (PL_tainting) ? Nullch : PerlEnv_getenv("PERLIO");
-	PerlIO_funcs *osLayer = &PerlIO_unix;
+	PERLIO_FUNCS_DECL(*osLayer) = &PerlIO_unix;
 	PL_def_layerlist = PerlIO_list_alloc(aTHX);
-	PerlIO_define_layer(aTHX_ & PerlIO_unix);
-#if defined(WIN32) && !defined(UNDER_CE)
-	PerlIO_define_layer(aTHX_ & PerlIO_win32);
+	PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_unix));
+#if defined(WIN32)
+	PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_win32));
 #if 0
 	osLayer = &PerlIO_win32;
 #endif
 #endif
-	PerlIO_define_layer(aTHX_ & PerlIO_raw);
-	PerlIO_define_layer(aTHX_ & PerlIO_perlio);
-	PerlIO_define_layer(aTHX_ & PerlIO_stdio);
-	PerlIO_define_layer(aTHX_ & PerlIO_crlf);
+	PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_raw));
+	PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_perlio));
+	PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_stdio));
+	PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_crlf));
 #ifdef HAS_MMAP
-	PerlIO_define_layer(aTHX_ & PerlIO_mmap);
+	PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_mmap));
 #endif
-	PerlIO_define_layer(aTHX_ & PerlIO_utf8);
-	PerlIO_define_layer(aTHX_ & PerlIO_remove);
-	PerlIO_define_layer(aTHX_ & PerlIO_byte);
+	PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_utf8));
+	PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_remove));
+	PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_byte));
 	PerlIO_list_push(aTHX_ PL_def_layerlist,
 			 PerlIO_find_layer(aTHX_ osLayer->name, 0, 0),
 			 &PL_sv_undef);
@@ -1037,7 +1135,7 @@ PerlIO_default_layer(pTHX_ I32 n)
     PerlIO_list_t *av = PerlIO_default_layers(aTHX);
     if (n < 0)
 	n += av->cur;
-    return PerlIO_layer_fetch(aTHX_ av, n, &PerlIO_stdio);
+    return PerlIO_layer_fetch(aTHX_ av, n, PERLIO_FUNCS_CAST(&PerlIO_stdio));
 }
 
 #define PerlIO_default_top() PerlIO_default_layer(aTHX_ -1)
@@ -1055,14 +1153,14 @@ PerlIO_stdstreams(pTHX)
 }
 
 PerlIO *
-PerlIO_push(pTHX_ PerlIO *f, PerlIO_funcs *tab, const char *mode, SV *arg)
+PerlIO_push(pTHX_ PerlIO *f, PERLIO_FUNCS_DECL(*tab), const char *mode, SV *arg)
 {
     if (tab->fsize != sizeof(PerlIO_funcs)) {
       mismatch:
 	Perl_croak(aTHX_ "Layer does not match this perl");
     }
     if (tab->size) {
-	PerlIOl *l = NULL;
+	PerlIOl *l;
 	if (tab->size < sizeof(PerlIOl)) {
 	    goto mismatch;
 	}
@@ -1071,11 +1169,12 @@ PerlIO_push(pTHX_ PerlIO *f, PerlIO_funcs *tab, const char *mode, SV *arg)
 	if (l && f) {
 	    Zero(l, tab->size, char);
 	    l->next = *f;
-	    l->tab = tab;
+	    l->tab = (PerlIO_funcs*) tab;
 	    *f = l;
 	    PerlIO_debug("PerlIO_push f=%p %s %s %p\n", (void*)f, tab->name,
 			(mode) ? mode : "(Null)", (void*)arg);
-	    if ((*l->tab->Pushed) (aTHX_ f, mode, arg, tab) != 0) {
+	    if (*l->tab->Pushed &&
+		(*l->tab->Pushed) (aTHX_ f, mode, arg, (PerlIO_funcs*) tab) != 0) {
 		PerlIO_pop(aTHX_ f);
 		return NULL;
 	    }
@@ -1085,8 +1184,9 @@ PerlIO_push(pTHX_ PerlIO *f, PerlIO_funcs *tab, const char *mode, SV *arg)
 	/* Pseudo-layer where push does its own stack adjust */
 	PerlIO_debug("PerlIO_push f=%p %s %s %p\n", (void*)f, tab->name,
 		     (mode) ? mode : "(Null)", (void*)arg);
-	if ((*tab->Pushed) (aTHX_ f, mode, arg, tab) != 0) {
-	    return NULL;
+	if (tab->Pushed &&
+	    (*tab->Pushed) (aTHX_ f, mode, arg, (PerlIO_funcs*) tab) != 0) {
+	     return NULL;
 	}
     }
     return f;
@@ -1113,10 +1213,13 @@ PerlIOBase_binmode(pTHX_ PerlIO *f)
 IV
 PerlIORaw_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
 {
+    (void)mode;
+    (void)arg;
+    (void)tab;
 
     if (PerlIOValid(f)) {
 	PerlIO *t;
-	PerlIOl *l;
+	const PerlIOl *l;
 	PerlIO_flush(f);
 	/*
 	 * Strip all layers that are not suitable for a raw stream
@@ -1238,15 +1341,20 @@ PerlIO_binmode(pTHX_ PerlIO *f, int iotype, int mode, const char *names)
 	/* Legacy binmode is now _defined_ as being equivalent to pushing :raw
 	   So code that used to be here is now in PerlIORaw_pushed().
 	 */
-	return PerlIO_push(aTHX_ f, &PerlIO_raw, Nullch, Nullsv) ? TRUE : FALSE;
+	return PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_raw), Nullch, Nullsv) ? TRUE : FALSE;
     }
 }
 
 int
 PerlIO__close(pTHX_ PerlIO *f)
 {
-    if (PerlIOValid(f))
-	return (*PerlIOBase(f)->tab->Close) (aTHX_ f);
+    if (PerlIOValid(f)) {
+	PerlIO_funcs *tab = PerlIOBase(f)->tab;
+	if (tab && tab->Close)
+	    return (*tab->Close)(aTHX_ f);
+	else
+	    return PerlIOBase_close(aTHX_ f);
+    }
     else {
 	SETERRNO(EBADF, SS_IVCHAN);
 	return -1;
@@ -1256,12 +1364,9 @@ PerlIO__close(pTHX_ PerlIO *f)
 int
 Perl_PerlIO_close(pTHX_ PerlIO *f)
 {
-    int code = -1;
-    if (PerlIOValid(f)) {
-	code = (*PerlIOBase(f)->tab->Close) (aTHX_ f);
-	while (*f) {
-	    PerlIO_pop(aTHX_ f);
-	}
+    const int code = PerlIO__close(aTHX_ f);
+    while (PerlIOValid(f)) {
+	PerlIO_pop(aTHX_ f);
     }
     return code;
 }
@@ -1269,12 +1374,7 @@ Perl_PerlIO_close(pTHX_ PerlIO *f)
 int
 Perl_PerlIO_fileno(pTHX_ PerlIO *f)
 {
-    if (PerlIOValid(f))
-	return (*PerlIOBase(f)->tab->Fileno) (aTHX_ f);
-    else {
-	SETERRNO(EBADF, SS_IVCHAN);
-	return -1;
-    }
+     Perl_PerlIO_or_Base(f, Fileno, fileno, -1, (aTHX_ f));
 }
 
 static const char *
@@ -1288,7 +1388,7 @@ PerlIO_context_layers(pTHX_ const char *mode)
 	SV *layers = PL_curcop->cop_io;
 	if (layers) {
 	    STRLEN len;
-	    type = SvPV(layers, len);
+	    type = SvPV_const(layers, len);
 	    if (type && mode[0] != 'r') {
 		/*
 		 * Skip to write part
@@ -1361,7 +1461,7 @@ PerlIO_resolve_layers(pTHX_ const char *layers,
     if (layers && *layers) {
 	PerlIO_list_t *av;
 	if (incdef) {
-	    IV i = def->cur;
+	    IV i;
 	    av = PerlIO_list_alloc(aTHX);
 	    for (i = 0; i < def->cur; i++) {
 		PerlIO_list_push(aTHX_ av, def->array[i].funcs,
@@ -1399,7 +1499,7 @@ PerlIO_openn(pTHX_ const char *layers, const char *mode, int fd,
 	}
     }
     else {
-	PerlIO_list_t *layera = NULL;
+	PerlIO_list_t *layera;
 	IV n;
 	PerlIO_funcs *tab = NULL;
 	if (PerlIOValid(f)) {
@@ -1445,8 +1545,13 @@ PerlIO_openn(pTHX_ const char *layers, const char *mode, int fd,
 	    PerlIO_debug("openn(%s,'%s','%s',%d,%x,%o,%p,%d,%p)\n",
 			 tab->name, layers, mode, fd, imode, perm,
 			 (void*)f, narg, (void*)args);
-	    f = (*tab->Open) (aTHX_ tab, layera, n, mode, fd, imode, perm,
-			      f, narg, args);
+	    if (tab->Open)
+		 f = (*tab->Open) (aTHX_ tab, layera, n, mode, fd, imode, perm,
+				   f, narg, args);
+	    else {
+		 SETERRNO(EINVAL, LIB_INVARG);
+		 f = NULL;
+	    }
 	    if (f) {
 		if (n + 1 < layera->cur) {
 		    /*
@@ -1470,56 +1575,31 @@ PerlIO_openn(pTHX_ const char *layers, const char *mode, int fd,
 SSize_t
 Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
 {
-    if (PerlIOValid(f))
-	return (*PerlIOBase(f)->tab->Read) (aTHX_ f, vbuf, count);
-    else {
-	SETERRNO(EBADF, SS_IVCHAN);
-	return -1;
-    }
+     Perl_PerlIO_or_Base(f, Read, read, -1, (aTHX_ f, vbuf, count));
 }
 
 SSize_t
 Perl_PerlIO_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
 {
-    if (PerlIOValid(f))
-	return (*PerlIOBase(f)->tab->Unread) (aTHX_ f, vbuf, count);
-    else {
-	SETERRNO(EBADF, SS_IVCHAN);
-	return -1;
-    }
+     Perl_PerlIO_or_Base(f, Unread, unread, -1, (aTHX_ f, vbuf, count));
 }
 
 SSize_t
 Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
 {
-    if (PerlIOValid(f))
-	return (*PerlIOBase(f)->tab->Write) (aTHX_ f, vbuf, count);
-    else {
-	SETERRNO(EBADF, SS_IVCHAN);
-	return -1;
-    }
+     Perl_PerlIO_or_fail(f, Write, -1, (aTHX_ f, vbuf, count));
 }
 
 int
 Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
 {
-    if (PerlIOValid(f))
-	return (*PerlIOBase(f)->tab->Seek) (aTHX_ f, offset, whence);
-    else {
-	SETERRNO(EBADF, SS_IVCHAN);
-	return -1;
-    }
+     Perl_PerlIO_or_fail(f, Seek, -1, (aTHX_ f, offset, whence));
 }
 
 Off_t
 Perl_PerlIO_tell(pTHX_ PerlIO *f)
 {
-    if (PerlIOValid(f))
-	return (*PerlIOBase(f)->tab->Tell) (aTHX_ f);
-    else {
-	SETERRNO(EBADF, SS_IVCHAN);
-	return -1;
-    }
+     Perl_PerlIO_or_fail(f, Tell, -1, (aTHX_ f));
 }
 
 int
@@ -1527,15 +1607,12 @@ Perl_PerlIO_flush(pTHX_ PerlIO *f)
 {
     if (f) {
 	if (*f) {
-	    PerlIO_funcs *tab = PerlIOBase(f)->tab;
-	    if (tab && tab->Flush) {
+	    const PerlIO_funcs *tab = PerlIOBase(f)->tab;
+
+	    if (tab && tab->Flush)
 		return (*tab->Flush) (aTHX_ f);
-	    }
-	    else {
-		PerlIO_debug("Cannot flush f=%p :%s\n", (void*)f, tab->name);
-		SETERRNO(EBADF, SS_IVCHAN);
-		return -1;
-	    }
+	    else
+		 return 0; /* If no Flush defined, silently succeed. */
 	}
 	else {
 	    PerlIO_debug("Cannot flush f=%p\n", (void*)f);
@@ -1588,81 +1665,73 @@ PerlIOBase_flush_linebuf(pTHX)
 int
 Perl_PerlIO_fill(pTHX_ PerlIO *f)
 {
-    if (PerlIOValid(f))
-	return (*PerlIOBase(f)->tab->Fill) (aTHX_ f);
-    else {
-	SETERRNO(EBADF, SS_IVCHAN);
-	return -1;
-    }
+     Perl_PerlIO_or_fail(f, Fill, -1, (aTHX_ f));
 }
 
 int
 PerlIO_isutf8(PerlIO *f)
 {
-    if (PerlIOValid(f))
-	return (PerlIOBase(f)->flags & PERLIO_F_UTF8) != 0;
-    else {
-	SETERRNO(EBADF, SS_IVCHAN);
-	return -1;
-    }
+     if (PerlIOValid(f))
+	  return (PerlIOBase(f)->flags & PERLIO_F_UTF8) != 0;
+     else
+	  SETERRNO(EBADF, SS_IVCHAN);
+
+     return -1;
 }
 
 int
 Perl_PerlIO_eof(pTHX_ PerlIO *f)
 {
-    if (PerlIOValid(f))
-	return (*PerlIOBase(f)->tab->Eof) (aTHX_ f);
-    else {
-	SETERRNO(EBADF, SS_IVCHAN);
-	return -1;
-    }
+     Perl_PerlIO_or_Base(f, Eof, eof, -1, (aTHX_ f));
 }
 
 int
 Perl_PerlIO_error(pTHX_ PerlIO *f)
 {
-    if (PerlIOValid(f))
-	return (*PerlIOBase(f)->tab->Error) (aTHX_ f);
-    else {
-	SETERRNO(EBADF, SS_IVCHAN);
-	return -1;
-    }
+     Perl_PerlIO_or_Base(f, Error, error, -1, (aTHX_ f));
 }
 
 void
 Perl_PerlIO_clearerr(pTHX_ PerlIO *f)
 {
-    if (PerlIOValid(f))
-	(*PerlIOBase(f)->tab->Clearerr) (aTHX_ f);
-    else
-	SETERRNO(EBADF, SS_IVCHAN);
+     Perl_PerlIO_or_Base_void(f, Clearerr, clearerr, (aTHX_ f));
 }
 
 void
 Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f)
 {
-    if (PerlIOValid(f))
-	(*PerlIOBase(f)->tab->Setlinebuf) (aTHX_ f);
-    else
-	SETERRNO(EBADF, SS_IVCHAN);
+     Perl_PerlIO_or_Base_void(f, Setlinebuf, setlinebuf, (aTHX_ f));
 }
 
 int
 PerlIO_has_base(PerlIO *f)
 {
-    if (PerlIOValid(f)) {
-	return (PerlIOBase(f)->tab->Get_base != NULL);
-    }
-    return 0;
+     if (PerlIOValid(f)) {
+          const PerlIO_funcs *tab = PerlIOBase(f)->tab;
+
+	  if (tab)
+	       return (tab->Get_base != NULL);
+	  SETERRNO(EINVAL, LIB_INVARG);
+     }
+     else
+	  SETERRNO(EBADF, SS_IVCHAN);
+
+     return 0;
 }
 
 int
 PerlIO_fast_gets(PerlIO *f)
 {
     if (PerlIOValid(f) && (PerlIOBase(f)->flags & PERLIO_F_FASTGETS)) {
-	PerlIO_funcs *tab = PerlIOBase(f)->tab;
-	return (tab->Set_ptrcnt != NULL);
+	 const PerlIO_funcs *tab = PerlIOBase(f)->tab;
+
+	 if (tab)
+	      return (tab->Set_ptrcnt != NULL);
+	 SETERRNO(EINVAL, LIB_INVARG);
     }
+    else
+	 SETERRNO(EBADF, SS_IVCHAN);
+
     return 0;
 }
 
@@ -1670,9 +1739,15 @@ int
 PerlIO_has_cntptr(PerlIO *f)
 {
     if (PerlIOValid(f)) {
-	PerlIO_funcs *tab = PerlIOBase(f)->tab;
-	return (tab->Get_ptr != NULL && tab->Get_cnt != NULL);
+	const PerlIO_funcs *tab = PerlIOBase(f)->tab;
+
+	if (tab)
+	     return (tab->Get_ptr != NULL && tab->Get_cnt != NULL);
+	  SETERRNO(EINVAL, LIB_INVARG);
     }
+    else
+	 SETERRNO(EBADF, SS_IVCHAN);
+
     return 0;
 }
 
@@ -1680,70 +1755,52 @@ int
 PerlIO_canset_cnt(PerlIO *f)
 {
     if (PerlIOValid(f)) {
-	PerlIOl *l = PerlIOBase(f);
-	return (l->tab->Set_ptrcnt != NULL);
+	  const PerlIO_funcs *tab = PerlIOBase(f)->tab;
+
+	  if (tab)
+	       return (tab->Set_ptrcnt != NULL);
+	  SETERRNO(EINVAL, LIB_INVARG);
     }
+    else
+	 SETERRNO(EBADF, SS_IVCHAN);
+
     return 0;
 }
 
 STDCHAR *
 Perl_PerlIO_get_base(pTHX_ PerlIO *f)
 {
-    if (PerlIOValid(f))
-	return (*PerlIOBase(f)->tab->Get_base) (aTHX_ f);
-    return NULL;
+     Perl_PerlIO_or_fail(f, Get_base, NULL, (aTHX_ f));
 }
 
 int
 Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f)
 {
-    if (PerlIOValid(f))
-	return (*PerlIOBase(f)->tab->Get_bufsiz) (aTHX_ f);
-    return 0;
+     Perl_PerlIO_or_fail(f, Get_bufsiz, -1, (aTHX_ f));
 }
 
 STDCHAR *
 Perl_PerlIO_get_ptr(pTHX_ PerlIO *f)
 {
-    if (PerlIOValid(f)) {
-	PerlIO_funcs *tab = PerlIOBase(f)->tab;
-	if (tab->Get_ptr == NULL)
-	    return NULL;
-	return (*tab->Get_ptr) (aTHX_ f);
-    }
-    return NULL;
+     Perl_PerlIO_or_fail(f, Get_ptr, NULL, (aTHX_ f));
 }
 
 int
 Perl_PerlIO_get_cnt(pTHX_ PerlIO *f)
 {
-    if (PerlIOValid(f)) {
-	PerlIO_funcs *tab = PerlIOBase(f)->tab;
-	if (tab->Get_cnt == NULL)
-	   return 0;
-	return (*tab->Get_cnt) (aTHX_ f);
-    }
-    return 0;
+     Perl_PerlIO_or_fail(f, Get_cnt, -1, (aTHX_ f));
 }
 
 void
 Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, int cnt)
 {
-    if (PerlIOValid(f)) {
-	(*PerlIOBase(f)->tab->Set_ptrcnt) (aTHX_ f, NULL, cnt);
-    }
+     Perl_PerlIO_or_fail_void(f, Set_ptrcnt, (aTHX_ f, NULL, cnt));
 }
 
 void
 Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, int cnt)
 {
-    if (PerlIOValid(f)) {
-	PerlIO_funcs *tab = PerlIOBase(f)->tab;
-	if (tab->Set_ptrcnt == NULL) {
-	    Perl_croak(aTHX_ "PerlIO buffer snooping abuse");
-	}
-	(*PerlIOBase(f)->tab->Set_ptrcnt) (aTHX_ f, ptr, cnt);
-    }
+     Perl_PerlIO_or_fail_void(f, Set_ptrcnt, (aTHX_ f, ptr, cnt));
 }
 
 
@@ -1755,6 +1812,8 @@ Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, int cnt)
 IV
 PerlIOUtf8_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
 {
+    (void)mode;
+    (void)arg;
     if (PerlIOValid(f)) {
 	if (tab->kind & PERLIO_K_UTF8)
 	    PerlIOBase(f)->flags |= PERLIO_F_UTF8;
@@ -1765,7 +1824,7 @@ PerlIOUtf8_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
     return -1;
 }
 
-PerlIO_funcs PerlIO_utf8 = {
+PERLIO_FUNCS_DECL(PerlIO_utf8) = {
     sizeof(PerlIO_funcs),
     "utf8",
     0,
@@ -1781,6 +1840,8 @@ PerlIO_funcs PerlIO_utf8 = {
     NULL,
     NULL,
     NULL,
+    NULL,
+    NULL,
     NULL,                       /* flush */
     NULL,                       /* fill */
     NULL,
@@ -1794,7 +1855,7 @@ PerlIO_funcs PerlIO_utf8 = {
     NULL,                       /* set_ptrcnt */
 };
 
-PerlIO_funcs PerlIO_byte = {
+PERLIO_FUNCS_DECL(PerlIO_byte) = {
     sizeof(PerlIO_funcs),
     "bytes",
     0,
@@ -1810,6 +1871,8 @@ PerlIO_funcs PerlIO_byte = {
     NULL,
     NULL,
     NULL,
+    NULL,
+    NULL,
     NULL,                       /* flush */
     NULL,                       /* fill */
     NULL,
@@ -1829,11 +1892,15 @@ PerlIORaw_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
 	       PerlIO *old, int narg, SV **args)
 {
     PerlIO_funcs *tab = PerlIO_default_btm();
-    return (*tab->Open) (aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
-			 old, narg, args);
+    (void)self;
+    if (tab && tab->Open)
+	 return (*tab->Open) (aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
+			      old, narg, args);
+    SETERRNO(EINVAL, LIB_INVARG);
+    return NULL;
 }
 
-PerlIO_funcs PerlIO_raw = {
+PERLIO_FUNCS_DECL(PerlIO_raw) = {
     sizeof(PerlIO_funcs),
     "raw",
     0,
@@ -1849,6 +1916,8 @@ PerlIO_funcs PerlIO_raw = {
     NULL,
     NULL,
     NULL,
+    NULL,
+    NULL,
     NULL,                       /* flush */
     NULL,                       /* fill */
     NULL,
@@ -1878,7 +1947,7 @@ PerlIO_modestr(PerlIO * f, char *buf)
 {
     char *s = buf;
     if (PerlIOValid(f)) {
-	IV flags = PerlIOBase(f)->flags;
+	const IV flags = PerlIOBase(f)->flags;
 	if (flags & PERLIO_F_APPEND) {
 	    *s++ = 'a';
 	    if (flags & PERLIO_F_CANREAD) {
@@ -1909,17 +1978,15 @@ PerlIO_modestr(PerlIO * f, char *buf)
 IV
 PerlIOBase_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
 {
-    PerlIOl *l = PerlIOBase(f);
-#if 0
-    const char *omode = mode;
-    char temp[8];
-#endif
+    PerlIOl * const l = PerlIOBase(f);
+    (void)arg;
+
     l->flags &= ~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE |
 		  PERLIO_F_TRUNCATE | PERLIO_F_APPEND);
     if (tab->Set_ptrcnt != NULL)
 	l->flags |= PERLIO_F_FASTGETS;
     if (mode) {
-	if (*mode == '#' || *mode == 'I')
+	if (*mode == IoTYPE_NUMERIC || *mode == IoTYPE_IMPLICIT)
 	    mode++;
 	switch (*mode++) {
 	case 'r':
@@ -1970,6 +2037,7 @@ PerlIOBase_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
 IV
 PerlIOBase_popped(pTHX_ PerlIO *f)
 {
+    (void)f;
     return 0;
 }
 
@@ -1979,12 +2047,10 @@ PerlIOBase_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
     /*
      * Save the position as current head considers it
      */
-    Off_t old = PerlIO_tell(f);
-    SSize_t done;
-    PerlIO_push(aTHX_ f, &PerlIO_pending, "r", Nullsv);
+    const Off_t old = PerlIO_tell(f);
+    PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_pending), "r", Nullsv);
     PerlIOSelf(f, PerlIOBuf)->posn = old;
-    done = PerlIOBuf_unread(aTHX_ f, vbuf, count);
-    return done;
+    return PerlIOBuf_unread(aTHX_ f, vbuf, count);
 }
 
 SSize_t
@@ -1992,8 +2058,11 @@ PerlIOBase_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
 {
     STDCHAR *buf = (STDCHAR *) vbuf;
     if (f) {
-	if (!(PerlIOBase(f)->flags & PERLIO_F_CANREAD))
+        if (!(PerlIOBase(f)->flags & PERLIO_F_CANREAD)) {
+	    PerlIOBase(f)->flags |= PERLIO_F_ERROR;
+	    SETERRNO(EBADF, SS_IVCHAN);
 	    return 0;
+	}
 	while (count > 0) {
 	    SSize_t avail = PerlIO_get_cnt(f);
 	    SSize_t take = 0;
@@ -2019,26 +2088,43 @@ PerlIOBase_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
 IV
 PerlIOBase_noop_ok(pTHX_ PerlIO *f)
 {
+    (void)f;
     return 0;
 }
 
 IV
 PerlIOBase_noop_fail(pTHX_ PerlIO *f)
 {
+    (void)f;
     return -1;
 }
 
 IV
 PerlIOBase_close(pTHX_ PerlIO *f)
 {
-    IV code = 0;
-    PerlIO *n = PerlIONext(f);
-    if (PerlIO_flush(f) != 0)
-	code = -1;
-    if (PerlIOValid(n) && (*PerlIOBase(n)->tab->Close)(aTHX_ n) != 0)
-	code = -1;
-    PerlIOBase(f)->flags &=
-	~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE | PERLIO_F_OPEN);
+    IV code = -1;
+    if (PerlIOValid(f)) {
+	PerlIO *n = PerlIONext(f);
+	code = PerlIO_flush(f);
+	PerlIOBase(f)->flags &=
+	   ~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE | PERLIO_F_OPEN);
+	while (PerlIOValid(n)) {
+	    const PerlIO_funcs * const tab = PerlIOBase(n)->tab;
+	    if (tab && tab->Close) {
+		if ((*tab->Close)(aTHX_ n) != 0)
+		    code = -1;
+		break;
+	    }
+	    else {
+		PerlIOBase(n)->flags &=
+		    ~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE | PERLIO_F_OPEN);
+	    }
+	    n = PerlIONext(n);
+	}
+    }
+    else {
+	SETERRNO(EBADF, SS_IVCHAN);
+    }
     return code;
 }
 
@@ -2101,17 +2187,22 @@ PerlIOBase_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
 {
     PerlIO *nexto = PerlIONext(o);
     if (PerlIOValid(nexto)) {
-	PerlIO_funcs *tab = PerlIOBase(nexto)->tab;
-	f = (*tab->Dup)(aTHX_ f, nexto, param, flags);
+	const PerlIO_funcs * const tab = PerlIOBase(nexto)->tab;
+	if (tab && tab->Dup)
+	    f = (*tab->Dup)(aTHX_ f, nexto, param, flags);
+	else
+	    f = PerlIOBase_dup(aTHX_ f, nexto, param, flags);
     }
     if (f) {
 	PerlIO_funcs *self = PerlIOBase(o)->tab;
-	SV *arg = Nullsv;
+	SV *arg;
 	char buf[8];
 	PerlIO_debug("PerlIOBase_dup %s f=%p o=%p param=%p\n",
 		     self->name, (void*)f, (void*)o, (void*)param);
-	if (self->Getarg) {
-	    arg = (*self->Getarg)(aTHX_ o,param,flags);
+	if (self->Getarg)
+	    arg = (*self->Getarg)(aTHX_ o, param, flags);
+	else {
+	    arg = Nullsv;
 	}
 	f = PerlIO_push(aTHX_ f, self, PerlIO_modestr(o,buf), arg);
 	if (arg) {
@@ -2121,30 +2212,31 @@ PerlIOBase_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
     return f;
 }
 
-#define PERLIO_MAX_REFCOUNTABLE_FD 2048
 #ifdef USE_THREADS
 perl_mutex PerlIO_mutex;
 #endif
-int PerlIO_fd_refcnt[PERLIO_MAX_REFCOUNTABLE_FD];
+
+/* PL_perlio_fd_refcnt[] is in intrpvar.h */
 
 void
 PerlIO_init(pTHX)
 {
  /* Place holder for stdstreams call ??? */
 #ifdef USE_THREADS
- MUTEX_INIT(&PerlIO_mutex);
+    MUTEX_INIT(&PerlIO_mutex);
 #endif
 }
 
 void
 PerlIOUnix_refcnt_inc(int fd)
 {
+    dTHX;
     if (fd >= 0 && fd < PERLIO_MAX_REFCOUNTABLE_FD) {
 #ifdef USE_THREADS
 	MUTEX_LOCK(&PerlIO_mutex);
 #endif
-	PerlIO_fd_refcnt[fd]++;
-	PerlIO_debug("fd %d refcnt=%d\n",fd,PerlIO_fd_refcnt[fd]);
+	PL_perlio_fd_refcnt[fd]++;
+	PerlIO_debug("fd %d refcnt=%d\n",fd,PL_perlio_fd_refcnt[fd]);
 #ifdef USE_THREADS
 	MUTEX_UNLOCK(&PerlIO_mutex);
 #endif
@@ -2154,12 +2246,13 @@ PerlIOUnix_refcnt_inc(int fd)
 int
 PerlIOUnix_refcnt_dec(int fd)
 {
+    dTHX;
     int cnt = 0;
     if (fd >= 0 && fd < PERLIO_MAX_REFCOUNTABLE_FD) {
 #ifdef USE_THREADS
 	MUTEX_LOCK(&PerlIO_mutex);
 #endif
-	cnt = --PerlIO_fd_refcnt[fd];
+	cnt = --PL_perlio_fd_refcnt[fd];
 	PerlIO_debug("fd %d refcnt=%d\n",fd,cnt);
 #ifdef USE_THREADS
 	MUTEX_UNLOCK(&PerlIO_mutex);
@@ -2189,7 +2282,7 @@ PerlIO_cleanup(pTHX)
 	PerlIO_list_free(aTHX_ PL_known_layers);
 	PL_known_layers = NULL;
     }
-    if(PL_def_layerlist) {
+    if (PL_def_layerlist) {
 	PerlIO_list_free(aTHX_ PL_def_layerlist);
 	PL_def_layerlist = NULL;
     }
@@ -2212,7 +2305,7 @@ int
 PerlIOUnix_oflags(const char *mode)
 {
     int oflags = -1;
-    if (*mode == 'I' || *mode == '#')
+    if (*mode == IoTYPE_IMPLICIT || *mode == IoTYPE_NUMERIC)
 	mode++;
     switch (*mode) {
     case 'r':
@@ -2270,26 +2363,69 @@ PerlIOUnix_fileno(pTHX_ PerlIO *f)
     return PerlIOSelf(f, PerlIOUnix)->fd;
 }
 
+static void
+PerlIOUnix_setfd(pTHX_ PerlIO *f, int fd, int imode)
+{
+    PerlIOUnix * const s = PerlIOSelf(f, PerlIOUnix);
+#if defined(WIN32)
+    Stat_t st;
+    if (PerlLIO_fstat(fd, &st) == 0) {
+	if (!S_ISREG(st.st_mode)) {
+	    PerlIO_debug("%d is not regular file\n",fd);
+    	    PerlIOBase(f)->flags |= PERLIO_F_NOTREG;
+	}
+	else {
+	    PerlIO_debug("%d _is_ a regular file\n",fd);
+	}
+    }
+#endif
+    s->fd = fd;
+    s->oflags = imode;
+    PerlIOUnix_refcnt_inc(fd);
+}
+
 IV
 PerlIOUnix_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
 {
     IV code = PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
-    PerlIOUnix *s = PerlIOSelf(f, PerlIOUnix);
     if (*PerlIONext(f)) {
 	/* We never call down so do any pending stuff now */
 	PerlIO_flush(PerlIONext(f));
-	s->fd = PerlIO_fileno(PerlIONext(f));
 	/*
 	 * XXX could (or should) we retrieve the oflags from the open file
 	 * handle rather than believing the "mode" we are passed in? XXX
 	 * Should the value on NULL mode be 0 or -1?
 	 */
-	s->oflags = mode ? PerlIOUnix_oflags(mode) : -1;
+        PerlIOUnix_setfd(aTHX_ f, PerlIO_fileno(PerlIONext(f)),
+                         mode ? PerlIOUnix_oflags(mode) : -1);
     }
     PerlIOBase(f)->flags |= PERLIO_F_OPEN;
+
     return code;
 }
 
+IV
+PerlIOUnix_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
+{
+    const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
+    Off_t new_loc;
+    if (PerlIOBase(f)->flags & PERLIO_F_NOTREG) {
+#ifdef  ESPIPE
+	SETERRNO(ESPIPE, LIB_INVARG);
+#else
+	SETERRNO(EINVAL, LIB_INVARG);
+#endif
+	return -1;
+    }
+    new_loc = PerlLIO_lseek(fd, offset, whence);
+    if (new_loc == (Off_t) - 1)
+     {
+      return -1;
+     }
+    PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
+    return  0;
+}
+
 PerlIO *
 PerlIOUnix_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
 		IV n, const char *mode, int fd, int imode,
@@ -2300,20 +2436,19 @@ PerlIOUnix_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
 	    (*PerlIOBase(f)->tab->Close)(aTHX_ f);
     }
     if (narg > 0) {
-	char *path = SvPV_nolen(*args);
-	if (*mode == '#')
+	if (*mode == IoTYPE_NUMERIC)
 	    mode++;
 	else {
 	    imode = PerlIOUnix_oflags(mode);
 	    perm = 0666;
 	}
 	if (imode != -1) {
+	    const char *path = SvPV_nolen_const(*args);
 	    fd = PerlLIO_open3(path, imode, perm);
 	}
     }
     if (fd >= 0) {
-	PerlIOUnix *s;
-	if (*mode == 'I')
+	if (*mode == IoTYPE_IMPLICIT)
 	    mode++;
 	if (!f) {
 	    f = PerlIO_allocate(aTHX);
@@ -2323,11 +2458,10 @@ PerlIOUnix_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
 		return NULL;
 	    }
 	}
-	s = PerlIOSelf(f, PerlIOUnix);
-	s->fd = fd;
-	s->oflags = imode;
+        PerlIOUnix_setfd(aTHX_ f, fd, imode);
 	PerlIOBase(f)->flags |= PERLIO_F_OPEN;
-	PerlIOUnix_refcnt_inc(fd);
+	if (*mode == IoTYPE_APPEND)
+	    PerlIOUnix_seek(aTHX_ f, 0, SEEK_END);
 	return f;
     }
     else {
@@ -2352,9 +2486,7 @@ PerlIOUnix_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
 	f = PerlIOBase_dup(aTHX_ f, o, param, flags);
 	if (f) {
 	    /* If all went well overwrite fd in dup'ed lay with the dup()'ed fd */
-	    PerlIOUnix *s = PerlIOSelf(f, PerlIOUnix);
-	    s->fd = fd;
-	    PerlIOUnix_refcnt_inc(fd);
+	    PerlIOUnix_setfd(aTHX_ f, fd, os->oflags);
 	    return f;
 	}
     }
@@ -2365,48 +2497,56 @@ PerlIOUnix_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
 SSize_t
 PerlIOUnix_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
 {
-    int fd = PerlIOSelf(f, PerlIOUnix)->fd;
+    const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
+#ifdef PERLIO_STD_SPECIAL
+    if (fd == 0)
+        return PERLIO_STD_IN(fd, vbuf, count);
+#endif
     if (!(PerlIOBase(f)->flags & PERLIO_F_CANREAD) ||
          PerlIOBase(f)->flags & (PERLIO_F_EOF|PERLIO_F_ERROR)) {
 	return 0;
     }
     while (1) {
-	SSize_t len = PerlLIO_read(fd, vbuf, count);
+	const SSize_t len = PerlLIO_read(fd, vbuf, count);
 	if (len >= 0 || errno != EINTR) {
-	    if (len < 0)
-		PerlIOBase(f)->flags |= PERLIO_F_ERROR;
-	    else if (len == 0 && count != 0)
+	    if (len < 0) {
+		if (errno != EAGAIN) {
+		    PerlIOBase(f)->flags |= PERLIO_F_ERROR;
+		}
+	    }
+	    else if (len == 0 && count != 0) {
 		PerlIOBase(f)->flags |= PERLIO_F_EOF;
+		SETERRNO(0,0);
+	    }
 	    return len;
 	}
 	PERL_ASYNC_CHECK();
     }
+    /*NOTREACHED*/
 }
 
 SSize_t
 PerlIOUnix_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
 {
-    int fd = PerlIOSelf(f, PerlIOUnix)->fd;
+    const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
+#ifdef PERLIO_STD_SPECIAL
+    if (fd == 1 || fd == 2)
+        return PERLIO_STD_OUT(fd, vbuf, count);
+#endif
     while (1) {
-	SSize_t len = PerlLIO_write(fd, vbuf, count);
+	const SSize_t len = PerlLIO_write(fd, vbuf, count);
 	if (len >= 0 || errno != EINTR) {
-	    if (len < 0)
-		PerlIOBase(f)->flags |= PERLIO_F_ERROR;
+	    if (len < 0) {
+		if (errno != EAGAIN) {
+		    PerlIOBase(f)->flags |= PERLIO_F_ERROR;
+		}
+	    }
 	    return len;
 	}
 	PERL_ASYNC_CHECK();
     }
 }
 
-IV
-PerlIOUnix_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
-{
-    Off_t new =
-	PerlLIO_lseek(PerlIOSelf(f, PerlIOUnix)->fd, offset, whence);
-    PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
-    return (new == (Off_t) - 1) ? -1 : 0;
-}
-
 Off_t
 PerlIOUnix_tell(pTHX_ PerlIO *f)
 {
@@ -2417,7 +2557,7 @@ PerlIOUnix_tell(pTHX_ PerlIO *f)
 IV
 PerlIOUnix_close(pTHX_ PerlIO *f)
 {
-    int fd = PerlIOSelf(f, PerlIOUnix)->fd;
+    const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
     int code = 0;
     if (PerlIOBase(f)->flags & PERLIO_F_OPEN) {
 	if (PerlIOUnix_refcnt_dec(fd) > 0) {
@@ -2442,7 +2582,7 @@ PerlIOUnix_close(pTHX_ PerlIO *f)
     return code;
 }
 
-PerlIO_funcs PerlIO_unix = {
+PERLIO_FUNCS_DECL(PerlIO_unix) = {
     sizeof(PerlIO_funcs),
     "unix",
     sizeof(PerlIOUnix),
@@ -2505,11 +2645,13 @@ PerlIOStdio_fileno(pTHX_ PerlIO *f)
 char *
 PerlIOStdio_mode(const char *mode, char *tmode)
 {
-    char *ret = tmode;
-    while (*mode) {
-	*tmode++ = *mode++;
+    char * const ret = tmode;
+    if (mode) {
+	while (*mode) {
+	    *tmode++ = *mode++;
+	}
     }
-#ifdef PERLIO_USING_CRLF
+#if defined(PERLIO_USING_CRLF) || defined(__CYGWIN__)
     *tmode++ = 'b';
 #endif
     *tmode = '\0';
@@ -2527,7 +2669,7 @@ PerlIOStdio_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab
 	    PerlIO_pop(aTHX_ f);
 	    return 0;
 	} else {
-	    int fd = PerlIO_fileno(n);
+	    const int fd = PerlIO_fileno(n);
 	    char tmode[8];
 	    FILE *stdio;
 	    if (fd >= 0 && (stdio  = PerlSIO_fdopen(fd,
@@ -2560,7 +2702,7 @@ PerlIO_importFILE(FILE *stdio, const char *mode)
 	       Note that the errno value set by a failing fdopen
 	       varies between stdio implementations.
 	     */
-	    int fd = PerlLIO_dup(fileno(stdio));
+	    const int fd = PerlLIO_dup(fileno(stdio));
 	    FILE *f2 = PerlSIO_fdopen(fd, (mode = "r+"));
 	    if (!f2) {
 		f2 = PerlSIO_fdopen(fd, (mode = "w"));
@@ -2575,7 +2717,7 @@ PerlIO_importFILE(FILE *stdio, const char *mode)
 	    }
 	    fclose(f2);
 	}
-	if ((f = PerlIO_push(aTHX_(f = PerlIO_allocate(aTHX)), &PerlIO_stdio, mode, Nullsv))) {
+	if ((f = PerlIO_push(aTHX_(f = PerlIO_allocate(aTHX)), PERLIO_FUNCS_CAST(&PerlIO_stdio), mode, Nullsv))) {
 	    s = PerlIOSelf(f, PerlIOStdio);
 	    s->stdio = stdio;
 	}
@@ -2590,7 +2732,7 @@ PerlIOStdio_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
 {
     char tmode[8];
     if (PerlIOValid(f)) {
-	char *path = SvPV_nolen(*args);
+	const char *path = SvPV_nolen_const(*args);
 	PerlIOStdio *s = PerlIOSelf(f, PerlIOStdio);
 	FILE *stdio;
 	PerlIOUnix_refcnt_dec(fileno(s->stdio));
@@ -2604,21 +2746,29 @@ PerlIOStdio_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
     }
     else {
 	if (narg > 0) {
-	    char *path = SvPV_nolen(*args);
-	    if (*mode == '#') {
+	    const char *path = SvPV_nolen_const(*args);
+	    if (*mode == IoTYPE_NUMERIC) {
 		mode++;
 		fd = PerlLIO_open3(path, imode, perm);
 	    }
 	    else {
-		FILE *stdio = PerlSIO_fopen(path, mode);
+	        FILE *stdio;
+	        bool appended = FALSE;
+#ifdef __CYGWIN__
+		/* Cygwin wants its 'b' early. */
+		appended = TRUE;
+		mode = PerlIOStdio_mode(mode, tmode);
+#endif
+		stdio = PerlSIO_fopen(path, mode);
 		if (stdio) {
 		    PerlIOStdio *s;
 		    if (!f) {
 			f = PerlIO_allocate(aTHX);
 		    }
-		    if ((f = PerlIO_push(aTHX_ f, self,
-				    (mode = PerlIOStdio_mode(mode, tmode)),
-				    PerlIOArg))) {
+		    if (!appended)
+		        mode = PerlIOStdio_mode(mode, tmode);
+		    f = PerlIO_push(aTHX_ f, self, mode, PerlIOArg);
+		    if (f) {
 			s = PerlIOSelf(f, PerlIOStdio);
 			s->stdio = stdio;
 			PerlIOUnix_refcnt_inc(fileno(s->stdio));
@@ -2633,7 +2783,7 @@ PerlIOStdio_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
 	if (fd >= 0) {
 	    FILE *stdio = NULL;
 	    int init = 0;
-	    if (*mode == 'I') {
+	    if (*mode == IoTYPE_IMPLICIT) {
 		init = 1;
 		mode++;
 	    }
@@ -2655,12 +2805,11 @@ PerlIOStdio_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
 				       PerlIOStdio_mode(mode, tmode));
 	    }
 	    if (stdio) {
-		PerlIOStdio *s;
 		if (!f) {
 		    f = PerlIO_allocate(aTHX);
 		}
 		if ((f = PerlIO_push(aTHX_ f, self, mode, PerlIOArg))) {
-		    s = PerlIOSelf(f, PerlIOStdio);
+		    PerlIOStdio *s = PerlIOSelf(f, PerlIOStdio);
 		    s->stdio = stdio;
 		    PerlIOUnix_refcnt_inc(fileno(s->stdio));
 		}
@@ -2679,10 +2828,10 @@ PerlIOStdio_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
      */
     if ((f = PerlIOBase_dup(aTHX_ f, o, param, flags))) {
 	FILE *stdio = PerlIOSelf(o, PerlIOStdio)->stdio;
-	int fd = fileno(stdio);
+	const int fd = fileno(stdio);
 	char mode[8];
 	if (flags & PERLIO_DUP_FD) {
-	    int dfd = PerlLIO_dup(fileno(stdio));
+	    const int dfd = PerlLIO_dup(fileno(stdio));
 	    if (dfd >= 0) {
 		stdio = PerlSIO_fdopen(dfd, PerlIO_modestr(o,mode));
 		goto set_this;
@@ -2705,11 +2854,15 @@ static int
 PerlIOStdio_invalidate_fileno(pTHX_ FILE *f)
 {
     /* XXX this could use PerlIO_canset_fileno() and
-     * PerlIO_set_fileno() support from Configure 
+     * PerlIO_set_fileno() support from Configure
      */
-#  if defined(__GLIBC__)
+#  if defined(__UCLIBC__)
+    /* uClibc must come before glibc because it defines __GLIBC__ as well. */
+    f->__filedes = -1;
+    return 1;
+#  elif defined(__GLIBC__)
     /* There may be a better way for GLIBC:
-    	- libio.h defines a flag to not close() on cleanup 
+    	- libio.h defines a flag to not close() on cleanup
      */	
     f->_fileno = -1;
     return 1;
@@ -2721,7 +2874,7 @@ PerlIOStdio_invalidate_fileno(pTHX_ FILE *f)
      *      long __pad[16];
      *  };
      *
-     * It turns out that the fd is stored in the top 32 bits of 
+     * It turns out that the fd is stored in the top 32 bits of
      * file->__pad[4]. The lower 32 bits contain flags. file->pad[5] appears
      * to contain a pointer or offset into another structure. All the
      * remaining fields are zero.
@@ -2731,12 +2884,12 @@ PerlIOStdio_invalidate_fileno(pTHX_ FILE *f)
     f->__pad[4] |= 0xffffffff00000000L;
     assert(fileno(f) == 0xffffffff);
 #    else /* !defined(_LP64) */
-    /* _file is just a unsigned char :-( 
-       Not clear why we dup() rather than using -1 
-       even if that would be treated as 0xFF - so will 
+    /* _file is just a unsigned char :-(
+       Not clear why we dup() rather than using -1
+       even if that would be treated as 0xFF - so will
        a dup fail ...
      */
-    f->_file = PerlLIO_dup(fd);
+    f->_file = PerlLIO_dup(fileno(f));
 #    endif /* defined(_LP64) */
     return 1;
 #  elif defined(__hpux)
@@ -2744,41 +2897,57 @@ PerlIOStdio_invalidate_fileno(pTHX_ FILE *f)
     f->__fileL = 0xff;
     return 1;
    /* Next one ->_file seems to be a reasonable fallback, i.e. if
-      your platform does not have special entry try this one.       
+      your platform does not have special entry try this one.
       [For OSF only have confirmation for Tru64 (alpha)
       but assume other OSFs will be similar.]
-    */    
+    */
 #  elif defined(_AIX) || defined(__osf__) || defined(__irix__)
     f->_file = -1;
     return 1;
 #  elif defined(__FreeBSD__)
     /* There may be a better way on FreeBSD:
-        - we could insert a dummy func in the _close function entry 
-	f->_close = (int (*)(void *)) dummy_close; 
+        - we could insert a dummy func in the _close function entry
+	f->_close = (int (*)(void *)) dummy_close;
+     */
+    f->_file = -1;
+    return 1;
+#  elif defined(__OpenBSD__)
+    /* There may be a better way on OpenBSD:
+        - we could insert a dummy func in the _close function entry
+	f->_close = (int (*)(void *)) dummy_close;
      */
     f->_file = -1;
     return 1;
+#  elif defined(__EMX__)
+    /* f->_flags &= ~_IOOPEN; */	/* Will leak stream->_buffer */
+    f->_handle = -1;
+    return 1;
 #  elif defined(__CYGWIN__)
     /* There may be a better way on CYGWIN:
-        - we could insert a dummy func in the _close function entry 
-	f->_close = (int (*)(void *)) dummy_close; 
+        - we could insert a dummy func in the _close function entry
+	f->_close = (int (*)(void *)) dummy_close;
      */
     f->_file = -1;
     return 1;
 #  elif defined(WIN32)
 #    if defined(__BORLANDC__)
     f->fd = PerlLIO_dup(fileno(f));
+#    elif defined(UNDER_CE)
+    /* WIN_CE does not have access to FILE internals, it hardly has FILE
+       structure at all
+     */
 #    else
     f->_file = -1;
 #    endif
     return 1;
 #  else
 #if 0
-    /* Sarathy's code did this - we fall back to a dup/dup2 hack 
+    /* Sarathy's code did this - we fall back to a dup/dup2 hack
        (which isn't thread safe) instead
-     */  
+     */
 #    error "Don't know how to set FILE.fileno on your platform"
 #endif
+    (void)f;
     return 0;
 #  endif
 }
@@ -2792,32 +2961,32 @@ PerlIOStdio_close(pTHX_ PerlIO *f)
 	return -1;
     }
     else {
-        int fd = fileno(stdio);
+        const int fd = fileno(stdio);
 	int socksfd = 0;
 	int invalidate = 0;
-	IV result;
+	IV result = 0;
 	int saveerr = 0;
 	int dupfd = 0;
 #ifdef SOCKS5_VERSION_NAME
-    	/* Socks lib overrides close() but stdio isn't linked to 
-	   that library (though we are) - so we must call close() 
-	   on sockets on stdio's behalf. 
-	 */   
+    	/* Socks lib overrides close() but stdio isn't linked to
+	   that library (though we are) - so we must call close()
+	   on sockets on stdio's behalf.
+	 */
     	int optval;
     	Sock_size_t optlen = sizeof(int);
     	if (getsockopt(fd, SOL_SOCKET, SO_TYPE, (void *) &optval, &optlen) == 0) {
             socksfd = 1;
-	    invalidate = 1;  
+	    invalidate = 1;
     	}
 #endif
     	if (PerlIOUnix_refcnt_dec(fd) > 0) {
 	    /* File descriptor still in use */
 	    invalidate = 1;
 	    socksfd = 0;
-	}    
+	}
 	if (invalidate) {
-   	    /* For STD* handles don't close the stdio at all 
-	       this is because we have shared the FILE * too 
+   	    /* For STD* handles don't close the stdio at all
+	       this is because we have shared the FILE * too
    	     */
 	    if (stdio == stdin) {
 	    	/* Some stdios are buggy fflush-ing inputs */
@@ -2826,33 +2995,34 @@ PerlIOStdio_close(pTHX_ PerlIO *f)
 	    else if (stdio == stdout || stdio == stderr) {
 	    	return PerlIO_flush(f);
 	    }
-            /* Tricky - must fclose(stdio) to free memory but not close(fd) 
-	       Use Sarathy's trick from maint-5.6 to invalidate the 
-	       fileno slot of the FILE * 
-	    */ 
+            /* Tricky - must fclose(stdio) to free memory but not close(fd)
+	       Use Sarathy's trick from maint-5.6 to invalidate the
+	       fileno slot of the FILE *
+	    */
+	    result = PerlIO_flush(f);
 	    saveerr = errno;
     	    if (!(invalidate = PerlIOStdio_invalidate_fileno(aTHX_ stdio))) {
 	    	dupfd = PerlLIO_dup(fd);
 	    }
-	} 
+	}
         result = PerlSIO_fclose(stdio);
-	/* We treat error from stdio as success if we invalidated 
-	   errno may NOT be expected EBADF 
+	/* We treat error from stdio as success if we invalidated
+	   errno may NOT be expected EBADF
 	 */
 	if (invalidate && result != 0) {
 	    errno = saveerr;
 	    result = 0;
-	} 
+	}
 	if (socksfd) {
 	    /* in SOCKS case let close() determine return value */
 	    result = close(fd);
 	}
 	if (dupfd) {
 	    PerlLIO_dup2(dupfd,fd);
-	    close(dupfd);
+	    PerlLIO_close(dupfd);
 	}
 	return result;
-    } 
+    }
 }
 
 SSize_t
@@ -2860,20 +3030,28 @@ PerlIOStdio_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
 {
     FILE *s = PerlIOSelf(f, PerlIOStdio)->stdio;
     SSize_t got = 0;
-    if (count == 1) {
-	STDCHAR *buf = (STDCHAR *) vbuf;
-	/*
-	 * Perl is expecting PerlIO_getc() to fill the buffer Linux's
-	 * stdio does not do that for fread()
-	 */
-	int ch = PerlSIO_fgetc(s);
-	if (ch != EOF) {
-	    *buf = ch;
-	    got = 1;
+    for (;;) {
+	if (count == 1) {
+	    STDCHAR *buf = (STDCHAR *) vbuf;
+	    /*
+	     * Perl is expecting PerlIO_getc() to fill the buffer Linux's
+	     * stdio does not do that for fread()
+	     */
+	    const int ch = PerlSIO_fgetc(s);
+	    if (ch != EOF) {
+		*buf = ch;
+		got = 1;
+	    }
 	}
+	else
+	    got = PerlSIO_fread(vbuf, 1, count, s);
+	if (got == 0 && PerlSIO_ferror(s))
+	    got = -1;
+	if (got >= 0 || errno != EINTR)
+	    break;
+	PERL_ASYNC_CHECK();
+	SETERRNO(0,0);	/* just in case */
     }
-    else
-	got = PerlSIO_fread(vbuf, 1, count, s);
     return got;
 }
 
@@ -2913,7 +3091,7 @@ PerlIOStdio_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
 	STDCHAR *eptr = (STDCHAR*)PerlSIO_get_ptr(s);
 	STDCHAR *buf = ((STDCHAR *) vbuf) + count;
 	while (count > 0) {
-	    int ch = *--buf & 0xFF;
+	    const int ch = *--buf & 0xFF;
 	    if (ungetc(ch,s) != ch) {
 		/* ungetc did not work */
 		break;
@@ -2938,8 +3116,16 @@ PerlIOStdio_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
 SSize_t
 PerlIOStdio_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
 {
-    return PerlSIO_fwrite(vbuf, 1, count,
-			  PerlIOSelf(f, PerlIOStdio)->stdio);
+    SSize_t got;
+    for (;;) {
+	got = PerlSIO_fwrite(vbuf, 1, count,
+			      PerlIOSelf(f, PerlIOStdio)->stdio);
+	if (got >= 0 || errno != EINTR)
+	    break;
+	PERL_ASYNC_CHECK();
+	SETERRNO(0,0);	/* just in case */
+    }
+    return got;
 }
 
 IV
@@ -3145,7 +3331,7 @@ PerlIOStdio_fill(pTHX_ PerlIO *f)
 
 
 
-PerlIO_funcs PerlIO_stdio = {
+PERLIO_FUNCS_DECL(PerlIO_stdio) = {
     sizeof(PerlIO_funcs),
     "stdio",
     sizeof(PerlIOStdio),
@@ -3179,16 +3365,16 @@ PerlIO_funcs PerlIO_stdio = {
 #ifdef USE_STDIO_PTR
     PerlIOStdio_get_ptr,
     PerlIOStdio_get_cnt,
-#if (defined(STDIO_PTR_LVALUE) && (defined(STDIO_CNT_LVALUE) || defined(STDIO_PTR_LVAL_SETS_CNT)))
-    PerlIOStdio_set_ptrcnt
-#else                           /* STDIO_PTR_LVALUE */
-    NULL
-#endif                          /* STDIO_PTR_LVALUE */
-#else                           /* USE_STDIO_PTR */
+#   if defined(HAS_FAST_STDIO) && defined(USE_FAST_STDIO)
+    PerlIOStdio_set_ptrcnt,
+#   else
+    NULL,
+#   endif /* HAS_FAST_STDIO && USE_FAST_STDIO */
+#else
+    NULL,
     NULL,
     NULL,
-    NULL
-#endif                          /* USE_STDIO_PTR */
+#endif /* USE_STDIO_PTR */
 };
 
 /* Note that calls to PerlIO_exportFILE() are reversed using
@@ -3207,10 +3393,11 @@ PerlIO_exportFILE(PerlIO * f, const char *mode)
 	stdio = PerlSIO_fdopen(PerlIO_fileno(f), mode);
 	if (stdio) {
 	    PerlIOl *l = *f;
+	    PerlIO *f2;
 	    /* De-link any lower layers so new :stdio sticks */
 	    *f = NULL;
-	    if ((f = PerlIO_push(aTHX_ f, &PerlIO_stdio, buf, Nullsv))) {
-		PerlIOStdio *s = PerlIOSelf(f, PerlIOStdio);
+	    if ((f2 = PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_stdio), buf, Nullsv))) {
+		PerlIOStdio *s = PerlIOSelf((f = f2), PerlIOStdio);
 		s->stdio = stdio;
 		/* Link previous lower layers under new one */
 		*PerlIONext(f) = l;
@@ -3244,6 +3431,7 @@ PerlIO_findFILE(PerlIO *f)
 void
 PerlIO_releaseFILE(PerlIO *p, FILE *f)
 {
+    dVAR;
     PerlIOl *l;
     while ((l = *p)) {
 	if (l->tab == &PerlIO_stdio) {
@@ -3268,12 +3456,12 @@ IV
 PerlIOBuf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
 {
     PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
-    int fd = PerlIO_fileno(f);
+    const int fd = PerlIO_fileno(f);
     if (fd >= 0 && PerlLIO_isatty(fd)) {
 	PerlIOBase(f)->flags |= PERLIO_F_LINEBUF | PERLIO_F_TTY;
     }
     if (*PerlIONext(f)) {
-	Off_t posn = PerlIO_tell(PerlIONext(f));
+	const Off_t posn = PerlIO_tell(PerlIONext(f));
 	if (posn != (Off_t) - 1) {
 	    b->posn = posn;
 	}
@@ -3288,9 +3476,12 @@ PerlIOBuf_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
 {
     if (PerlIOValid(f)) {
 	PerlIO *next = PerlIONext(f);
-	PerlIO_funcs *tab =  PerlIO_layer_fetch(aTHX_ layers, n - 1, PerlIOBase(next)->tab);
-	next = (*tab->Open) (aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
-			  next, narg, args);
+	PerlIO_funcs *tab =
+	     PerlIO_layer_fetch(aTHX_ layers, n - 1, PerlIOBase(next)->tab);
+	if (tab && tab->Open)
+	     next =
+		  (*tab->Open)(aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
+			       next, narg, args);
 	if (!next || (*PerlIOBase(f)->tab->Pushed) (aTHX_ f, mode, PerlIOArg, self) != 0) {
 	    return NULL;
 	}
@@ -3298,14 +3489,17 @@ PerlIOBuf_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
     else {
 	PerlIO_funcs *tab = PerlIO_layer_fetch(aTHX_ layers, n - 1, PerlIO_default_btm());
 	int init = 0;
-	if (*mode == 'I') {
+	if (*mode == IoTYPE_IMPLICIT) {
 	    init = 1;
 	    /*
 	     * mode++;
 	     */
 	}
-	f = (*tab->Open) (aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
-			  f, narg, args);
+	if (tab && tab->Open)
+	     f = (*tab->Open)(aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
+			      f, narg, args);
+	else
+	     SETERRNO(EINVAL, LIB_INVARG);
 	if (f) {
 	    if (PerlIO_push(aTHX_ f, self, mode, PerlIOArg) == 0) {
 		/*
@@ -3324,7 +3518,7 @@ PerlIOBuf_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
 #ifdef PERLIO_USING_CRLF
 #  ifdef PERLIO_IS_BINMODE_FD
 		if (PERLIO_IS_BINMODE_FD(fd))
-		    PerlIO_binmode(f,  '<'/*not used*/, O_BINARY, Nullch);
+		    PerlIO_binmode(aTHX_ f,  '<'/*not used*/, O_BINARY, Nullch);
 		else
 #  endif
 		/*
@@ -3352,8 +3546,8 @@ PerlIOBuf_flush(pTHX_ PerlIO *f)
 	/*
 	 * write() the buffer
 	 */
-	STDCHAR *buf = b->buf;
-	STDCHAR *p = buf;
+	const STDCHAR *buf = b->buf;
+	const STDCHAR *p = buf;
 	while (p < b->ptr) {
 	    SSize_t count = PerlIO_write(n, p, b->ptr - p);
 	    if (count > 0) {
@@ -3468,8 +3662,8 @@ PerlIOBuf_fill(pTHX_ PerlIO *f)
 SSize_t
 PerlIOBuf_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
 {
-    PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
     if (PerlIOValid(f)) {
+        const PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
 	if (!b->ptr)
 	    PerlIO_get_base(f);
 	return PerlIOBase_read(aTHX_ f, vbuf, count);
@@ -3540,8 +3734,9 @@ PerlIOBuf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
 SSize_t
 PerlIOBuf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
 {
-    PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
+    PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
     const STDCHAR *buf = (const STDCHAR *) vbuf;
+    const STDCHAR *flushptr = buf;
     Size_t written = 0;
     if (!b->buf)
 	PerlIO_get_base(f);
@@ -3552,32 +3747,26 @@ PerlIOBuf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
 	    return 0;
 	}
     }	
+    if (PerlIOBase(f)->flags & PERLIO_F_LINEBUF) {
+	flushptr = buf + count;
+	while (flushptr > buf && *(flushptr - 1) != '\n')
+	    --flushptr;
+    }
     while (count > 0) {
 	SSize_t avail = b->bufsiz - (b->ptr - b->buf);
 	if ((SSize_t) count < avail)
 	    avail = count;
+	if (flushptr > buf && flushptr <= buf + avail)
+	    avail = flushptr - buf;
 	PerlIOBase(f)->flags |= PERLIO_F_WRBUF;
-	if (PerlIOBase(f)->flags & PERLIO_F_LINEBUF) {
-	    while (avail > 0) {
-		int ch = *buf++;
-		*(b->ptr)++ = ch;
-		count--;
-		avail--;
-		written++;
-		if (ch == '\n') {
-		    PerlIO_flush(f);
-		    break;
-		}
-	    }
-	}
-	else {
-	    if (avail) {
-		Copy(buf, b->ptr, avail, STDCHAR);
-		count -= avail;
-		buf += avail;
-		written += avail;
-		b->ptr += avail;
-	    }
+	if (avail) {
+	    Copy(buf, b->ptr, avail, STDCHAR);
+	    count -= avail;
+	    buf += avail;
+	    written += avail;
+	    b->ptr += avail;
+	    if (buf == flushptr)
+		PerlIO_flush(f);
 	}
 	if (b->ptr >= (b->buf + b->bufsiz))
 	    PerlIO_flush(f);
@@ -3592,10 +3781,10 @@ PerlIOBuf_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
 {
     IV code;
     if ((code = PerlIO_flush(f)) == 0) {
-	PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
 	PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
 	code = PerlIO_seek(PerlIONext(f), offset, whence);
 	if (code == 0) {
+	    PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
 	    b->posn = PerlIO_tell(PerlIONext(f));
 	}
     }
@@ -3610,7 +3799,7 @@ PerlIOBuf_tell(pTHX_ PerlIO *f)
      * b->posn is file position where b->buf was read, or will be written
      */
     Off_t posn = b->posn;
-    if ((PerlIOBase(f)->flags & PERLIO_F_APPEND) && 
+    if ((PerlIOBase(f)->flags & PERLIO_F_APPEND) &&
         (PerlIOBase(f)->flags & PERLIO_F_WRBUF)) {
 #if 1
     	/* As O_APPEND files are normally shared in some sense it is better
@@ -3618,7 +3807,7 @@ PerlIOBuf_tell(pTHX_ PerlIO *f)
 	 */  	
 	PerlIO_flush(f);
 #else	
-        /* when file is NOT shared then this is sufficient */ 
+        /* when file is NOT shared then this is sufficient */
 	PerlIO_seek(PerlIONext(f),0, SEEK_END);
 #endif
 	posn = b->posn = PerlIO_tell(PerlIONext(f));
@@ -3635,8 +3824,8 @@ PerlIOBuf_tell(pTHX_ PerlIO *f)
 IV
 PerlIOBuf_popped(pTHX_ PerlIO *f)
 {
-    IV code = PerlIOBase_popped(aTHX_ f);
-    PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
+    const IV code = PerlIOBase_popped(aTHX_ f);
+    PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
     if (b->buf && b->buf != (STDCHAR *) & b->oneword) {
 	Safefree(b->buf);
     }
@@ -3649,8 +3838,8 @@ PerlIOBuf_popped(pTHX_ PerlIO *f)
 IV
 PerlIOBuf_close(pTHX_ PerlIO *f)
 {
-    IV code = PerlIOBase_close(aTHX_ f);
-    PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
+    const IV code = PerlIOBase_close(aTHX_ f);
+    PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
     if (b->buf && b->buf != (STDCHAR *) & b->oneword) {
 	Safefree(b->buf);
     }
@@ -3687,8 +3876,7 @@ PerlIOBuf_get_base(pTHX_ PerlIO *f)
     if (!b->buf) {
 	if (!b->bufsiz)
 	    b->bufsiz = 4096;
-	b->buf =
-	Newz('B',b->buf,b->bufsiz, STDCHAR);
+	b->buf = Newz('B',b->buf,b->bufsiz, STDCHAR);
 	if (!b->buf) {
 	    b->buf = (STDCHAR *) & b->oneword;
 	    b->bufsiz = sizeof(b->oneword);
@@ -3730,7 +3918,7 @@ PerlIOBuf_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
 
 
 
-PerlIO_funcs PerlIO_perlio = {
+PERLIO_FUNCS_DECL(PerlIO_perlio) = {
     sizeof(PerlIO_funcs),
     "perlio",
     sizeof(PerlIOBuf),
@@ -3823,7 +4011,7 @@ PerlIOPending_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
 IV
 PerlIOPending_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
 {
-    IV code = PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
+    const IV code = PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
     PerlIOl *l = PerlIOBase(f);
     /*
      * Our PerlIO_fast_gets must match what we are pushed on, or sv_gets()
@@ -3845,7 +4033,7 @@ PerlIOPending_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
     if (avail > 0)
 	got = PerlIOBuf_read(aTHX_ f, vbuf, avail);
     if (got >= 0 && got < (SSize_t)count) {
-	SSize_t more =
+	const SSize_t more =
 	    PerlIO_read(f, ((STDCHAR *) vbuf) + got, count - got);
 	if (more >= 0 || got == 0)
 	    got += more;
@@ -3853,7 +4041,7 @@ PerlIOPending_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
     return got;
 }
 
-PerlIO_funcs PerlIO_pending = {
+PERLIO_FUNCS_DECL(PerlIO_pending) = {
     sizeof(PerlIO_funcs),
     "pending",
     sizeof(PerlIOBuf),
@@ -3910,6 +4098,23 @@ PerlIOCrlf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
 		 f, PerlIOBase(f)->tab->name, (mode) ? mode : "(Null)",
 		 PerlIOBase(f)->flags);
 #endif
+    {
+      /* Enable the first CRLF capable layer you can find, but if none
+       * found, the one we just pushed is fine.  This results in at
+       * any given moment at most one CRLF-capable layer being enabled
+       * in the whole layer stack. */
+	 PerlIO *g = PerlIONext(f);
+	 while (g && *g) {
+	      PerlIOl *b = PerlIOBase(g);
+	      if (b && b->tab == &PerlIO_crlf) {
+		   if (!(b->flags & PERLIO_F_CRLF))
+			b->flags |= PERLIO_F_CRLF;
+		   PerlIO_pop(aTHX_ f);
+		   return code;
+	      }		  
+	      g = PerlIONext(g);
+	 }
+    }
     return code;
 }
 
@@ -4167,7 +4372,7 @@ PerlIOCrlf_binmode(pTHX_ PerlIO *f)
     return 0;
 }
 
-PerlIO_funcs PerlIO_crlf = {
+PERLIO_FUNCS_DECL(PerlIO_crlf) = {
     sizeof(PerlIO_funcs),
     "crlf",
     sizeof(PerlIOCrlf),
@@ -4179,8 +4384,7 @@ PerlIO_funcs PerlIO_crlf = {
     NULL,
     PerlIOBase_fileno,
     PerlIOBuf_dup,
-    PerlIOBuf_read,             /* generic read works with ptr/cnt lies
-				 * ... */
+    PerlIOBuf_read,             /* generic read works with ptr/cnt lies */
     PerlIOCrlf_unread,          /* Put CR,LF in buffer for each '\n' */
     PerlIOCrlf_write,           /* Put CR,LF in buffer for each '\n' */
     PerlIOBuf_seek,
@@ -4212,62 +4416,27 @@ typedef struct {
     STDCHAR *bbuf;              /* malloced buffer if map fails */
 } PerlIOMmap;
 
-static size_t page_size = 0;
-
 IV
 PerlIOMmap_map(pTHX_ PerlIO *f)
 {
-    PerlIOMmap *m = PerlIOSelf(f, PerlIOMmap);
-    IV flags = PerlIOBase(f)->flags;
+    dVAR;
+    PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
+    const IV flags = PerlIOBase(f)->flags;
     IV code = 0;
     if (m->len)
 	abort();
     if (flags & PERLIO_F_CANREAD) {
 	PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
-	int fd = PerlIO_fileno(f);
+	const int fd = PerlIO_fileno(f);
 	Stat_t st;
 	code = Fstat(fd, &st);
 	if (code == 0 && S_ISREG(st.st_mode)) {
 	    SSize_t len = st.st_size - b->posn;
 	    if (len > 0) {
 		Off_t posn;
-		if (!page_size) {
-#if defined(HAS_SYSCONF) && (defined(_SC_PAGESIZE) || defined(_SC_PAGE_SIZE))
-		    {
-			SETERRNO(0, SS_NORMAL);
-#   ifdef _SC_PAGESIZE
-			page_size = sysconf(_SC_PAGESIZE);
-#   else
-			page_size = sysconf(_SC_PAGE_SIZE);
-#   endif
-			if ((long) page_size < 0) {
-			    if (errno) {
-				SV *error = ERRSV;
-				char *msg;
-				STRLEN n_a;
-				(void) SvUPGRADE(error, SVt_PV);
-				msg = SvPVx(error, n_a);
-				Perl_croak(aTHX_ "panic: sysconf: %s",
-					   msg);
-			    }
-			    else
-				Perl_croak(aTHX_
-					   "panic: sysconf: pagesize unknown");
-			}
-		    }
-#else
-#   ifdef HAS_GETPAGESIZE
-		    page_size = getpagesize();
-#   else
-#       if defined(I_SYS_PARAM) && defined(PAGESIZE)
-		    page_size = PAGESIZE;       /* compiletime, bad */
-#       endif
-#   endif
-#endif
-		    if ((IV) page_size <= 0)
-			Perl_croak(aTHX_ "panic: bad pagesize %" IVdf,
-				   (IV) page_size);
-		}
+		if (PL_mmap_page_size <= 0)
+		  Perl_croak(aTHX_ "panic: bad pagesize %" IVdf,
+			     PL_mmap_page_size);
 		if (b->posn < 0) {
 		    /*
 		     * This is a hack - should never happen - open should
@@ -4275,7 +4444,7 @@ PerlIOMmap_map(pTHX_ PerlIO *f)
 		     */
 		    b->posn = PerlIO_tell(PerlIONext(f));
 		}
-		posn = (b->posn / page_size) * page_size;
+		posn = (b->posn / PL_mmap_page_size) * PL_mmap_page_size;
 		len = st.st_size - posn;
 		m->mptr = mmap(NULL, len, PROT_READ, MAP_SHARED, fd, posn);
 		if (m->mptr && m->mptr != (Mmap_t) - 1) {
@@ -4396,8 +4565,9 @@ PerlIOMmap_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
 SSize_t
 PerlIOMmap_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
 {
-    PerlIOMmap *m = PerlIOSelf(f, PerlIOMmap);
-    PerlIOBuf *b = &m->base;
+    PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
+    PerlIOBuf * const b = &m->base;
+
     if (!b->buf || !(PerlIOBase(f)->flags & PERLIO_F_WRBUF)) {
 	/*
 	 * No, or wrong sort of, buffer
@@ -4484,7 +4654,7 @@ PerlIOMmap_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
 }
 
 
-PerlIO_funcs PerlIO_mmap = {
+PERLIO_FUNCS_DECL(PerlIO_mmap) = {
     sizeof(PerlIO_funcs),
     "mmap",
     sizeof(PerlIOMmap),
@@ -4550,15 +4720,25 @@ char *
 PerlIO_getname(PerlIO *f, char *buf)
 {
     dTHX;
-    char *name = NULL;
 #ifdef VMS
+    char *name = NULL;
+    bool exported = FALSE;
     FILE *stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
-    if (stdio)
+    if (!stdio) {
+	stdio = PerlIO_exportFILE(f,0);
+	exported = TRUE;
+    }
+    if (stdio) {
 	name = fgetname(stdio, buf);
+	if (exported) PerlIO_releaseFILE(f,stdio);
+    }
+    return name;
 #else
+    (void)f;
+    (void)buf;
     Perl_croak(aTHX_ "Don't know how to get file name");
+    return Nullch;
 #endif
-    return name;
 }
 
 
@@ -4600,8 +4780,7 @@ PerlIO_getc(PerlIO *f)
 {
     dTHX;
     STDCHAR buf[1];
-    SSize_t count = PerlIO_read(f, buf, 1);
-    if (count == 1) {
+    if ( 1 == PerlIO_read(f, buf, 1) ) {
 	return (unsigned char) buf[0];
     }
     return EOF;
@@ -4653,7 +4832,7 @@ PerlIO_vprintf(PerlIO *f, const char *fmt, va_list ap)
 {
     dTHX;
     SV *sv = newSVpvn("", 0);
-    char *s;
+    const char *s;
     STRLEN len;
     SSize_t wrote;
 #ifdef NEED_VA_COPY
@@ -4663,7 +4842,7 @@ PerlIO_vprintf(PerlIO *f, const char *fmt, va_list ap)
 #else
     sv_vcatpvf(sv, fmt, &ap);
 #endif
-    s = SvPV(sv, len);
+    s = SvPV_const(sv, len);
     wrote = PerlIO_write(f, s, len);
     SvREFCNT_dec(sv);
     return wrote;
@@ -4698,35 +4877,42 @@ PerlIO_stdoutf(const char *fmt, ...)
 PerlIO *
 PerlIO_tmpfile(void)
 {
-    /*
-     * I have no idea how portable mkstemp() is ...
-     */
-#if defined(WIN32) || !defined(HAVE_MKSTEMP)
-    dTHX;
-    PerlIO *f = NULL;
-    FILE *stdio = PerlSIO_tmpfile();
-    if (stdio) {
-	if ((f = PerlIO_push(aTHX_(PerlIO_allocate(aTHX)), &PerlIO_stdio, "w+", Nullsv))) {
-	    PerlIOStdio *s = PerlIOSelf(f, PerlIOStdio);
-	    s->stdio = stdio;
-	}
-    }
-    return f;
-#else
-    dTHX;
-    SV *sv = newSVpv("/tmp/PerlIO_XXXXXX", 0);
-    int fd = mkstemp(SvPVX(sv));
-    PerlIO *f = NULL;
-    if (fd >= 0) {
-	f = PerlIO_fdopen(fd, "w+");
-	if (f) {
-	    PerlIOBase(f)->flags |= PERLIO_F_TEMP;
-	}
-	PerlLIO_unlink(SvPVX(sv));
-	SvREFCNT_dec(sv);
-    }
-    return f;
-#endif
+     dTHX;
+     PerlIO *f = NULL;
+#ifdef WIN32
+     const int fd = win32_tmpfd();
+     if (fd >= 0)
+	  f = PerlIO_fdopen(fd, "w+b");
+#else /* WIN32 */
+#    if defined(HAS_MKSTEMP) && ! defined(VMS) && ! defined(OS2)
+     SV *sv = newSVpv("/tmp/PerlIO_XXXXXX", 0);
+     /*
+      * I have no idea how portable mkstemp() is ... NI-S
+      */
+     const int fd = mkstemp(SvPVX(sv));
+     if (fd >= 0) {
+	  f = PerlIO_fdopen(fd, "w+");
+	  if (f)
+	       PerlIOBase(f)->flags |= PERLIO_F_TEMP;
+	  PerlLIO_unlink(SvPVX_const(sv));
+	  SvREFCNT_dec(sv);
+     }
+#    else	/* !HAS_MKSTEMP, fallback to stdio tmpfile(). */
+     FILE *stdio = PerlSIO_tmpfile();
+
+     if (stdio) {
+	  if ((f = PerlIO_push(aTHX_(PerlIO_allocate(aTHX)),
+                               PERLIO_FUNCS_CAST(&PerlIO_stdio),
+			       "w+", Nullsv))) {
+               PerlIOStdio *s = PerlIOSelf(f, PerlIOStdio);
+
+               if (s)
+                    s->stdio = stdio;
+          }
+     }
+#    endif /* else HAS_MKSTEMP */
+#endif /* else WIN32 */
+     return f;
 }
 
 #undef HAS_FSETPOS
@@ -4830,7 +5016,8 @@ vfprintf(FILE *fd, char *pat, char *args)
 int
 PerlIO_vsprintf(char *s, int n, const char *fmt, va_list ap)
 {
-    int val = vsprintf(s, fmt, ap);
+    dVAR;
+    const int val = vsprintf(s, fmt, ap);
     if (n >= 0) {
 	if (strlen(s) >= (STRLEN) n) {
 	    dTHX;
@@ -4856,10 +5043,12 @@ PerlIO_sprintf(char *s, int n, const char *fmt, ...)
 }
 #endif
 
-
-
-
-
-
-
-
+/*
+ * Local variables:
+ * c-indentation-style: bsd
+ * c-basic-offset: 4
+ * indent-tabs-mode: t
+ * End:
+ *
+ * ex: set ts=8 sts=4 sw=4 noet:
+ */