#define PERL_IN_PERLIO_C
#include "perl.h"
+#ifndef PERLIO_LAYERS
+int
+PerlIO_apply_layers(pTHX_ PerlIO *f, const char *mode, const char *names)
+{
+ if (!names || !*names || strEQ(names,":crlf") || strEQ(names,":raw"))
+ {
+ return 0;
+ }
+ Perl_croak(aTHX_ "Cannot apply \"%s\" in non-PerlIO perl",names);
+ /* NOTREACHED */
+ return -1;
+}
+#endif
+
#if !defined(PERL_IMPLICIT_SYS)
#ifdef PERLIO_IS_STDIO
/* Implement all the PerlIO interface ourselves.
*/
+#include "perliol.h"
+
/* We _MUST_ have <unistd.h> if we are using lseek() and may have large files */
#ifdef I_UNISTD
#include <unistd.h>
#endif
+#ifdef HAS_MMAP
+#include <sys/mman.h>
+#endif
+
#include "XSUB.h"
-#undef printf
-void PerlIO_debug(char *fmt,...) __attribute__((format(printf,1,2)));
+void PerlIO_debug(char *fmt,...) __attribute__((format(__printf__,1,2)));
void
PerlIO_debug(char *fmt,...)
static int dbg = 0;
if (!dbg)
{
- char *s = getenv("PERLIO_DEBUG");
+ char *s = PerlEnv_getenv("PERLIO_DEBUG");
if (s && *s)
- dbg = open(s,O_WRONLY|O_CREAT|O_APPEND,0666);
+ dbg = PerlLIO_open3(s,O_WRONLY|O_CREAT|O_APPEND,0666);
else
dbg = -1;
}
Perl_sv_vcatpvf(aTHX_ sv, fmt, &ap);
s = SvPV(sv,len);
- write(dbg,s,len);
+ PerlLIO_write(dbg,s,len);
va_end(ap);
SvREFCNT_dec(sv);
}
/*--------------------------------------------------------------------------------------*/
-typedef struct
-{
- char * name;
- Size_t size;
- IV kind;
- IV (*Fileno)(PerlIO *f);
- PerlIO * (*Fdopen)(int fd, const char *mode);
- PerlIO * (*Open)(const char *path, const char *mode);
- int (*Reopen)(const char *path, const char *mode, PerlIO *f);
- /* Unix-like functions - cf sfio line disciplines */
- SSize_t (*Read)(PerlIO *f, void *vbuf, Size_t count);
- SSize_t (*Unread)(PerlIO *f, const void *vbuf, Size_t count);
- SSize_t (*Write)(PerlIO *f, const void *vbuf, Size_t count);
- IV (*Seek)(PerlIO *f, Off_t offset, int whence);
- Off_t (*Tell)(PerlIO *f);
- IV (*Close)(PerlIO *f);
- /* Stdio-like buffered IO functions */
- IV (*Flush)(PerlIO *f);
- IV (*Eof)(PerlIO *f);
- IV (*Error)(PerlIO *f);
- void (*Clearerr)(PerlIO *f);
- void (*Setlinebuf)(PerlIO *f);
- /* Perl's snooping functions */
- STDCHAR * (*Get_base)(PerlIO *f);
- Size_t (*Get_bufsiz)(PerlIO *f);
- STDCHAR * (*Get_ptr)(PerlIO *f);
- SSize_t (*Get_cnt)(PerlIO *f);
- void (*Set_ptrcnt)(PerlIO *f,STDCHAR *ptr,SSize_t cnt);
-} PerlIO_funcs;
-
-
-struct _PerlIO
-{
- PerlIOl * next; /* Lower layer */
- PerlIO_funcs * tab; /* Functions for this layer */
- IV flags; /* Various flags for state */
-};
-
-/*--------------------------------------------------------------------------------------*/
-
-/* Flag values */
-#define PERLIO_F_EOF 0x00010000
-#define PERLIO_F_CANWRITE 0x00020000
-#define PERLIO_F_CANREAD 0x00040000
-#define PERLIO_F_ERROR 0x00080000
-#define PERLIO_F_TRUNCATE 0x00100000
-#define PERLIO_F_APPEND 0x00200000
-#define PERLIO_F_BINARY 0x00400000
-#define PERLIO_F_UTF8 0x00800000
-#define PERLIO_F_LINEBUF 0x01000000
-#define PERLIO_F_WRBUF 0x02000000
-#define PERLIO_F_RDBUF 0x04000000
-#define PERLIO_F_TEMP 0x08000000
-#define PERLIO_F_OPEN 0x10000000
-
-#define PerlIOBase(f) (*(f))
-#define PerlIOSelf(f,type) ((type *)PerlIOBase(f))
-#define PerlIONext(f) (&(PerlIOBase(f)->next))
-
-/*--------------------------------------------------------------------------------------*/
/* Inner level routines */
/* Table of pointers to the PerlIO structs (malloc'ed) */
}
}
+HV *PerlIO_layer_hv;
+AV *PerlIO_layer_av;
+
void
PerlIO_cleanup(void)
{
PerlIOl *l = *f;
if (l)
{
+ (*l->tab->Popped)(f);
*f = l->next;
Safefree(l);
}
}
-#undef PerlIO_close
-int
-PerlIO_close(PerlIO *f)
-{
- int code = (*PerlIOBase(f)->tab->Close)(f);
- while (*f)
- {
- PerlIO_pop(f);
- }
- return code;
-}
-
-
/*--------------------------------------------------------------------------------------*/
-/* Given the abstraction above the public API functions */
-
-#undef PerlIO_fileno
-int
-PerlIO_fileno(PerlIO *f)
-{
- return (*PerlIOBase(f)->tab->Fileno)(f);
-}
-
-
-extern PerlIO_funcs PerlIO_unix;
-extern PerlIO_funcs PerlIO_perlio;
-extern PerlIO_funcs PerlIO_stdio;
+/* XS Interface for perl code */
XS(XS_perlio_import)
{
XSRETURN_EMPTY;
}
-HV *PerlIO_layer_hv;
-AV *PerlIO_layer_av;
-
SV *
-PerlIO_find_layer(char *name, STRLEN len)
+PerlIO_find_layer(const char *name, STRLEN len)
{
dTHX;
SV **svp;
return NULL;
}
+
+static int
+perlio_mg_set(pTHX_ SV *sv, MAGIC *mg)
+{
+ if (SvROK(sv))
+ {
+ IO *io = GvIOn((GV *)SvRV(sv));
+ PerlIO *ifp = IoIFP(io);
+ PerlIO *ofp = IoOFP(io);
+ AV *av = (AV *) mg->mg_obj;
+ Perl_warn(aTHX_ "set %_ %p %p %p",sv,io,ifp,ofp);
+ }
+ return 0;
+}
+
+static int
+perlio_mg_get(pTHX_ SV *sv, MAGIC *mg)
+{
+ if (SvROK(sv))
+ {
+ IO *io = GvIOn((GV *)SvRV(sv));
+ PerlIO *ifp = IoIFP(io);
+ PerlIO *ofp = IoOFP(io);
+ AV *av = (AV *) mg->mg_obj;
+ Perl_warn(aTHX_ "get %_ %p %p %p",sv,io,ifp,ofp);
+ }
+ return 0;
+}
+
+static int
+perlio_mg_clear(pTHX_ SV *sv, MAGIC *mg)
+{
+ Perl_warn(aTHX_ "clear %_",sv);
+ return 0;
+}
+
+static int
+perlio_mg_free(pTHX_ SV *sv, MAGIC *mg)
+{
+ Perl_warn(aTHX_ "free %_",sv);
+ return 0;
+}
+
+MGVTBL perlio_vtab = {
+ perlio_mg_get,
+ perlio_mg_set,
+ NULL, /* len */
+ NULL,
+ perlio_mg_free
+};
+
+XS(XS_io_MODIFY_SCALAR_ATTRIBUTES)
+{
+ dXSARGS;
+ SV *sv = SvRV(ST(1));
+ AV *av = newAV();
+ MAGIC *mg;
+ int count = 0;
+ int i;
+ sv_magic(sv, (SV *)av, '~', NULL, 0);
+ SvRMAGICAL_off(sv);
+ mg = mg_find(sv,'~');
+ mg->mg_virtual = &perlio_vtab;
+ mg_magical(sv);
+ Perl_warn(aTHX_ "attrib %_",sv);
+ for (i=2; i < items; i++)
+ {
+ STRLEN len;
+ const char *name = SvPV(ST(i),len);
+ SV *layer = PerlIO_find_layer(name,len);
+ if (layer)
+ {
+ av_push(av,SvREFCNT_inc(layer));
+ }
+ else
+ {
+ ST(count) = ST(i);
+ count++;
+ }
+ }
+ SvREFCNT_dec(av);
+ XSRETURN(count);
+}
+
void
PerlIO_define_layer(PerlIO_funcs *tab)
{
dTHX;
HV *stash = gv_stashpv("perlio::Layer", TRUE);
- SV *sv = sv_bless(newRV_noinc(newSViv((IV) tab)),stash);
+ SV *sv = sv_bless(newRV_noinc(newSViv(PTR2IV(tab))),stash);
hv_store(PerlIO_layer_hv,tab->name,strlen(tab->name),sv,0);
}
int len;
if (!PerlIO_layer_hv)
{
- char *s = getenv("PERLIO");
+ const char *s = PerlEnv_getenv("PERLIO");
newXS("perlio::import",XS_perlio_import,__FILE__);
newXS("perlio::unimport",XS_perlio_unimport,__FILE__);
- PerlIO_layer_hv = get_hv("perlio::layers",GV_ADD|GV_ADDMULTI);
- PerlIO_layer_av = get_av("perlio::layers",GV_ADD|GV_ADDMULTI);
- PerlIO_define_layer(&PerlIO_unix);
+#if 0
+ newXS("io::MODIFY_SCALAR_ATTRIBUTES",XS_io_MODIFY_SCALAR_ATTRIBUTES,__FILE__);
+#endif
+ PerlIO_layer_hv = get_hv("open::layers",GV_ADD|GV_ADDMULTI);
+ PerlIO_layer_av = get_av("open::layers",GV_ADD|GV_ADDMULTI);
PerlIO_define_layer(&PerlIO_unix);
PerlIO_define_layer(&PerlIO_perlio);
PerlIO_define_layer(&PerlIO_stdio);
+ PerlIO_define_layer(&PerlIO_crlf);
+#ifdef HAS_MMAP
+ PerlIO_define_layer(&PerlIO_mmap);
+#endif
av_push(PerlIO_layer_av,SvREFCNT_inc(PerlIO_find_layer(PerlIO_unix.name,0)));
if (s)
{
while (*s)
{
- while (*s && isspace((unsigned char)*s))
+ while (*s && isSPACE((unsigned char)*s))
s++;
if (*s)
{
- char *e = s;
+ const char *e = s;
SV *layer;
- while (*e && !isspace((unsigned char)*e))
+ while (*e && !isSPACE((unsigned char)*e))
e++;
+ if (*s == ':')
+ s++;
layer = PerlIO_find_layer(s,e-s);
if (layer)
{
av_push(PerlIO_layer_av,SvREFCNT_inc(layer));
}
else
- Perl_warn(aTHX_ "Unknown layer %.*s",(e-s),s);
+ Perl_warn(aTHX_ "perlio: unknown layer \"%.*s\"",(e-s),s);
s = e;
}
}
svp = av_fetch(PerlIO_layer_av,n,0);
if (svp && (layer = *svp) && SvROK(layer) && SvIOK((layer = SvRV(layer))))
{
- tab = (PerlIO_funcs *) SvIV(layer);
+ tab = INT2PTR(PerlIO_funcs *, SvIV(layer));
}
/* PerlIO_debug("Layer %d is %s\n",n,tab->name); */
return tab;
}
+int
+PerlIO_apply_layers(pTHX_ PerlIO *f, const char *mode, const char *names)
+{
+ if (names)
+ {
+ const char *s = names;
+ while (*s)
+ {
+ while (isSPACE(*s))
+ s++;
+ if (*s == ':')
+ s++;
+ if (*s)
+ {
+ const char *e = s;
+ while (*e && *e != ':' && !isSPACE(*e))
+ e++;
+ if (e > s)
+ {
+ SV *layer = PerlIO_find_layer(s,e-s);
+ if (layer)
+ {
+ PerlIO_funcs *tab = INT2PTR(PerlIO_funcs *, SvIV(SvRV(layer)));
+ if (tab)
+ {
+ PerlIO *new = PerlIO_push(f,tab,mode);
+ if (!new)
+ return -1;
+ }
+ }
+ else
+ Perl_warn(aTHX_ "perlio: unknown layer \"%.*s\"",(e-s),s);
+ }
+ s = e;
+ }
+ }
+ }
+ return 0;
+}
+
#define PerlIO_default_top() PerlIO_default_layer(-1)
#define PerlIO_default_btm() PerlIO_default_layer(0)
}
}
+PerlIO *
+PerlIO_push(PerlIO *f,PerlIO_funcs *tab,const char *mode)
+{
+ PerlIOl *l = NULL;
+ Newc('L',l,tab->size,char,PerlIOl);
+ if (l)
+ {
+ Zero(l,tab->size,char);
+ l->next = *f;
+ l->tab = tab;
+ *f = l;
+ if ((*l->tab->Pushed)(f,mode) != 0)
+ {
+ PerlIO_pop(f);
+ return NULL;
+ }
+ }
+ return f;
+}
+
+/*--------------------------------------------------------------------------------------*/
+/* Given the abstraction above the public API functions */
+
+#undef PerlIO_close
+int
+PerlIO_close(PerlIO *f)
+{
+ int code = (*PerlIOBase(f)->tab->Close)(f);
+ while (*f)
+ {
+ PerlIO_pop(f);
+ }
+ return code;
+}
+
+#undef PerlIO_fileno
+int
+PerlIO_fileno(PerlIO *f)
+{
+ return (*PerlIOBase(f)->tab->Fileno)(f);
+}
+
+
+
#undef PerlIO_fdopen
PerlIO *
PerlIO_fdopen(int fd, const char *mode)
PerlIO_funcs *tab = PerlIO_default_top();
if (!_perlio)
PerlIO_stdstreams();
- return (*tab->Fdopen)(fd,mode);
+ return (*tab->Fdopen)(tab,fd,mode);
}
#undef PerlIO_open
PerlIO_funcs *tab = PerlIO_default_top();
if (!_perlio)
PerlIO_stdstreams();
- return (*tab->Open)(path,mode);
-}
-
-IV
-PerlIOBase_init(PerlIO *f, const char *mode)
-{
- PerlIOl *l = PerlIOBase(f);
- l->flags &= ~(PERLIO_F_CANREAD|PERLIO_F_CANWRITE|
- PERLIO_F_TRUNCATE|PERLIO_F_APPEND|PERLIO_F_BINARY);
- if (mode)
- {
- switch (*mode++)
- {
- case 'r':
- l->flags = PERLIO_F_CANREAD;
- break;
- case 'a':
- l->flags = PERLIO_F_APPEND|PERLIO_F_CANWRITE;
- break;
- case 'w':
- l->flags = PERLIO_F_TRUNCATE|PERLIO_F_CANWRITE;
- break;
- default:
- errno = EINVAL;
- return -1;
- }
- while (*mode)
- {
- switch (*mode++)
- {
- case '+':
- l->flags |= PERLIO_F_CANREAD|PERLIO_F_CANWRITE;
- break;
- case 'b':
- l->flags |= PERLIO_F_BINARY;
- break;
- default:
- errno = EINVAL;
- return -1;
- }
- }
- }
- else
- {
- if (l->next)
- {
- l->flags |= l->next->flags &
- (PERLIO_F_CANREAD|PERLIO_F_CANWRITE|
- PERLIO_F_TRUNCATE|PERLIO_F_APPEND|PERLIO_F_BINARY);
- }
- }
- return 0;
+ return (*tab->Open)(tab,path,mode);
}
#undef PerlIO_reopen
PerlIO_flush(f);
if ((*PerlIOBase(f)->tab->Reopen)(path,mode,f) == 0)
{
- PerlIOBase_init(f,mode);
- return f;
+ if ((*PerlIOBase(f)->tab->Pushed)(f,mode) == 0)
+ return f;
}
return NULL;
}
}
}
+#undef PerlIO_fill
+int
+PerlIO_fill(PerlIO *f)
+{
+ return (*PerlIOBase(f)->tab->Fill)(f);
+}
+
#undef PerlIO_isutf8
int
PerlIO_isutf8(PerlIO *f)
return PerlIO_fileno(PerlIONext(f));
}
-PerlIO *
-PerlIO_push(PerlIO *f,PerlIO_funcs *tab,const char *mode)
+IV
+PerlIOBase_pushed(PerlIO *f, const char *mode)
{
- PerlIOl *l = NULL;
- Newc('L',l,tab->size,char,PerlIOl);
- if (l)
+ PerlIOl *l = PerlIOBase(f);
+ l->flags &= ~(PERLIO_F_CANREAD|PERLIO_F_CANWRITE|
+ PERLIO_F_TRUNCATE|PERLIO_F_APPEND|PERLIO_F_BINARY);
+ if (mode)
{
- Zero(l,tab->size,char);
- l->next = *f;
- l->tab = tab;
- *f = l;
- PerlIOBase_init(f,mode);
+ switch (*mode++)
+ {
+ case 'r':
+ l->flags = PERLIO_F_CANREAD;
+ break;
+ case 'a':
+ l->flags = PERLIO_F_APPEND|PERLIO_F_CANWRITE;
+ break;
+ case 'w':
+ l->flags = PERLIO_F_TRUNCATE|PERLIO_F_CANWRITE;
+ break;
+ default:
+ errno = EINVAL;
+ return -1;
+ }
+ while (*mode)
+ {
+ switch (*mode++)
+ {
+ case '+':
+ l->flags |= PERLIO_F_CANREAD|PERLIO_F_CANWRITE;
+ break;
+ case 'b':
+ l->flags |= PERLIO_F_BINARY;
+ break;
+ default:
+ errno = EINVAL;
+ return -1;
+ }
+ }
}
- return f;
+ else
+ {
+ if (l->next)
+ {
+ l->flags |= l->next->flags &
+ (PERLIO_F_CANREAD|PERLIO_F_CANWRITE|
+ PERLIO_F_TRUNCATE|PERLIO_F_APPEND|PERLIO_F_BINARY);
+ }
+ }
+ return 0;
+}
+
+IV
+PerlIOBase_popped(PerlIO *f)
+{
+ return 0;
}
SSize_t
}
IV
-PerlIOBase_sync(PerlIO *f)
+PerlIOBase_noop_ok(PerlIO *f)
{
return 0;
}
IV
+PerlIOBase_noop_fail(PerlIO *f)
+{
+ return -1;
+}
+
+IV
PerlIOBase_close(PerlIO *f)
{
IV code = 0;
}
-
-
/*--------------------------------------------------------------------------------------*/
/* Bottom-most level for UNIX-like case */
}
PerlIO *
-PerlIOUnix_fdopen(int fd,const char *mode)
+PerlIOUnix_fdopen(PerlIO_funcs *self, int fd,const char *mode)
{
PerlIO *f = NULL;
if (*mode == 'I')
int oflags = PerlIOUnix_oflags(mode);
if (oflags != -1)
{
- PerlIOUnix *s = PerlIOSelf(PerlIO_push(f = PerlIO_allocate(),&PerlIO_unix,mode),PerlIOUnix);
+ PerlIOUnix *s = PerlIOSelf(PerlIO_push(f = PerlIO_allocate(),self,mode),PerlIOUnix);
s->fd = fd;
s->oflags = oflags;
PerlIOBase(f)->flags |= PERLIO_F_OPEN;
}
PerlIO *
-PerlIOUnix_open(const char *path,const char *mode)
+PerlIOUnix_open(PerlIO_funcs *self, const char *path,const char *mode)
{
PerlIO *f = NULL;
int oflags = PerlIOUnix_oflags(mode);
if (oflags != -1)
{
- int fd = open(path,oflags,0666);
+ int fd = PerlLIO_open3(path,oflags,0666);
if (fd >= 0)
{
- PerlIOUnix *s = PerlIOSelf(PerlIO_push(f = PerlIO_allocate(),&PerlIO_unix,mode),PerlIOUnix);
+ PerlIOUnix *s = PerlIOSelf(PerlIO_push(f = PerlIO_allocate(),self,mode),PerlIOUnix);
s->fd = fd;
s->oflags = oflags;
PerlIOBase(f)->flags |= PERLIO_F_OPEN;
(*PerlIOBase(f)->tab->Close)(f);
if (oflags != -1)
{
- int fd = open(path,oflags,0666);
+ int fd = PerlLIO_open3(path,oflags,0666);
if (fd >= 0)
{
s->fd = fd;
PerlIOUnix_read(PerlIO *f, void *vbuf, Size_t count)
{
int fd = PerlIOSelf(f,PerlIOUnix)->fd;
+ if (!(PerlIOBase(f)->flags & PERLIO_F_CANREAD))
+ return 0;
while (1)
{
- SSize_t len = read(fd,vbuf,count);
+ SSize_t len = PerlLIO_read(fd,vbuf,count);
if (len >= 0 || errno != EINTR)
- return len;
+ {
+ if (len < 0)
+ PerlIOBase(f)->flags |= PERLIO_F_ERROR;
+ else if (len == 0 && count != 0)
+ PerlIOBase(f)->flags |= PERLIO_F_EOF;
+ return len;
+ }
}
}
int fd = PerlIOSelf(f,PerlIOUnix)->fd;
while (1)
{
- SSize_t len = write(fd,vbuf,count);
+ SSize_t len = PerlLIO_write(fd,vbuf,count);
if (len >= 0 || errno != EINTR)
- return len;
+ {
+ if (len < 0)
+ PerlIOBase(f)->flags |= PERLIO_F_ERROR;
+ return len;
+ }
}
}
IV
PerlIOUnix_seek(PerlIO *f, Off_t offset, int whence)
{
- Off_t new = lseek(PerlIOSelf(f,PerlIOUnix)->fd,offset,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(PerlIO *f)
{
- return lseek(PerlIOSelf(f,PerlIOUnix)->fd,0,SEEK_CUR);
+ return PerlLIO_lseek(PerlIOSelf(f,PerlIOUnix)->fd,0,SEEK_CUR);
}
IV
{
int fd = PerlIOSelf(f,PerlIOUnix)->fd;
int code = 0;
- while (close(fd) != 0)
+ while (PerlLIO_close(fd) != 0)
{
if (errno != EINTR)
{
PerlIOUnix_fdopen,
PerlIOUnix_open,
PerlIOUnix_reopen,
+ PerlIOBase_pushed,
+ PerlIOBase_noop_ok,
PerlIOUnix_read,
PerlIOBase_unread,
PerlIOUnix_write,
PerlIOUnix_seek,
PerlIOUnix_tell,
PerlIOUnix_close,
- PerlIOBase_sync,
+ PerlIOBase_noop_ok, /* flush */
+ PerlIOBase_noop_fail, /* fill */
PerlIOBase_eof,
PerlIOBase_error,
PerlIOBase_clearerr,
PerlIO *
-PerlIOStdio_fdopen(int fd,const char *mode)
+PerlIOStdio_fdopen(PerlIO_funcs *self, int fd,const char *mode)
{
PerlIO *f = NULL;
int init = 0;
stdio = fdopen(fd,mode);
if (stdio)
{
- PerlIOStdio *s = PerlIOSelf(PerlIO_push(f = PerlIO_allocate(),&PerlIO_stdio,mode),PerlIOStdio);
+ PerlIOStdio *s = PerlIOSelf(PerlIO_push(f = PerlIO_allocate(),self,mode),PerlIOStdio);
s->stdio = stdio;
}
}
}
PerlIO *
-PerlIOStdio_open(const char *path,const char *mode)
+PerlIOStdio_open(PerlIO_funcs *self, const char *path,const char *mode)
{
PerlIO *f = NULL;
FILE *stdio = fopen(path,mode);
if (stdio)
{
- PerlIOStdio *s = PerlIOSelf(PerlIO_push(f = PerlIO_allocate(),&PerlIO_stdio,mode),PerlIOStdio);
+ PerlIOStdio *s = PerlIOSelf(PerlIO_push(f = PerlIO_allocate(),self,mode),PerlIOStdio);
s->stdio = stdio;
}
return f;
}
IV
+PerlIOStdio_fill(PerlIO *f)
+{
+ FILE *stdio = PerlIOSelf(f,PerlIOStdio)->stdio;
+ int c;
+ if (fflush(stdio) != 0)
+ return EOF;
+ c = fgetc(stdio);
+ if (c == EOF || ungetc(c,stdio) != c)
+ return EOF;
+ return 0;
+}
+
+IV
PerlIOStdio_eof(PerlIO *f)
{
return feof(PerlIOSelf(f,PerlIOStdio)->stdio);
PerlIOStdio_fdopen,
PerlIOStdio_open,
PerlIOStdio_reopen,
+ PerlIOBase_pushed,
+ PerlIOBase_noop_ok,
PerlIOStdio_read,
PerlIOStdio_unread,
PerlIOStdio_write,
PerlIOStdio_tell,
PerlIOStdio_close,
PerlIOStdio_flush,
+ PerlIOStdio_fill,
PerlIOStdio_eof,
PerlIOStdio_error,
PerlIOStdio_clearerr,
#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)))
+#if (defined(STDIO_PTR_LVALUE) && (defined(STDIO_CNT_LVALUE) || defined(STDIO_PTR_LVAL_SETS_CNT)))
PerlIOStdio_set_ptrcnt
#else /* STDIO_PTR_LVALUE */
NULL
/*--------------------------------------------------------------------------------------*/
/* perlio buffer layer */
-typedef struct
-{
- struct _PerlIO base;
- Off_t posn; /* Offset of buf into the file */
- STDCHAR * buf; /* Start of buffer */
- STDCHAR * end; /* End of valid part of buffer */
- STDCHAR * ptr; /* Current position in buffer */
- Size_t bufsiz; /* Size of buffer */
- IV oneword; /* Emergency buffer */
-} PerlIOBuf;
-
-
PerlIO *
-PerlIOBuf_fdopen(int fd, const char *mode)
+PerlIOBuf_fdopen(PerlIO_funcs *self, int fd, const char *mode)
{
PerlIO_funcs *tab = PerlIO_default_btm();
int init = 0;
init = 1;
mode++;
}
- f = (*tab->Fdopen)(fd,mode);
+ f = (*tab->Fdopen)(tab,fd,mode);
if (f)
{
/* Initial stderr is unbuffered */
if (!init || fd != 2)
{
- PerlIOBuf *b = PerlIOSelf(PerlIO_push(f,&PerlIO_perlio,NULL),PerlIOBuf);
+ PerlIOBuf *b = PerlIOSelf(PerlIO_push(f,self,NULL),PerlIOBuf);
b->posn = PerlIO_tell(PerlIONext(f));
}
}
}
PerlIO *
-PerlIOBuf_open(const char *path, const char *mode)
+PerlIOBuf_open(PerlIO_funcs *self, const char *path, const char *mode)
{
PerlIO_funcs *tab = PerlIO_default_btm();
- PerlIO *f = (*tab->Open)(path,mode);
+ PerlIO *f = (*tab->Open)(tab,path,mode);
if (f)
{
- PerlIOBuf *b = PerlIOSelf(PerlIO_push(f,&PerlIO_perlio,NULL),PerlIOBuf);
- b->posn = 0;
+ PerlIOBuf *b = PerlIOSelf(PerlIO_push(f,self,NULL),PerlIOBuf);
+ b->posn = PerlIO_tell(PerlIONext(f));
}
return f;
}
int
-PerlIOBase_reopen(const char *path, const char *mode, PerlIO *f)
-{
- return (*PerlIOBase(f)->tab->Reopen)(path,mode,PerlIONext(f));
-}
-
-void
-PerlIOBuf_alloc_buf(PerlIOBuf *b)
+PerlIOBuf_reopen(const char *path, const char *mode, PerlIO *f)
{
- if (!b->bufsiz)
- b->bufsiz = 4096;
- New('B',b->buf,b->bufsiz,STDCHAR);
- if (!b->buf)
+ PerlIO *next = PerlIONext(f);
+ int code = (*PerlIOBase(next)->tab->Reopen)(path,mode,next);
+ if (code = 0)
+ code = (*PerlIOBase(f)->tab->Pushed)(f,mode);
+ if (code == 0)
{
- b->buf = (STDCHAR *)&b->oneword;
- b->bufsiz = sizeof(b->oneword);
+ PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
+ b->posn = PerlIO_tell(PerlIONext(f));
}
- b->ptr = b->buf;
- b->end = b->ptr;
+ return code;
}
/* This "flush" is akin to sfio's sync in that it handles files in either
return code;
}
+IV
+PerlIOBuf_fill(PerlIO *f)
+{
+ PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
+ SSize_t avail;
+ if (PerlIO_flush(f) != 0)
+ return -1;
+ b->ptr = b->end = b->buf;
+ avail = PerlIO_read(PerlIONext(f),b->ptr,b->bufsiz);
+ if (avail <= 0)
+ {
+ if (avail == 0)
+ PerlIOBase(f)->flags |= PERLIO_F_EOF;
+ else
+ PerlIOBase(f)->flags |= PERLIO_F_ERROR;
+ return -1;
+ }
+ b->end = b->buf+avail;
+ PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
+ return 0;
+}
+
SSize_t
PerlIOBuf_read(PerlIO *f, void *vbuf, Size_t count)
{
{
Size_t got = 0;
if (!b->ptr)
- PerlIOBuf_alloc_buf(b);
+ PerlIO_get_base(f);
if (!(PerlIOBase(f)->flags & PERLIO_F_CANREAD))
return 0;
while (count > 0)
}
if (count && (b->ptr >= b->end))
{
- PerlIO_flush(f);
- b->ptr = b->end = b->buf;
- avail = PerlIO_read(PerlIONext(f),b->ptr,b->bufsiz);
- if (avail <= 0)
- {
- if (avail == 0)
- PerlIOBase(f)->flags |= PERLIO_F_EOF;
- else
- PerlIOBase(f)->flags |= PERLIO_F_ERROR;
- break;
- }
- b->end = b->buf+avail;
- PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
+ if (PerlIO_fill(f) != 0)
+ break;
}
}
return got;
PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
SSize_t unread = 0;
SSize_t avail;
- if (!b->buf)
- PerlIOBuf_alloc_buf(b);
if (PerlIOBase(f)->flags & PERLIO_F_WRBUF)
PerlIO_flush(f);
+ if (!b->buf)
+ PerlIO_get_base(f);
if (b->buf)
{
if (PerlIOBase(f)->flags & PERLIO_F_RDBUF)
const STDCHAR *buf = (const STDCHAR *) vbuf;
Size_t written = 0;
if (!b->buf)
- PerlIOBuf_alloc_buf(b);
+ PerlIO_get_base(f);
if (!(PerlIOBase(f)->flags & PERLIO_F_CANWRITE))
return 0;
while (count > 0)
PerlIOBuf_seek(PerlIO *f, Off_t offset, int whence)
{
PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
- int code;
- code = PerlIO_flush(f);
+ int code = PerlIO_flush(f);
if (code == 0)
{
PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
}
}
-void
-PerlIOBuf_set_cnt(PerlIO *f, int cnt)
-{
- PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
- dTHX;
- if (!b->buf)
- PerlIOBuf_alloc_buf(b);
- b->ptr = b->end - cnt;
- assert(b->ptr >= b->buf);
-}
-
STDCHAR *
PerlIOBuf_get_ptr(PerlIO *f)
{
PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
if (!b->buf)
- PerlIOBuf_alloc_buf(b);
+ PerlIO_get_base(f);
return b->ptr;
}
{
PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
if (!b->buf)
- PerlIOBuf_alloc_buf(b);
+ PerlIO_get_base(f);
if (PerlIOBase(f)->flags & PERLIO_F_RDBUF)
return (b->end - b->ptr);
return 0;
{
PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
if (!b->buf)
- PerlIOBuf_alloc_buf(b);
+ {
+ if (!b->bufsiz)
+ b->bufsiz = 4096;
+ New('B',b->buf,b->bufsiz,STDCHAR);
+ if (!b->buf)
+ {
+ b->buf = (STDCHAR *)&b->oneword;
+ b->bufsiz = sizeof(b->oneword);
+ }
+ b->ptr = b->buf;
+ b->end = b->ptr;
+ }
return b->buf;
}
{
PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
if (!b->buf)
- PerlIOBuf_alloc_buf(b);
+ PerlIO_get_base(f);
return (b->end - b->buf);
}
{
PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
if (!b->buf)
- PerlIOBuf_alloc_buf(b);
+ PerlIO_get_base(f);
b->ptr = ptr;
if (PerlIO_get_cnt(f) != cnt || b->ptr < b->buf)
{
PerlIOBase_fileno,
PerlIOBuf_fdopen,
PerlIOBuf_open,
- PerlIOBase_reopen,
+ PerlIOBuf_reopen,
+ PerlIOBase_pushed,
+ PerlIOBase_noop_ok,
PerlIOBuf_read,
PerlIOBuf_unread,
PerlIOBuf_write,
PerlIOBuf_tell,
PerlIOBuf_close,
PerlIOBuf_flush,
+ PerlIOBuf_fill,
PerlIOBase_eof,
PerlIOBase_error,
PerlIOBase_clearerr,
PerlIOBuf_set_ptrcnt,
};
+/*--------------------------------------------------------------------------------------*/
+/* crlf - translation currently just a copy of perlio to prove
+ that extra buffering which real one will do is not an issue.
+ */
+
+PerlIO_funcs PerlIO_crlf = {
+ "crlf",
+ sizeof(PerlIOBuf),
+ 0,
+ PerlIOBase_fileno,
+ PerlIOBuf_fdopen,
+ PerlIOBuf_open,
+ PerlIOBuf_reopen,
+ PerlIOBase_pushed,
+ PerlIOBase_noop_ok,
+ PerlIOBuf_read,
+ PerlIOBuf_unread,
+ PerlIOBuf_write,
+ PerlIOBuf_seek,
+ PerlIOBuf_tell,
+ PerlIOBuf_close,
+ PerlIOBuf_flush,
+ PerlIOBuf_fill,
+ PerlIOBase_eof,
+ PerlIOBase_error,
+ PerlIOBase_clearerr,
+ PerlIOBuf_setlinebuf,
+ PerlIOBuf_get_base,
+ PerlIOBuf_bufsiz,
+ PerlIOBuf_get_ptr,
+ PerlIOBuf_get_cnt,
+ PerlIOBuf_set_ptrcnt,
+};
+
+#ifdef HAS_MMAP
+/*--------------------------------------------------------------------------------------*/
+/* mmap as "buffer" layer */
+
+typedef struct
+{
+ PerlIOBuf base; /* PerlIOBuf stuff */
+ Mmap_t mptr; /* Mapped address */
+ Size_t len; /* mapped length */
+ STDCHAR *bbuf; /* malloced buffer if map fails */
+
+} PerlIOMmap;
+
+static size_t page_size = 0;
+
+IV
+PerlIOMmap_map(PerlIO *f)
+{
+ dTHX;
+ PerlIOMmap *m = PerlIOSelf(f,PerlIOMmap);
+ PerlIOBuf *b = &m->base;
+ 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);
+ struct stat 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 (b->posn < 0)
+ {
+ /* This is a hack - should never happen - open should have set it ! */
+ b->posn = PerlIO_tell(PerlIONext(f));
+ }
+ posn = (b->posn / page_size) * page_size;
+ len = st.st_size - posn;
+ m->mptr = mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, posn);
+ if (m->mptr && m->mptr != (Mmap_t) -1)
+ {
+#if defined(HAS_MADVISE) && defined(MADV_SEQUENTIAL)
+ madvise(m->mptr, len, MADV_SEQUENTIAL);
+#endif
+ PerlIOBase(f)->flags = (flags & ~PERLIO_F_EOF) | PERLIO_F_RDBUF;
+ b->end = ((STDCHAR *)m->mptr) + len;
+ b->buf = ((STDCHAR *)m->mptr) + (b->posn - posn);
+ b->ptr = b->buf;
+ m->len = len;
+ }
+ else
+ {
+ b->buf = NULL;
+ }
+ }
+ else
+ {
+ PerlIOBase(f)->flags = flags | PERLIO_F_EOF | PERLIO_F_RDBUF;
+ b->buf = NULL;
+ b->ptr = b->end = b->ptr;
+ code = -1;
+ }
+ }
+ }
+ return code;
+}
+
+IV
+PerlIOMmap_unmap(PerlIO *f)
+{
+ PerlIOMmap *m = PerlIOSelf(f,PerlIOMmap);
+ PerlIOBuf *b = &m->base;
+ IV code = 0;
+ if (m->len)
+ {
+ if (b->buf)
+ {
+ code = munmap(m->mptr, m->len);
+ b->buf = NULL;
+ m->len = 0;
+ m->mptr = NULL;
+ if (PerlIO_seek(PerlIONext(f),b->posn,SEEK_SET) != 0)
+ code = -1;
+ }
+ b->ptr = b->end = b->buf;
+ PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF|PERLIO_F_WRBUF);
+ }
+ return code;
+}
+
+STDCHAR *
+PerlIOMmap_get_base(PerlIO *f)
+{
+ PerlIOMmap *m = PerlIOSelf(f,PerlIOMmap);
+ PerlIOBuf *b = &m->base;
+ if (b->buf && (PerlIOBase(f)->flags & PERLIO_F_RDBUF))
+ {
+ /* Already have a readbuffer in progress */
+ return b->buf;
+ }
+ if (b->buf)
+ {
+ /* We have a write buffer or flushed PerlIOBuf read buffer */
+ m->bbuf = b->buf; /* save it in case we need it again */
+ b->buf = NULL; /* Clear to trigger below */
+ }
+ if (!b->buf)
+ {
+ PerlIOMmap_map(f); /* Try and map it */
+ if (!b->buf)
+ {
+ /* Map did not work - recover PerlIOBuf buffer if we have one */
+ b->buf = m->bbuf;
+ }
+ }
+ b->ptr = b->end = b->buf;
+ if (b->buf)
+ return b->buf;
+ return PerlIOBuf_get_base(f);
+}
+
+SSize_t
+PerlIOMmap_unread(PerlIO *f, const void *vbuf, Size_t count)
+{
+ PerlIOMmap *m = PerlIOSelf(f,PerlIOMmap);
+ PerlIOBuf *b = &m->base;
+ if (PerlIOBase(f)->flags & PERLIO_F_WRBUF)
+ PerlIO_flush(f);
+ if (b->ptr && (b->ptr - count) >= b->buf && memEQ(b->ptr - count,vbuf,count))
+ {
+ b->ptr -= count;
+ PerlIOBase(f)->flags &= ~ PERLIO_F_EOF;
+ return count;
+ }
+ if (m->len)
+ {
+ /* Loose the unwritable mapped buffer */
+ PerlIO_flush(f);
+ /* If flush took the "buffer" see if we have one from before */
+ if (!b->buf && m->bbuf)
+ b->buf = m->bbuf;
+ if (!b->buf)
+ {
+ PerlIOBuf_get_base(f);
+ m->bbuf = b->buf;
+ }
+ }
+ return PerlIOBuf_unread(f,vbuf,count);
+}
+
+SSize_t
+PerlIOMmap_write(PerlIO *f, const void *vbuf, Size_t count)
+{
+ PerlIOMmap *m = PerlIOSelf(f,PerlIOMmap);
+ PerlIOBuf *b = &m->base;
+ if (!b->buf || !(PerlIOBase(f)->flags & PERLIO_F_WRBUF))
+ {
+ /* No, or wrong sort of, buffer */
+ if (m->len)
+ {
+ if (PerlIOMmap_unmap(f) != 0)
+ return 0;
+ }
+ /* If unmap took the "buffer" see if we have one from before */
+ if (!b->buf && m->bbuf)
+ b->buf = m->bbuf;
+ if (!b->buf)
+ {
+ PerlIOBuf_get_base(f);
+ m->bbuf = b->buf;
+ }
+ }
+ return PerlIOBuf_write(f,vbuf,count);
+}
+
+IV
+PerlIOMmap_flush(PerlIO *f)
+{
+ PerlIOMmap *m = PerlIOSelf(f,PerlIOMmap);
+ PerlIOBuf *b = &m->base;
+ IV code = PerlIOBuf_flush(f);
+ /* Now we are "synced" at PerlIOBuf level */
+ if (b->buf)
+ {
+ if (m->len)
+ {
+ /* Unmap the buffer */
+ if (PerlIOMmap_unmap(f) != 0)
+ code = -1;
+ }
+ else
+ {
+ /* We seem to have a PerlIOBuf buffer which was not mapped
+ * remember it in case we need one later
+ */
+ m->bbuf = b->buf;
+ }
+ }
+ return code;
+}
+
+IV
+PerlIOMmap_fill(PerlIO *f)
+{
+ PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
+ IV code = PerlIO_flush(f);
+ if (code == 0 && !b->buf)
+ {
+ code = PerlIOMmap_map(f);
+ }
+ if (code == 0 && !(PerlIOBase(f)->flags & PERLIO_F_RDBUF))
+ {
+ code = PerlIOBuf_fill(f);
+ }
+ return code;
+}
+
+IV
+PerlIOMmap_close(PerlIO *f)
+{
+ PerlIOMmap *m = PerlIOSelf(f,PerlIOMmap);
+ PerlIOBuf *b = &m->base;
+ IV code = PerlIO_flush(f);
+ if (m->bbuf)
+ {
+ b->buf = m->bbuf;
+ m->bbuf = NULL;
+ b->ptr = b->end = b->buf;
+ }
+ if (PerlIOBuf_close(f) != 0)
+ code = -1;
+ return code;
+}
+
+
+PerlIO_funcs PerlIO_mmap = {
+ "mmap",
+ sizeof(PerlIOMmap),
+ 0,
+ PerlIOBase_fileno,
+ PerlIOBuf_fdopen,
+ PerlIOBuf_open,
+ PerlIOBuf_reopen,
+ PerlIOBase_pushed,
+ PerlIOBase_noop_ok,
+ PerlIOBuf_read,
+ PerlIOMmap_unread,
+ PerlIOMmap_write,
+ PerlIOBuf_seek,
+ PerlIOBuf_tell,
+ PerlIOBuf_close,
+ PerlIOMmap_flush,
+ PerlIOMmap_fill,
+ PerlIOBase_eof,
+ PerlIOBase_error,
+ PerlIOBase_clearerr,
+ PerlIOBuf_setlinebuf,
+ PerlIOMmap_get_base,
+ PerlIOBuf_bufsiz,
+ PerlIOBuf_get_ptr,
+ PerlIOBuf_get_cnt,
+ PerlIOBuf_set_ptrcnt,
+};
+
+#endif /* HAS_MMAP */
+
void
PerlIO_init(void)
{
{
PerlIOBase(f)->flags |= PERLIO_F_TEMP;
}
- unlink(SvPVX(sv));
+ PerlLIO_unlink(SvPVX(sv));
SvREFCNT_dec(sv);
}
return f;
PerlIO_getpos(PerlIO *f, Fpos_t *pos)
{
*pos = PerlIO_tell(f);
- return 0;
+ return *pos == -1 ? -1 : 0;
}
#else
#ifndef PERLIO_IS_STDIO
if (strlen(s) >= (STRLEN)n)
{
dTHX;
- PerlIO_puts(Perl_error_log,"panic: sprintf overflow - memory corrupted!\n");
+ (void)PerlIO_puts(Perl_error_log,
+ "panic: sprintf overflow - memory corrupted!\n");
my_exit(1);
}
}