}
int
-PerlIO_binmode(pTHX_ PerlIO *fp, int iotype, int mode, const char *names)
+perlsio_binmode(FILE *fp, int iotype, int mode)
{
/* This used to be contents of do_binmode in doio.c */
#ifdef DOSISH
# if defined(atarist) || defined(__MINT__)
- if (!PerlIO_flush(fp)) {
+ if (!fflush(fp)) {
if (mode & O_BINARY)
((FILE*)fp)->_flag |= _IOBIN;
else
}
return 0;
# else
- if (PerlLIO_setmode(PerlIO_fileno(fp), mode) != -1) {
+ if (PerlLIO_setmode(fileno(fp), mode) != -1) {
# if defined(WIN32) && defined(__BORLANDC__)
/* The translation mode of the stream is maintained independent
* of the translation mode of the fd in the Borland RTL (heavy
* set the mode explicitly for the stream (though they don't
* document this anywhere). GSAR 97-5-24
*/
- PerlIO_seek(fp,0L,0);
+ fseek(fp,0L,0);
if (mode & O_BINARY)
- ((FILE*)fp)->flags |= _F_BIN;
+ fp->flags |= _F_BIN;
else
- ((FILE*)fp)->flags &= ~ _F_BIN;
+ fp->flags &= ~ _F_BIN;
# endif
return 1;
}
#endif
}
-
-
+int
+PerlIO_binmode(pTHX_ PerlIO *fp, int iotype, int mode, const char *names)
+{
+ return perlsio_binmode(fp,iotype,mode);
+}
#endif
PerlIOl *l = *f;
if (l)
{
+ PerlIO_debug("PerlIO_pop f=%p %s\n",f,l->tab->name);
(*l->tab->Popped)(f);
*f = l->next;
Safefree(l);
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);
+ Perl_warn(aTHX_ "set %"SVf" %p %p %p",sv,io,ifp,ofp);
}
return 0;
}
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);
+ Perl_warn(aTHX_ "get %"SVf" %p %p %p",sv,io,ifp,ofp);
}
return 0;
}
static int
perlio_mg_clear(pTHX_ SV *sv, MAGIC *mg)
{
- Perl_warn(aTHX_ "clear %_",sv);
+ Perl_warn(aTHX_ "clear %"SVf,sv);
return 0;
}
static int
perlio_mg_free(pTHX_ SV *sv, MAGIC *mg)
{
- Perl_warn(aTHX_ "free %_",sv);
+ Perl_warn(aTHX_ "free %"SVf,sv);
return 0;
}
mg = mg_find(sv,'~');
mg->mg_virtual = &perlio_vtab;
mg_magical(sv);
- Perl_warn(aTHX_ "attrib %_",sv);
+ Perl_warn(aTHX_ "attrib %"SVf,sv);
for (i=2; i < items; i++)
{
STRLEN len;
len = av_len(PerlIO_layer_av);
if (len < 1)
{
- if (PerlIO_stdio.Set_ptrcnt)
+ if (O_BINARY != O_TEXT)
{
- av_push(PerlIO_layer_av,SvREFCNT_inc(PerlIO_find_layer(PerlIO_stdio.name,0)));
+ av_push(PerlIO_layer_av,SvREFCNT_inc(PerlIO_find_layer(PerlIO_crlf.name,0)));
}
else
{
- av_push(PerlIO_layer_av,SvREFCNT_inc(PerlIO_find_layer(PerlIO_perlio.name,0)));
+ 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 (!_perlio)
{
PerlIO_allocate();
- PerlIO_fdopen(0,"Ir");
- PerlIO_fdopen(1,"Iw");
- PerlIO_fdopen(2,"Iw");
+ PerlIO_fdopen(0,"Ir" PERLIO_STDTEXT);
+ PerlIO_fdopen(1,"Iw" PERLIO_STDTEXT);
+ PerlIO_fdopen(2,"Iw" PERLIO_STDTEXT);
}
}
l->next = *f;
l->tab = tab;
*f = l;
+ PerlIO_debug("PerlIO_push f=%p %s %s\n",f,tab->name,(mode) ? mode : "(Null)");
if ((*l->tab->Pushed)(f,mode) != 0)
{
PerlIO_pop(f);
/* Given the abstraction above the public API functions */
int
-PerlIO_binmode(pTHX_ PerlIO *fp, int iotype, int mode, const char *names)
+PerlIO_binmode(pTHX_ PerlIO *f, int iotype, int mode, const char *names)
{
+ PerlIO_debug("PerlIO_binmode f=%p %s %c %x %s\n",
+ f,PerlIOBase(f)->tab->name,iotype,mode, (names) ? names : "(Null)");
if (!names || (O_TEXT != O_BINARY && mode & O_BINARY))
{
- PerlIO *top = fp;
+ PerlIO *top = f;
PerlIOl *l;
while (l = *top)
{
if (PerlIOBase(top)->tab == &PerlIO_crlf)
{
PerlIO_flush(top);
- PerlIO_pop(top);
+ PerlIOBase(top)->flags &= ~PERLIO_F_CRLF;
break;
}
top = PerlIONext(top);
}
}
- return PerlIO_apply_layers(aTHX_ fp, NULL, names) == 0 ? TRUE : FALSE;
+ return PerlIO_apply_layers(aTHX_ f, NULL, names) == 0 ? TRUE : FALSE;
+}
+
+#undef PerlIO__close
+int
+PerlIO__close(PerlIO *f)
+{
+ return (*PerlIOBase(f)->tab->Close)(f);
}
+
#undef PerlIO_close
int
PerlIO_close(PerlIO *f)
void
PerlIO_clearerr(PerlIO *f)
{
- (*PerlIOBase(f)->tab->Clearerr)(f);
+ if (f && *f)
+ (*PerlIOBase(f)->tab->Clearerr)(f);
}
#undef PerlIO_setlinebuf
int
PerlIO_fast_gets(PerlIO *f)
{
- if (f && *f)
+ if (f && *f && (PerlIOBase(f)->flags & PERLIO_F_FASTGETS))
{
- PerlIOl *l = PerlIOBase(f);
- return (l->tab->Set_ptrcnt != NULL);
+ PerlIO_funcs *tab = PerlIOBase(f)->tab;
+ return (tab->Set_ptrcnt != NULL);
}
return 0;
}
STDCHAR *
PerlIO_get_ptr(PerlIO *f)
{
- return (*PerlIOBase(f)->tab->Get_ptr)(f);
+ PerlIO_funcs *tab = PerlIOBase(f)->tab;
+ if (tab->Get_ptr == NULL)
+ return NULL;
+ return (*tab->Get_ptr)(f);
}
#undef PerlIO_get_cnt
int
PerlIO_get_cnt(PerlIO *f)
{
- return (*PerlIOBase(f)->tab->Get_cnt)(f);
+ PerlIO_funcs *tab = PerlIOBase(f)->tab;
+ if (tab->Get_cnt == NULL)
+ return 0;
+ return (*tab->Get_cnt)(f);
}
#undef PerlIO_set_cnt
void
PerlIO_set_ptrcnt(PerlIO *f, STDCHAR *ptr, int cnt)
{
+ PerlIO_funcs *tab = PerlIOBase(f)->tab;
+ if (tab->Set_ptrcnt == NULL)
+ {
+ dTHX;
+ Perl_croak(aTHX_ "PerlIO buffer snooping abuse");
+ }
(*PerlIOBase(f)->tab->Set_ptrcnt)(f,ptr,cnt);
}
return PerlIO_fileno(PerlIONext(f));
}
+char *
+PerlIO_modestr(PerlIO *f,char *buf)
+{
+ char *s = buf;
+ IV flags = PerlIOBase(f)->flags;
+ if (flags & PERLIO_F_CANREAD)
+ *s++ = 'r';
+ if (flags & PERLIO_F_CANWRITE)
+ *s++ = 'w';
+ if (flags & PERLIO_F_CRLF)
+ *s++ = 't';
+ else
+ *s++ = 'b';
+ *s = '\0';
+ return buf;
+}
+
IV
PerlIOBase_pushed(PerlIO *f, const char *mode)
{
PerlIOl *l = PerlIOBase(f);
+ const char *omode = mode;
+ char temp[8];
+ PerlIO_funcs *tab = PerlIOBase(f)->tab;
l->flags &= ~(PERLIO_F_CANREAD|PERLIO_F_CANWRITE|
- PERLIO_F_TRUNCATE|PERLIO_F_APPEND|PERLIO_F_BINARY);
+ PERLIO_F_TRUNCATE|PERLIO_F_APPEND);
+ if (tab->Set_ptrcnt != NULL)
+ l->flags |= PERLIO_F_FASTGETS;
if (mode)
{
switch (*mode++)
{
case 'r':
- l->flags = PERLIO_F_CANREAD;
+ l->flags |= PERLIO_F_CANREAD;
break;
case 'a':
- l->flags = PERLIO_F_APPEND|PERLIO_F_CANWRITE;
+ l->flags |= PERLIO_F_APPEND|PERLIO_F_CANWRITE;
break;
case 'w':
- l->flags = PERLIO_F_TRUNCATE|PERLIO_F_CANWRITE;
+ l->flags |= PERLIO_F_TRUNCATE|PERLIO_F_CANWRITE;
break;
default:
errno = EINVAL;
l->flags |= PERLIO_F_CANREAD|PERLIO_F_CANWRITE;
break;
case 'b':
- l->flags |= PERLIO_F_BINARY;
+ l->flags &= ~PERLIO_F_CRLF;
+ break;
+ case 't':
+ l->flags |= PERLIO_F_CRLF;
break;
default:
errno = EINVAL;
if (l->next)
{
l->flags |= l->next->flags &
- (PERLIO_F_CANREAD|PERLIO_F_CANWRITE|
- PERLIO_F_TRUNCATE|PERLIO_F_APPEND|PERLIO_F_BINARY);
+ (PERLIO_F_CANREAD|PERLIO_F_CANWRITE|PERLIO_F_TRUNCATE|PERLIO_F_APPEND);
}
}
+#if 0
+ PerlIO_debug("PerlIOBase_pushed f=%p %s %s fl=%08"UVxf" (%s)\n",
+ f,PerlIOBase(f)->tab->name,(omode) ? omode : "(Null)",
+ l->flags,PerlIO_modestr(f,temp));
+#endif
return 0;
}
return 0;
}
+extern PerlIO_funcs PerlIO_pending;
+
SSize_t
PerlIOBase_unread(PerlIO *f, const void *vbuf, Size_t count)
{
+#if 0
Off_t old = PerlIO_tell(f);
- if (PerlIO_seek(f,-((Off_t)count),SEEK_CUR) == 0)
+ if (0 && PerlIO_seek(f,-((Off_t)count),SEEK_CUR) == 0)
{
Off_t new = PerlIO_tell(f);
return old - new;
}
- return 0;
+ else
+ {
+ return 0;
+ }
+#else
+ PerlIO_push(f,&PerlIO_pending,"r");
+ return PerlIOBuf_unread(f,vbuf,count);
+#endif
}
IV
PerlIOBase_close(PerlIO *f)
{
IV code = 0;
+ PerlIO *n = PerlIONext(f);
if (PerlIO_flush(f) != 0)
code = -1;
- if (PerlIO_close(PerlIONext(f)) != 0)
+ if (n && (*PerlIOBase(n)->tab->Close)(n) != 0)
code = -1;
PerlIOBase(f)->flags &= ~(PERLIO_F_CANREAD|PERLIO_F_CANWRITE|PERLIO_F_OPEN);
return code;
{
if (f && *f)
{
- PerlIOBase(f)->flags &= ~PERLIO_F_ERROR;
+ PerlIO *n = PerlIONext(f);
+ PerlIOBase(f)->flags &= ~(PERLIO_F_ERROR|PERLIO_F_EOF);
+ if (n)
+ PerlIO_clearerr(n);
}
}
}
if (*mode == 'b')
{
- oflags |= O_BINARY;
+ oflags |= O_BINARY;
+ oflags &= ~O_TEXT;
+ mode++;
+ }
+ else if (*mode == 't')
+ {
+ oflags |= O_TEXT;
+ oflags &= ~O_BINARY;
mode++;
}
/* Always open in binary mode */
PerlIO_funcs PerlIO_unix = {
"unix",
sizeof(PerlIOUnix),
- 0,
+ PERLIO_K_RAW,
PerlIOUnix_fileno,
PerlIOUnix_fdopen,
PerlIOUnix_open,
return fileno(PerlIOSelf(f,PerlIOStdio)->stdio);
}
+const char *
+PerlIOStdio_mode(const char *mode,char *tmode)
+{
+ const char *ret = mode;
+ if (O_BINARY != O_TEXT)
+ {
+ ret = (const char *) tmode;
+ while (*mode)
+ {
+ *tmode++ = *mode++;
+ }
+ *tmode++ = 'b';
+ *tmode = '\0';
+ }
+ return ret;
+}
PerlIO *
PerlIOStdio_fdopen(PerlIO_funcs *self, int fd,const char *mode)
{
PerlIO *f = NULL;
int init = 0;
+ char tmode[8];
if (*mode == 'I')
{
init = 1;
}
}
else
- stdio = fdopen(fd,mode);
+ {
+ stdio = fdopen(fd,mode = PerlIOStdio_mode(mode,tmode));
+ }
if (stdio)
{
PerlIOStdio *s = PerlIOSelf(PerlIO_push(f = PerlIO_allocate(),self,mode),PerlIOStdio);
FILE *stdio = fopen(path,mode);
if (stdio)
{
- PerlIOStdio *s = PerlIOSelf(PerlIO_push(f = PerlIO_allocate(),self,mode),PerlIOStdio);
+ char tmode[8];
+ PerlIOStdio *s = PerlIOSelf(PerlIO_push(f = PerlIO_allocate(), self,
+ (mode = PerlIOStdio_mode(mode,tmode))),
+ PerlIOStdio);
s->stdio = stdio;
}
return f;
PerlIOStdio_reopen(const char *path, const char *mode, PerlIO *f)
{
PerlIOStdio *s = PerlIOSelf(f,PerlIOStdio);
- FILE *stdio = freopen(path,mode,s->stdio);
+ char tmode[8];
+ FILE *stdio = freopen(path,(mode = PerlIOStdio_mode(mode,tmode)),s->stdio);
if (!s->stdio)
return -1;
s->stdio = stdio;
IV
PerlIOStdio_close(PerlIO *f)
{
+ int optval, optlen = sizeof(int);
FILE *stdio = PerlIOSelf(f,PerlIOStdio)->stdio;
- return fclose(stdio);
+ return(
+ (getsockopt(PerlIO_fileno(f), SOL_SOCKET, SO_TYPE, (char *)&optval, &optlen) < 0) ?
+ fclose(stdio) :
+ close(PerlIO_fileno(f)));
}
IV
PerlIO_funcs PerlIO_stdio = {
"stdio",
sizeof(PerlIOStdio),
- 0,
+ PERLIO_K_BUFFERED,
PerlIOStdio_fileno,
PerlIOStdio_fdopen,
PerlIOStdio_open,
/*--------------------------------------------------------------------------------------*/
/* perlio buffer layer */
+IV
+PerlIOBuf_pushed(PerlIO *f, const char *mode)
+{
+ PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
+ b->posn = PerlIO_tell(PerlIONext(f));
+ return PerlIOBase_pushed(f,mode);
+}
+
PerlIO *
PerlIOBuf_fdopen(PerlIO_funcs *self, int fd, const char *mode)
{
init = 1;
mode++;
}
+#if O_BINARY != O_TEXT
+ /* do something about failing setmode()? --jhi */
+ PerlLIO_setmode(fd, O_BINARY);
+#endif
f = (*tab->Fdopen)(tab,fd,mode);
if (f)
{
- /* Initial stderr is unbuffered */
- if (!init || fd != 2)
+ PerlIOBuf *b = PerlIOSelf(PerlIO_push(f,self,mode),PerlIOBuf);
+ if (init && fd == 2)
{
- PerlIOBuf *b = PerlIOSelf(PerlIO_push(f,self,NULL),PerlIOBuf);
- b->posn = PerlIO_tell(PerlIONext(f));
+ /* Initial stderr is unbuffered */
+ PerlIOBase(f)->flags |= PERLIO_F_UNBUF;
}
+#if 0
+ PerlIO_debug("PerlIOBuf_fdopen %s f=%p fd=%d m=%s fl=%08"UVxf"\n",
+ self->name,f,fd,mode,PerlIOBase(f)->flags);
+#endif
}
return f;
}
PerlIO *f = (*tab->Open)(tab,path,mode);
if (f)
{
- PerlIOBuf *b = PerlIOSelf(PerlIO_push(f,self,NULL),PerlIOBuf);
- b->posn = PerlIO_tell(PerlIONext(f));
+ PerlIO_push(f,self,mode);
}
return 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;
}
if (PerlIOBase(f)->flags & PERLIO_F_RDBUF)
{
avail = (b->ptr - b->buf);
- if (avail > (SSize_t) count)
- avail = count;
- b->ptr -= avail;
}
else
{
avail = b->bufsiz;
- if (avail > (SSize_t) count)
- avail = count;
- b->end = b->ptr + avail;
+ b->end = b->buf + avail;
+ b->ptr = b->end;
+ PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
+ b->posn -= b->bufsiz;
}
+ if (avail > (SSize_t) count)
+ avail = count;
if (avail > 0)
{
+ b->ptr -= avail;
buf -= avail;
if (buf != b->ptr)
{
if (b->ptr >= (b->buf + b->bufsiz))
PerlIO_flush(f);
}
+ if (PerlIOBase(f)->flags & PERLIO_F_UNBUF)
+ PerlIO_flush(f);
return written;
}
IV
PerlIOBuf_seek(PerlIO *f, Off_t offset, int whence)
{
- PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
- int code = PerlIO_flush(f);
- if (code == 0)
+ 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)
PerlIO_funcs PerlIO_perlio = {
"perlio",
sizeof(PerlIOBuf),
- 0,
+ PERLIO_K_BUFFERED,
PerlIOBase_fileno,
PerlIOBuf_fdopen,
PerlIOBuf_open,
PerlIOBuf_reopen,
- PerlIOBase_pushed,
+ PerlIOBuf_pushed,
PerlIOBase_noop_ok,
PerlIOBuf_read,
PerlIOBuf_unread,
};
/*--------------------------------------------------------------------------------------*/
+/* Temp layer to hold unread chars when cannot do it any other way */
+
+IV
+PerlIOPending_fill(PerlIO *f)
+{
+ /* Should never happen */
+ PerlIO_flush(f);
+ return 0;
+}
+
+IV
+PerlIOPending_close(PerlIO *f)
+{
+ /* A tad tricky - flush pops us, then we close new top */
+ PerlIO_flush(f);
+ return PerlIO_close(f);
+}
+
+IV
+PerlIOPending_seek(PerlIO *f, Off_t offset, int whence)
+{
+ /* A tad tricky - flush pops us, then we seek new top */
+ PerlIO_flush(f);
+ return PerlIO_seek(f,offset,whence);
+}
+
+
+IV
+PerlIOPending_flush(PerlIO *f)
+{
+ PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
+ if (b->buf && b->buf != (STDCHAR *) &b->oneword)
+ {
+ Safefree(b->buf);
+ b->buf = NULL;
+ }
+ PerlIO_pop(f);
+ return 0;
+}
+
+void
+PerlIOPending_set_ptrcnt(PerlIO *f, STDCHAR *ptr, SSize_t cnt)
+{
+ if (cnt <= 0)
+ {
+ PerlIO_flush(f);
+ }
+ else
+ {
+ PerlIOBuf_set_ptrcnt(f,ptr,cnt);
+ }
+}
+
+IV
+PerlIOPending_pushed(PerlIO *f,const char *mode)
+{
+ IV code = PerlIOBuf_pushed(f,mode);
+ PerlIOl *l = PerlIOBase(f);
+ /* Our PerlIO_fast_gets must match what we are pushed on,
+ or sv_gets() etc. get muddled when it changes mid-string
+ when we auto-pop.
+ */
+ l->flags = (l->flags & ~PERLIO_F_FASTGETS) |
+ (PerlIOBase(PerlIONext(f))->flags & PERLIO_F_FASTGETS);
+ return code;
+}
+
+SSize_t
+PerlIOPending_read(PerlIO *f, void *vbuf, Size_t count)
+{
+ SSize_t avail = PerlIO_get_cnt(f);
+ SSize_t got = 0;
+ if (count < avail)
+ avail = count;
+ if (avail > 0)
+ got = PerlIOBuf_read(f,vbuf,avail);
+ if (got < count)
+ got += PerlIO_read(f,((STDCHAR *) vbuf)+got,count-got);
+ return got;
+}
+
+
+PerlIO_funcs PerlIO_pending = {
+ "pending",
+ sizeof(PerlIOBuf),
+ PERLIO_K_BUFFERED,
+ PerlIOBase_fileno,
+ NULL,
+ NULL,
+ NULL,
+ PerlIOPending_pushed,
+ PerlIOBase_noop_ok,
+ PerlIOPending_read,
+ PerlIOBuf_unread,
+ PerlIOBuf_write,
+ PerlIOPending_seek,
+ PerlIOBuf_tell,
+ PerlIOPending_close,
+ PerlIOPending_flush,
+ PerlIOPending_fill,
+ PerlIOBase_eof,
+ PerlIOBase_error,
+ PerlIOBase_clearerr,
+ PerlIOBuf_setlinebuf,
+ PerlIOBuf_get_base,
+ PerlIOBuf_bufsiz,
+ PerlIOBuf_get_ptr,
+ PerlIOBuf_get_cnt,
+ PerlIOPending_set_ptrcnt,
+};
+
+
+
+/*--------------------------------------------------------------------------------------*/
/* crlf - translation
On read translate CR,LF to "\n" we do this by overriding ptr/cnt entries
to hand back a line at a time and keeping a record of which nl we "lied" about.
STDCHAR *nl; /* Position of crlf we "lied" about in the buffer */
} PerlIOCrlf;
+IV
+PerlIOCrlf_pushed(PerlIO *f, const char *mode)
+{
+ IV code;
+ PerlIOBase(f)->flags |= PERLIO_F_CRLF;
+ code = PerlIOBuf_pushed(f,mode);
+#if 0
+ PerlIO_debug("PerlIOCrlf_pushed f=%p %s %s fl=%08"UVxf"\n",
+ f,PerlIOBase(f)->tab->name,(mode) ? mode : "(Null)",
+ PerlIOBase(f)->flags);
+#endif
+ return code;
+}
+
+
SSize_t
PerlIOCrlf_unread(PerlIO *f, const void *vbuf, Size_t count)
{
- const STDCHAR *buf = (const STDCHAR *) vbuf+count;
- PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
PerlIOCrlf *c = PerlIOSelf(f,PerlIOCrlf);
- SSize_t unread = 0;
- if (PerlIOBase(f)->flags & PERLIO_F_WRBUF)
- PerlIO_flush(f);
if (c->nl)
{
*(c->nl) = 0xd;
c->nl = NULL;
}
- if (!b->buf)
- PerlIO_get_base(f);
- if (b->buf)
+ if (!(PerlIOBase(f)->flags & PERLIO_F_CRLF))
+ return PerlIOBuf_unread(f,vbuf,count);
+ else
{
- if (!(PerlIOBase(f)->flags & PERLIO_F_RDBUF))
- {
- b->end = b->ptr = b->buf + b->bufsiz;
- PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
- }
- while (count > 0 && b->ptr > b->buf)
+ const STDCHAR *buf = (const STDCHAR *) vbuf+count;
+ PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
+ SSize_t unread = 0;
+ if (PerlIOBase(f)->flags & PERLIO_F_WRBUF)
+ PerlIO_flush(f);
+ if (!b->buf)
+ PerlIO_get_base(f);
+ if (b->buf)
{
- int ch = *--buf;
- if (ch == '\n')
+ if (!(PerlIOBase(f)->flags & PERLIO_F_RDBUF))
+ {
+ b->end = b->ptr = b->buf + b->bufsiz;
+ PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
+ b->posn -= b->bufsiz;
+ }
+ while (count > 0 && b->ptr > b->buf)
{
- if (b->ptr - 2 >= b->buf)
+ int ch = *--buf;
+ if (ch == '\n')
{
- *--(b->ptr) = 0xa;
- *--(b->ptr) = 0xd;
- unread++;
- count--;
+ if (b->ptr - 2 >= b->buf)
+ {
+ *--(b->ptr) = 0xa;
+ *--(b->ptr) = 0xd;
+ unread++;
+ count--;
+ }
+ else
+ {
+ buf++;
+ break;
+ }
}
else
{
- buf++;
- break;
+ *--(b->ptr) = ch;
+ unread++;
+ count--;
}
}
- else
- {
- *--(b->ptr) = ch;
- unread++;
- count--;
- }
}
+ return unread;
}
- return unread;
}
SSize_t
if (PerlIOBase(f)->flags & PERLIO_F_RDBUF)
{
PerlIOCrlf *c = PerlIOSelf(f,PerlIOCrlf);
- if (!c->nl)
+ if ((PerlIOBase(f)->flags & PERLIO_F_CRLF) && !c->nl)
{
STDCHAR *nl = b->ptr;
scan:
{
int code;
dTHX;
- Perl_warn(aTHX_ __FUNCTION__ " f=%p CR @ end of buffer",f);
b->ptr++; /* say we have read it as far as flush() is concerned */
b->buf++; /* Leave space an front of buffer */
b->bufsiz--; /* Buffer is thus smaller */
{
PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
PerlIOCrlf *c = PerlIOSelf(f,PerlIOCrlf);
+ IV flags = PerlIOBase(f)->flags;
if (!b->buf)
PerlIO_get_base(f);
if (!ptr)
{
- ptr = ((c->nl) ? (c->nl+1) : b->end) - cnt;
+ if (c->nl)
+ ptr = c->nl+1;
+ else
+ {
+ ptr = b->end;
+ if ((flags & PERLIO_F_CRLF) && ptr > b->buf && ptr[-1] == 0xd)
+ ptr--;
+ }
+ ptr -= cnt;
}
else
{
- if (ptr != (((c->nl) ? (c->nl+1) : b->end) - cnt))
- abort();
+ /* Test code - delete when it works ... */
+ STDCHAR *chk;
+ if (c->nl)
+ chk = c->nl+1;
+ else
+ {
+ chk = b->end;
+ if ((flags & PERLIO_F_CRLF) && chk > b->buf && chk[-1] == 0xd)
+ chk--;
+ }
+ chk -= cnt;
+
+ if (ptr != chk)
+ {
+ dTHX;
+ Perl_croak(aTHX_ "ptr wrong %p != %p fl=%08"UVxf" nl=%p e=%p for %d",
+ ptr, chk, flags, c->nl, b->end, cnt);
+ }
}
if (c->nl)
{
SSize_t
PerlIOCrlf_write(PerlIO *f, const void *vbuf, Size_t count)
{
- PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
- const STDCHAR *buf = (const STDCHAR *) vbuf;
- const STDCHAR *ebuf = buf+count;
- if (!b->buf)
- PerlIO_get_base(f);
- if (!(PerlIOBase(f)->flags & PERLIO_F_CANWRITE))
- return 0;
- while (buf < ebuf)
+ if (!(PerlIOBase(f)->flags & PERLIO_F_CRLF))
+ return PerlIOBuf_write(f,vbuf,count);
+ else
{
- STDCHAR *eptr = b->buf+b->bufsiz;
- PerlIOBase(f)->flags |= PERLIO_F_WRBUF;
- while (buf < ebuf && b->ptr < eptr)
+ PerlIOBuf *b = PerlIOSelf(f,PerlIOBuf);
+ const STDCHAR *buf = (const STDCHAR *) vbuf;
+ const STDCHAR *ebuf = buf+count;
+ if (!b->buf)
+ PerlIO_get_base(f);
+ if (!(PerlIOBase(f)->flags & PERLIO_F_CANWRITE))
+ return 0;
+ while (buf < ebuf)
{
- if (*buf == '\n')
+ STDCHAR *eptr = b->buf+b->bufsiz;
+ PerlIOBase(f)->flags |= PERLIO_F_WRBUF;
+ while (buf < ebuf && b->ptr < eptr)
{
- if ((b->ptr + 2) > eptr)
+ if (*buf == '\n')
{
- /* Not room for both */
- PerlIO_flush(f);
- break;
- }
- else
- {
- *(b->ptr)++ = 0xd; /* CR */
- *(b->ptr)++ = 0xa; /* LF */
- buf++;
- if (PerlIOBase(f)->flags & PERLIO_F_LINEBUF)
+ if ((b->ptr + 2) > eptr)
{
+ /* Not room for both */
PerlIO_flush(f);
break;
}
+ else
+ {
+ *(b->ptr)++ = 0xd; /* CR */
+ *(b->ptr)++ = 0xa; /* LF */
+ buf++;
+ if (PerlIOBase(f)->flags & PERLIO_F_LINEBUF)
+ {
+ PerlIO_flush(f);
+ break;
+ }
+ }
+ }
+ else
+ {
+ int ch = *buf++;
+ *(b->ptr)++ = ch;
+ }
+ if (b->ptr >= eptr)
+ {
+ PerlIO_flush(f);
+ break;
}
- }
- else
- {
- int ch = *buf++;
- *(b->ptr)++ = ch;
- }
- if (b->ptr >= eptr)
- {
- PerlIO_flush(f);
- break;
}
}
+ if (PerlIOBase(f)->flags & PERLIO_F_UNBUF)
+ PerlIO_flush(f);
+ return (buf - (STDCHAR *) vbuf);
}
- return (buf - (STDCHAR *) vbuf);
}
IV
PerlIO_funcs PerlIO_crlf = {
"crlf",
sizeof(PerlIOCrlf),
- 0,
+ PERLIO_K_BUFFERED|PERLIO_K_CANCRLF,
PerlIOBase_fileno,
PerlIOBuf_fdopen,
PerlIOBuf_open,
PerlIOBuf_reopen,
- PerlIOBase_pushed,
+ PerlIOCrlf_pushed,
PerlIOBase_noop_ok, /* popped */
PerlIOBuf_read, /* generic read works with ptr/cnt lies ... */
PerlIOCrlf_unread, /* Put CR,LF in buffer for each '\n' */
m->bbuf = b->buf;
}
}
- return PerlIOBuf_unread(f,vbuf,count);
+return PerlIOBuf_unread(f,vbuf,count);
}
SSize_t
PerlIO_funcs PerlIO_mmap = {
"mmap",
sizeof(PerlIOMmap),
- 0,
+ PERLIO_K_BUFFERED,
PerlIOBase_fileno,
PerlIOBuf_fdopen,
PerlIOBuf_open,
PerlIOBuf_reopen,
- PerlIOBase_pushed,
+ PerlIOBuf_pushed,
PerlIOBase_noop_ok,
PerlIOBuf_read,
PerlIOMmap_unread,
projects / p5sagit/p5-mst-13.2.git / blobdiff