#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>
#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 _PerlIO_funcs PerlIO_funcs;
-struct _PerlIO_funcs
-{
- char * name;
- Size_t size;
- IV kind;
- IV (*Fileno)(PerlIO *f);
- 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);
- 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 (*Fill)(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);
-};
-
-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) */
}
}
-#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;
-#ifdef HAS_MMAP
-extern PerlIO_funcs PerlIO_mmap;
-#endif
+/* XS Interface for perl code */
XS(XS_perlio_import)
{
}
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)
{
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);
+#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
{
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;
}
}
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)
return (*tab->Open)(tab,path,mode);
}
-IV
-PerlIOBase_pushed(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;
-}
-
#undef PerlIO_reopen
PerlIO *
PerlIO_reopen(const char *path, const char *mode, 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;
- if ((*l->tab->Pushed)(f,mode) != 0)
+ switch (*mode++)
{
- PerlIO_pop(f);
- return NULL;
+ 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
}
-
-
/*--------------------------------------------------------------------------------------*/
/* Bottom-most level for UNIX-like case */
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(),self,mode),PerlIOUnix);
(*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;
return 0;
while (1)
{
- SSize_t len = read(fd,vbuf,count);
+ SSize_t len = PerlLIO_read(fd,vbuf,count);
if (len >= 0 || errno != EINTR)
{
if (len < 0)
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)
{
if (len < 0)
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_seek,
PerlIOUnix_tell,
PerlIOUnix_close,
- PerlIOBase_noop_ok,
- PerlIOBase_noop_fail,
+ PerlIOBase_noop_ok, /* flush */
+ PerlIOBase_noop_fail, /* fill */
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 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(PerlIO_funcs *self, int fd, const char *mode)
{
if (f)
{
PerlIOBuf *b = PerlIOSelf(PerlIO_push(f,self,NULL),PerlIOBuf);
- b->posn = 0;
+ 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));
+ 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)
+ {
+ PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
+ b->posn = PerlIO_tell(PerlIONext(f));
+ }
+ return code;
}
/* This "flush" is akin to sfio's sync in that it handles files in either
}
}
-void
-PerlIOBuf_set_cnt(PerlIO *f, int cnt)
-{
- PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
- dTHX;
- if (!b->buf)
- PerlIO_get_base(f);
- b->ptr = b->end - cnt;
- assert(b->ptr >= b->buf);
-}
-
STDCHAR *
PerlIOBuf_get_ptr(PerlIO *f)
{
PerlIOBase_fileno,
PerlIOBuf_fdopen,
PerlIOBuf_open,
- PerlIOBase_reopen,
+ 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,
+};
+
+/*--------------------------------------------------------------------------------------*/
+/* 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,
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;
SSize_t len = st.st_size - b->posn;
if (len > 0)
{
- b->buf = (STDCHAR *) mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, b->posn);
- if (b->buf && b->buf != (STDCHAR *) -1)
+ 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((Mmap_t) b->buf, len, MADV_SEQUENTIAL);
+ madvise(m->mptr, len, MADV_SEQUENTIAL);
#endif
- PerlIOBase(f)->flags = flags | PERLIO_F_RDBUF;
- b->end = b->buf+len;
- b->ptr = b->buf;
- m->len = len;
+ 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
{
{
if (b->buf)
{
- code = munmap((Mmap_t) b->buf, m->len);
- b->buf = NULL;
- m->len = 0;
+ 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;
}
{
/* 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);
}
PerlIOBase_fileno,
PerlIOBuf_fdopen,
PerlIOBuf_open,
- PerlIOBase_reopen,
+ PerlIOBuf_reopen,
PerlIOBase_pushed,
PerlIOBase_noop_ok,
PerlIOBuf_read,
#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);
}
}
projects / p5sagit/p5-mst-13.2.git / blobdiff