#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)));
char *s;
STRLEN len;
va_start(ap,fmt);
- sv_vcatpvf(sv, fmt, &ap);
+ 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);
write(dbg,s,len);
va_end(ap);
/*--------------------------------------------------------------------------------------*/
-typedef struct
+typedef struct _PerlIO_funcs PerlIO_funcs;
+struct _PerlIO_funcs
{
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);
+ PerlIO * (*Fdopen)(PerlIO_funcs *tab, int fd, const char *mode);
+ PerlIO * (*Open)(PerlIO_funcs *tab, const char *path, const char *mode);
int (*Reopen)(const char *path, const char *mode, PerlIO *f);
+ IV (*Pushed)(PerlIO *f,const char *mode);
+ IV (*Popped)(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);
IV (*Close)(PerlIO *f);
/* Stdio-like buffered IO functions */
IV (*Flush)(PerlIO *f);
+ IV (*Fill)(PerlIO *f);
IV (*Eof)(PerlIO *f);
IV (*Error)(PerlIO *f);
void (*Clearerr)(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
{
/*--------------------------------------------------------------------------------------*/
/* Flag values */
-#define PERLIO_F_EOF 0x0010000
-#define PERLIO_F_CANWRITE 0x0020000
-#define PERLIO_F_CANREAD 0x0040000
-#define PERLIO_F_ERROR 0x0080000
-#define PERLIO_F_TRUNCATE 0x0100000
-#define PERLIO_F_APPEND 0x0200000
-#define PERLIO_F_BINARY 0x0400000
-#define PERLIO_F_TEMP 0x0800000
-#define PERLIO_F_LINEBUF 0x0100000
-#define PERLIO_F_WRBUF 0x2000000
-#define PERLIO_F_RDBUF 0x4000000
-#define PERLIO_F_OPEN 0x8000000
+#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))
/* Inner level routines */
/* Table of pointers to the PerlIO structs (malloc'ed) */
-PerlIO **_perlio = NULL;
-int _perlio_size = 0;
+PerlIO *_perlio = NULL;
+#define PERLIO_TABLE_SIZE 64
PerlIO *
PerlIO_allocate(void)
{
- /* Find a free slot in the table, growing table as necessary */
+ /* Find a free slot in the table, allocating new table as necessary */
+ PerlIO **last = &_perlio;
PerlIO *f;
- int i = 0;
- while (1)
+ while ((f = *last))
{
- PerlIO **table = _perlio;
- while (i < _perlio_size)
+ int i;
+ last = (PerlIO **)(f);
+ for (i=1; i < PERLIO_TABLE_SIZE; i++)
{
- f = table[i];
- if (!f)
+ if (!*++f)
{
- Newz('F',f,1,PerlIO);
- if (!f)
- return NULL;
- table[i] = f;
- }
- if (!*f)
- {
- PerlIO_debug(__FUNCTION__ " f=%p\n",f);
return f;
}
- i++;
}
- Newz('I',table,_perlio_size+16,PerlIO *);
- if (!table)
- return NULL;
- Copy(_perlio,table,_perlio_size,PerlIO *);
- if (_perlio)
- Safefree(_perlio);
- _perlio = table;
- _perlio_size += 16;
+ }
+ Newz('I',f,PERLIO_TABLE_SIZE,PerlIO);
+ if (!f)
+ return NULL;
+ *last = f;
+ return f+1;
+}
+
+void
+PerlIO_cleantable(PerlIO **tablep)
+{
+ PerlIO *table = *tablep;
+ if (table)
+ {
+ int i;
+ PerlIO_cleantable((PerlIO **) &(table[0]));
+ for (i=PERLIO_TABLE_SIZE-1; i > 0; i--)
+ {
+ PerlIO *f = table+i;
+ if (*f)
+ PerlIO_close(f);
+ }
+ Safefree(table);
+ *tablep = NULL;
}
}
+HV *PerlIO_layer_hv;
+AV *PerlIO_layer_av;
+
+void
+PerlIO_cleanup(void)
+{
+ PerlIO_cleantable(&_perlio);
+}
+
void
PerlIO_pop(PerlIO *f)
{
PerlIOl *l = *f;
if (l)
{
+ (*l->tab->Popped)(f);
*f = l->next;
Safefree(l);
}
return code;
}
-void
-PerlIO_cleanup(void)
-{
- /* Close all the files */
- int i;
- for (i=_perlio_size-1; i >= 0; i--)
- {
- PerlIO *f = _perlio[i];
- if (f)
- {
- if (*f)
- PerlIO_close(f);
- Safefree(f);
- }
- }
- if (_perlio)
- Safefree(_perlio);
- _perlio = NULL;
- _perlio_size = 0;
-}
-
-
/*--------------------------------------------------------------------------------------*/
/* Given the abstraction above the public API functions */
return (*PerlIOBase(f)->tab->Fileno)(f);
}
+
extern PerlIO_funcs PerlIO_unix;
-extern PerlIO_funcs PerlIO_stdio;
extern PerlIO_funcs PerlIO_perlio;
+extern PerlIO_funcs PerlIO_stdio;
+#ifdef HAS_MMAP
+extern PerlIO_funcs PerlIO_mmap;
+#endif
+
+XS(XS_perlio_import)
+{
+ dXSARGS;
+ GV *gv = CvGV(cv);
+ char *s = GvNAME(gv);
+ STRLEN l = GvNAMELEN(gv);
+ PerlIO_debug("%.*s\n",(int) l,s);
+ XSRETURN_EMPTY;
+}
+
+XS(XS_perlio_unimport)
+{
+ dXSARGS;
+ GV *gv = CvGV(cv);
+ char *s = GvNAME(gv);
+ STRLEN l = GvNAMELEN(gv);
+ PerlIO_debug("%.*s\n",(int) l,s);
+ XSRETURN_EMPTY;
+}
+
+SV *
+PerlIO_find_layer(char *name, STRLEN len)
+{
+ dTHX;
+ SV **svp;
+ SV *sv;
+ if (len <= 0)
+ len = strlen(name);
+ svp = hv_fetch(PerlIO_layer_hv,name,len,0);
+ if (svp && (sv = *svp) && SvROK(sv))
+ return *svp;
+ return NULL;
+}
+
+void
+PerlIO_define_layer(PerlIO_funcs *tab)
+{
+ dTHX;
+ HV *stash = gv_stashpv("perlio::Layer", TRUE);
+ SV *sv = sv_bless(newRV_noinc(newSViv(PTR2IV(tab))),stash);
+ hv_store(PerlIO_layer_hv,tab->name,strlen(tab->name),sv,0);
+}
+
+PerlIO_funcs *
+PerlIO_default_layer(I32 n)
+{
+ dTHX;
+ SV **svp;
+ SV *layer;
+ PerlIO_funcs *tab = &PerlIO_stdio;
+ int len;
+ if (!PerlIO_layer_hv)
+ {
+ char *s = 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);
+ PerlIO_define_layer(&PerlIO_perlio);
+ PerlIO_define_layer(&PerlIO_stdio);
+#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))
+ s++;
+ if (*s)
+ {
+ char *e = s;
+ SV *layer;
+ while (*e && !isspace((unsigned char)*e))
+ e++;
+ layer = PerlIO_find_layer(s,e-s);
+ if (layer)
+ {
+ PerlIO_debug("Pushing %.*s\n",(e-s),s);
+ av_push(PerlIO_layer_av,SvREFCNT_inc(layer));
+ }
+ else
+ Perl_warn(aTHX_ "perlio: unknown layer \"%.*s\"",(e-s),s);
+ s = e;
+ }
+ }
+ }
+ }
+ len = av_len(PerlIO_layer_av);
+ if (len < 1)
+ {
+ if (PerlIO_stdio.Set_ptrcnt)
+ {
+ av_push(PerlIO_layer_av,SvREFCNT_inc(PerlIO_find_layer(PerlIO_stdio.name,0)));
+ }
+ else
+ {
+ av_push(PerlIO_layer_av,SvREFCNT_inc(PerlIO_find_layer(PerlIO_perlio.name,0)));
+ }
+ len = av_len(PerlIO_layer_av);
+ }
+ if (n < 0)
+ n += len+1;
+ svp = av_fetch(PerlIO_layer_av,n,0);
+ if (svp && (layer = *svp) && SvROK(layer) && SvIOK((layer = SvRV(layer))))
+ {
+ tab = INT2PTR(PerlIO_funcs *, SvIV(layer));
+ }
+ /* PerlIO_debug("Layer %d is %s\n",n,tab->name); */
+ return tab;
+}
+
+#define PerlIO_default_top() PerlIO_default_layer(-1)
+#define PerlIO_default_btm() PerlIO_default_layer(0)
-#define PerlIO_default_top() &PerlIO_stdio
-#define PerlIO_default_btm() &PerlIO_unix
+void
+PerlIO_stdstreams()
+{
+ if (!_perlio)
+ {
+ PerlIO_allocate();
+ PerlIO_fdopen(0,"Ir");
+ PerlIO_fdopen(1,"Iw");
+ PerlIO_fdopen(2,"Iw");
+ }
+}
#undef PerlIO_fdopen
PerlIO *
PerlIO_fdopen(int fd, const char *mode)
{
PerlIO_funcs *tab = PerlIO_default_top();
- return (*tab->Fdopen)(fd,mode);
+ if (!_perlio)
+ PerlIO_stdstreams();
+ return (*tab->Fdopen)(tab,fd,mode);
}
#undef PerlIO_open
PerlIO_open(const char *path, const char *mode)
{
PerlIO_funcs *tab = PerlIO_default_top();
- return (*tab->Open)(path,mode);
+ if (!_perlio)
+ PerlIO_stdstreams();
+ return (*tab->Open)(tab,path,mode);
}
IV
-PerlIOBase_init(PerlIO *f, const char *mode)
+PerlIOBase_pushed(PerlIO *f, const char *mode)
{
PerlIOl *l = PerlIOBase(f);
l->flags &= ~(PERLIO_F_CANREAD|PERLIO_F_CANWRITE|
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;
}
return (*PerlIOBase(f)->tab->Read)(f,vbuf,count);
}
-#undef PerlIO_ungetc
-int
-PerlIO_ungetc(PerlIO *f, int ch)
+#undef PerlIO_unread
+SSize_t
+PerlIO_unread(PerlIO *f, const void *vbuf, Size_t count)
{
- STDCHAR buf = ch;
- if ((*PerlIOBase(f)->tab->Unread)(f,&buf,1) == 1)
- return ch;
- return -1;
+ return (*PerlIOBase(f)->tab->Unread)(f,vbuf,count);
}
#undef PerlIO_write
}
else
{
+ PerlIO **table = &_perlio;
int code = 0;
- int i;
- for (i=_perlio_size-1; i >= 0; i--)
+ while ((f = *table))
{
- if ((f = _perlio[i]))
+ int i;
+ table = (PerlIO **)(f++);
+ for (i=1; i < PERLIO_TABLE_SIZE; i++)
{
if (*f && PerlIO_flush(f) != 0)
code = -1;
+ f++;
}
}
return code;
}
}
+#undef PerlIO_fill
+int
+PerlIO_fill(PerlIO *f)
+{
+ return (*PerlIOBase(f)->tab->Fill)(f);
+}
+
+#undef PerlIO_isutf8
+int
+PerlIO_isutf8(PerlIO *f)
+{
+ return (PerlIOBase(f)->flags & PERLIO_F_UTF8) != 0;
+}
+
#undef PerlIO_eof
int
PerlIO_eof(PerlIO *f)
{
if (f && *f)
{
- return (PerlIOBase(f)->tab->Set_ptrcnt != NULL);
+ PerlIOl *l = PerlIOBase(f);
+ return (l->tab->Set_ptrcnt != NULL);
}
return 0;
}
{
if (f && *f)
{
- return (PerlIOBase(f)->tab->Set_ptrcnt != NULL);
+ PerlIOl *l = PerlIOBase(f);
+ return (l->tab->Set_ptrcnt != NULL);
}
- return 1;
+ return 0;
}
#undef PerlIO_get_base
}
#undef PerlIO_get_cnt
-SSize_t
+int
PerlIO_get_cnt(PerlIO *f)
{
return (*PerlIOBase(f)->tab->Get_cnt)(f);
#undef PerlIO_set_cnt
void
-PerlIO_set_cnt(PerlIO *f,SSize_t cnt)
+PerlIO_set_cnt(PerlIO *f,int cnt)
{
- return (*PerlIOBase(f)->tab->Set_ptrcnt)(f,NULL,cnt);
+ (*PerlIOBase(f)->tab->Set_ptrcnt)(f,NULL,cnt);
}
#undef PerlIO_set_ptrcnt
void
-PerlIO_set_ptrcnt(PerlIO *f, STDCHAR *ptr, SSize_t cnt)
+PerlIO_set_ptrcnt(PerlIO *f, STDCHAR *ptr, int cnt)
{
- return (*PerlIOBase(f)->tab->Set_ptrcnt)(f,ptr,cnt);
+ (*PerlIOBase(f)->tab->Set_ptrcnt)(f,ptr,cnt);
}
/*--------------------------------------------------------------------------------------*/
l->next = *f;
l->tab = tab;
*f = l;
- PerlIOBase_init(f,mode);
- PerlIO_debug(__FUNCTION__ " f=%p %08lX %s\n",f,PerlIOBase(f)->flags,tab->name);
+ if ((*l->tab->Pushed)(f,mode) != 0)
+ {
+ PerlIO_pop(f);
+ return NULL;
+ }
}
return f;
}
}
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;
}
PerlIO *
-PerlIOUnix_fdopen(int fd,const char *mode)
+PerlIOUnix_fdopen(PerlIO_funcs *self, int fd,const char *mode)
{
PerlIO *f = NULL;
+ if (*mode == 'I')
+ mode++;
if (fd >= 0)
{
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);
int fd = open(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;
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);
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;
+ }
}
}
{
SSize_t len = write(fd,vbuf,count);
if (len >= 0 || errno != EINTR)
- return len;
+ {
+ if (len < 0)
+ PerlIOBase(f)->flags |= PERLIO_F_ERROR;
+ return len;
+ }
}
}
PerlIOUnix_seek(PerlIO *f, Off_t offset, int whence)
{
Off_t new = lseek(PerlIOSelf(f,PerlIOUnix)->fd,offset,whence);
+ PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
return (new == (Off_t) -1) ? -1 : 0;
}
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,
+ PerlIOBase_noop_fail,
PerlIOBase_eof,
PerlIOBase_error,
PerlIOBase_clearerr,
/*--------------------------------------------------------------------------------------*/
/* stdio as a layer */
+#if defined(USE_64_BIT_STDIO) && defined(HAS_FSEEKO) && !defined(USE_FSEEK64)
+#define fseek fseeko
+#endif
+
+#if defined(USE_64_BIT_STDIO) && defined(HAS_FTELLO) && !defined(USE_FTELL64)
+#define ftell ftello
+#endif
+
+
typedef struct
{
struct _PerlIO base;
PerlIO *
-PerlIOStdio_fdopen(int fd,const char *mode)
+PerlIOStdio_fdopen(PerlIO_funcs *self, int fd,const char *mode)
{
PerlIO *f = NULL;
+ int init = 0;
+ if (*mode == 'I')
+ {
+ init = 1;
+ mode++;
+ }
if (fd >= 0)
{
- FILE *stdio = fdopen(fd,mode);
+ FILE *stdio = NULL;
+ if (init)
+ {
+ switch(fd)
+ {
+ case 0:
+ stdio = stdin;
+ break;
+ case 1:
+ stdio = stdout;
+ break;
+ case 2:
+ stdio = stderr;
+ break;
+ }
+ }
+ else
+ 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;
PerlIOStdio_read(PerlIO *f, void *vbuf, Size_t count)
{
FILE *s = PerlIOSelf(f,PerlIOStdio)->stdio;
+ SSize_t got = 0;
if (count == 1)
{
STDCHAR *buf = (STDCHAR *) vbuf;
if (ch != EOF)
{
*buf = ch;
- return 1;
+ got = 1;
}
- return 0;
}
- return fread(vbuf,1,count,s);
+ else
+ got = fread(vbuf,1,count,s);
+ return got;
}
SSize_t
IV
PerlIOStdio_seek(PerlIO *f, Off_t offset, int whence)
{
- return fseek(PerlIOSelf(f,PerlIOStdio)->stdio,offset,whence);
+ FILE *stdio = PerlIOSelf(f,PerlIOStdio)->stdio;
+ return fseek(stdio,offset,whence);
}
Off_t
PerlIOStdio_tell(PerlIO *f)
{
- return ftell(PerlIOSelf(f,PerlIOStdio)->stdio);
+ FILE *stdio = PerlIOSelf(f,PerlIOStdio)->stdio;
+ return ftell(stdio);
}
IV
}
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 *
-PerlIOBuf_fdopen(int fd, const char *mode)
+PerlIOBuf_fdopen(PerlIO_funcs *self, int fd, const char *mode)
{
PerlIO_funcs *tab = PerlIO_default_btm();
- PerlIO *f = (*tab->Fdopen)(fd,mode);
+ int init = 0;
+ PerlIO *f;
+ if (*mode == 'I')
+ {
+ init = 1;
+ mode++;
+ }
+ f = (*tab->Fdopen)(tab,fd,mode);
if (f)
{
- PerlIOBuf *b = PerlIOSelf(PerlIO_push(f,&PerlIO_perlio,NULL),PerlIOBuf);
- b->posn = PerlIO_tell(PerlIONext(f));
+ /* Initial stderr is unbuffered */
+ if (!init || fd != 2)
+ {
+ PerlIOBuf *b = PerlIOSelf(PerlIO_push(f,self,NULL),PerlIOBuf);
+ b->posn = PerlIO_tell(PerlIONext(f));
+ }
}
return 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)
+PerlIOBuf_reopen(const char *path, const char *mode, PerlIO *f)
{
- return (*PerlIOBase(f)->tab->Reopen)(path,mode,PerlIONext(f));
-}
-
-void
-PerlIOBuf_alloc_buf(PerlIOBuf *b)
-{
- if (!b->bufsiz)
- b->bufsiz = 4096;
- New('B',b->buf,b->bufsiz,char);
- 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;
PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
dTHX;
if (!b->buf)
- PerlIOBuf_alloc_buf(b);
+ PerlIO_get_base(f);
b->ptr = b->end - cnt;
assert(b->ptr >= b->buf);
}
{
PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
if (!b->buf)
- PerlIOBuf_alloc_buf(b);
+ PerlIO_get_base(f);
return b->ptr;
}
-int
+SSize_t
PerlIOBuf_get_cnt(PerlIO *f)
{
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);
}
void
-PerlIOBuf_set_ptrcnt(PerlIO *f, STDCHAR *ptr, int cnt)
+PerlIOBuf_set_ptrcnt(PerlIO *f, STDCHAR *ptr, SSize_t cnt)
{
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,
};
+#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)
{
if (!_perlio)
{
atexit(&PerlIO_cleanup);
- PerlIO_fdopen(0,"r");
- PerlIO_fdopen(1,"w");
- PerlIO_fdopen(2,"w");
}
}
PerlIO_stdin(void)
{
if (!_perlio)
- PerlIO_init();
- return _perlio[0];
+ PerlIO_stdstreams();
+ return &_perlio[1];
}
#undef PerlIO_stdout
PerlIO_stdout(void)
{
if (!_perlio)
- PerlIO_init();
- return _perlio[1];
+ PerlIO_stdstreams();
+ return &_perlio[2];
}
#undef PerlIO_stderr
PerlIO_stderr(void)
{
if (!_perlio)
- PerlIO_init();
- return _perlio[2];
+ PerlIO_stdstreams();
+ return &_perlio[3];
}
/*--------------------------------------------------------------------------------------*/
int
PerlIO_getc(PerlIO *f)
{
- STDCHAR buf;
- int count = PerlIO_read(f,&buf,1);
+ STDCHAR buf[1];
+ SSize_t count = PerlIO_read(f,buf,1);
if (count == 1)
- return (unsigned char) buf;
- return -1;
+ {
+ return (unsigned char) buf[0];
+ }
+ return EOF;
+}
+
+#undef PerlIO_ungetc
+int
+PerlIO_ungetc(PerlIO *f, int ch)
+{
+ if (ch != EOF)
+ {
+ STDCHAR buf = ch;
+ if (PerlIO_unread(f,&buf,1) == 1)
+ return ch;
+ }
+ return EOF;
}
#undef PerlIO_putc
PerlIO_getpos(PerlIO *f, Fpos_t *pos)
{
*pos = PerlIO_tell(f);
- return 0;
+ return *pos != -1;
}
#else
#ifndef PERLIO_IS_STDIO
projects / p5sagit/p5-mst-13.2.git / blobdiff