/* Call the callback or PerlIOBase, and return failure. */
#define Perl_PerlIO_or_Base(f, callback, base, failure, args) \
if (PerlIOValid(f)) { \
- PerlIO_funcs *tab = PerlIOBase(f)->tab; \
+ const PerlIO_funcs *tab = PerlIOBase(f)->tab; \
if (tab && tab->callback) \
return (*tab->callback) args; \
else \
/* Call the callback or fail, and return failure. */
#define Perl_PerlIO_or_fail(f, callback, failure, args) \
if (PerlIOValid(f)) { \
- PerlIO_funcs *tab = PerlIOBase(f)->tab; \
+ const PerlIO_funcs *tab = PerlIOBase(f)->tab; \
if (tab && tab->callback) \
return (*tab->callback) args; \
SETERRNO(EINVAL, LIB_INVARG); \
/* Call the callback or PerlIOBase, and be void. */
#define Perl_PerlIO_or_Base_void(f, callback, base, args) \
if (PerlIOValid(f)) { \
- PerlIO_funcs *tab = PerlIOBase(f)->tab; \
+ const PerlIO_funcs *tab = PerlIOBase(f)->tab; \
if (tab && tab->callback) \
(*tab->callback) args; \
else \
/* Call the callback or fail, and be void. */
#define Perl_PerlIO_or_fail_void(f, callback, args) \
if (PerlIOValid(f)) { \
- PerlIO_funcs *tab = PerlIOBase(f)->tab; \
+ const PerlIO_funcs *tab = PerlIOBase(f)->tab; \
if (tab && tab->callback) \
(*tab->callback) args; \
else \
else \
SETERRNO(EBADF, SS_IVCHAN)
+#ifndef USE_SFIO
int
perlsio_binmode(FILE *fp, int iotype, int mode)
{
else
return 0;
# else
+ PERL_UNUSED_ARG(fp);
+ PERL_UNUSED_ARG(iotype);
+ PERL_UNUSED_ARG(mode);
return 1;
# endif
#endif
}
+#endif /* sfio */
#ifndef O_ACCMODE
#define O_ACCMODE 3 /* Assume traditional implementation */
int
PerlIO_intmode2str(int rawmode, char *mode, int *writing)
{
- int result = rawmode & O_ACCMODE;
+ const int result = rawmode & O_ACCMODE;
int ix = 0;
int ptype;
switch (result) {
PerlIO_binmode(pTHX_ PerlIO *fp, int iotype, int mode, const char *names)
{
#ifdef USE_SFIO
+ PERL_UNUSED_ARG(iotype);
+ PERL_UNUSED_ARG(mode);
+ PERL_UNUSED_ARG(names);
return 1;
#else
return perlsio_binmode(fp, iotype, mode);
return win32_fdupopen(f);
#else
if (f) {
- int fd = PerlLIO_dup(PerlIO_fileno(f));
+ const int fd = PerlLIO_dup(PerlIO_fileno(f));
if (fd >= 0) {
char mode[8];
int omode = fcntl(fd, F_GETFL);
if (*args == &PL_sv_undef)
return PerlIO_tmpfile();
else {
- char *name = SvPV_nolen(*args);
+ const char *name = SvPV_nolen_const(*args);
if (*mode == IoTYPE_NUMERIC) {
fd = PerlLIO_open3(name, imode, perm);
if (fd >= 0)
- return PerlIO_fdopen(fd, (char *) mode + 1);
+ return PerlIO_fdopen(fd, mode + 1);
}
else if (old) {
return PerlIO_reopen(name, mode, old);
if (items < 2)
Perl_croak(aTHX_ "Usage class->find(name[,load])");
else {
- char *name = SvPV_nolen(ST(1));
+ const char *name = SvPV_nolen_const(ST(1));
ST(0) = (strEQ(name, "crlf")
|| strEQ(name, "raw")) ? &PL_sv_yes : &PL_sv_undef;
XSRETURN(1);
PerlIO *
PerlIO_importFILE(FILE *stdio, const char *mode)
{
- int fd = fileno(stdio);
+ const int fd = fileno(stdio);
if (!mode || !*mode) {
mode = "r+";
}
FILE *
PerlIO_findFILE(PerlIO *pio)
{
- int fd = PerlIO_fileno(pio);
- FILE *f = fdopen(fd, "r+");
+ const int fd = PerlIO_fileno(pio);
+ FILE * const f = fdopen(fd, "r+");
PerlIO_flush(pio);
if (!f && errno == EINVAL)
f = fdopen(fd, "w");
#include <sys/mman.h>
#endif
-/*
- * Why is this here - not in perlio.h? RMB
- */
-void PerlIO_debug(const char *fmt, ...)
- __attribute__format__(__printf__, 1, 2);
-
void
PerlIO_debug(const char *fmt, ...)
{
dSYS;
va_start(ap, fmt);
if (!PL_perlio_debug_fd && !PL_tainting && PL_uid == PL_euid && PL_gid == PL_egid) {
- char *s = PerlEnv_getenv("PERLIO_DEBUG");
+ const char *s = PerlEnv_getenv("PERLIO_DEBUG");
if (s && *s)
PL_perlio_debug_fd = PerlLIO_open3(s, O_WRONLY | O_CREAT | O_APPEND, 0666);
else
}
if (PL_perlio_debug_fd > 0) {
dTHX;
- const char *s;
+ const char *s = CopFILE(PL_curcop);
+ STRLEN len;
#ifdef USE_ITHREADS
/* Use fixed buffer as sv_catpvf etc. needs SVs */
char buffer[1024];
- STRLEN len;
- s = CopFILE(PL_curcop);
if (!s)
s = "(none)";
- sprintf(buffer, "%.40s:%" IVdf " ", s, (IV) CopLINE(PL_curcop));
- len = strlen(buffer);
+ len = sprintf(buffer, "%.40s:%" IVdf " ", s, (IV) CopLINE(PL_curcop));
vsprintf(buffer+len, fmt, ap);
PerlLIO_write(PL_perlio_debug_fd, buffer, strlen(buffer));
#else
SV *sv = newSVpvn("", 0);
- STRLEN len;
- s = CopFILE(PL_curcop);
if (!s)
s = "(none)";
Perl_sv_catpvf(aTHX_ sv, "%s:%" IVdf " ", s,
(IV) CopLINE(PL_curcop));
Perl_sv_vcatpvf(aTHX_ sv, fmt, &ap);
- s = SvPV(sv, len);
+ s = SvPV_const(sv, len);
PerlLIO_write(PL_perlio_debug_fd, s, len);
SvREFCNT_dec(sv);
#endif
}
}
}
- Newz('I',f,PERLIO_TABLE_SIZE,PerlIO);
+ Newxz(f,PERLIO_TABLE_SIZE,PerlIO);
if (!f) {
return NULL;
}
PerlIO_fdupopen(pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
{
if (PerlIOValid(f)) {
- PerlIO_funcs *tab = PerlIOBase(f)->tab;
+ const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
PerlIO_debug("fdupopen f=%p param=%p\n",(void*)f,(void*)param);
if (tab && tab->Dup)
return (*tab->Dup)(aTHX_ PerlIO_allocate(aTHX), f, param, flags);
PerlIO_list_alloc(pTHX)
{
PerlIO_list_t *list;
- Newz('L', list, 1, PerlIO_list_t);
+ Newxz(list, 1, PerlIO_list_t);
list->refcnt = 1;
return list;
}
if (list->array)
Renew(list->array, list->len, PerlIO_pair_t);
else
- New('l', list->array, list->len, PerlIO_pair_t);
+ Newx(list->array, list->len, PerlIO_pair_t);
}
p = &(list->array[list->cur++]);
p->funcs = funcs;
f++;
}
}
+#else
+ PERL_UNUSED_ARG(proto);
+ PERL_UNUSED_ARG(param);
#endif
}
ENTER;
SAVEINT(PL_in_load_module);
if (cv) {
- SAVESPTR(PL_warnhook);
+ SAVEGENERICSV(PL_warnhook);
+ (void)SvREFCNT_inc(cv);
PL_warnhook = (SV *) cv;
}
PL_in_load_module++;
Perl_warn(aTHX_ "attrib %" SVf, sv);
for (i = 2; i < items; i++) {
STRLEN len;
- const char *name = SvPV(ST(i), len);
+ const char *name = SvPV_const(ST(i), len);
SV *layer = PerlIO_find_layer(aTHX_ name, len, 1);
if (layer) {
av_push(av, SvREFCNT_inc(layer));
*/
dXSARGS;
if (items)
- PerlIO_debug("warning:%s\n",SvPV_nolen(ST(0)));
+ PerlIO_debug("warning:%s\n",SvPV_nolen_const(ST(0)));
XSRETURN(0);
}
if (items < 2)
Perl_croak(aTHX_ "Usage class->find(name[,load])");
else {
- STRLEN len = 0;
- char *name = SvPV(ST(1), len);
- bool load = (items > 2) ? SvTRUE(ST(2)) : 0;
+ STRLEN len;
+ const char *name = SvPV_const(ST(1), len);
+ const bool load = (items > 2) ? SvTRUE(ST(2)) : 0;
PerlIO_funcs *layer = PerlIO_find_layer(aTHX_ name, len, load);
ST(0) =
(layer) ? sv_2mortal(PerlIO_tab_sv(aTHX_ layer)) :
* passed. Even though this means "foo : : bar" is
* seen as an invalid separator character.
*/
- char q = ((*s == '\'') ? '"' : '\'');
+ const char q = ((*s == '\'') ? '"' : '\'');
if (ckWARN(WARN_LAYER))
Perl_warner(aTHX_ packWARN(WARN_LAYER),
"Invalid separator character %c%c%c in PerlIO layer specification %s",
}
}
if (e > s) {
- bool warn_layer = ckWARN(WARN_LAYER);
+ const bool warn_layer = ckWARN(WARN_LAYER);
PerlIO_funcs *layer =
PerlIO_find_layer(aTHX_ s, llen, 1);
if (layer) {
IV
PerlIOPop_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
{
+ PERL_UNUSED_ARG(mode);
+ PERL_UNUSED_ARG(arg);
+ PERL_UNUSED_ARG(tab);
if (PerlIOValid(f)) {
PerlIO_flush(f);
PerlIO_pop(aTHX_ f);
NULL,
NULL,
NULL,
+ NULL,
+ NULL,
NULL, /* flush */
NULL, /* fill */
NULL,
Perl_croak(aTHX_ "Layer does not match this perl");
}
if (tab->size) {
- PerlIOl *l = NULL;
+ PerlIOl *l;
if (tab->size < sizeof(PerlIOl)) {
goto mismatch;
}
/* Real layer with a data area */
- Newc('L',l,tab->size,char,PerlIOl);
+ Newxc(l,tab->size,char,PerlIOl);
if (l && f) {
Zero(l, tab->size, char);
l->next = *f;
IV
PerlIORaw_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
{
+ PERL_UNUSED_ARG(mode);
+ PERL_UNUSED_ARG(arg);
+ PERL_UNUSED_ARG(tab);
if (PerlIOValid(f)) {
PerlIO *t;
- PerlIOl *l;
+ const PerlIOl *l;
PerlIO_flush(f);
/*
* Strip all layers that are not suitable for a raw stream
{
int code = 0;
while (n < max) {
- PerlIO_funcs *tab = PerlIO_layer_fetch(aTHX_ layers, n, NULL);
+ PerlIO_funcs * const tab = PerlIO_layer_fetch(aTHX_ layers, n, NULL);
if (tab) {
if (!PerlIO_push(aTHX_ f, tab, mode, PerlIOArg)) {
code = -1;
{
int code = 0;
if (f && names) {
- PerlIO_list_t *layers = PerlIO_list_alloc(aTHX);
+ PerlIO_list_t * const layers = PerlIO_list_alloc(aTHX);
code = PerlIO_parse_layers(aTHX_ layers, names);
if (code == 0) {
code = PerlIO_apply_layera(aTHX_ f, mode, layers, 0, layers->cur);
int
Perl_PerlIO_close(pTHX_ PerlIO *f)
{
- int code = PerlIO__close(aTHX_ f);
+ const int code = PerlIO__close(aTHX_ f);
while (PerlIOValid(f)) {
PerlIO_pop(aTHX_ f);
}
SV *layers = PL_curcop->cop_io;
if (layers) {
STRLEN len;
- type = SvPV(layers, len);
+ type = SvPV_const(layers, len);
if (type && mode[0] != 'r') {
/*
* Skip to write part
if (layers && *layers) {
PerlIO_list_t *av;
if (incdef) {
- IV i = def->cur;
+ IV i;
av = PerlIO_list_alloc(aTHX);
for (i = 0; i < def->cur; i++) {
PerlIO_list_push(aTHX_ av, def->array[i].funcs,
}
}
else {
- PerlIO_list_t *layera = NULL;
+ PerlIO_list_t *layera;
IV n;
PerlIO_funcs *tab = NULL;
if (PerlIOValid(f)) {
{
if (f) {
if (*f) {
- PerlIO_funcs *tab = PerlIOBase(f)->tab;
+ const PerlIO_funcs *tab = PerlIOBase(f)->tab;
if (tab && tab->Flush)
return (*tab->Flush) (aTHX_ f);
PerlIO_has_base(PerlIO *f)
{
if (PerlIOValid(f)) {
- PerlIO_funcs *tab = PerlIOBase(f)->tab;
+ const PerlIO_funcs *tab = PerlIOBase(f)->tab;
if (tab)
return (tab->Get_base != NULL);
PerlIO_fast_gets(PerlIO *f)
{
if (PerlIOValid(f) && (PerlIOBase(f)->flags & PERLIO_F_FASTGETS)) {
- PerlIO_funcs *tab = PerlIOBase(f)->tab;
+ const PerlIO_funcs *tab = PerlIOBase(f)->tab;
if (tab)
return (tab->Set_ptrcnt != NULL);
PerlIO_has_cntptr(PerlIO *f)
{
if (PerlIOValid(f)) {
- PerlIO_funcs *tab = PerlIOBase(f)->tab;
+ const PerlIO_funcs *tab = PerlIOBase(f)->tab;
if (tab)
return (tab->Get_ptr != NULL && tab->Get_cnt != NULL);
PerlIO_canset_cnt(PerlIO *f)
{
if (PerlIOValid(f)) {
- PerlIO_funcs *tab = PerlIOBase(f)->tab;
+ const PerlIO_funcs *tab = PerlIOBase(f)->tab;
if (tab)
return (tab->Set_ptrcnt != NULL);
IV
PerlIOUtf8_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
{
+ PERL_UNUSED_ARG(mode);
+ PERL_UNUSED_ARG(arg);
if (PerlIOValid(f)) {
if (tab->kind & PERLIO_K_UTF8)
PerlIOBase(f)->flags |= PERLIO_F_UTF8;
NULL,
NULL,
NULL,
+ NULL,
+ NULL,
NULL, /* flush */
NULL, /* fill */
NULL,
NULL,
NULL,
NULL,
+ NULL,
+ NULL,
NULL, /* flush */
NULL, /* fill */
NULL,
IV n, const char *mode, int fd, int imode, int perm,
PerlIO *old, int narg, SV **args)
{
- PerlIO_funcs *tab = PerlIO_default_btm();
+ PerlIO_funcs * const tab = PerlIO_default_btm();
+ PERL_UNUSED_ARG(self);
if (tab && tab->Open)
return (*tab->Open) (aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
old, narg, args);
NULL,
NULL,
NULL,
+ NULL,
+ NULL,
NULL, /* flush */
NULL, /* fill */
NULL,
{
char *s = buf;
if (PerlIOValid(f)) {
- IV flags = PerlIOBase(f)->flags;
+ const IV flags = PerlIOBase(f)->flags;
if (flags & PERLIO_F_APPEND) {
*s++ = 'a';
if (flags & PERLIO_F_CANREAD) {
IV
PerlIOBase_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
{
- PerlIOl *l = PerlIOBase(f);
-#if 0
- const char *omode = mode;
- char temp[8];
-#endif
+ PerlIOl * const l = PerlIOBase(f);
+ PERL_UNUSED_ARG(arg);
+
l->flags &= ~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE |
PERLIO_F_TRUNCATE | PERLIO_F_APPEND);
if (tab->Set_ptrcnt != NULL)
IV
PerlIOBase_popped(pTHX_ PerlIO *f)
{
+ PERL_UNUSED_ARG(f);
return 0;
}
/*
* Save the position as current head considers it
*/
- Off_t old = PerlIO_tell(f);
- SSize_t done;
+ const Off_t old = PerlIO_tell(f);
PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_pending), "r", Nullsv);
PerlIOSelf(f, PerlIOBuf)->posn = old;
- done = PerlIOBuf_unread(aTHX_ f, vbuf, count);
- return done;
+ return PerlIOBuf_unread(aTHX_ f, vbuf, count);
}
SSize_t
IV
PerlIOBase_noop_ok(pTHX_ PerlIO *f)
{
+ PERL_UNUSED_ARG(f);
return 0;
}
IV
PerlIOBase_noop_fail(pTHX_ PerlIO *f)
{
+ PERL_UNUSED_ARG(f);
return -1;
}
PerlIOBase(f)->flags &=
~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE | PERLIO_F_OPEN);
while (PerlIOValid(n)) {
- PerlIO_funcs *tab = PerlIOBase(n)->tab;
+ const PerlIO_funcs * const tab = PerlIOBase(n)->tab;
if (tab && tab->Close) {
if ((*tab->Close)(aTHX_ n) != 0)
code = -1;
return newSVsv(arg);
}
#else
+ PERL_UNUSED_ARG(param);
return newSVsv(arg);
#endif
}
PerlIO *
PerlIOBase_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
{
- PerlIO *nexto = PerlIONext(o);
+ PerlIO * const nexto = PerlIONext(o);
if (PerlIOValid(nexto)) {
- PerlIO_funcs *tab = PerlIOBase(nexto)->tab;
+ const PerlIO_funcs * const tab = PerlIOBase(nexto)->tab;
if (tab && tab->Dup)
f = (*tab->Dup)(aTHX_ f, nexto, param, flags);
else
static void
PerlIOUnix_setfd(pTHX_ PerlIO *f, int fd, int imode)
{
- PerlIOUnix *s = PerlIOSelf(f, PerlIOUnix);
+ PerlIOUnix * const s = PerlIOSelf(f, PerlIOUnix);
#if defined(WIN32)
Stat_t st;
if (PerlLIO_fstat(fd, &st) == 0) {
IV
PerlIOUnix_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
{
- int fd = PerlIOSelf(f, PerlIOUnix)->fd;
+ const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
Off_t new_loc;
if (PerlIOBase(f)->flags & PERLIO_F_NOTREG) {
#ifdef ESPIPE
(*PerlIOBase(f)->tab->Close)(aTHX_ f);
}
if (narg > 0) {
- char *path = SvPV_nolen(*args);
if (*mode == IoTYPE_NUMERIC)
mode++;
else {
perm = 0666;
}
if (imode != -1) {
+ const char *path = SvPV_nolen_const(*args);
fd = PerlLIO_open3(path, imode, perm);
}
}
SSize_t
PerlIOUnix_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
{
- int fd = PerlIOSelf(f, PerlIOUnix)->fd;
+ const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
#ifdef PERLIO_STD_SPECIAL
if (fd == 0)
return PERLIO_STD_IN(fd, vbuf, count);
return 0;
}
while (1) {
- SSize_t len = PerlLIO_read(fd, vbuf, count);
+ const SSize_t len = PerlLIO_read(fd, vbuf, count);
if (len >= 0 || errno != EINTR) {
if (len < 0) {
if (errno != EAGAIN) {
}
PERL_ASYNC_CHECK();
}
+ /*NOTREACHED*/
}
SSize_t
PerlIOUnix_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
{
- int fd = PerlIOSelf(f, PerlIOUnix)->fd;
+ const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
#ifdef PERLIO_STD_SPECIAL
if (fd == 1 || fd == 2)
return PERLIO_STD_OUT(fd, vbuf, count);
#endif
while (1) {
- SSize_t len = PerlLIO_write(fd, vbuf, count);
+ const SSize_t len = PerlLIO_write(fd, vbuf, count);
if (len >= 0 || errno != EINTR) {
if (len < 0) {
if (errno != EAGAIN) {
}
PERL_ASYNC_CHECK();
}
+ /*NOTREACHED*/
}
Off_t
IV
PerlIOUnix_close(pTHX_ PerlIO *f)
{
- int fd = PerlIOSelf(f, PerlIOUnix)->fd;
+ const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
int code = 0;
if (PerlIOBase(f)->flags & PERLIO_F_OPEN) {
if (PerlIOUnix_refcnt_dec(fd) > 0) {
char *
PerlIOStdio_mode(const char *mode, char *tmode)
{
- char *ret = tmode;
+ char * const ret = tmode;
if (mode) {
while (*mode) {
*tmode++ = *mode++;
PerlIO_pop(aTHX_ f);
return 0;
} else {
- int fd = PerlIO_fileno(n);
+ const int fd = PerlIO_fileno(n);
char tmode[8];
FILE *stdio;
if (fd >= 0 && (stdio = PerlSIO_fdopen(fd,
Note that the errno value set by a failing fdopen
varies between stdio implementations.
*/
- int fd = PerlLIO_dup(fileno(stdio));
+ const int fd = PerlLIO_dup(fileno(stdio));
FILE *f2 = PerlSIO_fdopen(fd, (mode = "r+"));
if (!f2) {
f2 = PerlSIO_fdopen(fd, (mode = "w"));
{
char tmode[8];
if (PerlIOValid(f)) {
- char *path = SvPV_nolen(*args);
+ const char *path = SvPV_nolen_const(*args);
PerlIOStdio *s = PerlIOSelf(f, PerlIOStdio);
FILE *stdio;
PerlIOUnix_refcnt_dec(fileno(s->stdio));
}
else {
if (narg > 0) {
- char *path = SvPV_nolen(*args);
+ const char *path = SvPV_nolen_const(*args);
if (*mode == IoTYPE_NUMERIC) {
mode++;
fd = PerlLIO_open3(path, imode, perm);
PerlIOStdio_mode(mode, tmode));
}
if (stdio) {
- PerlIOStdio *s;
if (!f) {
f = PerlIO_allocate(aTHX);
}
if ((f = PerlIO_push(aTHX_ f, self, mode, PerlIOArg))) {
- s = PerlIOSelf(f, PerlIOStdio);
+ PerlIOStdio *s = PerlIOSelf(f, PerlIOStdio);
s->stdio = stdio;
PerlIOUnix_refcnt_inc(fileno(s->stdio));
}
*/
if ((f = PerlIOBase_dup(aTHX_ f, o, param, flags))) {
FILE *stdio = PerlIOSelf(o, PerlIOStdio)->stdio;
- int fd = fileno(stdio);
+ const int fd = fileno(stdio);
char mode[8];
if (flags & PERLIO_DUP_FD) {
- int dfd = PerlLIO_dup(fileno(stdio));
+ const int dfd = PerlLIO_dup(fileno(stdio));
if (dfd >= 0) {
stdio = PerlSIO_fdopen(dfd, PerlIO_modestr(o,mode));
goto set_this;
*/
# error "Don't know how to set FILE.fileno on your platform"
#endif
+ PERL_UNUSED_ARG(f);
return 0;
# endif
}
return -1;
}
else {
- int fd = fileno(stdio);
+ const int fd = fileno(stdio);
int socksfd = 0;
int invalidate = 0;
IV result = 0;
* Perl is expecting PerlIO_getc() to fill the buffer Linux's
* stdio does not do that for fread()
*/
- int ch = PerlSIO_fgetc(s);
+ const int ch = PerlSIO_fgetc(s);
if (ch != EOF) {
*buf = ch;
got = 1;
STDCHAR *eptr = (STDCHAR*)PerlSIO_get_ptr(s);
STDCHAR *buf = ((STDCHAR *) vbuf) + count;
while (count > 0) {
- int ch = *--buf & 0xFF;
+ const int ch = *--buf & 0xFF;
if (ungetc(ch,s) != ch) {
/* ungetc did not work */
break;
PerlIOBuf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
{
PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
- int fd = PerlIO_fileno(f);
+ const int fd = PerlIO_fileno(f);
if (fd >= 0 && PerlLIO_isatty(fd)) {
PerlIOBase(f)->flags |= PERLIO_F_LINEBUF | PERLIO_F_TTY;
}
if (*PerlIONext(f)) {
- Off_t posn = PerlIO_tell(PerlIONext(f));
+ const Off_t posn = PerlIO_tell(PerlIONext(f));
if (posn != (Off_t) - 1) {
b->posn = posn;
}
/*
* write() the buffer
*/
- STDCHAR *buf = b->buf;
- STDCHAR *p = buf;
+ const STDCHAR *buf = b->buf;
+ const STDCHAR *p = buf;
while (p < b->ptr) {
SSize_t count = PerlIO_write(n, p, b->ptr - p);
if (count > 0) {
SSize_t
PerlIOBuf_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
{
- PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
if (PerlIOValid(f)) {
+ const PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
if (!b->ptr)
PerlIO_get_base(f);
return PerlIOBase_read(aTHX_ f, vbuf, count);
SSize_t
PerlIOBuf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
{
- PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
+ PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
const STDCHAR *buf = (const STDCHAR *) vbuf;
const STDCHAR *flushptr = buf;
Size_t written = 0;
{
IV code;
if ((code = PerlIO_flush(f)) == 0) {
- PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
code = PerlIO_seek(PerlIONext(f), offset, whence);
if (code == 0) {
+ PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
b->posn = PerlIO_tell(PerlIONext(f));
}
}
IV
PerlIOBuf_popped(pTHX_ PerlIO *f)
{
- IV code = PerlIOBase_popped(aTHX_ f);
- PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
+ const IV code = PerlIOBase_popped(aTHX_ f);
+ PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
if (b->buf && b->buf != (STDCHAR *) & b->oneword) {
Safefree(b->buf);
}
IV
PerlIOBuf_close(pTHX_ PerlIO *f)
{
- IV code = PerlIOBase_close(aTHX_ f);
- PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
+ const IV code = PerlIOBase_close(aTHX_ f);
+ PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
if (b->buf && b->buf != (STDCHAR *) & b->oneword) {
Safefree(b->buf);
}
if (!b->buf) {
if (!b->bufsiz)
b->bufsiz = 4096;
- b->buf =
- Newz('B',b->buf,b->bufsiz, STDCHAR);
+ b->buf = Newxz(b->buf,b->bufsiz, STDCHAR);
if (!b->buf) {
b->buf = (STDCHAR *) & b->oneword;
b->bufsiz = sizeof(b->oneword);
IV
PerlIOPending_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
{
- IV code = PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
+ const IV code = PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
PerlIOl *l = PerlIOBase(f);
/*
* Our PerlIO_fast_gets must match what we are pushed on, or sv_gets()
if (avail > 0)
got = PerlIOBuf_read(aTHX_ f, vbuf, avail);
if (got >= 0 && got < (SSize_t)count) {
- SSize_t more =
+ const SSize_t more =
PerlIO_read(f, ((STDCHAR *) vbuf) + got, count - got);
if (more >= 0 || got == 0)
got += more;
NULL,
PerlIOBase_fileno,
PerlIOBuf_dup,
- PerlIOBuf_read, /* generic read works with ptr/cnt lies
- * ... */
+ PerlIOBuf_read, /* generic read works with ptr/cnt lies */
PerlIOCrlf_unread, /* Put CR,LF in buffer for each '\n' */
PerlIOCrlf_write, /* Put CR,LF in buffer for each '\n' */
PerlIOBuf_seek,
PerlIOMmap_map(pTHX_ PerlIO *f)
{
dVAR;
- PerlIOMmap *m = PerlIOSelf(f, PerlIOMmap);
- IV flags = PerlIOBase(f)->flags;
+ PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
+ const IV flags = PerlIOBase(f)->flags;
IV code = 0;
if (m->len)
abort();
if (flags & PERLIO_F_CANREAD) {
PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
- int fd = PerlIO_fileno(f);
+ const int fd = PerlIO_fileno(f);
Stat_t st;
code = Fstat(fd, &st);
if (code == 0 && S_ISREG(st.st_mode)) {
SSize_t
PerlIOMmap_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
{
- PerlIOMmap *m = PerlIOSelf(f, PerlIOMmap);
- PerlIOBuf *b = &m->base;
+ PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
+ PerlIOBuf * const b = &m->base;
+
if (!b->buf || !(PerlIOBase(f)->flags & PERLIO_F_WRBUF)) {
/*
* No, or wrong sort of, buffer
}
return name;
#else
- (void)f;
- (void)buf;
+ PERL_UNUSED_ARG(f);
+ PERL_UNUSED_ARG(buf);
Perl_croak(aTHX_ "Don't know how to get file name");
return Nullch;
#endif
{
dTHX;
STDCHAR buf[1];
- SSize_t count = PerlIO_read(f, buf, 1);
- if (count == 1) {
+ if ( 1 == PerlIO_read(f, buf, 1) ) {
return (unsigned char) buf[0];
}
return EOF;
{
dTHX;
SV *sv = newSVpvn("", 0);
- char *s;
+ const char *s;
STRLEN len;
SSize_t wrote;
#ifdef NEED_VA_COPY
#else
sv_vcatpvf(sv, fmt, &ap);
#endif
- s = SvPV(sv, len);
+ s = SvPV_const(sv, len);
wrote = PerlIO_write(f, s, len);
SvREFCNT_dec(sv);
return wrote;
dTHX;
PerlIO *f = NULL;
#ifdef WIN32
- int fd = win32_tmpfd();
+ const int fd = win32_tmpfd();
if (fd >= 0)
f = PerlIO_fdopen(fd, "w+b");
#else /* WIN32 */
/*
* I have no idea how portable mkstemp() is ... NI-S
*/
- int fd = mkstemp(SvPVX(sv));
+ const int fd = mkstemp(SvPVX(sv));
if (fd >= 0) {
f = PerlIO_fdopen(fd, "w+");
if (f)
PerlIOBase(f)->flags |= PERLIO_F_TEMP;
- PerlLIO_unlink(SvPVX(sv));
+ PerlLIO_unlink(SvPVX_const(sv));
SvREFCNT_dec(sv);
}
# else /* !HAS_MKSTEMP, fallback to stdio tmpfile(). */
PerlIO_vsprintf(char *s, int n, const char *fmt, va_list ap)
{
dVAR;
- int val = vsprintf(s, fmt, ap);
+ const int val = vsprintf(s, fmt, ap);
if (n >= 0) {
if (strlen(s) >= (STRLEN) n) {
dTHX;
}
#endif
-
-
-
-
-
-
-
+/*
+ * Local variables:
+ * c-indentation-style: bsd
+ * c-basic-offset: 4
+ * indent-tabs-mode: t
+ * End:
+ *
+ * ex: set ts=8 sts=4 sw=4 noet:
+ */