This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
perlfunc.pod - unite gmtime and localtime
[perl5.git] / util.c
CommitLineData
a0d0e21e 1/* util.c
a687059c 2 *
4bb101f2 3 * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,
b94e2f88 4 * 2000, 2001, 2002, 2003, 2004, 2005, 2006, by Larry Wall and others
a687059c 5 *
d48672a2
LW
6 * You may distribute under the terms of either the GNU General Public
7 * License or the Artistic License, as specified in the README file.
8d063cd8 8 *
8d063cd8 9 */
a0d0e21e
LW
10
11/*
12 * "Very useful, no doubt, that was to Saruman; yet it seems that he was
13 * not content." --Gandalf
14 */
8d063cd8 15
166f8a29
DM
16/* This file contains assorted utility routines.
17 * Which is a polite way of saying any stuff that people couldn't think of
18 * a better place for. Amongst other things, it includes the warning and
19 * dieing stuff, plus wrappers for malloc code.
20 */
21
8d063cd8 22#include "EXTERN.h"
864dbfa3 23#define PERL_IN_UTIL_C
8d063cd8 24#include "perl.h"
62b28dd9 25
64ca3a65 26#ifndef PERL_MICRO
a687059c 27#include <signal.h>
36477c24
PP
28#ifndef SIG_ERR
29# define SIG_ERR ((Sighandler_t) -1)
30#endif
64ca3a65 31#endif
36477c24 32
172d2248
OS
33#ifdef __Lynx__
34/* Missing protos on LynxOS */
35int putenv(char *);
36#endif
37
ff68c719
PP
38#ifdef I_SYS_WAIT
39# include <sys/wait.h>
40#endif
41
868439a2
JH
42#ifdef HAS_SELECT
43# ifdef I_SYS_SELECT
44# include <sys/select.h>
45# endif
46#endif
47
8d063cd8 48#define FLUSH
8d063cd8 49
16cebae2
GS
50#if defined(HAS_FCNTL) && defined(F_SETFD) && !defined(FD_CLOEXEC)
51# define FD_CLOEXEC 1 /* NeXT needs this */
52#endif
53
a687059c
LW
54/* NOTE: Do not call the next three routines directly. Use the macros
55 * in handy.h, so that we can easily redefine everything to do tracking of
56 * allocated hunks back to the original New to track down any memory leaks.
20cec16a 57 * XXX This advice seems to be widely ignored :-( --AD August 1996.
a687059c
LW
58 */
59
ca8d8976
NC
60static char *
61S_write_no_mem(pTHX)
62{
97aff369 63 dVAR;
ca8d8976
NC
64 /* Can't use PerlIO to write as it allocates memory */
65 PerlLIO_write(PerlIO_fileno(Perl_error_log),
66 PL_no_mem, strlen(PL_no_mem));
67 my_exit(1);
1f440eb2 68 NORETURN_FUNCTION_END;
ca8d8976
NC
69}
70
26fa51c3
AMS
71/* paranoid version of system's malloc() */
72
bd4080b3 73Malloc_t
4f63d024 74Perl_safesysmalloc(MEM_SIZE size)
8d063cd8 75{
54aff467 76 dTHX;
bd4080b3 77 Malloc_t ptr;
55497cff 78#ifdef HAS_64K_LIMIT
62b28dd9 79 if (size > 0xffff) {
bf49b057 80 PerlIO_printf(Perl_error_log,
16cebae2 81 "Allocation too large: %lx\n", size) FLUSH;
54aff467 82 my_exit(1);
62b28dd9 83 }
55497cff 84#endif /* HAS_64K_LIMIT */
e8dda941
JD
85#ifdef PERL_TRACK_MEMPOOL
86 size += sTHX;
87#endif
34de22dd
LW
88#ifdef DEBUGGING
89 if ((long)size < 0)
4f63d024 90 Perl_croak_nocontext("panic: malloc");
34de22dd 91#endif
12ae5dfc 92 ptr = (Malloc_t)PerlMem_malloc(size?size:1); /* malloc(0) is NASTY on our system */
da927450 93 PERL_ALLOC_CHECK(ptr);
97835f67 94 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) malloc %ld bytes\n",PTR2UV(ptr),(long)PL_an++,(long)size));
bd61b366 95 if (ptr != NULL) {
e8dda941 96#ifdef PERL_TRACK_MEMPOOL
7cb608b5
NC
97 struct perl_memory_debug_header *const header
98 = (struct perl_memory_debug_header *)ptr;
9a083ecf
NC
99#endif
100
101#ifdef PERL_POISON
7e337ee0 102 PoisonNew(((char *)ptr), size, char);
9a083ecf 103#endif
7cb608b5 104
9a083ecf 105#ifdef PERL_TRACK_MEMPOOL
7cb608b5
NC
106 header->interpreter = aTHX;
107 /* Link us into the list. */
108 header->prev = &PL_memory_debug_header;
109 header->next = PL_memory_debug_header.next;
110 PL_memory_debug_header.next = header;
111 header->next->prev = header;
cd1541b2 112# ifdef PERL_POISON
7cb608b5 113 header->size = size;
cd1541b2 114# endif
e8dda941
JD
115 ptr = (Malloc_t)((char*)ptr+sTHX);
116#endif
8d063cd8 117 return ptr;
e8dda941 118}
3280af22 119 else if (PL_nomemok)
bd61b366 120 return NULL;
8d063cd8 121 else {
0bd48802 122 return write_no_mem();
8d063cd8
LW
123 }
124 /*NOTREACHED*/
125}
126
f2517201 127/* paranoid version of system's realloc() */
8d063cd8 128
bd4080b3 129Malloc_t
4f63d024 130Perl_safesysrealloc(Malloc_t where,MEM_SIZE size)
8d063cd8 131{
54aff467 132 dTHX;
bd4080b3 133 Malloc_t ptr;
9a34ef1d 134#if !defined(STANDARD_C) && !defined(HAS_REALLOC_PROTOTYPE) && !defined(PERL_MICRO)
6ad3d225 135 Malloc_t PerlMem_realloc();
ecfc5424 136#endif /* !defined(STANDARD_C) && !defined(HAS_REALLOC_PROTOTYPE) */
8d063cd8 137
a1d180c4 138#ifdef HAS_64K_LIMIT
5f05dabc 139 if (size > 0xffff) {
bf49b057 140 PerlIO_printf(Perl_error_log,
5f05dabc 141 "Reallocation too large: %lx\n", size) FLUSH;
54aff467 142 my_exit(1);
5f05dabc 143 }
55497cff 144#endif /* HAS_64K_LIMIT */
7614df0c 145 if (!size) {
f2517201 146 safesysfree(where);
7614df0c
JD
147 return NULL;
148 }
149
378cc40b 150 if (!where)
f2517201 151 return safesysmalloc(size);
e8dda941
JD
152#ifdef PERL_TRACK_MEMPOOL
153 where = (Malloc_t)((char*)where-sTHX);
154 size += sTHX;
7cb608b5
NC
155 {
156 struct perl_memory_debug_header *const header
157 = (struct perl_memory_debug_header *)where;
158
159 if (header->interpreter != aTHX) {
160 Perl_croak_nocontext("panic: realloc from wrong pool");
161 }
162 assert(header->next->prev == header);
163 assert(header->prev->next == header);
cd1541b2 164# ifdef PERL_POISON
7cb608b5
NC
165 if (header->size > size) {
166 const MEM_SIZE freed_up = header->size - size;
167 char *start_of_freed = ((char *)where) + size;
7e337ee0 168 PoisonFree(start_of_freed, freed_up, char);
7cb608b5
NC
169 }
170 header->size = size;
cd1541b2 171# endif
7cb608b5 172 }
e8dda941 173#endif
34de22dd
LW
174#ifdef DEBUGGING
175 if ((long)size < 0)
4f63d024 176 Perl_croak_nocontext("panic: realloc");
34de22dd 177#endif
12ae5dfc 178 ptr = (Malloc_t)PerlMem_realloc(where,size);
da927450 179 PERL_ALLOC_CHECK(ptr);
a1d180c4 180
97835f67
JH
181 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) rfree\n",PTR2UV(where),(long)PL_an++));
182 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) realloc %ld bytes\n",PTR2UV(ptr),(long)PL_an++,(long)size));
79072805 183
bd61b366 184 if (ptr != NULL) {
e8dda941 185#ifdef PERL_TRACK_MEMPOOL
7cb608b5
NC
186 struct perl_memory_debug_header *const header
187 = (struct perl_memory_debug_header *)ptr;
188
9a083ecf
NC
189# ifdef PERL_POISON
190 if (header->size < size) {
191 const MEM_SIZE fresh = size - header->size;
192 char *start_of_fresh = ((char *)ptr) + size;
7e337ee0 193 PoisonNew(start_of_fresh, fresh, char);
9a083ecf
NC
194 }
195# endif
196
7cb608b5
NC
197 header->next->prev = header;
198 header->prev->next = header;
199
e8dda941
JD
200 ptr = (Malloc_t)((char*)ptr+sTHX);
201#endif
8d063cd8 202 return ptr;
e8dda941 203 }
3280af22 204 else if (PL_nomemok)
bd61b366 205 return NULL;
8d063cd8 206 else {
0bd48802 207 return write_no_mem();
8d063cd8
LW
208 }
209 /*NOTREACHED*/
210}
211
f2517201 212/* safe version of system's free() */
8d063cd8 213
54310121 214Free_t
4f63d024 215Perl_safesysfree(Malloc_t where)
8d063cd8 216{
e8dda941 217#if defined(PERL_IMPLICIT_SYS) || defined(PERL_TRACK_MEMPOOL)
54aff467 218 dTHX;
97aff369
JH
219#else
220 dVAR;
155aba94 221#endif
97835f67 222 DEBUG_m( PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) free\n",PTR2UV(where),(long)PL_an++));
378cc40b 223 if (where) {
e8dda941
JD
224#ifdef PERL_TRACK_MEMPOOL
225 where = (Malloc_t)((char*)where-sTHX);
cd1541b2 226 {
7cb608b5
NC
227 struct perl_memory_debug_header *const header
228 = (struct perl_memory_debug_header *)where;
229
230 if (header->interpreter != aTHX) {
231 Perl_croak_nocontext("panic: free from wrong pool");
232 }
233 if (!header->prev) {
cd1541b2
NC
234 Perl_croak_nocontext("panic: duplicate free");
235 }
7cb608b5
NC
236 if (!(header->next) || header->next->prev != header
237 || header->prev->next != header) {
238 Perl_croak_nocontext("panic: bad free");
cd1541b2 239 }
7cb608b5
NC
240 /* Unlink us from the chain. */
241 header->next->prev = header->prev;
242 header->prev->next = header->next;
243# ifdef PERL_POISON
7e337ee0 244 PoisonNew(where, header->size, char);
cd1541b2 245# endif
7cb608b5
NC
246 /* Trigger the duplicate free warning. */
247 header->next = NULL;
248 }
e8dda941 249#endif
6ad3d225 250 PerlMem_free(where);
378cc40b 251 }
8d063cd8
LW
252}
253
f2517201 254/* safe version of system's calloc() */
1050c9ca 255
bd4080b3 256Malloc_t
4f63d024 257Perl_safesyscalloc(MEM_SIZE count, MEM_SIZE size)
1050c9ca 258{
54aff467 259 dTHX;
bd4080b3 260 Malloc_t ptr;
1050c9ca 261
55497cff 262#ifdef HAS_64K_LIMIT
5f05dabc 263 if (size * count > 0xffff) {
bf49b057 264 PerlIO_printf(Perl_error_log,
5f05dabc 265 "Allocation too large: %lx\n", size * count) FLUSH;
54aff467 266 my_exit(1);
5f05dabc 267 }
55497cff 268#endif /* HAS_64K_LIMIT */
1050c9ca
PP
269#ifdef DEBUGGING
270 if ((long)size < 0 || (long)count < 0)
4f63d024 271 Perl_croak_nocontext("panic: calloc");
1050c9ca 272#endif
0b7c1c42 273 size *= count;
e8dda941
JD
274#ifdef PERL_TRACK_MEMPOOL
275 size += sTHX;
276#endif
12ae5dfc 277 ptr = (Malloc_t)PerlMem_malloc(size?size:1); /* malloc(0) is NASTY on our system */
da927450 278 PERL_ALLOC_CHECK(ptr);
97835f67 279 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) calloc %ld x %ld bytes\n",PTR2UV(ptr),(long)PL_an++,(long)count,(long)size));
bd61b366 280 if (ptr != NULL) {
1050c9ca 281 memset((void*)ptr, 0, size);
e8dda941 282#ifdef PERL_TRACK_MEMPOOL
7cb608b5
NC
283 {
284 struct perl_memory_debug_header *const header
285 = (struct perl_memory_debug_header *)ptr;
286
287 header->interpreter = aTHX;
288 /* Link us into the list. */
289 header->prev = &PL_memory_debug_header;
290 header->next = PL_memory_debug_header.next;
291 PL_memory_debug_header.next = header;
292 header->next->prev = header;
cd1541b2 293# ifdef PERL_POISON
7cb608b5 294 header->size = size;
cd1541b2 295# endif
7cb608b5
NC
296 ptr = (Malloc_t)((char*)ptr+sTHX);
297 }
e8dda941 298#endif
1050c9ca
PP
299 return ptr;
300 }
3280af22 301 else if (PL_nomemok)
bd61b366 302 return NULL;
0bd48802 303 return write_no_mem();
1050c9ca
PP
304}
305
cae6d0e5
GS
306/* These must be defined when not using Perl's malloc for binary
307 * compatibility */
308
309#ifndef MYMALLOC
310
311Malloc_t Perl_malloc (MEM_SIZE nbytes)
312{
313 dTHXs;
077a72a9 314 return (Malloc_t)PerlMem_malloc(nbytes);
cae6d0e5
GS
315}
316
317Malloc_t Perl_calloc (MEM_SIZE elements, MEM_SIZE size)
318{
319 dTHXs;
077a72a9 320 return (Malloc_t)PerlMem_calloc(elements, size);
cae6d0e5
GS
321}
322
323Malloc_t Perl_realloc (Malloc_t where, MEM_SIZE nbytes)
324{
325 dTHXs;
077a72a9 326 return (Malloc_t)PerlMem_realloc(where, nbytes);
cae6d0e5
GS
327}
328
329Free_t Perl_mfree (Malloc_t where)
330{
331 dTHXs;
332 PerlMem_free(where);
333}
334
335#endif
336
8d063cd8
LW
337/* copy a string up to some (non-backslashed) delimiter, if any */
338
339char *
e1ec3a88 340Perl_delimcpy(pTHX_ register char *to, register const char *toend, register const char *from, register const char *fromend, register int delim, I32 *retlen)
8d063cd8 341{
fc36a67e 342 register I32 tolen;
96a5add6 343 PERL_UNUSED_CONTEXT;
35da51f7 344
fc36a67e 345 for (tolen = 0; from < fromend; from++, tolen++) {
378cc40b 346 if (*from == '\\') {
35da51f7 347 if (from[1] != delim) {
fc36a67e
PP
348 if (to < toend)
349 *to++ = *from;
350 tolen++;
fc36a67e 351 }
35da51f7 352 from++;
378cc40b 353 }
bedebaa5 354 else if (*from == delim)
8d063cd8 355 break;
fc36a67e
PP
356 if (to < toend)
357 *to++ = *from;
8d063cd8 358 }
bedebaa5
CS
359 if (to < toend)
360 *to = '\0';
fc36a67e 361 *retlen = tolen;
73d840c0 362 return (char *)from;
8d063cd8
LW
363}
364
365/* return ptr to little string in big string, NULL if not found */
378cc40b 366/* This routine was donated by Corey Satten. */
8d063cd8
LW
367
368char *
864dbfa3 369Perl_instr(pTHX_ register const char *big, register const char *little)
378cc40b 370{
79072805 371 register I32 first;
96a5add6 372 PERL_UNUSED_CONTEXT;
378cc40b 373
a687059c 374 if (!little)
08105a92 375 return (char*)big;
a687059c 376 first = *little++;
378cc40b 377 if (!first)
08105a92 378 return (char*)big;
378cc40b 379 while (*big) {
66a1b24b 380 register const char *s, *x;
378cc40b
LW
381 if (*big++ != first)
382 continue;
383 for (x=big,s=little; *s; /**/ ) {
384 if (!*x)
bd61b366 385 return NULL;
4fc877ac 386 if (*s != *x)
378cc40b 387 break;
4fc877ac
AL
388 else {
389 s++;
390 x++;
378cc40b
LW
391 }
392 }
393 if (!*s)
08105a92 394 return (char*)(big-1);
378cc40b 395 }
bd61b366 396 return NULL;
378cc40b 397}
8d063cd8 398
a687059c
LW
399/* same as instr but allow embedded nulls */
400
401char *
4c8626be 402Perl_ninstr(pTHX_ const char *big, const char *bigend, const char *little, const char *lend)
8d063cd8 403{
96a5add6 404 PERL_UNUSED_CONTEXT;
4c8626be
GA
405 if (little >= lend)
406 return (char*)big;
407 {
408 char first = *little++;
409 const char *s, *x;
410 bigend -= lend - little;
411 OUTER:
412 while (big <= bigend) {
413 if (*big++ != first)
414 goto OUTER;
415 for (x=big,s=little; s < lend; x++,s++) {
416 if (*s != *x)
417 goto OUTER;
418 }
419 return (char*)(big-1);
420 }
378cc40b 421 }
bd61b366 422 return NULL;
a687059c
LW
423}
424
425/* reverse of the above--find last substring */
426
427char *
864dbfa3 428Perl_rninstr(pTHX_ register const char *big, const char *bigend, const char *little, const char *lend)
a687059c 429{
08105a92 430 register const char *bigbeg;
e1ec3a88 431 register const I32 first = *little;
7452cf6a 432 register const char * const littleend = lend;
96a5add6 433 PERL_UNUSED_CONTEXT;
a687059c 434
260d78c9 435 if (little >= littleend)
08105a92 436 return (char*)bigend;
a687059c
LW
437 bigbeg = big;
438 big = bigend - (littleend - little++);
439 while (big >= bigbeg) {
66a1b24b 440 register const char *s, *x;
a687059c
LW
441 if (*big-- != first)
442 continue;
443 for (x=big+2,s=little; s < littleend; /**/ ) {
4fc877ac 444 if (*s != *x)
a687059c 445 break;
4fc877ac
AL
446 else {
447 x++;
448 s++;
a687059c
LW
449 }
450 }
451 if (s >= littleend)
08105a92 452 return (char*)(big+1);
378cc40b 453 }
bd61b366 454 return NULL;
378cc40b 455}
a687059c 456
cf93c79d
IZ
457#define FBM_TABLE_OFFSET 2 /* Number of bytes between EOS and table*/
458
459/* As a space optimization, we do not compile tables for strings of length
460 0 and 1, and for strings of length 2 unless FBMcf_TAIL. These are
461 special-cased in fbm_instr().
462
463 If FBMcf_TAIL, the table is created as if the string has a trailing \n. */
464
954c1994 465/*
ccfc67b7
JH
466=head1 Miscellaneous Functions
467
954c1994
GS
468=for apidoc fbm_compile
469
470Analyses the string in order to make fast searches on it using fbm_instr()
471-- the Boyer-Moore algorithm.
472
473=cut
474*/
475
378cc40b 476void
7506f9c3 477Perl_fbm_compile(pTHX_ SV *sv, U32 flags)
378cc40b 478{
97aff369 479 dVAR;
0d46e09a 480 register const U8 *s;
79072805 481 register U32 i;
0b71040e 482 STRLEN len;
79072805
LW
483 I32 rarest = 0;
484 U32 frequency = 256;
485
c517dc2b 486 if (flags & FBMcf_TAIL) {
890ce7af 487 MAGIC * const mg = SvUTF8(sv) && SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_utf8) : NULL;
396482e1 488 sv_catpvs(sv, "\n"); /* Taken into account in fbm_instr() */
c517dc2b
JH
489 if (mg && mg->mg_len >= 0)
490 mg->mg_len++;
491 }
9cbe880b 492 s = (U8*)SvPV_force_mutable(sv, len);
862a34c6 493 SvUPGRADE(sv, SVt_PVBM);
d1be9408 494 if (len == 0) /* TAIL might be on a zero-length string. */
cf93c79d 495 return;
02128f11 496 if (len > 2) {
9cbe880b 497 const unsigned char *sb;
66a1b24b 498 const U8 mlen = (len>255) ? 255 : (U8)len;
890ce7af 499 register U8 *table;
cf93c79d 500
7506f9c3 501 Sv_Grow(sv, len + 256 + FBM_TABLE_OFFSET);
9cbe880b 502 table = (unsigned char*)(SvPVX_mutable(sv) + len + FBM_TABLE_OFFSET);
7506f9c3
GS
503 s = table - 1 - FBM_TABLE_OFFSET; /* last char */
504 memset((void*)table, mlen, 256);
505 table[-1] = (U8)flags;
02128f11 506 i = 0;
7506f9c3 507 sb = s - mlen + 1; /* first char (maybe) */
cf93c79d
IZ
508 while (s >= sb) {
509 if (table[*s] == mlen)
7506f9c3 510 table[*s] = (U8)i;
cf93c79d
IZ
511 s--, i++;
512 }
378cc40b 513 }
a0714e2c 514 sv_magic(sv, NULL, PERL_MAGIC_bm, NULL, 0); /* deep magic */
79072805 515 SvVALID_on(sv);
378cc40b 516
9cbe880b 517 s = (const unsigned char*)(SvPVX_const(sv)); /* deeper magic */
bbce6d69 518 for (i = 0; i < len; i++) {
22c35a8c 519 if (PL_freq[s[i]] < frequency) {
bbce6d69 520 rarest = i;
22c35a8c 521 frequency = PL_freq[s[i]];
378cc40b
LW
522 }
523 }
79072805 524 BmRARE(sv) = s[rarest];
eb160463 525 BmPREVIOUS(sv) = (U16)rarest;
cf93c79d
IZ
526 BmUSEFUL(sv) = 100; /* Initial value */
527 if (flags & FBMcf_TAIL)
528 SvTAIL_on(sv);
7506f9c3
GS
529 DEBUG_r(PerlIO_printf(Perl_debug_log, "rarest char %c at %d\n",
530 BmRARE(sv),BmPREVIOUS(sv)));
378cc40b
LW
531}
532
cf93c79d
IZ
533/* If SvTAIL(littlestr), it has a fake '\n' at end. */
534/* If SvTAIL is actually due to \Z or \z, this gives false positives
535 if multiline */
536
954c1994
GS
537/*
538=for apidoc fbm_instr
539
540Returns the location of the SV in the string delimited by C<str> and
bd61b366 541C<strend>. It returns C<NULL> if the string can't be found. The C<sv>
954c1994
GS
542does not have to be fbm_compiled, but the search will not be as fast
543then.
544
545=cut
546*/
547
378cc40b 548char *
864dbfa3 549Perl_fbm_instr(pTHX_ unsigned char *big, register unsigned char *bigend, SV *littlestr, U32 flags)
378cc40b 550{
a687059c 551 register unsigned char *s;
cf93c79d 552 STRLEN l;
9cbe880b
NC
553 register const unsigned char *little
554 = (const unsigned char *)SvPV_const(littlestr,l);
cf93c79d 555 register STRLEN littlelen = l;
e1ec3a88 556 register const I32 multiline = flags & FBMrf_MULTILINE;
cf93c79d 557
eb160463 558 if ((STRLEN)(bigend - big) < littlelen) {
a1d180c4 559 if ( SvTAIL(littlestr)
eb160463 560 && ((STRLEN)(bigend - big) == littlelen - 1)
a1d180c4 561 && (littlelen == 1
12ae5dfc 562 || (*big == *little &&
27da23d5 563 memEQ((char *)big, (char *)little, littlelen - 1))))
cf93c79d 564 return (char*)big;
bd61b366 565 return NULL;
cf93c79d 566 }
378cc40b 567
cf93c79d 568 if (littlelen <= 2) { /* Special-cased */
cf93c79d
IZ
569
570 if (littlelen == 1) {
571 if (SvTAIL(littlestr) && !multiline) { /* Anchor only! */
572 /* Know that bigend != big. */
573 if (bigend[-1] == '\n')
574 return (char *)(bigend - 1);
575 return (char *) bigend;
576 }
577 s = big;
578 while (s < bigend) {
579 if (*s == *little)
580 return (char *)s;
581 s++;
582 }
583 if (SvTAIL(littlestr))
584 return (char *) bigend;
bd61b366 585 return NULL;
cf93c79d
IZ
586 }
587 if (!littlelen)
588 return (char*)big; /* Cannot be SvTAIL! */
589
590 /* littlelen is 2 */
591 if (SvTAIL(littlestr) && !multiline) {
592 if (bigend[-1] == '\n' && bigend[-2] == *little)
593 return (char*)bigend - 2;
594 if (bigend[-1] == *little)
595 return (char*)bigend - 1;
bd61b366 596 return NULL;
cf93c79d
IZ
597 }
598 {
599 /* This should be better than FBM if c1 == c2, and almost
600 as good otherwise: maybe better since we do less indirection.
601 And we save a lot of memory by caching no table. */
66a1b24b
AL
602 const unsigned char c1 = little[0];
603 const unsigned char c2 = little[1];
cf93c79d
IZ
604
605 s = big + 1;
606 bigend--;
607 if (c1 != c2) {
608 while (s <= bigend) {
609 if (s[0] == c2) {
610 if (s[-1] == c1)
611 return (char*)s - 1;
612 s += 2;
613 continue;
3fe6f2dc 614 }
cf93c79d
IZ
615 next_chars:
616 if (s[0] == c1) {
617 if (s == bigend)
618 goto check_1char_anchor;
619 if (s[1] == c2)
620 return (char*)s;
621 else {
622 s++;
623 goto next_chars;
624 }
625 }
626 else
627 s += 2;
628 }
629 goto check_1char_anchor;
630 }
631 /* Now c1 == c2 */
632 while (s <= bigend) {
633 if (s[0] == c1) {
634 if (s[-1] == c1)
635 return (char*)s - 1;
636 if (s == bigend)
637 goto check_1char_anchor;
638 if (s[1] == c1)
639 return (char*)s;
640 s += 3;
02128f11 641 }
c277df42 642 else
cf93c79d 643 s += 2;
c277df42 644 }
c277df42 645 }
cf93c79d
IZ
646 check_1char_anchor: /* One char and anchor! */
647 if (SvTAIL(littlestr) && (*bigend == *little))
648 return (char *)bigend; /* bigend is already decremented. */
bd61b366 649 return NULL;
d48672a2 650 }
cf93c79d 651 if (SvTAIL(littlestr) && !multiline) { /* tail anchored? */
bbce6d69 652 s = bigend - littlelen;
a1d180c4 653 if (s >= big && bigend[-1] == '\n' && *s == *little
cf93c79d
IZ
654 /* Automatically of length > 2 */
655 && memEQ((char*)s + 1, (char*)little + 1, littlelen - 2))
7506f9c3 656 {
bbce6d69 657 return (char*)s; /* how sweet it is */
7506f9c3
GS
658 }
659 if (s[1] == *little
660 && memEQ((char*)s + 2, (char*)little + 1, littlelen - 2))
661 {
cf93c79d 662 return (char*)s + 1; /* how sweet it is */
7506f9c3 663 }
bd61b366 664 return NULL;
02128f11 665 }
cf93c79d 666 if (SvTYPE(littlestr) != SVt_PVBM || !SvVALID(littlestr)) {
c4420975 667 char * const b = ninstr((char*)big,(char*)bigend,
cf93c79d
IZ
668 (char*)little, (char*)little + littlelen);
669
670 if (!b && SvTAIL(littlestr)) { /* Automatically multiline! */
671 /* Chop \n from littlestr: */
672 s = bigend - littlelen + 1;
7506f9c3
GS
673 if (*s == *little
674 && memEQ((char*)s + 1, (char*)little + 1, littlelen - 2))
675 {
3fe6f2dc 676 return (char*)s;
7506f9c3 677 }
bd61b366 678 return NULL;
a687059c 679 }
cf93c79d 680 return b;
a687059c 681 }
a1d180c4 682
cf93c79d 683 { /* Do actual FBM. */
c4420975 684 register const unsigned char * const table = little + littlelen + FBM_TABLE_OFFSET;
0d46e09a 685 register const unsigned char *oldlittle;
cf93c79d 686
eb160463 687 if (littlelen > (STRLEN)(bigend - big))
bd61b366 688 return NULL;
cf93c79d
IZ
689 --littlelen; /* Last char found by table lookup */
690
691 s = big + littlelen;
692 little += littlelen; /* last char */
693 oldlittle = little;
694 if (s < bigend) {
695 register I32 tmp;
696
697 top2:
7506f9c3 698 if ((tmp = table[*s])) {
cf93c79d 699 if ((s += tmp) < bigend)
62b28dd9 700 goto top2;
cf93c79d
IZ
701 goto check_end;
702 }
703 else { /* less expensive than calling strncmp() */
66a1b24b 704 register unsigned char * const olds = s;
cf93c79d
IZ
705
706 tmp = littlelen;
707
708 while (tmp--) {
709 if (*--s == *--little)
710 continue;
cf93c79d
IZ
711 s = olds + 1; /* here we pay the price for failure */
712 little = oldlittle;
713 if (s < bigend) /* fake up continue to outer loop */
714 goto top2;
715 goto check_end;
716 }
717 return (char *)s;
a687059c 718 }
378cc40b 719 }
cf93c79d
IZ
720 check_end:
721 if ( s == bigend && (table[-1] & FBMcf_TAIL)
12ae5dfc
JH
722 && memEQ((char *)(bigend - littlelen),
723 (char *)(oldlittle - littlelen), littlelen) )
cf93c79d 724 return (char*)bigend - littlelen;
bd61b366 725 return NULL;
378cc40b 726 }
378cc40b
LW
727}
728
c277df42
IZ
729/* start_shift, end_shift are positive quantities which give offsets
730 of ends of some substring of bigstr.
a0288114 731 If "last" we want the last occurrence.
c277df42 732 old_posp is the way of communication between consequent calls if
a1d180c4 733 the next call needs to find the .
c277df42 734 The initial *old_posp should be -1.
cf93c79d
IZ
735
736 Note that we take into account SvTAIL, so one can get extra
737 optimizations if _ALL flag is set.
c277df42
IZ
738 */
739
cf93c79d 740/* If SvTAIL is actually due to \Z or \z, this gives false positives
26fa51c3 741 if PL_multiline. In fact if !PL_multiline the authoritative answer
cf93c79d
IZ
742 is not supported yet. */
743
378cc40b 744char *
864dbfa3 745Perl_screaminstr(pTHX_ SV *bigstr, SV *littlestr, I32 start_shift, I32 end_shift, I32 *old_posp, I32 last)
378cc40b 746{
97aff369 747 dVAR;
0d46e09a 748 register const unsigned char *big;
79072805
LW
749 register I32 pos;
750 register I32 previous;
751 register I32 first;
0d46e09a 752 register const unsigned char *little;
c277df42 753 register I32 stop_pos;
0d46e09a 754 register const unsigned char *littleend;
c277df42 755 I32 found = 0;
378cc40b 756
c277df42 757 if (*old_posp == -1
3280af22 758 ? (pos = PL_screamfirst[BmRARE(littlestr)]) < 0
cf93c79d
IZ
759 : (((pos = *old_posp), pos += PL_screamnext[pos]) == 0)) {
760 cant_find:
a1d180c4 761 if ( BmRARE(littlestr) == '\n'
cf93c79d 762 && BmPREVIOUS(littlestr) == SvCUR(littlestr) - 1) {
cfd0369c 763 little = (const unsigned char *)(SvPVX_const(littlestr));
cf93c79d
IZ
764 littleend = little + SvCUR(littlestr);
765 first = *little++;
766 goto check_tail;
767 }
bd61b366 768 return NULL;
cf93c79d
IZ
769 }
770
cfd0369c 771 little = (const unsigned char *)(SvPVX_const(littlestr));
79072805 772 littleend = little + SvCUR(littlestr);
378cc40b 773 first = *little++;
c277df42 774 /* The value of pos we can start at: */
79072805 775 previous = BmPREVIOUS(littlestr);
cfd0369c 776 big = (const unsigned char *)(SvPVX_const(bigstr));
c277df42
IZ
777 /* The value of pos we can stop at: */
778 stop_pos = SvCUR(bigstr) - end_shift - (SvCUR(littlestr) - 1 - previous);
cf93c79d 779 if (previous + start_shift > stop_pos) {
0fe87f7c
HS
780/*
781 stop_pos does not include SvTAIL in the count, so this check is incorrect
782 (I think) - see [ID 20010618.006] and t/op/study.t. HVDS 2001/06/19
783*/
784#if 0
cf93c79d
IZ
785 if (previous + start_shift == stop_pos + 1) /* A fake '\n'? */
786 goto check_tail;
0fe87f7c 787#endif
bd61b366 788 return NULL;
cf93c79d 789 }
c277df42 790 while (pos < previous + start_shift) {
3280af22 791 if (!(pos += PL_screamnext[pos]))
cf93c79d 792 goto cant_find;
378cc40b 793 }
de3bb511 794 big -= previous;
bbce6d69 795 do {
0d46e09a 796 register const unsigned char *s, *x;
ef64f398 797 if (pos >= stop_pos) break;
bbce6d69
PP
798 if (big[pos] != first)
799 continue;
800 for (x=big+pos+1,s=little; s < littleend; /**/ ) {
bbce6d69
PP
801 if (*s++ != *x++) {
802 s--;
803 break;
378cc40b 804 }
bbce6d69 805 }
c277df42
IZ
806 if (s == littleend) {
807 *old_posp = pos;
808 if (!last) return (char *)(big+pos);
809 found = 1;
810 }
3280af22 811 } while ( pos += PL_screamnext[pos] );
a1d180c4 812 if (last && found)
cf93c79d 813 return (char *)(big+(*old_posp));
cf93c79d
IZ
814 check_tail:
815 if (!SvTAIL(littlestr) || (end_shift > 0))
bd61b366 816 return NULL;
cf93c79d 817 /* Ignore the trailing "\n". This code is not microoptimized */
cfd0369c 818 big = (const unsigned char *)(SvPVX_const(bigstr) + SvCUR(bigstr));
cf93c79d
IZ
819 stop_pos = littleend - little; /* Actual littlestr len */
820 if (stop_pos == 0)
821 return (char*)big;
822 big -= stop_pos;
823 if (*big == first
12ae5dfc
JH
824 && ((stop_pos == 1) ||
825 memEQ((char *)(big + 1), (char *)little, stop_pos - 1)))
cf93c79d 826 return (char*)big;
bd61b366 827 return NULL;
8d063cd8
LW
828}
829
79072805 830I32
864dbfa3 831Perl_ibcmp(pTHX_ const char *s1, const char *s2, register I32 len)
79072805 832{
e1ec3a88
AL
833 register const U8 *a = (const U8 *)s1;
834 register const U8 *b = (const U8 *)s2;
96a5add6
AL
835 PERL_UNUSED_CONTEXT;
836
79072805 837 while (len--) {
22c35a8c 838 if (*a != *b && *a != PL_fold[*b])
bbce6d69
PP
839 return 1;
840 a++,b++;
841 }
842 return 0;
843}
844
845I32
864dbfa3 846Perl_ibcmp_locale(pTHX_ const char *s1, const char *s2, register I32 len)
bbce6d69 847{
27da23d5 848 dVAR;
e1ec3a88
AL
849 register const U8 *a = (const U8 *)s1;
850 register const U8 *b = (const U8 *)s2;
96a5add6
AL
851 PERL_UNUSED_CONTEXT;
852
bbce6d69 853 while (len--) {
22c35a8c 854 if (*a != *b && *a != PL_fold_locale[*b])
bbce6d69
PP
855 return 1;
856 a++,b++;
79072805
LW
857 }
858 return 0;
859}
860
8d063cd8
LW
861/* copy a string to a safe spot */
862
954c1994 863/*
ccfc67b7
JH
864=head1 Memory Management
865
954c1994
GS
866=for apidoc savepv
867
61a925ed
AMS
868Perl's version of C<strdup()>. Returns a pointer to a newly allocated
869string which is a duplicate of C<pv>. The size of the string is
870determined by C<strlen()>. The memory allocated for the new string can
871be freed with the C<Safefree()> function.
954c1994
GS
872
873=cut
874*/
875
8d063cd8 876char *
efdfce31 877Perl_savepv(pTHX_ const char *pv)
8d063cd8 878{
96a5add6 879 PERL_UNUSED_CONTEXT;
e90e2364 880 if (!pv)
bd61b366 881 return NULL;
66a1b24b
AL
882 else {
883 char *newaddr;
884 const STRLEN pvlen = strlen(pv)+1;
a02a5408 885 Newx(newaddr,pvlen,char);
490a0e98 886 return memcpy(newaddr,pv,pvlen);
66a1b24b 887 }
8d063cd8
LW
888}
889
a687059c
LW
890/* same thing but with a known length */
891
954c1994
GS
892/*
893=for apidoc savepvn
894
61a925ed
AMS
895Perl's version of what C<strndup()> would be if it existed. Returns a
896pointer to a newly allocated string which is a duplicate of the first
cbf82dd0
NC
897C<len> bytes from C<pv>, plus a trailing NUL byte. The memory allocated for
898the new string can be freed with the C<Safefree()> function.
954c1994
GS
899
900=cut
901*/
902
a687059c 903char *
efdfce31 904Perl_savepvn(pTHX_ const char *pv, register I32 len)
a687059c
LW
905{
906 register char *newaddr;
96a5add6 907 PERL_UNUSED_CONTEXT;
a687059c 908
a02a5408 909 Newx(newaddr,len+1,char);
92110913 910 /* Give a meaning to NULL pointer mainly for the use in sv_magic() */
efdfce31 911 if (pv) {
e90e2364
NC
912 /* might not be null terminated */
913 newaddr[len] = '\0';
07409e01 914 return (char *) CopyD(pv,newaddr,len,char);
92110913
NIS
915 }
916 else {
07409e01 917 return (char *) ZeroD(newaddr,len+1,char);
92110913 918 }
a687059c
LW
919}
920
05ec9bb3
NIS
921/*
922=for apidoc savesharedpv
923
61a925ed
AMS
924A version of C<savepv()> which allocates the duplicate string in memory
925which is shared between threads.
05ec9bb3
NIS
926
927=cut
928*/
929char *
efdfce31 930Perl_savesharedpv(pTHX_ const char *pv)
05ec9bb3 931{
e90e2364 932 register char *newaddr;
490a0e98 933 STRLEN pvlen;
e90e2364 934 if (!pv)
bd61b366 935 return NULL;
e90e2364 936
490a0e98
NC
937 pvlen = strlen(pv)+1;
938 newaddr = (char*)PerlMemShared_malloc(pvlen);
e90e2364 939 if (!newaddr) {
0bd48802 940 return write_no_mem();
05ec9bb3 941 }
490a0e98 942 return memcpy(newaddr,pv,pvlen);
05ec9bb3
NIS
943}
944
2e0de35c
NC
945/*
946=for apidoc savesvpv
947
6832267f 948A version of C<savepv()>/C<savepvn()> which gets the string to duplicate from
2e0de35c
NC
949the passed in SV using C<SvPV()>
950
951=cut
952*/
953
954char *
955Perl_savesvpv(pTHX_ SV *sv)
956{
957 STRLEN len;
7452cf6a 958 const char * const pv = SvPV_const(sv, len);
2e0de35c
NC
959 register char *newaddr;
960
26866f99 961 ++len;
a02a5408 962 Newx(newaddr,len,char);
07409e01 963 return (char *) CopyD(pv,newaddr,len,char);
2e0de35c 964}
05ec9bb3
NIS
965
966
cea2e8a9 967/* the SV for Perl_form() and mess() is not kept in an arena */
fc36a67e 968
76e3520e 969STATIC SV *
cea2e8a9 970S_mess_alloc(pTHX)
fc36a67e 971{
97aff369 972 dVAR;
fc36a67e
PP
973 SV *sv;
974 XPVMG *any;
975
e72dc28c 976 if (!PL_dirty)
396482e1 977 return sv_2mortal(newSVpvs(""));
e72dc28c 978
0372dbb6
GS
979 if (PL_mess_sv)
980 return PL_mess_sv;
981
fc36a67e 982 /* Create as PVMG now, to avoid any upgrading later */
a02a5408
JC
983 Newx(sv, 1, SV);
984 Newxz(any, 1, XPVMG);
fc36a67e
PP
985 SvFLAGS(sv) = SVt_PVMG;
986 SvANY(sv) = (void*)any;
6136c704 987 SvPV_set(sv, NULL);
fc36a67e 988 SvREFCNT(sv) = 1 << 30; /* practically infinite */
e72dc28c 989 PL_mess_sv = sv;
fc36a67e
PP
990 return sv;
991}
992
c5be433b 993#if defined(PERL_IMPLICIT_CONTEXT)
cea2e8a9
GS
994char *
995Perl_form_nocontext(const char* pat, ...)
996{
997 dTHX;
c5be433b 998 char *retval;
cea2e8a9
GS
999 va_list args;
1000 va_start(args, pat);
c5be433b 1001 retval = vform(pat, &args);
cea2e8a9 1002 va_end(args);
c5be433b 1003 return retval;
cea2e8a9 1004}
c5be433b 1005#endif /* PERL_IMPLICIT_CONTEXT */
cea2e8a9 1006
7c9e965c 1007/*
ccfc67b7 1008=head1 Miscellaneous Functions
7c9e965c
JP
1009=for apidoc form
1010
1011Takes a sprintf-style format pattern and conventional
1012(non-SV) arguments and returns the formatted string.
1013
1014 (char *) Perl_form(pTHX_ const char* pat, ...)
1015
1016can be used any place a string (char *) is required:
1017
1018 char * s = Perl_form("%d.%d",major,minor);
1019
1020Uses a single private buffer so if you want to format several strings you
1021must explicitly copy the earlier strings away (and free the copies when you
1022are done).
1023
1024=cut
1025*/
1026
8990e307 1027char *
864dbfa3 1028Perl_form(pTHX_ const char* pat, ...)
8990e307 1029{
c5be433b 1030 char *retval;
46fc3d4c 1031 va_list args;
46fc3d4c 1032 va_start(args, pat);
c5be433b 1033 retval = vform(pat, &args);
46fc3d4c 1034 va_end(args);
c5be433b
GS
1035 return retval;
1036}
1037
1038char *
1039Perl_vform(pTHX_ const char *pat, va_list *args)
1040{
2d03de9c 1041 SV * const sv = mess_alloc();
4608196e 1042 sv_vsetpvfn(sv, pat, strlen(pat), args, NULL, 0, NULL);
e72dc28c 1043 return SvPVX(sv);
46fc3d4c 1044}
a687059c 1045
5a844595
GS
1046#if defined(PERL_IMPLICIT_CONTEXT)
1047SV *
1048Perl_mess_nocontext(const char *pat, ...)
1049{
1050 dTHX;
1051 SV *retval;
1052 va_list args;
1053 va_start(args, pat);
1054 retval = vmess(pat, &args);
1055 va_end(args);
1056 return retval;
1057}
1058#endif /* PERL_IMPLICIT_CONTEXT */
1059
06bf62c7 1060SV *
5a844595
GS
1061Perl_mess(pTHX_ const char *pat, ...)
1062{
1063 SV *retval;
1064 va_list args;
1065 va_start(args, pat);
1066 retval = vmess(pat, &args);
1067 va_end(args);
1068 return retval;
1069}
1070
5f66b61c
AL
1071STATIC const COP*
1072S_closest_cop(pTHX_ const COP *cop, const OP *o)
ae7d165c 1073{
97aff369 1074 dVAR;
ae7d165c
PJ
1075 /* Look for PL_op starting from o. cop is the last COP we've seen. */
1076
fabdb6c0
AL
1077 if (!o || o == PL_op)
1078 return cop;
ae7d165c
PJ
1079
1080 if (o->op_flags & OPf_KIDS) {
5f66b61c 1081 const OP *kid;
fabdb6c0 1082 for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling) {
5f66b61c 1083 const COP *new_cop;
ae7d165c
PJ
1084
1085 /* If the OP_NEXTSTATE has been optimised away we can still use it
1086 * the get the file and line number. */
1087
1088 if (kid->op_type == OP_NULL && kid->op_targ == OP_NEXTSTATE)
5f66b61c 1089 cop = (const COP *)kid;
ae7d165c
PJ
1090
1091 /* Keep searching, and return when we've found something. */
1092
1093 new_cop = closest_cop(cop, kid);
fabdb6c0
AL
1094 if (new_cop)
1095 return new_cop;
ae7d165c
PJ
1096 }
1097 }
1098
1099 /* Nothing found. */
1100
5f66b61c 1101 return NULL;
ae7d165c
PJ
1102}
1103
5a844595
GS
1104SV *
1105Perl_vmess(pTHX_ const char *pat, va_list *args)
46fc3d4c 1106{
97aff369 1107 dVAR;
c4420975 1108 SV * const sv = mess_alloc();
46fc3d4c 1109
5f66b61c 1110 sv_vsetpvfn(sv, pat, strlen(pat), args, NULL, 0, NULL);
46fc3d4c 1111 if (!SvCUR(sv) || *(SvEND(sv) - 1) != '\n') {
ae7d165c
PJ
1112 /*
1113 * Try and find the file and line for PL_op. This will usually be
1114 * PL_curcop, but it might be a cop that has been optimised away. We
1115 * can try to find such a cop by searching through the optree starting
1116 * from the sibling of PL_curcop.
1117 */
1118
e1ec3a88 1119 const COP *cop = closest_cop(PL_curcop, PL_curcop->op_sibling);
5f66b61c
AL
1120 if (!cop)
1121 cop = PL_curcop;
ae7d165c
PJ
1122
1123 if (CopLINE(cop))
ed094faf 1124 Perl_sv_catpvf(aTHX_ sv, " at %s line %"IVdf,
3aed30dc 1125 OutCopFILE(cop), (IV)CopLINE(cop));
2035c5e8 1126 if (GvIO(PL_last_in_gv) && IoLINES(GvIOp(PL_last_in_gv))) {
e1ec3a88 1127 const bool line_mode = (RsSIMPLE(PL_rs) &&
95a20fc0 1128 SvCUR(PL_rs) == 1 && *SvPVX_const(PL_rs) == '\n');
57def98f 1129 Perl_sv_catpvf(aTHX_ sv, ", <%s> %s %"IVdf,
5f66b61c 1130 PL_last_in_gv == PL_argvgv ? "" : GvNAME(PL_last_in_gv),
edc2eac3
JH
1131 line_mode ? "line" : "chunk",
1132 (IV)IoLINES(GvIOp(PL_last_in_gv)));
a687059c 1133 }
5f66b61c
AL
1134 if (PL_dirty)
1135 sv_catpvs(sv, " during global destruction");
1136 sv_catpvs(sv, ".\n");
a687059c 1137 }
06bf62c7 1138 return sv;
a687059c
LW
1139}
1140
7ff03255
SG
1141void
1142Perl_write_to_stderr(pTHX_ const char* message, int msglen)
1143{
27da23d5 1144 dVAR;
7ff03255
SG
1145 IO *io;
1146 MAGIC *mg;
1147
1148 if (PL_stderrgv && SvREFCNT(PL_stderrgv)
1149 && (io = GvIO(PL_stderrgv))
1150 && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar)))
1151 {
1152 dSP;
1153 ENTER;
1154 SAVETMPS;
1155
1156 save_re_context();
1157 SAVESPTR(PL_stderrgv);
a0714e2c 1158 PL_stderrgv = NULL;
7ff03255
SG
1159
1160 PUSHSTACKi(PERLSI_MAGIC);
1161
1162 PUSHMARK(SP);
1163 EXTEND(SP,2);
1164 PUSHs(SvTIED_obj((SV*)io, mg));
1165 PUSHs(sv_2mortal(newSVpvn(message, msglen)));
1166 PUTBACK;
1167 call_method("PRINT", G_SCALAR);
1168
1169 POPSTACK;
1170 FREETMPS;
1171 LEAVE;
1172 }
1173 else {
1174#ifdef USE_SFIO
1175 /* SFIO can really mess with your errno */
53c1dcc0 1176 const int e = errno;
7ff03255 1177#endif
53c1dcc0 1178 PerlIO * const serr = Perl_error_log;
7ff03255
SG
1179
1180 PERL_WRITE_MSG_TO_CONSOLE(serr, message, msglen);
1181 (void)PerlIO_flush(serr);
1182#ifdef USE_SFIO
1183 errno = e;
1184#endif
1185 }
1186}
1187
46d9c920 1188/* Common code used by vcroak, vdie, vwarn and vwarner */
3ab1ac99 1189
46d9c920
NC
1190STATIC bool
1191S_vdie_common(pTHX_ const char *message, STRLEN msglen, I32 utf8, bool warn)
63315e18 1192{
97aff369 1193 dVAR;
63315e18
NC
1194 HV *stash;
1195 GV *gv;
1196 CV *cv;
46d9c920
NC
1197 SV **const hook = warn ? &PL_warnhook : &PL_diehook;
1198 /* sv_2cv might call Perl_croak() or Perl_warner() */
1199 SV * const oldhook = *hook;
1200
1201 assert(oldhook);
63315e18 1202
63315e18 1203 ENTER;
46d9c920
NC
1204 SAVESPTR(*hook);
1205 *hook = NULL;
1206 cv = sv_2cv(oldhook, &stash, &gv, 0);
63315e18
NC
1207 LEAVE;
1208 if (cv && !CvDEPTH(cv) && (CvROOT(cv) || CvXSUB(cv))) {
1209 dSP;
1210 SV *msg;
1211
1212 ENTER;
1213 save_re_context();
46d9c920
NC
1214 if (warn) {
1215 SAVESPTR(*hook);
1216 *hook = NULL;
1217 }
1218 if (warn || message) {
63315e18
NC
1219 msg = newSVpvn(message, msglen);
1220 SvFLAGS(msg) |= utf8;
1221 SvREADONLY_on(msg);
1222 SAVEFREESV(msg);
1223 }
1224 else {
1225 msg = ERRSV;
1226 }
1227
46d9c920 1228 PUSHSTACKi(warn ? PERLSI_WARNHOOK : PERLSI_DIEHOOK);
63315e18
NC
1229 PUSHMARK(SP);
1230 XPUSHs(msg);
1231 PUTBACK;
1232 call_sv((SV*)cv, G_DISCARD);
1233 POPSTACK;
1234 LEAVE;
46d9c920 1235 return TRUE;
63315e18 1236 }
46d9c920 1237 return FALSE;
63315e18
NC
1238}
1239
cfd0369c 1240STATIC const char *
e07360fa
AT
1241S_vdie_croak_common(pTHX_ const char* pat, va_list* args, STRLEN* msglen,
1242 I32* utf8)
1243{
1244 dVAR;
cfd0369c 1245 const char *message;
e07360fa
AT
1246
1247 if (pat) {
890ce7af 1248 SV * const msv = vmess(pat, args);
e07360fa
AT
1249 if (PL_errors && SvCUR(PL_errors)) {
1250 sv_catsv(PL_errors, msv);
cfd0369c 1251 message = SvPV_const(PL_errors, *msglen);
e07360fa
AT
1252 SvCUR_set(PL_errors, 0);
1253 }
1254 else
cfd0369c 1255 message = SvPV_const(msv,*msglen);
e07360fa
AT
1256 *utf8 = SvUTF8(msv);
1257 }
1258 else {
bd61b366 1259 message = NULL;
e07360fa
AT
1260 }
1261
1262 DEBUG_S(PerlIO_printf(Perl_debug_log,
1263 "%p: die/croak: message = %s\ndiehook = %p\n",
1264 thr, message, PL_diehook));
1265 if (PL_diehook) {
46d9c920 1266 S_vdie_common(aTHX_ message, *msglen, *utf8, FALSE);
e07360fa
AT
1267 }
1268 return message;
1269}
1270
c5be433b
GS
1271OP *
1272Perl_vdie(pTHX_ const char* pat, va_list *args)
36477c24 1273{
97aff369 1274 dVAR;
73d840c0 1275 const char *message;
e1ec3a88 1276 const int was_in_eval = PL_in_eval;
06bf62c7 1277 STRLEN msglen;
ff882698 1278 I32 utf8 = 0;
36477c24 1279
bf49b057 1280 DEBUG_S(PerlIO_printf(Perl_debug_log,
199100c8 1281 "%p: die: curstack = %p, mainstack = %p\n",
533c011a 1282 thr, PL_curstack, PL_mainstack));
36477c24 1283
890ce7af 1284 message = vdie_croak_common(pat, args, &msglen, &utf8);
36477c24 1285
06bf62c7 1286 PL_restartop = die_where(message, msglen);
ff882698 1287 SvFLAGS(ERRSV) |= utf8;
bf49b057 1288 DEBUG_S(PerlIO_printf(Perl_debug_log,
7c06b590 1289 "%p: die: restartop = %p, was_in_eval = %d, top_env = %p\n",
533c011a 1290 thr, PL_restartop, was_in_eval, PL_top_env));
3280af22 1291 if ((!PL_restartop && was_in_eval) || PL_top_env->je_prev)
6224f72b 1292 JMPENV_JUMP(3);
3280af22 1293 return PL_restartop;
36477c24
PP
1294}
1295
c5be433b 1296#if defined(PERL_IMPLICIT_CONTEXT)
cea2e8a9
GS
1297OP *
1298Perl_die_nocontext(const char* pat, ...)
a687059c 1299{
cea2e8a9
GS
1300 dTHX;
1301 OP *o;
a687059c 1302 va_list args;
cea2e8a9 1303 va_start(args, pat);
c5be433b 1304 o = vdie(pat, &args);
cea2e8a9
GS
1305 va_end(args);
1306 return o;
1307}
c5be433b 1308#endif /* PERL_IMPLICIT_CONTEXT */
cea2e8a9
GS
1309
1310OP *
1311Perl_die(pTHX_ const char* pat, ...)
1312{
1313 OP *o;
1314 va_list args;
1315 va_start(args, pat);
c5be433b 1316 o = vdie(pat, &args);
cea2e8a9
GS
1317 va_end(args);
1318 return o;
1319}
1320
c5be433b
GS
1321void
1322Perl_vcroak(pTHX_ const char* pat, va_list *args)
cea2e8a9 1323{
97aff369 1324 dVAR;
73d840c0 1325 const char *message;
06bf62c7 1326 STRLEN msglen;
ff882698 1327 I32 utf8 = 0;
a687059c 1328
3ab1ac99 1329 message = S_vdie_croak_common(aTHX_ pat, args, &msglen, &utf8);
5a844595 1330
3280af22 1331 if (PL_in_eval) {
06bf62c7 1332 PL_restartop = die_where(message, msglen);
ff882698 1333 SvFLAGS(ERRSV) |= utf8;
6224f72b 1334 JMPENV_JUMP(3);
a0d0e21e 1335 }
84414e3e 1336 else if (!message)
cfd0369c 1337 message = SvPVx_const(ERRSV, msglen);
84414e3e 1338
7ff03255 1339 write_to_stderr(message, msglen);
f86702cc 1340 my_failure_exit();
a687059c
LW
1341}
1342
c5be433b 1343#if defined(PERL_IMPLICIT_CONTEXT)
8990e307 1344void
cea2e8a9 1345Perl_croak_nocontext(const char *pat, ...)
a687059c 1346{
cea2e8a9 1347 dTHX;
a687059c 1348 va_list args;
cea2e8a9 1349 va_start(args, pat);
c5be433b 1350 vcroak(pat, &args);
cea2e8a9
GS
1351 /* NOTREACHED */
1352 va_end(args);
1353}
1354#endif /* PERL_IMPLICIT_CONTEXT */
1355
954c1994 1356/*
ccfc67b7
JH
1357=head1 Warning and Dieing
1358
954c1994
GS
1359=for apidoc croak
1360
9983fa3c 1361This is the XSUB-writer's interface to Perl's C<die> function.
966353fd
MF
1362Normally call this function the same way you call the C C<printf>
1363function. Calling C<croak> returns control directly to Perl,
1364sidestepping the normal C order of execution. See C<warn>.
9983fa3c
GS
1365
1366If you want to throw an exception object, assign the object to
bd61b366 1367C<$@> and then pass C<NULL> to croak():
9983fa3c
GS
1368
1369 errsv = get_sv("@", TRUE);
1370 sv_setsv(errsv, exception_object);
bd61b366 1371 croak(NULL);
954c1994
GS
1372
1373=cut
1374*/
1375
cea2e8a9
GS
1376void
1377Perl_croak(pTHX_ const char *pat, ...)
1378{
1379 va_list args;
1380 va_start(args, pat);
c5be433b 1381 vcroak(pat, &args);
cea2e8a9
GS
1382 /* NOTREACHED */
1383 va_end(args);
1384}
1385
c5be433b
GS
1386void
1387Perl_vwarn(pTHX_ const char* pat, va_list *args)
cea2e8a9 1388{
27da23d5 1389 dVAR;
06bf62c7 1390 STRLEN msglen;
53c1dcc0
AL
1391 SV * const msv = vmess(pat, args);
1392 const I32 utf8 = SvUTF8(msv);
1393 const char * const message = SvPV_const(msv, msglen);
a687059c 1394
3280af22 1395 if (PL_warnhook) {
46d9c920 1396 if (vdie_common(message, msglen, utf8, TRUE))
20cec16a 1397 return;
748a9306 1398 }
87582a92 1399
7ff03255 1400 write_to_stderr(message, msglen);
a687059c 1401}
8d063cd8 1402
c5be433b 1403#if defined(PERL_IMPLICIT_CONTEXT)
cea2e8a9
GS
1404void
1405Perl_warn_nocontext(const char *pat, ...)
1406{
1407 dTHX;
1408 va_list args;
1409 va_start(args, pat);
c5be433b 1410 vwarn(pat, &args);
cea2e8a9
GS
1411 va_end(args);
1412}
1413#endif /* PERL_IMPLICIT_CONTEXT */
1414
954c1994
GS
1415/*
1416=for apidoc warn
1417
966353fd
MF
1418This is the XSUB-writer's interface to Perl's C<warn> function. Call this
1419function the same way you call the C C<printf> function. See C<croak>.
954c1994
GS
1420
1421=cut
1422*/
1423
cea2e8a9
GS
1424void
1425Perl_warn(pTHX_ const char *pat, ...)
1426{
1427 va_list args;
1428 va_start(args, pat);
c5be433b 1429 vwarn(pat, &args);
cea2e8a9
GS
1430 va_end(args);
1431}
1432
c5be433b
GS
1433#if defined(PERL_IMPLICIT_CONTEXT)
1434void
1435Perl_warner_nocontext(U32 err, const char *pat, ...)
1436{
27da23d5 1437 dTHX;
c5be433b
GS
1438 va_list args;
1439 va_start(args, pat);
1440 vwarner(err, pat, &args);
1441 va_end(args);
1442}
1443#endif /* PERL_IMPLICIT_CONTEXT */
1444
599cee73 1445void
864dbfa3 1446Perl_warner(pTHX_ U32 err, const char* pat,...)
599cee73
PM
1447{
1448 va_list args;
c5be433b
GS
1449 va_start(args, pat);
1450 vwarner(err, pat, &args);
1451 va_end(args);
1452}
1453
1454void
1455Perl_vwarner(pTHX_ U32 err, const char* pat, va_list* args)
1456{
27da23d5 1457 dVAR;
5f2d9966 1458 if (PL_warnhook == PERL_WARNHOOK_FATAL || ckDEAD(err)) {
a3b680e6 1459 SV * const msv = vmess(pat, args);
d13b0d77 1460 STRLEN msglen;
7452cf6a 1461 const char * const message = SvPV_const(msv, msglen);
a3b680e6 1462 const I32 utf8 = SvUTF8(msv);
599cee73 1463
3aed30dc 1464 if (PL_diehook) {
63315e18 1465 assert(message);
46d9c920 1466 S_vdie_common(aTHX_ message, msglen, utf8, FALSE);
3aed30dc
HS
1467 }
1468 if (PL_in_eval) {
1469 PL_restartop = die_where(message, msglen);
ff882698 1470 SvFLAGS(ERRSV) |= utf8;
3aed30dc
HS
1471 JMPENV_JUMP(3);
1472 }
7ff03255 1473 write_to_stderr(message, msglen);
3aed30dc 1474 my_failure_exit();
599cee73
PM
1475 }
1476 else {
d13b0d77 1477 Perl_vwarn(aTHX_ pat, args);
599cee73
PM
1478 }
1479}
1480
f54ba1c2
DM
1481/* implements the ckWARN? macros */
1482
1483bool
1484Perl_ckwarn(pTHX_ U32 w)
1485{
97aff369 1486 dVAR;
f54ba1c2
DM
1487 return
1488 (
1489 isLEXWARN_on
1490 && PL_curcop->cop_warnings != pWARN_NONE
1491 && (
1492 PL_curcop->cop_warnings == pWARN_ALL
1493 || isWARN_on(PL_curcop->cop_warnings, unpackWARN1(w))
1494 || (unpackWARN2(w) &&
1495 isWARN_on(PL_curcop->cop_warnings, unpackWARN2(w)))
1496 || (unpackWARN3(w) &&
1497 isWARN_on(PL_curcop->cop_warnings, unpackWARN3(w)))
1498 || (unpackWARN4(w) &&
1499 isWARN_on(PL_curcop->cop_warnings, unpackWARN4(w)))
1500 )
1501 )
1502 ||
1503 (
1504 isLEXWARN_off && PL_dowarn & G_WARN_ON
1505 )
1506 ;
1507}
1508
1509/* implements the ckWARN?_d macro */
1510
1511bool
1512Perl_ckwarn_d(pTHX_ U32 w)
1513{
97aff369 1514 dVAR;
f54ba1c2
DM
1515 return
1516 isLEXWARN_off
1517 || PL_curcop->cop_warnings == pWARN_ALL
1518 || (
1519 PL_curcop->cop_warnings != pWARN_NONE
1520 && (
1521 isWARN_on(PL_curcop->cop_warnings, unpackWARN1(w))
1522 || (unpackWARN2(w) &&
1523 isWARN_on(PL_curcop->cop_warnings, unpackWARN2(w)))
1524 || (unpackWARN3(w) &&
1525 isWARN_on(PL_curcop->cop_warnings, unpackWARN3(w)))
1526 || (unpackWARN4(w) &&
1527 isWARN_on(PL_curcop->cop_warnings, unpackWARN4(w)))
1528 )
1529 )
1530 ;
1531}
1532
72dc9ed5
NC
1533/* Set buffer=NULL to get a new one. */
1534STRLEN *
8ee4cf24 1535Perl_new_warnings_bitfield(pTHX_ STRLEN *buffer, const char *const bits,
72dc9ed5
NC
1536 STRLEN size) {
1537 const MEM_SIZE len_wanted = sizeof(STRLEN) + size;
35da51f7 1538 PERL_UNUSED_CONTEXT;
72dc9ed5
NC
1539
1540 buffer = specialWARN(buffer) ? PerlMemShared_malloc(len_wanted)
1541 : PerlMemShared_realloc(buffer, len_wanted);
1542 buffer[0] = size;
1543 Copy(bits, (buffer + 1), size, char);
1544 return buffer;
1545}
f54ba1c2 1546
e6587932
DM
1547/* since we've already done strlen() for both nam and val
1548 * we can use that info to make things faster than
1549 * sprintf(s, "%s=%s", nam, val)
1550 */
1551#define my_setenv_format(s, nam, nlen, val, vlen) \
1552 Copy(nam, s, nlen, char); \
1553 *(s+nlen) = '='; \
1554 Copy(val, s+(nlen+1), vlen, char); \
1555 *(s+(nlen+1+vlen)) = '\0'
1556
13b6e58c 1557#ifdef USE_ENVIRON_ARRAY
eccd403f 1558 /* VMS' my_setenv() is in vms.c */
2986a63f 1559#if !defined(WIN32) && !defined(NETWARE)
8d063cd8 1560void
e1ec3a88 1561Perl_my_setenv(pTHX_ const char *nam, const char *val)
8d063cd8 1562{
27da23d5 1563 dVAR;
4efc5df6
GS
1564#ifdef USE_ITHREADS
1565 /* only parent thread can modify process environment */
1566 if (PL_curinterp == aTHX)
1567#endif
1568 {
f2517201 1569#ifndef PERL_USE_SAFE_PUTENV
50acdf95 1570 if (!PL_use_safe_putenv) {
f2517201 1571 /* most putenv()s leak, so we manipulate environ directly */
79072805 1572 register I32 i=setenv_getix(nam); /* where does it go? */
e6587932 1573 int nlen, vlen;
8d063cd8 1574
3280af22 1575 if (environ == PL_origenviron) { /* need we copy environment? */
79072805
LW
1576 I32 j;
1577 I32 max;
fe14fcc3
LW
1578 char **tmpenv;
1579
35da51f7
AL
1580 max = i;
1581 while (environ[max])
1582 max++;
f2517201
GS
1583 tmpenv = (char**)safesysmalloc((max+2) * sizeof(char*));
1584 for (j=0; j<max; j++) { /* copy environment */
e1ec3a88 1585 const int len = strlen(environ[j]);
3aed30dc
HS
1586 tmpenv[j] = (char*)safesysmalloc((len+1)*sizeof(char));
1587 Copy(environ[j], tmpenv[j], len+1, char);
f2517201 1588 }
bd61b366 1589 tmpenv[max] = NULL;
fe14fcc3
LW
1590 environ = tmpenv; /* tell exec where it is now */
1591 }
a687059c 1592 if (!val) {
f2517201 1593 safesysfree(environ[i]);
a687059c
LW
1594 while (environ[i]) {
1595 environ[i] = environ[i+1];
1596 i++;
1597 }
1598 return;
1599 }
8d063cd8 1600 if (!environ[i]) { /* does not exist yet */
f2517201 1601 environ = (char**)safesysrealloc(environ, (i+2) * sizeof(char*));
bd61b366 1602 environ[i+1] = NULL; /* make sure it's null terminated */
8d063cd8 1603 }
fe14fcc3 1604 else
f2517201 1605 safesysfree(environ[i]);
7ee146b1
AW
1606 nlen = strlen(nam);
1607 vlen = strlen(val);
f2517201 1608
7ee146b1
AW
1609 environ[i] = (char*)safesysmalloc((nlen+vlen+2) * sizeof(char));
1610 /* all that work just for this */
1611 my_setenv_format(environ[i], nam, nlen, val, vlen);
50acdf95
MS
1612 } else {
1613# endif
7ee146b1 1614# if defined(__CYGWIN__) || defined(EPOC) || defined(__SYMBIAN32__) || defined(__riscos__)
88f5bc07
AB
1615# if defined(HAS_UNSETENV)
1616 if (val == NULL) {
1617 (void)unsetenv(nam);
1618 } else {
1619 (void)setenv(nam, val, 1);
1620 }
1621# else /* ! HAS_UNSETENV */
1622 (void)setenv(nam, val, 1);
1623# endif /* HAS_UNSETENV */
47dafe4d 1624# else
88f5bc07
AB
1625# if defined(HAS_UNSETENV)
1626 if (val == NULL) {
1627 (void)unsetenv(nam);
1628 } else {
c4420975
AL
1629 const int nlen = strlen(nam);
1630 const int vlen = strlen(val);
1631 char * const new_env =
88f5bc07
AB
1632 (char*)safesysmalloc((nlen + vlen + 2) * sizeof(char));
1633 my_setenv_format(new_env, nam, nlen, val, vlen);
1634 (void)putenv(new_env);
1635 }
1636# else /* ! HAS_UNSETENV */
1637 char *new_env;
c4420975
AL
1638 const int nlen = strlen(nam);
1639 int vlen;
88f5bc07
AB
1640 if (!val) {
1641 val = "";
1642 }
1643 vlen = strlen(val);
1644 new_env = (char*)safesysmalloc((nlen + vlen + 2) * sizeof(char));
1645 /* all that work just for this */
1646 my_setenv_format(new_env, nam, nlen, val, vlen);
1647 (void)putenv(new_env);
1648# endif /* HAS_UNSETENV */
47dafe4d 1649# endif /* __CYGWIN__ */
50acdf95
MS
1650#ifndef PERL_USE_SAFE_PUTENV
1651 }
1652#endif
4efc5df6 1653 }
8d063cd8
LW
1654}
1655
2986a63f 1656#else /* WIN32 || NETWARE */
68dc0745
PP
1657
1658void
72229eff 1659Perl_my_setenv(pTHX_ const char *nam, const char *val)
68dc0745 1660{
27da23d5 1661 dVAR;
ac5c734f 1662 register char *envstr;
e1ec3a88
AL
1663 const int nlen = strlen(nam);
1664 int vlen;
e6587932 1665
ac5c734f
GS
1666 if (!val) {
1667 val = "";
1668 }
e6587932 1669 vlen = strlen(val);
a02a5408 1670 Newx(envstr, nlen+vlen+2, char);
e6587932 1671 my_setenv_format(envstr, nam, nlen, val, vlen);
ac5c734f
GS
1672 (void)PerlEnv_putenv(envstr);
1673 Safefree(envstr);
3e3baf6d
TB
1674}
1675
2986a63f 1676#endif /* WIN32 || NETWARE */
3e3baf6d 1677
2f42fcb0 1678#ifndef PERL_MICRO
3e3baf6d 1679I32
e1ec3a88 1680Perl_setenv_getix(pTHX_ const char *nam)
3e3baf6d 1681{
53c1dcc0 1682 register I32 i;
0d46e09a 1683 register const I32 len = strlen(nam);
96a5add6 1684 PERL_UNUSED_CONTEXT;
3e3baf6d
TB
1685
1686 for (i = 0; environ[i]; i++) {
1687 if (
1688#ifdef WIN32
1689 strnicmp(environ[i],nam,len) == 0
1690#else
1691 strnEQ(environ[i],nam,len)
1692#endif
1693 && environ[i][len] == '=')
1694 break; /* strnEQ must come first to avoid */
1695 } /* potential SEGV's */
1696 return i;
68dc0745 1697}
2f42fcb0 1698#endif /* !PERL_MICRO */
68dc0745 1699
ed79a026 1700#endif /* !VMS && !EPOC*/
378cc40b 1701
16d20bd9 1702#ifdef UNLINK_ALL_VERSIONS
79072805 1703I32
6e732051 1704Perl_unlnk(pTHX_ const char *f) /* unlink all versions of a file */
378cc40b 1705{
35da51f7 1706 I32 retries = 0;
378cc40b 1707
35da51f7
AL
1708 while (PerlLIO_unlink(f) >= 0)
1709 retries++;
1710 return retries ? 0 : -1;
378cc40b
LW
1711}
1712#endif
1713
7a3f2258 1714/* this is a drop-in replacement for bcopy() */
2253333f 1715#if (!defined(HAS_MEMCPY) && !defined(HAS_BCOPY)) || (!defined(HAS_MEMMOVE) && !defined(HAS_SAFE_MEMCPY) && !defined(HAS_SAFE_BCOPY))
378cc40b 1716char *
7a3f2258 1717Perl_my_bcopy(register const char *from,register char *to,register I32 len)
378cc40b 1718{
2d03de9c 1719 char * const retval = to;
378cc40b 1720
7c0587c8
LW
1721 if (from - to >= 0) {
1722 while (len--)
1723 *to++ = *from++;
1724 }
1725 else {
1726 to += len;
1727 from += len;
1728 while (len--)
faf8582f 1729 *(--to) = *(--from);
7c0587c8 1730 }
378cc40b
LW
1731 return retval;
1732}
ffed7fef 1733#endif
378cc40b 1734
7a3f2258 1735/* this is a drop-in replacement for memset() */
fc36a67e
PP
1736#ifndef HAS_MEMSET
1737void *
7a3f2258 1738Perl_my_memset(register char *loc, register I32 ch, register I32 len)
fc36a67e 1739{
2d03de9c 1740 char * const retval = loc;
fc36a67e
PP
1741
1742 while (len--)
1743 *loc++ = ch;
1744 return retval;
1745}
1746#endif
1747
7a3f2258 1748/* this is a drop-in replacement for bzero() */
7c0587c8 1749#if !defined(HAS_BZERO) && !defined(HAS_MEMSET)
378cc40b 1750char *
7a3f2258 1751Perl_my_bzero(register char *loc, register I32 len)
378cc40b 1752{
2d03de9c 1753 char * const retval = loc;
378cc40b
LW
1754
1755 while (len--)
1756 *loc++ = 0;
1757 return retval;
1758}
1759#endif
7c0587c8 1760
7a3f2258 1761/* this is a drop-in replacement for memcmp() */
36477c24 1762#if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP)
79072805 1763I32
7a3f2258 1764Perl_my_memcmp(const char *s1, const char *s2, register I32 len)
7c0587c8 1765{
e1ec3a88
AL
1766 register const U8 *a = (const U8 *)s1;
1767 register const U8 *b = (const U8 *)s2;
79072805 1768 register I32 tmp;
7c0587c8
LW
1769
1770 while (len--) {
27da23d5 1771 if ((tmp = *a++ - *b++))
7c0587c8
LW
1772 return tmp;
1773 }
1774 return 0;
1775}
36477c24 1776#endif /* !HAS_MEMCMP || !HAS_SANE_MEMCMP */
a687059c 1777
fe14fcc3 1778#ifndef HAS_VPRINTF
a687059c 1779
85e6fe83 1780#ifdef USE_CHAR_VSPRINTF
a687059c
LW
1781char *
1782#else
1783int
1784#endif
08105a92 1785vsprintf(char *dest, const char *pat, char *args)
a687059c
LW
1786{
1787 FILE fakebuf;
1788
1789 fakebuf._ptr = dest;
1790 fakebuf._cnt = 32767;
35c8bce7
LW
1791#ifndef _IOSTRG
1792#define _IOSTRG 0
1793#endif
a687059c
LW
1794 fakebuf._flag = _IOWRT|_IOSTRG;
1795 _doprnt(pat, args, &fakebuf); /* what a kludge */
1796 (void)putc('\0', &fakebuf);
85e6fe83 1797#ifdef USE_CHAR_VSPRINTF
a687059c
LW
1798 return(dest);
1799#else
1800 return 0; /* perl doesn't use return value */
1801#endif
1802}
1803
fe14fcc3 1804#endif /* HAS_VPRINTF */
a687059c
LW
1805
1806#ifdef MYSWAP
ffed7fef 1807#if BYTEORDER != 0x4321
a687059c 1808short
864dbfa3 1809Perl_my_swap(pTHX_ short s)
a687059c
LW
1810{
1811#if (BYTEORDER & 1) == 0
1812 short result;
1813
1814 result = ((s & 255) << 8) + ((s >> 8) & 255);
1815 return result;
1816#else
1817 return s;
1818#endif
1819}
1820
1821long
864dbfa3 1822Perl_my_htonl(pTHX_ long l)
a687059c
LW
1823{
1824 union {
1825 long result;
ffed7fef 1826 char c[sizeof(long)];
a687059c
LW
1827 } u;
1828
ffed7fef 1829#if BYTEORDER == 0x1234
a687059c
LW
1830 u.c[0] = (l >> 24) & 255;
1831 u.c[1] = (l >> 16) & 255;
1832 u.c[2] = (l >> 8) & 255;
1833 u.c[3] = l & 255;
1834 return u.result;
1835#else
ffed7fef 1836#if ((BYTEORDER - 0x1111) & 0x444) || !(BYTEORDER & 0xf)
cea2e8a9 1837 Perl_croak(aTHX_ "Unknown BYTEORDER\n");
a687059c 1838#else
79072805
LW
1839 register I32 o;
1840 register I32 s;
a687059c 1841
ffed7fef
LW
1842 for (o = BYTEORDER - 0x1111, s = 0; s < (sizeof(long)*8); o >>= 4, s += 8) {
1843 u.c[o & 0xf] = (l >> s) & 255;
a687059c
LW
1844 }
1845 return u.result;
1846#endif
1847#endif
1848}
1849
1850long
864dbfa3 1851Perl_my_ntohl(pTHX_ long l)
a687059c
LW
1852{
1853 union {
1854 long l;
ffed7fef 1855 char c[sizeof(long)];
a687059c
LW
1856 } u;
1857
ffed7fef 1858#if BYTEORDER == 0x1234
a687059c
LW
1859 u.c[0] = (l >> 24) & 255;
1860 u.c[1] = (l >> 16) & 255;
1861 u.c[2] = (l >> 8) & 255;
1862 u.c[3] = l & 255;
1863 return u.l;
1864#else
ffed7fef 1865#if ((BYTEORDER - 0x1111) & 0x444) || !(BYTEORDER & 0xf)
cea2e8a9 1866 Perl_croak(aTHX_ "Unknown BYTEORDER\n");
a687059c 1867#else
79072805
LW
1868 register I32 o;
1869 register I32 s;
a687059c
LW
1870
1871 u.l = l;
1872 l = 0;
ffed7fef
LW
1873 for (o = BYTEORDER - 0x1111, s = 0; s < (sizeof(long)*8); o >>= 4, s += 8) {
1874 l |= (u.c[o & 0xf] & 255) << s;
a687059c
LW
1875 }
1876 return l;
1877#endif
1878#endif
1879}
1880
ffed7fef 1881#endif /* BYTEORDER != 0x4321 */
988174c1
LW
1882#endif /* MYSWAP */
1883
1884/*
1885 * Little-endian byte order functions - 'v' for 'VAX', or 'reVerse'.
1886 * If these functions are defined,
1887 * the BYTEORDER is neither 0x1234 nor 0x4321.
1888 * However, this is not assumed.
1889 * -DWS
1890 */
1891
1109a392 1892#define HTOLE(name,type) \
988174c1 1893 type \
ba106d47 1894 name (register type n) \
988174c1
LW
1895 { \
1896 union { \
1897 type value; \
1898 char c[sizeof(type)]; \
1899 } u; \
bb7a0f54
MHM
1900 register U32 i; \
1901 register U32 s = 0; \
1109a392 1902 for (i = 0; i < sizeof(u.c); i++, s += 8) { \
988174c1
LW
1903 u.c[i] = (n >> s) & 0xFF; \
1904 } \
1905 return u.value; \
1906 }
1907
1109a392 1908#define LETOH(name,type) \
988174c1 1909 type \
ba106d47 1910 name (register type n) \
988174c1
LW
1911 { \
1912 union { \
1913 type value; \
1914 char c[sizeof(type)]; \
1915 } u; \
bb7a0f54
MHM
1916 register U32 i; \
1917 register U32 s = 0; \
988174c1
LW
1918 u.value = n; \
1919 n = 0; \
1109a392
MHM
1920 for (i = 0; i < sizeof(u.c); i++, s += 8) { \
1921 n |= ((type)(u.c[i] & 0xFF)) << s; \
988174c1
LW
1922 } \
1923 return n; \
1924 }
1925
1109a392
MHM
1926/*
1927 * Big-endian byte order functions.
1928 */
1929
1930#define HTOBE(name,type) \
1931 type \
1932 name (register type n) \
1933 { \
1934 union { \
1935 type value; \
1936 char c[sizeof(type)]; \
1937 } u; \
bb7a0f54
MHM
1938 register U32 i; \
1939 register U32 s = 8*(sizeof(u.c)-1); \
1109a392
MHM
1940 for (i = 0; i < sizeof(u.c); i++, s -= 8) { \
1941 u.c[i] = (n >> s) & 0xFF; \
1942 } \
1943 return u.value; \
1944 }
1945
1946#define BETOH(name,type) \
1947 type \
1948 name (register type n) \
1949 { \
1950 union { \
1951 type value; \
1952 char c[sizeof(type)]; \
1953 } u; \
bb7a0f54
MHM
1954 register U32 i; \
1955 register U32 s = 8*(sizeof(u.c)-1); \
1109a392
MHM
1956 u.value = n; \
1957 n = 0; \
1958 for (i = 0; i < sizeof(u.c); i++, s -= 8) { \
1959 n |= ((type)(u.c[i] & 0xFF)) << s; \
1960 } \
1961 return n; \
1962 }
1963
1964/*
1965 * If we just can't do it...
1966 */
1967
1968#define NOT_AVAIL(name,type) \
1969 type \
1970 name (register type n) \
1971 { \
1972 Perl_croak_nocontext(#name "() not available"); \
1973 return n; /* not reached */ \
1974 }
1975
1976
988174c1 1977#if defined(HAS_HTOVS) && !defined(htovs)
1109a392 1978HTOLE(htovs,short)
988174c1
LW
1979#endif
1980#if defined(HAS_HTOVL) && !defined(htovl)
1109a392 1981HTOLE(htovl,long)
988174c1
LW
1982#endif
1983#if defined(HAS_VTOHS) && !defined(vtohs)
1109a392 1984LETOH(vtohs,short)
988174c1
LW
1985#endif
1986#if defined(HAS_VTOHL) && !defined(vtohl)
1109a392
MHM
1987LETOH(vtohl,long)
1988#endif
1989
1990#ifdef PERL_NEED_MY_HTOLE16
1991# if U16SIZE == 2
1992HTOLE(Perl_my_htole16,U16)
1993# else
1994NOT_AVAIL(Perl_my_htole16,U16)
1995# endif
1996#endif
1997#ifdef PERL_NEED_MY_LETOH16
1998# if U16SIZE == 2
1999LETOH(Perl_my_letoh16,U16)
2000# else
2001NOT_AVAIL(Perl_my_letoh16,U16)
2002# endif
2003#endif
2004#ifdef PERL_NEED_MY_HTOBE16
2005# if U16SIZE == 2
2006HTOBE(Perl_my_htobe16,U16)
2007# else
2008NOT_AVAIL(Perl_my_htobe16,U16)
2009# endif
2010#endif
2011#ifdef PERL_NEED_MY_BETOH16
2012# if U16SIZE == 2
2013BETOH(Perl_my_betoh16,U16)
2014# else
2015NOT_AVAIL(Perl_my_betoh16,U16)
2016# endif
2017#endif
2018
2019#ifdef PERL_NEED_MY_HTOLE32
2020# if U32SIZE == 4
2021HTOLE(Perl_my_htole32,U32)
2022# else
2023NOT_AVAIL(Perl_my_htole32,U32)
2024# endif
2025#endif
2026#ifdef PERL_NEED_MY_LETOH32
2027# if U32SIZE == 4
2028LETOH(Perl_my_letoh32,U32)
2029# else
2030NOT_AVAIL(Perl_my_letoh32,U32)
2031# endif
2032#endif
2033#ifdef PERL_NEED_MY_HTOBE32
2034# if U32SIZE == 4
2035HTOBE(Perl_my_htobe32,U32)
2036# else
2037NOT_AVAIL(Perl_my_htobe32,U32)
2038# endif
2039#endif
2040#ifdef PERL_NEED_MY_BETOH32
2041# if U32SIZE == 4
2042BETOH(Perl_my_betoh32,U32)
2043# else
2044NOT_AVAIL(Perl_my_betoh32,U32)
2045# endif
2046#endif
2047
2048#ifdef PERL_NEED_MY_HTOLE64
2049# if U64SIZE == 8
2050HTOLE(Perl_my_htole64,U64)
2051# else
2052NOT_AVAIL(Perl_my_htole64,U64)
2053# endif
2054#endif
2055#ifdef PERL_NEED_MY_LETOH64
2056# if U64SIZE == 8
2057LETOH(Perl_my_letoh64,U64)
2058# else
2059NOT_AVAIL(Perl_my_letoh64,U64)
2060# endif
2061#endif
2062#ifdef PERL_NEED_MY_HTOBE64
2063# if U64SIZE == 8
2064HTOBE(Perl_my_htobe64,U64)
2065# else
2066NOT_AVAIL(Perl_my_htobe64,U64)
2067# endif
2068#endif
2069#ifdef PERL_NEED_MY_BETOH64
2070# if U64SIZE == 8
2071BETOH(Perl_my_betoh64,U64)
2072# else
2073NOT_AVAIL(Perl_my_betoh64,U64)
2074# endif
988174c1 2075#endif
a687059c 2076
1109a392
MHM
2077#ifdef PERL_NEED_MY_HTOLES
2078HTOLE(Perl_my_htoles,short)
2079#endif
2080#ifdef PERL_NEED_MY_LETOHS
2081LETOH(Perl_my_letohs,short)
2082#endif
2083#ifdef PERL_NEED_MY_HTOBES
2084HTOBE(Perl_my_htobes,short)
2085#endif
2086#ifdef PERL_NEED_MY_BETOHS
2087BETOH(Perl_my_betohs,short)
2088#endif
2089
2090#ifdef PERL_NEED_MY_HTOLEI
2091HTOLE(Perl_my_htolei,int)
2092#endif
2093#ifdef PERL_NEED_MY_LETOHI
2094LETOH(Perl_my_letohi,int)
2095#endif
2096#ifdef PERL_NEED_MY_HTOBEI
2097HTOBE(Perl_my_htobei,int)
2098#endif
2099#ifdef PERL_NEED_MY_BETOHI
2100BETOH(Perl_my_betohi,int)
2101#endif
2102
2103#ifdef PERL_NEED_MY_HTOLEL
2104HTOLE(Perl_my_htolel,long)
2105#endif
2106#ifdef PERL_NEED_MY_LETOHL
2107LETOH(Perl_my_letohl,long)
2108#endif
2109#ifdef PERL_NEED_MY_HTOBEL
2110HTOBE(Perl_my_htobel,long)
2111#endif
2112#ifdef PERL_NEED_MY_BETOHL
2113BETOH(Perl_my_betohl,long)
2114#endif
2115
2116void
2117Perl_my_swabn(void *ptr, int n)
2118{
2119 register char *s = (char *)ptr;
2120 register char *e = s + (n-1);
2121 register char tc;
2122
2123 for (n /= 2; n > 0; s++, e--, n--) {
2124 tc = *s;
2125 *s = *e;
2126 *e = tc;
2127 }
2128}
2129
4a7d1889
NIS
2130PerlIO *
2131Perl_my_popen_list(pTHX_ char *mode, int n, SV **args)
2132{
2986a63f 2133#if (!defined(DOSISH) || defined(HAS_FORK) || defined(AMIGAOS)) && !defined(OS2) && !defined(VMS) && !defined(__OPEN_VM) && !defined(EPOC) && !defined(MACOS_TRADITIONAL) && !defined(NETWARE)
97aff369 2134 dVAR;
1f852d0d
NIS
2135 int p[2];
2136 register I32 This, that;
2137 register Pid_t pid;
2138 SV *sv;
2139 I32 did_pipes = 0;
2140 int pp[2];
2141
2142 PERL_FLUSHALL_FOR_CHILD;
2143 This = (*mode == 'w');
2144 that = !This;
2145 if (PL_tainting) {
2146 taint_env();
2147 taint_proper("Insecure %s%s", "EXEC");
2148 }
2149 if (PerlProc_pipe(p) < 0)
4608196e 2150 return NULL;
1f852d0d
NIS
2151 /* Try for another pipe pair for error return */
2152 if (PerlProc_pipe(pp) >= 0)
2153 did_pipes = 1;
52e18b1f 2154 while ((pid = PerlProc_fork()) < 0) {
1f852d0d
NIS
2155 if (errno != EAGAIN) {
2156 PerlLIO_close(p[This]);
4e6dfe71 2157 PerlLIO_close(p[that]);
1f852d0d
NIS
2158 if (did_pipes) {
2159 PerlLIO_close(pp[0]);
2160 PerlLIO_close(pp[1]);
2161 }
4608196e 2162 return NULL;
1f852d0d
NIS
2163 }
2164 sleep(5);
2165 }
2166 if (pid == 0) {
2167 /* Child */
1f852d0d
NIS
2168#undef THIS
2169#undef THAT
2170#define THIS that
2171#define THAT This
1f852d0d
NIS
2172 /* Close parent's end of error status pipe (if any) */
2173 if (did_pipes) {
2174 PerlLIO_close(pp[0]);
2175#if defined(HAS_FCNTL) && defined(F_SETFD)
2176 /* Close error pipe automatically if exec works */
2177 fcntl(pp[1], F_SETFD, FD_CLOEXEC);
2178#endif
2179 }
2180 /* Now dup our end of _the_ pipe to right position */
2181 if (p[THIS] != (*mode == 'r')) {
2182 PerlLIO_dup2(p[THIS], *mode == 'r');
2183 PerlLIO_close(p[THIS]);
4e6dfe71
GS
2184 if (p[THAT] != (*mode == 'r')) /* if dup2() didn't close it */
2185 PerlLIO_close(p[THAT]); /* close parent's end of _the_ pipe */
1f852d0d 2186 }
4e6dfe71
GS
2187 else
2188 PerlLIO_close(p[THAT]); /* close parent's end of _the_ pipe */
1f852d0d
NIS
2189#if !defined(HAS_FCNTL) || !defined(F_SETFD)
2190 /* No automatic close - do it by hand */
b7953727
JH
2191# ifndef NOFILE
2192# define NOFILE 20
2193# endif
a080fe3d
NIS
2194 {
2195 int fd;
2196
2197 for (fd = PL_maxsysfd + 1; fd < NOFILE; fd++) {
3aed30dc 2198 if (fd != pp[1])
a080fe3d
NIS
2199 PerlLIO_close(fd);
2200 }
1f852d0d
NIS
2201 }
2202#endif
a0714e2c 2203 do_aexec5(NULL, args-1, args-1+n, pp[1], did_pipes);
1f852d0d
NIS
2204 PerlProc__exit(1);
2205#undef THIS
2206#undef THAT
2207 }
2208 /* Parent */
52e18b1f 2209 do_execfree(); /* free any memory malloced by child on fork */
1f852d0d
NIS
2210 if (did_pipes)
2211 PerlLIO_close(pp[1]);
2212 /* Keep the lower of the two fd numbers */
2213 if (p[that] < p[This]) {
2214 PerlLIO_dup2(p[This], p[that]);
2215 PerlLIO_close(p[This]);
2216 p[This] = p[that];
2217 }
4e6dfe71
GS
2218 else
2219 PerlLIO_close(p[that]); /* close child's end of pipe */
2220
1f852d0d
NIS
2221 LOCK_FDPID_MUTEX;
2222 sv = *av_fetch(PL_fdpid,p[This],TRUE);
2223 UNLOCK_FDPID_MUTEX;
862a34c6 2224 SvUPGRADE(sv,SVt_IV);
45977657 2225 SvIV_set(sv, pid);
1f852d0d
NIS
2226 PL_forkprocess = pid;
2227 /* If we managed to get status pipe check for exec fail */
2228 if (did_pipes && pid > 0) {
2229 int errkid;
bb7a0f54
MHM
2230 unsigned n = 0;
2231 SSize_t n1;
1f852d0d
NIS
2232
2233 while (n < sizeof(int)) {
2234 n1 = PerlLIO_read(pp[0],
2235 (void*)(((char*)&errkid)+n),
2236 (sizeof(int)) - n);
2237 if (n1 <= 0)
2238 break;
2239 n += n1;
2240 }
2241 PerlLIO_close(pp[0]);
2242 did_pipes = 0;
2243 if (n) { /* Error */
2244 int pid2, status;
8c51524e 2245 PerlLIO_close(p[This]);
1f852d0d
NIS
2246 if (n != sizeof(int))
2247 Perl_croak(aTHX_ "panic: kid popen errno read");
2248 do {
2249 pid2 = wait4pid(pid, &status, 0);
2250 } while (pid2 == -1 && errno == EINTR);
2251 errno = errkid; /* Propagate errno from kid */
4608196e 2252 return NULL;
1f852d0d
NIS
2253 }
2254 }
2255 if (did_pipes)
2256 PerlLIO_close(pp[0]);
2257 return PerlIO_fdopen(p[This], mode);
2258#else
4a7d1889
NIS
2259 Perl_croak(aTHX_ "List form of piped open not implemented");
2260 return (PerlIO *) NULL;
1f852d0d 2261#endif
4a7d1889
NIS
2262}
2263
5f05dabc 2264 /* VMS' my_popen() is in VMS.c, same with OS/2. */
cd39f2b6 2265#if (!defined(DOSISH) || defined(HAS_FORK) || defined(AMIGAOS)) && !defined(VMS) && !defined(__OPEN_VM) && !defined(EPOC) && !defined(MACOS_TRADITIONAL)
760ac839 2266PerlIO *
3dd43144 2267Perl_my_popen(pTHX_ const char *cmd, const char *mode)
a687059c 2268{
97aff369 2269 dVAR;
a687059c 2270 int p[2];
8ac85365 2271 register I32 This, that;
d8a83dd3 2272 register Pid_t pid;
79072805 2273 SV *sv;
bfce84ec 2274 const I32 doexec = !(*cmd == '-' && cmd[1] == '\0');
e446cec8
IZ
2275 I32 did_pipes = 0;
2276 int pp[2];
a687059c 2277
45bc9206 2278 PERL_FLUSHALL_FOR_CHILD;
ddcf38b7
IZ
2279#ifdef OS2
2280 if (doexec) {
23da6c43 2281 return my_syspopen(aTHX_ cmd,mode);
ddcf38b7 2282 }
a1d180c4 2283#endif
8ac85365
NIS
2284 This = (*mode == 'w');
2285 that = !This;
3280af22 2286 if (doexec && PL_tainting) {
bbce6d69
PP
2287 taint_env();
2288 taint_proper("Insecure %s%s", "EXEC");
d48672a2 2289 }
c2267164 2290 if (PerlProc_pipe(p) < 0)
4608196e 2291 return NULL;
e446cec8
IZ
2292 if (doexec && PerlProc_pipe(pp) >= 0)
2293 did_pipes = 1;
52e18b1f 2294 while ((pid = PerlProc_fork()) < 0) {
a687059c 2295 if (errno != EAGAIN) {
6ad3d225 2296 PerlLIO_close(p[This]);
b5ac89c3 2297 PerlLIO_close(p[that]);
e446cec8
IZ
2298 if (did_pipes) {
2299 PerlLIO_close(pp[0]);
2300 PerlLIO_close(pp[1]);
2301 }
a687059c 2302 if (!doexec)
cea2e8a9 2303 Perl_croak(aTHX_ "Can't fork");
4608196e 2304 return NULL;
a687059c
LW
2305 }
2306 sleep(5);
2307 }
2308 if (pid == 0) {
79072805
LW
2309 GV* tmpgv;
2310
30ac6d9b
GS
2311#undef THIS
2312#undef THAT
a687059c 2313#define THIS that
8ac85365 2314#define THAT This
e446cec8
IZ
2315 if (did_pipes) {
2316 PerlLIO_close(pp[0]);
2317#if defined(HAS_FCNTL) && defined(F_SETFD)
2318 fcntl(pp[1], F_SETFD, FD_CLOEXEC);
2319#endif
2320 }
a687059c 2321 if (p[THIS] != (*mode == 'r')) {
6ad3d225
GS
2322 PerlLIO_dup2(p[THIS], *mode == 'r');
2323 PerlLIO_close(p[THIS]);
b5ac89c3
NIS
2324 if (p[THAT] != (*mode == 'r')) /* if dup2() didn't close it */
2325 PerlLIO_close(p[THAT]);
a687059c 2326 }
b5ac89c3
NIS
2327 else
2328 PerlLIO_close(p[THAT]);
4435c477 2329#ifndef OS2
a687059c 2330 if (doexec) {
a0d0e21e 2331#if !defined(HAS_FCNTL) || !defined(F_SETFD)
ae986130
LW
2332#ifndef NOFILE
2333#define NOFILE 20
2334#endif
a080fe3d 2335 {
3aed30dc 2336 int fd;
a080fe3d
NIS
2337
2338 for (fd = PL_maxsysfd + 1; fd < NOFILE; fd++)
2339 if (fd != pp[1])
3aed30dc 2340 PerlLIO_close(fd);
a080fe3d 2341 }
ae986130 2342#endif
a080fe3d
NIS
2343 /* may or may not use the shell */
2344 do_exec3(cmd, pp[1], did_pipes);
6ad3d225 2345 PerlProc__exit(1);
a687059c 2346 }
4435c477 2347#endif /* defined OS2 */
fafc274c 2348 if ((tmpgv = gv_fetchpvs("$", GV_ADD|GV_NOTQUAL, SVt_PV))) {
4d76a344 2349 SvREADONLY_off(GvSV(tmpgv));
7766f137 2350 sv_setiv(GvSV(tmpgv), PerlProc_getpid());
4d76a344
RGS
2351 SvREADONLY_on(GvSV(tmpgv));
2352 }
2353#ifdef THREADS_HAVE_PIDS
2354 PL_ppid = (IV)getppid();
2355#endif
3280af22 2356 PL_forkprocess = 0;
ca0c25f6 2357#ifdef PERL_USES_PL_PIDSTATUS
3280af22 2358 hv_clear(PL_pidstatus); /* we have no children */
ca0c25f6 2359#endif
4608196e 2360 return NULL;
a687059c
LW
2361#undef THIS
2362#undef THAT
2363 }
b5ac89c3 2364 do_execfree(); /* free any memory malloced by child on vfork */
e446cec8
IZ
2365 if (did_pipes)
2366 PerlLIO_close(pp[1]);
8ac85365 2367 if (p[that] < p[This]) {
6ad3d225
GS
2368 PerlLIO_dup2(p[This], p[that]);
2369 PerlLIO_close(p[This]);
8ac85365 2370 p[This] = p[that];
62b28dd9 2371 }
b5ac89c3
NIS
2372 else
2373 PerlLIO_close(p[that]);
2374
4755096e 2375 LOCK_FDPID_MUTEX;
3280af22 2376 sv = *av_fetch(PL_fdpid,p[This],TRUE);
4755096e 2377 UNLOCK_FDPID_MUTEX;
862a34c6 2378 SvUPGRADE(sv,SVt_IV);
45977657 2379 SvIV_set(sv, pid);
3280af22 2380 PL_forkprocess = pid;
e446cec8
IZ
2381 if (did_pipes && pid > 0) {
2382 int errkid;
bb7a0f54
MHM
2383 unsigned n = 0;
2384 SSize_t n1;
e446cec8
IZ
2385
2386 while (n < sizeof(int)) {
2387 n1 = PerlLIO_read(pp[0],
2388 (void*)(((char*)&errkid)+n),
2389 (sizeof(int)) - n);
2390 if (n1 <= 0)
2391 break;
2392 n += n1;
2393 }
2f96c702
IZ
2394 PerlLIO_close(pp[0]);
2395 did_pipes = 0;
e446cec8 2396 if (n) { /* Error */
faa466a7 2397 int pid2, status;
8c51524e 2398 PerlLIO_close(p[This]);
e446cec8 2399 if (n != sizeof(int))
cea2e8a9 2400 Perl_croak(aTHX_ "panic: kid popen errno read");
faa466a7
RG
2401 do {
2402 pid2 = wait4pid(pid, &status, 0);
2403 } while (pid2 == -1 && errno == EINTR);
e446cec8 2404 errno = errkid; /* Propagate errno from kid */
4608196e 2405 return NULL;
e446cec8
IZ
2406 }
2407 }
2408 if (did_pipes)
2409 PerlLIO_close(pp[0]);
8ac85365 2410 return PerlIO_fdopen(p[This], mode);
a687059c 2411}
7c0587c8 2412#else
85ca448a 2413#if defined(atarist) || defined(EPOC)
7c0587c8 2414FILE *popen();
760ac839 2415PerlIO *
864dbfa3 2416Perl_my_popen(pTHX_ char *cmd, char *mode)
7c0587c8 2417{
45bc9206 2418 PERL_FLUSHALL_FOR_CHILD;
a1d180c4
NIS
2419 /* Call system's popen() to get a FILE *, then import it.
2420 used 0 for 2nd parameter to PerlIO_importFILE;
2421 apparently not used
2422 */
2423 return PerlIO_importFILE(popen(cmd, mode), 0);
7c0587c8 2424}
2b96b0a5
JH
2425#else
2426#if defined(DJGPP)
2427FILE *djgpp_popen();
2428PerlIO *
2429Perl_my_popen(pTHX_ char *cmd, char *mode)
2430{
2431 PERL_FLUSHALL_FOR_CHILD;
2432 /* Call system's popen() to get a FILE *, then import it.
2433 used 0 for 2nd parameter to PerlIO_importFILE;
2434 apparently not used
2435 */
2436 return PerlIO_importFILE(djgpp_popen(cmd, mode), 0);
2437}
2438#endif
7c0587c8
LW
2439#endif
2440
2441#endif /* !DOSISH */
a687059c 2442
52e18b1f
GS
2443/* this is called in parent before the fork() */
2444void
2445Perl_atfork_lock(void)
2446{
27da23d5 2447 dVAR;
3db8f154 2448#if defined(USE_ITHREADS)
52e18b1f
GS
2449 /* locks must be held in locking order (if any) */
2450# ifdef MYMALLOC
2451 MUTEX_LOCK(&PL_malloc_mutex);
2452# endif
2453 OP_REFCNT_LOCK;
2454#endif
2455}
2456
2457/* this is called in both parent and child after the fork() */
2458void
2459Perl_atfork_unlock(void)
2460{
27da23d5 2461 dVAR;
3db8f154 2462#if defined(USE_ITHREADS)
52e18b1f
GS
2463 /* locks must be released in same order as in atfork_lock() */
2464# ifdef MYMALLOC
2465 MUTEX_UNLOCK(&PL_malloc_mutex);
2466# endif
2467 OP_REFCNT_UNLOCK;
2468#endif
2469}
2470
2471Pid_t
2472Perl_my_fork(void)
2473{
2474#if defined(HAS_FORK)
2475 Pid_t pid;
3db8f154 2476#if defined(USE_ITHREADS) && !defined(HAS_PTHREAD_ATFORK)
52e18b1f
GS
2477 atfork_lock();
2478 pid = fork();
2479 atfork_unlock();
2480#else
2481 /* atfork_lock() and atfork_unlock() are installed as pthread_atfork()
2482 * handlers elsewhere in the code */
2483 pid = fork();
2484#endif
2485 return pid;
2486#else
2487 /* this "canna happen" since nothing should be calling here if !HAS_FORK */
2488 Perl_croak_nocontext("fork() not available");
b961a566 2489 return 0;
52e18b1f
GS
2490#endif /* HAS_FORK */
2491}
2492
748a9306 2493#ifdef DUMP_FDS
35ff7856 2494void
864dbfa3 2495Perl_dump_fds(pTHX_ char *s)
ae986130
LW
2496{
2497 int fd;
c623ac67 2498 Stat_t tmpstatbuf;
ae986130 2499
bf49b057 2500 PerlIO_printf(Perl_debug_log,"%s", s);
ae986130 2501 for (fd = 0; fd < 32; fd++) {
6ad3d225 2502 if (PerlLIO_fstat(fd,&tmpstatbuf) >= 0)
bf49b057 2503 PerlIO_printf(Perl_debug_log," %d",fd);
ae986130 2504 }
bf49b057 2505 PerlIO_printf(Perl_debug_log,"\n");
27da23d5 2506 return;
ae986130 2507}
35ff7856 2508#endif /* DUMP_FDS */
ae986130 2509
fe14fcc3 2510#ifndef HAS_DUP2
fec02dd3 2511int
ba106d47 2512dup2(int oldfd, int newfd)
a687059c 2513{
a0d0e21e 2514#if defined(HAS_FCNTL) && defined(F_DUPFD)
fec02dd3
AD
2515 if (oldfd == newfd)
2516 return oldfd;
6ad3d225 2517 PerlLIO_close(newfd);
fec02dd3 2518 return fcntl(oldfd, F_DUPFD, newfd);
62b28dd9 2519#else
fc36a67e
PP
2520#define DUP2_MAX_FDS 256
2521 int fdtmp[DUP2_MAX_FDS];
79072805 2522 I32 fdx = 0;
ae986130
LW
2523 int fd;
2524
fe14fcc3 2525 if (oldfd == newfd)
fec02dd3 2526 return oldfd;
6ad3d225 2527 PerlLIO_close(newfd);
fc36a67e 2528 /* good enough for low fd's... */
6ad3d225 2529 while ((fd = PerlLIO_dup(oldfd)) != newfd && fd >= 0) {
fc36a67e 2530 if (fdx >= DUP2_MAX_FDS) {
6ad3d225 2531 PerlLIO_close(fd);
fc36a67e
PP
2532 fd = -1;
2533 break;
2534 }
ae986130 2535 fdtmp[fdx++] = fd;
fc36a67e 2536 }
ae986130 2537 while (fdx > 0)
6ad3d225 2538 PerlLIO_close(fdtmp[--fdx]);
fec02dd3 2539 return fd;
62b28dd9 2540#endif
a687059c
LW
2541}
2542#endif
2543
64ca3a65 2544#ifndef PERL_MICRO
ff68c719
PP
2545#ifdef HAS_SIGACTION
2546
abea2c45
HS
2547#ifdef MACOS_TRADITIONAL
2548/* We don't want restart behavior on MacOS */
2549#undef SA_RESTART
2550#endif
2551
ff68c719 2552Sighandler_t
864dbfa3 2553Perl_rsignal(pTHX_ int signo, Sighandler_t handler)
ff68c719 2554{
27da23d5 2555 dVAR;
ff68c719
PP
2556 struct sigaction act, oact;
2557
a10b1e10
JH
2558#ifdef USE_ITHREADS
2559 /* only "parent" interpreter can diddle signals */
2560 if (PL_curinterp != aTHX)
8aad04aa 2561 return (Sighandler_t) SIG_ERR;
a10b1e10
JH
2562#endif
2563
8aad04aa 2564 act.sa_handler = (void(*)(int))handler;
ff68c719
PP
2565 sigemptyset(&act.sa_mask);
2566 act.sa_flags = 0;
2567#ifdef SA_RESTART
4ffa73a3
JH
2568 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
2569 act.sa_flags |= SA_RESTART; /* SVR4, 4.3+BSD */
0a8e0eff 2570#endif
358837b8 2571#if defined(SA_NOCLDWAIT) && !defined(BSDish) /* See [perl #18849] */
8aad04aa 2572 if (signo == SIGCHLD && handler == (Sighandler_t) SIG_IGN)
85264bed
CS
2573 act.sa_flags |= SA_NOCLDWAIT;
2574#endif
ff68c719 2575 if (sigaction(signo, &act, &oact) == -1)
8aad04aa 2576 return (Sighandler_t) SIG_ERR;
ff68c719 2577 else
8aad04aa 2578 return (Sighandler_t) oact.sa_handler;
ff68c719
PP
2579}
2580
2581Sighandler_t
864dbfa3 2582Perl_rsignal_state(pTHX_ int signo)
ff68c719
PP
2583{
2584 struct sigaction oact;
96a5add6 2585 PERL_UNUSED_CONTEXT;
ff68c719
PP
2586
2587 if (sigaction(signo, (struct sigaction *)NULL, &oact) == -1)
8aad04aa 2588 return (Sighandler_t) SIG_ERR;
ff68c719 2589 else
8aad04aa 2590 return (Sighandler_t) oact.sa_handler;
ff68c719
PP
2591}
2592
2593int
864dbfa3 2594Perl_rsignal_save(pTHX_ int signo, Sighandler_t handler, Sigsave_t *save)
ff68c719 2595{
27da23d5 2596 dVAR;
ff68c719
PP
2597 struct sigaction act;
2598
a10b1e10
JH
2599#ifdef USE_ITHREADS
2600 /* only "parent" interpreter can diddle signals */
2601 if (PL_curinterp != aTHX)
2602 return -1;
2603#endif
2604
8aad04aa 2605 act.sa_handler = (void(*)(int))handler;
ff68c719
PP
2606 sigemptyset(&act.sa_mask);
2607 act.sa_flags = 0;
2608#ifdef SA_RESTART
4ffa73a3
JH
2609 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
2610 act.sa_flags |= SA_RESTART; /* SVR4, 4.3+BSD */
0a8e0eff 2611#endif
36b5d377 2612#if defined(SA_NOCLDWAIT) && !defined(BSDish) /* See [perl #18849] */
8aad04aa 2613 if (signo == SIGCHLD && handler == (Sighandler_t) SIG_IGN)
85264bed
CS
2614 act.sa_flags |= SA_NOCLDWAIT;
2615#endif
ff68c719
PP
2616 return sigaction(signo, &act, save);
2617}
2618
2619int
864dbfa3 2620Perl_rsignal_restore(pTHX_ int signo, Sigsave_t *save)
ff68c719 2621{
27da23d5 2622 dVAR;
a10b1e10
JH
2623#ifdef USE_ITHREADS
2624 /* only "parent" interpreter can diddle signals */
2625 if (PL_curinterp != aTHX)
2626 return -1;
2627#endif
2628
ff68c719
PP
2629 return sigaction(signo, save, (struct sigaction *)NULL);
2630}
2631
2632#else /* !HAS_SIGACTION */
2633
2634Sighandler_t
864dbfa3 2635Perl_rsignal(pTHX_ int signo, Sighandler_t handler)
ff68c719 2636{
39f1703b 2637#if defined(USE_ITHREADS) && !defined(WIN32)
a10b1e10
JH
2638 /* only "parent" interpreter can diddle signals */
2639 if (PL_curinterp != aTHX)
8aad04aa 2640 return (Sighandler_t) SIG_ERR;
a10b1e10
JH
2641#endif
2642
6ad3d225 2643 return PerlProc_signal(signo, handler);
ff68c719
PP
2644}
2645
fabdb6c0 2646static Signal_t
4e35701f 2647sig_trap(int signo)
ff68c719 2648{
27da23d5
JH
2649 dVAR;
2650 PL_sig_trapped++;
ff68c719
PP
2651}
2652
2653Sighandler_t
864dbfa3 2654Perl_rsignal_state(pTHX_ int signo)
ff68c719 2655{
27da23d5 2656 dVAR;
ff68c719
PP
2657 Sighandler_t oldsig;
2658
39f1703b 2659#if defined(USE_ITHREADS) && !defined(WIN32)
a10b1e10
JH
2660 /* only "parent" interpreter can diddle signals */
2661 if (PL_curinterp != aTHX)
8aad04aa 2662 return (Sighandler_t) SIG_ERR;
a10b1e10
JH
2663#endif
2664
27da23d5 2665 PL_sig_trapped = 0;
6ad3d225
GS
2666 oldsig = PerlProc_signal(signo, sig_trap);
2667 PerlProc_signal(signo, oldsig);
27da23d5 2668 if (PL_sig_trapped)
3aed30dc 2669 PerlProc_kill(PerlProc_getpid(), signo);
ff68c719
PP
2670 return oldsig;
2671}
2672
2673int
864dbfa3 2674Perl_rsignal_save(pTHX_ int signo, Sighandler_t handler, Sigsave_t *save)
ff68c719 2675{
39f1703b 2676#if defined(USE_ITHREADS) && !defined(WIN32)
a10b1e10
JH
2677 /* only "parent" interpreter can diddle signals */
2678 if (PL_curinterp != aTHX)
2679 return -1;
2680#endif
6ad3d225 2681 *save = PerlProc_signal(signo, handler);
8aad04aa 2682 return (*save == (Sighandler_t) SIG_ERR) ? -1 : 0;
ff68c719
PP
2683}
2684
2685int
864dbfa3 2686Perl_rsignal_restore(pTHX_ int signo, Sigsave_t *save)
ff68c719 2687{
39f1703b 2688#if defined(USE_ITHREADS) && !defined(WIN32)
a10b1e10
JH
2689 /* only "parent" interpreter can diddle signals */
2690 if (PL_curinterp != aTHX)
2691 return -1;
2692#endif
8aad04aa 2693 return (PerlProc_signal(signo, *save) == (Sighandler_t) SIG_ERR) ? -1 : 0;
ff68c719
PP
2694}
2695
2696#endif /* !HAS_SIGACTION */
64ca3a65 2697#endif /* !PERL_MICRO */
ff68c719 2698
5f05dabc 2699 /* VMS' my_pclose() is in VMS.c; same with OS/2 */
cd39f2b6 2700#if (!defined(DOSISH) || defined(HAS_FORK) || defined(AMIGAOS)) && !defined(VMS) && !defined(__OPEN_VM) && !defined(EPOC) && !defined(MACOS_TRADITIONAL)
79072805 2701I32
864dbfa3 2702Perl_my_pclose(pTHX_ PerlIO *ptr)
a687059c 2703{
97aff369 2704 dVAR;
ff68c719 2705 Sigsave_t hstat, istat, qstat;
a687059c 2706 int status;
a0d0e21e 2707 SV **svp;
d8a83dd3
JH
2708 Pid_t pid;
2709 Pid_t pid2;
03136e13 2710 bool close_failed;
b7953727 2711 int saved_errno = 0;
22fae026
TM
2712#ifdef WIN32
2713 int saved_win32_errno;
2714#endif
a687059c 2715
4755096e 2716 LOCK_FDPID_MUTEX;
3280af22 2717 svp = av_fetch(PL_fdpid,PerlIO_fileno(ptr),TRUE);
4755096e 2718 UNLOCK_FDPID_MUTEX;
25d92023 2719 pid = (SvTYPE(*svp) == SVt_IV) ? SvIVX(*svp) : -1;
a0d0e21e 2720 SvREFCNT_dec(*svp);
3280af22 2721 *svp = &PL_sv_undef;
ddcf38b7
IZ
2722#ifdef OS2
2723 if (pid == -1) { /* Opened by popen. */
2724 return my_syspclose(ptr);
2725 }
a1d180c4 2726#endif
03136e13
CS
2727 if ((close_failed = (PerlIO_close(ptr) == EOF))) {
2728 saved_errno = errno;
22fae026
TM
2729#ifdef WIN32
2730 saved_win32_errno = GetLastError();
2731#endif
03136e13 2732 }
7c0587c8 2733#ifdef UTS
6ad3d225 2734 if(PerlProc_kill(pid, 0) < 0) { return(pid); } /* HOM 12/23/91 */
7c0587c8 2735#endif
64ca3a65 2736#ifndef PERL_MICRO
8aad04aa
JH
2737 rsignal_save(SIGHUP, (Sighandler_t) SIG_IGN, &hstat);
2738 rsignal_save(SIGINT, (Sighandler_t) SIG_IGN, &istat);
2739 rsignal_save(SIGQUIT, (Sighandler_t) SIG_IGN, &qstat);
64ca3a65 2740#endif
748a9306 2741 do {
1d3434b8
GS
2742 pid2 = wait4pid(pid, &status, 0);
2743 } while (pid2 == -1 && errno == EINTR);
64ca3a65 2744#ifndef PERL_MICRO
ff68c719
PP
2745 rsignal_restore(SIGHUP, &hstat);
2746 rsignal_restore(SIGINT, &istat);
2747 rsignal_restore(SIGQUIT, &qstat);
64ca3a65 2748#endif
03136e13 2749 if (close_failed) {
ce6e1103 2750 SETERRNO(saved_errno, 0);
03136e13
CS
2751 return -1;
2752 }
1d3434b8 2753 return(pid2 < 0 ? pid2 : status == 0 ? 0 : (errno = 0, status));
20188a90 2754}
4633a7c4
LW
2755#endif /* !DOSISH */
2756
2986a63f 2757#if (!defined(DOSISH) || defined(OS2) || defined(WIN32) || defined(NETWARE)) && !defined(MACOS_TRADITIONAL)
79072805 2758I32
d8a83dd3 2759Perl_wait4pid(pTHX_ Pid_t pid, int *statusp, int flags)
20188a90 2760{
97aff369 2761 dVAR;
27da23d5 2762 I32 result = 0;
b7953727
JH
2763 if (!pid)
2764 return -1;
ca0c25f6 2765#ifdef PERL_USES_PL_PIDSTATUS
b7953727 2766 {
3aed30dc 2767 if (pid > 0) {
12072db5
NC
2768 /* The keys in PL_pidstatus are now the raw 4 (or 8) bytes of the
2769 pid, rather than a string form. */
c4420975 2770 SV * const * const svp = hv_fetch(PL_pidstatus,(const char*) &pid,sizeof(Pid_t),FALSE);
3aed30dc
HS
2771 if (svp && *svp != &PL_sv_undef) {
2772 *statusp = SvIVX(*svp);
12072db5
NC
2773 (void)hv_delete(PL_pidstatus,(const char*) &pid,sizeof(Pid_t),
2774 G_DISCARD);
3aed30dc
HS
2775 return pid;
2776 }
2777 }
2778 else {
2779 HE *entry;
2780
2781 hv_iterinit(PL_pidstatus);
2782 if ((entry = hv_iternext(PL_pidstatus))) {
c4420975 2783 SV * const sv = hv_iterval(PL_pidstatus,entry);
7ea75b61 2784 I32 len;
0bcc34c2 2785 const char * const spid = hv_iterkey(entry,&len);
27da23d5 2786
12072db5
NC
2787 assert (len == sizeof(Pid_t));
2788 memcpy((char *)&pid, spid, len);
3aed30dc 2789 *statusp = SvIVX(sv);
7b9a3241
NC
2790 /* The hash iterator is currently on this entry, so simply
2791 calling hv_delete would trigger the lazy delete, which on
2792 aggregate does more work, beacuse next call to hv_iterinit()
2793 would spot the flag, and have to call the delete routine,
2794 while in the meantime any new entries can't re-use that
2795 memory. */
2796 hv_iterinit(PL_pidstatus);
7ea75b61 2797 (void)hv_delete(PL_pidstatus,spid,len,G_DISCARD);
3aed30dc
HS
2798 return pid;
2799 }
20188a90
LW
2800 }
2801 }
68a29c53 2802#endif
79072805 2803#ifdef HAS_WAITPID
367f3c24
IZ
2804# ifdef HAS_WAITPID_RUNTIME
2805 if (!HAS_WAITPID_RUNTIME)
2806 goto hard_way;
2807# endif
cddd4526 2808 result = PerlProc_waitpid(pid,statusp,flags);
dfcfdb64 2809 goto finish;
367f3c24
IZ
2810#endif
2811#if !defined(HAS_WAITPID) && defined(HAS_WAIT4)
4608196e 2812 result = wait4((pid==-1)?0:pid,statusp,flags,NULL);
dfcfdb64 2813 goto finish;
367f3c24 2814#endif
ca0c25f6 2815#ifdef PERL_USES_PL_PIDSTATUS
27da23d5 2816#if defined(HAS_WAITPID) && defined(HAS_WAITPID_RUNTIME)
367f3c24 2817 hard_way:
27da23d5 2818#endif
a0d0e21e 2819 {
a0d0e21e 2820 if (flags)
cea2e8a9 2821 Perl_croak(aTHX_ "Can't do waitpid with flags");
a0d0e21e 2822 else {
76e3520e 2823 while ((result = PerlProc_wait(statusp)) != pid && pid > 0 && result >= 0)
a0d0e21e
LW
2824 pidgone(result,*statusp);
2825 if (result < 0)
2826 *statusp = -1;
2827 }
a687059c
LW
2828 }
2829#endif
27da23d5 2830#if defined(HAS_WAITPID) || defined(HAS_WAIT4)
dfcfdb64 2831 finish:
27da23d5 2832#endif
cddd4526
NIS
2833 if (result < 0 && errno == EINTR) {
2834 PERL_ASYNC_CHECK();
2835 }
2836 return result;
a687059c 2837}
2986a63f 2838#endif /* !DOSISH || OS2 || WIN32 || NETWARE */
a687059c 2839
ca0c25f6 2840#ifdef PERL_USES_PL_PIDSTATUS
7c0587c8 2841void
d8a83dd3 2842Perl_pidgone(pTHX_ Pid_t pid, int status)
a687059c 2843{
79072805 2844 register SV *sv;
a687059c 2845
12072db5 2846 sv = *hv_fetch(PL_pidstatus,(const char*)&pid,sizeof(Pid_t),TRUE);
862a34c6 2847 SvUPGRADE(sv,SVt_IV);
45977657 2848 SvIV_set(sv, status);
20188a90 2849 return;
a687059c 2850}
ca0c25f6 2851#endif
a687059c 2852
85ca448a 2853#if defined(atarist) || defined(OS2) || defined(EPOC)
7c0587c8 2854int pclose();
ddcf38b7
IZ
2855#ifdef HAS_FORK
2856int /* Cannot prototype with I32
2857 in os2ish.h. */
ba106d47 2858my_syspclose(PerlIO *ptr)
ddcf38b7 2859#else
79072805 2860I32
864dbfa3 2861Perl_my_pclose(pTHX_ PerlIO *ptr)
a1d180c4 2862#endif
a687059c 2863{
760ac839 2864 /* Needs work for PerlIO ! */
c4420975 2865 FILE * const f = PerlIO_findFILE(ptr);
7452cf6a 2866 const I32 result = pclose(f);
2b96b0a5
JH
2867 PerlIO_releaseFILE(ptr,f);
2868 return result;
2869}
2870#endif
2871
933fea7f 2872#if defined(DJGPP)
2b96b0a5
JH
2873int djgpp_pclose();
2874I32
2875Perl_my_pclose(pTHX_ PerlIO *ptr)
2876{
2877 /* Needs work for PerlIO ! */
c4420975 2878 FILE * const f = PerlIO_findFILE(ptr);
2b96b0a5 2879 I32 result = djgpp_pclose(f);
933fea7f 2880 result = (result << 8) & 0xff00;
760ac839
LW
2881 PerlIO_releaseFILE(ptr,f);
2882 return result;
a687059c 2883}
7c0587c8 2884#endif
9f68db38
LW
2885
2886void
864dbfa3 2887Perl_repeatcpy(pTHX_ register char *to, register const char *from, I32 len, register I32 count)
9f68db38 2888{
79072805 2889 register I32 todo;
c4420975 2890 register const char * const frombase = from;
96a5add6 2891 PERL_UNUSED_CONTEXT;
9f68db38
LW
2892
2893 if (len == 1) {
08105a92 2894 register const char c = *from;
9f68db38 2895 while (count-- > 0)
5926133d 2896 *to++ = c;
9f68db38
LW
2897 return;
2898 }
2899 while (count-- > 0) {
2900 for (todo = len; todo > 0; todo--) {
2901 *to++ = *from++;
2902 }
2903 from = frombase;
2904 }
2905}
0f85fab0 2906
fe14fcc3 2907#ifndef HAS_RENAME
79072805 2908I32
4373e329 2909Perl_same_dirent(pTHX_ const char *a, const char *b)
62b28dd9 2910{
93a17b20
LW
2911 char *fa = strrchr(a,'/');
2912 char *fb = strrchr(b,'/');
c623ac67
GS
2913 Stat_t tmpstatbuf1;
2914 Stat_t tmpstatbuf2;
c4420975 2915 SV * const tmpsv = sv_newmortal();
62b28dd9
LW
2916
2917 if (fa)
2918 fa++;
2919 else
2920 fa = a;
2921 if (fb)
2922 fb++;
2923 else
2924 fb = b;
2925 if (strNE(a,b))
2926 return FALSE;
2927 if (fa == a)
616d8c9c 2928 sv_setpvn(tmpsv, ".", 1);
62b28dd9 2929 else
46fc3d4c 2930 sv_setpvn(tmpsv, a, fa - a);
95a20fc0 2931 if (PerlLIO_stat(SvPVX_const(tmpsv), &tmpstatbuf1) < 0)
62b28dd9
LW
2932 return FALSE;
2933 if (fb == b)
616d8c9c 2934 sv_setpvn(tmpsv, ".", 1);
62b28dd9 2935 else
46fc3d4c 2936 sv_setpvn(tmpsv, b, fb - b);
95a20fc0 2937 if (PerlLIO_stat(SvPVX_const(tmpsv), &tmpstatbuf2) < 0)
62b28dd9
LW
2938 return FALSE;
2939 return tmpstatbuf1.st_dev == tmpstatbuf2.st_dev &&
2940 tmpstatbuf1.st_ino == tmpstatbuf2.st_ino;
2941}
fe14fcc3
LW
2942#endif /* !HAS_RENAME */
2943
491527d0 2944char*
7f315aed
NC
2945Perl_find_script(pTHX_ const char *scriptname, bool dosearch,
2946 const char *const *const search_ext, I32 flags)
491527d0 2947{
97aff369 2948 dVAR;
bd61b366
SS
2949 const char *xfound = NULL;
2950 char *xfailed = NULL;
0f31cffe 2951 char tmpbuf[MAXPATHLEN];
491527d0 2952 register char *s;
5f74f29c 2953 I32 len = 0;
491527d0
GS
2954 int retval;
2955#if defined(DOSISH) && !defined(OS2) && !defined(atarist)
2956# define SEARCH_EXTS ".bat", ".cmd", NULL
2957# define MAX_EXT_LEN 4
2958#endif
2959#ifdef OS2
2960# define SEARCH_EXTS ".cmd", ".btm", ".bat", ".pl", NULL
2961# define MAX_EXT_LEN 4
2962#endif
2963#ifdef VMS
2964# define SEARCH_EXTS ".pl", ".com", NULL
2965# define MAX_EXT_LEN 4
2966#endif
2967 /* additional extensions to try in each dir if scriptname not found */
2968#ifdef SEARCH_EXTS
0bcc34c2 2969 static const char *const exts[] = { SEARCH_EXTS };
7f315aed 2970 const char *const *const ext = search_ext ? search_ext : exts;
491527d0 2971 int extidx = 0, i = 0;
bd61b366 2972 const char *curext = NULL;
491527d0 2973#else
53c1dcc0 2974 PERL_UNUSED_ARG(search_ext);
491527d0
GS
2975# define MAX_EXT_LEN 0
2976#endif
2977
2978 /*
2979 * If dosearch is true and if scriptname does not contain path
2980 * delimiters, search the PATH for scriptname.
2981 *
2982 * If SEARCH_EXTS is also defined, will look for each
2983 * scriptname{SEARCH_EXTS} whenever scriptname is not found
2984 * while searching the PATH.
2985 *
2986 * Assuming SEARCH_EXTS is C<".foo",".bar",NULL>, PATH search
2987 * proceeds as follows:
2988 * If DOSISH or VMSISH:
2989 * + look for ./scriptname{,.foo,.bar}
2990 * + search the PATH for scriptname{,.foo,.bar}
2991 *
2992 * If !DOSISH:
2993 * + look *only* in the PATH for scriptname{,.foo,.bar} (note
2994 * this will not look in '.' if it's not in the PATH)
2995 */
84486fc6 2996 tmpbuf[0] = '\0';
491527d0
GS
2997
2998#ifdef VMS
2999# ifdef ALWAYS_DEFTYPES
3000 len = strlen(scriptname);
3001 if (!(len == 1 && *scriptname == '-') && scriptname[len-1] != ':') {
c4420975 3002 int idx = 0, deftypes = 1;
491527d0
GS
3003 bool seen_dot = 1;
3004
bd61b366 3005 const int hasdir = !dosearch || (strpbrk(scriptname,":[</") != NULL);
491527d0
GS
3006# else
3007 if (dosearch) {
c4420975 3008 int idx = 0, deftypes = 1;
491527d0
GS
3009 bool seen_dot = 1;
3010
bd61b366 3011 const int hasdir = (strpbrk(scriptname,":[</") != NULL);
491527d0
GS
3012# endif
3013 /* The first time through, just add SEARCH_EXTS to whatever we
3014 * already have, so we can check for default file types. */
3015 while (deftypes ||
84486fc6 3016 (!hasdir && my_trnlnm("DCL$PATH",tmpbuf,idx++)) )
491527d0
GS
3017 {
3018 if (deftypes) {
3019 deftypes = 0;
84486fc6 3020 *tmpbuf = '\0';
491527d0 3021 }
84486fc6
GS
3022 if ((strlen(tmpbuf) + strlen(scriptname)
3023 + MAX_EXT_LEN) >= sizeof tmpbuf)
491527d0 3024 continue; /* don't search dir with too-long name */
6fca0082 3025 my_strlcat(tmpbuf, scriptname, sizeof(tmpbuf));
491527d0
GS
3026#else /* !VMS */
3027
3028#ifdef DOSISH
3029 if (strEQ(scriptname, "-"))
3030 dosearch = 0;
3031 if (dosearch) { /* Look in '.' first. */
fe2774ed 3032 const char *cur = scriptname;
491527d0
GS
3033#ifdef SEARCH_EXTS
3034 if ((curext = strrchr(scriptname,'.'))) /* possible current ext */
3035 while (ext[i])
3036 if (strEQ(ext[i++],curext)) {
3037 extidx = -1; /* already has an ext */
3038 break;
3039 }
3040 do {
3041#endif
3042 DEBUG_p(PerlIO_printf(Perl_debug_log,
3043 "Looking for %s\n",cur));
017f25f1
IZ
3044 if (PerlLIO_stat(cur,&PL_statbuf) >= 0
3045 && !S_ISDIR(PL_statbuf.st_mode)) {
491527d0
GS
3046 dosearch = 0;
3047 scriptname = cur;
3048#ifdef SEARCH_EXTS
3049 break;
3050#endif
3051 }
3052#ifdef SEARCH_EXTS
3053 if (cur == scriptname) {
3054 len = strlen(scriptname);
84486fc6 3055 if (len+MAX_EXT_LEN+1 >= sizeof(tmpbuf))
491527d0 3056 break;
9e4425f7
SH
3057 my_strlcpy(tmpbuf, scriptname, sizeof(tmpbuf));
3058 cur = tmpbuf;
491527d0
GS
3059 }
3060 } while (extidx >= 0 && ext[extidx] /* try an extension? */
6fca0082 3061 && my_strlcpy(tmpbuf+len, ext[extidx++], sizeof(tmpbuf) - len));
491527d0
GS
3062#endif
3063 }
3064#endif
3065
cd39f2b6
JH
3066#ifdef MACOS_TRADITIONAL
3067 if (dosearch && !strchr(scriptname, ':') &&
3068 (s = PerlEnv_getenv("Commands")))
3069#else
491527d0
GS
3070 if (dosearch && !strchr(scriptname, '/')
3071#ifdef DOSISH
3072 && !strchr(scriptname, '\\')
3073#endif
cd39f2b6
JH
3074 && (s = PerlEnv_getenv("PATH")))
3075#endif
3076 {
491527d0 3077 bool seen_dot = 0;
92f0c265 3078
3280af22
NIS
3079 PL_bufend = s + strlen(s);
3080 while (s < PL_bufend) {
cd39f2b6
JH
3081#ifdef MACOS_TRADITIONAL
3082 s = delimcpy(tmpbuf, tmpbuf + sizeof tmpbuf, s, PL_bufend,
3083 ',',
3084 &len);
3085#else
491527d0
GS
3086#if defined(atarist) || defined(DOSISH)
3087 for (len = 0; *s
3088# ifdef atarist
3089 && *s != ','
3090# endif
3091 && *s != ';'; len++, s++) {
84486fc6
GS
3092 if (len < sizeof tmpbuf)
3093 tmpbuf[len] = *s;
491527d0 3094 }
84486fc6
GS
3095 if (len < sizeof tmpbuf)
3096 tmpbuf[len] = '\0';
491527d0 3097#else /* ! (atarist || DOSISH) */
3280af22 3098 s = delimcpy(tmpbuf, tmpbuf + sizeof tmpbuf, s, PL_bufend,
491527d0
GS
3099 ':',
3100 &len);
3101#endif /* ! (atarist || DOSISH) */
cd39f2b6 3102#endif /* MACOS_TRADITIONAL */
3280af22 3103 if (s < PL_bufend)
491527d0 3104 s++;
84486fc6 3105 if (len + 1 + strlen(scriptname) + MAX_EXT_LEN >= sizeof tmpbuf)
491527d0 3106 continue; /* don't search dir with too-long name */
cd39f2b6
JH
3107#ifdef MACOS_TRADITIONAL
3108 if (len && tmpbuf[len - 1] != ':')
3109 tmpbuf[len++] = ':';
3110#else
491527d0 3111 if (len
490a0e98 3112# if defined(atarist) || defined(__MINT__) || defined(DOSISH)
84486fc6
GS
3113 && tmpbuf[len - 1] != '/'
3114 && tmpbuf[len - 1] != '\\'
490a0e98 3115# endif
491527d0 3116 )
84486fc6
GS
3117 tmpbuf[len++] = '/';
3118 if (len == 2 && tmpbuf[0] == '.')
491527d0 3119 seen_dot = 1;
cd39f2b6 3120#endif
28f0d0ec 3121 (void)my_strlcpy(tmpbuf + len, scriptname, sizeof(tmpbuf) - len);
491527d0
GS
3122#endif /* !VMS */
3123
3124#ifdef SEARCH_EXTS
84486fc6 3125 len = strlen(tmpbuf);
491527d0
GS
3126 if (extidx > 0) /* reset after previous loop */
3127 extidx = 0;
3128 do {
3129#endif
84486fc6 3130 DEBUG_p(PerlIO_printf(Perl_debug_log, "Looking for %s\n",tmpbuf));
3280af22 3131 retval = PerlLIO_stat(tmpbuf,&PL_statbuf);
017f25f1
IZ
3132 if (S_ISDIR(PL_statbuf.st_mode)) {
3133 retval = -1;
3134 }
491527d0
GS
3135#ifdef SEARCH_EXTS
3136 } while ( retval < 0 /* not there */
3137 && extidx>=0 && ext[extidx] /* try an extension? */
6fca0082 3138 && my_strlcpy(tmpbuf+len, ext[extidx++], sizeof(tmpbuf) - len)
491527d0
GS
3139 );
3140#endif
3141 if (retval < 0)
3142 continue;
3280af22
NIS
3143 if (S_ISREG(PL_statbuf.st_mode)
3144 && cando(S_IRUSR,TRUE,&PL_statbuf)
73811745 3145#if !defined(DOSISH) && !defined(MACOS_TRADITIONAL)
3280af22 3146 && cando(S_IXUSR,TRUE,&PL_statbuf)
491527d0
GS
3147#endif
3148 )
3149 {
3aed30dc 3150 xfound = tmpbuf; /* bingo! */
491527d0
GS
3151 break;
3152 }
3153 if (!xfailed)
84486fc6 3154 xfailed = savepv(tmpbuf);
491527d0
GS
3155 }
3156#ifndef DOSISH
017f25f1 3157 if (!xfound && !seen_dot && !xfailed &&
a1d180c4 3158 (PerlLIO_stat(scriptname,&PL_statbuf) < 0
017f25f1 3159 || S_ISDIR(PL_statbuf.st_mode)))
491527d0
GS
3160#endif
3161 seen_dot = 1; /* Disable message. */
9ccb31f9
GS
3162 if (!xfound) {
3163 if (flags & 1) { /* do or die? */
3aed30dc 3164 Perl_croak(aTHX_ "Can't %s %s%s%s",
9ccb31f9
GS
3165 (xfailed ? "execute" : "find"),
3166 (xfailed ? xfailed : scriptname),
3167 (xfailed ? "" : " on PATH"),
3168 (xfailed || seen_dot) ? "" : ", '.' not in PATH");
3169 }
bd61b366 3170 scriptname = NULL;
9ccb31f9 3171 }
43c5f42d 3172 Safefree(xfailed);
491527d0
GS
3173 scriptname = xfound;
3174 }
bd61b366 3175 return (scriptname ? savepv(scriptname) : NULL);
491527d0
GS
3176}
3177
ba869deb
GS
3178#ifndef PERL_GET_CONTEXT_DEFINED
3179
3180void *
3181Perl_get_context(void)
3182{
27da23d5 3183 dVAR;
3db8f154 3184#if defined(USE_ITHREADS)
ba869deb
GS
3185# ifdef OLD_PTHREADS_API
3186 pthread_addr_t t;
3187 if (pthread_getspecific(PL_thr_key, &t))
3188 Perl_croak_nocontext("panic: pthread_getspecific");
3189 return (void*)t;
3190# else
bce813aa 3191# ifdef I_MACH_CTHREADS
8b8b35ab 3192 return (void*)cthread_data(cthread_self());
bce813aa 3193# else
8b8b35ab
JH
3194 return (void*)PTHREAD_GETSPECIFIC(PL_thr_key);
3195# endif
c44d3fdb 3196# endif
ba869deb
GS
3197#else
3198 return (void*)NULL;
3199#endif
3200}
3201
3202void
3203Perl_set_context(void *t)
3204{
8772537c 3205 dVAR;
3db8f154 3206#if defined(USE_ITHREADS)
c44d3fdb
GS
3207# ifdef I_MACH_CTHREADS
3208 cthread_set_data(cthread_self(), t);
3209# else
ba869deb
GS
3210 if (pthread_setspecific(PL_thr_key, t))
3211 Perl_croak_nocontext("panic: pthread_setspecific");
c44d3fdb 3212# endif
b464bac0 3213#else
8772537c 3214 PERL_UNUSED_ARG(t);
ba869deb
GS
3215#endif
3216}
3217
3218#endif /* !PERL_GET_CONTEXT_DEFINED */
491527d0 3219
27da23d5 3220#if defined(PERL_GLOBAL_STRUCT) && !defined(PERL_GLOBAL_STRUCT_PRIVATE)
22239a37 3221struct perl_vars *
864dbfa3 3222Perl_GetVars(pTHX)
22239a37 3223{
533c011a 3224 return &PL_Vars;
22239a37 3225}
31fb1209
NIS
3226#endif
3227
1cb0ed9b 3228char **
864dbfa3 3229Perl_get_op_names(pTHX)
31fb1209 3230{
96a5add6
AL
3231 PERL_UNUSED_CONTEXT;
3232 return (char **)PL_op_name;
31fb1209
NIS
3233}
3234
1cb0ed9b 3235char **
864dbfa3 3236Perl_get_op_descs(pTHX)
31fb1209 3237{
96a5add6
AL
3238 PERL_UNUSED_CONTEXT;
3239 return (char **)PL_op_desc;
31fb1209 3240}
9e6b2b00 3241
e1ec3a88 3242const char *
864dbfa3 3243Perl_get_no_modify(pTHX)
9e6b2b00 3244{
96a5add6
AL
3245 PERL_UNUSED_CONTEXT;
3246 return PL_no_modify;
9e6b2b00
GS
3247}
3248
3249U32 *
864dbfa3 3250Perl_get_opargs(pTHX)
9e6b2b00 3251{
96a5add6
AL
3252 PERL_UNUSED_CONTEXT;
3253 return (U32 *)PL_opargs;
9e6b2b00 3254}
51aa15f3 3255
0cb96387
GS
3256PPADDR_t*
3257Perl_get_ppaddr(pTHX)
3258{
96a5add6
AL
3259 dVAR;
3260 PERL_UNUSED_CONTEXT;
3261 return (PPADDR_t*)PL_ppaddr;
0cb96387
GS
3262}
3263
a6c40364
GS
3264#ifndef HAS_GETENV_LEN
3265char *
bf4acbe4 3266Perl_getenv_len(pTHX_ const char *env_elem, unsigned long *len)
a6c40364 3267{
8772537c 3268 char * const env_trans = PerlEnv_getenv(env_elem);
96a5add6 3269 PERL_UNUSED_CONTEXT;
a6c40364
GS
3270 if (env_trans)
3271 *len = strlen(env_trans);
3272 return env_trans;
f675dbe5
CB
3273}
3274#endif
3275
dc9e4912
GS
3276
3277MGVTBL*
864dbfa3 3278Perl_get_vtbl(pTHX_ int vtbl_id)
dc9e4912 3279{
7452cf6a 3280 const MGVTBL* result;
96a5add6 3281 PERL_UNUSED_CONTEXT;
dc9e4912
GS
3282
3283 switch(vtbl_id) {
3284 case want_vtbl_sv:
3285 result = &PL_vtbl_sv;
3286 break;
3287 case want_vtbl_env:
3288 result = &PL_vtbl_env;
3289 break;
3290 case want_vtbl_envelem:
3291 result = &PL_vtbl_envelem;
3292 break;
3293 case want_vtbl_sig:
3294 result = &PL_vtbl_sig;
3295 break;
3296 case want_vtbl_sigelem:
3297 result = &PL_vtbl_sigelem;
3298 break;
3299 case want_vtbl_pack:
3300 result = &PL_vtbl_pack;
3301 break;
3302 case want_vtbl_packelem:
3303 result = &PL_vtbl_packelem;
3304 break;
3305 case want_vtbl_dbline:
3306 result = &PL_vtbl_dbline;
3307 break;
3308 case want_vtbl_isa:
3309 result = &PL_vtbl_isa;
3310 break;
3311 case want_vtbl_isaelem:
3312 result = &PL_vtbl_isaelem;
3313 break;
3314 case want_vtbl_arylen:
3315 result = &PL_vtbl_arylen;
3316 break;
dc9e4912
GS
3317 case want_vtbl_mglob:
3318 result = &PL_vtbl_mglob;
3319 break;
3320 case want_vtbl_nkeys:
3321 result = &PL_vtbl_nkeys;
3322 break;
3323 case want_vtbl_taint:
3324 result = &PL_vtbl_taint;
3325 break;
3326 case want_vtbl_substr:
3327 result = &PL_vtbl_substr;
3328 break;
3329 case want_vtbl_vec:
3330 result = &PL_vtbl_vec;
3331 break;
3332 case want_vtbl_pos:
3333 result = &PL_vtbl_pos;
3334 break;
3335 case want_vtbl_bm:
3336 result = &PL_vtbl_bm;
3337 break;
3338 case want_vtbl_fm:
3339 result = &PL_vtbl_fm;
3340 break;
3341 case want_vtbl_uvar:
3342 result = &PL_vtbl_uvar;
3343 break;
dc9e4912
GS
3344 case want_vtbl_defelem:
3345 result = &PL_vtbl_defelem;
3346 break;
3347 case want_vtbl_regexp:
3348 result = &PL_vtbl_regexp;
3349 break;
3350 case want_vtbl_regdata:
3351 result = &PL_vtbl_regdata;
3352 break;
3353 case want_vtbl_regdatum:
3354 result = &PL_vtbl_regdatum;
3355 break;
3c90161d 3356#ifdef USE_LOCALE_COLLATE
dc9e4912
GS
3357 case want_vtbl_collxfrm:
3358 result = &PL_vtbl_collxfrm;
3359 break;
3c90161d 3360#endif
dc9e4912
GS
3361 case want_vtbl_amagic:
3362 result = &PL_vtbl_amagic;
3363 break;
3364 case want_vtbl_amagicelem:
3365 result = &PL_vtbl_amagicelem;
3366 break;
810b8aa5
GS
3367 case want_vtbl_backref:
3368 result = &PL_vtbl_backref;
3369 break;
7e8c5dac
HS
3370 case want_vtbl_utf8:
3371 result = &PL_vtbl_utf8;
3372 break;
7452cf6a 3373 default:
4608196e 3374 result = NULL;
7452cf6a 3375 break;
dc9e4912 3376 }
27da23d5 3377 return (MGVTBL*)result;
dc9e4912
GS
3378}
3379
767df6a1 3380I32
864dbfa3 3381Perl_my_fflush_all(pTHX)
767df6a1 3382{
f800e14d 3383#if defined(USE_PERLIO) || defined(FFLUSH_NULL) || defined(USE_SFIO)
ce720889 3384 return PerlIO_flush(NULL);
767df6a1 3385#else
8fbdfb7c 3386# if defined(HAS__FWALK)
f13a2bc0 3387 extern int fflush(FILE *);
74cac757
JH
3388 /* undocumented, unprototyped, but very useful BSDism */
3389 extern void _fwalk(int (*)(FILE *));
8fbdfb7c 3390 _fwalk(&fflush);
74cac757 3391 return 0;
8fa7f367 3392# else
8fbdfb7c 3393# if defined(FFLUSH_ALL) && defined(HAS_STDIO_STREAM_ARRAY)
8fa7f367 3394 long open_max = -1;
8fbdfb7c 3395# ifdef PERL_FFLUSH_ALL_FOPEN_MAX
d2201af2 3396 open_max = PERL_FFLUSH_ALL_FOPEN_MAX;
8fbdfb7c 3397# else
8fa7f367 3398# if defined(HAS_SYSCONF) && defined(_SC_OPEN_MAX)
767df6a1 3399 open_max = sysconf(_SC_OPEN_MAX);
8fa7f367
JH
3400# else
3401# ifdef FOPEN_MAX
74cac757 3402 open_max = FOPEN_MAX;
8fa7f367
JH
3403# else
3404# ifdef OPEN_MAX
74cac757 3405 open_max = OPEN_MAX;
8fa7f367
JH
3406# else
3407# ifdef _NFILE
d2201af2 3408 open_max = _NFILE;
8fa7f367
JH
3409# endif
3410# endif
74cac757 3411# endif
767df6a1
JH
3412# endif
3413# endif
767df6a1
JH
3414 if (open_max > 0) {
3415 long i;
3416 for (i = 0; i < open_max; i++)
d2201af2
AD
3417 if (STDIO_STREAM_ARRAY[i]._file >= 0 &&
3418 STDIO_STREAM_ARRAY[i]._file < open_max &&
3419 STDIO_STREAM_ARRAY[i]._flag)
3420 PerlIO_flush(&STDIO_STREAM_ARRAY[i]);
767df6a1
JH
3421 return 0;
3422 }
8fbdfb7c 3423# endif
93189314 3424 SETERRNO(EBADF,RMS_IFI);
767df6a1 3425 return EOF;
74cac757 3426# endif
767df6a1
JH
3427#endif
3428}
097ee67d 3429
69282e91 3430void
e1ec3a88 3431Perl_report_evil_fh(pTHX_ const GV *gv, const IO *io, I32 op)
bc37a18f 3432{
b64e5050 3433 const char * const name = gv && isGV(gv) ? GvENAME(gv) : NULL;
66fc2fa5 3434
4c80c0b2 3435 if (op == OP_phoney_OUTPUT_ONLY || op == OP_phoney_INPUT_ONLY) {
3aed30dc 3436 if (ckWARN(WARN_IO)) {
b64e5050 3437 const char * const direction = (op == OP_phoney_INPUT_ONLY) ? "in" : "out";
3aed30dc
HS
3438 if (name && *name)
3439 Perl_warner(aTHX_ packWARN(WARN_IO),
3440 "Filehandle %s opened only for %sput",
fd322ea4 3441 name, direction);
3aed30dc
HS
3442 else
3443 Perl_warner(aTHX_ packWARN(WARN_IO),
fd322ea4 3444 "Filehandle opened only for %sput", direction);
3aed30dc 3445 }
2dd78f96
JH
3446 }
3447 else {
e1ec3a88 3448 const char *vile;
3aed30dc
HS
3449 I32 warn_type;
3450
3451 if (gv && io && IoTYPE(io) == IoTYPE_CLOSED) {
3452 vile = "closed";
3453 warn_type = WARN_CLOSED;
3454 }
3455 else {
3456 vile = "unopened";
3457 warn_type = WARN_UNOPENED;
3458 }
3459
3460 if (ckWARN(warn_type)) {
f0a09b71
AL
3461 const char * const pars = OP_IS_FILETEST(op) ? "" : "()";
3462 const char * const func =
3463 op == OP_READLINE ? "readline" : /* "<HANDLE>" not nice */
3464 op == OP_LEAVEWRITE ? "write" : /* "write exit" not nice */
3465 op < 0 ? "" : /* handle phoney cases */
3466 PL_op_desc[op];
3467 const char * const type = OP_IS_SOCKET(op)
3468 || (gv && io && IoTYPE(io) == IoTYPE_SOCKET)
3469 ? "socket" : "filehandle";
3aed30dc
HS
3470 if (name && *name) {
3471 Perl_warner(aTHX_ packWARN(warn_type),
3472 "%s%s on %s %s %s", func, pars, vile, type, name);
3473 if (io && IoDIRP(io) && !(IoFLAGS(io) & IOf_FAKE_DIRP))
3474 Perl_warner(
3475 aTHX_ packWARN(warn_type),
3476 "\t(Are you trying to call %s%s on dirhandle %s?)\n",
3477 func, pars, name
3478 );
3479 }
3480 else {
3481 Perl_warner(aTHX_ packWARN(warn_type),
3482 "%s%s on %s %s", func, pars, vile, type);
3483 if (gv && io && IoDIRP(io) && !(IoFLAGS(io) & IOf_FAKE_DIRP))
3484 Perl_warner(
3485 aTHX_ packWARN(warn_type),
3486 "\t(Are you trying to call %s%s on dirhandle?)\n",
3487 func, pars
3488 );
3489 }
3490 }
bc37a18f 3491 }
69282e91 3492}
a926ef6b
JH
3493
3494#ifdef EBCDIC
cbebf344
JH
3495/* in ASCII order, not that it matters */
3496static const char controllablechars[] = "?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_";
3497
a926ef6b
JH
3498int
3499Perl_ebcdic_control(pTHX_ int ch)
3500{
3aed30dc 3501 if (ch > 'a') {
e1ec3a88 3502 const char *ctlp;
3aed30dc
HS
3503
3504 if (islower(ch))
3505 ch = toupper(ch);
3506
3507 if ((ctlp = strchr(controllablechars, ch)) == 0) {
3508 Perl_die(aTHX_ "unrecognised control character '%c'\n", ch);
a926ef6b 3509 }
3aed30dc
HS
3510
3511 if (ctlp == controllablechars)
3512 return('\177'); /* DEL */
3513 else
3514 return((unsigned char)(ctlp - controllablechars - 1));
3515 } else { /* Want uncontrol */
3516 if (ch == '\177' || ch == -1)
3517 return('?');
3518 else if (ch == '\157')
3519 return('\177');
3520 else if (ch == '\174')
3521 return('\000');
3522 else if (ch == '^') /* '\137' in 1047, '\260' in 819 */
3523 return('\036');
3524 else if (ch == '\155')
3525 return('\037');
3526 else if (0 < ch && ch < (sizeof(controllablechars) - 1))
3527 return(controllablechars[ch+1]);
3528 else
3529 Perl_die(aTHX_ "invalid control request: '\\%03o'\n", ch & 0xFF);
3530 }
a926ef6b
JH
3531}
3532#endif
e72cf795 3533
f6adc668 3534/* To workaround core dumps from the uninitialised tm_zone we get the
e72cf795
JH
3535 * system to give us a reasonable struct to copy. This fix means that
3536 * strftime uses the tm_zone and tm_gmtoff values returned by
3537 * localtime(time()). That should give the desired result most of the
3538 * time. But probably not always!
3539 *
f6adc668
JH
3540 * This does not address tzname aspects of NETaa14816.
3541 *
e72cf795 3542 */
f6adc668 3543
e72cf795
JH
3544#ifdef HAS_GNULIBC
3545# ifndef STRUCT_TM_HASZONE
3546# define STRUCT_TM_HASZONE
3547# endif
3548#endif
3549
f6adc668
JH
3550#ifdef STRUCT_TM_HASZONE /* Backward compat */
3551# ifndef HAS_TM_TM_ZONE
3552# define HAS_TM_TM_ZONE
3553# endif
3554#endif
3555
e72cf795 3556void
f1208910 3557Perl_init_tm(pTHX_ struct tm *ptm) /* see mktime, strftime and asctime */
e72cf795 3558{
f6adc668 3559#ifdef HAS_TM_TM_ZONE
e72cf795 3560 Time_t now;
1b6737cc 3561 const struct tm* my_tm;
e72cf795 3562 (void)time(&now);
82c57498 3563 my_tm = localtime(&now);
ca46b8ee
SP
3564 if (my_tm)
3565 Copy(my_tm, ptm, 1, struct tm);
1b6737cc
AL
3566#else
3567 PERL_UNUSED_ARG(ptm);
e72cf795
JH
3568#endif
3569}
3570
3571/*
3572 * mini_mktime - normalise struct tm values without the localtime()
3573 * semantics (and overhead) of mktime().
3574 */
3575void
f1208910 3576Perl_mini_mktime(pTHX_ struct tm *ptm)
e72cf795
JH
3577{
3578 int yearday;
3579 int secs;
3580 int month, mday, year, jday;
3581 int odd_cent, odd_year;
96a5add6 3582 PERL_UNUSED_CONTEXT;
e72cf795
JH
3583