This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
https://perl5.git.perl.org / perl5.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
regen/ebcdic.pl: Declare tables with correct size
[perl5.git] / perlio.c
CommitLineData
14a5cf38 1/*
5cb43542
RGS		 2 * perlio.c
3 * Copyright (c) 1996-2006, Nick Ing-Simmons
2eee27d7 4 * Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011 Larry Wall and others
5cb43542
RGS		 5 *
6 * You may distribute under the terms of either the GNU General Public License
7 * or the Artistic License, as specified in the README file.
760ac839
LW		 8 */
9
14a5cf38 10/*
d31a8517
AT		 11 * Hour after hour for nearly three weary days he had jogged up and down,
12 * over passes, and through long dales, and across many streams.
4ac71550
TC		 13 *
14 * [pp.791-792 of _The Lord of the Rings_, V/iii: "The Muster of Rohan"]
d31a8517
AT		 15 */
16
166f8a29
DM		 17/* This file contains the functions needed to implement PerlIO, which
18 * is Perl's private replacement for the C stdio library. This is used
19 * by default unless you compile with -Uuseperlio or run with
20 * PERLIO=:stdio (but don't do this unless you know what you're doing)
21 */
22
d31a8517 23/*
71200d45 24 * If we have ActivePerl-like PERL_IMPLICIT_SYS then we need a dTHX to get
14a5cf38 25 * at the dispatch tables, even when we do not need it for other reasons.
71200d45 26 * Invent a dSYS macro to abstract this out
14a5cf38 27 */
7bcba3d4
NIS		 28#ifdef PERL_IMPLICIT_SYS
29#define dSYS dTHX
30#else
31#define dSYS dNOOP
32#endif
33
6f9d8c32 34#define PERLIO_NOT_STDIO 0
760ac839 35/*
6f9d8c32 36 * This file provides those parts of PerlIO abstraction
88b61e10 37 * which are not #defined in perlio.h.
6f9d8c32 38 * Which these are depends on various Configure #ifdef's
760ac839
LW		 39 */
40
41#include "EXTERN.h"
864dbfa3 42#define PERL_IN_PERLIO_C
760ac839
LW		 43#include "perl.h"
44
32af7c23
CL		 45#ifdef PERL_IMPLICIT_CONTEXT
46#undef dSYS
47#define dSYS dTHX
48#endif
49
0c4f7ff0
NIS		 50#include "XSUB.h"
51
25bbd826
CB		 52#ifdef VMS
53#include <rms.h>
54#endif
55
abf9167d
DM		 56#define PerlIO_lockcnt(f) (((PerlIOl*)(f))->head->flags)
57
1b7a0411 58/* Call the callback or PerlIOBase, and return failure. */
b32dd47e 59#define Perl_PerlIO_or_Base(f, callback, base, failure, args) \
1b7a0411 60 if (PerlIOValid(f)) { \
46c461b5 61 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;\
1b7a0411
JH		 62 if (tab && tab->callback) \
63 return (*tab->callback) args; \
64 else \
65 return PerlIOBase_ ## base args; \
66 } \
67 else \
68 SETERRNO(EBADF, SS_IVCHAN); \
69 return failure
70
71/* Call the callback or fail, and return failure. */
b32dd47e 72#define Perl_PerlIO_or_fail(f, callback, failure, args) \
1b7a0411 73 if (PerlIOValid(f)) { \
46c461b5 74 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;\
1b7a0411
JH		 75 if (tab && tab->callback) \
76 return (*tab->callback) args; \
77 SETERRNO(EINVAL, LIB_INVARG); \
78 } \
79 else \
80 SETERRNO(EBADF, SS_IVCHAN); \
81 return failure
82
83/* Call the callback or PerlIOBase, and be void. */
b32dd47e 84#define Perl_PerlIO_or_Base_void(f, callback, base, args) \
1b7a0411 85 if (PerlIOValid(f)) { \
46c461b5 86 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;\
1b7a0411
JH		 87 if (tab && tab->callback) \
88 (*tab->callback) args; \
89 else \
90 PerlIOBase_ ## base args; \
1b7a0411
JH		 91 } \
92 else \
93 SETERRNO(EBADF, SS_IVCHAN)
94
95/* Call the callback or fail, and be void. */
b32dd47e 96#define Perl_PerlIO_or_fail_void(f, callback, args) \
1b7a0411 97 if (PerlIOValid(f)) { \
46c461b5 98 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;\
1b7a0411
JH		 99 if (tab && tab->callback) \
100 (*tab->callback) args; \
37725cdc
NIS		 101 else \
102 SETERRNO(EINVAL, LIB_INVARG); \
1b7a0411
JH		 103 } \
104 else \
105 SETERRNO(EBADF, SS_IVCHAN)
106
89a3a251
JH		 107#if defined(__osf__) && _XOPEN_SOURCE < 500
108extern int fseeko(FILE *, off_t, int);
109extern off_t ftello(FILE *);
110#endif
111
76e6dc3a
KW		 112#define NATIVE_0xd CR_NATIVE
113#define NATIVE_0xa LF_NATIVE
114
a0c21aa1
JH		 115EXTERN_C int perlsio_binmode(FILE *fp, int iotype, int mode);
116
71ab4674
SP		 117int
118perlsio_binmode(FILE *fp, int iotype, int mode)
119{
120 /*
121 * This used to be contents of do_binmode in doio.c
122 */
123#ifdef DOSISH
71ab4674 124 dTHX;
58c0efa5 125 PERL_UNUSED_ARG(iotype);
71ab4674
SP		 126#ifdef NETWARE
127 if (PerlLIO_setmode(fp, mode) != -1) {
128#else
129 if (PerlLIO_setmode(fileno(fp), mode) != -1) {
130#endif
71ab4674
SP		 131 return 1;
132 }
133 else
134 return 0;
71ab4674
SP		 135#else
136# if defined(USEMYBINMODE)
137 dTHX;
58c0efa5
RGS		 138# if defined(__CYGWIN__)
139 PERL_UNUSED_ARG(iotype);
140# endif
71ab4674
SP		 141 if (my_binmode(fp, iotype, mode) != FALSE)
142 return 1;
143 else
144 return 0;
145# else
146 PERL_UNUSED_ARG(fp);
147 PERL_UNUSED_ARG(iotype);
148 PERL_UNUSED_ARG(mode);
149 return 1;
150# endif
151#endif
152}
71ab4674 153
06c7082d 154#ifndef O_ACCMODE
22569500 155#define O_ACCMODE 3 /* Assume traditional implementation */
06c7082d
NIS		 156#endif
157
158int
159PerlIO_intmode2str(int rawmode, char *mode, int *writing)
160{
de009b76 161 const int result = rawmode & O_ACCMODE;
06c7082d
NIS		 162 int ix = 0;
163 int ptype;
164 switch (result) {
165 case O_RDONLY:
166 ptype = IoTYPE_RDONLY;
167 break;
168 case O_WRONLY:
169 ptype = IoTYPE_WRONLY;
170 break;
171 case O_RDWR:
172 default:
173 ptype = IoTYPE_RDWR;
174 break;
175 }
176 if (writing)
177 *writing = (result != O_RDONLY);
178
179 if (result == O_RDONLY) {
180 mode[ix++] = 'r';
181 }
182#ifdef O_APPEND
183 else if (rawmode & O_APPEND) {
184 mode[ix++] = 'a';
185 if (result != O_WRONLY)
186 mode[ix++] = '+';
187 }
188#endif
189 else {
190 if (result == O_WRONLY)
191 mode[ix++] = 'w';
192 else {
193 mode[ix++] = 'r';
194 mode[ix++] = '+';
195 }
196 }
43e5477e
JH		 197#if O_BINARY != 0
198 /* Unless O_BINARY is different from zero, bit-and:ing
199 * with it won't do much good. */
06c7082d
NIS		 200 if (rawmode & O_BINARY)
201 mode[ix++] = 'b';
43e5477e 202# endif
06c7082d
NIS		 203 mode[ix] = '\0';
204 return ptype;
205}
206
eb73beca
NIS		 207#ifndef PERLIO_LAYERS
208int
209PerlIO_apply_layers(pTHX_ PerlIO *f, const char *mode, const char *names)
210{
6874a2de
NIS		 211 if (!names || !*names
212 || strEQ(names, ":crlf")
213 || strEQ(names, ":raw")
214 || strEQ(names, ":bytes")
215 ) {
14a5cf38
JH		 216 return 0;
217 }
218 Perl_croak(aTHX_ "Cannot apply \"%s\" in non-PerlIO perl", names);
219 /*
71200d45 220 * NOTREACHED
14a5cf38
JH		 221 */
222 return -1;
eb73beca
NIS		 223}
224
13621cfb
NIS		 225void
226PerlIO_destruct(pTHX)
227{
228}
229
f5b9d040
NIS		 230int
231PerlIO_binmode(pTHX_ PerlIO *fp, int iotype, int mode, const char *names)
232{
14a5cf38 233 return perlsio_binmode(fp, iotype, mode);
f5b9d040 234}
60382766 235
e0fa5af2 236PerlIO *
ecdeb87c 237PerlIO_fdupopen(pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
e0fa5af2 238{
a0fd4948 239#if defined(PERL_MICRO) || defined(__SYMBIAN32__)
0553478e 240 return NULL;
faf55891 241#elif defined(PERL_IMPLICIT_SYS)
22569500 242 return PerlSIO_fdupopen(f);
0553478e 243#else
faf55891 244# ifdef WIN32
30753f56 245 return win32_fdupopen(f);
faf55891 246# else
e0fa5af2 247 if (f) {
884fc2d3 248 const int fd = PerlLIO_dup_cloexec(PerlIO_fileno(f));
e0fa5af2 249 if (fd >= 0) {
06c7082d 250 char mode[8];
faf55891 251# ifdef DJGPP
dcda55fc 252 const int omode = djgpp_get_stream_mode(f);
faf55891 253# else
dcda55fc 254 const int omode = fcntl(fd, F_GETFL);
faf55891 255# endif
06c7082d 256 PerlIO_intmode2str(omode,mode,NULL);
e0fa5af2 257 /* the r+ is a hack */
06c7082d 258 return PerlIO_fdopen(fd, mode);
e0fa5af2
NIS		 259 }
260 return NULL;
261 }
262 else {
93189314 263 SETERRNO(EBADF, SS_IVCHAN);
e0fa5af2 264 }
faf55891 265# endif
e0fa5af2 266 return NULL;
0553478e 267#endif
e0fa5af2
NIS		 268}
269
270
14a5cf38 271/*
71200d45 272 * De-mux PerlIO_openn() into fdopen, freopen and fopen type entries
14a5cf38 273 */
ee518936
NIS		 274
275PerlIO *
14a5cf38
JH		 276PerlIO_openn(pTHX_ const char *layers, const char *mode, int fd,
277 int imode, int perm, PerlIO *old, int narg, SV **args)
278{
7cf31beb
NIS		 279 if (narg) {
280 if (narg > 1) {
3b8752bb 281 Perl_croak(aTHX_ "More than one argument to open");
7cf31beb 282 }
14a5cf38
JH		 283 if (*args == &PL_sv_undef)
284 return PerlIO_tmpfile();
285 else {
41188aa0 286 STRLEN len;
74622586 287 const char *name = SvPV_const(*args, len);
41188aa0 288 if (!IS_SAFE_PATHNAME(name, len, "open"))
c8028aa6
TC		 289 return NULL;
290
3b6c1aba 291 if (*mode == IoTYPE_NUMERIC) {
884fc2d3 292 fd = PerlLIO_open3_cloexec(name, imode, perm);
14a5cf38 293 if (fd >= 0)
de009b76 294 return PerlIO_fdopen(fd, mode + 1);
14a5cf38
JH		 295 }
296 else if (old) {
297 return PerlIO_reopen(name, mode, old);
298 }
299 else {
300 return PerlIO_open(name, mode);
301 }
302 }
303 }
304 else {
305 return PerlIO_fdopen(fd, (char *) mode);
306 }
307 return NULL;
ee518936
NIS		 308}
309
15eb3045 310XS(XS_PerlIO__Layer__find); /* prototype to pass -Wmissing-prototypes */
0c4f7ff0
NIS		 311XS(XS_PerlIO__Layer__find)
312{
14a5cf38
JH		 313 dXSARGS;
314 if (items < 2)
315 Perl_croak(aTHX_ "Usage class->find(name[,load])");
316 else {
dcda55fc 317 const char * const name = SvPV_nolen_const(ST(1));
14a5cf38
JH		 318 ST(0) = (strEQ(name, "crlf")
319 || strEQ(name, "raw")) ? &PL_sv_yes : &PL_sv_undef;
320 XSRETURN(1);
321 }
0c4f7ff0
NIS		 322}
323
324
325void
326Perl_boot_core_PerlIO(pTHX)
327{
14a5cf38 328 newXS("PerlIO::Layer::find", XS_PerlIO__Layer__find, __FILE__);
0c4f7ff0
NIS		 329}
330
ac27b0f5
NIS		 331#endif
332
32e30700 333
6f9d8c32 334/*======================================================================================*/
14a5cf38 335/*
71200d45 336 * Implement all the PerlIO interface ourselves.
9e353e3b 337 */
760ac839 338
76ced9ad
NIS		 339#include "perliol.h"
340
6f9d8c32 341void
14a5cf38
JH		 342PerlIO_debug(const char *fmt, ...)
343{
14a5cf38
JH		 344 va_list ap;
345 dSYS;
e17bc05a
TC		 346
347 if (!DEBUG_i_TEST)
348 return;
349
d732c5e5
JH		 350 va_start(ap, fmt);
351
582588d2 352 if (!PL_perlio_debug_fd) {
284167a5 353 if (!TAINTING_get &&
985213f2
AB		 354 PerlProc_getuid() == PerlProc_geteuid() &&
355 PerlProc_getgid() == PerlProc_getegid()) {
582588d2
NC		 356 const char * const s = PerlEnv_getenv("PERLIO_DEBUG");
357 if (s && *s)
0b5984d3
Z		 358 PL_perlio_debug_fd = PerlLIO_open3_cloexec(s,
359 O_WRONLY | O_CREAT | O_APPEND, 0666);
582588d2 360 else
0b5984d3 361 PL_perlio_debug_fd = PerlLIO_dup_cloexec(2); /* stderr */
582588d2 362 } else {
64320867
TC		 363 /* tainting or set*id, so ignore the environment and send the
364 debug output to stderr, like other -D switches. */
0b5984d3 365 PL_perlio_debug_fd = PerlLIO_dup_cloexec(2); /* stderr */
582588d2 366 }
14a5cf38 367 }
27da23d5 368 if (PL_perlio_debug_fd > 0) {
70ace5da 369#ifdef USE_ITHREADS
dcda55fc 370 const char * const s = CopFILE(PL_curcop);
70ace5da
NIS		 371 /* Use fixed buffer as sv_catpvf etc. needs SVs */
372 char buffer[1024];
1208b3dd 373 const STRLEN len1 = my_snprintf(buffer, sizeof(buffer), "%.40s:%" IVdf " ", s ? s : "(none)", (IV) CopLINE(PL_curcop));
048eef38
TC		 374# ifdef USE_QUADMATH
375# ifdef HAS_VSNPRINTF
376 /* my_vsnprintf() isn't available with quadmath, but the native vsnprintf()
377 should be, otherwise the system isn't likely to support quadmath.
378 Nothing should be calling PerlIO_debug() with floating point anyway.
379 */
380 const STRLEN len2 = vsnprintf(buffer + len1, sizeof(buffer) - len1, fmt, ap);
381# else
382 STATIC_ASSERT_STMT(0);
383# endif
384# else
1208b3dd 385 const STRLEN len2 = my_vsnprintf(buffer + len1, sizeof(buffer) - len1, fmt, ap);
048eef38 386# endif
b469f1e0 387 PERL_UNUSED_RESULT(PerlLIO_write(PL_perlio_debug_fd, buffer, len1 + len2));
70ace5da 388#else
dcda55fc
AL		 389 const char *s = CopFILE(PL_curcop);
390 STRLEN len;
550e2ce0
NC		 391 SV * const sv = Perl_newSVpvf(aTHX_ "%s:%" IVdf " ", s ? s : "(none)",
392 (IV) CopLINE(PL_curcop));
14a5cf38
JH		 393 Perl_sv_vcatpvf(aTHX_ sv, fmt, &ap);
394
b83604b4 395 s = SvPV_const(sv, len);
b469f1e0 396 PERL_UNUSED_RESULT(PerlLIO_write(PL_perlio_debug_fd, s, len));
14a5cf38 397 SvREFCNT_dec(sv);
70ace5da 398#endif
14a5cf38
JH		 399 }
400 va_end(ap);
6f9d8c32
NIS		 401}
402
9e353e3b
NIS		 403/*--------------------------------------------------------------------------------------*/
404
14a5cf38 405/*
71200d45 406 * Inner level routines
14a5cf38 407 */
9e353e3b 408
16865ff7
DM		 409/* check that the head field of each layer points back to the head */
410
411#ifdef DEBUGGING
412# define VERIFY_HEAD(f) PerlIO_verify_head(aTHX_ f)
413static void
414PerlIO_verify_head(pTHX_ PerlIO *f)
415{
416 PerlIOl *head, *p;
417 int seen = 0;
dd791c72
JH		 418#ifndef PERL_IMPLICIT_SYS
419 PERL_UNUSED_CONTEXT;
420#endif
16865ff7
DM		 421 if (!PerlIOValid(f))
422 return;
423 p = head = PerlIOBase(f)->head;
424 assert(p);
425 do {
426 assert(p->head == head);
427 if (p == (PerlIOl*)f)
428 seen = 1;
429 p = p->next;
430 } while (p);
431 assert(seen);
432}
433#else
434# define VERIFY_HEAD(f)
435#endif
436
437
14a5cf38 438/*
71200d45 439 * Table of pointers to the PerlIO structs (malloc'ed)
14a5cf38 440 */
05d1247b 441#define PERLIO_TABLE_SIZE 64
6f9d8c32 442
8995e67d
DM		 443static void
444PerlIO_init_table(pTHX)
445{
446 if (PL_perlio)
447 return;
448 Newxz(PL_perlio, PERLIO_TABLE_SIZE, PerlIOl);
449}
450
451
452
760ac839 453PerlIO *
5f1a76d0 454PerlIO_allocate(pTHX)
6f9d8c32 455{
14a5cf38 456 /*
71200d45 457 * Find a free slot in the table, allocating new table as necessary
14a5cf38 458 */
303f2dc3
DM		 459 PerlIOl **last;
460 PerlIOl *f;
a1ea730d 461 last = &PL_perlio;
14a5cf38
JH		 462 while ((f = *last)) {
463 int i;
303f2dc3 464 last = (PerlIOl **) (f);
14a5cf38 465 for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
303f2dc3 466 if (!((++f)->next)) {
4e0ef342 467 goto good_exit;
14a5cf38
JH		 468 }
469 }
470 }
303f2dc3 471 Newxz(f,PERLIO_TABLE_SIZE,PerlIOl);
14a5cf38
JH		 472 if (!f) {
473 return NULL;
474 }
303f2dc3 475 *last = (PerlIOl*) f++;
4e0ef342
DD		 476
477 good_exit:
abf9167d 478 f->flags = 0; /* lockcnt */
303f2dc3 479 f->tab = NULL;
16865ff7 480 f->head = f;
303f2dc3 481 return (PerlIO*) f;
05d1247b
NIS		 482}
483
a1ea730d
NIS		 484#undef PerlIO_fdupopen
485PerlIO *
ecdeb87c 486PerlIO_fdupopen(pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
a1ea730d 487{
04892f78 488 if (PerlIOValid(f)) {
de009b76 489 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
e17bc05a 490 DEBUG_i( PerlIO_debug("fdupopen f=%p param=%p\n",(void*)f,(void*)param) );
210e727c
JH		 491 if (tab && tab->Dup)
492 return (*tab->Dup)(aTHX_ PerlIO_allocate(aTHX), f, param, flags);
37725cdc
NIS		 493 else {
494 return PerlIOBase_dup(aTHX_ PerlIO_allocate(aTHX), f, param, flags);
495 }
a1ea730d 496 }
210e727c
JH		 497 else
498 SETERRNO(EBADF, SS_IVCHAN);
499
500 return NULL;
a1ea730d
NIS		 501}
502
503void
303f2dc3 504PerlIO_cleantable(pTHX_ PerlIOl **tablep)
05d1247b 505{
303f2dc3 506 PerlIOl * const table = *tablep;
14a5cf38
JH		 507 if (table) {
508 int i;
303f2dc3 509 PerlIO_cleantable(aTHX_(PerlIOl **) & (table[0]));
14a5cf38 510 for (i = PERLIO_TABLE_SIZE - 1; i > 0; i--) {
303f2dc3
DM		 511 PerlIOl * const f = table + i;
512 if (f->next) {
513 PerlIO_close(&(f->next));
14a5cf38
JH		 514 }
515 }
3a1ee7e8 516 Safefree(table);
14a5cf38 517 *tablep = NULL;
05d1247b 518 }
05d1247b
NIS		 519}
520
fcf2db38
NIS		 521
522PerlIO_list_t *
3a1ee7e8 523PerlIO_list_alloc(pTHX)
fcf2db38 524{
14a5cf38 525 PerlIO_list_t *list;
96a5add6 526 PERL_UNUSED_CONTEXT;
a02a5408 527 Newxz(list, 1, PerlIO_list_t);
14a5cf38
JH		 528 list->refcnt = 1;
529 return list;
fcf2db38
NIS		 530}
531
532void
3a1ee7e8 533PerlIO_list_free(pTHX_ PerlIO_list_t *list)
fcf2db38 534{
14a5cf38
JH		 535 if (list) {
536 if (--list->refcnt == 0) {
537 if (list->array) {
14a5cf38 538 IV i;
ef8d46e8
VP		 539 for (i = 0; i < list->cur; i++)
540 SvREFCNT_dec(list->array[i].arg);
14a5cf38
JH		 541 Safefree(list->array);
542 }
543 Safefree(list);
544 }
545 }
fcf2db38
NIS		 546}
547
548void
3a1ee7e8 549PerlIO_list_push(pTHX_ PerlIO_list_t *list, PerlIO_funcs *funcs, SV *arg)
14a5cf38 550{
334e202e 551 PerlIO_pair_t *p;
b37c2d43
AL		 552 PERL_UNUSED_CONTEXT;
553
14a5cf38 554 if (list->cur >= list->len) {
00195859 555 const IV new_len = list->len + 8;
14a5cf38 556 if (list->array)
00195859 557 Renew(list->array, new_len, PerlIO_pair_t);
14a5cf38 558 else
00195859
HS		 559 Newx(list->array, new_len, PerlIO_pair_t);
560 list->len = new_len;
14a5cf38
JH		 561 }
562 p = &(list->array[list->cur++]);
563 p->funcs = funcs;
564 if ((p->arg = arg)) {
f84c484e 565 SvREFCNT_inc_simple_void_NN(arg);
14a5cf38 566 }
fcf2db38
NIS		 567}
568
3a1ee7e8
NIS		 569PerlIO_list_t *
570PerlIO_clone_list(pTHX_ PerlIO_list_t *proto, CLONE_PARAMS *param)
571{
b37c2d43 572 PerlIO_list_t *list = NULL;
694c95cf
JH		 573 if (proto) {
574 int i;
575 list = PerlIO_list_alloc(aTHX);
576 for (i=0; i < proto->cur; i++) {
a951d81d 577 SV *arg = proto->array[i].arg;
24d147a6 578#ifdef USE_ITHREADS
a951d81d
BL		 579 if (arg && param)
580 arg = sv_dup(arg, param);
581#else
582 PERL_UNUSED_ARG(param);
583#endif
694c95cf
JH		 584 PerlIO_list_push(aTHX_ list, proto->array[i].funcs, arg);
585 }
3a1ee7e8
NIS		 586 }
587 return list;
588}
4a4a6116 589
05d1247b 590void
3a1ee7e8 591PerlIO_clone(pTHX_ PerlInterpreter *proto, CLONE_PARAMS *param)
9a6404c5 592{
3aaf42a7 593#ifdef USE_ITHREADS
303f2dc3
DM		 594 PerlIOl **table = &proto->Iperlio;
595 PerlIOl *f;
3a1ee7e8
NIS		 596 PL_perlio = NULL;
597 PL_known_layers = PerlIO_clone_list(aTHX_ proto->Iknown_layers, param);
598 PL_def_layerlist = PerlIO_clone_list(aTHX_ proto->Idef_layerlist, param);
8995e67d 599 PerlIO_init_table(aTHX);
e17bc05a 600 DEBUG_i( PerlIO_debug("Clone %p from %p\n",(void*)aTHX,(void*)proto) );
3a1ee7e8
NIS		 601 while ((f = *table)) {
602 int i;
303f2dc3 603 table = (PerlIOl **) (f++);
3a1ee7e8 604 for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
303f2dc3
DM		 605 if (f->next) {
606 (void) fp_dup(&(f->next), 0, param);
3a1ee7e8
NIS		 607 }
608 f++;
609 }
610 }
1b6737cc 611#else
a25429c6 612 PERL_UNUSED_CONTEXT;
1b6737cc
AL		 613 PERL_UNUSED_ARG(proto);
614 PERL_UNUSED_ARG(param);
3aaf42a7 615#endif
9a6404c5
DM		 616}
617
618void
13621cfb
NIS		 619PerlIO_destruct(pTHX)
620{
303f2dc3
DM		 621 PerlIOl **table = &PL_perlio;
622 PerlIOl *f;
694c95cf 623#ifdef USE_ITHREADS
e17bc05a 624 DEBUG_i( PerlIO_debug("Destruct %p\n",(void*)aTHX) );
694c95cf 625#endif
14a5cf38
JH		 626 while ((f = *table)) {
627 int i;
303f2dc3 628 table = (PerlIOl **) (f++);
14a5cf38 629 for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
303f2dc3 630 PerlIO *x = &(f->next);
dcda55fc 631 const PerlIOl *l;
14a5cf38 632 while ((l = *x)) {
cc6623a8 633 if (l->tab && l->tab->kind & PERLIO_K_DESTRUCT) {
e17bc05a 634 DEBUG_i( PerlIO_debug("Destruct popping %s\n", l->tab->name) );
14a5cf38
JH		 635 PerlIO_flush(x);
636 PerlIO_pop(aTHX_ x);
637 }
638 else {
639 x = PerlIONext(x);
640 }
641 }
642 f++;
643 }
644 }
13621cfb
NIS		 645}
646
647void
a999f61b 648PerlIO_pop(pTHX_ PerlIO *f)
760ac839 649{
dcda55fc 650 const PerlIOl *l = *f;
16865ff7 651 VERIFY_HEAD(f);
14a5cf38 652 if (l) {
e17bc05a
TC		 653 DEBUG_i( PerlIO_debug("PerlIO_pop f=%p %s\n", (void*)f,
654 l->tab ? l->tab->name : "(Null)") );
cc6623a8 655 if (l->tab && l->tab->Popped) {
14a5cf38
JH		 656 /*
657 * If popped returns non-zero do not free its layer structure
658 * it has either done so itself, or it is shared and still in
71200d45 659 * use
14a5cf38 660 */
f62ce20a 661 if ((*l->tab->Popped) (aTHX_ f) != 0)
14a5cf38
JH		 662 return;
663 }
abf9167d
DM		 664 if (PerlIO_lockcnt(f)) {
665 /* we're in use; defer freeing the structure */
666 PerlIOBase(f)->flags = PERLIO_F_CLEARED;
667 PerlIOBase(f)->tab = NULL;
668 }
669 else {
670 *f = l->next;
671 Safefree(l);
672 }
673
a8c08ecd 674 }
6f9d8c32
NIS		 675}
676
39f7a870
JH		 677/* Return as an array the stack of layers on a filehandle. Note that
678 * the stack is returned top-first in the array, and there are three
679 * times as many array elements as there are layers in the stack: the
680 * first element of a layer triplet is the name, the second one is the
681 * arguments, and the third one is the flags. */
682
683AV *
684PerlIO_get_layers(pTHX_ PerlIO *f)
685{
dcda55fc 686 AV * const av = newAV();
39f7a870 687
dcda55fc
AL		 688 if (PerlIOValid(f)) {
689 PerlIOl *l = PerlIOBase(f);
690
691 while (l) {
92e45a3e
NC		 692 /* There is some collusion in the implementation of
693 XS_PerlIO_get_layers - it knows that name and flags are
694 generated as fresh SVs here, and takes advantage of that to
695 "copy" them by taking a reference. If it changes here, it needs
696 to change there too. */
dcda55fc
AL		 697 SV * const name = l->tab && l->tab->name ?
698 newSVpv(l->tab->name, 0) : &PL_sv_undef;
699 SV * const arg = l->tab && l->tab->Getarg ?
700 (*l->tab->Getarg)(aTHX_ &l, 0, 0) : &PL_sv_undef;
701 av_push(av, name);
702 av_push(av, arg);
703 av_push(av, newSViv((IV)l->flags));
704 l = l->next;
705 }
706 }
39f7a870 707
dcda55fc 708 return av;
39f7a870
JH		 709}
710
9e353e3b 711/*--------------------------------------------------------------------------------------*/
14a5cf38 712/*
71200d45 713 * XS Interface for perl code
14a5cf38 714 */
9e353e3b 715
fcf2db38 716PerlIO_funcs *
2edd7e44 717PerlIO_find_layer(pTHX_ const char *name, STRLEN len, int load)
f3862f8b 718{
20b7effb 719
14a5cf38
JH		 720 IV i;
721 if ((SSize_t) len <= 0)
722 len = strlen(name);
3a1ee7e8 723 for (i = 0; i < PL_known_layers->cur; i++) {
46c461b5 724 PerlIO_funcs * const f = PL_known_layers->array[i].funcs;
ba90859e
NC		 725 const STRLEN this_len = strlen(f->name);
726 if (this_len == len && memEQ(f->name, name, len)) {
e17bc05a 727 DEBUG_i( PerlIO_debug("%.*s => %p\n", (int) len, name, (void*)f) );
14a5cf38
JH		 728 return f;
729 }
730 }
3a1ee7e8
NIS		 731 if (load && PL_subname && PL_def_layerlist
732 && PL_def_layerlist->cur >= 2) {
d7a09b41
SR		 733 if (PL_in_load_module) {
734 Perl_croak(aTHX_ "Recursive call to Perl_load_module in PerlIO_find_layer");
735 return NULL;
736 } else {
396482e1 737 SV * const pkgsv = newSVpvs("PerlIO");
46c461b5 738 SV * const layer = newSVpvn(name, len);
b96d8cd9 739 CV * const cv = get_cvs("PerlIO::Layer::NoWarnings", 0);
46c461b5 740 ENTER;
4fa7c2bf 741 SAVEBOOL(PL_in_load_module);
c9bca74a 742 if (cv) {
9cfa90c0 743 SAVEGENERICSV(PL_warnhook);
ad64d0ec 744 PL_warnhook = MUTABLE_SV((SvREFCNT_inc_simple_NN(cv)));
c9bca74a 745 }
4fa7c2bf 746 PL_in_load_module = TRUE;
d7a09b41
SR		 747 /*
748 * The two SVs are magically freed by load_module
749 */
a0714e2c 750 Perl_load_module(aTHX_ 0, pkgsv, NULL, layer, NULL);
d7a09b41
SR		 751 LEAVE;
752 return PerlIO_find_layer(aTHX_ name, len, 0);
753 }
14a5cf38 754 }
e17bc05a 755 DEBUG_i( PerlIO_debug("Cannot find %.*s\n", (int) len, name) );
14a5cf38 756 return NULL;
f3862f8b
NIS		 757}
758
2a1bc955 759#ifdef USE_ATTRIBUTES_FOR_PERLIO
b13b2135
NIS		 760
761static int
762perlio_mg_set(pTHX_ SV *sv, MAGIC *mg)
763{
14a5cf38 764 if (SvROK(sv)) {
159b6efe 765 IO * const io = GvIOn(MUTABLE_GV(SvRV(sv)));
dcda55fc
AL		 766 PerlIO * const ifp = IoIFP(io);
767 PerlIO * const ofp = IoOFP(io);
be2597df
MHM		 768 Perl_warn(aTHX_ "set %" SVf " %p %p %p",
769 SVfARG(sv), (void*)io, (void*)ifp, (void*)ofp);
14a5cf38
JH		 770 }
771 return 0;
b13b2135
NIS		 772}
773
774static int
775perlio_mg_get(pTHX_ SV *sv, MAGIC *mg)
776{
14a5cf38 777 if (SvROK(sv)) {
159b6efe 778 IO * const io = GvIOn(MUTABLE_GV(SvRV(sv)));
dcda55fc
AL		 779 PerlIO * const ifp = IoIFP(io);
780 PerlIO * const ofp = IoOFP(io);
be2597df
MHM		 781 Perl_warn(aTHX_ "get %" SVf " %p %p %p",
782 SVfARG(sv), (void*)io, (void*)ifp, (void*)ofp);
14a5cf38
JH		 783 }
784 return 0;
b13b2135
NIS		 785}
786
787static int
788perlio_mg_clear(pTHX_ SV *sv, MAGIC *mg)
789{
be2597df 790 Perl_warn(aTHX_ "clear %" SVf, SVfARG(sv));
14a5cf38 791 return 0;
b13b2135
NIS		 792}
793
794static int
795perlio_mg_free(pTHX_ SV *sv, MAGIC *mg)
796{
be2597df 797 Perl_warn(aTHX_ "free %" SVf, SVfARG(sv));
14a5cf38 798 return 0;
b13b2135
NIS		 799}
800
801MGVTBL perlio_vtab = {
14a5cf38
JH		 802 perlio_mg_get,
803 perlio_mg_set,
22569500 804 NULL, /* len */
14a5cf38
JH		 805 perlio_mg_clear,
806 perlio_mg_free
b13b2135
NIS		 807};
808
15eb3045 809XS(XS_io_MODIFY_SCALAR_ATTRIBUTES); /* prototype to pass -Wmissing-prototypes */
b13b2135
NIS		 810XS(XS_io_MODIFY_SCALAR_ATTRIBUTES)
811{
14a5cf38 812 dXSARGS;
dcda55fc
AL		 813 SV * const sv = SvRV(ST(1));
814 AV * const av = newAV();
14a5cf38
JH		 815 MAGIC *mg;
816 int count = 0;
817 int i;
ad64d0ec 818 sv_magic(sv, MUTABLE_SV(av), PERL_MAGIC_ext, NULL, 0);
14a5cf38
JH		 819 SvRMAGICAL_off(sv);
820 mg = mg_find(sv, PERL_MAGIC_ext);
821 mg->mg_virtual = &perlio_vtab;
822 mg_magical(sv);
be2597df 823 Perl_warn(aTHX_ "attrib %" SVf, SVfARG(sv));
14a5cf38
JH		 824 for (i = 2; i < items; i++) {
825 STRLEN len;
dcda55fc
AL		 826 const char * const name = SvPV_const(ST(i), len);
827 SV * const layer = PerlIO_find_layer(aTHX_ name, len, 1);
14a5cf38 828 if (layer) {
b37c2d43 829 av_push(av, SvREFCNT_inc_simple_NN(layer));
14a5cf38
JH		 830 }
831 else {
832 ST(count) = ST(i);
833 count++;
834 }
835 }
836 SvREFCNT_dec(av);
837 XSRETURN(count);
838}
839
b8fda935 840#endif /* USE_ATTRIBUTES_FOR_PERLIO */
2a1bc955 841
e3f3bf95
NIS		 842SV *
843PerlIO_tab_sv(pTHX_ PerlIO_funcs *tab)
f3862f8b 844{
da51bb9b 845 HV * const stash = gv_stashpvs("PerlIO::Layer", GV_ADD);
46c461b5 846 SV * const sv = sv_bless(newRV_noinc(newSViv(PTR2IV(tab))), stash);
14a5cf38 847 return sv;
e3f3bf95
NIS		 848}
849
15eb3045 850XS(XS_PerlIO__Layer__NoWarnings); /* prototype to pass -Wmissing-prototypes */
5ca1d77f 851XS(XS_PerlIO__Layer__NoWarnings)
c9bca74a 852{
486ec47a 853 /* This is used as a %SIG{__WARN__} handler to suppress warnings
c9bca74a
NIS		 854 during loading of layers.
855 */
856 dXSARGS;
5347602a 857 PERL_UNUSED_VAR(items);
e17bc05a
TC		 858 DEBUG_i(
859 if (items)
860 PerlIO_debug("warning:%s\n",SvPV_nolen_const(ST(0))) );
c9bca74a
NIS		 861 XSRETURN(0);
862}
863
15eb3045 864XS(XS_PerlIO__Layer__find); /* prototype to pass -Wmissing-prototypes */
5ca1d77f 865XS(XS_PerlIO__Layer__find)
0c4f7ff0 866{
14a5cf38
JH		 867 dXSARGS;
868 if (items < 2)
869 Perl_croak(aTHX_ "Usage class->find(name[,load])");
870 else {
de009b76 871 STRLEN len;
46c461b5 872 const char * const name = SvPV_const(ST(1), len);
f814d560 873 const bool load = (items > 2) ? SvTRUE_NN(ST(2)) : 0;
46c461b5 874 PerlIO_funcs * const layer = PerlIO_find_layer(aTHX_ name, len, load);
14a5cf38
JH		 875 ST(0) =
876 (layer) ? sv_2mortal(PerlIO_tab_sv(aTHX_ layer)) :
877 &PL_sv_undef;
878 XSRETURN(1);
879 }
0c4f7ff0
NIS		 880}
881
e3f3bf95
NIS		 882void
883PerlIO_define_layer(pTHX_ PerlIO_funcs *tab)
884{
3a1ee7e8
NIS		 885 if (!PL_known_layers)
886 PL_known_layers = PerlIO_list_alloc(aTHX);
a0714e2c 887 PerlIO_list_push(aTHX_ PL_known_layers, tab, NULL);
e17bc05a 888 DEBUG_i( PerlIO_debug("define %s %p\n", tab->name, (void*)tab) );
f3862f8b
NIS		 889}
890
1141d9f8 891int
fcf2db38 892PerlIO_parse_layers(pTHX_ PerlIO_list_t *av, const char *names)
1141d9f8 893{
14a5cf38
JH		 894 if (names) {
895 const char *s = names;
896 while (*s) {
897 while (isSPACE(*s) || *s == ':')
898 s++;
899 if (*s) {
900 STRLEN llen = 0;
901 const char *e = s;
bd61b366 902 const char *as = NULL;
14a5cf38
JH		 903 STRLEN alen = 0;
904 if (!isIDFIRST(*s)) {
905 /*
906 * Message is consistent with how attribute lists are
907 * passed. Even though this means "foo : : bar" is
71200d45 908 * seen as an invalid separator character.
14a5cf38 909 */
de009b76 910 const char q = ((*s == '\'') ? '"' : '\'');
a2a5de95
NC		 911 Perl_ck_warner(aTHX_ packWARN(WARN_LAYER),
912 "Invalid separator character %c%c%c in PerlIO layer specification %s",
913 q, *s, q, s);
93189314 914 SETERRNO(EINVAL, LIB_INVARG);
14a5cf38
JH		 915 return -1;
916 }
917 do {
918 e++;
0eb30aeb 919 } while (isWORDCHAR(*e));
14a5cf38
JH		 920 llen = e - s;
921 if (*e == '(') {
922 int nesting = 1;
923 as = ++e;
924 while (nesting) {
925 switch (*e++) {
926 case ')':
927 if (--nesting == 0)
928 alen = (e - 1) - as;
929 break;
930 case '(':
931 ++nesting;
932 break;
933 case '\\':
934 /*
935 * It's a nul terminated string, not allowed
936 * to \ the terminating null. Anything other
71200d45 937 * character is passed over.
14a5cf38
JH		 938 */
939 if (*e++) {
940 break;
941 }
2165bd23 942 /* Fall through */
14a5cf38
JH		 943 case '\0':
944 e--;
a2a5de95
NC		 945 Perl_ck_warner(aTHX_ packWARN(WARN_LAYER),
946 "Argument list not closed for PerlIO layer \"%.*s\"",
947 (int) (e - s), s);
14a5cf38
JH		 948 return -1;
949 default:
950 /*
71200d45 951 * boring.
14a5cf38
JH		 952 */
953 break;
954 }
955 }
956 }
957 if (e > s) {
46c461b5 958 PerlIO_funcs * const layer =
14a5cf38
JH		 959 PerlIO_find_layer(aTHX_ s, llen, 1);
960 if (layer) {
a951d81d
BL		 961 SV *arg = NULL;
962 if (as)
963 arg = newSVpvn(as, alen);
3a1ee7e8 964 PerlIO_list_push(aTHX_ av, layer,
a951d81d 965 (arg) ? arg : &PL_sv_undef);
ef8d46e8 966 SvREFCNT_dec(arg);
14a5cf38
JH		 967 }
968 else {
a2a5de95
NC		 969 Perl_ck_warner(aTHX_ packWARN(WARN_LAYER), "Unknown PerlIO layer \"%.*s\"",
970 (int) llen, s);
14a5cf38
JH		 971 return -1;
972 }
973 }
974 s = e;
975 }
976 }
977 }
978 return 0;
1141d9f8
NIS		 979}
980
dfebf958 981void
fcf2db38 982PerlIO_default_buffer(pTHX_ PerlIO_list_t *av)
dfebf958 983{
27da23d5 984 PERLIO_FUNCS_DECL(*tab) = &PerlIO_perlio;
35990314 985#ifdef PERLIO_USING_CRLF
6ce75a77 986 tab = &PerlIO_crlf;
846be114 987#else
6ce75a77 988 if (PerlIO_stdio.Set_ptrcnt)
22569500 989 tab = &PerlIO_stdio;
846be114 990#endif
e17bc05a 991 DEBUG_i( PerlIO_debug("Pushing %s\n", tab->name) );
0987d6f3 992 PerlIO_list_push(aTHX_ av, (PerlIO_funcs *)tab, &PL_sv_undef);
dfebf958
NIS		 993}
994
e3f3bf95 995SV *
14a5cf38 996PerlIO_arg_fetch(PerlIO_list_t *av, IV n)
e3f3bf95 997{
14a5cf38 998 return av->array[n].arg;
e3f3bf95
NIS		 999}
1000
f3862f8b 1001PerlIO_funcs *
14a5cf38 1002PerlIO_layer_fetch(pTHX_ PerlIO_list_t *av, IV n, PerlIO_funcs *def)
f3862f8b 1003{
14a5cf38 1004 if (n >= 0 && n < av->cur) {
e17bc05a
TC		 1005 DEBUG_i( PerlIO_debug("Layer %" IVdf " is %s\n", n,
1006 av->array[n].funcs->name) );
14a5cf38
JH		 1007 return av->array[n].funcs;
1008 }
1009 if (!def)
1010 Perl_croak(aTHX_ "panic: PerlIO layer array corrupt");
1011 return def;
e3f3bf95
NIS		 1012}
1013
4ec2216f
NIS		 1014IV
1015PerlIOPop_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
1016{
8772537c
AL		 1017 PERL_UNUSED_ARG(mode);
1018 PERL_UNUSED_ARG(arg);
1019 PERL_UNUSED_ARG(tab);
4ec2216f
NIS		 1020 if (PerlIOValid(f)) {
1021 PerlIO_flush(f);
1022 PerlIO_pop(aTHX_ f);
1023 return 0;
1024 }
1025 return -1;
1026}
1027
27da23d5 1028PERLIO_FUNCS_DECL(PerlIO_remove) = {
4ec2216f
NIS		 1029 sizeof(PerlIO_funcs),
1030 "pop",
1031 0,
1032 PERLIO_K_DUMMY | PERLIO_K_UTF8,
1033 PerlIOPop_pushed,
1034 NULL,
c0888ace 1035 PerlIOBase_open,
4ec2216f
NIS		 1036 NULL,
1037 NULL,
1038 NULL,
1039 NULL,
1040 NULL,
1041 NULL,
1042 NULL,
1043 NULL,
de009b76
AL		 1044 NULL,
1045 NULL,
4ec2216f
NIS		 1046 NULL, /* flush */
1047 NULL, /* fill */
1048 NULL,
1049 NULL,
1050 NULL,
1051 NULL,
1052 NULL, /* get_base */
1053 NULL, /* get_bufsiz */
1054 NULL, /* get_ptr */
1055 NULL, /* get_cnt */
1056 NULL, /* set_ptrcnt */
1057};
1058
fcf2db38 1059PerlIO_list_t *
e3f3bf95
NIS		 1060PerlIO_default_layers(pTHX)
1061{
3a1ee7e8 1062 if (!PL_def_layerlist) {
284167a5 1063 const char * const s = TAINTING_get ? NULL : PerlEnv_getenv("PERLIO");
27da23d5 1064 PERLIO_FUNCS_DECL(*osLayer) = &PerlIO_unix;
3a1ee7e8 1065 PL_def_layerlist = PerlIO_list_alloc(aTHX);
27da23d5 1066 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_unix));
979e2c82 1067#if defined(WIN32)
27da23d5 1068 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_win32));
2f8118af 1069#if 0
14a5cf38 1070 osLayer = &PerlIO_win32;
0c4128ad 1071#endif
2f8118af 1072#endif
27da23d5
JH		 1073 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_raw));
1074 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_perlio));
1075 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_stdio));
1076 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_crlf));
27da23d5
JH		 1077 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_utf8));
1078 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_remove));
1079 PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_byte));
0987d6f3
TC		 1080 PerlIO_list_push(aTHX_ PL_def_layerlist, (PerlIO_funcs *)osLayer,
1081 &PL_sv_undef);
14a5cf38 1082 if (s) {
3a1ee7e8 1083 PerlIO_parse_layers(aTHX_ PL_def_layerlist, s);
14a5cf38
JH		 1084 }
1085 else {
3a1ee7e8 1086 PerlIO_default_buffer(aTHX_ PL_def_layerlist);
14a5cf38 1087 }
1141d9f8 1088 }
3a1ee7e8
NIS		 1089 if (PL_def_layerlist->cur < 2) {
1090 PerlIO_default_buffer(aTHX_ PL_def_layerlist);
f3862f8b 1091 }
3a1ee7e8 1092 return PL_def_layerlist;
e3f3bf95
NIS		 1093}
1094
0c4f7ff0
NIS		 1095void
1096Perl_boot_core_PerlIO(pTHX)
1097{
1098#ifdef USE_ATTRIBUTES_FOR_PERLIO
14a5cf38
JH		 1099 newXS("io::MODIFY_SCALAR_ATTRIBUTES", XS_io_MODIFY_SCALAR_ATTRIBUTES,
1100 __FILE__);
0c4f7ff0 1101#endif
14a5cf38 1102 newXS("PerlIO::Layer::find", XS_PerlIO__Layer__find, __FILE__);
c9bca74a 1103 newXS("PerlIO::Layer::NoWarnings", XS_PerlIO__Layer__NoWarnings, __FILE__);
0c4f7ff0 1104}
e3f3bf95
NIS		 1105
1106PerlIO_funcs *
1107PerlIO_default_layer(pTHX_ I32 n)
1108{
46c461b5 1109 PerlIO_list_t * const av = PerlIO_default_layers(aTHX);
14a5cf38
JH		 1110 if (n < 0)
1111 n += av->cur;
27da23d5 1112 return PerlIO_layer_fetch(aTHX_ av, n, PERLIO_FUNCS_CAST(&PerlIO_stdio));
f3862f8b
NIS		 1113}
1114
a999f61b
NIS		 1115#define PerlIO_default_top() PerlIO_default_layer(aTHX_ -1)
1116#define PerlIO_default_btm() PerlIO_default_layer(aTHX_ 0)
60382766
NIS		 1117
1118void
1141d9f8 1119PerlIO_stdstreams(pTHX)
60382766 1120{
a1ea730d 1121 if (!PL_perlio) {
8995e67d 1122 PerlIO_init_table(aTHX);
14a5cf38
JH		 1123 PerlIO_fdopen(0, "Ir" PERLIO_STDTEXT);
1124 PerlIO_fdopen(1, "Iw" PERLIO_STDTEXT);
1125 PerlIO_fdopen(2, "Iw" PERLIO_STDTEXT);
1126 }
60382766
NIS		 1127}
1128
1129PerlIO *
27da23d5 1130PerlIO_push(pTHX_ PerlIO *f, PERLIO_FUNCS_DECL(*tab), const char *mode, SV *arg)
14a5cf38 1131{
16865ff7 1132 VERIFY_HEAD(f);
2dc2558e 1133 if (tab->fsize != sizeof(PerlIO_funcs)) {
0dc17498 1134 Perl_croak( aTHX_
147e3846 1135 "%s (%" UVuf ") does not match %s (%" UVuf ")",
5cf96513
RB		 1136 "PerlIO layer function table size", (UV)tab->fsize,
1137 "size expected by this perl", (UV)sizeof(PerlIO_funcs) );
2dc2558e
NIS		 1138 }
1139 if (tab->size) {
b464bac0 1140 PerlIOl *l;
2dc2558e 1141 if (tab->size < sizeof(PerlIOl)) {
0dc17498 1142 Perl_croak( aTHX_
147e3846 1143 "%s (%" UVuf ") smaller than %s (%" UVuf ")",
5cf96513
RB		 1144 "PerlIO layer instance size", (UV)tab->size,
1145 "size expected by this perl", (UV)sizeof(PerlIOl) );
2dc2558e
NIS		 1146 }
1147 /* Real layer with a data area */
002e75cf
JH		 1148 if (f) {
1149 char *temp;
1150 Newxz(temp, tab->size, char);
1151 l = (PerlIOl*)temp;
1152 if (l) {
1153 l->next = *f;
1154 l->tab = (PerlIO_funcs*) tab;
16865ff7 1155 l->head = ((PerlIOl*)f)->head;
002e75cf 1156 *f = l;
e17bc05a
TC		 1157 DEBUG_i( PerlIO_debug("PerlIO_push f=%p %s %s %p\n",
1158 (void*)f, tab->name,
1159 (mode) ? mode : "(Null)", (void*)arg) );
002e75cf
JH		 1160 if (*l->tab->Pushed &&
1161 (*l->tab->Pushed)
1162 (aTHX_ f, mode, arg, (PerlIO_funcs*) tab) != 0) {
1163 PerlIO_pop(aTHX_ f);
1164 return NULL;
1165 }
2dc2558e 1166 }
002e75cf
JH		 1167 else
1168 return NULL;
2dc2558e
NIS		 1169 }
1170 }
1171 else if (f) {
1172 /* Pseudo-layer where push does its own stack adjust */
e17bc05a
TC		 1173 DEBUG_i( PerlIO_debug("PerlIO_push f=%p %s %s %p\n", (void*)f, tab->name,
1174 (mode) ? mode : "(Null)", (void*)arg) );
210e727c 1175 if (tab->Pushed &&
27da23d5 1176 (*tab->Pushed) (aTHX_ f, mode, arg, (PerlIO_funcs*) tab) != 0) {
210e727c 1177 return NULL;
14a5cf38
JH		 1178 }
1179 }
1180 return f;
60382766
NIS		 1181}
1182
81fe74fb
LT		 1183PerlIO *
1184PerlIOBase_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
1185 IV n, const char *mode, int fd, int imode, int perm,
1186 PerlIO *old, int narg, SV **args)
1187{
1188 PerlIO_funcs * const tab = PerlIO_layer_fetch(aTHX_ layers, n - 1, PerlIO_default_layer(aTHX_ 0));
1189 if (tab && tab->Open) {
1190 PerlIO* ret = (*tab->Open)(aTHX_ tab, layers, n - 1, mode, fd, imode, perm, old, narg, args);
6d5bdea2 1191 if (ret && PerlIO_push(aTHX_ ret, self, mode, PerlIOArg) == NULL) {
81fe74fb
LT		 1192 PerlIO_close(ret);
1193 return NULL;
1194 }
1195 return ret;
1196 }
1197 SETERRNO(EINVAL, LIB_INVARG);
1198 return NULL;
1199}
1200
dfebf958 1201IV
86e05cf2
NIS		 1202PerlIOBase_binmode(pTHX_ PerlIO *f)
1203{
1204 if (PerlIOValid(f)) {
1205 /* Is layer suitable for raw stream ? */
cc6623a8 1206 if (PerlIOBase(f)->tab && PerlIOBase(f)->tab->kind & PERLIO_K_RAW) {
86e05cf2
NIS		 1207 /* Yes - turn off UTF-8-ness, to undo UTF-8 locale effects */
1208 PerlIOBase(f)->flags &= ~PERLIO_F_UTF8;
1209 }
1210 else {
1211 /* Not suitable - pop it */
1212 PerlIO_pop(aTHX_ f);
1213 }
1214 return 0;
1215 }
1216 return -1;
1217}
1218
1219IV
2dc2558e 1220PerlIORaw_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
dfebf958 1221{
8772537c
AL		 1222 PERL_UNUSED_ARG(mode);
1223 PERL_UNUSED_ARG(arg);
1224 PERL_UNUSED_ARG(tab);
86e05cf2 1225
04892f78 1226 if (PerlIOValid(f)) {
86e05cf2 1227 PerlIO *t;
de009b76 1228 const PerlIOl *l;
14a5cf38 1229 PerlIO_flush(f);
86e05cf2
NIS		 1230 /*
1231 * Strip all layers that are not suitable for a raw stream
1232 */
1233 t = f;
1234 while (t && (l = *t)) {
cc6623a8 1235 if (l->tab && l->tab->Binmode) {
86e05cf2 1236 /* Has a handler - normal case */
9d97e8b8 1237 if ((*l->tab->Binmode)(aTHX_ t) == 0) {
86e05cf2
NIS		 1238 if (*t == l) {
1239 /* Layer still there - move down a layer */
1240 t = PerlIONext(t);
1241 }
1242 }
1243 else {
1244 return -1;
1245 }
14a5cf38
JH		 1246 }
1247 else {
86e05cf2
NIS		 1248 /* No handler - pop it */
1249 PerlIO_pop(aTHX_ t);
14a5cf38
JH		 1250 }
1251 }
86e05cf2 1252 if (PerlIOValid(f)) {
e17bc05a
TC		 1253 DEBUG_i( PerlIO_debug(":raw f=%p :%s\n", (void*)f,
1254 PerlIOBase(f)->tab ? PerlIOBase(f)->tab->name : "(Null)") );
86e05cf2
NIS		 1255 return 0;
1256 }
14a5cf38
JH		 1257 }
1258 return -1;
dfebf958
NIS		 1259}
1260
ac27b0f5 1261int
14a5cf38 1262PerlIO_apply_layera(pTHX_ PerlIO *f, const char *mode,
d9dac8cd 1263 PerlIO_list_t *layers, IV n, IV max)
14a5cf38 1264{
14a5cf38
JH		 1265 int code = 0;
1266 while (n < max) {
8772537c 1267 PerlIO_funcs * const tab = PerlIO_layer_fetch(aTHX_ layers, n, NULL);
14a5cf38
JH		 1268 if (tab) {
1269 if (!PerlIO_push(aTHX_ f, tab, mode, PerlIOArg)) {
1270 code = -1;
1271 break;
1272 }
1273 }
1274 n++;
1275 }
1276 return code;
e3f3bf95
NIS		 1277}
1278
1279int
ac27b0f5
NIS		 1280PerlIO_apply_layers(pTHX_ PerlIO *f, const char *mode, const char *names)
1281{
14a5cf38 1282 int code = 0;
da0fccaa
DG		 1283 ENTER;
1284 save_scalar(PL_errgv);
53f1b6d2 1285 if (f && names) {
8772537c 1286 PerlIO_list_t * const layers = PerlIO_list_alloc(aTHX);
14a5cf38
JH		 1287 code = PerlIO_parse_layers(aTHX_ layers, names);
1288 if (code == 0) {
d9dac8cd 1289 code = PerlIO_apply_layera(aTHX_ f, mode, layers, 0, layers->cur);
14a5cf38 1290 }
3a1ee7e8 1291 PerlIO_list_free(aTHX_ layers);
ac27b0f5 1292 }
da0fccaa 1293 LEAVE;
14a5cf38 1294 return code;
ac27b0f5
NIS		 1295}
1296
f3862f8b 1297
60382766 1298/*--------------------------------------------------------------------------------------*/
14a5cf38 1299/*
71200d45 1300 * Given the abstraction above the public API functions
14a5cf38 1301 */
60382766
NIS		 1302
1303int
f5b9d040 1304PerlIO_binmode(pTHX_ PerlIO *f, int iotype, int mode, const char *names)
76ced9ad 1305{
5347602a
DM		 1306 PERL_UNUSED_ARG(iotype);
1307 PERL_UNUSED_ARG(mode);
1308
e17bc05a
TC		 1309 DEBUG_i(
1310 PerlIO_debug("PerlIO_binmode f=%p %s %c %x %s\n", (void*)f,
1311 (PerlIOBase(f) && PerlIOBase(f)->tab) ?
1312 PerlIOBase(f)->tab->name : "(Null)",
1313 iotype, mode, (names) ? names : "(Null)") );
68b5363f 1314
03c0554d
NIS		 1315 if (names) {
1316 /* Do not flush etc. if (e.g.) switching encodings.
1317 if a pushed layer knows it needs to flush lower layers
1318 (for example :unix which is never going to call them)
1319 it can do the flush when it is pushed.
1320 */
8298454c 1321 return cBOOL(PerlIO_apply_layers(aTHX_ f, NULL, names) == 0);
03c0554d
NIS		 1322 }
1323 else {
86e05cf2 1324 /* Fake 5.6 legacy of using this call to turn ON O_TEXT */
35990314 1325#ifdef PERLIO_USING_CRLF
03c0554d
NIS		 1326 /* Legacy binmode only has meaning if O_TEXT has a value distinct from
1327 O_BINARY so we can look for it in mode.
1328 */
1329 if (!(mode & O_BINARY)) {
1330 /* Text mode */
86e05cf2
NIS		 1331 /* FIXME?: Looking down the layer stack seems wrong,
1332 but is a way of reaching past (say) an encoding layer
1333 to flip CRLF-ness of the layer(s) below
1334 */
03c0554d
NIS		 1335 while (*f) {
1336 /* Perhaps we should turn on bottom-most aware layer
1337 e.g. Ilya's idea that UNIX TTY could serve
1338 */
cc6623a8
DM		 1339 if (PerlIOBase(f)->tab &&
1340 PerlIOBase(f)->tab->kind & PERLIO_K_CANCRLF)
1341 {
03c0554d
NIS		 1342 if (!(PerlIOBase(f)->flags & PERLIO_F_CRLF)) {
1343 /* Not in text mode - flush any pending stuff and flip it */
1344 PerlIO_flush(f);
1345 PerlIOBase(f)->flags |= PERLIO_F_CRLF;
1346 }
1347 /* Only need to turn it on in one layer so we are done */
1348 return TRUE;
ed53a2bb 1349 }
03c0554d 1350 f = PerlIONext(f);
14a5cf38 1351 }
03c0554d
NIS		 1352 /* Not finding a CRLF aware layer presumably means we are binary
1353 which is not what was requested - so we failed
1354 We _could_ push :crlf layer but so could caller
1355 */
1356 return FALSE;
14a5cf38 1357 }
6ce75a77 1358#endif
86e05cf2
NIS		 1359 /* Legacy binmode is now _defined_ as being equivalent to pushing :raw
1360 So code that used to be here is now in PerlIORaw_pushed().
03c0554d 1361 */
8298454c 1362 return cBOOL(PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_raw), NULL, NULL));
14a5cf38 1363 }
f5b9d040
NIS		 1364}
1365
f5b9d040 1366int
e87a358a 1367PerlIO__close(pTHX_ PerlIO *f)
f5b9d040 1368{
37725cdc 1369 if (PerlIOValid(f)) {
46c461b5 1370 PerlIO_funcs * const tab = PerlIOBase(f)->tab;
37725cdc
NIS		 1371 if (tab && tab->Close)
1372 return (*tab->Close)(aTHX_ f);
1373 else
1374 return PerlIOBase_close(aTHX_ f);
1375 }
14a5cf38 1376 else {
93189314 1377 SETERRNO(EBADF, SS_IVCHAN);
14a5cf38
JH		 1378 return -1;
1379 }
76ced9ad
NIS		 1380}
1381
b931b1d9 1382int
e87a358a 1383Perl_PerlIO_close(pTHX_ PerlIO *f)
b931b1d9 1384{
de009b76 1385 const int code = PerlIO__close(aTHX_ f);
37725cdc
NIS		 1386 while (PerlIOValid(f)) {
1387 PerlIO_pop(aTHX_ f);
abf9167d
DM		 1388 if (PerlIO_lockcnt(f))
1389 /* we're in use; the 'pop' deferred freeing the structure */
1390 f = PerlIONext(f);
f6c77cf1 1391 }
14a5cf38 1392 return code;
b931b1d9
NIS		 1393}
1394
b931b1d9 1395int
e87a358a 1396Perl_PerlIO_fileno(pTHX_ PerlIO *f)
b931b1d9 1397{
20b7effb 1398 Perl_PerlIO_or_Base(f, Fileno, fileno, -1, (aTHX_ f));
b931b1d9
NIS		 1399}
1400
1141d9f8 1401
fcf2db38 1402static PerlIO_funcs *
2edd7e44
NIS		 1403PerlIO_layer_from_ref(pTHX_ SV *sv)
1404{
14a5cf38 1405 /*
71200d45 1406 * For any scalar type load the handler which is bundled with perl
14a5cf38 1407 */
526fd1b4 1408 if (SvTYPE(sv) < SVt_PVAV && (!isGV_with_GP(sv) || SvFAKE(sv))) {
75208dda
RGS		 1409 PerlIO_funcs *f = PerlIO_find_layer(aTHX_ STR_WITH_LEN("scalar"), 1);
1410 /* This isn't supposed to happen, since PerlIO::scalar is core,
1411 * but could happen anyway in smaller installs or with PAR */
a2a5de95 1412 if (!f)
dcbac5bb 1413 /* diag_listed_as: Unknown PerlIO layer "%s" */
a2a5de95 1414 Perl_ck_warner(aTHX_ packWARN(WARN_LAYER), "Unknown PerlIO layer \"scalar\"");
75208dda
RGS		 1415 return f;
1416 }
14a5cf38
JH		 1417
1418 /*
71200d45 1419 * For other types allow if layer is known but don't try and load it
14a5cf38
JH		 1420 */
1421 switch (SvTYPE(sv)) {
1422 case SVt_PVAV:
6a245ed1 1423 return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Array"), 0);
14a5cf38 1424 case SVt_PVHV:
6a245ed1 1425 return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Hash"), 0);
14a5cf38 1426 case SVt_PVCV:
6a245ed1 1427 return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Code"), 0);
14a5cf38 1428 case SVt_PVGV:
6a245ed1 1429 return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Glob"), 0);
42d0e0b7
AL		 1430 default:
1431 return NULL;
14a5cf38 1432 }
2edd7e44
NIS		 1433}
1434
fcf2db38 1435PerlIO_list_t *
14a5cf38
JH		 1436PerlIO_resolve_layers(pTHX_ const char *layers,
1437 const char *mode, int narg, SV **args)
1438{
1439 PerlIO_list_t *def = PerlIO_default_layers(aTHX);
1440 int incdef = 1;
a1ea730d 1441 if (!PL_perlio)
14a5cf38
JH		 1442 PerlIO_stdstreams(aTHX);
1443 if (narg) {
dcda55fc 1444 SV * const arg = *args;
14a5cf38 1445 /*
71200d45
NIS		 1446 * If it is a reference but not an object see if we have a handler
1447 * for it
14a5cf38 1448 */
4e0ef342 1449 if (SvROK(arg) && !SvOBJECT(SvRV(arg))) {
46c461b5 1450 PerlIO_funcs * const handler = PerlIO_layer_from_ref(aTHX_ SvRV(arg));
14a5cf38 1451 if (handler) {
3a1ee7e8
NIS		 1452 def = PerlIO_list_alloc(aTHX);
1453 PerlIO_list_push(aTHX_ def, handler, &PL_sv_undef);
14a5cf38
JH		 1454 incdef = 0;
1455 }
1456 /*
e934609f 1457 * Don't fail if handler cannot be found :via(...) etc. may do
14a5cf38 1458 * something sensible else we will just stringfy and open
71200d45 1459 * resulting string.
14a5cf38
JH		 1460 */
1461 }
1462 }
9fe371da 1463 if (!layers || !*layers)
11bcd5da 1464 layers = Perl_PerlIO_context_layers(aTHX_ mode);
14a5cf38
JH		 1465 if (layers && *layers) {
1466 PerlIO_list_t *av;
1467 if (incdef) {
a951d81d 1468 av = PerlIO_clone_list(aTHX_ def, NULL);
14a5cf38
JH		 1469 }
1470 else {
1471 av = def;
1472 }
0cff2cf3
NIS		 1473 if (PerlIO_parse_layers(aTHX_ av, layers) == 0) {
1474 return av;
1475 }
1476 else {
1477 PerlIO_list_free(aTHX_ av);
b37c2d43 1478 return NULL;
0cff2cf3 1479 }
14a5cf38
JH		 1480 }
1481 else {
1482 if (incdef)
1483 def->refcnt++;
1484 return def;
1485 }
ee518936
NIS		 1486}
1487
1488PerlIO *
14a5cf38
JH		 1489PerlIO_openn(pTHX_ const char *layers, const char *mode, int fd,
1490 int imode, int perm, PerlIO *f, int narg, SV **args)
1491{
1492 if (!f && narg == 1 && *args == &PL_sv_undef) {
16bac4a4 1493 imode = PerlIOUnix_oflags(mode);
ae73d7ec
TC		 1494
1495 if (imode != -1 && (f = PerlIO_tmpfile_flags(imode))) {
9fe371da 1496 if (!layers || !*layers)
11bcd5da 1497 layers = Perl_PerlIO_context_layers(aTHX_ mode);
14a5cf38
JH		 1498 if (layers && *layers)
1499 PerlIO_apply_layers(aTHX_ f, mode, layers);
1500 }
1501 }
1502 else {
de009b76 1503 PerlIO_list_t *layera;
14a5cf38
JH		 1504 IV n;
1505 PerlIO_funcs *tab = NULL;
04892f78 1506 if (PerlIOValid(f)) {
14a5cf38 1507 /*
71200d45
NIS		 1508 * This is "reopen" - it is not tested as perl does not use it
1509 * yet
14a5cf38
JH		 1510 */
1511 PerlIOl *l = *f;
3a1ee7e8 1512 layera = PerlIO_list_alloc(aTHX);
14a5cf38 1513 while (l) {
a951d81d 1514 SV *arg = NULL;
cc6623a8 1515 if (l->tab && l->tab->Getarg)
a951d81d
BL		 1516 arg = (*l->tab->Getarg) (aTHX_ &l, NULL, 0);
1517 PerlIO_list_push(aTHX_ layera, l->tab,
1518 (arg) ? arg : &PL_sv_undef);
ef8d46e8 1519 SvREFCNT_dec(arg);
14a5cf38
JH		 1520 l = *PerlIONext(&l);
1521 }
1522 }
1523 else {
1524 layera = PerlIO_resolve_layers(aTHX_ layers, mode, narg, args);
0cff2cf3
NIS		 1525 if (!layera) {
1526 return NULL;
1527 }
14a5cf38
JH		 1528 }
1529 /*
71200d45 1530 * Start at "top" of layer stack
14a5cf38
JH		 1531 */
1532 n = layera->cur - 1;
1533 while (n >= 0) {
46c461b5 1534 PerlIO_funcs * const t = PerlIO_layer_fetch(aTHX_ layera, n, NULL);
14a5cf38
JH		 1535 if (t && t->Open) {
1536 tab = t;
1537 break;
1538 }
1539 n--;
1540 }
1541 if (tab) {
1542 /*
71200d45 1543 * Found that layer 'n' can do opens - call it
14a5cf38 1544 */
7cf31beb 1545 if (narg > 1 && !(tab->kind & PERLIO_K_MULTIARG)) {
3b8752bb 1546 Perl_croak(aTHX_ "More than one argument to open(,':%s')",tab->name);
7cf31beb 1547 }
e17bc05a
TC		 1548 DEBUG_i( PerlIO_debug("openn(%s,'%s','%s',%d,%x,%o,%p,%d,%p)\n",
1549 tab->name, layers ? layers : "(Null)", mode, fd,
1550 imode, perm, (void*)f, narg, (void*)args) );
210e727c
JH		 1551 if (tab->Open)
1552 f = (*tab->Open) (aTHX_ tab, layera, n, mode, fd, imode, perm,
1553 f, narg, args);
1554 else {
1555 SETERRNO(EINVAL, LIB_INVARG);
1556 f = NULL;
1557 }
14a5cf38
JH		 1558 if (f) {
1559 if (n + 1 < layera->cur) {
1560 /*
1561 * More layers above the one that we used to open -
71200d45 1562 * apply them now
14a5cf38 1563 */
d9dac8cd
NIS		 1564 if (PerlIO_apply_layera(aTHX_ f, mode, layera, n + 1, layera->cur) != 0) {
1565 /* If pushing layers fails close the file */
1566 PerlIO_close(f);
14a5cf38
JH		 1567 f = NULL;
1568 }
1569 }
1570 }
1571 }
3a1ee7e8 1572 PerlIO_list_free(aTHX_ layera);
14a5cf38
JH		 1573 }
1574 return f;
ee518936 1575}
b931b1d9
NIS		 1576
1577
9e353e3b 1578SSize_t
e87a358a 1579Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
6f9d8c32 1580{
7918f24d
NC		 1581 PERL_ARGS_ASSERT_PERLIO_READ;
1582
b32dd47e 1583 Perl_PerlIO_or_Base(f, Read, read, -1, (aTHX_ f, vbuf, count));
760ac839
LW		 1584}
1585
313ca112 1586SSize_t
e87a358a 1587Perl_PerlIO_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
760ac839 1588{
7918f24d
NC		 1589 PERL_ARGS_ASSERT_PERLIO_UNREAD;
1590
b32dd47e 1591 Perl_PerlIO_or_Base(f, Unread, unread, -1, (aTHX_ f, vbuf, count));
760ac839
LW		 1592}
1593
9e353e3b 1594SSize_t
e87a358a 1595Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
760ac839 1596{
7918f24d
NC		 1597 PERL_ARGS_ASSERT_PERLIO_WRITE;
1598
b32dd47e 1599 Perl_PerlIO_or_fail(f, Write, -1, (aTHX_ f, vbuf, count));
760ac839
LW		 1600}
1601
6f9d8c32 1602int
e87a358a 1603Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
760ac839 1604{
b32dd47e 1605 Perl_PerlIO_or_fail(f, Seek, -1, (aTHX_ f, offset, whence));
760ac839
LW		 1606}
1607
9e353e3b 1608Off_t
e87a358a 1609Perl_PerlIO_tell(pTHX_ PerlIO *f)
760ac839 1610{
b32dd47e 1611 Perl_PerlIO_or_fail(f, Tell, -1, (aTHX_ f));
760ac839
LW		 1612}
1613
6f9d8c32 1614int
e87a358a 1615Perl_PerlIO_flush(pTHX_ PerlIO *f)
760ac839 1616{
14a5cf38
JH		 1617 if (f) {
1618 if (*f) {
de009b76 1619 const PerlIO_funcs *tab = PerlIOBase(f)->tab;
1b7a0411
JH		 1620
1621 if (tab && tab->Flush)
f62ce20a 1622 return (*tab->Flush) (aTHX_ f);
1b7a0411
JH		 1623 else
1624 return 0; /* If no Flush defined, silently succeed. */
14a5cf38
JH		 1625 }
1626 else {
e17bc05a 1627 DEBUG_i( PerlIO_debug("Cannot flush f=%p\n", (void*)f) );
93189314 1628 SETERRNO(EBADF, SS_IVCHAN);
14a5cf38
JH		 1629 return -1;
1630 }
1631 }
1632 else {
1633 /*
1634 * Is it good API design to do flush-all on NULL, a potentially
486ec47a 1635 * erroneous input? Maybe some magical value (PerlIO*
14a5cf38
JH		 1636 * PERLIO_FLUSH_ALL = (PerlIO*)-1;)? Yes, stdio does similar
1637 * things on fflush(NULL), but should we be bound by their design
71200d45 1638 * decisions? --jhi
14a5cf38 1639 */
303f2dc3
DM		 1640 PerlIOl **table = &PL_perlio;
1641 PerlIOl *ff;
14a5cf38 1642 int code = 0;
303f2dc3 1643 while ((ff = *table)) {
14a5cf38 1644 int i;
303f2dc3 1645 table = (PerlIOl **) (ff++);
14a5cf38 1646 for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
303f2dc3 1647 if (ff->next && PerlIO_flush(&(ff->next)) != 0)
14a5cf38 1648 code = -1;
303f2dc3 1649 ff++;
14a5cf38
JH		 1650 }
1651 }
1652 return code;
1653 }
760ac839
LW		 1654}
1655
a9c883f6 1656void
f62ce20a 1657PerlIOBase_flush_linebuf(pTHX)
a9c883f6 1658{
303f2dc3
DM		 1659 PerlIOl **table = &PL_perlio;
1660 PerlIOl *f;
14a5cf38
JH		 1661 while ((f = *table)) {
1662 int i;
303f2dc3 1663 table = (PerlIOl **) (f++);
14a5cf38 1664 for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
303f2dc3
DM		 1665 if (f->next
1666 && (PerlIOBase(&(f->next))->
14a5cf38
JH		 1667 flags & (PERLIO_F_LINEBUF | PERLIO_F_CANWRITE))
1668 == (PERLIO_F_LINEBUF | PERLIO_F_CANWRITE))
303f2dc3 1669 PerlIO_flush(&(f->next));
14a5cf38
JH		 1670 f++;
1671 }
a9c883f6 1672 }
a9c883f6
NIS		 1673}
1674
06da4f11 1675int
e87a358a 1676Perl_PerlIO_fill(pTHX_ PerlIO *f)
06da4f11 1677{
b32dd47e 1678 Perl_PerlIO_or_fail(f, Fill, -1, (aTHX_ f));
06da4f11
NIS		 1679}
1680
f3862f8b
NIS		 1681int
1682PerlIO_isutf8(PerlIO *f)
1683{
1b7a0411
JH		 1684 if (PerlIOValid(f))
1685 return (PerlIOBase(f)->flags & PERLIO_F_UTF8) != 0;
1686 else
1687 SETERRNO(EBADF, SS_IVCHAN);
37725cdc 1688
1b7a0411 1689 return -1;
f3862f8b
NIS		 1690}
1691
6f9d8c32 1692int
e87a358a 1693Perl_PerlIO_eof(pTHX_ PerlIO *f)
760ac839 1694{
b32dd47e 1695 Perl_PerlIO_or_Base(f, Eof, eof, -1, (aTHX_ f));
9e353e3b
NIS		 1696}
1697
9e353e3b 1698int
e87a358a 1699Perl_PerlIO_error(pTHX_ PerlIO *f)
9e353e3b 1700{
b32dd47e 1701 Perl_PerlIO_or_Base(f, Error, error, -1, (aTHX_ f));
9e353e3b
NIS		 1702}
1703
9e353e3b 1704void
e87a358a 1705Perl_PerlIO_clearerr(pTHX_ PerlIO *f)
9e353e3b 1706{
b32dd47e 1707 Perl_PerlIO_or_Base_void(f, Clearerr, clearerr, (aTHX_ f));
9e353e3b
NIS		 1708}
1709
9e353e3b 1710void
e87a358a 1711Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f)
9e353e3b 1712{
b32dd47e 1713 Perl_PerlIO_or_Base_void(f, Setlinebuf, setlinebuf, (aTHX_ f));
9e353e3b
NIS		 1714}
1715
9e353e3b
NIS		 1716int
1717PerlIO_has_base(PerlIO *f)
1718{
1b7a0411 1719 if (PerlIOValid(f)) {
46c461b5 1720 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1b7a0411
JH		 1721
1722 if (tab)
1723 return (tab->Get_base != NULL);
1b7a0411 1724 }
1b7a0411
JH		 1725
1726 return 0;
760ac839
LW		 1727}
1728
9e353e3b
NIS		 1729int
1730PerlIO_fast_gets(PerlIO *f)
760ac839 1731{
d7dfc388
SK		 1732 if (PerlIOValid(f)) {
1733 if (PerlIOBase(f)->flags & PERLIO_F_FASTGETS) {
1734 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1b7a0411 1735
d7dfc388
SK		 1736 if (tab)
1737 return (tab->Set_ptrcnt != NULL);
d7dfc388 1738 }
14a5cf38 1739 }
1b7a0411 1740
14a5cf38 1741 return 0;
9e353e3b
NIS		 1742}
1743
9e353e3b
NIS		 1744int
1745PerlIO_has_cntptr(PerlIO *f)
1746{
04892f78 1747 if (PerlIOValid(f)) {
46c461b5 1748 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1b7a0411
JH		 1749
1750 if (tab)
1751 return (tab->Get_ptr != NULL && tab->Get_cnt != NULL);
14a5cf38 1752 }
1b7a0411 1753
14a5cf38 1754 return 0;
9e353e3b
NIS		 1755}
1756
9e353e3b
NIS		 1757int
1758PerlIO_canset_cnt(PerlIO *f)
1759{
04892f78 1760 if (PerlIOValid(f)) {
46c461b5 1761 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1b7a0411
JH		 1762
1763 if (tab)
1764 return (tab->Set_ptrcnt != NULL);
14a5cf38 1765 }
1b7a0411 1766
14a5cf38 1767 return 0;
760ac839
LW		 1768}
1769
888911fc 1770STDCHAR *
e87a358a 1771Perl_PerlIO_get_base(pTHX_ PerlIO *f)
760ac839 1772{
b32dd47e 1773 Perl_PerlIO_or_fail(f, Get_base, NULL, (aTHX_ f));
9e353e3b
NIS		 1774}
1775
b66f3475 1776SSize_t
e87a358a 1777Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f)
9e353e3b 1778{
b66f3475 1779 /* Note that Get_bufsiz returns a Size_t */
b32dd47e 1780 Perl_PerlIO_or_fail(f, Get_bufsiz, -1, (aTHX_ f));
9e353e3b
NIS		 1781}
1782
9e353e3b 1783STDCHAR *
e87a358a 1784Perl_PerlIO_get_ptr(pTHX_ PerlIO *f)
9e353e3b 1785{
b32dd47e 1786 Perl_PerlIO_or_fail(f, Get_ptr, NULL, (aTHX_ f));
9e353e3b
NIS		 1787}
1788
b66f3475 1789SSize_t
e87a358a 1790Perl_PerlIO_get_cnt(pTHX_ PerlIO *f)
9e353e3b 1791{
b32dd47e 1792 Perl_PerlIO_or_fail(f, Get_cnt, -1, (aTHX_ f));
9e353e3b
NIS		 1793}
1794
9e353e3b 1795void
b66f3475 1796Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, SSize_t cnt)
9e353e3b 1797{
b32dd47e 1798 Perl_PerlIO_or_fail_void(f, Set_ptrcnt, (aTHX_ f, NULL, cnt));
9e353e3b
NIS		 1799}
1800
9e353e3b 1801void
b66f3475 1802Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
9e353e3b 1803{
b32dd47e 1804 Perl_PerlIO_or_fail_void(f, Set_ptrcnt, (aTHX_ f, ptr, cnt));
9e353e3b
NIS		 1805}
1806
4ec2216f 1807
9e353e3b 1808/*--------------------------------------------------------------------------------------*/
14a5cf38 1809/*
71200d45 1810 * utf8 and raw dummy layers
14a5cf38 1811 */
dfebf958 1812
26fb694e 1813IV
2dc2558e 1814PerlIOUtf8_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
26fb694e 1815{
96a5add6 1816 PERL_UNUSED_CONTEXT;
8772537c
AL		 1817 PERL_UNUSED_ARG(mode);
1818 PERL_UNUSED_ARG(arg);
00f51856 1819 if (PerlIOValid(f)) {
cc6623a8 1820 if (tab && tab->kind & PERLIO_K_UTF8)
14a5cf38
JH		 1821 PerlIOBase(f)->flags |= PERLIO_F_UTF8;
1822 else
1823 PerlIOBase(f)->flags &= ~PERLIO_F_UTF8;
1824 return 0;
1825 }
1826 return -1;
26fb694e
NIS		 1827}
1828
27da23d5 1829PERLIO_FUNCS_DECL(PerlIO_utf8) = {
2dc2558e 1830 sizeof(PerlIO_funcs),
14a5cf38 1831 "utf8",
2dc2558e 1832 0,
a778d1f5 1833 PERLIO_K_DUMMY | PERLIO_K_UTF8 | PERLIO_K_MULTIARG,
14a5cf38
JH		 1834 PerlIOUtf8_pushed,
1835 NULL,
c0888ace 1836 PerlIOBase_open,
14a5cf38
JH		 1837 NULL,
1838 NULL,
1839 NULL,
1840 NULL,
1841 NULL,
1842 NULL,
1843 NULL,
1844 NULL,
de009b76
AL		 1845 NULL,
1846 NULL,
22569500
NIS		 1847 NULL, /* flush */
1848 NULL, /* fill */
14a5cf38
JH		 1849 NULL,
1850 NULL,
1851 NULL,
1852 NULL,
22569500
NIS		 1853 NULL, /* get_base */
1854 NULL, /* get_bufsiz */
1855 NULL, /* get_ptr */
1856 NULL, /* get_cnt */
1857 NULL, /* set_ptrcnt */
26fb694e
NIS		 1858};
1859
27da23d5 1860PERLIO_FUNCS_DECL(PerlIO_byte) = {
2dc2558e 1861 sizeof(PerlIO_funcs),
14a5cf38 1862 "bytes",
2dc2558e 1863 0,
a778d1f5 1864 PERLIO_K_DUMMY | PERLIO_K_MULTIARG,
14a5cf38
JH		 1865 PerlIOUtf8_pushed,
1866 NULL,
c0888ace 1867 PerlIOBase_open,
14a5cf38
JH		 1868 NULL,
1869 NULL,
1870 NULL,
1871 NULL,
1872 NULL,
1873 NULL,
1874 NULL,
1875 NULL,
de009b76
AL		 1876 NULL,
1877 NULL,
22569500
NIS		 1878 NULL, /* flush */
1879 NULL, /* fill */
14a5cf38
JH		 1880 NULL,
1881 NULL,
1882 NULL,
1883 NULL,
22569500
NIS		 1884 NULL, /* get_base */
1885 NULL, /* get_bufsiz */
1886 NULL, /* get_ptr */
1887 NULL, /* get_cnt */
1888 NULL, /* set_ptrcnt */
dfebf958
NIS		 1889};
1890
27da23d5 1891PERLIO_FUNCS_DECL(PerlIO_raw) = {
2dc2558e 1892 sizeof(PerlIO_funcs),
14a5cf38 1893 "raw",
2dc2558e 1894 0,
14a5cf38
JH		 1895 PERLIO_K_DUMMY,
1896 PerlIORaw_pushed,
1897 PerlIOBase_popped,
ecfd0649 1898 PerlIOBase_open,
14a5cf38
JH		 1899 NULL,
1900 NULL,
1901 NULL,
1902 NULL,
1903 NULL,
1904 NULL,
1905 NULL,
1906 NULL,
de009b76
AL		 1907 NULL,
1908 NULL,
22569500
NIS		 1909 NULL, /* flush */
1910 NULL, /* fill */
14a5cf38
JH		 1911 NULL,
1912 NULL,
1913 NULL,
1914 NULL,
22569500
NIS		 1915 NULL, /* get_base */
1916 NULL, /* get_bufsiz */
1917 NULL, /* get_ptr */
1918 NULL, /* get_cnt */
1919 NULL, /* set_ptrcnt */
dfebf958
NIS		 1920};
1921/*--------------------------------------------------------------------------------------*/
1922/*--------------------------------------------------------------------------------------*/
14a5cf38 1923/*
71200d45 1924 * "Methods" of the "base class"
14a5cf38 1925 */
9e353e3b
NIS		 1926
1927IV
f62ce20a 1928PerlIOBase_fileno(pTHX_ PerlIO *f)
9e353e3b 1929{
04892f78 1930 return PerlIOValid(f) ? PerlIO_fileno(PerlIONext(f)) : -1;
9e353e3b
NIS		 1931}
1932
f5b9d040 1933char *
81428673 1934PerlIO_modestr(PerlIO * f, char *buf)
14a5cf38
JH		 1935{
1936 char *s = buf;
81428673 1937 if (PerlIOValid(f)) {
de009b76 1938 const IV flags = PerlIOBase(f)->flags;
81428673
NIS		 1939 if (flags & PERLIO_F_APPEND) {
1940 *s++ = 'a';
1941 if (flags & PERLIO_F_CANREAD) {
1942 *s++ = '+';
1943 }
14a5cf38 1944 }
81428673
NIS		 1945 else if (flags & PERLIO_F_CANREAD) {
1946 *s++ = 'r';
1947 if (flags & PERLIO_F_CANWRITE)
1948 *s++ = '+';
1949 }
1950 else if (flags & PERLIO_F_CANWRITE) {
1951 *s++ = 'w';
1952 if (flags & PERLIO_F_CANREAD) {
1953 *s++ = '+';
1954 }
14a5cf38 1955 }
35990314 1956#ifdef PERLIO_USING_CRLF
81428673
NIS		 1957 if (!(flags & PERLIO_F_CRLF))
1958 *s++ = 'b';
5f1a76d0 1959#endif
81428673 1960 }
14a5cf38
JH		 1961 *s = '\0';
1962 return buf;
f5b9d040
NIS		 1963}
1964
81428673 1965
76ced9ad 1966IV
2dc2558e 1967PerlIOBase_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
9e353e3b 1968{
de009b76 1969 PerlIOl * const l = PerlIOBase(f);
96a5add6 1970 PERL_UNUSED_CONTEXT;
8772537c 1971 PERL_UNUSED_ARG(arg);
de009b76 1972
14a5cf38
JH		 1973 l->flags &= ~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE |
1974 PERLIO_F_TRUNCATE | PERLIO_F_APPEND);
cc6623a8 1975 if (tab && tab->Set_ptrcnt != NULL)
14a5cf38
JH		 1976 l->flags |= PERLIO_F_FASTGETS;
1977 if (mode) {
3b6c1aba 1978 if (*mode == IoTYPE_NUMERIC || *mode == IoTYPE_IMPLICIT)
14a5cf38
JH		 1979 mode++;
1980 switch (*mode++) {
1981 case 'r':
1982 l->flags |= PERLIO_F_CANREAD;
1983 break;
1984 case 'a':
1985 l->flags |= PERLIO_F_APPEND | PERLIO_F_CANWRITE;
1986 break;
1987 case 'w':
1988 l->flags |= PERLIO_F_TRUNCATE | PERLIO_F_CANWRITE;
1989 break;
1990 default:
93189314 1991 SETERRNO(EINVAL, LIB_INVARG);
14a5cf38
JH		 1992 return -1;
1993 }
49fc4906
YK		 1994#ifdef EBCDIC
1995 {
1996 /* The mode variable contains one positional parameter followed by
1997 * optional keyword parameters. The positional parameters must be
1998 * passed as lowercase characters. The keyword parameters can be
1999 * passed in mixed case. They must be separated by commas. Only one
2000 * instance of a keyword can be specified. */
2001 int comma = 0;
2002 while (*mode) {
2003 switch (*mode++) {
2004 case '+':
2005 if(!comma)
2006 l->flags |= PERLIO_F_CANREAD | PERLIO_F_CANWRITE;
2007 break;
2008 case 'b':
2009 if(!comma)
2010 l->flags &= ~PERLIO_F_CRLF;
2011 break;
2012 case 't':
2013 if(!comma)
2014 l->flags |= PERLIO_F_CRLF;
2015 break;
2016 case ',':
2017 comma = 1;
2018 break;
2019 default:
2020 break;
2021 }
2022 }
2023 }
2024#else
14a5cf38
JH		 2025 while (*mode) {
2026 switch (*mode++) {
2027 case '+':
2028 l->flags |= PERLIO_F_CANREAD | PERLIO_F_CANWRITE;
2029 break;
2030 case 'b':
2031 l->flags &= ~PERLIO_F_CRLF;
2032 break;
2033 case 't':
2034 l->flags |= PERLIO_F_CRLF;
2035 break;
2036 default:
93189314 2037 SETERRNO(EINVAL, LIB_INVARG);
14a5cf38
JH		 2038 return -1;
2039 }
2040 }
49fc4906 2041#endif
14a5cf38
JH		 2042 }
2043 else {
2044 if (l->next) {
2045 l->flags |= l->next->flags &
2046 (PERLIO_F_CANREAD | PERLIO_F_CANWRITE | PERLIO_F_TRUNCATE |
2047 PERLIO_F_APPEND);
2048 }
2049 }
5e2ab84b 2050#if 0
e17bc05a 2051 DEBUG_i(
14a5cf38 2052 PerlIO_debug("PerlIOBase_pushed f=%p %s %s fl=%08" UVxf " (%s)\n",
6c9570dc 2053 (void*)f, PerlIOBase(f)->tab->name, (omode) ? omode : "(Null)",
14a5cf38 2054 l->flags, PerlIO_modestr(f, temp));
e17bc05a 2055 );
5e2ab84b 2056#endif
14a5cf38 2057 return 0;
76ced9ad
NIS		 2058}
2059
2060IV
f62ce20a 2061PerlIOBase_popped(pTHX_ PerlIO *f)
76ced9ad 2062{
96a5add6 2063 PERL_UNUSED_CONTEXT;
8772537c 2064 PERL_UNUSED_ARG(f);
14a5cf38 2065 return 0;
760ac839
LW		 2066}
2067
9e353e3b 2068SSize_t
f62ce20a 2069PerlIOBase_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
9e353e3b 2070{
14a5cf38 2071 /*
71200d45 2072 * Save the position as current head considers it
14a5cf38 2073 */
de009b76 2074 const Off_t old = PerlIO_tell(f);
a0714e2c 2075 PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_pending), "r", NULL);
14a5cf38 2076 PerlIOSelf(f, PerlIOBuf)->posn = old;
de009b76 2077 return PerlIOBuf_unread(aTHX_ f, vbuf, count);
9e353e3b
NIS		 2078}
2079
f6c77cf1 2080SSize_t
f62ce20a 2081PerlIOBase_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
f6c77cf1 2082{
14a5cf38
JH		 2083 STDCHAR *buf = (STDCHAR *) vbuf;
2084 if (f) {
263df5f1
JH		 2085 if (!(PerlIOBase(f)->flags & PERLIO_F_CANREAD)) {
2086 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
2087 SETERRNO(EBADF, SS_IVCHAN);
0ea86a10 2088 PerlIO_save_errno(f);
263df5f1
JH		 2089 return 0;
2090 }
14a5cf38 2091 while (count > 0) {
93c2c2ec
IZ		 2092 get_cnt:
2093 {
14a5cf38
JH		 2094 SSize_t avail = PerlIO_get_cnt(f);
2095 SSize_t take = 0;
2096 if (avail > 0)
94e529cc 2097 take = (((SSize_t) count >= 0) && ((SSize_t)count < avail)) ? (SSize_t)count : avail;
14a5cf38
JH		 2098 if (take > 0) {
2099 STDCHAR *ptr = PerlIO_get_ptr(f);
2100 Copy(ptr, buf, take, STDCHAR);
2101 PerlIO_set_ptrcnt(f, ptr + take, (avail -= take));
2102 count -= take;
2103 buf += take;
93c2c2ec
IZ		 2104 if (avail == 0) /* set_ptrcnt could have reset avail */
2105 goto get_cnt;
14a5cf38
JH		 2106 }
2107 if (count > 0 && avail <= 0) {
2108 if (PerlIO_fill(f) != 0)
2109 break;
2110 }
93c2c2ec 2111 }
14a5cf38
JH		 2112 }
2113 return (buf - (STDCHAR *) vbuf);
2114 }
f6c77cf1 2115 return 0;
f6c77cf1
NIS		 2116}
2117
9e353e3b 2118IV
f62ce20a 2119PerlIOBase_noop_ok(pTHX_ PerlIO *f)
9e353e3b 2120{
96a5add6 2121 PERL_UNUSED_CONTEXT;
8772537c 2122 PERL_UNUSED_ARG(f);
14a5cf38 2123 return 0;
9e353e3b
NIS		 2124}
2125
2126IV
f62ce20a 2127PerlIOBase_noop_fail(pTHX_ PerlIO *f)
06da4f11 2128{
96a5add6 2129 PERL_UNUSED_CONTEXT;
8772537c 2130 PERL_UNUSED_ARG(f);
14a5cf38 2131 return -1;
06da4f11
NIS		 2132}
2133
2134IV
f62ce20a 2135PerlIOBase_close(pTHX_ PerlIO *f)
9e353e3b 2136{
37725cdc
NIS		 2137 IV code = -1;
2138 if (PerlIOValid(f)) {
2139 PerlIO *n = PerlIONext(f);
2140 code = PerlIO_flush(f);
2141 PerlIOBase(f)->flags &=
2142 ~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE | PERLIO_F_OPEN);
2143 while (PerlIOValid(n)) {
de009b76 2144 const PerlIO_funcs * const tab = PerlIOBase(n)->tab;
37725cdc
NIS		 2145 if (tab && tab->Close) {
2146 if ((*tab->Close)(aTHX_ n) != 0)
2147 code = -1;
2148 break;
2149 }
2150 else {
2151 PerlIOBase(n)->flags &=
2152 ~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE | PERLIO_F_OPEN);
2153 }
2154 n = PerlIONext(n);
2155 }
2156 }
2157 else {
2158 SETERRNO(EBADF, SS_IVCHAN);
2159 }
14a5cf38 2160 return code;
9e353e3b
NIS		 2161}
2162
2163IV
f62ce20a 2164PerlIOBase_eof(pTHX_ PerlIO *f)
9e353e3b 2165{
96a5add6 2166 PERL_UNUSED_CONTEXT;
04892f78 2167 if (PerlIOValid(f)) {
14a5cf38
JH		 2168 return (PerlIOBase(f)->flags & PERLIO_F_EOF) != 0;
2169 }
2170 return 1;
9e353e3b
NIS		 2171}
2172
2173IV
f62ce20a 2174PerlIOBase_error(pTHX_ PerlIO *f)
9e353e3b 2175{
96a5add6 2176 PERL_UNUSED_CONTEXT;
04892f78 2177 if (PerlIOValid(f)) {
14a5cf38
JH		 2178 return (PerlIOBase(f)->flags & PERLIO_F_ERROR) != 0;
2179 }
2180 return 1;
9e353e3b
NIS		 2181}
2182
2183void
f62ce20a 2184PerlIOBase_clearerr(pTHX_ PerlIO *f)
9e353e3b 2185{
04892f78 2186 if (PerlIOValid(f)) {
dcda55fc 2187 PerlIO * const n = PerlIONext(f);
14a5cf38 2188 PerlIOBase(f)->flags &= ~(PERLIO_F_ERROR | PERLIO_F_EOF);
04892f78 2189 if (PerlIOValid(n))
14a5cf38
JH		 2190 PerlIO_clearerr(n);
2191 }
9e353e3b
NIS		 2192}
2193
2194void
f62ce20a 2195PerlIOBase_setlinebuf(pTHX_ PerlIO *f)
9e353e3b 2196{
96a5add6 2197 PERL_UNUSED_CONTEXT;
04892f78 2198 if (PerlIOValid(f)) {
14a5cf38
JH		 2199 PerlIOBase(f)->flags |= PERLIO_F_LINEBUF;
2200 }
9e353e3b
NIS		 2201}
2202
93a8090d
NIS		 2203SV *
2204PerlIO_sv_dup(pTHX_ SV *arg, CLONE_PARAMS *param)
2205{
2206 if (!arg)
a0714e2c 2207 return NULL;
24d147a6 2208#ifdef USE_ITHREADS
93a8090d 2209 if (param) {
a951d81d
BL		 2210 arg = sv_dup(arg, param);
2211 SvREFCNT_inc_simple_void_NN(arg);
2212 return arg;
93a8090d
NIS		 2213 }
2214 else {
2215 return newSVsv(arg);
2216 }
2217#else
1b6737cc 2218 PERL_UNUSED_ARG(param);
93a8090d
NIS		 2219 return newSVsv(arg);
2220#endif
2221}
2222
2223PerlIO *
ecdeb87c 2224PerlIOBase_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
93a8090d 2225{
1b6737cc 2226 PerlIO * const nexto = PerlIONext(o);
04892f78 2227 if (PerlIOValid(nexto)) {
de009b76 2228 const PerlIO_funcs * const tab = PerlIOBase(nexto)->tab;
37725cdc
NIS		 2229 if (tab && tab->Dup)
2230 f = (*tab->Dup)(aTHX_ f, nexto, param, flags);
2231 else
2232 f = PerlIOBase_dup(aTHX_ f, nexto, param, flags);
93a8090d
NIS		 2233 }
2234 if (f) {
dcda55fc 2235 PerlIO_funcs * const self = PerlIOBase(o)->tab;
a951d81d 2236 SV *arg = NULL;
93a8090d 2237 char buf[8];
316ebaf2 2238 assert(self);
e17bc05a
TC		 2239 DEBUG_i(PerlIO_debug("PerlIOBase_dup %s f=%p o=%p param=%p\n",
2240 self->name,
2241 (void*)f, (void*)o, (void*)param) );
27e6dabe
JH		 2242 if (self->Getarg)
2243 arg = (*self->Getarg)(aTHX_ o, param, flags);
93a8090d 2244 f = PerlIO_push(aTHX_ f, self, PerlIO_modestr(o,buf), arg);
df8c7dee 2245 if (f && PerlIOBase(o)->flags & PERLIO_F_UTF8)
f0720f70 2246 PerlIOBase(f)->flags |= PERLIO_F_UTF8;
ef8d46e8 2247 SvREFCNT_dec(arg);
93a8090d
NIS		 2248 }
2249 return f;
2250}
2251
27da23d5 2252/* PL_perlio_fd_refcnt[] is in intrpvar.h */
93a8090d 2253
8b84d7dd 2254/* Must be called with PL_perlio_mutex locked. */
22c96fc1 2255static void
ff25d7bc
JH		 2256S_more_refcounted_fds(pTHX_ const int new_fd)
2257 PERL_TSA_REQUIRES(PL_perlio_mutex)
2258{
7a89be66 2259 dVAR;
22c96fc1 2260 const int old_max = PL_perlio_fd_refcnt_size;
f4ae5be6 2261 const int new_max = 16 + (new_fd & ~15);
22c96fc1
NC		 2262 int *new_array;
2263
dd791c72
JH		 2264#ifndef PERL_IMPLICIT_SYS
2265 PERL_UNUSED_CONTEXT;
2266#endif
2267
e17bc05a
TC		 2268 DEBUG_i( PerlIO_debug("More fds - old=%d, need %d, new=%d\n",
2269 old_max, new_fd, new_max) );
22c96fc1
NC		 2270
2271 if (new_fd < old_max) {
2272 return;
2273 }
2274
f4ae5be6
NC		 2275 assert (new_max > new_fd);
2276
eae082a0
JH		 2277 /* Use plain realloc() since we need this memory to be really
2278 * global and visible to all the interpreters and/or threads. */
2279 new_array = (int*) realloc(PL_perlio_fd_refcnt, new_max * sizeof(int));
22c96fc1
NC		 2280
2281 if (!new_array) {
6cb8cb21 2282 MUTEX_UNLOCK(&PL_perlio_mutex);
4cbe3a7d 2283 croak_no_mem();
22c96fc1
NC		 2284 }
2285
2286 PL_perlio_fd_refcnt_size = new_max;
2287 PL_perlio_fd_refcnt = new_array;
2288
e17bc05a
TC		 2289 DEBUG_i( PerlIO_debug("Zeroing %p, %d\n",
2290 (void*)(new_array + old_max),
2291 new_max - old_max) );
22c96fc1
NC		 2292
2293 Zero(new_array + old_max, new_max - old_max, int);
2294}
2295
2296
93a8090d
NIS		 2297void
2298PerlIO_init(pTHX)
2299{
8b84d7dd 2300 /* MUTEX_INIT(&PL_perlio_mutex) is done in PERL_SYS_INIT3(). */
96a5add6 2301 PERL_UNUSED_CONTEXT;
93a8090d
NIS		 2302}
2303
168d5872
NIS		 2304void
2305PerlIOUnix_refcnt_inc(int fd)
2306{
27da23d5 2307 dTHX;
22c96fc1 2308 if (fd >= 0) {
97aff369 2309 dVAR;
22c96fc1 2310
6cb8cb21 2311 MUTEX_LOCK(&PL_perlio_mutex);
22c96fc1
NC		 2312 if (fd >= PL_perlio_fd_refcnt_size)
2313 S_more_refcounted_fds(aTHX_ fd);
2314
27da23d5 2315 PL_perlio_fd_refcnt[fd]++;
8b84d7dd 2316 if (PL_perlio_fd_refcnt[fd] <= 0) {
12605ff9 2317 /* diag_listed_as: refcnt_inc: fd %d%s */
8b84d7dd
RGS		 2318 Perl_croak(aTHX_ "refcnt_inc: fd %d: %d <= 0\n",
2319 fd, PL_perlio_fd_refcnt[fd]);
2320 }
e17bc05a
TC		 2321 DEBUG_i( PerlIO_debug("refcnt_inc: fd %d refcnt=%d\n",
2322 fd, PL_perlio_fd_refcnt[fd]) );
22c96fc1 2323
6cb8cb21 2324 MUTEX_UNLOCK(&PL_perlio_mutex);
8b84d7dd 2325 } else {
12605ff9 2326 /* diag_listed_as: refcnt_inc: fd %d%s */
8b84d7dd 2327 Perl_croak(aTHX_ "refcnt_inc: fd %d < 0\n", fd);
168d5872
NIS		 2328 }
2329}
2330
168d5872
NIS		 2331int
2332PerlIOUnix_refcnt_dec(int fd)
2333{
2334 int cnt = 0;
22c96fc1 2335 if (fd >= 0) {
e17bc05a
TC		 2336#ifdef DEBUGGING
2337 dTHX;
2338#else
97aff369 2339 dVAR;
e17bc05a 2340#endif
6cb8cb21 2341 MUTEX_LOCK(&PL_perlio_mutex);
8b84d7dd 2342 if (fd >= PL_perlio_fd_refcnt_size) {
12605ff9 2343 /* diag_listed_as: refcnt_dec: fd %d%s */
2bcd6579 2344 Perl_croak_nocontext("refcnt_dec: fd %d >= refcnt_size %d\n",
8b84d7dd
RGS		 2345 fd, PL_perlio_fd_refcnt_size);
2346 }
2347 if (PL_perlio_fd_refcnt[fd] <= 0) {
12605ff9 2348 /* diag_listed_as: refcnt_dec: fd %d%s */
2bcd6579 2349 Perl_croak_nocontext("refcnt_dec: fd %d: %d <= 0\n",
8b84d7dd
RGS		 2350 fd, PL_perlio_fd_refcnt[fd]);
2351 }
27da23d5 2352 cnt = --PL_perlio_fd_refcnt[fd];
e17bc05a 2353 DEBUG_i( PerlIO_debug("refcnt_dec: fd %d refcnt=%d\n", fd, cnt) );
6cb8cb21 2354 MUTEX_UNLOCK(&PL_perlio_mutex);
8b84d7dd 2355 } else {
12605ff9 2356 /* diag_listed_as: refcnt_dec: fd %d%s */
2bcd6579 2357 Perl_croak_nocontext("refcnt_dec: fd %d < 0\n", fd);
168d5872
NIS		 2358 }
2359 return cnt;
2360}
2361
2e0cfa16
FC		 2362int
2363PerlIOUnix_refcnt(int fd)
2364{
2365 dTHX;
2366 int cnt = 0;
2367 if (fd >= 0) {
2368 dVAR;
2e0cfa16 2369 MUTEX_LOCK(&PL_perlio_mutex);
2e0cfa16
FC		 2370 if (fd >= PL_perlio_fd_refcnt_size) {
2371 /* diag_listed_as: refcnt: fd %d%s */
2372 Perl_croak(aTHX_ "refcnt: fd %d >= refcnt_size %d\n",
2373 fd, PL_perlio_fd_refcnt_size);
2374 }
2375 if (PL_perlio_fd_refcnt[fd] <= 0) {
2376 /* diag_listed_as: refcnt: fd %d%s */
2377 Perl_croak(aTHX_ "refcnt: fd %d: %d <= 0\n",
2378 fd, PL_perlio_fd_refcnt[fd]);
2379 }
2380 cnt = PL_perlio_fd_refcnt[fd];
2e0cfa16 2381 MUTEX_UNLOCK(&PL_perlio_mutex);
2e0cfa16
FC		 2382 } else {
2383 /* diag_listed_as: refcnt: fd %d%s */
2384 Perl_croak(aTHX_ "refcnt: fd %d < 0\n", fd);
2385 }
2386 return cnt;
2387}
2388
694c95cf
JH		 2389void
2390PerlIO_cleanup(pTHX)
2391{
2392 int i;
2393#ifdef USE_ITHREADS
e17bc05a 2394 DEBUG_i( PerlIO_debug("Cleanup layers for %p\n",(void*)aTHX) );
9f4bd222 2395#else
e17bc05a 2396 DEBUG_i( PerlIO_debug("Cleanup layers\n") );
694c95cf 2397#endif
e47547a8 2398
694c95cf
JH		 2399 /* Raise STDIN..STDERR refcount so we don't close them */
2400 for (i=0; i < 3; i++)
2401 PerlIOUnix_refcnt_inc(i);
2402 PerlIO_cleantable(aTHX_ &PL_perlio);
2403 /* Restore STDIN..STDERR refcount */
2404 for (i=0; i < 3; i++)
2405 PerlIOUnix_refcnt_dec(i);
9f4bd222
NIS		 2406
2407 if (PL_known_layers) {
2408 PerlIO_list_free(aTHX_ PL_known_layers);
2409 PL_known_layers = NULL;
2410 }
27da23d5 2411 if (PL_def_layerlist) {
9f4bd222
NIS		 2412 PerlIO_list_free(aTHX_ PL_def_layerlist);
2413 PL_def_layerlist = NULL;
2414 }
6cb8cb21
RGS		 2415}
2416
0934c9d9 2417void PerlIO_teardown(void) /* Call only from PERL_SYS_TERM(). */
6cb8cb21 2418{
53d44271 2419 dVAR;
4f3da17a
DM		 2420#if 0
2421/* XXX we can't rely on an interpreter being present at this late stage,
2422 XXX so we can't use a function like PerlLIO_write that relies on one
2423 being present (at least in win32) :-(.
2424 Disable for now.
2425*/
6cb8cb21
RGS		 2426#ifdef DEBUGGING
2427 {
2428 /* By now all filehandles should have been closed, so any
2429 * stray (non-STD-)filehandles indicate *possible* (PerlIO)
2430 * errors. */
77db880c
JH		 2431#define PERLIO_TEARDOWN_MESSAGE_BUF_SIZE 64
2432#define PERLIO_TEARDOWN_MESSAGE_FD 2
2433 char buf[PERLIO_TEARDOWN_MESSAGE_BUF_SIZE];
6cb8cb21
RGS		 2434 int i;
2435 for (i = 3; i < PL_perlio_fd_refcnt_size; i++) {
77db880c
JH		 2436 if (PL_perlio_fd_refcnt[i]) {
2437 const STRLEN len =
2438 my_snprintf(buf, sizeof(buf),
2439 "PerlIO_teardown: fd %d refcnt=%d\n",
2440 i, PL_perlio_fd_refcnt[i]);
2441 PerlLIO_write(PERLIO_TEARDOWN_MESSAGE_FD, buf, len);
2442 }
6cb8cb21
RGS		 2443 }
2444 }
2445#endif
4f3da17a 2446#endif
eae082a0
JH		 2447 /* Not bothering with PL_perlio_mutex since by now
2448 * all the interpreters are gone. */
1cd82952
RGS		 2449 if (PL_perlio_fd_refcnt_size /* Assuming initial size of zero. */
2450 && PL_perlio_fd_refcnt) {
eae082a0 2451 free(PL_perlio_fd_refcnt); /* To match realloc() in S_more_refcounted_fds(). */
432ce874
YO		 2452 PL_perlio_fd_refcnt = NULL;
2453 PL_perlio_fd_refcnt_size = 0;
1cd82952 2454 }
694c95cf
JH		 2455}
2456
9e353e3b 2457/*--------------------------------------------------------------------------------------*/
14a5cf38 2458/*
71200d45 2459 * Bottom-most level for UNIX-like case
14a5cf38 2460 */
9e353e3b 2461
14a5cf38 2462typedef struct {
22569500
NIS		 2463 struct _PerlIO base; /* The generic part */
2464 int fd; /* UNIX like file descriptor */
2465 int oflags; /* open/fcntl flags */
9e353e3b
NIS		 2466} PerlIOUnix;
2467
abf9167d
DM		 2468static void
2469S_lockcnt_dec(pTHX_ const void* f)
2470{
dd791c72
JH		 2471#ifndef PERL_IMPLICIT_SYS
2472 PERL_UNUSED_CONTEXT;
2473#endif
abf9167d
DM		 2474 PerlIO_lockcnt((PerlIO*)f)--;
2475}
2476
2477
2478/* call the signal handler, and if that handler happens to clear
2479 * this handle, free what we can and return true */
2480
2481static bool
2482S_perlio_async_run(pTHX_ PerlIO* f) {
2483 ENTER;
2484 SAVEDESTRUCTOR_X(S_lockcnt_dec, (void*)f);
2485 PerlIO_lockcnt(f)++;
2486 PERL_ASYNC_CHECK();
be48bbe8
CS		 2487 if ( !(PerlIOBase(f)->flags & PERLIO_F_CLEARED) ) {
2488 LEAVE;
abf9167d 2489 return 0;
be48bbe8 2490 }
abf9167d
DM		 2491 /* we've just run some perl-level code that could have done
2492 * anything, including closing the file or clearing this layer.
2493 * If so, free any lower layers that have already been
2494 * cleared, then return an error. */
2495 while (PerlIOValid(f) &&
2496 (PerlIOBase(f)->flags & PERLIO_F_CLEARED))
2497 {
2498 const PerlIOl *l = *f;
2499 *f = l->next;
2500 Safefree(l);
2501 }
be48bbe8 2502 LEAVE;
abf9167d
DM		 2503 return 1;
2504}
2505
6f9d8c32 2506int
9e353e3b 2507PerlIOUnix_oflags(const char *mode)
760ac839 2508{
14a5cf38 2509 int oflags = -1;
3b6c1aba 2510 if (*mode == IoTYPE_IMPLICIT || *mode == IoTYPE_NUMERIC)
14a5cf38
JH		 2511 mode++;
2512 switch (*mode) {
2513 case 'r':
2514 oflags = O_RDONLY;
2515 if (*++mode == '+') {
2516 oflags = O_RDWR;
2517 mode++;
2518 }
2519 break;
2520
2521 case 'w':
2522 oflags = O_CREAT | O_TRUNC;
2523 if (*++mode == '+') {
2524 oflags |= O_RDWR;
2525 mode++;
2526 }
2527 else
2528 oflags |= O_WRONLY;
2529 break;
2530
2531 case 'a':
2532 oflags = O_CREAT | O_APPEND;
2533 if (*++mode == '+') {
2534 oflags |= O_RDWR;
2535 mode++;
2536 }
2537 else
2538 oflags |= O_WRONLY;
2539 break;
2540 }
43e5477e
JH		 2541
2542 /* XXX TODO: PerlIO_open() test that exercises 'rb' and 'rt'. */
2543
2544 /* Unless O_BINARY is different from O_TEXT, first bit-or:ing one
2545 * of them in, and then bit-and-masking the other them away, won't
2546 * have much of an effect. */
2547 switch (*mode) {
2548 case 'b':
2549#if O_TEXT != O_BINARY
2550 oflags |= O_BINARY;
14a5cf38 2551 oflags &= ~O_TEXT;
43e5477e
JH		 2552#endif
2553 mode++;
2554 break;
2555 case 't':
2556#if O_TEXT != O_BINARY
14a5cf38
JH		 2557 oflags |= O_TEXT;
2558 oflags &= ~O_BINARY;
43e5477e
JH		 2559#endif
2560 mode++;
2561 break;
2562 default:
2563# if O_BINARY != 0
2564 /* bit-or:ing with zero O_BINARY would be useless. */
93f31ee9
PG		 2565 /*
2566 * If neither "t" nor "b" was specified, open the file
2567 * in O_BINARY mode.
43e5477e
JH		 2568 *
2569 * Note that if something else than the zero byte was seen
2570 * here (e.g. bogus mode "rx"), just few lines later we will
2571 * set the errno and invalidate the flags.
93f31ee9
PG		 2572 */
2573 oflags |= O_BINARY;
43e5477e
JH		 2574# endif
2575 break;
93f31ee9 2576 }
14a5cf38 2577 if (*mode || oflags == -1) {
93189314 2578 SETERRNO(EINVAL, LIB_INVARG);
14a5cf38
JH		 2579 oflags = -1;
2580 }
2581 return oflags;
9e353e3b
NIS		 2582}
2583
2584IV
f62ce20a 2585PerlIOUnix_fileno(pTHX_ PerlIO *f)
9e353e3b 2586{
96a5add6 2587 PERL_UNUSED_CONTEXT;
14a5cf38 2588 return PerlIOSelf(f, PerlIOUnix)->fd;
9e353e3b
NIS		 2589}
2590
aa063c35
NIS		 2591static void
2592PerlIOUnix_setfd(pTHX_ PerlIO *f, int fd, int imode)
4b803d04 2593{
de009b76 2594 PerlIOUnix * const s = PerlIOSelf(f, PerlIOUnix);
6caa5a9c 2595#if defined(WIN32)
aa063c35
NIS		 2596 Stat_t st;
2597 if (PerlLIO_fstat(fd, &st) == 0) {
6caa5a9c 2598 if (!S_ISREG(st.st_mode)) {
e17bc05a 2599 DEBUG_i( PerlIO_debug("%d is not regular file\n",fd) );
6caa5a9c
NIS		 2600 PerlIOBase(f)->flags |= PERLIO_F_NOTREG;
2601 }
aa063c35 2602 else {
e17bc05a 2603 DEBUG_i( PerlIO_debug("%d _is_ a regular file\n",fd) );
aa063c35 2604 }
6caa5a9c
NIS		 2605 }
2606#endif
aa063c35
NIS		 2607 s->fd = fd;
2608 s->oflags = imode;
2609 PerlIOUnix_refcnt_inc(fd);
96a5add6 2610 PERL_UNUSED_CONTEXT;
aa063c35
NIS		 2611}
2612
2613IV
2614PerlIOUnix_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
2615{
2616 IV code = PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
14a5cf38 2617 if (*PerlIONext(f)) {
4b069b44 2618 /* We never call down so do any pending stuff now */
03c0554d 2619 PerlIO_flush(PerlIONext(f));
14a5cf38 2620 /*
71200d45 2621 * XXX could (or should) we retrieve the oflags from the open file
14a5cf38 2622 * handle rather than believing the "mode" we are passed in? XXX
71200d45 2623 * Should the value on NULL mode be 0 or -1?
14a5cf38 2624 */
acbd16bf 2625 PerlIOUnix_setfd(aTHX_ f, PerlIO_fileno(PerlIONext(f)),
aa063c35 2626 mode ? PerlIOUnix_oflags(mode) : -1);
14a5cf38
JH		 2627 }
2628 PerlIOBase(f)->flags |= PERLIO_F_OPEN;
6caa5a9c 2629
14a5cf38 2630 return code;
4b803d04
NIS		 2631}
2632
c2fcde81
JH		 2633IV
2634PerlIOUnix_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
2635{
de009b76 2636 const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
0723351e 2637 Off_t new_loc;
96a5add6 2638 PERL_UNUSED_CONTEXT;
c2fcde81
JH		 2639 if (PerlIOBase(f)->flags & PERLIO_F_NOTREG) {
2640#ifdef ESPIPE
2641 SETERRNO(ESPIPE, LIB_INVARG);
2642#else
2643 SETERRNO(EINVAL, LIB_INVARG);
2644#endif
2645 return -1;
2646 }
0723351e
NC		 2647 new_loc = PerlLIO_lseek(fd, offset, whence);
2648 if (new_loc == (Off_t) - 1)
dcda55fc 2649 return -1;
c2fcde81
JH		 2650 PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
2651 return 0;
2652}
2653
9e353e3b 2654PerlIO *
14a5cf38
JH		 2655PerlIOUnix_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
2656 IV n, const char *mode, int fd, int imode,
2657 int perm, PerlIO *f, int narg, SV **args)
2658{
884fc2d3 2659 bool known_cloexec = 0;
d9dac8cd 2660 if (PerlIOValid(f)) {
cc6623a8 2661 if (PerlIOBase(f)->tab && PerlIOBase(f)->flags & PERLIO_F_OPEN)
f62ce20a 2662 (*PerlIOBase(f)->tab->Close)(aTHX_ f);
14a5cf38
JH		 2663 }
2664 if (narg > 0) {
3b6c1aba 2665 if (*mode == IoTYPE_NUMERIC)
14a5cf38
JH		 2666 mode++;
2667 else {
2668 imode = PerlIOUnix_oflags(mode);
5e2ce0f3
CB		 2669#ifdef VMS
2670 perm = 0777; /* preserve RMS defaults, ACL inheritance, etc. */
2671#else
14a5cf38 2672 perm = 0666;
5e2ce0f3 2673#endif
14a5cf38
JH		 2674 }
2675 if (imode != -1) {
41188aa0
TC		 2676 STRLEN len;
2677 const char *path = SvPV_const(*args, len);
2678 if (!IS_SAFE_PATHNAME(path, len, "open"))
c8028aa6 2679 return NULL;
884fc2d3
Z		 2680 fd = PerlLIO_open3_cloexec(path, imode, perm);
2681 known_cloexec = 1;
14a5cf38
JH		 2682 }
2683 }
2684 if (fd >= 0) {
884fc2d3
Z		 2685 if (known_cloexec)
2686 setfd_inhexec_for_sysfd(fd);
2687 else
2688 setfd_cloexec_or_inhexec_by_sysfdness(fd);
3b6c1aba 2689 if (*mode == IoTYPE_IMPLICIT)
14a5cf38
JH		 2690 mode++;
2691 if (!f) {
2692 f = PerlIO_allocate(aTHX);
d9dac8cd
NIS		 2693 }
2694 if (!PerlIOValid(f)) {
a33cf58c 2695 if (!(f = PerlIO_push(aTHX_ f, self, mode, PerlIOArg))) {
0a20f69b 2696 PerlLIO_close(fd);
a33cf58c
NIS		 2697 return NULL;
2698 }
d9dac8cd 2699 }
aa063c35 2700 PerlIOUnix_setfd(aTHX_ f, fd, imode);
14a5cf38 2701 PerlIOBase(f)->flags |= PERLIO_F_OPEN;
c2fcde81
JH		 2702 if (*mode == IoTYPE_APPEND)
2703 PerlIOUnix_seek(aTHX_ f, 0, SEEK_END);
14a5cf38
JH		 2704 return f;
2705 }
2706 else {
2707 if (f) {
6f207bd3 2708 NOOP;
14a5cf38 2709 /*
71200d45 2710 * FIXME: pop layers ???
14a5cf38
JH		 2711 */
2712 }
2713 return NULL;
2714 }
9e353e3b
NIS		 2715}
2716
71200d45 2717PerlIO *
ecdeb87c 2718PerlIOUnix_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
71200d45 2719{
dcda55fc 2720 const PerlIOUnix * const os = PerlIOSelf(o, PerlIOUnix);
93a8090d 2721 int fd = os->fd;
ecdeb87c 2722 if (flags & PERLIO_DUP_FD) {
884fc2d3
Z		 2723 fd = PerlLIO_dup_cloexec(fd);
2724 if (fd >= 0)
2725 setfd_inhexec_for_sysfd(fd);
ecdeb87c 2726 }
22c96fc1 2727 if (fd >= 0) {
ecdeb87c 2728 f = PerlIOBase_dup(aTHX_ f, o, param, flags);
71200d45
NIS		 2729 if (f) {
2730 /* If all went well overwrite fd in dup'ed lay with the dup()'ed fd */
aa063c35 2731 PerlIOUnix_setfd(aTHX_ f, fd, os->oflags);
71200d45
NIS		 2732 return f;
2733 }
0a20f69b 2734 PerlLIO_close(fd);
71200d45
NIS		 2735 }
2736 return NULL;
2737}
2738
2739
9e353e3b 2740SSize_t
f62ce20a 2741PerlIOUnix_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
9e353e3b 2742{
abf9167d
DM		 2743 int fd;
2744 if (PerlIO_lockcnt(f)) /* in use: abort ungracefully */
2745 return -1;
2746 fd = PerlIOSelf(f, PerlIOUnix)->fd;
27da23d5
JH		 2747#ifdef PERLIO_STD_SPECIAL
2748 if (fd == 0)
2749 return PERLIO_STD_IN(fd, vbuf, count);
2750#endif
81428673 2751 if (!(PerlIOBase(f)->flags & PERLIO_F_CANREAD) ||
1fd8f4ce 2752 PerlIOBase(f)->flags & (PERLIO_F_EOF|PERLIO_F_ERROR)) {
263df5f1 2753 return 0;
1fd8f4ce 2754 }
14a5cf38 2755 while (1) {
b464bac0 2756 const SSize_t len = PerlLIO_read(fd, vbuf, count);
14a5cf38 2757 if (len >= 0 || errno != EINTR) {
ba85f2ea
NIS		 2758 if (len < 0) {
2759 if (errno != EAGAIN) {
2760 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
0ea86a10 2761 PerlIO_save_errno(f);
ba85f2ea
NIS		 2762 }
2763 }
2764 else if (len == 0 && count != 0) {
14a5cf38 2765 PerlIOBase(f)->flags |= PERLIO_F_EOF;
ba85f2ea
NIS		 2766 SETERRNO(0,0);
2767 }
14a5cf38
JH		 2768 return len;
2769 }
abf9167d
DM		 2770 /* EINTR */
2771 if (PL_sig_pending && S_perlio_async_run(aTHX_ f))
2772 return -1;
14a5cf38 2773 }
e5964223 2774 NOT_REACHED; /*NOTREACHED*/
9e353e3b
NIS		 2775}
2776
2777SSize_t
f62ce20a 2778PerlIOUnix_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
9e353e3b 2779{
abf9167d
DM		 2780 int fd;
2781 if (PerlIO_lockcnt(f)) /* in use: abort ungracefully */
2782 return -1;
2783 fd = PerlIOSelf(f, PerlIOUnix)->fd;
27da23d5
JH		 2784#ifdef PERLIO_STD_SPECIAL
2785 if (fd == 1 || fd == 2)
2786 return PERLIO_STD_OUT(fd, vbuf, count);
2787#endif
14a5cf38 2788 while (1) {
de009b76 2789 const SSize_t len = PerlLIO_write(fd, vbuf, count);
14a5cf38 2790 if (len >= 0 || errno != EINTR) {
ba85f2ea
NIS		 2791 if (len < 0) {
2792 if (errno != EAGAIN) {
2793 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
0ea86a10 2794 PerlIO_save_errno(f);
ba85f2ea
NIS		 2795 }
2796 }
14a5cf38
JH		 2797 return len;
2798 }
abf9167d
DM		 2799 /* EINTR */
2800 if (PL_sig_pending && S_perlio_async_run(aTHX_ f))
2801 return -1;
06da4f11 2802 }
e5964223 2803 NOT_REACHED; /*NOTREACHED*/
9e353e3b
NIS		 2804}
2805
9e353e3b 2806Off_t
f62ce20a 2807PerlIOUnix_tell(pTHX_ PerlIO *f)
9e353e3b 2808{
96a5add6
AL		 2809 PERL_UNUSED_CONTEXT;
2810
14a5cf38 2811 return PerlLIO_lseek(PerlIOSelf(f, PerlIOUnix)->fd, 0, SEEK_CUR);
9e353e3b
NIS		 2812}
2813
2556f95e
GF		 2814
2815IV
2376d97d 2816PerlIOUnix_close(pTHX_ PerlIO *f)
2556f95e 2817{
de009b76 2818 const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
14a5cf38 2819 int code = 0;
168d5872 2820 if (PerlIOBase(f)->flags & PERLIO_F_OPEN) {
d55a1461 2821 code = PerlIOBase_close(aTHX_ f);
168d5872 2822 if (PerlIOUnix_refcnt_dec(fd) > 0) {
93a8090d
NIS		 2823 PerlIOBase(f)->flags &= ~PERLIO_F_OPEN;
2824 return 0;
22569500 2825 }
93a8090d
NIS		 2826 }
2827 else {
93189314 2828 SETERRNO(EBADF,SS_IVCHAN);
93a8090d
NIS		 2829 return -1;
2830 }
14a5cf38
JH		 2831 while (PerlLIO_close(fd) != 0) {
2832 if (errno != EINTR) {
2833 code = -1;
2834 break;
2835 }
abf9167d
DM		 2836 /* EINTR */
2837 if (PL_sig_pending && S_perlio_async_run(aTHX_ f))
2838 return -1;
14a5cf38
JH		 2839 }
2840 if (code == 0) {
2841 PerlIOBase(f)->flags &= ~PERLIO_F_OPEN;
2842 }
2843 return code;
9e353e3b
NIS		 2844}
2845
27da23d5 2846PERLIO_FUNCS_DECL(PerlIO_unix) = {
2dc2558e 2847 sizeof(PerlIO_funcs),
14a5cf38
JH		 2848 "unix",
2849 sizeof(PerlIOUnix),
2850 PERLIO_K_RAW,
2851 PerlIOUnix_pushed,
2376d97d 2852 PerlIOBase_popped,
14a5cf38 2853 PerlIOUnix_open,
86e05cf2 2854 PerlIOBase_binmode, /* binmode */
14a5cf38
JH		 2855 NULL,
2856 PerlIOUnix_fileno,
71200d45 2857 PerlIOUnix_dup,
14a5cf38
JH		 2858 PerlIOUnix_read,
2859 PerlIOBase_unread,
2860 PerlIOUnix_write,
2861 PerlIOUnix_seek,
2862 PerlIOUnix_tell,
2863 PerlIOUnix_close,
22569500
NIS		 2864 PerlIOBase_noop_ok, /* flush */
2865 PerlIOBase_noop_fail, /* fill */
14a5cf38
JH		 2866 PerlIOBase_eof,
2867 PerlIOBase_error,
2868 PerlIOBase_clearerr,
2869 PerlIOBase_setlinebuf,
22569500
NIS		 2870 NULL, /* get_base */
2871 NULL, /* get_bufsiz */
2872 NULL, /* get_ptr */
2873 NULL, /* get_cnt */
2874 NULL, /* set_ptrcnt */
9e353e3b
NIS		 2875};
2876
2877/*--------------------------------------------------------------------------------------*/
14a5cf38 2878/*
71200d45 2879 * stdio as a layer
14a5cf38 2880 */
9e353e3b 2881
313e59c8
NIS		 2882#if defined(VMS) && !defined(STDIO_BUFFER_WRITABLE)
2883/* perl5.8 - This ensures the last minute VMS ungetc fix is not
2884 broken by the last second glibc 2.3 fix
2885 */
2886#define STDIO_BUFFER_WRITABLE
2887#endif
2888
2889
14a5cf38
JH		 2890typedef struct {
2891 struct _PerlIO base;
22569500 2892 FILE *stdio; /* The stream */
9e353e3b
NIS		 2893} PerlIOStdio;
2894
2895IV
f62ce20a 2896PerlIOStdio_fileno(pTHX_ PerlIO *f)
9e353e3b 2897{
96a5add6
AL		 2898 PERL_UNUSED_CONTEXT;
2899
c4420975
AL		 2900 if (PerlIOValid(f)) {
2901 FILE * const s = PerlIOSelf(f, PerlIOStdio)->stdio;
2902 if (s)
2903 return PerlSIO_fileno(s);
439ba545
NIS		 2904 }
2905 errno = EBADF;
2906 return -1;
9e353e3b
NIS		 2907}
2908
766a733e 2909char *
14a5cf38
JH		 2910PerlIOStdio_mode(const char *mode, char *tmode)
2911{
de009b76 2912 char * const ret = tmode;
a0625d38
SR		 2913 if (mode) {
2914 while (*mode) {
2915 *tmode++ = *mode++;
2916 }
14a5cf38 2917 }
95005ad8 2918#if defined(PERLIO_USING_CRLF) || defined(__CYGWIN__)
6ce75a77
JH		 2919 *tmode++ = 'b';
2920#endif
14a5cf38
JH		 2921 *tmode = '\0';
2922 return ret;
2923}
2924
4b803d04 2925IV
2dc2558e 2926PerlIOStdio_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
4b803d04 2927{
1fd8f4ce
NIS		 2928 PerlIO *n;
2929 if (PerlIOValid(f) && PerlIOValid(n = PerlIONext(f))) {
46c461b5 2930 PerlIO_funcs * const toptab = PerlIOBase(n)->tab;
1fd8f4ce
NIS		 2931 if (toptab == tab) {
2932 /* Top is already stdio - pop self (duplicate) and use original */
2933 PerlIO_pop(aTHX_ f);
2934 return 0;
2935 } else {
de009b76 2936 const int fd = PerlIO_fileno(n);
1fd8f4ce
NIS		 2937 char tmode[8];
2938 FILE *stdio;
81428673 2939 if (fd >= 0 && (stdio = PerlSIO_fdopen(fd,
1fd8f4ce
NIS		 2940 mode = PerlIOStdio_mode(mode, tmode)))) {
2941 PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
2942 /* We never call down so do any pending stuff now */
2943 PerlIO_flush(PerlIONext(f));
2a600bb8 2944 return PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
81428673 2945 }
1fd8f4ce
NIS		 2946 else {
2947 return -1;
2948 }
2949 }
14a5cf38 2950 }
2dc2558e 2951 return PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
4b803d04
NIS		 2952}
2953
22569500 2954
9e353e3b 2955PerlIO *
4b069b44 2956PerlIO_importFILE(FILE *stdio, const char *mode)
9e353e3b 2957{
14a5cf38
JH		 2958 dTHX;
2959 PerlIO *f = NULL;
ea5bc90f
YK		 2960#ifdef EBCDIC
2961 int rc;
2962 char filename[FILENAME_MAX];
2963 fldata_t fileinfo;
2964#endif
14a5cf38 2965 if (stdio) {
22569500 2966 PerlIOStdio *s;
375ed12a
JH		 2967 int fd0 = fileno(stdio);
2968 if (fd0 < 0) {
ea5bc90f
YK		 2969#ifdef EBCDIC
2970 rc = fldata(stdio,filename,&fileinfo);
2971 if(rc != 0){
2972 return NULL;
2973 }
2974 if(fileinfo.__dsorgHFS){
2975 return NULL;
2976 }
2977 /*This MVS dataset , OK!*/
2978#else
375ed12a 2979 return NULL;
ea5bc90f 2980#endif
375ed12a 2981 }
4b069b44
NIS		 2982 if (!mode || !*mode) {
2983 /* We need to probe to see how we can open the stream
2984 so start with read/write and then try write and read
2985 we dup() so that we can fclose without loosing the fd.
2986
2987 Note that the errno value set by a failing fdopen
2988 varies between stdio implementations.
2989 */
884fc2d3 2990 const int fd = PerlLIO_dup_cloexec(fd0);
375ed12a
JH		 2991 FILE *f2;
2992 if (fd < 0) {
2993 return f;
2994 }
2995 f2 = PerlSIO_fdopen(fd, (mode = "r+"));
4b069b44 2996 if (!f2) {
a33cf58c 2997 f2 = PerlSIO_fdopen(fd, (mode = "w"));
4b069b44
NIS		 2998 }
2999 if (!f2) {
a33cf58c 3000 f2 = PerlSIO_fdopen(fd, (mode = "r"));
4b069b44
NIS		 3001 }
3002 if (!f2) {
3003 /* Don't seem to be able to open */
3004 PerlLIO_close(fd);
3005 return f;
3006 }
3007 fclose(f2);
22569500 3008 }
de092133 3009 if ((f = PerlIO_push(aTHX_(PerlIO_allocate(aTHX)), PERLIO_FUNCS_CAST(&PerlIO_stdio), mode, NULL))) {
a33cf58c
NIS		 3010 s = PerlIOSelf(f, PerlIOStdio);
3011 s->stdio = stdio;
884fc2d3
Z		 3012 fd0 = fileno(stdio);
3013 if(fd0 != -1){
3014 PerlIOUnix_refcnt_inc(fd0);
3015 setfd_cloexec_or_inhexec_by_sysfdness(fd0);
3016 }
ea5bc90f 3017#ifdef EBCDIC
ea5bc90f
YK		 3018 else{
3019 rc = fldata(stdio,filename,&fileinfo);
3020 if(rc != 0){
3021 PerlIOUnix_refcnt_inc(fd0);
3022 }
3023 if(fileinfo.__dsorgHFS){
3024 PerlIOUnix_refcnt_inc(fd0);
3025 }
3026 /*This MVS dataset , OK!*/
3027 }
ea5bc90f 3028#endif
a33cf58c 3029 }
14a5cf38
JH		 3030 }
3031 return f;
9e353e3b
NIS		 3032}
3033
3034PerlIO *
14a5cf38
JH		 3035PerlIOStdio_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
3036 IV n, const char *mode, int fd, int imode,
3037 int perm, PerlIO *f, int narg, SV **args)
3038{
3039 char tmode[8];
d9dac8cd 3040 if (PerlIOValid(f)) {
41188aa0
TC		 3041 STRLEN len;
3042 const char * const path = SvPV_const(*args, len);
dcda55fc 3043 PerlIOStdio * const s = PerlIOSelf(f, PerlIOStdio);
1751d015 3044 FILE *stdio;
41188aa0 3045 if (!IS_SAFE_PATHNAME(path, len, "open"))
c8028aa6 3046 return NULL;
1751d015 3047 PerlIOUnix_refcnt_dec(fileno(s->stdio));
de092133
JH		 3048 stdio = PerlSIO_freopen(path, PerlIOStdio_mode(mode, tmode),
3049 s->stdio);
14a5cf38
JH		 3050 if (!s->stdio)
3051 return NULL;
3052 s->stdio = stdio;
884fc2d3
Z		 3053 fd = fileno(stdio);
3054 PerlIOUnix_refcnt_inc(fd);
3055 setfd_cloexec_or_inhexec_by_sysfdness(fd);
14a5cf38
JH		 3056 return f;
3057 }
3058 else {
3059 if (narg > 0) {
41188aa0
TC		 3060 STRLEN len;
3061 const char * const path = SvPV_const(*args, len);
3062 if (!IS_SAFE_PATHNAME(path, len, "open"))
c8028aa6 3063 return NULL;
3b6c1aba 3064 if (*mode == IoTYPE_NUMERIC) {
14a5cf38 3065 mode++;
884fc2d3 3066 fd = PerlLIO_open3_cloexec(path, imode, perm);
14a5cf38
JH		 3067 }
3068 else {
95005ad8
GH		 3069 FILE *stdio;
3070 bool appended = FALSE;
3071#ifdef __CYGWIN__
3072 /* Cygwin wants its 'b' early. */
3073 appended = TRUE;
3074 mode = PerlIOStdio_mode(mode, tmode);
3075#endif
3076 stdio = PerlSIO_fopen(path, mode);
6f0313ac 3077 if (stdio) {
6f0313ac
JH		 3078 if (!f) {
3079 f = PerlIO_allocate(aTHX);
3080 }
95005ad8
GH		 3081 if (!appended)
3082 mode = PerlIOStdio_mode(mode, tmode);
3083 f = PerlIO_push(aTHX_ f, self, mode, PerlIOArg);
3084 if (f) {
0f0f9e2b 3085 PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
884fc2d3
Z		 3086 fd = fileno(stdio);
3087 PerlIOUnix_refcnt_inc(fd);
3088 setfd_cloexec_or_inhexec_by_sysfdness(fd);
0f0f9e2b
JH		 3089 } else {
3090 PerlSIO_fclose(stdio);
6f0313ac
JH		 3091 }
3092 return f;
3093 }
3094 else {
3095 return NULL;
3096 }
14a5cf38
JH		 3097 }
3098 }
3099 if (fd >= 0) {
3100 FILE *stdio = NULL;
3101 int init = 0;
3b6c1aba 3102 if (*mode == IoTYPE_IMPLICIT) {
14a5cf38
JH		 3103 init = 1;
3104 mode++;
3105 }
3106 if (init) {
3107 switch (fd) {
3108 case 0:
3109 stdio = PerlSIO_stdin;
3110 break;
3111 case 1:
3112 stdio = PerlSIO_stdout;
3113 break;
3114 case 2:
3115 stdio = PerlSIO_stderr;
3116 break;
3117 }
3118 }
3119 else {
3120 stdio = PerlSIO_fdopen(fd, mode =
3121 PerlIOStdio_mode(mode, tmode));
3122 }
3123 if (stdio) {
d9dac8cd
NIS		 3124 if (!f) {
3125 f = PerlIO_allocate(aTHX);
3126 }
a33cf58c 3127 if ((f = PerlIO_push(aTHX_ f, self, mode, PerlIOArg))) {
1a159fba 3128 PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
884fc2d3
Z		 3129 fd = fileno(stdio);
3130 PerlIOUnix_refcnt_inc(fd);
3131 setfd_cloexec_or_inhexec_by_sysfdness(fd);
a33cf58c 3132 }
14a5cf38
JH		 3133 return f;
3134 }
0a20f69b 3135 PerlLIO_close(fd);
14a5cf38
JH		 3136 }
3137 }
ee518936 3138 return NULL;
9e353e3b
NIS		 3139}
3140
1751d015 3141PerlIO *
ecdeb87c 3142PerlIOStdio_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
1751d015
NIS		 3143{
3144 /* This assumes no layers underneath - which is what
3145 happens, but is not how I remember it. NI-S 2001/10/16
3146 */
ecdeb87c 3147 if ((f = PerlIOBase_dup(aTHX_ f, o, param, flags))) {
694c95cf 3148 FILE *stdio = PerlIOSelf(o, PerlIOStdio)->stdio;
de009b76 3149 const int fd = fileno(stdio);
9217ff3f 3150 char mode[8];
ecdeb87c 3151 if (flags & PERLIO_DUP_FD) {
884fc2d3 3152 const int dfd = PerlLIO_dup_cloexec(fileno(stdio));
9217ff3f
NIS		 3153 if (dfd >= 0) {
3154 stdio = PerlSIO_fdopen(dfd, PerlIO_modestr(o,mode));
3155 goto set_this;
ecdeb87c
NIS		 3156 }
3157 else {
6f207bd3 3158 NOOP;
ecdeb87c
NIS		 3159 /* FIXME: To avoid messy error recovery if dup fails
3160 re-use the existing stdio as though flag was not set
3161 */
3162 }
3163 }
9217ff3f
NIS		 3164 stdio = PerlSIO_fdopen(fd, PerlIO_modestr(o,mode));
3165 set_this:
694c95cf 3166 PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
40596bc5 3167 if(stdio) {
884fc2d3
Z		 3168 int fd = fileno(stdio);
3169 PerlIOUnix_refcnt_inc(fd);
3170 setfd_cloexec_or_inhexec_by_sysfdness(fd);
40596bc5 3171 }
1751d015
NIS		 3172 }
3173 return f;
3174}
3175
0d7a5398
NIS		 3176static int
3177PerlIOStdio_invalidate_fileno(pTHX_ FILE *f)
3178{
96a5add6
AL		 3179 PERL_UNUSED_CONTEXT;
3180
0d7a5398 3181 /* XXX this could use PerlIO_canset_fileno() and
37725cdc 3182 * PerlIO_set_fileno() support from Configure
0d7a5398 3183 */
36b1c892
AD		 3184# if defined(HAS_FDCLOSE)
3185 return fdclose(f, NULL) == 0 ? 1 : 0;
3186# elif defined(__UCLIBC__)
ef8eacb8
AT		 3187 /* uClibc must come before glibc because it defines __GLIBC__ as well. */
3188 f->__filedes = -1;
3189 return 1;
3190# elif defined(__GLIBC__)
0d7a5398 3191 /* There may be a better way for GLIBC:
37725cdc 3192 - libio.h defines a flag to not close() on cleanup
0d7a5398
NIS		 3193 */
3194 f->_fileno = -1;
3195 return 1;
bdea967c 3196# elif defined(__sun)
f5992bc4 3197 PERL_UNUSED_ARG(f);
cfedb851 3198 return 0;
0d7a5398
NIS		 3199# elif defined(__hpux)
3200 f->__fileH = 0xff;
3201 f->__fileL = 0xff;
3202 return 1;
9837d373 3203 /* Next one ->_file seems to be a reasonable fallback, i.e. if
37725cdc 3204 your platform does not have special entry try this one.
9837d373
NIS		 3205 [For OSF only have confirmation for Tru64 (alpha)
3206 but assume other OSFs will be similar.]
37725cdc 3207 */
9837d373 3208# elif defined(_AIX) || defined(__osf__) || defined(__irix__)
0d7a5398
NIS		 3209 f->_file = -1;
3210 return 1;
3211# elif defined(__FreeBSD__)
3212 /* There may be a better way on FreeBSD:
37725cdc
NIS		 3213 - we could insert a dummy func in the _close function entry
3214 f->_close = (int (*)(void *)) dummy_close;
0d7a5398
NIS		 3215 */
3216 f->_file = -1;
0c49ea6a
SU		 3217 return 1;
3218# elif defined(__OpenBSD__)
3219 /* There may be a better way on OpenBSD:
3220 - we could insert a dummy func in the _close function entry
3221 f->_close = (int (*)(void *)) dummy_close;
3222 */
3223 f->_file = -1;
0d7a5398 3224 return 1;
59ad941d
IZ		 3225# elif defined(__EMX__)
3226 /* f->_flags &= ~_IOOPEN; */ /* Will leak stream->_buffer */
3227 f->_handle = -1;
3228 return 1;
0d7a5398
NIS		 3229# elif defined(__CYGWIN__)
3230 /* There may be a better way on CYGWIN:
37725cdc
NIS		 3231 - we could insert a dummy func in the _close function entry
3232 f->_close = (int (*)(void *)) dummy_close;
0d7a5398
NIS		 3233 */
3234 f->_file = -1;
3235 return 1;
3236# elif defined(WIN32)
1f664ef5 3237 PERLIO_FILE_file(f) = -1;
0d7a5398
NIS		 3238 return 1;
3239# else
3240#if 0
37725cdc 3241 /* Sarathy's code did this - we fall back to a dup/dup2 hack
0d7a5398 3242 (which isn't thread safe) instead
37725cdc 3243 */
0d7a5398
NIS		 3244# error "Don't know how to set FILE.fileno on your platform"
3245#endif
8772537c 3246 PERL_UNUSED_ARG(f);
0d7a5398
NIS		 3247 return 0;
3248# endif
3249}
3250
1751d015 3251IV
f62ce20a 3252PerlIOStdio_close(pTHX_ PerlIO *f)
1751d015 3253{
c4420975 3254 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
439ba545
NIS		 3255 if (!stdio) {
3256 errno = EBADF;
3257 return -1;
3258 }
9217ff3f 3259 else {
de009b76 3260 const int fd = fileno(stdio);
0d7a5398 3261 int invalidate = 0;
bbfd922f 3262 IV result = 0;
1d791a44 3263 int dupfd = -1;
4ee39169 3264 dSAVEDERRNO;
a2e578da
MHM		 3265#ifdef USE_ITHREADS
3266 dVAR;
3267#endif
0d7a5398 3268#ifdef SOCKS5_VERSION_NAME
37725cdc
NIS		 3269 /* Socks lib overrides close() but stdio isn't linked to
3270 that library (though we are) - so we must call close()
3271 on sockets on stdio's behalf.
3272 */
0d7a5398
NIS		 3273 int optval;
3274 Sock_size_t optlen = sizeof(int);
6b4ce6c8 3275 if (getsockopt(fd, SOL_SOCKET, SO_TYPE, (void *) &optval, &optlen) == 0)
37725cdc 3276 invalidate = 1;
0d7a5398 3277#endif
d8723f43
NC		 3278 /* Test for -1, as *BSD stdio (at least) on fclose sets the FILE* such
3279 that a subsequent fileno() on it returns -1. Don't want to croak()
3280 from within PerlIOUnix_refcnt_dec() if some buggy caller code is
3281 trying to close an already closed handle which somehow it still has
3282 a reference to. (via.xs, I'm looking at you). */
3283 if (fd != -1 && PerlIOUnix_refcnt_dec(fd) > 0) {
3284 /* File descriptor still in use */
0d7a5398 3285 invalidate = 1;
d8723f43 3286 }
0d7a5398 3287 if (invalidate) {
6b4ce6c8
AL		 3288 /* For STD* handles, don't close stdio, since we shared the FILE *, too. */
3289 if (stdio == stdin) /* Some stdios are buggy fflush-ing inputs */
3290 return 0;
3291 if (stdio == stdout || stdio == stderr)
3292 return PerlIO_flush(f);
d88f7f65 3293 }
d88f7f65
JH		 3294 MUTEX_LOCK(&PL_perlio_mutex);
3295 /* Right. We need a mutex here because for a brief while we
3296 will have the situation that fd is actually closed. Hence if
3297 a second thread were to get into this block, its dup() would
3298 likely return our fd as its dupfd. (after all, it is closed)
3299 Then if we get to the dup2() first, we blat the fd back
3300 (messing up its temporary as a side effect) only for it to
3301 then close its dupfd (== our fd) in its close(dupfd) */
3302
3303 /* There is, of course, a race condition, that any other thread
3304 trying to input/output/whatever on this fd will be stuffed
3305 for the duration of this little manoeuvrer. Perhaps we
3306 should hold an IO mutex for the duration of every IO
3307 operation if we know that invalidate doesn't work on this
3308 platform, but that would suck, and could kill performance.
3309
3310 Except that correctness trumps speed.
3311 Advice from klortho #11912. */
d88f7f65 3312 if (invalidate) {
37725cdc
NIS		 3313 /* Tricky - must fclose(stdio) to free memory but not close(fd)
3314 Use Sarathy's trick from maint-5.6 to invalidate the
3315 fileno slot of the FILE *
3316 */
bbfd922f 3317 result = PerlIO_flush(f);
4ee39169 3318 SAVE_ERRNO;
6b4ce6c8 3319 invalidate = PerlIOStdio_invalidate_fileno(aTHX_ stdio);
711e8db2 3320 if (!invalidate) {
884fc2d3 3321 dupfd = PerlLIO_dup_cloexec(fd);
711e8db2 3322#ifdef USE_ITHREADS
9bab90c0 3323 if (dupfd < 0) {
711e8db2
NC		 3324 /* Oh cXap. This isn't going to go well. Not sure if we can
3325 recover from here, or if closing this particular FILE *
3326 is a good idea now. */
3327 }
3328#endif
3329 }
94ccb807
JH		 3330 } else {
3331 SAVE_ERRNO; /* This is here only to silence compiler warnings */
37725cdc 3332 }
0d7a5398 3333 result = PerlSIO_fclose(stdio);
37725cdc
NIS		 3334 /* We treat error from stdio as success if we invalidated
3335 errno may NOT be expected EBADF
e8529473
NIS		 3336 */
3337 if (invalidate && result != 0) {
4ee39169 3338 RESTORE_ERRNO;
0d7a5398 3339 result = 0;
37725cdc 3340 }
6b4ce6c8
AL		 3341#ifdef SOCKS5_VERSION_NAME
3342 /* in SOCKS' case, let close() determine return value */
3343 result = close(fd);
3344#endif
1d791a44 3345 if (dupfd >= 0) {
884fc2d3
Z		 3346 PerlLIO_dup2_cloexec(dupfd, fd);
3347 setfd_inhexec_for_sysfd(fd);
9bab90c0 3348 PerlLIO_close(dupfd);
d88f7f65 3349 }
d88f7f65 3350 MUTEX_UNLOCK(&PL_perlio_mutex);
9217ff3f 3351 return result;
37725cdc 3352 }
1751d015
NIS		 3353}
3354
9e353e3b 3355SSize_t
f62ce20a 3356PerlIOStdio_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
9e353e3b 3357{
abf9167d 3358 FILE * s;
14a5cf38 3359 SSize_t got = 0;
abf9167d
DM		 3360 if (PerlIO_lockcnt(f)) /* in use: abort ungracefully */
3361 return -1;
3362 s = PerlIOSelf(f, PerlIOStdio)->stdio;
4d948241
NIS		 3363 for (;;) {
3364 if (count == 1) {
3365 STDCHAR *buf = (STDCHAR *) vbuf;
3366 /*
3367 * Perl is expecting PerlIO_getc() to fill the buffer Linux's
3368 * stdio does not do that for fread()
3369 */
de009b76 3370 const int ch = PerlSIO_fgetc(s);
4d948241
NIS		 3371 if (ch != EOF) {
3372 *buf = ch;
3373 got = 1;
3374 }
14a5cf38 3375 }
4d948241
NIS		 3376 else
3377 got = PerlSIO_fread(vbuf, 1, count, s);
b1d8b47a
CS		 3378 if (got == 0 && PerlSIO_ferror(s))
3379 got = -1;
42a7a32f 3380 if (got >= 0 || errno != EINTR)
4d948241 3381 break;
abf9167d
DM		 3382 if (PL_sig_pending && S_perlio_async_run(aTHX_ f))
3383 return -1;
42a7a32f 3384 SETERRNO(0,0); /* just in case */
14a5cf38 3385 }
bdae4172
JH		 3386#ifdef __sgi
3387 /* Under some circumstances IRIX stdio fgetc() and fread()
3388 * set the errno to ENOENT, which makes no sense according
3389 * to either IRIX or POSIX. [rt.perl.org #123977] */
3390 if (errno == ENOENT) SETERRNO(0,0);
3391#endif
14a5cf38 3392 return got;
9e353e3b
NIS		 3393}
3394
3395SSize_t
f62ce20a 3396PerlIOStdio_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
9e353e3b 3397{
14a5cf38 3398 SSize_t unread = 0;
c4420975 3399 FILE * const s = PerlIOSelf(f, PerlIOStdio)->stdio;
93679785 3400
313e59c8 3401#ifdef STDIO_BUFFER_WRITABLE
9f7cd136 3402 if (PerlIO_fast_gets(f) && PerlIO_has_base(f)) {
93679785
NIS		 3403 STDCHAR *buf = ((STDCHAR *) vbuf) + count;
3404 STDCHAR *base = PerlIO_get_base(f);
3405 SSize_t cnt = PerlIO_get_cnt(f);
3406 STDCHAR *ptr = PerlIO_get_ptr(f);
3407 SSize_t avail = ptr - base;
3408 if (avail > 0) {
3409 if (avail > count) {
3410 avail = count;
3411 }
3412 ptr -= avail;
3413 Move(buf-avail,ptr,avail,STDCHAR);
3414 count -= avail;
3415 unread += avail;
3416 PerlIO_set_ptrcnt(f,ptr,cnt+avail);
9f7cd136
NIS		 3417 if (PerlSIO_feof(s) && unread >= 0)
3418 PerlSIO_clearerr(s);
3419 }
3420 }
313e59c8
NIS		 3421 else
3422#endif
3423 if (PerlIO_has_cntptr(f)) {
9f7cd136
NIS		 3424 /* We can get pointer to buffer but not its base
3425 Do ungetc() but check chars are ending up in the
3426 buffer
3427 */
3428 STDCHAR *eptr = (STDCHAR*)PerlSIO_get_ptr(s);
3429 STDCHAR *buf = ((STDCHAR *) vbuf) + count;
3430 while (count > 0) {
de009b76 3431 const int ch = *--buf & 0xFF;
9f7cd136
NIS		 3432 if (ungetc(ch,s) != ch) {
3433 /* ungetc did not work */
3434 break;
3435 }
3436 if ((STDCHAR*)PerlSIO_get_ptr(s) != --eptr || ((*eptr & 0xFF) != ch)) {
3437 /* Did not change pointer as expected */
375ed12a
JH		 3438 if (fgetc(s) != EOF) /* get char back again */
3439 break;
9f7cd136
NIS		 3440 }
3441 /* It worked ! */
3442 count--;
3443 unread++;
93679785
NIS		 3444 }
3445 }
3446
3447 if (count > 0) {
3448 unread += PerlIOBase_unread(aTHX_ f, vbuf, count);
14a5cf38
JH		 3449 }
3450 return unread;
9e353e3b
NIS		 3451}
3452
3453SSize_t
f62ce20a 3454PerlIOStdio_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
9e353e3b 3455{
4d948241 3456 SSize_t got;
abf9167d
DM		 3457 if (PerlIO_lockcnt(f)) /* in use: abort ungracefully */
3458 return -1;
4d948241
NIS		 3459 for (;;) {
3460 got = PerlSIO_fwrite(vbuf, 1, count,
3461 PerlIOSelf(f, PerlIOStdio)->stdio);
42a7a32f 3462 if (got >= 0 || errno != EINTR)
4d948241 3463 break;
abf9167d
DM		 3464 if (PL_sig_pending && S_perlio_async_run(aTHX_ f))
3465 return -1;
42a7a32f 3466 SETERRNO(0,0); /* just in case */
4d948241
NIS		 3467 }
3468 return got;
9e353e3b
NIS		 3469}
3470
94a175e1 3471IV
f62ce20a 3472PerlIOStdio_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
9e353e3b 3473{
c4420975 3474 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
96a5add6
AL		 3475 PERL_UNUSED_CONTEXT;
3476
94a175e1 3477 return PerlSIO_fseek(stdio, offset, whence);
9e353e3b
NIS		 3478}
3479
3480Off_t
f62ce20a 3481PerlIOStdio_tell(pTHX_ PerlIO *f)
9e353e3b 3482{
c4420975 3483 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
96a5add6
AL		 3484 PERL_UNUSED_CONTEXT;
3485
94a175e1 3486 return PerlSIO_ftell(stdio);
9e353e3b
NIS		 3487}
3488
3489IV
f62ce20a 3490PerlIOStdio_flush(pTHX_ PerlIO *f)
9e353e3b 3491{
c4420975 3492 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
96a5add6
AL		 3493 PERL_UNUSED_CONTEXT;
3494
14a5cf38
JH		 3495 if (PerlIOBase(f)->flags & PERLIO_F_CANWRITE) {
3496 return PerlSIO_fflush(stdio);
3497 }
3498 else {
6f207bd3 3499 NOOP;
88b61e10 3500#if 0
14a5cf38
JH		 3501 /*
3502 * FIXME: This discards ungetc() and pre-read stuff which is not
71200d45 3503 * right if this is just a "sync" from a layer above Suspect right
14a5cf38 3504 * design is to do _this_ but not have layer above flush this
71200d45 3505 * layer read-to-read
14a5cf38
JH		 3506 */
3507 /*
71200d45 3508 * Not writeable - sync by attempting a seek
14a5cf38 3509 */
4ee39169 3510 dSAVE_ERRNO;
14a5cf38 3511 if (PerlSIO_fseek(stdio, (Off_t) 0, SEEK_CUR) != 0)
4ee39169 3512 RESTORE_ERRNO;
88b61e10 3513#endif
14a5cf38
JH		 3514 }
3515 return 0;
9e353e3b
NIS		 3516}
3517
3518IV
f62ce20a 3519PerlIOStdio_eof(pTHX_ PerlIO *f)
9e353e3b 3520{
96a5add6
AL		 3521 PERL_UNUSED_CONTEXT;
3522
14a5cf38 3523 return PerlSIO_feof(PerlIOSelf(f, PerlIOStdio)->stdio);
9e353e3b
NIS		 3524}
3525
3526IV
f62ce20a 3527PerlIOStdio_error(pTHX_ PerlIO *f)
9e353e3b 3528{
96a5add6
AL		 3529 PERL_UNUSED_CONTEXT;
3530
263df5f1 3531 return PerlSIO_ferror(PerlIOSelf(f, PerlIOStdio)->stdio);
9e353e3b
NIS		 3532}
3533
3534void
f62ce20a 3535PerlIOStdio_clearerr(pTHX_ PerlIO *f)
9e353e3b 3536{
96a5add6
AL		 3537 PERL_UNUSED_CONTEXT;
3538
14a5cf38 3539 PerlSIO_clearerr(PerlIOSelf(f, PerlIOStdio)->stdio);
9e353e3b
NIS		 3540}
3541
3542void
f62ce20a 3543PerlIOStdio_setlinebuf(pTHX_ PerlIO *f)
9e353e3b 3544{
96a5add6
AL		 3545 PERL_UNUSED_CONTEXT;
3546
9e353e3b 3547#ifdef HAS_SETLINEBUF
14a5cf38 3548 PerlSIO_setlinebuf(PerlIOSelf(f, PerlIOStdio)->stdio);
9e353e3b 3549#else
bd61b366 3550 PerlSIO_setvbuf(PerlIOSelf(f, PerlIOStdio)->stdio, NULL, _IOLBF, 0);
9e353e3b
NIS		 3551#endif
3552}
3553
3554#ifdef FILE_base
3555STDCHAR *
f62ce20a 3556PerlIOStdio_get_base(pTHX_ PerlIO *f)
9e353e3b 3557{
c4420975 3558 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
e9b8343f 3559 PERL_UNUSED_CONTEXT;
cc00df79 3560 return (STDCHAR*)PerlSIO_get_base(stdio);
9e353e3b
NIS		 3561}
3562
3563Size_t
f62ce20a 3564PerlIOStdio_get_bufsiz(pTHX_ PerlIO *f)
9e353e3b 3565{
c4420975 3566 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
e9b8343f 3567 PERL_UNUSED_CONTEXT;
14a5cf38 3568 return PerlSIO_get_bufsiz(stdio);
9e353e3b
NIS		 3569}
3570#endif
3571
3572#ifdef USE_STDIO_PTR
3573STDCHAR *
f62ce20a 3574PerlIOStdio_get_ptr(pTHX_ PerlIO *f)
9e353e3b 3575{
c4420975 3576 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
e9b8343f 3577 PERL_UNUSED_CONTEXT;
cc00df79 3578 return (STDCHAR*)PerlSIO_get_ptr(stdio);
9e353e3b
NIS		 3579}
3580
3581SSize_t
f62ce20a 3582PerlIOStdio_get_cnt(pTHX_ PerlIO *f)
9e353e3b 3583{
c4420975 3584 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
e9b8343f 3585 PERL_UNUSED_CONTEXT;
14a5cf38 3586 return PerlSIO_get_cnt(stdio);
9e353e3b
NIS		 3587}
3588
3589void
f62ce20a 3590PerlIOStdio_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
9e353e3b 3591{
c4420975 3592 FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
e9b8343f 3593 PERL_UNUSED_CONTEXT;
14a5cf38 3594 if (ptr != NULL) {
9e353e3b 3595#ifdef STDIO_PTR_LVALUE
46f05249
JH		 3596 /* This is a long-standing infamous mess. The root of the
3597 * problem is that one cannot know the signedness of char, and
3598 * more precisely the signedness of FILE._ptr. The following
3599 * things have been tried, and they have all failed (across
3600 * different compilers (remember that core needs to to build
3601 * also with c++) and compiler options:
3602 *
3603 * - casting the RHS to (void*) -- works in *some* places
3604 * - casting the LHS to (void*) -- totally unportable
3605 *
3606 * So let's try silencing the warning at least for gcc. */
7347ee54 3607 GCC_DIAG_IGNORE_STMT(-Wpointer-sign);
d06fc7d4 3608 PerlSIO_set_ptr(stdio, ptr); /* LHS STDCHAR* cast non-portable */
7347ee54 3609 GCC_DIAG_RESTORE_STMT;
9e353e3b 3610#ifdef STDIO_PTR_LVAL_SETS_CNT
f8a4dbc5 3611 assert(PerlSIO_get_cnt(stdio) == (cnt));
9e353e3b
NIS		 3612#endif
3613#if (!defined(STDIO_PTR_LVAL_NOCHANGE_CNT))
14a5cf38 3614 /*
71200d45 3615 * Setting ptr _does_ change cnt - we are done
14a5cf38
JH		 3616 */
3617 return;
9e353e3b 3618#endif
22569500 3619#else /* STDIO_PTR_LVALUE */
14a5cf38 3620 PerlProc_abort();
22569500 3621#endif /* STDIO_PTR_LVALUE */
14a5cf38
JH		 3622 }
3623 /*
71200d45 3624 * Now (or only) set cnt
14a5cf38 3625 */
9e353e3b 3626#ifdef STDIO_CNT_LVALUE
14a5cf38 3627 PerlSIO_set_cnt(stdio, cnt);
faf55891 3628#elif (defined(STDIO_PTR_LVALUE) && defined(STDIO_PTR_LVAL_SETS_CNT))
14a5cf38
JH		 3629 PerlSIO_set_ptr(stdio,
3630 PerlSIO_get_ptr(stdio) + (PerlSIO_get_cnt(stdio) -
3631 cnt));
22569500 3632#else /* STDIO_PTR_LVAL_SETS_CNT */
14a5cf38 3633 PerlProc_abort();
22569500 3634#endif /* STDIO_CNT_LVALUE */
9e353e3b
NIS		 3635}
3636
93679785 3637
9e353e3b
NIS		 3638#endif
3639
93679785
NIS		 3640IV
3641PerlIOStdio_fill(pTHX_ PerlIO *f)
3642{
abf9167d 3643 FILE * stdio;
93679785 3644 int c;
96a5add6 3645 PERL_UNUSED_CONTEXT;
abf9167d
DM		 3646 if (PerlIO_lockcnt(f)) /* in use: abort ungracefully */
3647 return -1;
3648 stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
96a5add6 3649
93679785
NIS		 3650 /*
3651 * fflush()ing read-only streams can cause trouble on some stdio-s
3652 */
3653 if ((PerlIOBase(f)->flags & PERLIO_F_CANWRITE)) {
3654 if (PerlSIO_fflush(stdio) != 0)
3655 return EOF;
3656 }
f3be3723
BL		 3657 for (;;) {
3658 c = PerlSIO_fgetc(stdio);
3659 if (c != EOF)
3660 break;
3661 if (! PerlSIO_ferror(stdio) || errno != EINTR)
3662 return EOF;
abf9167d
DM		 3663 if (PL_sig_pending && S_perlio_async_run(aTHX_ f))
3664 return -1;
f3be3723
BL		 3665 SETERRNO(0,0);
3666 }
93679785
NIS		 3667
3668#if (defined(STDIO_PTR_LVALUE) && (defined(STDIO_CNT_LVALUE) || defined(STDIO_PTR_LVAL_SETS_CNT)))
313e59c8
NIS		 3669
3670#ifdef STDIO_BUFFER_WRITABLE
9f7cd136 3671 if (PerlIO_fast_gets(f) && PerlIO_has_base(f)) {
93679785
NIS		 3672 /* Fake ungetc() to the real buffer in case system's ungetc
3673 goes elsewhere
3674 */
3675 STDCHAR *base = (STDCHAR*)PerlSIO_get_base(stdio);
3676 SSize_t cnt = PerlSIO_get_cnt(stdio);
3677 STDCHAR *ptr = (STDCHAR*)PerlSIO_get_ptr(stdio);
3678 if (ptr == base+1) {
3679 *--ptr = (STDCHAR) c;
3680 PerlIOStdio_set_ptrcnt(aTHX_ f,ptr,cnt+1);
3681 if (PerlSIO_feof(stdio))
3682 PerlSIO_clearerr(stdio);
3683 return 0;
3684 }
3685 }
313e59c8
NIS		 3686 else
3687#endif
3688 if (PerlIO_has_cntptr(f)) {
9f7cd136
NIS		 3689 STDCHAR ch = c;
3690 if (PerlIOStdio_unread(aTHX_ f,&ch,1) == 1) {
3691 return 0;
3692 }
3693 }
93679785
NIS		 3694#endif
3695
93679785 3696 /* If buffer snoop scheme above fails fall back to
9f7cd136 3697 using ungetc().
93679785
NIS		 3698 */
3699 if (PerlSIO_ungetc(c, stdio) != c)
3700 return EOF;
5876737a 3701
93679785
NIS		 3702 return 0;
3703}
3704
3705
3706
27da23d5 3707PERLIO_FUNCS_DECL(PerlIO_stdio) = {
2dc2558e 3708 sizeof(PerlIO_funcs),
14a5cf38
JH		 3709 "stdio",
3710 sizeof(PerlIOStdio),
86e05cf2 3711 PERLIO_K_BUFFERED|PERLIO_K_RAW,
1fd8f4ce 3712 PerlIOStdio_pushed,
2376d97d 3713 PerlIOBase_popped,
14a5cf38 3714 PerlIOStdio_open,
86e05cf2 3715 PerlIOBase_binmode, /* binmode */
14a5cf38
JH		 3716 NULL,
3717 PerlIOStdio_fileno,
71200d45 3718 PerlIOStdio_dup,
14a5cf38
JH		 3719 PerlIOStdio_read,
3720 PerlIOStdio_unread,
3721 PerlIOStdio_write,
3722 PerlIOStdio_seek,
3723 PerlIOStdio_tell,
3724 PerlIOStdio_close,
3725 PerlIOStdio_flush,
3726 PerlIOStdio_fill,
3727 PerlIOStdio_eof,
3728 PerlIOStdio_error,
3729 PerlIOStdio_clearerr,
3730 PerlIOStdio_setlinebuf,
9e353e3b 3731#ifdef FILE_base
14a5cf38
JH		 3732 PerlIOStdio_get_base,
3733 PerlIOStdio_get_bufsiz,
9e353e3b 3734#else
14a5cf38
JH		 3735 NULL,
3736 NULL,
9e353e3b
NIS		 3737#endif
3738#ifdef USE_STDIO_PTR
14a5cf38
JH		 3739 PerlIOStdio_get_ptr,
3740 PerlIOStdio_get_cnt,
15b61c98 3741# if defined(HAS_FAST_STDIO) && defined(USE_FAST_STDIO)
79ed0f43 3742 PerlIOStdio_set_ptrcnt,
15b61c98
JH		 3743# else
3744 NULL,
3745# endif /* HAS_FAST_STDIO && USE_FAST_STDIO */
3746#else
3747 NULL,
14a5cf38
JH		 3748 NULL,
3749 NULL,
15b61c98 3750#endif /* USE_STDIO_PTR */
9e353e3b
NIS		 3751};
3752
b9d6bf13
JH		 3753/* Note that calls to PerlIO_exportFILE() are reversed using
3754 * PerlIO_releaseFILE(), not importFILE. */
9e353e3b 3755FILE *
81428673 3756PerlIO_exportFILE(PerlIO * f, const char *mode)
9e353e3b 3757{
e87a358a 3758 dTHX;
81428673
NIS		 3759 FILE *stdio = NULL;
3760 if (PerlIOValid(f)) {
3761 char buf[8];
375ed12a
JH		 3762 int fd = PerlIO_fileno(f);
3763 if (fd < 0) {
3764 return NULL;
3765 }
81428673
NIS		 3766 PerlIO_flush(f);
3767 if (!mode || !*mode) {
3768 mode = PerlIO_modestr(f, buf);
3769 }
3770 stdio = PerlSIO_fdopen(PerlIO_fileno(f), mode);
3771 if (stdio) {
3772 PerlIOl *l = *f;
9f75cc58 3773 PerlIO *f2;
81428673
NIS		 3774 /* De-link any lower layers so new :stdio sticks */
3775 *f = NULL;
a0714e2c 3776 if ((f2 = PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_stdio), buf, NULL))) {
9f75cc58 3777 PerlIOStdio *s = PerlIOSelf((f = f2), PerlIOStdio);
81428673 3778 s->stdio = stdio;
6b54a403 3779 PerlIOUnix_refcnt_inc(fileno(stdio));
81428673
NIS		 3780 /* Link previous lower layers under new one */
3781 *PerlIONext(f) = l;
3782 }
3783 else {
3784 /* restore layers list */
3785 *f = l;
3786 }
a33cf58c 3787 }
14a5cf38
JH		 3788 }
3789 return stdio;
9e353e3b
NIS		 3790}
3791
81428673 3792
9e353e3b
NIS		 3793FILE *
3794PerlIO_findFILE(PerlIO *f)
3795{
14a5cf38 3796 PerlIOl *l = *f;
bbbc33d0 3797 FILE *stdio;
14a5cf38
JH		 3798 while (l) {
3799 if (l->tab == &PerlIO_stdio) {
3800 PerlIOStdio *s = PerlIOSelf(&l, PerlIOStdio);
3801 return s->stdio;
3802 }
3803 l = *PerlIONext(&l);
f7e7eb72 3804 }
4b069b44 3805 /* Uses fallback "mode" via PerlIO_modestr() in PerlIO_exportFILE */
bbbc33d0
NC		 3806 /* However, we're not really exporting a FILE * to someone else (who
3807 becomes responsible for closing it, or calling PerlIO_releaseFILE())
486ec47a 3808 So we need to undo its reference count increase on the underlying file
bbbc33d0
NC		 3809 descriptor. We have to do this, because if the loop above returns you
3810 the FILE *, then *it* didn't increase any reference count. So there's
3811 only one way to be consistent. */
3812 stdio = PerlIO_exportFILE(f, NULL);
3813 if (stdio) {
3814 const int fd = fileno(stdio);
3815 if (fd >= 0)
3816 PerlIOUnix_refcnt_dec(fd);
3817 }
3818 return stdio;
9e353e3b
NIS		 3819}
3820
b9d6bf13 3821/* Use this to reverse PerlIO_exportFILE calls. */
9e353e3b
NIS		 3822void
3823PerlIO_releaseFILE(PerlIO *p, FILE *f)
3824{
22569500
NIS		 3825 PerlIOl *l;
3826 while ((l = *p)) {
3827 if (l->tab == &PerlIO_stdio) {
3828 PerlIOStdio *s = PerlIOSelf(&l, PerlIOStdio);
2bcd6579 3829 if (s->stdio == f) { /* not in a loop */
6b54a403
NC		 3830 const int fd = fileno(f);
3831 if (fd >= 0)
3832 PerlIOUnix_refcnt_dec(fd);
2bcd6579
DD		 3833 {
3834 dTHX;
3835 PerlIO_pop(aTHX_ p);
3836 }
22569500
NIS		 3837 return;
3838 }
3839 }
3840 p = PerlIONext(p);
3841 }
3842 return;
9e353e3b
NIS		 3843}
3844
3845/*--------------------------------------------------------------------------------------*/
14a5cf38 3846/*
71200d45 3847 * perlio buffer layer
14a5cf38 3848 */
9e353e3b 3849
5e2ab84b 3850IV
2dc2558e 3851PerlIOBuf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
5e2ab84b 3852{
14a5cf38 3853 PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
de009b76 3854 const int fd = PerlIO_fileno(f);
14a5cf38
JH		 3855 if (fd >= 0 && PerlLIO_isatty(fd)) {
3856 PerlIOBase(f)->flags |= PERLIO_F_LINEBUF | PERLIO_F_TTY;
3857 }
4b069b44 3858 if (*PerlIONext(f)) {
de009b76 3859 const Off_t posn = PerlIO_tell(PerlIONext(f));
4b069b44
NIS		 3860 if (posn != (Off_t) - 1) {
3861 b->posn = posn;
3862 }
14a5cf38 3863 }
2dc2558e 3864 return PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
5e2ab84b
NIS		 3865}
3866
9e353e3b 3867PerlIO *
14a5cf38
JH		 3868PerlIOBuf_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
3869 IV n, const char *mode, int fd, int imode, int perm,
3870 PerlIO *f, int narg, SV **args)
3871{
04892f78 3872 if (PerlIOValid(f)) {
14a5cf38 3873 PerlIO *next = PerlIONext(f);
67363c0d
JH		 3874 PerlIO_funcs *tab =
3875 PerlIO_layer_fetch(aTHX_ layers, n - 1, PerlIOBase(next)->tab);
3876 if (tab && tab->Open)
3877 next =
3878 (*tab->Open)(aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
3879 next, narg, args);
2dc2558e 3880 if (!next || (*PerlIOBase(f)->tab->Pushed) (aTHX_ f, mode, PerlIOArg, self) != 0) {
14a5cf38
JH		 3881 return NULL;
3882 }
3883 }
3884 else {
04892f78 3885 PerlIO_funcs *tab = PerlIO_layer_fetch(aTHX_ layers, n - 1, PerlIO_default_btm());
14a5cf38 3886 int init = 0;
3b6c1aba 3887 if (*mode == IoTYPE_IMPLICIT) {
14a5cf38
JH		 3888 init = 1;
3889 /*
71200d45 3890 * mode++;
14a5cf38
JH		 3891 */
3892 }
67363c0d
JH		 3893 if (tab && tab->Open)
3894 f = (*tab->Open)(aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
3895 f, narg, args);
3896 else
3897 SETERRNO(EINVAL, LIB_INVARG);
14a5cf38 3898 if (f) {
22569500 3899 if (PerlIO_push(aTHX_ f, self, mode, PerlIOArg) == 0) {
b26b1ab5
NC		 3900 /*
3901 * if push fails during open, open fails. close will pop us.
3902 */
3903 PerlIO_close (f);
3904 return NULL;
3905 } else {
3906 fd = PerlIO_fileno(f);
b26b1ab5
NC		 3907 if (init && fd == 2) {
3908 /*
3909 * Initial stderr is unbuffered
3910 */
3911 PerlIOBase(f)->flags |= PERLIO_F_UNBUF;
3912 }
23b84778
IZ		 3913#ifdef PERLIO_USING_CRLF
3914# ifdef PERLIO_IS_BINMODE_FD
3915 if (PERLIO_IS_BINMODE_FD(fd))
bd61b366 3916 PerlIO_binmode(aTHX_ f, '<'/*not used*/, O_BINARY, NULL);
23b84778
IZ		 3917 else
3918# endif
3919 /*
3920 * do something about failing setmode()? --jhi
3921 */
3922 PerlLIO_setmode(fd, O_BINARY);
3923#endif
8c8488cd 3924#ifdef VMS
8c8488cd
CB		 3925 /* Enable line buffering with record-oriented regular files
3926 * so we don't introduce an extraneous record boundary when
3927 * the buffer fills up.
3928 */
3929 if (PerlIOBase(f)->flags & PERLIO_F_CANWRITE) {
3930 Stat_t st;
3931 if (PerlLIO_fstat(fd, &st) == 0
3932 && S_ISREG(st.st_mode)
3933 && (st.st_fab_rfm == FAB$C_VAR
3934 || st.st_fab_rfm == FAB$C_VFC)) {
3935 PerlIOBase(f)->flags |= PERLIO_F_LINEBUF;
3936 }
3937 }
3938#endif
14a5cf38
JH		 3939 }
3940 }
ee518936 3941 }
14a5cf38 3942 return f;
9e353e3b
NIS		 3943}
3944
14a5cf38
JH		 3945/*
3946 * This "flush" is akin to sfio's sync in that it handles files in either
93c2c2ec
IZ		 3947 * read or write state. For write state, we put the postponed data through
3948 * the next layers. For read state, we seek() the next layers to the
3949 * offset given by current position in the buffer, and discard the buffer
3950 * state (XXXX supposed to be for seek()able buffers only, but now it is done
3951 * in any case?). Then the pass the stick further in chain.
14a5cf38 3952 */
9e353e3b 3953IV
f62ce20a 3954PerlIOBuf_flush(pTHX_ PerlIO *f)
6f9d8c32 3955{
dcda55fc 3956 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
14a5cf38 3957 int code = 0;
04892f78 3958 PerlIO *n = PerlIONext(f);
14a5cf38
JH		 3959 if (PerlIOBase(f)->flags & PERLIO_F_WRBUF) {
3960 /*
71200d45 3961 * write() the buffer
14a5cf38 3962 */
de009b76
AL		 3963 const STDCHAR *buf = b->buf;
3964 const STDCHAR *p = buf;
14a5cf38
JH		 3965 while (p < b->ptr) {
3966 SSize_t count = PerlIO_write(n, p, b->ptr - p);
3967 if (count > 0) {
3968 p += count;
3969 }
3970 else if (count < 0 || PerlIO_error(n)) {
3971 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
0ea86a10 3972 PerlIO_save_errno(f);
14a5cf38
JH		 3973 code = -1;
3974 break;
3975 }
3976 }
3977 b->posn += (p - buf);
3978 }
3979 else if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
3980 STDCHAR *buf = PerlIO_get_base(f);
3981 /*
71200d45 3982 * Note position change
14a5cf38
JH		 3983 */
3984 b->posn += (b->ptr - buf);
3985 if (b->ptr < b->end) {
4b069b44
NIS		 3986 /* We did not consume all of it - try and seek downstream to
3987 our logical position
14a5cf38 3988 */
4b069b44 3989 if (PerlIOValid(n) && PerlIO_seek(n, b->posn, SEEK_SET) == 0) {
04892f78
NIS		 3990 /* Reload n as some layers may pop themselves on seek */
3991 b->posn = PerlIO_tell(n = PerlIONext(f));
14a5cf38 3992 }
ba5c3fe9 3993 else {
4b069b44
NIS		 3994 /* Seek failed (e.g. pipe or tty). Do NOT clear buffer or pre-read
3995 data is lost for good - so return saying "ok" having undone
3996 the position adjust
3997 */
3998 b->posn -= (b->ptr - buf);
ba5c3fe9
NIS		 3999 return code;
4000 }
14a5cf38
JH		 4001 }
4002 }
4003 b->ptr = b->end = b->buf;
4004 PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF | PERLIO_F_WRBUF);
04892f78 4005 /* We check for Valid because of dubious decision to make PerlIO_flush(NULL) flush all */
04892f78 4006 if (PerlIOValid(n) && PerlIO_flush(n) != 0)
14a5cf38
JH		 4007 code = -1;
4008 return code;
6f9d8c32
NIS		 4009}
4010
93c2c2ec
IZ		 4011/* This discards the content of the buffer after b->ptr, and rereads
4012 * the buffer from the position off in the layer downstream; here off
4013 * is at offset corresponding to b->ptr - b->buf.
4014 */
06da4f11 4015IV
f62ce20a 4016PerlIOBuf_fill(pTHX_ PerlIO *f)
06da4f11 4017{
dcda55fc 4018 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
14a5cf38
JH		 4019 PerlIO *n = PerlIONext(f);
4020 SSize_t avail;
4021 /*
4b069b44
NIS		 4022 * Down-stream flush is defined not to loose read data so is harmless.
4023 * we would not normally be fill'ing if there was data left in anycase.
14a5cf38 4024 */
93c2c2ec 4025 if (PerlIO_flush(f) != 0) /* XXXX Check that its seek() succeeded?! */
14a5cf38
JH		 4026 return -1;
4027 if (PerlIOBase(f)->flags & PERLIO_F_TTY)
f62ce20a 4028 PerlIOBase_flush_linebuf(aTHX);
14a5cf38
JH		 4029
4030 if (!b->buf)
22569500 4031 PerlIO_get_base(f); /* allocate via vtable */
14a5cf38 4032
0f0eef27 4033 assert(b->buf); /* The b->buf does get allocated via the vtable system. */
ec6fa4f0 4034
14a5cf38 4035 b->ptr = b->end = b->buf;
4b069b44
NIS		 4036
4037 if (!PerlIOValid(n)) {
4038 PerlIOBase(f)->flags |= PERLIO_F_EOF;
4039 return -1;
4040 }
4041
14a5cf38
JH		 4042 if (PerlIO_fast_gets(n)) {
4043 /*
04892f78 4044 * Layer below is also buffered. We do _NOT_ want to call its
14a5cf38
JH		 4045 * ->Read() because that will loop till it gets what we asked for
4046 * which may hang on a pipe etc. Instead take anything it has to
71200d45 4047 * hand, or ask it to fill _once_.
14a5cf38
JH		 4048 */
4049 avail = PerlIO_get_cnt(n);
4050 if (avail <= 0) {
4051 avail = PerlIO_fill(n);
4052 if (avail == 0)
4053 avail = PerlIO_get_cnt(n);
4054 else {
4055 if (!PerlIO_error(n) && PerlIO_eof(n))
4056 avail = 0;
4057 }
4058 }
4059 if (avail > 0) {
4060 STDCHAR *ptr = PerlIO_get_ptr(n);
dcda55fc 4061 const SSize_t cnt = avail;
eb160463 4062 if (avail > (SSize_t)b->bufsiz)
14a5cf38
JH		 4063 avail = b->bufsiz;
4064 Copy(ptr, b->buf, avail, STDCHAR);
4065 PerlIO_set_ptrcnt(n, ptr + avail, cnt - avail);
4066 }
4067 }
4068 else {
4069 avail = PerlIO_read(n, b->ptr, b->bufsiz);
4070 }
4071 if (avail <= 0) {
4072 if (avail == 0)
4073 PerlIOBase(f)->flags |= PERLIO_F_EOF;
4074 else
0ea86a10 4075 {
14a5cf38 4076 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
0ea86a10
FC		 4077 PerlIO_save_errno(f);
4078 }
14a5cf38
JH		 4079 return -1;
4080 }
4081 b->end = b->buf + avail;
4082 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
4083 return 0;
06da4f11
NIS		 4084}
4085
6f9d8c32 4086SSize_t
f62ce20a 4087PerlIOBuf_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
6f9d8c32 4088{
04892f78 4089 if (PerlIOValid(f)) {
dcda55fc 4090 const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
14a5cf38
JH		 4091 if (!b->ptr)
4092 PerlIO_get_base(f);
f62ce20a 4093 return PerlIOBase_read(aTHX_ f, vbuf, count);
14a5cf38
JH		 4094 }
4095 return 0;
6f9d8c32
NIS		 4096}
4097
9e353e3b 4098SSize_t
f62ce20a 4099PerlIOBuf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
760ac839 4100{
14a5cf38 4101 const STDCHAR *buf = (const STDCHAR *) vbuf + count;
dcda55fc 4102 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
14a5cf38
JH		 4103 SSize_t unread = 0;
4104 SSize_t avail;
4105 if (PerlIOBase(f)->flags & PERLIO_F_WRBUF)
4106 PerlIO_flush(f);
4107 if (!b->buf)
4108 PerlIO_get_base(f);
4109 if (b->buf) {
4110 if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
4111 /*
4112 * Buffer is already a read buffer, we can overwrite any chars
71200d45 4113 * which have been read back to buffer start
14a5cf38
JH		 4114 */
4115 avail = (b->ptr - b->buf);
4116 }
4117 else {
4118 /*
4119 * Buffer is idle, set it up so whole buffer is available for
71200d45 4120 * unread
14a5cf38
JH		 4121 */
4122 avail = b->bufsiz;
4123 b->end = b->buf + avail;
4124 b->ptr = b->end;
4125 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
4126 /*
71200d45 4127 * Buffer extends _back_ from where we are now
14a5cf38
JH		 4128 */
4129 b->posn -= b->bufsiz;
4130 }
94e529cc 4131 if ((SSize_t) count >= 0 && avail > (SSize_t) count) {
14a5cf38 4132 /*
71200d45 4133 * If we have space for more than count, just move count
14a5cf38
JH		 4134 */
4135 avail = count;
4136 }
4137 if (avail > 0) {
4138 b->ptr -= avail;
4139 buf -= avail;
4140 /*
4141 * In simple stdio-like ungetc() case chars will be already
71200d45 4142 * there
14a5cf38
JH		 4143 */
4144 if (buf != b->ptr) {
4145 Copy(buf, b->ptr, avail, STDCHAR);
4146 }
4147 count -= avail;
4148 unread += avail;
4149 PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
4150 }
4151 }
93679785
NIS		 4152 if (count > 0) {
4153 unread += PerlIOBase_unread(aTHX_ f, vbuf, count);
4154 }
14a5cf38 4155 return unread;
760ac839
LW		 4156}
4157
9e353e3b 4158SSize_t
f62ce20a 4159PerlIOBuf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
760ac839 4160{
de009b76 4161 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
14a5cf38 4162 const STDCHAR *buf = (const STDCHAR *) vbuf;
ee56a6b9 4163 const STDCHAR *flushptr = buf;
14a5cf38
JH		 4164 Size_t written = 0;
4165 if (!b->buf)
4166 PerlIO_get_base(f);
4167 if (!(PerlIOBase(f)->flags & PERLIO_F_CANWRITE))
4168 return 0;
0678cb22
NIS		 4169 if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
4170 if (PerlIO_flush(f) != 0) {
4171 return 0;
4172 }
4173 }
ee56a6b9
CS		 4174 if (PerlIOBase(f)->flags & PERLIO_F_LINEBUF) {
4175 flushptr = buf + count;
4176 while (flushptr > buf && *(flushptr - 1) != '\n')
4177 --flushptr;
4178 }
14a5cf38
JH		 4179 while (count > 0) {
4180 SSize_t avail = b->bufsiz - (b->ptr - b->buf);
94e529cc 4181 if ((SSize_t) count >= 0 && (SSize_t) count < avail)
14a5cf38 4182 avail = count;
ee56a6b9
CS		 4183 if (flushptr > buf && flushptr <= buf + avail)
4184 avail = flushptr - buf;
14a5cf38 4185 PerlIOBase(f)->flags |= PERLIO_F_WRBUF;
ee56a6b9
CS		 4186 if (avail) {
4187 Copy(buf, b->ptr, avail, STDCHAR);
4188 count -= avail;
4189 buf += avail;
4190 written += avail;
4191 b->ptr += avail;
4192 if (buf == flushptr)
4193 PerlIO_flush(f);
14a5cf38
JH		 4194 }
4195 if (b->ptr >= (b->buf + b->bufsiz))
abf9167d
DM		 4196 if (PerlIO_flush(f) == -1)
4197 return -1;
14a5cf38
JH		 4198 }
4199 if (PerlIOBase(f)->flags & PERLIO_F_UNBUF)
4200 PerlIO_flush(f);
4201 return written;
9e353e3b
NIS		 4202}
4203
94a175e1 4204IV
f62ce20a 4205PerlIOBuf_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
9e353e3b 4206{
14a5cf38
JH		 4207 IV code;
4208 if ((code = PerlIO_flush(f)) == 0) {
14a5cf38
JH		 4209 PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
4210 code = PerlIO_seek(PerlIONext(f), offset, whence);
4211 if (code == 0) {
de009b76 4212 PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
14a5cf38
JH		 4213 b->posn = PerlIO_tell(PerlIONext(f));
4214 }
9e353e3b 4215 }
14a5cf38 4216 return code;
9e353e3b
NIS		 4217}
4218
4219Off_t
f62ce20a 4220PerlIOBuf_tell(pTHX_ PerlIO *f)
9e353e3b 4221{
dcda55fc 4222 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
14a5cf38 4223 /*
71200d45 4224 * b->posn is file position where b->buf was read, or will be written
14a5cf38
JH		 4225 */
4226 Off_t posn = b->posn;
37725cdc 4227 if ((PerlIOBase(f)->flags & PERLIO_F_APPEND) &&
0678cb22
NIS		 4228 (PerlIOBase(f)->flags & PERLIO_F_WRBUF)) {
4229#if 1
4230 /* As O_APPEND files are normally shared in some sense it is better
4231 to flush :
4232 */
4233 PerlIO_flush(f);
4234#else
37725cdc 4235 /* when file is NOT shared then this is sufficient */
0678cb22
NIS		 4236 PerlIO_seek(PerlIONext(f),0, SEEK_END);
4237#endif
4238 posn = b->posn = PerlIO_tell(PerlIONext(f));
4239 }
14a5cf38
JH		 4240 if (b->buf) {
4241 /*
71200d45 4242 * If buffer is valid adjust position by amount in buffer
14a5cf38
JH		 4243 */
4244 posn += (b->ptr - b->buf);
4245 }
4246 return posn;
9e353e3b
NIS		 4247}
4248
4249IV
44798d05
NIS		 4250PerlIOBuf_popped(pTHX_ PerlIO *f)
4251{
de009b76
AL		 4252 const IV code = PerlIOBase_popped(aTHX_ f);
4253 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
44798d05
NIS		 4254 if (b->buf && b->buf != (STDCHAR *) & b->oneword) {
4255 Safefree(b->buf);
4256 }
dcda55fc 4257 b->ptr = b->end = b->buf = NULL;
44798d05
NIS		 4258 PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF | PERLIO_F_WRBUF);
4259 return code;
4260}
4261
4262IV
f62ce20a 4263PerlIOBuf_close(pTHX_ PerlIO *f)
9e353e3b 4264{
de009b76
AL		 4265 const IV code = PerlIOBase_close(aTHX_ f);
4266 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
14a5cf38 4267 if (b->buf && b->buf != (STDCHAR *) & b->oneword) {
3a1ee7e8 4268 Safefree(b->buf);
14a5cf38 4269 }
dcda55fc 4270 b->ptr = b->end = b->buf = NULL;
14a5cf38
JH		 4271 PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF | PERLIO_F_WRBUF);
4272 return code;
760ac839
LW		 4273}
4274
9e353e3b 4275STDCHAR *
f62ce20a 4276PerlIOBuf_get_ptr(pTHX_ PerlIO *f)
9e353e3b 4277{
dcda55fc 4278 const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
14a5cf38
JH		 4279 if (!b->buf)
4280 PerlIO_get_base(f);
4281 return b->ptr;
9e353e3b
NIS		 4282}
4283
05d1247b 4284SSize_t
f62ce20a 4285PerlIOBuf_get_cnt(pTHX_ PerlIO *f)
9e353e3b 4286{
dcda55fc 4287 const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
14a5cf38
JH		 4288 if (!b->buf)
4289 PerlIO_get_base(f);
4290 if (PerlIOBase(f)->flags & PERLIO_F_RDBUF)
4291 return (b->end - b->ptr);
4292 return 0;
9e353e3b
NIS		 4293}
4294
4295STDCHAR *
f62ce20a 4296PerlIOBuf_get_base(pTHX_ PerlIO *f)
9e353e3b 4297{
dcda55fc 4298 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
96a5add6
AL		 4299 PERL_UNUSED_CONTEXT;
4300
14a5cf38
JH		 4301 if (!b->buf) {
4302 if (!b->bufsiz)
1810cd7c 4303 b->bufsiz = PERLIOBUF_DEFAULT_BUFSIZ;
d09f14bf 4304 Newx(b->buf,b->bufsiz, STDCHAR);
14a5cf38
JH		 4305 if (!b->buf) {
4306 b->buf = (STDCHAR *) & b->oneword;
4307 b->bufsiz = sizeof(b->oneword);
4308 }
dcda55fc 4309 b->end = b->ptr = b->buf;
06da4f11 4310 }
14a5cf38 4311 return b->buf;
9e353e3b
NIS		 4312}
4313
4314Size_t
f62ce20a 4315PerlIOBuf_bufsiz(pTHX_ PerlIO *f)
9e353e3b 4316{
dcda55fc 4317 const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
14a5cf38
JH		 4318 if (!b->buf)
4319 PerlIO_get_base(f);
4320 return (b->end - b->buf);
9e353e3b
NIS		 4321}
4322
4323void
f62ce20a 4324PerlIOBuf_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
9e353e3b 4325{
dcda55fc 4326 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
babfacb9
JH		 4327#ifndef DEBUGGING
4328 PERL_UNUSED_ARG(cnt);
4329#endif
14a5cf38
JH		 4330 if (!b->buf)
4331 PerlIO_get_base(f);
4332 b->ptr = ptr;
b727803b
RGS		 4333 assert(PerlIO_get_cnt(f) == cnt);
4334 assert(b->ptr >= b->buf);
14a5cf38 4335 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
760ac839
LW		 4336}
4337
71200d45 4338PerlIO *
ecdeb87c 4339PerlIOBuf_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
71200d45 4340{
ecdeb87c 4341 return PerlIOBase_dup(aTHX_ f, o, param, flags);
71200d45
NIS		 4342}
4343
4344
4345
27da23d5 4346PERLIO_FUNCS_DECL(PerlIO_perlio) = {
2dc2558e 4347 sizeof(PerlIO_funcs),
14a5cf38
JH		 4348 "perlio",
4349 sizeof(PerlIOBuf),
86e05cf2 4350 PERLIO_K_BUFFERED|PERLIO_K_RAW,
14a5cf38 4351 PerlIOBuf_pushed,
44798d05 4352 PerlIOBuf_popped,
14a5cf38 4353 PerlIOBuf_open,
86e05cf2 4354 PerlIOBase_binmode, /* binmode */
14a5cf38
JH		 4355 NULL,
4356 PerlIOBase_fileno,
71200d45 4357 PerlIOBuf_dup,
14a5cf38
JH		 4358 PerlIOBuf_read,
4359 PerlIOBuf_unread,
4360 PerlIOBuf_write,
4361 PerlIOBuf_seek,
4362 PerlIOBuf_tell,
4363 PerlIOBuf_close,
4364 PerlIOBuf_flush,
4365 PerlIOBuf_fill,
4366 PerlIOBase_eof,
4367 PerlIOBase_error,
4368 PerlIOBase_clearerr,
4369 PerlIOBase_setlinebuf,
4370 PerlIOBuf_get_base,
4371 PerlIOBuf_bufsiz,
4372 PerlIOBuf_get_ptr,
4373 PerlIOBuf_get_cnt,
4374 PerlIOBuf_set_ptrcnt,
9e353e3b
NIS		 4375};
4376
66ecd56b 4377/*--------------------------------------------------------------------------------------*/
14a5cf38 4378/*
71200d45 4379 * Temp layer to hold unread chars when cannot do it any other way
14a5cf38 4380 */
5e2ab84b
NIS		 4381
4382IV
f62ce20a 4383PerlIOPending_fill(pTHX_ PerlIO *f)
5e2ab84b 4384{
14a5cf38 4385 /*
71200d45 4386 * Should never happen
14a5cf38
JH		 4387 */
4388 PerlIO_flush(f);
4389 return 0;
5e2ab84b
NIS		 4390}
4391
4392IV
f62ce20a 4393PerlIOPending_close(pTHX_ PerlIO *f)
5e2ab84b 4394{
14a5cf38 4395 /*
71200d45 4396 * A tad tricky - flush pops us, then we close new top
14a5cf38
JH		 4397 */
4398 PerlIO_flush(f);
4399 return PerlIO_close(f);
5e2ab84b
NIS		 4400}
4401
94a175e1 4402IV
f62ce20a 4403PerlIOPending_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
5e2ab84b 4404{
14a5cf38 4405 /*
71200d45 4406 * A tad tricky - flush pops us, then we seek new top
14a5cf38
JH		 4407 */
4408 PerlIO_flush(f);
4409 return PerlIO_seek(f, offset, whence);
5e2ab84b
NIS		 4410}
4411
4412
4413IV
f62ce20a 4414PerlIOPending_flush(pTHX_ PerlIO *f)
5e2ab84b 4415{
dcda55fc 4416 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
14a5cf38 4417 if (b->buf && b->buf != (STDCHAR *) & b->oneword) {
3a1ee7e8 4418 Safefree(b->buf);
14a5cf38
JH		 4419 b->buf = NULL;
4420 }
4421 PerlIO_pop(aTHX_ f);
4422 return 0;
5e2ab84b
NIS		 4423}
4424
4425void
f62ce20a 4426PerlIOPending_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
5e2ab84b 4427{
14a5cf38
JH		 4428 if (cnt <= 0) {
4429 PerlIO_flush(f);
4430 }
4431 else {
f62ce20a 4432 PerlIOBuf_set_ptrcnt(aTHX_ f, ptr, cnt);
14a5cf38 4433 }
5e2ab84b
NIS		 4434}
4435
4436IV
2dc2558e 4437PerlIOPending_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
5e2ab84b 4438{
de009b76 4439 const IV code = PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
dcda55fc 4440 PerlIOl * const l = PerlIOBase(f);
14a5cf38 4441 /*
71200d45
NIS		 4442 * Our PerlIO_fast_gets must match what we are pushed on, or sv_gets()
4443 * etc. get muddled when it changes mid-string when we auto-pop.
14a5cf38
JH		 4444 */
4445 l->flags = (l->flags & ~(PERLIO_F_FASTGETS | PERLIO_F_UTF8)) |
4446 (PerlIOBase(PerlIONext(f))->
4447 flags & (PERLIO_F_FASTGETS | PERLIO_F_UTF8));
4448 return code;
5e2ab84b
NIS		 4449}
4450
4451SSize_t
f62ce20a 4452PerlIOPending_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
5e2ab84b 4453{
14a5cf38
JH		 4454 SSize_t avail = PerlIO_get_cnt(f);
4455 SSize_t got = 0;
94e529cc 4456 if ((SSize_t) count >= 0 && (SSize_t)count < avail)
14a5cf38
JH		 4457 avail = count;
4458 if (avail > 0)
f62ce20a 4459 got = PerlIOBuf_read(aTHX_ f, vbuf, avail);
eb160463 4460 if (got >= 0 && got < (SSize_t)count) {
de009b76 4461 const SSize_t more =
14a5cf38
JH		 4462 PerlIO_read(f, ((STDCHAR *) vbuf) + got, count - got);
4463 if (more >= 0 || got == 0)
4464 got += more;
4465 }
4466 return got;
5e2ab84b
NIS		 4467}
4468
27da23d5 4469PERLIO_FUNCS_DECL(PerlIO_pending) = {
2dc2558e 4470 sizeof(PerlIO_funcs),
14a5cf38
JH		 4471 "pending",
4472 sizeof(PerlIOBuf),
86e05cf2 4473 PERLIO_K_BUFFERED|PERLIO_K_RAW, /* not sure about RAW here */
14a5cf38 4474 PerlIOPending_pushed,
44798d05 4475 PerlIOBuf_popped,
14a5cf38 4476 NULL,
86e05cf2 4477 PerlIOBase_binmode, /* binmode */
14a5cf38
JH		 4478 NULL,
4479 PerlIOBase_fileno,
71200d45 4480 PerlIOBuf_dup,
14a5cf38
JH		 4481 PerlIOPending_read,
4482 PerlIOBuf_unread,
4483 PerlIOBuf_write,
4484 PerlIOPending_seek,
4485 PerlIOBuf_tell,
4486 PerlIOPending_close,
4487 PerlIOPending_flush,
4488 PerlIOPending_fill,
4489 PerlIOBase_eof,
4490 PerlIOBase_error,
4491 PerlIOBase_clearerr,
4492 PerlIOBase_setlinebuf,
4493 PerlIOBuf_get_base,
4494 PerlIOBuf_bufsiz,
4495 PerlIOBuf_get_ptr,
4496 PerlIOBuf_get_cnt,
4497 PerlIOPending_set_ptrcnt,
5e2ab84b
NIS		 4498};
4499
4500
4501
4502/*--------------------------------------------------------------------------------------*/
14a5cf38
JH		 4503/*
4504 * crlf - translation On read translate CR,LF to "\n" we do this by
4505 * overriding ptr/cnt entries to hand back a line at a time and keeping a
71200d45 4506 * record of which nl we "lied" about. On write translate "\n" to CR,LF
93c2c2ec
IZ		 4507 *
4508 * c->nl points on the first byte of CR LF pair when it is temporarily
4509 * replaced by LF, or to the last CR of the buffer. In the former case
4510 * the caller thinks that the buffer ends at c->nl + 1, in the latter
4511 * that it ends at c->nl; these two cases can be distinguished by
4512 * *c->nl. c->nl is set during _getcnt() call, and unset during
4513 * _unread() and _flush() calls.
4514 * It only matters for read operations.
66ecd56b
NIS		 4515 */
4516
14a5cf38 4517typedef struct {
22569500
NIS		 4518 PerlIOBuf base; /* PerlIOBuf stuff */
4519 STDCHAR *nl; /* Position of crlf we "lied" about in the
14a5cf38 4520 * buffer */
99efab12
NIS		 4521} PerlIOCrlf;
4522
ff1e3883
JD		 4523/* Inherit the PERLIO_F_UTF8 flag from previous layer.
4524 * Otherwise the :crlf layer would always revert back to
4525 * raw mode.
4526 */
4527static void
4528S_inherit_utf8_flag(PerlIO *f)
4529{
4530 PerlIO *g = PerlIONext(f);
4531 if (PerlIOValid(g)) {
4532 if (PerlIOBase(g)->flags & PERLIO_F_UTF8) {
4533 PerlIOBase(f)->flags |= PERLIO_F_UTF8;
4534 }
4535 }
4536}
4537
f5b9d040 4538IV
2dc2558e 4539PerlIOCrlf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
f5b9d040 4540{
14a5cf38
JH		 4541 IV code;
4542 PerlIOBase(f)->flags |= PERLIO_F_CRLF;
2dc2558e 4543 code = PerlIOBuf_pushed(aTHX_ f, mode, arg, tab);
5e2ab84b 4544#if 0
e17bc05a 4545 DEBUG_i(
14a5cf38 4546 PerlIO_debug("PerlIOCrlf_pushed f=%p %s %s fl=%08" UVxf "\n",
6c9570dc 4547 (void*)f, PerlIOBase(f)->tab->name, (mode) ? mode : "(Null)",
14a5cf38 4548 PerlIOBase(f)->flags);
e17bc05a 4549 );
5e2ab84b 4550#endif
8229d19f 4551 {
5da08ab0
LT		 4552 /* If the old top layer is a CRLF layer, reactivate it (if
4553 * necessary) and remove this new layer from the stack */
8229d19f 4554 PerlIO *g = PerlIONext(f);
7826b36f 4555 if (PerlIOValid(g)) {
8229d19f
JH		 4556 PerlIOl *b = PerlIOBase(g);
4557 if (b && b->tab == &PerlIO_crlf) {
4558 if (!(b->flags & PERLIO_F_CRLF))
4559 b->flags |= PERLIO_F_CRLF;
ff1e3883 4560 S_inherit_utf8_flag(g);
8229d19f
JH		 4561 PerlIO_pop(aTHX_ f);
4562 return code;
7826b36f 4563 }
8229d19f
JH		 4564 }
4565 }
ff1e3883 4566 S_inherit_utf8_flag(f);
14a5cf38 4567 return code;
f5b9d040
NIS		 4568}
4569
4570
99efab12 4571SSize_t
f62ce20a 4572PerlIOCrlf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
99efab12 4573{
dcda55fc 4574 PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
93c2c2ec 4575 if (c->nl) { /* XXXX Shouldn't it be done only if b->ptr > c->nl? */
76e6dc3a 4576 *(c->nl) = NATIVE_0xd;
14a5cf38
JH		 4577 c->nl = NULL;
4578 }
4579 if (!(PerlIOBase(f)->flags & PERLIO_F_CRLF))
f62ce20a 4580 return PerlIOBuf_unread(aTHX_ f, vbuf, count);
14a5cf38
JH		 4581 else {
4582 const STDCHAR *buf = (const STDCHAR *) vbuf + count;
4583 PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
4584 SSize_t unread = 0;
4585 if (PerlIOBase(f)->flags & PERLIO_F_WRBUF)
4586 PerlIO_flush(f);
4587 if (!b->buf)
4588 PerlIO_get_base(f);
4589 if (b->buf) {
4590 if (!(PerlIOBase(f)->flags & PERLIO_F_RDBUF)) {
4591 b->end = b->ptr = b->buf + b->bufsiz;
4592 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
4593 b->posn -= b->bufsiz;
4594 }
4595 while (count > 0 && b->ptr > b->buf) {
dcda55fc 4596 const int ch = *--buf;
14a5cf38
JH		 4597 if (ch == '\n') {
4598 if (b->ptr - 2 >= b->buf) {
76e6dc3a
KW		 4599 *--(b->ptr) = NATIVE_0xa;
4600 *--(b->ptr) = NATIVE_0xd;
14a5cf38
JH		 4601 unread++;
4602 count--;
4603 }
4604 else {
93c2c2ec 4605 /* If b->ptr - 1 == b->buf, we are undoing reading 0xa */
76e6dc3a
KW		 4606 *--(b->ptr) = NATIVE_0xa; /* Works even if 0xa ==
4607 '\r' */
93c2c2ec
IZ		 4608 unread++;
4609 count--;
14a5cf38
JH		 4610 }
4611 }
4612 else {
4613 *--(b->ptr) = ch;
4614 unread++;
4615 count--;
4616 }
4617 }
4618 }
ec1da995
LT		 4619 if (count > 0)
4620 unread += PerlIOBase_unread(aTHX_ f, (const STDCHAR *) vbuf + unread, count);
14a5cf38
JH		 4621 return unread;
4622 }
99efab12
NIS		 4623}
4624
93c2c2ec 4625/* XXXX This code assumes that buffer size >=2, but does not check it... */
99efab12 4626SSize_t
f62ce20a 4627PerlIOCrlf_get_cnt(pTHX_ PerlIO *f)
99efab12 4628{
dcda55fc 4629 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
14a5cf38
JH		 4630 if (!b->buf)
4631 PerlIO_get_base(f);
4632 if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
dcda55fc 4633 PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
76e6dc3a 4634 if ((PerlIOBase(f)->flags & PERLIO_F_CRLF) && (!c->nl || *c->nl == NATIVE_0xd)) {
23b3c6af 4635 STDCHAR *nl = (c->nl) ? c->nl : b->ptr;
14a5cf38 4636 scan:
76e6dc3a 4637 while (nl < b->end && *nl != NATIVE_0xd)
14a5cf38 4638 nl++;
76e6dc3a 4639 if (nl < b->end && *nl == NATIVE_0xd) {
14a5cf38
JH		 4640 test:
4641 if (nl + 1 < b->end) {
76e6dc3a 4642 if (nl[1] == NATIVE_0xa) {
14a5cf38
JH		 4643 *nl = '\n';
4644 c->nl = nl;
4645 }
4646 else {
4647 /*
71200d45 4648 * Not CR,LF but just CR
14a5cf38
JH		 4649 */
4650 nl++;
4651 goto scan;
4652 }
4653 }
4654 else {
4655 /*
71200d45 4656 * Blast - found CR as last char in buffer
14a5cf38 4657 */
e87a358a 4658
14a5cf38
JH		 4659 if (b->ptr < nl) {
4660 /*
4661 * They may not care, defer work as long as
71200d45 4662 * possible
14a5cf38 4663 */
a0d1d361 4664 c->nl = nl;
14a5cf38
JH		 4665 return (nl - b->ptr);
4666 }
4667 else {
4668 int code;
22569500 4669 b->ptr++; /* say we have read it as far as
14a5cf38 4670 * flush() is concerned */
22569500 4671 b->buf++; /* Leave space in front of buffer */
e949e37c
NIS		 4672 /* Note as we have moved buf up flush's
4673 posn += ptr-buf
4674 will naturally make posn point at CR
4675 */
22569500
NIS		 4676 b->bufsiz--; /* Buffer is thus smaller */
4677 code = PerlIO_fill(f); /* Fetch some more */
4678 b->bufsiz++; /* Restore size for next time */
4679 b->buf--; /* Point at space */
4680 b->ptr = nl = b->buf; /* Which is what we hand
14a5cf38 4681 * off */
76e6dc3a 4682 *nl = NATIVE_0xd; /* Fill in the CR */
14a5cf38 4683 if (code == 0)
22569500 4684 goto test; /* fill() call worked */
14a5cf38 4685 /*
71200d45 4686 * CR at EOF - just fall through
14a5cf38 4687 */
a0d1d361 4688 /* Should we clear EOF though ??? */
14a5cf38
JH		 4689 }
4690 }
4691 }
4692 }
4693 return (((c->nl) ? (c->nl + 1) : b->end) - b->ptr);
4694 }
4695 return 0;
99efab12
NIS		 4696}
4697
4698void
f62ce20a 4699PerlIOCrlf_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
14a5cf38 4700{
dcda55fc
AL		 4701 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4702 PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
14a5cf38
JH		 4703 if (!b->buf)
4704 PerlIO_get_base(f);
4705 if (!ptr) {
a0d1d361 4706 if (c->nl) {
14a5cf38 4707 ptr = c->nl + 1;
76e6dc3a 4708 if (ptr == b->end && *c->nl == NATIVE_0xd) {
486ec47a 4709 /* Deferred CR at end of buffer case - we lied about count */
22569500
NIS		 4710 ptr--;
4711 }
4712 }
14a5cf38
JH		 4713 else {
4714 ptr = b->end;
14a5cf38
JH		 4715 }
4716 ptr -= cnt;
4717 }
4718 else {
6f207bd3 4719 NOOP;
3b4bd3fd 4720#if 0
14a5cf38 4721 /*
71200d45 4722 * Test code - delete when it works ...
14a5cf38 4723 */
3b4bd3fd 4724 IV flags = PerlIOBase(f)->flags;
ba7abf9d 4725 STDCHAR *chk = (c->nl) ? (c->nl+1) : b->end;
76e6dc3a 4726 if (ptr+cnt == c->nl && c->nl+1 == b->end && *c->nl == NATIVE_0xd) {
486ec47a 4727 /* Deferred CR at end of buffer case - we lied about count */
a0d1d361 4728 chk--;
22569500 4729 }
14a5cf38
JH		 4730 chk -= cnt;
4731
a0d1d361 4732 if (ptr != chk ) {
99ef548b 4733 Perl_croak(aTHX_ "ptr wrong %p != %p fl=%08" UVxf
6c9570dc
MHM		 4734 " nl=%p e=%p for %d", (void*)ptr, (void*)chk,
4735 flags, c->nl, b->end, cnt);
14a5cf38 4736 }
99ef548b 4737#endif
14a5cf38
JH		 4738 }
4739 if (c->nl) {
4740 if (ptr > c->nl) {
4741 /*
71200d45 4742 * They have taken what we lied about
14a5cf38 4743 */
76e6dc3a 4744 *(c->nl) = NATIVE_0xd;
14a5cf38
JH		 4745 c->nl = NULL;
4746 ptr++;
4747 }
4748 }
4749 b->ptr = ptr;
4750 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
99efab12
NIS		 4751}
4752
4753SSize_t
f62ce20a 4754PerlIOCrlf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
99efab12 4755{
14a5cf38 4756 if (!(PerlIOBase(f)->flags & PERLIO_F_CRLF))
f62ce20a 4757 return PerlIOBuf_write(aTHX_ f, vbuf, count);
14a5cf38 4758 else {
dcda55fc 4759 PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
14a5cf38 4760 const STDCHAR *buf = (const STDCHAR *) vbuf;
dcda55fc 4761 const STDCHAR * const ebuf = buf + count;
14a5cf38
JH		 4762 if (!b->buf)
4763 PerlIO_get_base(f);
4764 if (!(PerlIOBase(f)->flags & PERLIO_F_CANWRITE))
4765 return 0;
4766 while (buf < ebuf) {
dcda55fc 4767 const STDCHAR * const eptr = b->buf + b->bufsiz;
14a5cf38
JH		 4768 PerlIOBase(f)->flags |= PERLIO_F_WRBUF;
4769 while (buf < ebuf && b->ptr < eptr) {
4770 if (*buf == '\n') {
4771 if ((b->ptr + 2) > eptr) {
4772 /*
71200d45 4773 * Not room for both
14a5cf38
JH		 4774 */
4775 PerlIO_flush(f);
4776 break;
4777 }
4778 else {
76e6dc3a
KW		 4779 *(b->ptr)++ = NATIVE_0xd; /* CR */
4780 *(b->ptr)++ = NATIVE_0xa; /* LF */
14a5cf38
JH		 4781 buf++;
4782 if (PerlIOBase(f)->flags & PERLIO_F_LINEBUF) {
4783 PerlIO_flush(f);
4784 break;
4785 }
4786 }
4787 }
4788 else {
dcda55fc 4789 *(b->ptr)++ = *buf++;
14a5cf38
JH		 4790 }
4791 if (b->ptr >= eptr) {
4792 PerlIO_flush(f);
4793 break;
4794 }
4795 }
4796 }
4797 if (PerlIOBase(f)->flags & PERLIO_F_UNBUF)
4798 PerlIO_flush(f);
4799 return (buf - (STDCHAR *) vbuf);
4800 }
99efab12
NIS		 4801}
4802
4803IV
f62ce20a 4804PerlIOCrlf_flush(pTHX_ PerlIO *f)
99efab12 4805{
dcda55fc 4806 PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
14a5cf38 4807 if (c->nl) {
76e6dc3a 4808 *(c->nl) = NATIVE_0xd;
14a5cf38
JH		 4809 c->nl = NULL;
4810 }
f62ce20a 4811 return PerlIOBuf_flush(aTHX_ f);
99efab12
NIS		 4812}
4813
86e05cf2
NIS		 4814IV
4815PerlIOCrlf_binmode(pTHX_ PerlIO *f)
4816{
4817 if ((PerlIOBase(f)->flags & PERLIO_F_CRLF)) {
4818 /* In text mode - flush any pending stuff and flip it */
4819 PerlIOBase(f)->flags &= ~PERLIO_F_CRLF;
4820#ifndef PERLIO_USING_CRLF
4821 /* CRLF is unusual case - if this is just the :crlf layer pop it */
5fae6dc1 4822 PerlIO_pop(aTHX_ f);
86e05cf2
NIS		 4823#endif
4824 }
dda4a477 4825 return PerlIOBase_binmode(aTHX_ f);
86e05cf2
NIS		 4826}
4827
27da23d5 4828PERLIO_FUNCS_DECL(PerlIO_crlf) = {
2dc2558e 4829 sizeof(PerlIO_funcs),
14a5cf38
JH		 4830 "crlf",
4831 sizeof(PerlIOCrlf),
86e05cf2 4832 PERLIO_K_BUFFERED | PERLIO_K_CANCRLF | PERLIO_K_RAW,
14a5cf38 4833 PerlIOCrlf_pushed,
44798d05 4834 PerlIOBuf_popped, /* popped */
14a5cf38 4835 PerlIOBuf_open,
86e05cf2 4836 PerlIOCrlf_binmode, /* binmode */
14a5cf38
JH		 4837 NULL,
4838 PerlIOBase_fileno,
71200d45 4839 PerlIOBuf_dup,
de009b76 4840 PerlIOBuf_read, /* generic read works with ptr/cnt lies */
22569500
NIS		 4841 PerlIOCrlf_unread, /* Put CR,LF in buffer for each '\n' */
4842 PerlIOCrlf_write, /* Put CR,LF in buffer for each '\n' */
14a5cf38
JH		 4843 PerlIOBuf_seek,
4844 PerlIOBuf_tell,
4845 PerlIOBuf_close,
4846 PerlIOCrlf_flush,
4847 PerlIOBuf_fill,
4848 PerlIOBase_eof,
4849 PerlIOBase_error,
4850 PerlIOBase_clearerr,
4851 PerlIOBase_setlinebuf,
4852 PerlIOBuf_get_base,
4853 PerlIOBuf_bufsiz,
4854 PerlIOBuf_get_ptr,
4855 PerlIOCrlf_get_cnt,
4856 PerlIOCrlf_set_ptrcnt,
66ecd56b
NIS		 4857};
4858
9e353e3b 4859PerlIO *
e87a358a 4860Perl_PerlIO_stdin(pTHX)
9e353e3b 4861{
a1ea730d 4862 if (!PL_perlio) {
14a5cf38
JH		 4863 PerlIO_stdstreams(aTHX);
4864 }
303f2dc3 4865 return (PerlIO*)&PL_perlio[1];
9e353e3b
NIS		 4866}
4867
9e353e3b 4868PerlIO *
e87a358a 4869Perl_PerlIO_stdout(pTHX)
9e353e3b 4870{
a1ea730d 4871 if (!PL_perlio) {
14a5cf38
JH		 4872 PerlIO_stdstreams(aTHX);
4873 }
303f2dc3 4874 return (PerlIO*)&PL_perlio[2];
9e353e3b
NIS		 4875}
4876
9e353e3b 4877PerlIO *
e87a358a 4878Perl_PerlIO_stderr(pTHX)
9e353e3b 4879{
a1ea730d 4880 if (!PL_perlio) {
14a5cf38
JH		 4881 PerlIO_stdstreams(aTHX);
4882 }
303f2dc3 4883 return (PerlIO*)&PL_perlio[3];
9e353e3b
NIS		 4884}
4885
4886/*--------------------------------------------------------------------------------------*/
4887
9e353e3b
NIS		 4888char *
4889PerlIO_getname(PerlIO *f, char *buf)
4890{
a15cef0c 4891#ifdef VMS
dbf7dff6 4892 dTHX;
73d840c0 4893 char *name = NULL;
7659f319 4894 bool exported = FALSE;
14a5cf38 4895 FILE *stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
7659f319
CB		 4896 if (!stdio) {
4897 stdio = PerlIO_exportFILE(f,0);
4898 exported = TRUE;
4899 }
4900 if (stdio) {
14a5cf38 4901 name = fgetname(stdio, buf);
7659f319
CB		 4902 if (exported) PerlIO_releaseFILE(f,stdio);
4903 }
73d840c0 4904 return name;
a15cef0c 4905#else
8772537c
AL		 4906 PERL_UNUSED_ARG(f);
4907 PERL_UNUSED_ARG(buf);
dbf7dff6 4908 Perl_croak_nocontext("Don't know how to get file name");
bd61b366 4909 return NULL;
a15cef0c 4910#endif
9e353e3b
NIS		 4911}
4912
4913
4914/*--------------------------------------------------------------------------------------*/
14a5cf38
JH		 4915/*
4916 * Functions which can be called on any kind of PerlIO implemented in
71200d45 4917 * terms of above
14a5cf38 4918 */
9e353e3b 4919
e87a358a
NIS		 4920#undef PerlIO_fdopen
4921PerlIO *
4922PerlIO_fdopen(int fd, const char *mode)
4923{
4924 dTHX;
bd61b366 4925 return PerlIO_openn(aTHX_ NULL, mode, fd, 0, 0, NULL, 0, NULL);
e87a358a
NIS		 4926}
4927
4928#undef PerlIO_open
4929PerlIO *
4930PerlIO_open(const char *path, const char *mode)
4931{
4932 dTHX;
42d9b98d 4933 SV *name = sv_2mortal(newSVpv(path, 0));
bd61b366 4934 return PerlIO_openn(aTHX_ NULL, mode, -1, 0, 0, NULL, 1, &name);
e87a358a
NIS		 4935}
4936
4937#undef Perlio_reopen
4938PerlIO *
4939PerlIO_reopen(const char *path, const char *mode, PerlIO *f)
4940{
4941 dTHX;
42d9b98d 4942 SV *name = sv_2mortal(newSVpv(path,0));
bd61b366 4943 return PerlIO_openn(aTHX_ NULL, mode, -1, 0, 0, f, 1, &name);
e87a358a
NIS		 4944}
4945
9e353e3b 4946#undef PerlIO_getc
6f9d8c32 4947int
9e353e3b 4948PerlIO_getc(PerlIO *f)
760ac839 4949{
e87a358a 4950 dTHX;
14a5cf38 4951 STDCHAR buf[1];
de009b76 4952 if ( 1 == PerlIO_read(f, buf, 1) ) {
14a5cf38
JH		 4953 return (unsigned char) buf[0];
4954 }
4955 return EOF;
313ca112
NIS		 4956}
4957
4958#undef PerlIO_ungetc
4959int
4960PerlIO_ungetc(PerlIO *f, int ch)
4961{
e87a358a 4962 dTHX;
14a5cf38
JH		 4963 if (ch != EOF) {
4964 STDCHAR buf = ch;
4965 if (PerlIO_unread(f, &buf, 1) == 1)
4966 return ch;
4967 }
4968 return EOF;
760ac839
LW		 4969}
4970
9e353e3b
NIS		 4971#undef PerlIO_putc
4972int
4973PerlIO_putc(PerlIO *f, int ch)
760ac839 4974{
e87a358a 4975 dTHX;
14a5cf38
JH		 4976 STDCHAR buf = ch;
4977 return PerlIO_write(f, &buf, 1);
760ac839
LW		 4978}
4979
9e353e3b 4980#undef PerlIO_puts
760ac839 4981int
9e353e3b 4982PerlIO_puts(PerlIO *f, const char *s)
760ac839 4983{
e87a358a 4984 dTHX;
dcda55fc 4985 return PerlIO_write(f, s, strlen(s));
760ac839
LW		 4986}
4987
4988#undef PerlIO_rewind
4989void
c78749f2 4990PerlIO_rewind(PerlIO *f)
760ac839 4991{
e87a358a 4992 dTHX;
14a5cf38
JH		 4993 PerlIO_seek(f, (Off_t) 0, SEEK_SET);
4994 PerlIO_clearerr(f);
6f9d8c32
NIS		 4995}
4996
4997#undef PerlIO_vprintf
4998int
4999PerlIO_vprintf(PerlIO *f, const char *fmt, va_list ap)
5000{
14a5cf38 5001 dTHX;
53ce71d3 5002 SV * sv;
b83604b4 5003 const char *s;
14a5cf38
JH		 5004 STRLEN len;
5005 SSize_t wrote;
2cc61e15 5006#ifdef NEED_VA_COPY
14a5cf38
JH		 5007 va_list apc;
5008 Perl_va_copy(ap, apc);
53ce71d3 5009 sv = vnewSVpvf(fmt, &apc);
d4825b27 5010 va_end(apc);
2cc61e15 5011#else
53ce71d3 5012 sv = vnewSVpvf(fmt, &ap);
2cc61e15 5013#endif
b83604b4 5014 s = SvPV_const(sv, len);
14a5cf38
JH		 5015 wrote = PerlIO_write(f, s, len);
5016 SvREFCNT_dec(sv);
5017 return wrote;
760ac839
LW		 5018}
5019
5020#undef PerlIO_printf
6f9d8c32 5021int
14a5cf38 5022PerlIO_printf(PerlIO *f, const char *fmt, ...)
760ac839 5023{
14a5cf38
JH		 5024 va_list ap;
5025 int result;
5026 va_start(ap, fmt);
5027 result = PerlIO_vprintf(f, fmt, ap);
5028 va_end(ap);
5029 return result;
760ac839
LW		 5030}
5031
5032#undef PerlIO_stdoutf
6f9d8c32 5033int
14a5cf38 5034PerlIO_stdoutf(const char *fmt, ...)
760ac839 5035{
e87a358a 5036 dTHX;
14a5cf38
JH		 5037 va_list ap;
5038 int result;
5039 va_start(ap, fmt);
5040 result = PerlIO_vprintf(PerlIO_stdout(), fmt, ap);
5041 va_end(ap);
5042 return result;
760ac839
LW		 5043}
5044
5045#undef PerlIO_tmpfile
5046PerlIO *
c78749f2 5047PerlIO_tmpfile(void)
760ac839 5048{
ae73d7ec
TC		 5049 return PerlIO_tmpfile_flags(0);
5050}
5051
5052#define MKOSTEMP_MODES ( O_RDWR | O_CREAT | O_EXCL )
5053#define MKOSTEMP_MODE_MASK ( O_ACCMODE | O_CREAT | O_EXCL | O_TRUNC )
5054
5055PerlIO *
5056PerlIO_tmpfile_flags(int imode)
5057{
dbf7dff6 5058#ifndef WIN32
2941a2e1 5059 dTHX;
dbf7dff6 5060#endif
2941a2e1 5061 PerlIO *f = NULL;
2941a2e1 5062#ifdef WIN32
04247234 5063 const int fd = win32_tmpfd_mode(imode);
2941a2e1
JH		 5064 if (fd >= 0)
5065 f = PerlIO_fdopen(fd, "w+b");
74b421cc 5066#elif ! defined(OS2)
0b99e986
RGS		 5067 int fd = -1;
5068 char tempname[] = "/tmp/PerlIO_XXXXXX";
284167a5 5069 const char * const tmpdir = TAINTING_get ? NULL : PerlEnv_getenv("TMPDIR");
525f6fe9 5070 SV * sv = NULL;
e57270be 5071 int old_umask = umask(0177);
ae73d7ec 5072 imode &= ~MKOSTEMP_MODE_MASK;
7299ca58 5073 if (tmpdir && *tmpdir) {
0b99e986 5074 /* if TMPDIR is set and not empty, we try that first */
7299ca58 5075 sv = newSVpv(tmpdir, 0);
0b99e986 5076 sv_catpv(sv, tempname + 4);
74b421cc 5077 fd = Perl_my_mkostemp_cloexec(SvPVX(sv), imode | O_VMS_DELETEONCLOSE);
0b99e986
RGS		 5078 }
5079 if (fd < 0) {
e40f8e80 5080 SvREFCNT_dec(sv);
7299ca58 5081 sv = NULL;
0b99e986 5082 /* else we try /tmp */
74b421cc 5083 fd = Perl_my_mkostemp_cloexec(tempname, imode | O_VMS_DELETEONCLOSE);
0b99e986 5084 }
b7561fc9
BF		 5085 if (fd < 0) {
5086 /* Try cwd */
5087 sv = newSVpvs(".");
5088 sv_catpv(sv, tempname + 4);
74b421cc 5089 fd = Perl_my_mkostemp_cloexec(SvPVX(sv), imode | O_VMS_DELETEONCLOSE);
b7561fc9 5090 }
60f7fc1e 5091 umask(old_umask);
2941a2e1 5092 if (fd >= 0) {
ae73d7ec
TC		 5093 /* fdopen() with a numeric mode */
5094 char mode[8];
5095 int writing = 1;
5096 (void)PerlIO_intmode2str(imode | MKOSTEMP_MODES, mode, &writing);
5097 f = PerlIO_fdopen(fd, mode);
2941a2e1
JH		 5098 if (f)
5099 PerlIOBase(f)->flags |= PERLIO_F_TEMP;
74b421cc 5100# ifndef VMS
0b99e986 5101 PerlLIO_unlink(sv ? SvPVX_const(sv) : tempname);
74b421cc 5102# endif
2941a2e1 5103 }
ef8d46e8 5104 SvREFCNT_dec(sv);
faf55891 5105#else /* !HAS_MKSTEMP, fallback to stdio tmpfile(). */
c4420975 5106 FILE * const stdio = PerlSIO_tmpfile();
2941a2e1 5107
085e731f
CB		 5108 if (stdio)
5109 f = PerlIO_fdopen(fileno(stdio), "w+");
5110
2941a2e1
JH		 5111#endif /* else WIN32 */
5112 return f;
760ac839
LW		 5113}
5114
0ea86a10
FC		 5115void
5116Perl_PerlIO_save_errno(pTHX_ PerlIO *f)
5117{
e9b8343f 5118 PERL_UNUSED_CONTEXT;
0ea86a10
FC		 5119 if (!PerlIOValid(f))
5120 return;
5121 PerlIOBase(f)->err = errno;
5122#ifdef VMS
5123 PerlIOBase(f)->os_err = vaxc$errno;
5124#elif defined(OS2)
5125 PerlIOBase(f)->os_err = Perl_rc;
5126#elif defined(WIN32)
5127 PerlIOBase(f)->os_err = GetLastError();
5128#endif
5129}
5130
5131void
5132Perl_PerlIO_restore_errno(pTHX_ PerlIO *f)
5133{
e9b8343f 5134 PERL_UNUSED_CONTEXT;
0ea86a10
FC		 5135 if (!PerlIOValid(f))
5136 return;
5137 SETERRNO(PerlIOBase(f)->err, PerlIOBase(f)->os_err);
5138#ifdef OS2
5139 Perl_rc = PerlIOBase(f)->os_err);
5140#elif defined(WIN32)
5141 SetLastError(PerlIOBase(f)->os_err);
5142#endif
5143}
5144
6f9d8c32
NIS		 5145#undef HAS_FSETPOS
5146#undef HAS_FGETPOS
5147
760ac839 5148
9e353e3b 5149/*======================================================================================*/
14a5cf38 5150/*
71200d45
NIS		 5151 * Now some functions in terms of above which may be needed even if we are
5152 * not in true PerlIO mode
9e353e3b 5153 */
188f0c84
YO		 5154const char *
5155Perl_PerlIO_context_layers(pTHX_ const char *mode)
5156{
8b850bd5
NC		 5157 const char *direction = NULL;
5158 SV *layers;
188f0c84
YO		 5159 /*
5160 * Need to supply default layer info from open.pm
5161 */
8b850bd5
NC		 5162
5163 if (!PL_curcop)
5164 return NULL;
5165
5166 if (mode && mode[0] != 'r') {
5167 if (PL_curcop->cop_hints & HINT_LEXICAL_IO_OUT)
5168 direction = "open>";
5169 } else {
5170 if (PL_curcop->cop_hints & HINT_LEXICAL_IO_IN)
5171 direction = "open<";
188f0c84 5172 }
8b850bd5
NC		 5173 if (!direction)
5174 return NULL;
5175
20439bc7 5176 layers = cop_hints_fetch_pvn(PL_curcop, direction, 5, 0, 0);
8b850bd5
NC		 5177
5178 assert(layers);
5179 return SvOK(layers) ? SvPV_nolen_const(layers) : NULL;
188f0c84
YO		 5180}
5181
9e353e3b 5182
760ac839
LW		 5183#ifndef HAS_FSETPOS
5184#undef PerlIO_setpos
5185int
766a733e 5186PerlIO_setpos(PerlIO *f, SV *pos)
760ac839 5187{
14a5cf38 5188 if (SvOK(pos)) {
e1a83e70
DD		 5189 if (f) {
5190 dTHX;
5191 STRLEN len;
5192 const Off_t * const posn = (Off_t *) SvPV(pos, len);
5193 if(len == sizeof(Off_t))
5194 return PerlIO_seek(f, *posn, SEEK_SET);
5195 }
14a5cf38 5196 }
93189314 5197 SETERRNO(EINVAL, SS_IVCHAN);
14a5cf38 5198 return -1;
760ac839 5199}
c411622e 5200#else
c411622e 5201#undef PerlIO_setpos
5202int
766a733e 5203PerlIO_setpos(PerlIO *f, SV *pos)
c411622e 5204{
14a5cf38 5205 if (SvOK(pos)) {
e1a83e70
DD		 5206 if (f) {
5207 dTHX;
5208 STRLEN len;
5209 Fpos_t * const fpos = (Fpos_t *) SvPV(pos, len);
5210 if(len == sizeof(Fpos_t))
2d4389e4 5211#if defined(USE_64_BIT_STDIO) && defined(USE_FSETPOS64)
e1a83e70 5212 return fsetpos64(f, fpos);
d9b3e12d 5213#else
e1a83e70 5214 return fsetpos(f, fpos);
d9b3e12d 5215#endif
14a5cf38 5216 }
766a733e 5217 }
93189314 5218 SETERRNO(EINVAL, SS_IVCHAN);
14a5cf38 5219 return -1;
c411622e 5220}
5221#endif
760ac839
LW		 5222
5223#ifndef HAS_FGETPOS
5224#undef PerlIO_getpos
5225int
766a733e 5226PerlIO_getpos(PerlIO *f, SV *pos)
760ac839 5227{
14a5cf38
JH		 5228 dTHX;
5229 Off_t posn = PerlIO_tell(f);
5230 sv_setpvn(pos, (char *) &posn, sizeof(posn));
5231 return (posn == (Off_t) - 1) ? -1 : 0;
760ac839 5232}
c411622e 5233#else
c411622e 5234#undef PerlIO_getpos
5235int
766a733e 5236PerlIO_getpos(PerlIO *f, SV *pos)
c411622e 5237{
14a5cf38
JH		 5238 dTHX;
5239 Fpos_t fpos;
5240 int code;
2d4389e4 5241#if defined(USE_64_BIT_STDIO) && defined(USE_FSETPOS64)
14a5cf38 5242 code = fgetpos64(f, &fpos);
d9b3e12d 5243#else
14a5cf38 5244 code = fgetpos(f, &fpos);
d9b3e12d 5245#endif
14a5cf38
JH		 5246 sv_setpvn(pos, (char *) &fpos, sizeof(fpos));
5247 return code;
c411622e 5248}
5249#endif
760ac839 5250
db6e00bd
DD		 5251/* print a failure format string message to stderr and fail exit the process
5252 using only libc without depending on any perl data structures being
5253 initialized.
5254*/
5255
5256void
5257Perl_noperl_die(const char* pat, ...)
5258{
fc917fff 5259 va_list arglist;
db6e00bd
DD		 5260 PERL_ARGS_ASSERT_NOPERL_DIE;
5261 va_start(arglist, pat);
5262 vfprintf(stderr, pat, arglist);
5263 va_end(arglist);
5264 exit(1);
5265}
5266
9cfa90c0 5267/*
14d04a33 5268 * ex: set ts=8 sts=4 sw=4 et:
37442d52 5269 */
Unnamed repository; edit this file 'description' to name the repository.