This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
https://perl5.git.perl.org / perl5.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Document "delete local" in perlsub
[perl5.git] / util.c
CommitLineData
a0d0e21e 1/* util.c
a687059c 2 *
1129b882
NC		 3 * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 * 2002, 2003, 2004, 2005, 2006, 2007, 2008 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/*
4ac71550
TC		 12 * 'Very useful, no doubt, that was to Saruman; yet it seems that he was
13 * not content.' --Gandalf to Pippin
14 *
15 * [p.598 of _The Lord of the Rings_, III/xi: "The Palantír"]
a0d0e21e 16 */
8d063cd8 17
166f8a29
DM		 18/* This file contains assorted utility routines.
19 * Which is a polite way of saying any stuff that people couldn't think of
20 * a better place for. Amongst other things, it includes the warning and
21 * dieing stuff, plus wrappers for malloc code.
22 */
23
8d063cd8 24#include "EXTERN.h"
864dbfa3 25#define PERL_IN_UTIL_C
8d063cd8 26#include "perl.h"
62b28dd9 27
64ca3a65 28#ifndef PERL_MICRO
a687059c 29#include <signal.h>
36477c24 30#ifndef SIG_ERR
31# define SIG_ERR ((Sighandler_t) -1)
32#endif
64ca3a65 33#endif
36477c24 34
172d2248
OS		 35#ifdef __Lynx__
36/* Missing protos on LynxOS */
37int putenv(char *);
38#endif
39
ff68c719 40#ifdef I_SYS_WAIT
41# include <sys/wait.h>
42#endif
43
868439a2
JH		 44#ifdef HAS_SELECT
45# ifdef I_SYS_SELECT
46# include <sys/select.h>
47# endif
48#endif
49
8d063cd8 50#define FLUSH
8d063cd8 51
16cebae2
GS		 52#if defined(HAS_FCNTL) && defined(F_SETFD) && !defined(FD_CLOEXEC)
53# define FD_CLOEXEC 1 /* NeXT needs this */
54#endif
55
a687059c
LW		 56/* NOTE: Do not call the next three routines directly. Use the macros
57 * in handy.h, so that we can easily redefine everything to do tracking of
58 * allocated hunks back to the original New to track down any memory leaks.
20cec16a 59 * XXX This advice seems to be widely ignored :-( --AD August 1996.
a687059c
LW		 60 */
61
ca8d8976
NC		 62static char *
63S_write_no_mem(pTHX)
64{
97aff369 65 dVAR;
ca8d8976
NC		 66 /* Can't use PerlIO to write as it allocates memory */
67 PerlLIO_write(PerlIO_fileno(Perl_error_log),
68 PL_no_mem, strlen(PL_no_mem));
69 my_exit(1);
1f440eb2 70 NORETURN_FUNCTION_END;
ca8d8976
NC		 71}
72
26fa51c3
AMS		 73/* paranoid version of system's malloc() */
74
bd4080b3 75Malloc_t
4f63d024 76Perl_safesysmalloc(MEM_SIZE size)
8d063cd8 77{
54aff467 78 dTHX;
bd4080b3 79 Malloc_t ptr;
55497cff 80#ifdef HAS_64K_LIMIT
62b28dd9 81 if (size > 0xffff) {
bf49b057 82 PerlIO_printf(Perl_error_log,
16cebae2 83 "Allocation too large: %lx\n", size) FLUSH;
54aff467 84 my_exit(1);
62b28dd9 85 }
55497cff 86#endif /* HAS_64K_LIMIT */
e8dda941
JD		 87#ifdef PERL_TRACK_MEMPOOL
88 size += sTHX;
89#endif
34de22dd
LW		 90#ifdef DEBUGGING
91 if ((long)size < 0)
4f63d024 92 Perl_croak_nocontext("panic: malloc");
34de22dd 93#endif
12ae5dfc 94 ptr = (Malloc_t)PerlMem_malloc(size?size:1); /* malloc(0) is NASTY on our system */
da927450 95 PERL_ALLOC_CHECK(ptr);
97835f67 96 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) malloc %ld bytes\n",PTR2UV(ptr),(long)PL_an++,(long)size));
bd61b366 97 if (ptr != NULL) {
e8dda941 98#ifdef PERL_TRACK_MEMPOOL
7cb608b5
NC		 99 struct perl_memory_debug_header *const header
100 = (struct perl_memory_debug_header *)ptr;
9a083ecf
NC		 101#endif
102
103#ifdef PERL_POISON
7e337ee0 104 PoisonNew(((char *)ptr), size, char);
9a083ecf 105#endif
7cb608b5 106
9a083ecf 107#ifdef PERL_TRACK_MEMPOOL
7cb608b5
NC		 108 header->interpreter = aTHX;
109 /* Link us into the list. */
110 header->prev = &PL_memory_debug_header;
111 header->next = PL_memory_debug_header.next;
112 PL_memory_debug_header.next = header;
113 header->next->prev = header;
cd1541b2 114# ifdef PERL_POISON
7cb608b5 115 header->size = size;
cd1541b2 116# endif
e8dda941
JD		 117 ptr = (Malloc_t)((char*)ptr+sTHX);
118#endif
8d063cd8 119 return ptr;
e8dda941 120}
3280af22 121 else if (PL_nomemok)
bd61b366 122 return NULL;
8d063cd8 123 else {
0bd48802 124 return write_no_mem();
8d063cd8
LW		 125 }
126 /*NOTREACHED*/
127}
128
f2517201 129/* paranoid version of system's realloc() */
8d063cd8 130
bd4080b3 131Malloc_t
4f63d024 132Perl_safesysrealloc(Malloc_t where,MEM_SIZE size)
8d063cd8 133{
54aff467 134 dTHX;
bd4080b3 135 Malloc_t ptr;
9a34ef1d 136#if !defined(STANDARD_C) && !defined(HAS_REALLOC_PROTOTYPE) && !defined(PERL_MICRO)
6ad3d225 137 Malloc_t PerlMem_realloc();
ecfc5424 138#endif /* !defined(STANDARD_C) && !defined(HAS_REALLOC_PROTOTYPE) */
8d063cd8 139
a1d180c4 140#ifdef HAS_64K_LIMIT
5f05dabc 141 if (size > 0xffff) {
bf49b057 142 PerlIO_printf(Perl_error_log,
5f05dabc 143 "Reallocation too large: %lx\n", size) FLUSH;
54aff467 144 my_exit(1);
5f05dabc 145 }
55497cff 146#endif /* HAS_64K_LIMIT */
7614df0c 147 if (!size) {
f2517201 148 safesysfree(where);
7614df0c
JD		 149 return NULL;
150 }
151
378cc40b 152 if (!where)
f2517201 153 return safesysmalloc(size);
e8dda941
JD		 154#ifdef PERL_TRACK_MEMPOOL
155 where = (Malloc_t)((char*)where-sTHX);
156 size += sTHX;
7cb608b5
NC		 157 {
158 struct perl_memory_debug_header *const header
159 = (struct perl_memory_debug_header *)where;
160
161 if (header->interpreter != aTHX) {
162 Perl_croak_nocontext("panic: realloc from wrong pool");
163 }
164 assert(header->next->prev == header);
165 assert(header->prev->next == header);
cd1541b2 166# ifdef PERL_POISON
7cb608b5
NC		 167 if (header->size > size) {
168 const MEM_SIZE freed_up = header->size - size;
169 char *start_of_freed = ((char *)where) + size;
7e337ee0 170 PoisonFree(start_of_freed, freed_up, char);
7cb608b5
NC		 171 }
172 header->size = size;
cd1541b2 173# endif
7cb608b5 174 }
e8dda941 175#endif
34de22dd
LW		 176#ifdef DEBUGGING
177 if ((long)size < 0)
4f63d024 178 Perl_croak_nocontext("panic: realloc");
34de22dd 179#endif
12ae5dfc 180 ptr = (Malloc_t)PerlMem_realloc(where,size);
da927450 181 PERL_ALLOC_CHECK(ptr);
a1d180c4 182
4fd0a9b8
NC		 183 /* MUST do this fixup first, before doing ANYTHING else, as anything else
184 might allocate memory/free/move memory, and until we do the fixup, it
185 may well be chasing (and writing to) free memory. */
e8dda941 186#ifdef PERL_TRACK_MEMPOOL
4fd0a9b8 187 if (ptr != NULL) {
7cb608b5
NC		 188 struct perl_memory_debug_header *const header
189 = (struct perl_memory_debug_header *)ptr;
190
9a083ecf
NC		 191# ifdef PERL_POISON
192 if (header->size < size) {
193 const MEM_SIZE fresh = size - header->size;
194 char *start_of_fresh = ((char *)ptr) + size;
7e337ee0 195 PoisonNew(start_of_fresh, fresh, char);
9a083ecf
NC		 196 }
197# endif
198
7cb608b5
NC		 199 header->next->prev = header;
200 header->prev->next = header;
201
e8dda941 202 ptr = (Malloc_t)((char*)ptr+sTHX);
4fd0a9b8 203 }
e8dda941 204#endif
4fd0a9b8
NC		 205
206 /* In particular, must do that fixup above before logging anything via
207 *printf(), as it can reallocate memory, which can cause SEGVs. */
208
209 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) rfree\n",PTR2UV(where),(long)PL_an++));
210 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) realloc %ld bytes\n",PTR2UV(ptr),(long)PL_an++,(long)size));
211
212
213 if (ptr != NULL) {
8d063cd8 214 return ptr;
e8dda941 215 }
3280af22 216 else if (PL_nomemok)
bd61b366 217 return NULL;
8d063cd8 218 else {
0bd48802 219 return write_no_mem();
8d063cd8
LW		 220 }
221 /*NOTREACHED*/
222}
223
f2517201 224/* safe version of system's free() */
8d063cd8 225
54310121 226Free_t
4f63d024 227Perl_safesysfree(Malloc_t where)
8d063cd8 228{
e8dda941 229#if defined(PERL_IMPLICIT_SYS) || defined(PERL_TRACK_MEMPOOL)
54aff467 230 dTHX;
97aff369
JH		 231#else
232 dVAR;
155aba94 233#endif
97835f67 234 DEBUG_m( PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) free\n",PTR2UV(where),(long)PL_an++));
378cc40b 235 if (where) {
e8dda941
JD		 236#ifdef PERL_TRACK_MEMPOOL
237 where = (Malloc_t)((char*)where-sTHX);
cd1541b2 238 {
7cb608b5
NC		 239 struct perl_memory_debug_header *const header
240 = (struct perl_memory_debug_header *)where;
241
242 if (header->interpreter != aTHX) {
243 Perl_croak_nocontext("panic: free from wrong pool");
244 }
245 if (!header->prev) {
cd1541b2
NC		 246 Perl_croak_nocontext("panic: duplicate free");
247 }
7cb608b5
NC		 248 if (!(header->next) || header->next->prev != header
249 || header->prev->next != header) {
250 Perl_croak_nocontext("panic: bad free");
cd1541b2 251 }
7cb608b5
NC		 252 /* Unlink us from the chain. */
253 header->next->prev = header->prev;
254 header->prev->next = header->next;
255# ifdef PERL_POISON
7e337ee0 256 PoisonNew(where, header->size, char);
cd1541b2 257# endif
7cb608b5
NC		 258 /* Trigger the duplicate free warning. */
259 header->next = NULL;
260 }
e8dda941 261#endif
6ad3d225 262 PerlMem_free(where);
378cc40b 263 }
8d063cd8
LW		 264}
265
f2517201 266/* safe version of system's calloc() */
1050c9ca 267
bd4080b3 268Malloc_t
4f63d024 269Perl_safesyscalloc(MEM_SIZE count, MEM_SIZE size)
1050c9ca 270{
54aff467 271 dTHX;
bd4080b3 272 Malloc_t ptr;
ad7244db 273 MEM_SIZE total_size = 0;
1050c9ca 274
ad7244db 275 /* Even though calloc() for zero bytes is strange, be robust. */
19a94d75 276 if (size && (count <= MEM_SIZE_MAX / size))
ad7244db
JH		 277 total_size = size * count;
278 else
f1f66076 279 Perl_croak_nocontext("%s", PL_memory_wrap);
ad7244db 280#ifdef PERL_TRACK_MEMPOOL
19a94d75 281 if (sTHX <= MEM_SIZE_MAX - (MEM_SIZE)total_size)
ad7244db
JH		 282 total_size += sTHX;
283 else
f1f66076 284 Perl_croak_nocontext("%s", PL_memory_wrap);
ad7244db 285#endif
55497cff 286#ifdef HAS_64K_LIMIT
e1a95402 287 if (total_size > 0xffff) {
bf49b057 288 PerlIO_printf(Perl_error_log,
e1a95402 289 "Allocation too large: %lx\n", total_size) FLUSH;
54aff467 290 my_exit(1);
5f05dabc 291 }
55497cff 292#endif /* HAS_64K_LIMIT */
1050c9ca 293#ifdef DEBUGGING
294 if ((long)size < 0 || (long)count < 0)
4f63d024 295 Perl_croak_nocontext("panic: calloc");
1050c9ca 296#endif
e8dda941 297#ifdef PERL_TRACK_MEMPOOL
e1a95402
NC		 298 /* Have to use malloc() because we've added some space for our tracking
299 header. */
ad7244db
JH		 300 /* malloc(0) is non-portable. */
301 ptr = (Malloc_t)PerlMem_malloc(total_size ? total_size : 1);
e1a95402
NC		 302#else
303 /* Use calloc() because it might save a memset() if the memory is fresh
304 and clean from the OS. */
ad7244db
JH		 305 if (count && size)
306 ptr = (Malloc_t)PerlMem_calloc(count, size);
307 else /* calloc(0) is non-portable. */
308 ptr = (Malloc_t)PerlMem_calloc(count ? count : 1, size ? size : 1);
e8dda941 309#endif
da927450 310 PERL_ALLOC_CHECK(ptr);
e1a95402 311 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) calloc %ld x %ld bytes\n",PTR2UV(ptr),(long)PL_an++,(long)count,(long)total_size));
bd61b366 312 if (ptr != NULL) {
e8dda941 313#ifdef PERL_TRACK_MEMPOOL
7cb608b5
NC		 314 {
315 struct perl_memory_debug_header *const header
316 = (struct perl_memory_debug_header *)ptr;
317
e1a95402 318 memset((void*)ptr, 0, total_size);
7cb608b5
NC		 319 header->interpreter = aTHX;
320 /* Link us into the list. */
321 header->prev = &PL_memory_debug_header;
322 header->next = PL_memory_debug_header.next;
323 PL_memory_debug_header.next = header;
324 header->next->prev = header;
cd1541b2 325# ifdef PERL_POISON
e1a95402 326 header->size = total_size;
cd1541b2 327# endif
7cb608b5
NC		 328 ptr = (Malloc_t)((char*)ptr+sTHX);
329 }
e8dda941 330#endif
1050c9ca 331 return ptr;
332 }
3280af22 333 else if (PL_nomemok)
bd61b366 334 return NULL;
0bd48802 335 return write_no_mem();
1050c9ca 336}
337
cae6d0e5
GS		 338/* These must be defined when not using Perl's malloc for binary
339 * compatibility */
340
341#ifndef MYMALLOC
342
343Malloc_t Perl_malloc (MEM_SIZE nbytes)
344{
345 dTHXs;
077a72a9 346 return (Malloc_t)PerlMem_malloc(nbytes);
cae6d0e5
GS		 347}
348
349Malloc_t Perl_calloc (MEM_SIZE elements, MEM_SIZE size)
350{
351 dTHXs;
077a72a9 352 return (Malloc_t)PerlMem_calloc(elements, size);
cae6d0e5
GS		 353}
354
355Malloc_t Perl_realloc (Malloc_t where, MEM_SIZE nbytes)
356{
357 dTHXs;
077a72a9 358 return (Malloc_t)PerlMem_realloc(where, nbytes);
cae6d0e5
GS		 359}
360
361Free_t Perl_mfree (Malloc_t where)
362{
363 dTHXs;
364 PerlMem_free(where);
365}
366
367#endif
368
8d063cd8
LW		 369/* copy a string up to some (non-backslashed) delimiter, if any */
370
371char *
e1ec3a88 372Perl_delimcpy(pTHX_ register char *to, register const char *toend, register const char *from, register const char *fromend, register int delim, I32 *retlen)
8d063cd8 373{
fc36a67e 374 register I32 tolen;
96a5add6 375 PERL_UNUSED_CONTEXT;
35da51f7 376
7918f24d
NC		 377 PERL_ARGS_ASSERT_DELIMCPY;
378
fc36a67e 379 for (tolen = 0; from < fromend; from++, tolen++) {
378cc40b 380 if (*from == '\\') {
35da51f7 381 if (from[1] != delim) {
fc36a67e 382 if (to < toend)
383 *to++ = *from;
384 tolen++;
fc36a67e 385 }
35da51f7 386 from++;
378cc40b 387 }
bedebaa5 388 else if (*from == delim)
8d063cd8 389 break;
fc36a67e 390 if (to < toend)
391 *to++ = *from;
8d063cd8 392 }
bedebaa5
CS		 393 if (to < toend)
394 *to = '\0';
fc36a67e 395 *retlen = tolen;
73d840c0 396 return (char *)from;
8d063cd8
LW		 397}
398
399/* return ptr to little string in big string, NULL if not found */
378cc40b 400/* This routine was donated by Corey Satten. */
8d063cd8
LW		 401
402char *
864dbfa3 403Perl_instr(pTHX_ register const char *big, register const char *little)
378cc40b 404{
79072805 405 register I32 first;
96a5add6 406 PERL_UNUSED_CONTEXT;
378cc40b 407
7918f24d
NC		 408 PERL_ARGS_ASSERT_INSTR;
409
a687059c 410 if (!little)
08105a92 411 return (char*)big;
a687059c 412 first = *little++;
378cc40b 413 if (!first)
08105a92 414 return (char*)big;
378cc40b 415 while (*big) {
66a1b24b 416 register const char *s, *x;
378cc40b
LW		 417 if (*big++ != first)
418 continue;
419 for (x=big,s=little; *s; /**/ ) {
420 if (!*x)
bd61b366 421 return NULL;
4fc877ac 422 if (*s != *x)
378cc40b 423 break;
4fc877ac
AL		 424 else {
425 s++;
426 x++;
378cc40b
LW		 427 }
428 }
429 if (!*s)
08105a92 430 return (char*)(big-1);
378cc40b 431 }
bd61b366 432 return NULL;
378cc40b 433}
8d063cd8 434
a687059c
LW		 435/* same as instr but allow embedded nulls */
436
437char *
4c8626be 438Perl_ninstr(pTHX_ const char *big, const char *bigend, const char *little, const char *lend)
8d063cd8 439{
7918f24d 440 PERL_ARGS_ASSERT_NINSTR;
96a5add6 441 PERL_UNUSED_CONTEXT;
4c8626be
GA		 442 if (little >= lend)
443 return (char*)big;
444 {
8ba22ff4 445 const char first = *little;
4c8626be 446 const char *s, *x;
8ba22ff4 447 bigend -= lend - little++;
4c8626be
GA		 448 OUTER:
449 while (big <= bigend) {
b0ca24ee
JH		 450 if (*big++ == first) {
451 for (x=big,s=little; s < lend; x++,s++) {
452 if (*s != *x)
453 goto OUTER;
454 }
455 return (char*)(big-1);
4c8626be 456 }
4c8626be 457 }
378cc40b 458 }
bd61b366 459 return NULL;
a687059c
LW		 460}
461
462/* reverse of the above--find last substring */
463
464char *
864dbfa3 465Perl_rninstr(pTHX_ register const char *big, const char *bigend, const char *little, const char *lend)
a687059c 466{
08105a92 467 register const char *bigbeg;
e1ec3a88 468 register const I32 first = *little;
7452cf6a 469 register const char * const littleend = lend;
96a5add6 470 PERL_UNUSED_CONTEXT;
a687059c 471
7918f24d
NC		 472 PERL_ARGS_ASSERT_RNINSTR;
473
260d78c9 474 if (little >= littleend)
08105a92 475 return (char*)bigend;
a687059c
LW		 476 bigbeg = big;
477 big = bigend - (littleend - little++);
478 while (big >= bigbeg) {
66a1b24b 479 register const char *s, *x;
a687059c
LW		 480 if (*big-- != first)
481 continue;
482 for (x=big+2,s=little; s < littleend; /**/ ) {
4fc877ac 483 if (*s != *x)
a687059c 484 break;
4fc877ac
AL		 485 else {
486 x++;
487 s++;
a687059c
LW		 488 }
489 }
490 if (s >= littleend)
08105a92 491 return (char*)(big+1);
378cc40b 492 }
bd61b366 493 return NULL;
378cc40b 494}
a687059c 495
cf93c79d
IZ		 496/* As a space optimization, we do not compile tables for strings of length
497 0 and 1, and for strings of length 2 unless FBMcf_TAIL. These are
498 special-cased in fbm_instr().
499
500 If FBMcf_TAIL, the table is created as if the string has a trailing \n. */
501
954c1994 502/*
ccfc67b7
JH		 503=head1 Miscellaneous Functions
504
954c1994
GS		 505=for apidoc fbm_compile
506
507Analyses the string in order to make fast searches on it using fbm_instr()
508-- the Boyer-Moore algorithm.
509
510=cut
511*/
512
378cc40b 513void
7506f9c3 514Perl_fbm_compile(pTHX_ SV *sv, U32 flags)
378cc40b 515{
97aff369 516 dVAR;
0d46e09a 517 register const U8 *s;
79072805 518 register U32 i;
0b71040e 519 STRLEN len;
cb742848 520 U32 rarest = 0;
79072805
LW		 521 U32 frequency = 256;
522
7918f24d
NC		 523 PERL_ARGS_ASSERT_FBM_COMPILE;
524
c517dc2b 525 if (flags & FBMcf_TAIL) {
890ce7af 526 MAGIC * const mg = SvUTF8(sv) && SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_utf8) : NULL;
396482e1 527 sv_catpvs(sv, "\n"); /* Taken into account in fbm_instr() */
c517dc2b
JH		 528 if (mg && mg->mg_len >= 0)
529 mg->mg_len++;
530 }
9cbe880b 531 s = (U8*)SvPV_force_mutable(sv, len);
d1be9408 532 if (len == 0) /* TAIL might be on a zero-length string. */
cf93c79d 533 return;
cecf5685 534 SvUPGRADE(sv, SVt_PVGV);
78d0cf80 535 SvIOK_off(sv);
8eeaf79a
NC		 536 SvNOK_off(sv);
537 SvVALID_on(sv);
02128f11 538 if (len > 2) {
9cbe880b 539 const unsigned char *sb;
66a1b24b 540 const U8 mlen = (len>255) ? 255 : (U8)len;
890ce7af 541 register U8 *table;
cf93c79d 542
d8419e03
NC		 543 Sv_Grow(sv, len + 256 + PERL_FBM_TABLE_OFFSET);
544 table
545 = (unsigned char*)(SvPVX_mutable(sv) + len + PERL_FBM_TABLE_OFFSET);
546 s = table - 1 - PERL_FBM_TABLE_OFFSET; /* last char */
7506f9c3 547 memset((void*)table, mlen, 256);
02128f11 548 i = 0;
7506f9c3 549 sb = s - mlen + 1; /* first char (maybe) */
cf93c79d
IZ		 550 while (s >= sb) {
551 if (table[*s] == mlen)
7506f9c3 552 table[*s] = (U8)i;
cf93c79d
IZ		 553 s--, i++;
554 }
d0688fc4
NC		 555 } else {
556 Sv_Grow(sv, len + PERL_FBM_TABLE_OFFSET);
378cc40b 557 }
a0714e2c 558 sv_magic(sv, NULL, PERL_MAGIC_bm, NULL, 0); /* deep magic */
378cc40b 559
9cbe880b 560 s = (const unsigned char*)(SvPVX_const(sv)); /* deeper magic */
bbce6d69 561 for (i = 0; i < len; i++) {
22c35a8c 562 if (PL_freq[s[i]] < frequency) {
bbce6d69 563 rarest = i;
22c35a8c 564 frequency = PL_freq[s[i]];
378cc40b
LW		 565 }
566 }
610460f9 567 BmFLAGS(sv) = (U8)flags;
79072805 568 BmRARE(sv) = s[rarest];
44a10c71 569 BmPREVIOUS(sv) = rarest;
cf93c79d
IZ		 570 BmUSEFUL(sv) = 100; /* Initial value */
571 if (flags & FBMcf_TAIL)
572 SvTAIL_on(sv);
8eeaf79a
NC		 573 DEBUG_r(PerlIO_printf(Perl_debug_log, "rarest char %c at %lu\n",
574 BmRARE(sv),(unsigned long)BmPREVIOUS(sv)));
378cc40b
LW		 575}
576
cf93c79d
IZ		 577/* If SvTAIL(littlestr), it has a fake '\n' at end. */
578/* If SvTAIL is actually due to \Z or \z, this gives false positives
579 if multiline */
580
954c1994
GS		 581/*
582=for apidoc fbm_instr
583
584Returns the location of the SV in the string delimited by C<str> and
bd61b366 585C<strend>. It returns C<NULL> if the string can't be found. The C<sv>
954c1994
GS		 586does not have to be fbm_compiled, but the search will not be as fast
587then.
588
589=cut
590*/
591
378cc40b 592char *
864dbfa3 593Perl_fbm_instr(pTHX_ unsigned char *big, register unsigned char *bigend, SV *littlestr, U32 flags)
378cc40b 594{
a687059c 595 register unsigned char *s;
cf93c79d 596 STRLEN l;
9cbe880b
NC		 597 register const unsigned char *little
598 = (const unsigned char *)SvPV_const(littlestr,l);
cf93c79d 599 register STRLEN littlelen = l;
e1ec3a88 600 register const I32 multiline = flags & FBMrf_MULTILINE;
cf93c79d 601
7918f24d
NC		 602 PERL_ARGS_ASSERT_FBM_INSTR;
603
eb160463 604 if ((STRLEN)(bigend - big) < littlelen) {
a1d180c4 605 if ( SvTAIL(littlestr)
eb160463 606 && ((STRLEN)(bigend - big) == littlelen - 1)
a1d180c4 607 && (littlelen == 1
12ae5dfc 608 || (*big == *little &&
27da23d5 609 memEQ((char *)big, (char *)little, littlelen - 1))))
cf93c79d 610 return (char*)big;
bd61b366 611 return NULL;
cf93c79d 612 }
378cc40b 613
cf93c79d 614 if (littlelen <= 2) { /* Special-cased */
cf93c79d
IZ		 615
616 if (littlelen == 1) {
617 if (SvTAIL(littlestr) && !multiline) { /* Anchor only! */
618 /* Know that bigend != big. */
619 if (bigend[-1] == '\n')
620 return (char *)(bigend - 1);
621 return (char *) bigend;
622 }
623 s = big;
624 while (s < bigend) {
625 if (*s == *little)
626 return (char *)s;
627 s++;
628 }
629 if (SvTAIL(littlestr))
630 return (char *) bigend;
bd61b366 631 return NULL;
cf93c79d
IZ		 632 }
633 if (!littlelen)
634 return (char*)big; /* Cannot be SvTAIL! */
635
636 /* littlelen is 2 */
637 if (SvTAIL(littlestr) && !multiline) {
638 if (bigend[-1] == '\n' && bigend[-2] == *little)
639 return (char*)bigend - 2;
640 if (bigend[-1] == *little)
641 return (char*)bigend - 1;
bd61b366 642 return NULL;
cf93c79d
IZ		 643 }
644 {
645 /* This should be better than FBM if c1 == c2, and almost
646 as good otherwise: maybe better since we do less indirection.
647 And we save a lot of memory by caching no table. */
66a1b24b
AL		 648 const unsigned char c1 = little[0];
649 const unsigned char c2 = little[1];
cf93c79d
IZ		 650
651 s = big + 1;
652 bigend--;
653 if (c1 != c2) {
654 while (s <= bigend) {
655 if (s[0] == c2) {
656 if (s[-1] == c1)
657 return (char*)s - 1;
658 s += 2;
659 continue;
3fe6f2dc 660 }
cf93c79d
IZ		 661 next_chars:
662 if (s[0] == c1) {
663 if (s == bigend)
664 goto check_1char_anchor;
665 if (s[1] == c2)
666 return (char*)s;
667 else {
668 s++;
669 goto next_chars;
670 }
671 }
672 else
673 s += 2;
674 }
675 goto check_1char_anchor;
676 }
677 /* Now c1 == c2 */
678 while (s <= bigend) {
679 if (s[0] == c1) {
680 if (s[-1] == c1)
681 return (char*)s - 1;
682 if (s == bigend)
683 goto check_1char_anchor;
684 if (s[1] == c1)
685 return (char*)s;
686 s += 3;
02128f11 687 }
c277df42 688 else
cf93c79d 689 s += 2;
c277df42 690 }
c277df42 691 }
cf93c79d
IZ		 692 check_1char_anchor: /* One char and anchor! */
693 if (SvTAIL(littlestr) && (*bigend == *little))
694 return (char *)bigend; /* bigend is already decremented. */
bd61b366 695 return NULL;
d48672a2 696 }
cf93c79d 697 if (SvTAIL(littlestr) && !multiline) { /* tail anchored? */
bbce6d69 698 s = bigend - littlelen;
a1d180c4 699 if (s >= big && bigend[-1] == '\n' && *s == *little
cf93c79d
IZ		 700 /* Automatically of length > 2 */
701 && memEQ((char*)s + 1, (char*)little + 1, littlelen - 2))
7506f9c3 702 {
bbce6d69 703 return (char*)s; /* how sweet it is */
7506f9c3
GS		 704 }
705 if (s[1] == *little
706 && memEQ((char*)s + 2, (char*)little + 1, littlelen - 2))
707 {
cf93c79d 708 return (char*)s + 1; /* how sweet it is */
7506f9c3 709 }
bd61b366 710 return NULL;
02128f11 711 }
cecf5685 712 if (!SvVALID(littlestr)) {
c4420975 713 char * const b = ninstr((char*)big,(char*)bigend,
cf93c79d
IZ		 714 (char*)little, (char*)little + littlelen);
715
716 if (!b && SvTAIL(littlestr)) { /* Automatically multiline! */
717 /* Chop \n from littlestr: */
718 s = bigend - littlelen + 1;
7506f9c3
GS		 719 if (*s == *little
720 && memEQ((char*)s + 1, (char*)little + 1, littlelen - 2))
721 {
3fe6f2dc 722 return (char*)s;
7506f9c3 723 }
bd61b366 724 return NULL;
a687059c 725 }
cf93c79d 726 return b;
a687059c 727 }
a1d180c4 728
3566a07d
NC		 729 /* Do actual FBM. */
730 if (littlelen > (STRLEN)(bigend - big))
731 return NULL;
732
733 {
d8419e03
NC		 734 register const unsigned char * const table
735 = little + littlelen + PERL_FBM_TABLE_OFFSET;
0d46e09a 736 register const unsigned char *oldlittle;
cf93c79d 737
cf93c79d
IZ		 738 --littlelen; /* Last char found by table lookup */
739
740 s = big + littlelen;
741 little += littlelen; /* last char */
742 oldlittle = little;
743 if (s < bigend) {
744 register I32 tmp;
745
746 top2:
7506f9c3 747 if ((tmp = table[*s])) {
cf93c79d 748 if ((s += tmp) < bigend)
62b28dd9 749 goto top2;
cf93c79d
IZ		 750 goto check_end;
751 }
752 else { /* less expensive than calling strncmp() */
66a1b24b 753 register unsigned char * const olds = s;
cf93c79d
IZ		 754
755 tmp = littlelen;
756
757 while (tmp--) {
758 if (*--s == *--little)
759 continue;
cf93c79d
IZ		 760 s = olds + 1; /* here we pay the price for failure */
761 little = oldlittle;
762 if (s < bigend) /* fake up continue to outer loop */
763 goto top2;
764 goto check_end;
765 }
766 return (char *)s;
a687059c 767 }
378cc40b 768 }
cf93c79d 769 check_end:
c8029a41 770 if ( s == bigend
8eeaf79a 771 && (BmFLAGS(littlestr) & FBMcf_TAIL)
12ae5dfc
JH		 772 && memEQ((char *)(bigend - littlelen),
773 (char *)(oldlittle - littlelen), littlelen) )
cf93c79d 774 return (char*)bigend - littlelen;
bd61b366 775 return NULL;
378cc40b 776 }
378cc40b
LW		 777}
778
c277df42
IZ		 779/* start_shift, end_shift are positive quantities which give offsets
780 of ends of some substring of bigstr.
a0288114 781 If "last" we want the last occurrence.
c277df42 782 old_posp is the way of communication between consequent calls if
a1d180c4 783 the next call needs to find the .
c277df42 784 The initial *old_posp should be -1.
cf93c79d
IZ		 785
786 Note that we take into account SvTAIL, so one can get extra
787 optimizations if _ALL flag is set.
c277df42
IZ		 788 */
789
cf93c79d 790/* If SvTAIL is actually due to \Z or \z, this gives false positives
26fa51c3 791 if PL_multiline. In fact if !PL_multiline the authoritative answer
cf93c79d
IZ		 792 is not supported yet. */
793
378cc40b 794char *
864dbfa3 795Perl_screaminstr(pTHX_ SV *bigstr, SV *littlestr, I32 start_shift, I32 end_shift, I32 *old_posp, I32 last)
378cc40b 796{
97aff369 797 dVAR;
0d46e09a 798 register const unsigned char *big;
79072805
LW		 799 register I32 pos;
800 register I32 previous;
801 register I32 first;
0d46e09a 802 register const unsigned char *little;
c277df42 803 register I32 stop_pos;
0d46e09a 804 register const unsigned char *littleend;
c277df42 805 I32 found = 0;
378cc40b 806
7918f24d
NC		 807 PERL_ARGS_ASSERT_SCREAMINSTR;
808
cecf5685
NC		 809 assert(SvTYPE(littlestr) == SVt_PVGV);
810 assert(SvVALID(littlestr));
d372c834 811
c277df42 812 if (*old_posp == -1
3280af22 813 ? (pos = PL_screamfirst[BmRARE(littlestr)]) < 0
cf93c79d
IZ		 814 : (((pos = *old_posp), pos += PL_screamnext[pos]) == 0)) {
815 cant_find:
a1d180c4 816 if ( BmRARE(littlestr) == '\n'
85c508c3 817 && BmPREVIOUS(littlestr) == SvCUR(littlestr) - 1) {
cfd0369c 818 little = (const unsigned char *)(SvPVX_const(littlestr));
cf93c79d
IZ		 819 littleend = little + SvCUR(littlestr);
820 first = *little++;
821 goto check_tail;
822 }
bd61b366 823 return NULL;
cf93c79d
IZ		 824 }
825
cfd0369c 826 little = (const unsigned char *)(SvPVX_const(littlestr));
79072805 827 littleend = little + SvCUR(littlestr);
378cc40b 828 first = *little++;
c277df42 829 /* The value of pos we can start at: */
79072805 830 previous = BmPREVIOUS(littlestr);
cfd0369c 831 big = (const unsigned char *)(SvPVX_const(bigstr));
c277df42
IZ		 832 /* The value of pos we can stop at: */
833 stop_pos = SvCUR(bigstr) - end_shift - (SvCUR(littlestr) - 1 - previous);
cf93c79d 834 if (previous + start_shift > stop_pos) {
0fe87f7c
HS		 835/*
836 stop_pos does not include SvTAIL in the count, so this check is incorrect
837 (I think) - see [ID 20010618.006] and t/op/study.t. HVDS 2001/06/19
838*/
839#if 0
cf93c79d
IZ		 840 if (previous + start_shift == stop_pos + 1) /* A fake '\n'? */
841 goto check_tail;
0fe87f7c 842#endif
bd61b366 843 return NULL;
cf93c79d 844 }
c277df42 845 while (pos < previous + start_shift) {
3280af22 846 if (!(pos += PL_screamnext[pos]))
cf93c79d 847 goto cant_find;
378cc40b 848 }
de3bb511 849 big -= previous;
bbce6d69 850 do {
0d46e09a 851 register const unsigned char *s, *x;
ef64f398 852 if (pos >= stop_pos) break;
bbce6d69 853 if (big[pos] != first)
854 continue;
855 for (x=big+pos+1,s=little; s < littleend; /**/ ) {
bbce6d69 856 if (*s++ != *x++) {
857 s--;
858 break;
378cc40b 859 }
bbce6d69 860 }
c277df42
IZ		 861 if (s == littleend) {
862 *old_posp = pos;
863 if (!last) return (char *)(big+pos);
864 found = 1;
865 }
3280af22 866 } while ( pos += PL_screamnext[pos] );
a1d180c4 867 if (last && found)
cf93c79d 868 return (char *)(big+(*old_posp));
cf93c79d
IZ		 869 check_tail:
870 if (!SvTAIL(littlestr) || (end_shift > 0))
bd61b366 871 return NULL;
cf93c79d 872 /* Ignore the trailing "\n". This code is not microoptimized */
cfd0369c 873 big = (const unsigned char *)(SvPVX_const(bigstr) + SvCUR(bigstr));
cf93c79d
IZ		 874 stop_pos = littleend - little; /* Actual littlestr len */
875 if (stop_pos == 0)
876 return (char*)big;
877 big -= stop_pos;
878 if (*big == first
12ae5dfc
JH		 879 && ((stop_pos == 1) ||
880 memEQ((char *)(big + 1), (char *)little, stop_pos - 1)))
cf93c79d 881 return (char*)big;
bd61b366 882 return NULL;
8d063cd8
LW		 883}
884
79072805 885I32
864dbfa3 886Perl_ibcmp(pTHX_ const char *s1, const char *s2, register I32 len)
79072805 887{
e1ec3a88
AL		 888 register const U8 *a = (const U8 *)s1;
889 register const U8 *b = (const U8 *)s2;
96a5add6
AL		 890 PERL_UNUSED_CONTEXT;
891
7918f24d
NC		 892 PERL_ARGS_ASSERT_IBCMP;
893
79072805 894 while (len--) {
22c35a8c 895 if (*a != *b && *a != PL_fold[*b])
bbce6d69 896 return 1;
897 a++,b++;
898 }
899 return 0;
900}
901
902I32
864dbfa3 903Perl_ibcmp_locale(pTHX_ const char *s1, const char *s2, register I32 len)
bbce6d69 904{
27da23d5 905 dVAR;
e1ec3a88
AL		 906 register const U8 *a = (const U8 *)s1;
907 register const U8 *b = (const U8 *)s2;
96a5add6
AL		 908 PERL_UNUSED_CONTEXT;
909
7918f24d
NC		 910 PERL_ARGS_ASSERT_IBCMP_LOCALE;
911
bbce6d69 912 while (len--) {
22c35a8c 913 if (*a != *b && *a != PL_fold_locale[*b])
bbce6d69 914 return 1;
915 a++,b++;
79072805
LW		 916 }
917 return 0;
918}
919
8d063cd8
LW		 920/* copy a string to a safe spot */
921
954c1994 922/*
ccfc67b7
JH		 923=head1 Memory Management
924
954c1994
GS		 925=for apidoc savepv
926
61a925ed
AMS		 927Perl's version of C<strdup()>. Returns a pointer to a newly allocated
928string which is a duplicate of C<pv>. The size of the string is
929determined by C<strlen()>. The memory allocated for the new string can
930be freed with the C<Safefree()> function.
954c1994
GS		 931
932=cut
933*/
934
8d063cd8 935char *
efdfce31 936Perl_savepv(pTHX_ const char *pv)
8d063cd8 937{
96a5add6 938 PERL_UNUSED_CONTEXT;
e90e2364 939 if (!pv)
bd61b366 940 return NULL;
66a1b24b
AL		 941 else {
942 char *newaddr;
943 const STRLEN pvlen = strlen(pv)+1;
10edeb5d
JH		 944 Newx(newaddr, pvlen, char);
945 return (char*)memcpy(newaddr, pv, pvlen);
66a1b24b 946 }
8d063cd8
LW		 947}
948
a687059c
LW		 949/* same thing but with a known length */
950
954c1994
GS		 951/*
952=for apidoc savepvn
953
61a925ed
AMS		 954Perl's version of what C<strndup()> would be if it existed. Returns a
955pointer to a newly allocated string which is a duplicate of the first
cbf82dd0
NC		 956C<len> bytes from C<pv>, plus a trailing NUL byte. The memory allocated for
957the new string can be freed with the C<Safefree()> function.
954c1994
GS		 958
959=cut
960*/
961
a687059c 962char *
efdfce31 963Perl_savepvn(pTHX_ const char *pv, register I32 len)
a687059c
LW		 964{
965 register char *newaddr;
96a5add6 966 PERL_UNUSED_CONTEXT;
a687059c 967
a02a5408 968 Newx(newaddr,len+1,char);
92110913 969 /* Give a meaning to NULL pointer mainly for the use in sv_magic() */
efdfce31 970 if (pv) {
e90e2364
NC		 971 /* might not be null terminated */
972 newaddr[len] = '\0';
07409e01 973 return (char *) CopyD(pv,newaddr,len,char);
92110913
NIS		 974 }
975 else {
07409e01 976 return (char *) ZeroD(newaddr,len+1,char);
92110913 977 }
a687059c
LW		 978}
979
05ec9bb3
NIS		 980/*
981=for apidoc savesharedpv
982
61a925ed
AMS		 983A version of C<savepv()> which allocates the duplicate string in memory
984which is shared between threads.
05ec9bb3
NIS		 985
986=cut
987*/
988char *
efdfce31 989Perl_savesharedpv(pTHX_ const char *pv)
05ec9bb3 990{
e90e2364 991 register char *newaddr;
490a0e98 992 STRLEN pvlen;
e90e2364 993 if (!pv)
bd61b366 994 return NULL;
e90e2364 995
490a0e98
NC		 996 pvlen = strlen(pv)+1;
997 newaddr = (char*)PerlMemShared_malloc(pvlen);
e90e2364 998 if (!newaddr) {
0bd48802 999 return write_no_mem();
05ec9bb3 1000 }
10edeb5d 1001 return (char*)memcpy(newaddr, pv, pvlen);
05ec9bb3
NIS		 1002}
1003
2e0de35c 1004/*
d9095cec
NC		 1005=for apidoc savesharedpvn
1006
1007A version of C<savepvn()> which allocates the duplicate string in memory
1008which is shared between threads. (With the specific difference that a NULL
1009pointer is not acceptable)
1010
1011=cut
1012*/
1013char *
1014Perl_savesharedpvn(pTHX_ const char *const pv, const STRLEN len)
1015{
1016 char *const newaddr = (char*)PerlMemShared_malloc(len + 1);
7918f24d
NC		 1017
1018 PERL_ARGS_ASSERT_SAVESHAREDPVN;
1019
d9095cec
NC		 1020 if (!newaddr) {
1021 return write_no_mem();
1022 }
1023 newaddr[len] = '\0';
1024 return (char*)memcpy(newaddr, pv, len);
1025}
1026
1027/*
2e0de35c
NC		 1028=for apidoc savesvpv
1029
6832267f 1030A version of C<savepv()>/C<savepvn()> which gets the string to duplicate from
2e0de35c
NC		 1031the passed in SV using C<SvPV()>
1032
1033=cut
1034*/
1035
1036char *
1037Perl_savesvpv(pTHX_ SV *sv)
1038{
1039 STRLEN len;
7452cf6a 1040 const char * const pv = SvPV_const(sv, len);
2e0de35c
NC		 1041 register char *newaddr;
1042
7918f24d
NC		 1043 PERL_ARGS_ASSERT_SAVESVPV;
1044
26866f99 1045 ++len;
a02a5408 1046 Newx(newaddr,len,char);
07409e01 1047 return (char *) CopyD(pv,newaddr,len,char);
2e0de35c 1048}
05ec9bb3
NIS		 1049
1050
cea2e8a9 1051/* the SV for Perl_form() and mess() is not kept in an arena */
fc36a67e 1052
76e3520e 1053STATIC SV *
cea2e8a9 1054S_mess_alloc(pTHX)
fc36a67e 1055{
97aff369 1056 dVAR;
fc36a67e 1057 SV *sv;
1058 XPVMG *any;
1059
e72dc28c 1060 if (!PL_dirty)
84bafc02 1061 return newSVpvs_flags("", SVs_TEMP);
e72dc28c 1062
0372dbb6
GS		 1063 if (PL_mess_sv)
1064 return PL_mess_sv;
1065
fc36a67e 1066 /* Create as PVMG now, to avoid any upgrading later */
a02a5408
JC		 1067 Newx(sv, 1, SV);
1068 Newxz(any, 1, XPVMG);
fc36a67e 1069 SvFLAGS(sv) = SVt_PVMG;
1070 SvANY(sv) = (void*)any;
6136c704 1071 SvPV_set(sv, NULL);
fc36a67e 1072 SvREFCNT(sv) = 1 << 30; /* practically infinite */
e72dc28c 1073 PL_mess_sv = sv;
fc36a67e 1074 return sv;
1075}
1076
c5be433b 1077#if defined(PERL_IMPLICIT_CONTEXT)
cea2e8a9
GS		 1078char *
1079Perl_form_nocontext(const char* pat, ...)
1080{
1081 dTHX;
c5be433b 1082 char *retval;
cea2e8a9 1083 va_list args;
7918f24d 1084 PERL_ARGS_ASSERT_FORM_NOCONTEXT;
cea2e8a9 1085 va_start(args, pat);
c5be433b 1086 retval = vform(pat, &args);
cea2e8a9 1087 va_end(args);
c5be433b 1088 return retval;
cea2e8a9 1089}
c5be433b 1090#endif /* PERL_IMPLICIT_CONTEXT */
cea2e8a9 1091
7c9e965c 1092/*
ccfc67b7 1093=head1 Miscellaneous Functions
7c9e965c
JP		 1094=for apidoc form
1095
1096Takes a sprintf-style format pattern and conventional
1097(non-SV) arguments and returns the formatted string.
1098
1099 (char *) Perl_form(pTHX_ const char* pat, ...)
1100
1101can be used any place a string (char *) is required:
1102
1103 char * s = Perl_form("%d.%d",major,minor);
1104
1105Uses a single private buffer so if you want to format several strings you
1106must explicitly copy the earlier strings away (and free the copies when you
1107are done).
1108
1109=cut
1110*/
1111
8990e307 1112char *
864dbfa3 1113Perl_form(pTHX_ const char* pat, ...)
8990e307 1114{
c5be433b 1115 char *retval;
46fc3d4c 1116 va_list args;
7918f24d 1117 PERL_ARGS_ASSERT_FORM;
46fc3d4c 1118 va_start(args, pat);
c5be433b 1119 retval = vform(pat, &args);
46fc3d4c 1120 va_end(args);
c5be433b
GS		 1121 return retval;
1122}
1123
1124char *
1125Perl_vform(pTHX_ const char *pat, va_list *args)
1126{
2d03de9c 1127 SV * const sv = mess_alloc();
7918f24d 1128 PERL_ARGS_ASSERT_VFORM;
4608196e 1129 sv_vsetpvfn(sv, pat, strlen(pat), args, NULL, 0, NULL);
e72dc28c 1130 return SvPVX(sv);
46fc3d4c 1131}
a687059c 1132
5a844595
GS		 1133#if defined(PERL_IMPLICIT_CONTEXT)
1134SV *
1135Perl_mess_nocontext(const char *pat, ...)
1136{
1137 dTHX;
1138 SV *retval;
1139 va_list args;
7918f24d 1140 PERL_ARGS_ASSERT_MESS_NOCONTEXT;
5a844595
GS		 1141 va_start(args, pat);
1142 retval = vmess(pat, &args);
1143 va_end(args);
1144 return retval;
1145}
1146#endif /* PERL_IMPLICIT_CONTEXT */
1147
06bf62c7 1148SV *
5a844595
GS		 1149Perl_mess(pTHX_ const char *pat, ...)
1150{
1151 SV *retval;
1152 va_list args;
7918f24d 1153 PERL_ARGS_ASSERT_MESS;
5a844595
GS		 1154 va_start(args, pat);
1155 retval = vmess(pat, &args);
1156 va_end(args);
1157 return retval;
1158}
1159
5f66b61c
AL		 1160STATIC const COP*
1161S_closest_cop(pTHX_ const COP *cop, const OP *o)
ae7d165c 1162{
97aff369 1163 dVAR;
ae7d165c
PJ		 1164 /* Look for PL_op starting from o. cop is the last COP we've seen. */
1165
7918f24d
NC		 1166 PERL_ARGS_ASSERT_CLOSEST_COP;
1167
fabdb6c0
AL		 1168 if (!o || o == PL_op)
1169 return cop;
ae7d165c
PJ		 1170
1171 if (o->op_flags & OPf_KIDS) {
5f66b61c 1172 const OP *kid;
fabdb6c0 1173 for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling) {
5f66b61c 1174 const COP *new_cop;
ae7d165c
PJ		 1175
1176 /* If the OP_NEXTSTATE has been optimised away we can still use it
1177 * the get the file and line number. */
1178
1179 if (kid->op_type == OP_NULL && kid->op_targ == OP_NEXTSTATE)
5f66b61c 1180 cop = (const COP *)kid;
ae7d165c
PJ		 1181
1182 /* Keep searching, and return when we've found something. */
1183
1184 new_cop = closest_cop(cop, kid);
fabdb6c0
AL		 1185 if (new_cop)
1186 return new_cop;
ae7d165c
PJ		 1187 }
1188 }
1189
1190 /* Nothing found. */
1191
5f66b61c 1192 return NULL;
ae7d165c
PJ		 1193}
1194
5a844595
GS		 1195SV *
1196Perl_vmess(pTHX_ const char *pat, va_list *args)
46fc3d4c 1197{
97aff369 1198 dVAR;
c4420975 1199 SV * const sv = mess_alloc();
46fc3d4c 1200
7918f24d
NC		 1201 PERL_ARGS_ASSERT_VMESS;
1202
5f66b61c 1203 sv_vsetpvfn(sv, pat, strlen(pat), args, NULL, 0, NULL);
46fc3d4c 1204 if (!SvCUR(sv) || *(SvEND(sv) - 1) != '\n') {
ae7d165c
PJ		 1205 /*
1206 * Try and find the file and line for PL_op. This will usually be
1207 * PL_curcop, but it might be a cop that has been optimised away. We
1208 * can try to find such a cop by searching through the optree starting
1209 * from the sibling of PL_curcop.
1210 */
1211
e1ec3a88 1212 const COP *cop = closest_cop(PL_curcop, PL_curcop->op_sibling);
5f66b61c
AL		 1213 if (!cop)
1214 cop = PL_curcop;
ae7d165c
PJ		 1215
1216 if (CopLINE(cop))
ed094faf 1217 Perl_sv_catpvf(aTHX_ sv, " at %s line %"IVdf,
3aed30dc 1218 OutCopFILE(cop), (IV)CopLINE(cop));
191f87d5
DH		 1219 /* Seems that GvIO() can be untrustworthy during global destruction. */
1220 if (GvIO(PL_last_in_gv) && (SvTYPE(GvIOp(PL_last_in_gv)) == SVt_PVIO)
1221 && IoLINES(GvIOp(PL_last_in_gv)))
1222 {
e1ec3a88 1223 const bool line_mode = (RsSIMPLE(PL_rs) &&
95a20fc0 1224 SvCUR(PL_rs) == 1 && *SvPVX_const(PL_rs) == '\n');
57def98f 1225 Perl_sv_catpvf(aTHX_ sv, ", <%s> %s %"IVdf,
5f66b61c 1226 PL_last_in_gv == PL_argvgv ? "" : GvNAME(PL_last_in_gv),
edc2eac3
JH		 1227 line_mode ? "line" : "chunk",
1228 (IV)IoLINES(GvIOp(PL_last_in_gv)));
a687059c 1229 }
5f66b61c
AL		 1230 if (PL_dirty)
1231 sv_catpvs(sv, " during global destruction");
1232 sv_catpvs(sv, ".\n");
a687059c 1233 }
06bf62c7 1234 return sv;
a687059c
LW		 1235}
1236
7ff03255
SG		 1237void
1238Perl_write_to_stderr(pTHX_ const char* message, int msglen)
1239{
27da23d5 1240 dVAR;
7ff03255
SG		 1241 IO *io;
1242 MAGIC *mg;
1243
7918f24d
NC		 1244 PERL_ARGS_ASSERT_WRITE_TO_STDERR;
1245
7ff03255
SG		 1246 if (PL_stderrgv && SvREFCNT(PL_stderrgv)
1247 && (io = GvIO(PL_stderrgv))
daba3364 1248 && (mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar)))
7ff03255
SG		 1249 {
1250 dSP;
1251 ENTER;
1252 SAVETMPS;
1253
1254 save_re_context();
1255 SAVESPTR(PL_stderrgv);
a0714e2c 1256 PL_stderrgv = NULL;
7ff03255
SG		 1257
1258 PUSHSTACKi(PERLSI_MAGIC);
1259
1260 PUSHMARK(SP);
1261 EXTEND(SP,2);
daba3364 1262 PUSHs(SvTIED_obj(MUTABLE_SV(io), mg));
6e449a3a 1263 mPUSHp(message, msglen);
7ff03255
SG		 1264 PUTBACK;
1265 call_method("PRINT", G_SCALAR);
1266
1267 POPSTACK;
1268 FREETMPS;
1269 LEAVE;
1270 }
1271 else {
1272#ifdef USE_SFIO
1273 /* SFIO can really mess with your errno */
4ee39169 1274 dSAVED_ERRNO;
7ff03255 1275#endif
53c1dcc0 1276 PerlIO * const serr = Perl_error_log;
7ff03255
SG		 1277
1278 PERL_WRITE_MSG_TO_CONSOLE(serr, message, msglen);
1279 (void)PerlIO_flush(serr);
1280#ifdef USE_SFIO
4ee39169 1281 RESTORE_ERRNO;
7ff03255
SG		 1282#endif
1283 }
1284}
1285
46d9c920 1286/* Common code used by vcroak, vdie, vwarn and vwarner */
3ab1ac99 1287
46d9c920
NC		 1288STATIC bool
1289S_vdie_common(pTHX_ const char *message, STRLEN msglen, I32 utf8, bool warn)
63315e18 1290{
97aff369 1291 dVAR;
63315e18
NC		 1292 HV *stash;
1293 GV *gv;
1294 CV *cv;
46d9c920
NC		 1295 SV **const hook = warn ? &PL_warnhook : &PL_diehook;
1296 /* sv_2cv might call Perl_croak() or Perl_warner() */
1297 SV * const oldhook = *hook;
1298
1299 assert(oldhook);
63315e18 1300
63315e18 1301 ENTER;
46d9c920
NC		 1302 SAVESPTR(*hook);
1303 *hook = NULL;
1304 cv = sv_2cv(oldhook, &stash, &gv, 0);
63315e18
NC		 1305 LEAVE;
1306 if (cv && !CvDEPTH(cv) && (CvROOT(cv) || CvXSUB(cv))) {
1307 dSP;
1308 SV *msg;
1309
1310 ENTER;
1311 save_re_context();
46d9c920
NC		 1312 if (warn) {
1313 SAVESPTR(*hook);
1314 *hook = NULL;
1315 }
1316 if (warn || message) {
740cce10 1317 msg = newSVpvn_flags(message, msglen, utf8);
63315e18
NC		 1318 SvREADONLY_on(msg);
1319 SAVEFREESV(msg);
1320 }
1321 else {
1322 msg = ERRSV;
1323 }
1324
46d9c920 1325 PUSHSTACKi(warn ? PERLSI_WARNHOOK : PERLSI_DIEHOOK);
63315e18
NC		 1326 PUSHMARK(SP);
1327 XPUSHs(msg);
1328 PUTBACK;
daba3364 1329 call_sv(MUTABLE_SV(cv), G_DISCARD);
63315e18
NC		 1330 POPSTACK;
1331 LEAVE;
46d9c920 1332 return TRUE;
63315e18 1333 }
46d9c920 1334 return FALSE;
63315e18
NC		 1335}
1336
cfd0369c 1337STATIC const char *
e07360fa
AT		 1338S_vdie_croak_common(pTHX_ const char* pat, va_list* args, STRLEN* msglen,
1339 I32* utf8)
1340{
1341 dVAR;
cfd0369c 1342 const char *message;
e07360fa
AT		 1343
1344 if (pat) {
890ce7af 1345 SV * const msv = vmess(pat, args);
e07360fa
AT		 1346 if (PL_errors && SvCUR(PL_errors)) {
1347 sv_catsv(PL_errors, msv);
cfd0369c 1348 message = SvPV_const(PL_errors, *msglen);
e07360fa
AT		 1349 SvCUR_set(PL_errors, 0);
1350 }
1351 else
cfd0369c 1352 message = SvPV_const(msv,*msglen);
e07360fa
AT		 1353 *utf8 = SvUTF8(msv);
1354 }
1355 else {
bd61b366 1356 message = NULL;
e07360fa
AT		 1357 }
1358
e07360fa 1359 if (PL_diehook) {
46d9c920 1360 S_vdie_common(aTHX_ message, *msglen, *utf8, FALSE);
e07360fa
AT		 1361 }
1362 return message;
1363}
1364
1f676739 1365static OP *
e3cf49e2 1366S_vdie(pTHX_ const char* pat, va_list *args)
36477c24 1367{
97aff369 1368 dVAR;
73d840c0 1369 const char *message;
e1ec3a88 1370 const int was_in_eval = PL_in_eval;
06bf62c7 1371 STRLEN msglen;
ff882698 1372 I32 utf8 = 0;
36477c24 1373
890ce7af 1374 message = vdie_croak_common(pat, args, &msglen, &utf8);
36477c24 1375
06bf62c7 1376 PL_restartop = die_where(message, msglen);
ff882698 1377 SvFLAGS(ERRSV) |= utf8;
3280af22 1378 if ((!PL_restartop && was_in_eval) || PL_top_env->je_prev)
6224f72b 1379 JMPENV_JUMP(3);
3280af22 1380 return PL_restartop;
36477c24 1381}
1382
c5be433b 1383#if defined(PERL_IMPLICIT_CONTEXT)
cea2e8a9
GS		 1384OP *
1385Perl_die_nocontext(const char* pat, ...)
a687059c 1386{
cea2e8a9
GS		 1387 dTHX;
1388 OP *o;
a687059c 1389 va_list args;
7918f24d 1390 PERL_ARGS_ASSERT_DIE_NOCONTEXT;
cea2e8a9 1391 va_start(args, pat);
c5be433b 1392 o = vdie(pat, &args);
cea2e8a9
GS		 1393 va_end(args);
1394 return o;
1395}
c5be433b 1396#endif /* PERL_IMPLICIT_CONTEXT */
cea2e8a9
GS		 1397
1398OP *
1399Perl_die(pTHX_ const char* pat, ...)
1400{
1401 OP *o;
1402 va_list args;
1403 va_start(args, pat);
c5be433b 1404 o = vdie(pat, &args);
cea2e8a9
GS		 1405 va_end(args);
1406 return o;
1407}
1408
c5be433b
GS		 1409void
1410Perl_vcroak(pTHX_ const char* pat, va_list *args)
cea2e8a9 1411{
97aff369 1412 dVAR;
73d840c0 1413 const char *message;
06bf62c7 1414 STRLEN msglen;
ff882698 1415 I32 utf8 = 0;
a687059c 1416
3ab1ac99 1417 message = S_vdie_croak_common(aTHX_ pat, args, &msglen, &utf8);
5a844595 1418
3280af22 1419 if (PL_in_eval) {
06bf62c7 1420 PL_restartop = die_where(message, msglen);
ff882698 1421 SvFLAGS(ERRSV) |= utf8;
6224f72b 1422 JMPENV_JUMP(3);
a0d0e21e 1423 }
84414e3e 1424 else if (!message)
cfd0369c 1425 message = SvPVx_const(ERRSV, msglen);
84414e3e 1426
7ff03255 1427 write_to_stderr(message, msglen);
f86702cc 1428 my_failure_exit();
a687059c
LW		 1429}
1430
c5be433b 1431#if defined(PERL_IMPLICIT_CONTEXT)
8990e307 1432void
cea2e8a9 1433Perl_croak_nocontext(const char *pat, ...)
a687059c 1434{
cea2e8a9 1435 dTHX;
a687059c 1436 va_list args;
cea2e8a9 1437 va_start(args, pat);
c5be433b 1438 vcroak(pat, &args);
cea2e8a9
GS		 1439 /* NOTREACHED */
1440 va_end(args);
1441}
1442#endif /* PERL_IMPLICIT_CONTEXT */
1443
954c1994 1444/*
ccfc67b7
JH		 1445=head1 Warning and Dieing
1446
954c1994
GS		 1447=for apidoc croak
1448
9983fa3c 1449This is the XSUB-writer's interface to Perl's C<die> function.
966353fd
MF		 1450Normally call this function the same way you call the C C<printf>
1451function. Calling C<croak> returns control directly to Perl,
1452sidestepping the normal C order of execution. See C<warn>.
9983fa3c
GS		 1453
1454If you want to throw an exception object, assign the object to
bd61b366 1455C<$@> and then pass C<NULL> to croak():
9983fa3c 1456
64ace3f8 1457 errsv = get_sv("@", GV_ADD);
9983fa3c 1458 sv_setsv(errsv, exception_object);
bd61b366 1459 croak(NULL);
954c1994
GS		 1460
1461=cut
1462*/
1463
cea2e8a9
GS		 1464void
1465Perl_croak(pTHX_ const char *pat, ...)
1466{
1467 va_list args;
1468 va_start(args, pat);
c5be433b 1469 vcroak(pat, &args);
cea2e8a9
GS		 1470 /* NOTREACHED */
1471 va_end(args);
1472}
1473
c5be433b
GS		 1474void
1475Perl_vwarn(pTHX_ const char* pat, va_list *args)
cea2e8a9 1476{
27da23d5 1477 dVAR;
06bf62c7 1478 STRLEN msglen;
53c1dcc0
AL		 1479 SV * const msv = vmess(pat, args);
1480 const I32 utf8 = SvUTF8(msv);
1481 const char * const message = SvPV_const(msv, msglen);
a687059c 1482
7918f24d
NC		 1483 PERL_ARGS_ASSERT_VWARN;
1484
3280af22 1485 if (PL_warnhook) {
46d9c920 1486 if (vdie_common(message, msglen, utf8, TRUE))
20cec16a 1487 return;
748a9306 1488 }
87582a92 1489
7ff03255 1490 write_to_stderr(message, msglen);
a687059c 1491}
8d063cd8 1492
c5be433b 1493#if defined(PERL_IMPLICIT_CONTEXT)
cea2e8a9
GS		 1494void
1495Perl_warn_nocontext(const char *pat, ...)
1496{
1497 dTHX;
1498 va_list args;
7918f24d 1499 PERL_ARGS_ASSERT_WARN_NOCONTEXT;
cea2e8a9 1500 va_start(args, pat);
c5be433b 1501 vwarn(pat, &args);
cea2e8a9
GS		 1502 va_end(args);
1503}
1504#endif /* PERL_IMPLICIT_CONTEXT */
1505
954c1994
GS		 1506/*
1507=for apidoc warn
1508
966353fd
MF		 1509This is the XSUB-writer's interface to Perl's C<warn> function. Call this
1510function the same way you call the C C<printf> function. See C<croak>.
954c1994
GS		 1511
1512=cut
1513*/
1514
cea2e8a9
GS		 1515void
1516Perl_warn(pTHX_ const char *pat, ...)
1517{
1518 va_list args;
7918f24d 1519 PERL_ARGS_ASSERT_WARN;
cea2e8a9 1520 va_start(args, pat);
c5be433b 1521 vwarn(pat, &args);
cea2e8a9
GS		 1522 va_end(args);
1523}
1524
c5be433b
GS		 1525#if defined(PERL_IMPLICIT_CONTEXT)
1526void
1527Perl_warner_nocontext(U32 err, const char *pat, ...)
1528{
27da23d5 1529 dTHX;
c5be433b 1530 va_list args;
7918f24d 1531 PERL_ARGS_ASSERT_WARNER_NOCONTEXT;
c5be433b
GS		 1532 va_start(args, pat);
1533 vwarner(err, pat, &args);
1534 va_end(args);
1535}
1536#endif /* PERL_IMPLICIT_CONTEXT */
1537
599cee73 1538void
864dbfa3 1539Perl_warner(pTHX_ U32 err, const char* pat,...)
599cee73
PM		 1540{
1541 va_list args;
7918f24d 1542 PERL_ARGS_ASSERT_WARNER;
c5be433b
GS		 1543 va_start(args, pat);
1544 vwarner(err, pat, &args);
1545 va_end(args);
1546}
1547
1548void
1549Perl_vwarner(pTHX_ U32 err, const char* pat, va_list* args)
1550{
27da23d5 1551 dVAR;
7918f24d 1552 PERL_ARGS_ASSERT_VWARNER;
5f2d9966 1553 if (PL_warnhook == PERL_WARNHOOK_FATAL || ckDEAD(err)) {
a3b680e6 1554 SV * const msv = vmess(pat, args);
d13b0d77 1555 STRLEN msglen;
7452cf6a 1556 const char * const message = SvPV_const(msv, msglen);
a3b680e6 1557 const I32 utf8 = SvUTF8(msv);
599cee73 1558
3aed30dc 1559 if (PL_diehook) {
63315e18 1560 assert(message);
46d9c920 1561 S_vdie_common(aTHX_ message, msglen, utf8, FALSE);
3aed30dc
HS		 1562 }
1563 if (PL_in_eval) {
1564 PL_restartop = die_where(message, msglen);
ff882698 1565 SvFLAGS(ERRSV) |= utf8;
3aed30dc
HS		 1566 JMPENV_JUMP(3);
1567 }
7ff03255 1568 write_to_stderr(message, msglen);
3aed30dc 1569 my_failure_exit();
599cee73
PM		 1570 }
1571 else {
d13b0d77 1572 Perl_vwarn(aTHX_ pat, args);
599cee73
PM		 1573 }
1574}
1575
f54ba1c2
DM		 1576/* implements the ckWARN? macros */
1577
1578bool
1579Perl_ckwarn(pTHX_ U32 w)
1580{
97aff369 1581 dVAR;
f54ba1c2
DM		 1582 return
1583 (
1584 isLEXWARN_on
1585 && PL_curcop->cop_warnings != pWARN_NONE
1586 && (
1587 PL_curcop->cop_warnings == pWARN_ALL
1588 || isWARN_on(PL_curcop->cop_warnings, unpackWARN1(w))
1589 || (unpackWARN2(w) &&
1590 isWARN_on(PL_curcop->cop_warnings, unpackWARN2(w)))
1591 || (unpackWARN3(w) &&
1592 isWARN_on(PL_curcop->cop_warnings, unpackWARN3(w)))
1593 || (unpackWARN4(w) &&
1594 isWARN_on(PL_curcop->cop_warnings, unpackWARN4(w)))
1595 )
1596 )
1597 ||
1598 (
1599 isLEXWARN_off && PL_dowarn & G_WARN_ON
1600 )
1601 ;
1602}
1603
1604/* implements the ckWARN?_d macro */
1605
1606bool
1607Perl_ckwarn_d(pTHX_ U32 w)
1608{
97aff369 1609 dVAR;
f54ba1c2
DM		 1610 return
1611 isLEXWARN_off
1612 || PL_curcop->cop_warnings == pWARN_ALL
1613 || (
1614 PL_curcop->cop_warnings != pWARN_NONE
1615 && (
1616 isWARN_on(PL_curcop->cop_warnings, unpackWARN1(w))
1617 || (unpackWARN2(w) &&
1618 isWARN_on(PL_curcop->cop_warnings, unpackWARN2(w)))
1619 || (unpackWARN3(w) &&
1620 isWARN_on(PL_curcop->cop_warnings, unpackWARN3(w)))
1621 || (unpackWARN4(w) &&
1622 isWARN_on(PL_curcop->cop_warnings, unpackWARN4(w)))
1623 )
1624 )
1625 ;
1626}
1627
72dc9ed5
NC		 1628/* Set buffer=NULL to get a new one. */
1629STRLEN *
8ee4cf24 1630Perl_new_warnings_bitfield(pTHX_ STRLEN *buffer, const char *const bits,
72dc9ed5
NC		 1631 STRLEN size) {
1632 const MEM_SIZE len_wanted = sizeof(STRLEN) + size;
35da51f7 1633 PERL_UNUSED_CONTEXT;
7918f24d 1634 PERL_ARGS_ASSERT_NEW_WARNINGS_BITFIELD;
72dc9ed5 1635
10edeb5d
JH		 1636 buffer = (STRLEN*)
1637 (specialWARN(buffer) ?
1638 PerlMemShared_malloc(len_wanted) :
1639 PerlMemShared_realloc(buffer, len_wanted));
72dc9ed5
NC		 1640 buffer[0] = size;
1641 Copy(bits, (buffer + 1), size, char);
1642 return buffer;
1643}
f54ba1c2 1644
e6587932
DM		 1645/* since we've already done strlen() for both nam and val
1646 * we can use that info to make things faster than
1647 * sprintf(s, "%s=%s", nam, val)
1648 */
1649#define my_setenv_format(s, nam, nlen, val, vlen) \
1650 Copy(nam, s, nlen, char); \
1651 *(s+nlen) = '='; \
1652 Copy(val, s+(nlen+1), vlen, char); \
1653 *(s+(nlen+1+vlen)) = '\0'
1654
c5d12488
JH		 1655#ifdef USE_ENVIRON_ARRAY
1656 /* VMS' my_setenv() is in vms.c */
1657#if !defined(WIN32) && !defined(NETWARE)
8d063cd8 1658void
e1ec3a88 1659Perl_my_setenv(pTHX_ const char *nam, const char *val)
8d063cd8 1660{
27da23d5 1661 dVAR;
4efc5df6
GS		 1662#ifdef USE_ITHREADS
1663 /* only parent thread can modify process environment */
1664 if (PL_curinterp == aTHX)
1665#endif
1666 {
f2517201 1667#ifndef PERL_USE_SAFE_PUTENV
50acdf95 1668 if (!PL_use_safe_putenv) {
c5d12488 1669 /* most putenv()s leak, so we manipulate environ directly */
3a9222be
JH		 1670 register I32 i;
1671 register const I32 len = strlen(nam);
c5d12488
JH		 1672 int nlen, vlen;
1673
3a9222be
JH		 1674 /* where does it go? */
1675 for (i = 0; environ[i]; i++) {
1676 if (strnEQ(environ[i],nam,len) && environ[i][len] == '=')
1677 break;
1678 }
1679
c5d12488
JH		 1680 if (environ == PL_origenviron) { /* need we copy environment? */
1681 I32 j;
1682 I32 max;
1683 char **tmpenv;
1684
1685 max = i;
1686 while (environ[max])
1687 max++;
1688 tmpenv = (char**)safesysmalloc((max+2) * sizeof(char*));
1689 for (j=0; j<max; j++) { /* copy environment */
1690 const int len = strlen(environ[j]);
1691 tmpenv[j] = (char*)safesysmalloc((len+1)*sizeof(char));
1692 Copy(environ[j], tmpenv[j], len+1, char);
1693 }
1694 tmpenv[max] = NULL;
1695 environ = tmpenv; /* tell exec where it is now */
1696 }
1697 if (!val) {
1698 safesysfree(environ[i]);
1699 while (environ[i]) {
1700 environ[i] = environ[i+1];
1701 i++;
a687059c 1702 }
c5d12488
JH		 1703 return;
1704 }
1705 if (!environ[i]) { /* does not exist yet */
1706 environ = (char**)safesysrealloc(environ, (i+2) * sizeof(char*));
1707 environ[i+1] = NULL; /* make sure it's null terminated */
1708 }
1709 else
1710 safesysfree(environ[i]);
1711 nlen = strlen(nam);
1712 vlen = strlen(val);
1713
1714 environ[i] = (char*)safesysmalloc((nlen+vlen+2) * sizeof(char));
1715 /* all that work just for this */
1716 my_setenv_format(environ[i], nam, nlen, val, vlen);
50acdf95 1717 } else {
c5d12488 1718# endif
7ee146b1 1719# if defined(__CYGWIN__) || defined(EPOC) || defined(__SYMBIAN32__) || defined(__riscos__)
88f5bc07
AB		 1720# if defined(HAS_UNSETENV)
1721 if (val == NULL) {
1722 (void)unsetenv(nam);
1723 } else {
1724 (void)setenv(nam, val, 1);
1725 }
1726# else /* ! HAS_UNSETENV */
1727 (void)setenv(nam, val, 1);
1728# endif /* HAS_UNSETENV */
47dafe4d 1729# else
88f5bc07
AB		 1730# if defined(HAS_UNSETENV)
1731 if (val == NULL) {
1732 (void)unsetenv(nam);
1733 } else {
c4420975
AL		 1734 const int nlen = strlen(nam);
1735 const int vlen = strlen(val);
1736 char * const new_env =
88f5bc07
AB		 1737 (char*)safesysmalloc((nlen + vlen + 2) * sizeof(char));
1738 my_setenv_format(new_env, nam, nlen, val, vlen);
1739 (void)putenv(new_env);
1740 }
1741# else /* ! HAS_UNSETENV */
1742 char *new_env;
c4420975
AL		 1743 const int nlen = strlen(nam);
1744 int vlen;
88f5bc07
AB		 1745 if (!val) {
1746 val = "";
1747 }
1748 vlen = strlen(val);
1749 new_env = (char*)safesysmalloc((nlen + vlen + 2) * sizeof(char));
1750 /* all that work just for this */
1751 my_setenv_format(new_env, nam, nlen, val, vlen);
1752 (void)putenv(new_env);
1753# endif /* HAS_UNSETENV */
47dafe4d 1754# endif /* __CYGWIN__ */
50acdf95
MS		 1755#ifndef PERL_USE_SAFE_PUTENV
1756 }
1757#endif
4efc5df6 1758 }
8d063cd8
LW		 1759}
1760
c5d12488 1761#else /* WIN32 || NETWARE */
68dc0745 1762
1763void
72229eff 1764Perl_my_setenv(pTHX_ const char *nam, const char *val)
68dc0745 1765{
27da23d5 1766 dVAR;
c5d12488
JH		 1767 register char *envstr;
1768 const int nlen = strlen(nam);
1769 int vlen;
e6587932 1770
c5d12488
JH		 1771 if (!val) {
1772 val = "";
ac5c734f 1773 }
c5d12488
JH		 1774 vlen = strlen(val);
1775 Newx(envstr, nlen+vlen+2, char);
1776 my_setenv_format(envstr, nam, nlen, val, vlen);
1777 (void)PerlEnv_putenv(envstr);
1778 Safefree(envstr);
3e3baf6d
TB		 1779}
1780
c5d12488 1781#endif /* WIN32 || NETWARE */
3e3baf6d 1782
c5d12488 1783#endif /* !VMS && !EPOC*/
378cc40b 1784
16d20bd9 1785#ifdef UNLINK_ALL_VERSIONS
79072805 1786I32
6e732051 1787Perl_unlnk(pTHX_ const char *f) /* unlink all versions of a file */
378cc40b 1788{
35da51f7 1789 I32 retries = 0;
378cc40b 1790
7918f24d
NC		 1791 PERL_ARGS_ASSERT_UNLNK;
1792
35da51f7
AL		 1793 while (PerlLIO_unlink(f) >= 0)
1794 retries++;
1795 return retries ? 0 : -1;
378cc40b
LW		 1796}
1797#endif
1798
7a3f2258 1799/* this is a drop-in replacement for bcopy() */
2253333f 1800#if (!defined(HAS_MEMCPY) && !defined(HAS_BCOPY)) || (!defined(HAS_MEMMOVE) && !defined(HAS_SAFE_MEMCPY) && !defined(HAS_SAFE_BCOPY))
378cc40b 1801char *
7a3f2258 1802Perl_my_bcopy(register const char *from,register char *to,register I32 len)
378cc40b 1803{
2d03de9c 1804 char * const retval = to;
378cc40b 1805
7918f24d
NC		 1806 PERL_ARGS_ASSERT_MY_BCOPY;
1807
7c0587c8
LW		 1808 if (from - to >= 0) {
1809 while (len--)
1810 *to++ = *from++;
1811 }
1812 else {
1813 to += len;
1814 from += len;
1815 while (len--)
faf8582f 1816 *(--to) = *(--from);
7c0587c8 1817 }
378cc40b
LW		 1818 return retval;
1819}
ffed7fef 1820#endif
378cc40b 1821
7a3f2258 1822/* this is a drop-in replacement for memset() */
fc36a67e 1823#ifndef HAS_MEMSET
1824void *
7a3f2258 1825Perl_my_memset(register char *loc, register I32 ch, register I32 len)
fc36a67e 1826{
2d03de9c 1827 char * const retval = loc;
fc36a67e 1828
7918f24d
NC		 1829 PERL_ARGS_ASSERT_MY_MEMSET;
1830
fc36a67e 1831 while (len--)
1832 *loc++ = ch;
1833 return retval;
1834}
1835#endif
1836
7a3f2258 1837/* this is a drop-in replacement for bzero() */
7c0587c8 1838#if !defined(HAS_BZERO) && !defined(HAS_MEMSET)
378cc40b 1839char *
7a3f2258 1840Perl_my_bzero(register char *loc, register I32 len)
378cc40b 1841{
2d03de9c 1842 char * const retval = loc;
378cc40b 1843
7918f24d
NC		 1844 PERL_ARGS_ASSERT_MY_BZERO;
1845
378cc40b
LW		 1846 while (len--)
1847 *loc++ = 0;
1848 return retval;
1849}
1850#endif
7c0587c8 1851
7a3f2258 1852/* this is a drop-in replacement for memcmp() */
36477c24 1853#if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP)
79072805 1854I32
7a3f2258 1855Perl_my_memcmp(const char *s1, const char *s2, register I32 len)
7c0587c8 1856{
e1ec3a88
AL		 1857 register const U8 *a = (const U8 *)s1;
1858 register const U8 *b = (const U8 *)s2;
79072805 1859 register I32 tmp;
7c0587c8 1860
7918f24d
NC		 1861 PERL_ARGS_ASSERT_MY_MEMCMP;
1862
7c0587c8 1863 while (len--) {
27da23d5 1864 if ((tmp = *a++ - *b++))
7c0587c8
LW		 1865 return tmp;
1866 }
1867 return 0;
1868}
36477c24 1869#endif /* !HAS_MEMCMP || !HAS_SANE_MEMCMP */
a687059c 1870
fe14fcc3 1871#ifndef HAS_VPRINTF
d05d9be5
AD		 1872/* This vsprintf replacement should generally never get used, since
1873 vsprintf was available in both System V and BSD 2.11. (There may
1874 be some cross-compilation or embedded set-ups where it is needed,
1875 however.)
1876
1877 If you encounter a problem in this function, it's probably a symptom
1878 that Configure failed to detect your system's vprintf() function.
1879 See the section on "item vsprintf" in the INSTALL file.
1880
1881 This version may compile on systems with BSD-ish <stdio.h>,
1882 but probably won't on others.
1883*/
a687059c 1884
85e6fe83 1885#ifdef USE_CHAR_VSPRINTF
a687059c
LW		 1886char *
1887#else
1888int
1889#endif
d05d9be5 1890vsprintf(char *dest, const char *pat, void *args)
a687059c
LW		 1891{
1892 FILE fakebuf;
1893
d05d9be5
AD		 1894#if defined(STDIO_PTR_LVALUE) && defined(STDIO_CNT_LVALUE)
1895 FILE_ptr(&fakebuf) = (STDCHAR *) dest;
1896 FILE_cnt(&fakebuf) = 32767;
1897#else
1898 /* These probably won't compile -- If you really need
1899 this, you'll have to figure out some other method. */
a687059c
LW		 1900 fakebuf._ptr = dest;
1901 fakebuf._cnt = 32767;
d05d9be5 1902#endif
35c8bce7
LW		 1903#ifndef _IOSTRG
1904#define _IOSTRG 0
1905#endif
a687059c
LW		 1906 fakebuf._flag = _IOWRT|_IOSTRG;
1907 _doprnt(pat, args, &fakebuf); /* what a kludge */
d05d9be5
AD		 1908#if defined(STDIO_PTR_LVALUE)
1909 *(FILE_ptr(&fakebuf)++) = '\0';
1910#else
1911 /* PerlIO has probably #defined away fputc, but we want it here. */
1912# ifdef fputc
1913# undef fputc /* XXX Should really restore it later */
1914# endif
1915 (void)fputc('\0', &fakebuf);
1916#endif
85e6fe83 1917#ifdef USE_CHAR_VSPRINTF
a687059c
LW		 1918 return(dest);
1919#else
1920 return 0; /* perl doesn't use return value */
1921#endif
1922}
1923
fe14fcc3 1924#endif /* HAS_VPRINTF */
a687059c
LW		 1925
1926#ifdef MYSWAP
ffed7fef 1927#if BYTEORDER != 0x4321
a687059c 1928short
864dbfa3 1929Perl_my_swap(pTHX_ short s)
a687059c
LW		 1930{
1931#if (BYTEORDER & 1) == 0
1932 short result;
1933
1934 result = ((s & 255) << 8) + ((s >> 8) & 255);
1935 return result;
1936#else
1937 return s;
1938#endif
1939}
1940
1941long
864dbfa3 1942Perl_my_htonl(pTHX_ long l)
a687059c
LW		 1943{
1944 union {
1945 long result;
ffed7fef 1946 char c[sizeof(long)];
a687059c
LW		 1947 } u;
1948
cef6ea9d
JH		 1949#if BYTEORDER == 0x1234 || BYTEORDER == 0x12345678
1950#if BYTEORDER == 0x12345678
1951 u.result = 0;
1952#endif
a687059c
LW		 1953 u.c[0] = (l >> 24) & 255;
1954 u.c[1] = (l >> 16) & 255;
1955 u.c[2] = (l >> 8) & 255;
1956 u.c[3] = l & 255;
1957 return u.result;
1958#else
ffed7fef 1959#if ((BYTEORDER - 0x1111) & 0x444) || !(BYTEORDER & 0xf)
cea2e8a9 1960 Perl_croak(aTHX_ "Unknown BYTEORDER\n");
a687059c 1961#else
79072805
LW		 1962 register I32 o;
1963 register I32 s;
a687059c 1964
ffed7fef
LW		 1965 for (o = BYTEORDER - 0x1111, s = 0; s < (sizeof(long)*8); o >>= 4, s += 8) {
1966 u.c[o & 0xf] = (l >> s) & 255;
a687059c
LW		 1967 }
1968 return u.result;
1969#endif
1970#endif
1971}
1972
1973long
864dbfa3 1974Perl_my_ntohl(pTHX_ long l)
a687059c
LW		 1975{
1976 union {
1977 long l;
ffed7fef 1978 char c[sizeof(long)];
a687059c
LW		 1979 } u;
1980
ffed7fef 1981#if BYTEORDER == 0x1234
a687059c
LW		 1982 u.c[0] = (l >> 24) & 255;
1983 u.c[1] = (l >> 16) & 255;
1984 u.c[2] = (l >> 8) & 255;
1985 u.c[3] = l & 255;
1986 return u.l;
1987#else
ffed7fef 1988#if ((BYTEORDER - 0x1111) & 0x444) || !(BYTEORDER & 0xf)
cea2e8a9 1989 Perl_croak(aTHX_ "Unknown BYTEORDER\n");
a687059c 1990#else
79072805
LW		 1991 register I32 o;
1992 register I32 s;
a687059c
LW		 1993
1994 u.l = l;
1995 l = 0;
ffed7fef
LW		 1996 for (o = BYTEORDER - 0x1111, s = 0; s < (sizeof(long)*8); o >>= 4, s += 8) {
1997 l |= (u.c[o & 0xf] & 255) << s;
a687059c
LW		 1998 }
1999 return l;
2000#endif
2001#endif
2002}
2003
ffed7fef 2004#endif /* BYTEORDER != 0x4321 */
988174c1
LW		 2005#endif /* MYSWAP */
2006
2007/*
2008 * Little-endian byte order functions - 'v' for 'VAX', or 'reVerse'.
2009 * If these functions are defined,
2010 * the BYTEORDER is neither 0x1234 nor 0x4321.
2011 * However, this is not assumed.
2012 * -DWS
2013 */
2014
1109a392 2015#define HTOLE(name,type) \
988174c1 2016 type \
ba106d47 2017 name (register type n) \
988174c1
LW		 2018 { \
2019 union { \
2020 type value; \
2021 char c[sizeof(type)]; \
2022 } u; \
bb7a0f54
MHM		 2023 register U32 i; \
2024 register U32 s = 0; \
1109a392 2025 for (i = 0; i < sizeof(u.c); i++, s += 8) { \
988174c1
LW		 2026 u.c[i] = (n >> s) & 0xFF; \
2027 } \
2028 return u.value; \
2029 }
2030
1109a392 2031#define LETOH(name,type) \
988174c1 2032 type \
ba106d47 2033 name (register type n) \
988174c1
LW		 2034 { \
2035 union { \
2036 type value; \
2037 char c[sizeof(type)]; \
2038 } u; \
bb7a0f54
MHM		 2039 register U32 i; \
2040 register U32 s = 0; \
988174c1
LW		 2041 u.value = n; \
2042 n = 0; \
1109a392
MHM		 2043 for (i = 0; i < sizeof(u.c); i++, s += 8) { \
2044 n |= ((type)(u.c[i] & 0xFF)) << s; \
988174c1
LW		 2045 } \
2046 return n; \
2047 }
2048
1109a392
MHM		 2049/*
2050 * Big-endian byte order functions.
2051 */
2052
2053#define HTOBE(name,type) \
2054 type \
2055 name (register type n) \
2056 { \
2057 union { \
2058 type value; \
2059 char c[sizeof(type)]; \
2060 } u; \
bb7a0f54
MHM		 2061 register U32 i; \
2062 register U32 s = 8*(sizeof(u.c)-1); \
1109a392
MHM		 2063 for (i = 0; i < sizeof(u.c); i++, s -= 8) { \
2064 u.c[i] = (n >> s) & 0xFF; \
2065 } \
2066 return u.value; \
2067 }
2068
2069#define BETOH(name,type) \
2070 type \
2071 name (register type n) \
2072 { \
2073 union { \
2074 type value; \
2075 char c[sizeof(type)]; \
2076 } u; \
bb7a0f54
MHM		 2077 register U32 i; \
2078 register U32 s = 8*(sizeof(u.c)-1); \
1109a392
MHM		 2079 u.value = n; \
2080 n = 0; \
2081 for (i = 0; i < sizeof(u.c); i++, s -= 8) { \
2082 n |= ((type)(u.c[i] & 0xFF)) << s; \
2083 } \
2084 return n; \
2085 }
2086
2087/*
2088 * If we just can't do it...
2089 */
2090
2091#define NOT_AVAIL(name,type) \
2092 type \
2093 name (register type n) \
2094 { \
2095 Perl_croak_nocontext(#name "() not available"); \
2096 return n; /* not reached */ \
2097 }
2098
2099
988174c1 2100#if defined(HAS_HTOVS) && !defined(htovs)
1109a392 2101HTOLE(htovs,short)
988174c1
LW		 2102#endif
2103#if defined(HAS_HTOVL) && !defined(htovl)
1109a392 2104HTOLE(htovl,long)
988174c1
LW		 2105#endif
2106#if defined(HAS_VTOHS) && !defined(vtohs)
1109a392 2107LETOH(vtohs,short)
988174c1
LW		 2108#endif
2109#if defined(HAS_VTOHL) && !defined(vtohl)
1109a392
MHM		 2110LETOH(vtohl,long)
2111#endif
2112
2113#ifdef PERL_NEED_MY_HTOLE16
2114# if U16SIZE == 2
2115HTOLE(Perl_my_htole16,U16)
2116# else
2117NOT_AVAIL(Perl_my_htole16,U16)
2118# endif
2119#endif
2120#ifdef PERL_NEED_MY_LETOH16
2121# if U16SIZE == 2
2122LETOH(Perl_my_letoh16,U16)
2123# else
2124NOT_AVAIL(Perl_my_letoh16,U16)
2125# endif
2126#endif
2127#ifdef PERL_NEED_MY_HTOBE16
2128# if U16SIZE == 2
2129HTOBE(Perl_my_htobe16,U16)
2130# else
2131NOT_AVAIL(Perl_my_htobe16,U16)
2132# endif
2133#endif
2134#ifdef PERL_NEED_MY_BETOH16
2135# if U16SIZE == 2
2136BETOH(Perl_my_betoh16,U16)
2137# else
2138NOT_AVAIL(Perl_my_betoh16,U16)
2139# endif
2140#endif
2141
2142#ifdef PERL_NEED_MY_HTOLE32
2143# if U32SIZE == 4
2144HTOLE(Perl_my_htole32,U32)
2145# else
2146NOT_AVAIL(Perl_my_htole32,U32)
2147# endif
2148#endif
2149#ifdef PERL_NEED_MY_LETOH32
2150# if U32SIZE == 4
2151LETOH(Perl_my_letoh32,U32)
2152# else
2153NOT_AVAIL(Perl_my_letoh32,U32)
2154# endif
2155#endif
2156#ifdef PERL_NEED_MY_HTOBE32
2157# if U32SIZE == 4
2158HTOBE(Perl_my_htobe32,U32)
2159# else
2160NOT_AVAIL(Perl_my_htobe32,U32)
2161# endif
2162#endif
2163#ifdef PERL_NEED_MY_BETOH32
2164# if U32SIZE == 4
2165BETOH(Perl_my_betoh32,U32)
2166# else
2167NOT_AVAIL(Perl_my_betoh32,U32)
2168# endif
2169#endif
2170
2171#ifdef PERL_NEED_MY_HTOLE64
2172# if U64SIZE == 8
2173HTOLE(Perl_my_htole64,U64)
2174# else
2175NOT_AVAIL(Perl_my_htole64,U64)
2176# endif
2177#endif
2178#ifdef PERL_NEED_MY_LETOH64
2179# if U64SIZE == 8
2180LETOH(Perl_my_letoh64,U64)
2181# else
2182NOT_AVAIL(Perl_my_letoh64,U64)
2183# endif
2184#endif
2185#ifdef PERL_NEED_MY_HTOBE64
2186# if U64SIZE == 8
2187HTOBE(Perl_my_htobe64,U64)
2188# else
2189NOT_AVAIL(Perl_my_htobe64,U64)
2190# endif
2191#endif
2192#ifdef PERL_NEED_MY_BETOH64
2193# if U64SIZE == 8
2194BETOH(Perl_my_betoh64,U64)
2195# else
2196NOT_AVAIL(Perl_my_betoh64,U64)
2197# endif
988174c1 2198#endif
a687059c 2199
1109a392
MHM		 2200#ifdef PERL_NEED_MY_HTOLES
2201HTOLE(Perl_my_htoles,short)
2202#endif
2203#ifdef PERL_NEED_MY_LETOHS
2204LETOH(Perl_my_letohs,short)
2205#endif
2206#ifdef PERL_NEED_MY_HTOBES
2207HTOBE(Perl_my_htobes,short)
2208#endif
2209#ifdef PERL_NEED_MY_BETOHS
2210BETOH(Perl_my_betohs,short)
2211#endif
2212
2213#ifdef PERL_NEED_MY_HTOLEI
2214HTOLE(Perl_my_htolei,int)
2215#endif
2216#ifdef PERL_NEED_MY_LETOHI
2217LETOH(Perl_my_letohi,int)
2218#endif
2219#ifdef PERL_NEED_MY_HTOBEI
2220HTOBE(Perl_my_htobei,int)
2221#endif
2222#ifdef PERL_NEED_MY_BETOHI
2223BETOH(Perl_my_betohi,int)
2224#endif
2225
2226#ifdef PERL_NEED_MY_HTOLEL
2227HTOLE(Perl_my_htolel,long)
2228#endif
2229#ifdef PERL_NEED_MY_LETOHL
2230LETOH(Perl_my_letohl,long)
2231#endif
2232#ifdef PERL_NEED_MY_HTOBEL
2233HTOBE(Perl_my_htobel,long)
2234#endif
2235#ifdef PERL_NEED_MY_BETOHL
2236BETOH(Perl_my_betohl,long)
2237#endif
2238
2239void
2240Perl_my_swabn(void *ptr, int n)
2241{
2242 register char *s = (char *)ptr;
2243 register char *e = s + (n-1);
2244 register char tc;
2245
7918f24d
NC		 2246 PERL_ARGS_ASSERT_MY_SWABN;
2247
1109a392
MHM		 2248 for (n /= 2; n > 0; s++, e--, n--) {
2249 tc = *s;
2250 *s = *e;
2251 *e = tc;
2252 }
2253}
2254
4a7d1889 2255PerlIO *
c9289b7b 2256Perl_my_popen_list(pTHX_ const char *mode, int n, SV **args)
4a7d1889 2257{
e37778c2 2258#if (!defined(DOSISH) || defined(HAS_FORK) || defined(AMIGAOS)) && !defined(OS2) && !defined(VMS) && !defined(__OPEN_VM) && !defined(EPOC) && !defined(NETWARE) && !defined(__LIBCATAMOUNT__)
97aff369 2259 dVAR;
1f852d0d
NIS		 2260 int p[2];
2261 register I32 This, that;
2262 register Pid_t pid;
2263 SV *sv;
2264 I32 did_pipes = 0;
2265 int pp[2];
2266
7918f24d
NC		 2267 PERL_ARGS_ASSERT_MY_POPEN_LIST;
2268
1f852d0d
NIS		 2269 PERL_FLUSHALL_FOR_CHILD;
2270 This = (*mode == 'w');
2271 that = !This;
2272 if (PL_tainting) {
2273 taint_env();
2274 taint_proper("Insecure %s%s", "EXEC");
2275 }
2276 if (PerlProc_pipe(p) < 0)
4608196e 2277 return NULL;
1f852d0d
NIS		 2278 /* Try for another pipe pair for error return */
2279 if (PerlProc_pipe(pp) >= 0)
2280 did_pipes = 1;
52e18b1f 2281 while ((pid = PerlProc_fork()) < 0) {
1f852d0d
NIS		 2282 if (errno != EAGAIN) {
2283 PerlLIO_close(p[This]);
4e6dfe71 2284 PerlLIO_close(p[that]);
1f852d0d
NIS		 2285 if (did_pipes) {
2286 PerlLIO_close(pp[0]);
2287 PerlLIO_close(pp[1]);
2288 }
4608196e 2289 return NULL;
1f852d0d 2290 }
b3647a36
SR		 2291 if (ckWARN(WARN_PIPE))
2292 Perl_warner(aTHX_ packWARN(WARN_PIPE), "Can't fork, trying again in 5 seconds");
1f852d0d
NIS		 2293 sleep(5);
2294 }
2295 if (pid == 0) {
2296 /* Child */
1f852d0d
NIS		 2297#undef THIS
2298#undef THAT
2299#define THIS that
2300#define THAT This
1f852d0d
NIS		 2301 /* Close parent's end of error status pipe (if any) */
2302 if (did_pipes) {
2303 PerlLIO_close(pp[0]);
2304#if defined(HAS_FCNTL) && defined(F_SETFD)
2305 /* Close error pipe automatically if exec works */
2306 fcntl(pp[1], F_SETFD, FD_CLOEXEC);
2307#endif
2308 }
2309 /* Now dup our end of _the_ pipe to right position */
2310 if (p[THIS] != (*mode == 'r')) {
2311 PerlLIO_dup2(p[THIS], *mode == 'r');
2312 PerlLIO_close(p[THIS]);
4e6dfe71
GS		 2313 if (p[THAT] != (*mode == 'r')) /* if dup2() didn't close it */
2314 PerlLIO_close(p[THAT]); /* close parent's end of _the_ pipe */
1f852d0d 2315 }
4e6dfe71
GS		 2316 else
2317 PerlLIO_close(p[THAT]); /* close parent's end of _the_ pipe */
1f852d0d
NIS		 2318#if !defined(HAS_FCNTL) || !defined(F_SETFD)
2319 /* No automatic close - do it by hand */
b7953727
JH		 2320# ifndef NOFILE
2321# define NOFILE 20
2322# endif
a080fe3d
NIS		 2323 {
2324 int fd;
2325
2326 for (fd = PL_maxsysfd + 1; fd < NOFILE; fd++) {
3aed30dc 2327 if (fd != pp[1])
a080fe3d
NIS		 2328 PerlLIO_close(fd);
2329 }
1f852d0d
NIS		 2330 }
2331#endif
a0714e2c 2332 do_aexec5(NULL, args-1, args-1+n, pp[1], did_pipes);
1f852d0d
NIS		 2333 PerlProc__exit(1);
2334#undef THIS
2335#undef THAT
2336 }
2337 /* Parent */
52e18b1f 2338 do_execfree(); /* free any memory malloced by child on fork */
1f852d0d
NIS		 2339 if (did_pipes)
2340 PerlLIO_close(pp[1]);
2341 /* Keep the lower of the two fd numbers */
2342 if (p[that] < p[This]) {
2343 PerlLIO_dup2(p[This], p[that]);
2344 PerlLIO_close(p[This]);
2345 p[This] = p[that];
2346 }
4e6dfe71
GS		 2347 else
2348 PerlLIO_close(p[that]); /* close child's end of pipe */
2349
1f852d0d 2350 sv = *av_fetch(PL_fdpid,p[This],TRUE);
862a34c6 2351 SvUPGRADE(sv,SVt_IV);
45977657 2352 SvIV_set(sv, pid);
1f852d0d
NIS		 2353 PL_forkprocess = pid;
2354 /* If we managed to get status pipe check for exec fail */
2355 if (did_pipes && pid > 0) {
2356 int errkid;
bb7a0f54
MHM		 2357 unsigned n = 0;
2358 SSize_t n1;
1f852d0d
NIS		 2359
2360 while (n < sizeof(int)) {
2361 n1 = PerlLIO_read(pp[0],
2362 (void*)(((char*)&errkid)+n),
2363 (sizeof(int)) - n);
2364 if (n1 <= 0)
2365 break;
2366 n += n1;
2367 }
2368 PerlLIO_close(pp[0]);
2369 did_pipes = 0;
2370 if (n) { /* Error */
2371 int pid2, status;
8c51524e 2372 PerlLIO_close(p[This]);
1f852d0d
NIS		 2373 if (n != sizeof(int))
2374 Perl_croak(aTHX_ "panic: kid popen errno read");
2375 do {
2376 pid2 = wait4pid(pid, &status, 0);
2377 } while (pid2 == -1 && errno == EINTR);
2378 errno = errkid; /* Propagate errno from kid */
4608196e 2379 return NULL;
1f852d0d
NIS		 2380 }
2381 }
2382 if (did_pipes)
2383 PerlLIO_close(pp[0]);
2384 return PerlIO_fdopen(p[This], mode);
2385#else
9d419b5f 2386# ifdef OS2 /* Same, without fork()ing and all extra overhead... */
4e205ed6 2387 return my_syspopen4(aTHX_ NULL, mode, n, args);
9d419b5f 2388# else
4a7d1889
NIS		 2389 Perl_croak(aTHX_ "List form of piped open not implemented");
2390 return (PerlIO *) NULL;
9d419b5f 2391# endif
1f852d0d 2392#endif
4a7d1889
NIS		 2393}
2394
5f05dabc 2395 /* VMS' my_popen() is in VMS.c, same with OS/2. */
e37778c2 2396#if (!defined(DOSISH) || defined(HAS_FORK) || defined(AMIGAOS)) && !defined(VMS) && !defined(__OPEN_VM) && !defined(EPOC) && !defined(__LIBCATAMOUNT__)
760ac839 2397PerlIO *
3dd43144 2398Perl_my_popen(pTHX_ const char *cmd, const char *mode)
a687059c 2399{
97aff369 2400 dVAR;
a687059c 2401 int p[2];
8ac85365 2402 register I32 This, that;
d8a83dd3 2403 register Pid_t pid;
79072805 2404 SV *sv;
bfce84ec 2405 const I32 doexec = !(*cmd == '-' && cmd[1] == '\0');
e446cec8
IZ		 2406 I32 did_pipes = 0;
2407 int pp[2];
a687059c 2408
7918f24d
NC		 2409 PERL_ARGS_ASSERT_MY_POPEN;
2410
45bc9206 2411 PERL_FLUSHALL_FOR_CHILD;
ddcf38b7
IZ		 2412#ifdef OS2
2413 if (doexec) {
23da6c43 2414 return my_syspopen(aTHX_ cmd,mode);
ddcf38b7 2415 }
a1d180c4 2416#endif
8ac85365
NIS		 2417 This = (*mode == 'w');
2418 that = !This;
3280af22 2419 if (doexec && PL_tainting) {
bbce6d69 2420 taint_env();
2421 taint_proper("Insecure %s%s", "EXEC");
d48672a2 2422 }
c2267164 2423 if (PerlProc_pipe(p) < 0)
4608196e 2424 return NULL;
e446cec8
IZ		 2425 if (doexec && PerlProc_pipe(pp) >= 0)
2426 did_pipes = 1;
52e18b1f 2427 while ((pid = PerlProc_fork()) < 0) {
a687059c 2428 if (errno != EAGAIN) {
6ad3d225 2429 PerlLIO_close(p[This]);
b5ac89c3 2430 PerlLIO_close(p[that]);
e446cec8
IZ		 2431 if (did_pipes) {
2432 PerlLIO_close(pp[0]);
2433 PerlLIO_close(pp[1]);
2434 }
a687059c 2435 if (!doexec)
b3647a36 2436 Perl_croak(aTHX_ "Can't fork: %s", Strerror(errno));
4608196e 2437 return NULL;
a687059c 2438 }
b3647a36
SR		 2439 if (ckWARN(WARN_PIPE))
2440 Perl_warner(aTHX_ packWARN(WARN_PIPE), "Can't fork, trying again in 5 seconds");
a687059c
LW		 2441 sleep(5);
2442 }
2443 if (pid == 0) {
79072805
LW		 2444 GV* tmpgv;
2445
30ac6d9b
GS		 2446#undef THIS
2447#undef THAT
a687059c 2448#define THIS that
8ac85365 2449#define THAT This
e446cec8
IZ		 2450 if (did_pipes) {
2451 PerlLIO_close(pp[0]);
2452#if defined(HAS_FCNTL) && defined(F_SETFD)
2453 fcntl(pp[1], F_SETFD, FD_CLOEXEC);
2454#endif
2455 }
a687059c 2456 if (p[THIS] != (*mode == 'r')) {
6ad3d225
GS		 2457 PerlLIO_dup2(p[THIS], *mode == 'r');
2458 PerlLIO_close(p[THIS]);
b5ac89c3
NIS		 2459 if (p[THAT] != (*mode == 'r')) /* if dup2() didn't close it */
2460 PerlLIO_close(p[THAT]);
a687059c 2461 }
b5ac89c3
NIS		 2462 else
2463 PerlLIO_close(p[THAT]);
4435c477 2464#ifndef OS2
a687059c 2465 if (doexec) {
a0d0e21e 2466#if !defined(HAS_FCNTL) || !defined(F_SETFD)
ae986130
LW		 2467#ifndef NOFILE
2468#define NOFILE 20
2469#endif
a080fe3d 2470 {
3aed30dc 2471 int fd;
a080fe3d
NIS		 2472
2473 for (fd = PL_maxsysfd + 1; fd < NOFILE; fd++)
2474 if (fd != pp[1])
3aed30dc 2475 PerlLIO_close(fd);
a080fe3d 2476 }
ae986130 2477#endif
a080fe3d
NIS		 2478 /* may or may not use the shell */
2479 do_exec3(cmd, pp[1], did_pipes);
6ad3d225 2480 PerlProc__exit(1);
a687059c 2481 }
4435c477 2482#endif /* defined OS2 */
713cef20
IZ		 2483
2484#ifdef PERLIO_USING_CRLF
2485 /* Since we circumvent IO layers when we manipulate low-level
2486 filedescriptors directly, need to manually switch to the
2487 default, binary, low-level mode; see PerlIOBuf_open(). */
2488 PerlLIO_setmode((*mode == 'r'), O_BINARY);
2489#endif
2490
fafc274c 2491 if ((tmpgv = gv_fetchpvs("$", GV_ADD|GV_NOTQUAL, SVt_PV))) {
4d76a344 2492 SvREADONLY_off(GvSV(tmpgv));
7766f137 2493 sv_setiv(GvSV(tmpgv), PerlProc_getpid());
4d76a344
RGS		 2494 SvREADONLY_on(GvSV(tmpgv));
2495 }
2496#ifdef THREADS_HAVE_PIDS
2497 PL_ppid = (IV)getppid();
2498#endif
3280af22 2499 PL_forkprocess = 0;
ca0c25f6 2500#ifdef PERL_USES_PL_PIDSTATUS
3280af22 2501 hv_clear(PL_pidstatus); /* we have no children */
ca0c25f6 2502#endif
4608196e 2503 return NULL;
a687059c
LW		 2504#undef THIS
2505#undef THAT
2506 }
b5ac89c3 2507 do_execfree(); /* free any memory malloced by child on vfork */
e446cec8
IZ		 2508 if (did_pipes)
2509 PerlLIO_close(pp[1]);
8ac85365 2510 if (p[that] < p[This]) {
6ad3d225
GS		 2511 PerlLIO_dup2(p[This], p[that]);
2512 PerlLIO_close(p[This]);
8ac85365 2513 p[This] = p[that];
62b28dd9 2514 }
b5ac89c3
NIS		 2515 else
2516 PerlLIO_close(p[that]);
2517
3280af22 2518 sv = *av_fetch(PL_fdpid,p[This],TRUE);
862a34c6 2519 SvUPGRADE(sv,SVt_IV);
45977657 2520 SvIV_set(sv, pid);
3280af22 2521 PL_forkprocess = pid;
e446cec8
IZ		 2522 if (did_pipes && pid > 0) {
2523 int errkid;
bb7a0f54
MHM		 2524 unsigned n = 0;
2525 SSize_t n1;
e446cec8
IZ		 2526
2527 while (n < sizeof(int)) {
2528 n1 = PerlLIO_read(pp[0],
2529 (void*)(((char*)&errkid)+n),
2530 (sizeof(int)) - n);
2531 if (n1 <= 0)
2532 break;
2533 n += n1;
2534 }
2f96c702
IZ		 2535 PerlLIO_close(pp[0]);
2536 did_pipes = 0;
e446cec8 2537 if (n) { /* Error */
faa466a7 2538 int pid2, status;
8c51524e 2539 PerlLIO_close(p[This]);
e446cec8 2540 if (n != sizeof(int))
cea2e8a9 2541 Perl_croak(aTHX_ "panic: kid popen errno read");
faa466a7
RG		 2542 do {
2543 pid2 = wait4pid(pid, &status, 0);
2544 } while (pid2 == -1 && errno == EINTR);
e446cec8 2545 errno = errkid; /* Propagate errno from kid */
4608196e 2546 return NULL;
e446cec8
IZ		 2547 }
2548 }
2549 if (did_pipes)
2550 PerlLIO_close(pp[0]);
8ac85365 2551 return PerlIO_fdopen(p[This], mode);
a687059c 2552}
7c0587c8 2553#else
85ca448a 2554#if defined(atarist) || defined(EPOC)
7c0587c8 2555FILE *popen();
760ac839 2556PerlIO *
cef6ea9d 2557Perl_my_popen(pTHX_ const char *cmd, const char *mode)
7c0587c8 2558{
7918f24d 2559 PERL_ARGS_ASSERT_MY_POPEN;
45bc9206 2560 PERL_FLUSHALL_FOR_CHILD;
a1d180c4
NIS		 2561 /* Call system's popen() to get a FILE *, then import it.
2562 used 0 for 2nd parameter to PerlIO_importFILE;
2563 apparently not used
2564 */
2565 return PerlIO_importFILE(popen(cmd, mode), 0);
7c0587c8 2566}
2b96b0a5
JH		 2567#else
2568#if defined(DJGPP)
2569FILE *djgpp_popen();
2570PerlIO *
cef6ea9d 2571Perl_my_popen(pTHX_ const char *cmd, const char *mode)
2b96b0a5
JH		 2572{
2573 PERL_FLUSHALL_FOR_CHILD;
2574 /* Call system's popen() to get a FILE *, then import it.
2575 used 0 for 2nd parameter to PerlIO_importFILE;
2576 apparently not used
2577 */
2578 return PerlIO_importFILE(djgpp_popen(cmd, mode), 0);
2579}
9c12f1e5
RGS		 2580#else
2581#if defined(__LIBCATAMOUNT__)
2582PerlIO *
2583Perl_my_popen(pTHX_ const char *cmd, const char *mode)
2584{
2585 return NULL;
2586}
2587#endif
2b96b0a5 2588#endif
7c0587c8
LW		 2589#endif
2590
2591#endif /* !DOSISH */
a687059c 2592
52e18b1f
GS		 2593/* this is called in parent before the fork() */
2594void
2595Perl_atfork_lock(void)
2596{
27da23d5 2597 dVAR;
3db8f154 2598#if defined(USE_ITHREADS)
52e18b1f
GS		 2599 /* locks must be held in locking order (if any) */
2600# ifdef MYMALLOC
2601 MUTEX_LOCK(&PL_malloc_mutex);
2602# endif
2603 OP_REFCNT_LOCK;
2604#endif
2605}
2606
2607/* this is called in both parent and child after the fork() */
2608void
2609Perl_atfork_unlock(void)
2610{
27da23d5 2611 dVAR;
3db8f154 2612#if defined(USE_ITHREADS)
52e18b1f
GS		 2613 /* locks must be released in same order as in atfork_lock() */
2614# ifdef MYMALLOC
2615 MUTEX_UNLOCK(&PL_malloc_mutex);
2616# endif
2617 OP_REFCNT_UNLOCK;
2618#endif
2619}
2620
2621Pid_t
2622Perl_my_fork(void)
2623{
2624#if defined(HAS_FORK)
2625 Pid_t pid;
3db8f154 2626#if defined(USE_ITHREADS) && !defined(HAS_PTHREAD_ATFORK)
52e18b1f
GS		 2627 atfork_lock();
2628 pid = fork();
2629 atfork_unlock();
2630#else
2631 /* atfork_lock() and atfork_unlock() are installed as pthread_atfork()
2632 * handlers elsewhere in the code */
2633 pid = fork();
2634#endif
2635 return pid;
2636#else
2637 /* this "canna happen" since nothing should be calling here if !HAS_FORK */
2638 Perl_croak_nocontext("fork() not available");
b961a566 2639 return 0;
52e18b1f
GS		 2640#endif /* HAS_FORK */
2641}
2642
748a9306 2643#ifdef DUMP_FDS
35ff7856 2644void
c9289b7b 2645Perl_dump_fds(pTHX_ const char *const s)
ae986130
LW		 2646{
2647 int fd;
c623ac67 2648 Stat_t tmpstatbuf;
ae986130 2649
7918f24d
NC		 2650 PERL_ARGS_ASSERT_DUMP_FDS;
2651
bf49b057 2652 PerlIO_printf(Perl_debug_log,"%s", s);
ae986130 2653 for (fd = 0; fd < 32; fd++) {
6ad3d225 2654 if (PerlLIO_fstat(fd,&tmpstatbuf) >= 0)
bf49b057 2655 PerlIO_printf(Perl_debug_log," %d",fd);
ae986130 2656 }
bf49b057 2657 PerlIO_printf(Perl_debug_log,"\n");
27da23d5 2658 return;
ae986130 2659}
35ff7856 2660#endif /* DUMP_FDS */
ae986130 2661
fe14fcc3 2662#ifndef HAS_DUP2
fec02dd3 2663int
ba106d47 2664dup2(int oldfd, int newfd)
a687059c 2665{
a0d0e21e 2666#if defined(HAS_FCNTL) && defined(F_DUPFD)
fec02dd3
AD		 2667 if (oldfd == newfd)
2668 return oldfd;
6ad3d225 2669 PerlLIO_close(newfd);
fec02dd3 2670 return fcntl(oldfd, F_DUPFD, newfd);
62b28dd9 2671#else
fc36a67e 2672#define DUP2_MAX_FDS 256
2673 int fdtmp[DUP2_MAX_FDS];
79072805 2674 I32 fdx = 0;
ae986130
LW		 2675 int fd;
2676
fe14fcc3 2677 if (oldfd == newfd)
fec02dd3 2678 return oldfd;
6ad3d225 2679 PerlLIO_close(newfd);
fc36a67e 2680 /* good enough for low fd's... */
6ad3d225 2681 while ((fd = PerlLIO_dup(oldfd)) != newfd && fd >= 0) {
fc36a67e 2682 if (fdx >= DUP2_MAX_FDS) {
6ad3d225 2683 PerlLIO_close(fd);
fc36a67e 2684 fd = -1;
2685 break;
2686 }
ae986130 2687 fdtmp[fdx++] = fd;
fc36a67e 2688 }
ae986130 2689 while (fdx > 0)
6ad3d225 2690 PerlLIO_close(fdtmp[--fdx]);
fec02dd3 2691 return fd;
62b28dd9 2692#endif
a687059c
LW		 2693}
2694#endif
2695
64ca3a65 2696#ifndef PERL_MICRO
ff68c719 2697#ifdef HAS_SIGACTION
2698
2699Sighandler_t
864dbfa3 2700Perl_rsignal(pTHX_ int signo, Sighandler_t handler)
ff68c719 2701{
27da23d5 2702 dVAR;
ff68c719 2703 struct sigaction act, oact;
2704
a10b1e10
JH		 2705#ifdef USE_ITHREADS
2706 /* only "parent" interpreter can diddle signals */
2707 if (PL_curinterp != aTHX)
8aad04aa 2708 return (Sighandler_t) SIG_ERR;
a10b1e10
JH		 2709#endif
2710
8aad04aa 2711 act.sa_handler = (void(*)(int))handler;
ff68c719 2712 sigemptyset(&act.sa_mask);
2713 act.sa_flags = 0;
2714#ifdef SA_RESTART
4ffa73a3
JH		 2715 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
2716 act.sa_flags |= SA_RESTART; /* SVR4, 4.3+BSD */
0a8e0eff 2717#endif
358837b8 2718#if defined(SA_NOCLDWAIT) && !defined(BSDish) /* See [perl #18849] */
8aad04aa 2719 if (signo == SIGCHLD && handler == (Sighandler_t) SIG_IGN)
85264bed
CS		 2720 act.sa_flags |= SA_NOCLDWAIT;
2721#endif
ff68c719 2722 if (sigaction(signo, &act, &oact) == -1)
8aad04aa 2723 return (Sighandler_t) SIG_ERR;
ff68c719 2724 else
8aad04aa 2725 return (Sighandler_t) oact.sa_handler;
ff68c719 2726}
2727
2728Sighandler_t
864dbfa3 2729Perl_rsignal_state(pTHX_ int signo)
ff68c719 2730{
2731 struct sigaction oact;
96a5add6 2732 PERL_UNUSED_CONTEXT;
ff68c719 2733
2734 if (sigaction(signo, (struct sigaction *)NULL, &oact) == -1)
8aad04aa 2735 return (Sighandler_t) SIG_ERR;
ff68c719 2736 else
8aad04aa 2737 return (Sighandler_t) oact.sa_handler;
ff68c719 2738}
2739
2740int
864dbfa3 2741Perl_rsignal_save(pTHX_ int signo, Sighandler_t handler, Sigsave_t *save)
ff68c719 2742{
27da23d5 2743 dVAR;
ff68c719 2744 struct sigaction act;
2745
7918f24d
NC		 2746 PERL_ARGS_ASSERT_RSIGNAL_SAVE;
2747
a10b1e10
JH		 2748#ifdef USE_ITHREADS
2749 /* only "parent" interpreter can diddle signals */
2750 if (PL_curinterp != aTHX)
2751 return -1;
2752#endif
2753
8aad04aa 2754 act.sa_handler = (void(*)(int))handler;
ff68c719 2755 sigemptyset(&act.sa_mask);
2756 act.sa_flags = 0;
2757#ifdef SA_RESTART
4ffa73a3
JH		 2758 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
2759 act.sa_flags |= SA_RESTART; /* SVR4, 4.3+BSD */
0a8e0eff 2760#endif
36b5d377 2761#if defined(SA_NOCLDWAIT) && !defined(BSDish) /* See [perl #18849] */
8aad04aa 2762 if (signo == SIGCHLD && handler == (Sighandler_t) SIG_IGN)
85264bed
CS		 2763 act.sa_flags |= SA_NOCLDWAIT;
2764#endif
ff68c719 2765 return sigaction(signo, &act, save);
2766}
2767
2768int
864dbfa3 2769Perl_rsignal_restore(pTHX_ int signo, Sigsave_t *save)
ff68c719 2770{
27da23d5 2771 dVAR;
a10b1e10
JH		 2772#ifdef USE_ITHREADS
2773 /* only "parent" interpreter can diddle signals */
2774 if (PL_curinterp != aTHX)
2775 return -1;
2776#endif
2777
ff68c719 2778 return sigaction(signo, save, (struct sigaction *)NULL);
2779}
2780
2781#else /* !HAS_SIGACTION */
2782
2783Sighandler_t
864dbfa3 2784Perl_rsignal(pTHX_ int signo, Sighandler_t handler)
ff68c719 2785{
39f1703b 2786#if defined(USE_ITHREADS) && !defined(WIN32)
a10b1e10
JH		 2787 /* only "parent" interpreter can diddle signals */
2788 if (PL_curinterp != aTHX)
8aad04aa 2789 return (Sighandler_t) SIG_ERR;
a10b1e10
JH		 2790#endif
2791
6ad3d225 2792 return PerlProc_signal(signo, handler);
ff68c719 2793}
2794
fabdb6c0 2795static Signal_t
4e35701f 2796sig_trap(int signo)
ff68c719 2797{
27da23d5
JH		 2798 dVAR;
2799 PL_sig_trapped++;
ff68c719 2800}
2801
2802Sighandler_t
864dbfa3 2803Perl_rsignal_state(pTHX_ int signo)
ff68c719 2804{
27da23d5 2805 dVAR;
ff68c719 2806 Sighandler_t oldsig;
2807
39f1703b 2808#if defined(USE_ITHREADS) && !defined(WIN32)
a10b1e10
JH		 2809 /* only "parent" interpreter can diddle signals */
2810 if (PL_curinterp != aTHX)
8aad04aa 2811 return (Sighandler_t) SIG_ERR;
a10b1e10
JH		 2812#endif
2813
27da23d5 2814 PL_sig_trapped = 0;
6ad3d225
GS		 2815 oldsig = PerlProc_signal(signo, sig_trap);
2816 PerlProc_signal(signo, oldsig);
27da23d5 2817 if (PL_sig_trapped)
3aed30dc 2818 PerlProc_kill(PerlProc_getpid(), signo);
ff68c719 2819 return oldsig;
2820}
2821
2822int
864dbfa3 2823Perl_rsignal_save(pTHX_ int signo, Sighandler_t handler, Sigsave_t *save)
ff68c719 2824{
39f1703b 2825#if defined(USE_ITHREADS) && !defined(WIN32)
a10b1e10
JH		 2826 /* only "parent" interpreter can diddle signals */
2827 if (PL_curinterp != aTHX)
2828 return -1;
2829#endif
6ad3d225 2830 *save = PerlProc_signal(signo, handler);
8aad04aa 2831 return (*save == (Sighandler_t) SIG_ERR) ? -1 : 0;
ff68c719 2832}
2833
2834int
864dbfa3 2835Perl_rsignal_restore(pTHX_ int signo, Sigsave_t *save)
ff68c719 2836{
39f1703b 2837#if defined(USE_ITHREADS) && !defined(WIN32)
a10b1e10
JH		 2838 /* only "parent" interpreter can diddle signals */
2839 if (PL_curinterp != aTHX)
2840 return -1;
2841#endif
8aad04aa 2842 return (PerlProc_signal(signo, *save) == (Sighandler_t) SIG_ERR) ? -1 : 0;
ff68c719 2843}
2844
2845#endif /* !HAS_SIGACTION */
64ca3a65 2846#endif /* !PERL_MICRO */
ff68c719 2847
5f05dabc 2848 /* VMS' my_pclose() is in VMS.c; same with OS/2 */
e37778c2 2849#if (!defined(DOSISH) || defined(HAS_FORK) || defined(AMIGAOS)) && !defined(VMS) && !defined(__OPEN_VM) && !defined(EPOC) && !defined(__LIBCATAMOUNT__)
79072805 2850I32
864dbfa3 2851Perl_my_pclose(pTHX_ PerlIO *ptr)
a687059c 2852{
97aff369 2853 dVAR;
ff68c719 2854 Sigsave_t hstat, istat, qstat;
a687059c 2855 int status;
a0d0e21e 2856 SV **svp;
d8a83dd3
JH		 2857 Pid_t pid;
2858 Pid_t pid2;
03136e13 2859 bool close_failed;
4ee39169 2860 dSAVEDERRNO;
a687059c 2861
3280af22 2862 svp = av_fetch(PL_fdpid,PerlIO_fileno(ptr),TRUE);
25d92023 2863 pid = (SvTYPE(*svp) == SVt_IV) ? SvIVX(*svp) : -1;
a0d0e21e 2864 SvREFCNT_dec(*svp);
3280af22 2865 *svp = &PL_sv_undef;
ddcf38b7
IZ		 2866#ifdef OS2
2867 if (pid == -1) { /* Opened by popen. */
2868 return my_syspclose(ptr);
2869 }
a1d180c4 2870#endif
f1618b10
CS		 2871 close_failed = (PerlIO_close(ptr) == EOF);
2872 SAVE_ERRNO;
7c0587c8 2873#ifdef UTS
6ad3d225 2874 if(PerlProc_kill(pid, 0) < 0) { return(pid); } /* HOM 12/23/91 */
7c0587c8 2875#endif
64ca3a65 2876#ifndef PERL_MICRO
8aad04aa
JH		 2877 rsignal_save(SIGHUP, (Sighandler_t) SIG_IGN, &hstat);
2878 rsignal_save(SIGINT, (Sighandler_t) SIG_IGN, &istat);
2879 rsignal_save(SIGQUIT, (Sighandler_t) SIG_IGN, &qstat);
64ca3a65 2880#endif
748a9306 2881 do {
1d3434b8
GS		 2882 pid2 = wait4pid(pid, &status, 0);
2883 } while (pid2 == -1 && errno == EINTR);
64ca3a65 2884#ifndef PERL_MICRO
ff68c719 2885 rsignal_restore(SIGHUP, &hstat);
2886 rsignal_restore(SIGINT, &istat);
2887 rsignal_restore(SIGQUIT, &qstat);
64ca3a65 2888#endif
03136e13 2889 if (close_failed) {
4ee39169 2890 RESTORE_ERRNO;
03136e13
CS		 2891 return -1;
2892 }
1d3434b8 2893 return(pid2 < 0 ? pid2 : status == 0 ? 0 : (errno = 0, status));
20188a90 2894}
9c12f1e5
RGS		 2895#else
2896#if defined(__LIBCATAMOUNT__)
2897I32
2898Perl_my_pclose(pTHX_ PerlIO *ptr)
2899{
2900 return -1;
2901}
2902#endif
4633a7c4
LW		 2903#endif /* !DOSISH */
2904
e37778c2 2905#if (!defined(DOSISH) || defined(OS2) || defined(WIN32) || defined(NETWARE)) && !defined(__LIBCATAMOUNT__)
79072805 2906I32
d8a83dd3 2907Perl_wait4pid(pTHX_ Pid_t pid, int *statusp, int flags)
20188a90 2908{
97aff369 2909 dVAR;
27da23d5 2910 I32 result = 0;
7918f24d 2911 PERL_ARGS_ASSERT_WAIT4PID;
b7953727
JH		 2912 if (!pid)
2913 return -1;
ca0c25f6 2914#ifdef PERL_USES_PL_PIDSTATUS
b7953727 2915 {
3aed30dc 2916 if (pid > 0) {
12072db5
NC		 2917 /* The keys in PL_pidstatus are now the raw 4 (or 8) bytes of the
2918 pid, rather than a string form. */
c4420975 2919 SV * const * const svp = hv_fetch(PL_pidstatus,(const char*) &pid,sizeof(Pid_t),FALSE);
3aed30dc
HS		 2920 if (svp && *svp != &PL_sv_undef) {
2921 *statusp = SvIVX(*svp);
12072db5
NC		 2922 (void)hv_delete(PL_pidstatus,(const char*) &pid,sizeof(Pid_t),
2923 G_DISCARD);
3aed30dc
HS		 2924 return pid;
2925 }
2926 }
2927 else {
2928 HE *entry;
2929
2930 hv_iterinit(PL_pidstatus);
2931 if ((entry = hv_iternext(PL_pidstatus))) {
c4420975 2932 SV * const sv = hv_iterval(PL_pidstatus,entry);
7ea75b61 2933 I32 len;
0bcc34c2 2934 const char * const spid = hv_iterkey(entry,&len);
27da23d5 2935
12072db5
NC		 2936 assert (len == sizeof(Pid_t));
2937 memcpy((char *)&pid, spid, len);
3aed30dc 2938 *statusp = SvIVX(sv);
7b9a3241
NC		 2939 /* The hash iterator is currently on this entry, so simply
2940 calling hv_delete would trigger the lazy delete, which on
2941 aggregate does more work, beacuse next call to hv_iterinit()
2942 would spot the flag, and have to call the delete routine,
2943 while in the meantime any new entries can't re-use that
2944 memory. */
2945 hv_iterinit(PL_pidstatus);
7ea75b61 2946 (void)hv_delete(PL_pidstatus,spid,len,G_DISCARD);
3aed30dc
HS		 2947 return pid;
2948 }
20188a90
LW		 2949 }
2950 }
68a29c53 2951#endif
79072805 2952#ifdef HAS_WAITPID
367f3c24
IZ		 2953# ifdef HAS_WAITPID_RUNTIME
2954 if (!HAS_WAITPID_RUNTIME)
2955 goto hard_way;
2956# endif
cddd4526 2957 result = PerlProc_waitpid(pid,statusp,flags);
dfcfdb64 2958 goto finish;
367f3c24
IZ		 2959#endif
2960#if !defined(HAS_WAITPID) && defined(HAS_WAIT4)
4608196e 2961 result = wait4((pid==-1)?0:pid,statusp,flags,NULL);
dfcfdb64 2962 goto finish;
367f3c24 2963#endif
ca0c25f6 2964#ifdef PERL_USES_PL_PIDSTATUS
27da23d5 2965#if defined(HAS_WAITPID) && defined(HAS_WAITPID_RUNTIME)
367f3c24 2966 hard_way:
27da23d5 2967#endif
a0d0e21e 2968 {
a0d0e21e 2969 if (flags)
cea2e8a9 2970 Perl_croak(aTHX_ "Can't do waitpid with flags");
a0d0e21e 2971 else {
76e3520e 2972 while ((result = PerlProc_wait(statusp)) != pid && pid > 0 && result >= 0)
a0d0e21e
LW		 2973 pidgone(result,*statusp);
2974 if (result < 0)
2975 *statusp = -1;
2976 }
a687059c
LW		 2977 }
2978#endif
27da23d5 2979#if defined(HAS_WAITPID) || defined(HAS_WAIT4)
dfcfdb64 2980 finish:
27da23d5 2981#endif
cddd4526
NIS		 2982 if (result < 0 && errno == EINTR) {
2983 PERL_ASYNC_CHECK();
48dbb59e 2984 errno = EINTR; /* reset in case a signal handler changed $! */
cddd4526
NIS		 2985 }
2986 return result;
a687059c 2987}
2986a63f 2988#endif /* !DOSISH || OS2 || WIN32 || NETWARE */
a687059c 2989
ca0c25f6 2990#ifdef PERL_USES_PL_PIDSTATUS
7c0587c8 2991void
ed4173ef 2992S_pidgone(pTHX_ Pid_t pid, int status)
a687059c 2993{
79072805 2994 register SV *sv;
a687059c 2995
12072db5 2996 sv = *hv_fetch(PL_pidstatus,(const char*)&pid,sizeof(Pid_t),TRUE);
862a34c6 2997 SvUPGRADE(sv,SVt_IV);
45977657 2998 SvIV_set(sv, status);
20188a90 2999 return;
a687059c 3000}
ca0c25f6 3001#endif
a687059c 3002
85ca448a 3003#if defined(atarist) || defined(OS2) || defined(EPOC)
7c0587c8 3004int pclose();
ddcf38b7
IZ		 3005#ifdef HAS_FORK
3006int /* Cannot prototype with I32
3007 in os2ish.h. */
ba106d47 3008my_syspclose(PerlIO *ptr)
ddcf38b7 3009#else
79072805 3010I32
864dbfa3 3011Perl_my_pclose(pTHX_ PerlIO *ptr)
a1d180c4 3012#endif
a687059c 3013{
760ac839 3014 /* Needs work for PerlIO ! */
c4420975 3015 FILE * const f = PerlIO_findFILE(ptr);
7452cf6a 3016 const I32 result = pclose(f);
2b96b0a5
JH		 3017 PerlIO_releaseFILE(ptr,f);
3018 return result;
3019}
3020#endif
3021
933fea7f 3022#if defined(DJGPP)
2b96b0a5
JH		 3023int djgpp_pclose();
3024I32
3025Perl_my_pclose(pTHX_ PerlIO *ptr)
3026{
3027 /* Needs work for PerlIO ! */
c4420975 3028 FILE * const f = PerlIO_findFILE(ptr);
2b96b0a5 3029 I32 result = djgpp_pclose(f);
933fea7f 3030 result = (result << 8) & 0xff00;
760ac839
LW		 3031 PerlIO_releaseFILE(ptr,f);
3032 return result;
a687059c 3033}
7c0587c8 3034#endif
9f68db38
LW		 3035
3036void
864dbfa3 3037Perl_repeatcpy(pTHX_ register char *to, register const char *from, I32 len, register I32 count)
9f68db38 3038{
79072805 3039 register I32 todo;
c4420975 3040 register const char * const frombase = from;
96a5add6 3041 PERL_UNUSED_CONTEXT;
9f68db38 3042
7918f24d
NC		 3043 PERL_ARGS_ASSERT_REPEATCPY;
3044
9f68db38 3045 if (len == 1) {
08105a92 3046 register const char c = *from;
9f68db38 3047 while (count-- > 0)
5926133d 3048 *to++ = c;
9f68db38
LW		 3049 return;
3050 }
3051 while (count-- > 0) {
3052 for (todo = len; todo > 0; todo--) {
3053 *to++ = *from++;
3054 }
3055 from = frombase;
3056 }
3057}
0f85fab0 3058
fe14fcc3 3059#ifndef HAS_RENAME
79072805 3060I32
4373e329 3061Perl_same_dirent(pTHX_ const char *a, const char *b)
62b28dd9 3062{
93a17b20
LW		 3063 char *fa = strrchr(a,'/');
3064 char *fb = strrchr(b,'/');
c623ac67
GS		 3065 Stat_t tmpstatbuf1;
3066 Stat_t tmpstatbuf2;
c4420975 3067 SV * const tmpsv = sv_newmortal();
62b28dd9 3068
7918f24d
NC		 3069 PERL_ARGS_ASSERT_SAME_DIRENT;
3070
62b28dd9
LW		 3071 if (fa)
3072 fa++;
3073 else
3074 fa = a;
3075 if (fb)
3076 fb++;
3077 else
3078 fb = b;
3079 if (strNE(a,b))
3080 return FALSE;
3081 if (fa == a)
76f68e9b 3082 sv_setpvs(tmpsv, ".");
62b28dd9 3083 else
46fc3d4c 3084 sv_setpvn(tmpsv, a, fa - a);
95a20fc0 3085 if (PerlLIO_stat(SvPVX_const(tmpsv), &tmpstatbuf1) < 0)
62b28dd9
LW		 3086 return FALSE;
3087 if (fb == b)
76f68e9b 3088 sv_setpvs(tmpsv, ".");
62b28dd9 3089 else
46fc3d4c 3090 sv_setpvn(tmpsv, b, fb - b);
95a20fc0 3091 if (PerlLIO_stat(SvPVX_const(tmpsv), &tmpstatbuf2) < 0)
62b28dd9
LW		 3092 return FALSE;
3093 return tmpstatbuf1.st_dev == tmpstatbuf2.st_dev &&
3094 tmpstatbuf1.st_ino == tmpstatbuf2.st_ino;
3095}
fe14fcc3
LW		 3096#endif /* !HAS_RENAME */
3097
491527d0 3098char*
7f315aed
NC		 3099Perl_find_script(pTHX_ const char *scriptname, bool dosearch,
3100 const char *const *const search_ext, I32 flags)
491527d0 3101{
97aff369 3102 dVAR;
bd61b366
SS		 3103 const char *xfound = NULL;
3104 char *xfailed = NULL;
0f31cffe 3105 char tmpbuf[MAXPATHLEN];
491527d0 3106 register char *s;
5f74f29c 3107 I32 len = 0;
491527d0 3108 int retval;
39a02377 3109 char *bufend;
491527d0
GS		 3110#if defined(DOSISH) && !defined(OS2) && !defined(atarist)
3111# define SEARCH_EXTS ".bat", ".cmd", NULL
3112# define MAX_EXT_LEN 4
3113#endif
3114#ifdef OS2
3115# define SEARCH_EXTS ".cmd", ".btm", ".bat", ".pl", NULL
3116# define MAX_EXT_LEN 4
3117#endif
3118#ifdef VMS
3119# define SEARCH_EXTS ".pl", ".com", NULL
3120# define MAX_EXT_LEN 4
3121#endif
3122 /* additional extensions to try in each dir if scriptname not found */
3123#ifdef SEARCH_EXTS
0bcc34c2 3124 static const char *const exts[] = { SEARCH_EXTS };
7f315aed 3125 const char *const *const ext = search_ext ? search_ext : exts;
491527d0 3126 int extidx = 0, i = 0;
bd61b366 3127 const char *curext = NULL;
491527d0 3128#else
53c1dcc0 3129 PERL_UNUSED_ARG(search_ext);
491527d0
GS		 3130# define MAX_EXT_LEN 0
3131#endif
3132
7918f24d
NC		 3133 PERL_ARGS_ASSERT_FIND_SCRIPT;
3134
491527d0
GS		 3135 /*
3136 * If dosearch is true and if scriptname does not contain path
3137 * delimiters, search the PATH for scriptname.
3138 *
3139 * If SEARCH_EXTS is also defined, will look for each
3140 * scriptname{SEARCH_EXTS} whenever scriptname is not found
3141 * while searching the PATH.
3142 *
3143 * Assuming SEARCH_EXTS is C<".foo",".bar",NULL>, PATH search
3144 * proceeds as follows:
3145 * If DOSISH or VMSISH:
3146 * + look for ./scriptname{,.foo,.bar}
3147 * + search the PATH for scriptname{,.foo,.bar}
3148 *
3149 * If !DOSISH:
3150 * + look *only* in the PATH for scriptname{,.foo,.bar} (note
3151 * this will not look in '.' if it's not in the PATH)
3152 */
84486fc6 3153 tmpbuf[0] = '\0';
491527d0
GS		 3154
3155#ifdef VMS
3156# ifdef ALWAYS_DEFTYPES
3157 len = strlen(scriptname);
3158 if (!(len == 1 && *scriptname == '-') && scriptname[len-1] != ':') {
c4420975 3159 int idx = 0, deftypes = 1;
491527d0
GS		 3160 bool seen_dot = 1;
3161
bd61b366 3162 const int hasdir = !dosearch || (strpbrk(scriptname,":[</") != NULL);
491527d0
GS		 3163# else
3164 if (dosearch) {
c4420975 3165 int idx = 0, deftypes = 1;
491527d0
GS		 3166 bool seen_dot = 1;
3167
bd61b366 3168 const int hasdir = (strpbrk(scriptname,":[</") != NULL);
491527d0
GS		 3169# endif
3170 /* The first time through, just add SEARCH_EXTS to whatever we
3171 * already have, so we can check for default file types. */
3172 while (deftypes ||
84486fc6 3173 (!hasdir && my_trnlnm("DCL$PATH",tmpbuf,idx++)) )
491527d0
GS		 3174 {
3175 if (deftypes) {
3176 deftypes = 0;
84486fc6 3177 *tmpbuf = '\0';
491527d0 3178 }
84486fc6
GS		 3179 if ((strlen(tmpbuf) + strlen(scriptname)
3180 + MAX_EXT_LEN) >= sizeof tmpbuf)
491527d0 3181 continue; /* don't search dir with too-long name */
6fca0082 3182 my_strlcat(tmpbuf, scriptname, sizeof(tmpbuf));
491527d0
GS		 3183#else /* !VMS */
3184
3185#ifdef DOSISH
3186 if (strEQ(scriptname, "-"))
3187 dosearch = 0;
3188 if (dosearch) { /* Look in '.' first. */
fe2774ed 3189 const char *cur = scriptname;
491527d0
GS		 3190#ifdef SEARCH_EXTS
3191 if ((curext = strrchr(scriptname,'.'))) /* possible current ext */
3192 while (ext[i])
3193 if (strEQ(ext[i++],curext)) {
3194 extidx = -1; /* already has an ext */
3195 break;
3196 }
3197 do {
3198#endif
3199 DEBUG_p(PerlIO_printf(Perl_debug_log,
3200 "Looking for %s\n",cur));
017f25f1
IZ		 3201 if (PerlLIO_stat(cur,&PL_statbuf) >= 0
3202 && !S_ISDIR(PL_statbuf.st_mode)) {
491527d0
GS		 3203 dosearch = 0;
3204 scriptname = cur;
3205#ifdef SEARCH_EXTS
3206 break;
3207#endif
3208 }
3209#ifdef SEARCH_EXTS
3210 if (cur == scriptname) {
3211 len = strlen(scriptname);
84486fc6 3212 if (len+MAX_EXT_LEN+1 >= sizeof(tmpbuf))
491527d0 3213 break;
9e4425f7
SH		 3214 my_strlcpy(tmpbuf, scriptname, sizeof(tmpbuf));
3215 cur = tmpbuf;
491527d0
GS		 3216 }
3217 } while (extidx >= 0 && ext[extidx] /* try an extension? */
6fca0082 3218 && my_strlcpy(tmpbuf+len, ext[extidx++], sizeof(tmpbuf) - len));
491527d0
GS		 3219#endif
3220 }
3221#endif
3222
3223 if (dosearch && !strchr(scriptname, '/')
3224#ifdef DOSISH
3225 && !strchr(scriptname, '\\')
3226#endif
cd39f2b6 3227 && (s = PerlEnv_getenv("PATH")))
cd39f2b6 3228 {
491527d0 3229 bool seen_dot = 0;
92f0c265 3230
39a02377
DM		 3231 bufend = s + strlen(s);
3232 while (s < bufend) {
491527d0
GS		 3233#if defined(atarist) || defined(DOSISH)
3234 for (len = 0; *s
3235# ifdef atarist
3236 && *s != ','
3237# endif
3238 && *s != ';'; len++, s++) {
84486fc6
GS		 3239 if (len < sizeof tmpbuf)
3240 tmpbuf[len] = *s;
491527d0 3241 }
84486fc6
GS		 3242 if (len < sizeof tmpbuf)
3243 tmpbuf[len] = '\0';
491527d0 3244#else /* ! (atarist || DOSISH) */
39a02377 3245 s = delimcpy(tmpbuf, tmpbuf + sizeof tmpbuf, s, bufend,
491527d0
GS		 3246 ':',
3247 &len);
3248#endif /* ! (atarist || DOSISH) */
39a02377 3249 if (s < bufend)
491527d0 3250 s++;
84486fc6 3251 if (len + 1 + strlen(scriptname) + MAX_EXT_LEN >= sizeof tmpbuf)
491527d0
GS		 3252 continue; /* don't search dir with too-long name */
3253 if (len
490a0e98 3254# if defined(atarist) || defined(__MINT__) || defined(DOSISH)
84486fc6
GS		 3255 && tmpbuf[len - 1] != '/'
3256 && tmpbuf[len - 1] != '\\'
490a0e98 3257# endif
491527d0 3258 )
84486fc6
GS		 3259 tmpbuf[len++] = '/';
3260 if (len == 2 && tmpbuf[0] == '.')
491527d0 3261 seen_dot = 1;
28f0d0ec 3262 (void)my_strlcpy(tmpbuf + len, scriptname, sizeof(tmpbuf) - len);
491527d0
GS		 3263#endif /* !VMS */
3264
3265#ifdef SEARCH_EXTS
84486fc6 3266 len = strlen(tmpbuf);
491527d0
GS		 3267 if (extidx > 0) /* reset after previous loop */
3268 extidx = 0;
3269 do {
3270#endif
84486fc6 3271 DEBUG_p(PerlIO_printf(Perl_debug_log, "Looking for %s\n",tmpbuf));
3280af22 3272 retval = PerlLIO_stat(tmpbuf,&PL_statbuf);
017f25f1
IZ		 3273 if (S_ISDIR(PL_statbuf.st_mode)) {
3274 retval = -1;
3275 }
491527d0
GS		 3276#ifdef SEARCH_EXTS
3277 } while ( retval < 0 /* not there */
3278 && extidx>=0 && ext[extidx] /* try an extension? */
6fca0082 3279 && my_strlcpy(tmpbuf+len, ext[extidx++], sizeof(tmpbuf) - len)
491527d0
GS		 3280 );
3281#endif
3282 if (retval < 0)
3283 continue;
3280af22
NIS		 3284 if (S_ISREG(PL_statbuf.st_mode)
3285 && cando(S_IRUSR,TRUE,&PL_statbuf)
e37778c2 3286#if !defined(DOSISH)
3280af22 3287 && cando(S_IXUSR,TRUE,&PL_statbuf)
491527d0
GS		 3288#endif
3289 )
3290 {
3aed30dc 3291 xfound = tmpbuf; /* bingo! */
491527d0
GS		 3292 break;
3293 }
3294 if (!xfailed)
84486fc6 3295 xfailed = savepv(tmpbuf);
491527d0
GS		 3296 }
3297#ifndef DOSISH
017f25f1 3298 if (!xfound && !seen_dot && !xfailed &&
a1d180c4 3299 (PerlLIO_stat(scriptname,&PL_statbuf) < 0
017f25f1 3300 || S_ISDIR(PL_statbuf.st_mode)))
491527d0
GS		 3301#endif
3302 seen_dot = 1; /* Disable message. */
9ccb31f9
GS		 3303 if (!xfound) {
3304 if (flags & 1) { /* do or die? */
3aed30dc 3305 Perl_croak(aTHX_ "Can't %s %s%s%s",
9ccb31f9
GS		 3306 (xfailed ? "execute" : "find"),
3307 (xfailed ? xfailed : scriptname),
3308 (xfailed ? "" : " on PATH"),
3309 (xfailed || seen_dot) ? "" : ", '.' not in PATH");
3310 }
bd61b366 3311 scriptname = NULL;
9ccb31f9 3312 }
43c5f42d 3313 Safefree(xfailed);
491527d0
GS		 3314 scriptname = xfound;
3315 }
bd61b366 3316 return (scriptname ? savepv(scriptname) : NULL);
491527d0
GS		 3317}
3318
ba869deb
GS		 3319#ifndef PERL_GET_CONTEXT_DEFINED
3320
3321void *
3322Perl_get_context(void)
3323{
27da23d5 3324 dVAR;
3db8f154 3325#if defined(USE_ITHREADS)
ba869deb
GS		 3326# ifdef OLD_PTHREADS_API
3327 pthread_addr_t t;
3328 if (pthread_getspecific(PL_thr_key, &t))
3329 Perl_croak_nocontext("panic: pthread_getspecific");
3330 return (void*)t;
3331# else
bce813aa 3332# ifdef I_MACH_CTHREADS
8b8b35ab 3333 return (void*)cthread_data(cthread_self());
bce813aa 3334# else
8b8b35ab
JH		 3335 return (void*)PTHREAD_GETSPECIFIC(PL_thr_key);
3336# endif
c44d3fdb 3337# endif
ba869deb
GS		 3338#else
3339 return (void*)NULL;
3340#endif
3341}
3342
3343void
3344Perl_set_context(void *t)
3345{
8772537c 3346 dVAR;
7918f24d 3347 PERL_ARGS_ASSERT_SET_CONTEXT;
3db8f154 3348#if defined(USE_ITHREADS)
c44d3fdb
GS		 3349# ifdef I_MACH_CTHREADS
3350 cthread_set_data(cthread_self(), t);
3351# else
ba869deb
GS		 3352 if (pthread_setspecific(PL_thr_key, t))
3353 Perl_croak_nocontext("panic: pthread_setspecific");
c44d3fdb 3354# endif
b464bac0 3355#else
8772537c 3356 PERL_UNUSED_ARG(t);
ba869deb
GS		 3357#endif
3358}
3359
3360#endif /* !PERL_GET_CONTEXT_DEFINED */
491527d0 3361
27da23d5 3362#if defined(PERL_GLOBAL_STRUCT) && !defined(PERL_GLOBAL_STRUCT_PRIVATE)
22239a37 3363struct perl_vars *
864dbfa3 3364Perl_GetVars(pTHX)
22239a37 3365{
533c011a 3366 return &PL_Vars;
22239a37 3367}
31fb1209
NIS		 3368#endif
3369
1cb0ed9b 3370char **
864dbfa3 3371Perl_get_op_names(pTHX)
31fb1209 3372{
96a5add6
AL		 3373 PERL_UNUSED_CONTEXT;
3374 return (char **)PL_op_name;
31fb1209
NIS		 3375}
3376
1cb0ed9b 3377char **
864dbfa3 3378Perl_get_op_descs(pTHX)
31fb1209 3379{
96a5add6
AL		 3380 PERL_UNUSED_CONTEXT;
3381 return (char **)PL_op_desc;
31fb1209 3382}
9e6b2b00 3383
e1ec3a88 3384const char *
864dbfa3 3385Perl_get_no_modify(pTHX)
9e6b2b00 3386{
96a5add6
AL		 3387 PERL_UNUSED_CONTEXT;
3388 return PL_no_modify;
9e6b2b00
GS		 3389}
3390
3391U32 *
864dbfa3 3392Perl_get_opargs(pTHX)
9e6b2b00 3393{
96a5add6
AL		 3394 PERL_UNUSED_CONTEXT;
3395 return (U32 *)PL_opargs;
9e6b2b00 3396}
51aa15f3 3397
0cb96387
GS		 3398PPADDR_t*
3399Perl_get_ppaddr(pTHX)
3400{
96a5add6
AL		 3401 dVAR;
3402 PERL_UNUSED_CONTEXT;
3403 return (PPADDR_t*)PL_ppaddr;
0cb96387
GS		 3404}
3405
a6c40364
GS		 3406#ifndef HAS_GETENV_LEN
3407char *
bf4acbe4 3408Perl_getenv_len(pTHX_ const char *env_elem, unsigned long *len)
a6c40364 3409{
8772537c 3410 char * const env_trans = PerlEnv_getenv(env_elem);
96a5add6 3411 PERL_UNUSED_CONTEXT;
7918f24d 3412 PERL_ARGS_ASSERT_GETENV_LEN;
a6c40364
GS		 3413 if (env_trans)
3414 *len = strlen(env_trans);
3415 return env_trans;
f675dbe5
CB		 3416}
3417#endif
3418
dc9e4912
GS		 3419
3420MGVTBL*
864dbfa3 3421Perl_get_vtbl(pTHX_ int vtbl_id)
dc9e4912 3422{
7452cf6a 3423 const MGVTBL* result;
96a5add6 3424 PERL_UNUSED_CONTEXT;
dc9e4912
GS		 3425
3426 switch(vtbl_id) {
3427 case want_vtbl_sv:
3428 result = &PL_vtbl_sv;
3429 break;
3430 case want_vtbl_env:
3431 result = &PL_vtbl_env;
3432 break;
3433 case want_vtbl_envelem:
3434 result = &PL_vtbl_envelem;
3435 break;
3436 case want_vtbl_sig:
3437 result = &PL_vtbl_sig;
3438 break;
3439 case want_vtbl_sigelem:
3440 result = &PL_vtbl_sigelem;
3441 break;
3442 case want_vtbl_pack:
3443 result = &PL_vtbl_pack;
3444 break;
3445 case want_vtbl_packelem:
3446 result = &PL_vtbl_packelem;
3447 break;
3448 case want_vtbl_dbline:
3449 result = &PL_vtbl_dbline;
3450 break;
3451 case want_vtbl_isa:
3452 result = &PL_vtbl_isa;
3453 break;
3454 case want_vtbl_isaelem:
3455 result = &PL_vtbl_isaelem;
3456 break;
3457 case want_vtbl_arylen:
3458 result = &PL_vtbl_arylen;
3459 break;
dc9e4912
GS		 3460 case want_vtbl_mglob:
3461 result = &PL_vtbl_mglob;
3462 break;
3463 case want_vtbl_nkeys:
3464 result = &PL_vtbl_nkeys;
3465 break;
3466 case want_vtbl_taint:
3467 result = &PL_vtbl_taint;
3468 break;
3469 case want_vtbl_substr:
3470 result = &PL_vtbl_substr;
3471 break;
3472 case want_vtbl_vec:
3473 result = &PL_vtbl_vec;
3474 break;
3475 case want_vtbl_pos:
3476 result = &PL_vtbl_pos;
3477 break;
3478 case want_vtbl_bm:
3479 result = &PL_vtbl_bm;
3480 break;
3481 case want_vtbl_fm:
3482 result = &PL_vtbl_fm;
3483 break;
3484 case want_vtbl_uvar:
3485 result = &PL_vtbl_uvar;
3486 break;
dc9e4912
GS		 3487 case want_vtbl_defelem:
3488 result = &PL_vtbl_defelem;
3489 break;
3490 case want_vtbl_regexp:
3491 result = &PL_vtbl_regexp;
3492 break;
3493 case want_vtbl_regdata:
3494 result = &PL_vtbl_regdata;
3495 break;
3496 case want_vtbl_regdatum:
3497 result = &PL_vtbl_regdatum;
3498 break;
3c90161d 3499#ifdef USE_LOCALE_COLLATE
dc9e4912
GS		 3500 case want_vtbl_collxfrm:
3501 result = &PL_vtbl_collxfrm;
3502 break;
3c90161d 3503#endif
dc9e4912
GS		 3504 case want_vtbl_amagic:
3505 result = &PL_vtbl_amagic;
3506 break;
3507 case want_vtbl_amagicelem:
3508 result = &PL_vtbl_amagicelem;
3509 break;
810b8aa5
GS		 3510 case want_vtbl_backref:
3511 result = &PL_vtbl_backref;
3512 break;
7e8c5dac
HS		 3513 case want_vtbl_utf8:
3514 result = &PL_vtbl_utf8;
3515 break;
7452cf6a 3516 default:
4608196e 3517 result = NULL;
7452cf6a 3518 break;
dc9e4912 3519 }
27da23d5 3520 return (MGVTBL*)result;
dc9e4912
GS		 3521}
3522
767df6a1 3523I32
864dbfa3 3524Perl_my_fflush_all(pTHX)
767df6a1 3525{
f800e14d 3526#if defined(USE_PERLIO) || defined(FFLUSH_NULL) || defined(USE_SFIO)
ce720889 3527 return PerlIO_flush(NULL);
767df6a1 3528#else
8fbdfb7c 3529# if defined(HAS__FWALK)
f13a2bc0 3530 extern int fflush(FILE *);
74cac757
JH		 3531 /* undocumented, unprototyped, but very useful BSDism */
3532 extern void _fwalk(int (*)(FILE *));
8fbdfb7c 3533 _fwalk(&fflush);
74cac757 3534 return 0;
8fa7f367 3535# else
8fbdfb7c 3536# if defined(FFLUSH_ALL) && defined(HAS_STDIO_STREAM_ARRAY)
8fa7f367 3537 long open_max = -1;
8fbdfb7c 3538# ifdef PERL_FFLUSH_ALL_FOPEN_MAX
d2201af2 3539 open_max = PERL_FFLUSH_ALL_FOPEN_MAX;
8fbdfb7c 3540# else
8fa7f367 3541# if defined(HAS_SYSCONF) && defined(_SC_OPEN_MAX)
767df6a1 3542 open_max = sysconf(_SC_OPEN_MAX);
8fa7f367
JH		 3543# else
3544# ifdef FOPEN_MAX
74cac757 3545 open_max = FOPEN_MAX;
8fa7f367
JH		 3546# else
3547# ifdef OPEN_MAX
74cac757 3548 open_max = OPEN_MAX;
8fa7f367
JH		 3549# else
3550# ifdef _NFILE
d2201af2 3551 open_max = _NFILE;
8fa7f367
JH		 3552# endif
3553# endif
74cac757 3554# endif
767df6a1
JH		 3555# endif
3556# endif
767df6a1
JH		 3557 if (open_max > 0) {
3558 long i;
3559 for (i = 0; i < open_max; i++)
d2201af2
AD		 3560 if (STDIO_STREAM_ARRAY[i]._file >= 0 &&
3561 STDIO_STREAM_ARRAY[i]._file < open_max &&
3562 STDIO_STREAM_ARRAY[i]._flag)
3563 PerlIO_flush(&STDIO_STREAM_ARRAY[i]);
767df6a1
JH		 3564 return 0;
3565 }
8fbdfb7c 3566# endif
93189314 3567 SETERRNO(EBADF,RMS_IFI);
767df6a1 3568 return EOF;
74cac757 3569# endif
767df6a1
JH		 3570#endif
3571}
097ee67d 3572
69282e91 3573void
e1ec3a88 3574Perl_report_evil_fh(pTHX_ const GV *gv, const IO *io, I32 op)
bc37a18f 3575{
b64e5050 3576 const char * const name = gv && isGV(gv) ? GvENAME(gv) : NULL;
66fc2fa5 3577
4c80c0b2 3578 if (op == OP_phoney_OUTPUT_ONLY || op == OP_phoney_INPUT_ONLY) {
3aed30dc 3579 if (ckWARN(WARN_IO)) {
10edeb5d
JH		 3580 const char * const direction =
3581 (const char *)((op == OP_phoney_INPUT_ONLY) ? "in" : "out");
3aed30dc
HS		 3582 if (name && *name)
3583 Perl_warner(aTHX_ packWARN(WARN_IO),
3584 "Filehandle %s opened only for %sput",
fd322ea4 3585 name, direction);
3aed30dc
HS		 3586 else
3587 Perl_warner(aTHX_ packWARN(WARN_IO),
fd322ea4 3588 "Filehandle opened only for %sput", direction);
3aed30dc 3589 }
2dd78f96
JH		 3590 }
3591 else {
e1ec3a88 3592 const char *vile;
3aed30dc
HS		 3593 I32 warn_type;
3594
3595 if (gv && io && IoTYPE(io) == IoTYPE_CLOSED) {
3596 vile = "closed";
3597 warn_type = WARN_CLOSED;
3598 }
3599 else {
3600 vile = "unopened";
3601 warn_type = WARN_UNOPENED;
3602 }
3603
3604 if (ckWARN(warn_type)) {
10edeb5d
JH		 3605 const char * const pars =
3606 (const char *)(OP_IS_FILETEST(op) ? "" : "()");
f0a09b71 3607 const char * const func =
10edeb5d
JH		 3608 (const char *)
3609 (op == OP_READLINE ? "readline" : /* "<HANDLE>" not nice */
3610 op == OP_LEAVEWRITE ? "write" : /* "write exit" not nice */
3611 op < 0 ? "" : /* handle phoney cases */
3612 PL_op_desc[op]);
3613 const char * const type =
3614 (const char *)
3615 (OP_IS_SOCKET(op) ||
3616 (gv && io && IoTYPE(io) == IoTYPE_SOCKET) ?
3617 "socket" : "filehandle");
3aed30dc
HS		 3618 if (name && *name) {
3619 Perl_warner(aTHX_ packWARN(warn_type),
3620 "%s%s on %s %s %s", func, pars, vile, type, name);
3621 if (io && IoDIRP(io) && !(IoFLAGS(io) & IOf_FAKE_DIRP))
3622 Perl_warner(
3623 aTHX_ packWARN(warn_type),
3624 "\t(Are you trying to call %s%s on dirhandle %s?)\n",
3625 func, pars, name
3626 );
3627 }
3628 else {
3629 Perl_warner(aTHX_ packWARN(warn_type),
3630 "%s%s on %s %s", func, pars, vile, type);
3631 if (gv && io && IoDIRP(io) && !(IoFLAGS(io) & IOf_FAKE_DIRP))
3632 Perl_warner(
3633 aTHX_ packWARN(warn_type),
3634 "\t(Are you trying to call %s%s on dirhandle?)\n",
3635 func, pars
3636 );
3637 }
3638 }
bc37a18f 3639 }
69282e91 3640}
a926ef6b
JH		 3641
3642#ifdef EBCDIC
cbebf344
JH		 3643/* in ASCII order, not that it matters */
3644static const char controllablechars[] = "?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_";
3645
a926ef6b
JH		 3646int
3647Perl_ebcdic_control(pTHX_ int ch)
3648{
3aed30dc 3649 if (ch > 'a') {
e1ec3a88 3650 const char *ctlp;
3aed30dc
HS		 3651
3652 if (islower(ch))
3653 ch = toupper(ch);
3654
3655 if ((ctlp = strchr(controllablechars, ch)) == 0) {
3656 Perl_die(aTHX_ "unrecognised control character '%c'\n", ch);
a926ef6b 3657 }
3aed30dc
HS		 3658
3659 if (ctlp == controllablechars)
3660 return('\177'); /* DEL */
3661 else
3662 return((unsigned char)(ctlp - controllablechars - 1));
3663 } else { /* Want uncontrol */
3664 if (ch == '\177' || ch == -1)
3665 return('?');
3666 else if (ch == '\157')
3667 return('\177');
3668 else if (ch == '\174')
3669 return('\000');
3670 else if (ch == '^') /* '\137' in 1047, '\260' in 819 */
3671 return('\036');
3672 else if (ch == '\155')
3673 return('\037');
3674 else if (0 < ch && ch < (sizeof(controllablechars) - 1))
3675 return(controllablechars[ch+1]);
3676 else
3677 Perl_die(aTHX_ "invalid control request: '\\%03o'\n", ch & 0xFF);
3678 }
a926ef6b
JH		 3679}
3680#endif
e72cf795 3681
f6adc668 3682/* To workaround core dumps from the uninitialised tm_zone we get the
e72cf795
JH		 3683 * system to give us a reasonable struct to copy. This fix means that
3684 * strftime uses the tm_zone and tm_gmtoff values returned by
3685 * localtime(time()). That should give the desired result most of the
3686 * time. But probably not always!
3687 *
f6adc668
JH		 3688 * This does not address tzname aspects of NETaa14816.
3689 *
e72cf795 3690 */
f6adc668 3691
e72cf795
JH		 3692#ifdef HAS_GNULIBC
3693# ifndef STRUCT_TM_HASZONE
3694# define STRUCT_TM_HASZONE
3695# endif
3696#endif
3697
f6adc668
JH		 3698#ifdef STRUCT_TM_HASZONE /* Backward compat */
3699# ifndef HAS_TM_TM_ZONE
3700# define HAS_TM_TM_ZONE
3701# endif
3702#endif
3703
e72cf795 3704void
f1208910 3705Perl_init_tm(pTHX_ struct tm *ptm) /* see mktime, strftime and asctime */
e72cf795 3706{
f6adc668 3707#ifdef HAS_TM_TM_ZONE
e72cf795 3708 Time_t now;
1b6737cc 3709 const struct tm* my_tm;
7918f24d 3710 PERL_ARGS_ASSERT_INIT_TM;
e72cf795 3711 (void)time(&now);
82c57498 3712 my_tm = localtime(&now);
ca46b8ee
SP		 3713 if (my_tm)
3714 Copy(my_tm, ptm, 1, struct tm);
1b6737cc 3715#else
7918f24d 3716 PERL_ARGS_ASSERT_INIT_TM;
1b6737cc 3717 PERL_UNUSED_ARG(ptm);
e72cf795
JH		 3718#endif
3719}
3720
3721/*
3722 * mini_mktime - normalise struct tm values without the localtime()
3723 * semantics (and overhead) of mktime().
3724 */
3725void
f1208910 3726Perl_mini_mktime(pTHX_ struct tm *ptm)
e72cf795
JH		 3727{
3728 int yearday;
3729 int secs;
3730 int month, mday, year, jday;
3731 int odd_cent, odd_year;
96a5add6 3732 PERL_UNUSED_CONTEXT;
e72cf795 3733
7918f24d
NC		 3734 PERL_ARGS_ASSERT_MINI_MKTIME;
3735
e72cf795
JH		 3736#define DAYS_PER_YEAR 365
3737#define DAYS_PER_QYEAR (4*DAYS_PER_YEAR+1)
3738#define DAYS_PER_CENT (25*DAYS_PER_QYEAR-1)
3739#define DAYS_PER_QCENT (4*DAYS_PER_CENT+1)
3740#define SECS_PER_HOUR (60*60)
3741#define SECS_PER_DAY (24*SECS_PER_HOUR)
3742/* parentheses deliberately absent on these two, otherwise they don't work */
3743#define MONTH_TO_DAYS 153/5
3744#define DAYS_TO_MONTH 5/153
3745/* offset to bias by March (month 4) 1st between month/mday & year finding */
3746#define YEAR_ADJUST (4*MONTH_TO_DAYS+1)
3747/* as used here, the algorithm leaves Sunday as day 1 unless we adjust it */
3748#define WEEKDAY_BIAS 6 /* (1+6)%7 makes Sunday 0 again */
3749
3750/*
3751 * Year/day algorithm notes:
3752 *
3753 * With a suitable offset for numeric value of the month, one can find
3754 * an offset into the year by considering months to have 30.6 (153/5) days,
3755 * using integer arithmetic (i.e., with truncation). To avoid too much
3756 * messing about with leap days, we consider January and February to be
3757 * the 13th and 14th month of the previous year. After that transformation,
3758 * we need the month index we use to be high by 1 from 'normal human' usage,
3759 * so the month index values we use run from 4 through 15.
3760 *
3761 * Given that, and the rules for the Gregorian calendar (leap years are those
3762 * divisible by 4 unless also divisible by 100, when they must be divisible
3763 * by 400 instead), we can simply calculate the number of days since some
3764 * arbitrary 'beginning of time' by futzing with the (adjusted) year number,
3765 * the days we derive from our month index, and adding in the day of the
3766 * month. The value used here is not adjusted for the actual origin which
3767 * it normally would use (1 January A.D. 1), since we're not exposing it.
3768 * We're only building the value so we can turn around and get the
3769 * normalised values for the year, month, day-of-month, and day-of-year.
3770 *
3771 * For going backward, we need to bias the value we're using so that we find
3772 * the right year value. (Basically, we don't want the contribution of
3773 * March 1st to the number to apply while deriving the year). Having done
3774 * that, we 'count up' the contribution to the year number by accounting for
3775 * full quadracenturies (400-year periods) with their extra leap days, plus
3776 * the contribution from full centuries (to avoid counting in the lost leap
3777 * days), plus the contribution from full quad-years (to count in the normal
3778 * leap days), plus the leftover contribution from any non-leap years.
3779 * At this point, if we were working with an actual leap day, we'll have 0
3780 * days left over. This is also true for March 1st, however. So, we have
3781 * to special-case that result, and (earlier) keep track of the 'odd'
3782 * century and year contributions. If we got 4 extra centuries in a qcent,
3783 * or 4 extra years in a qyear, then it's a leap day and we call it 29 Feb.
3784 * Otherwise, we add back in the earlier bias we removed (the 123 from
3785 * figuring in March 1st), find the month index (integer division by 30.6),
3786 * and the remainder is the day-of-month. We then have to convert back to
3787 * 'real' months (including fixing January and February from being 14/15 in
3788 * the previous year to being in the proper year). After that, to get
3789 * tm_yday, we work with the normalised year and get a new yearday value for
3790 * January 1st, which we subtract from the yearday value we had earlier,
3791 * representing the date we've re-built. This is done from January 1
3792 * because tm_yday is 0-origin.
3793 *
3794 * Since POSIX time routines are only guaranteed to work for times since the
3795 * UNIX epoch (00:00:00 1 Jan 1970 UTC), the fact that this algorithm
3796 * applies Gregorian calendar rules even to dates before the 16th century
3797 * doesn't bother me. Besides, you'd need cultural context for a given
3798 * date to know whether it was Julian or Gregorian calendar, and that's
3799 * outside the scope for this routine. Since we convert back based on the
3800 * same rules we used to build the yearday, you'll only get strange results
3801 * for input which needed normalising, or for the 'odd' century years which
3802 * were leap years in the Julian calander but not in the Gregorian one.
3803 * I can live with that.
3804 *
3805 * This algorithm also fails to handle years before A.D. 1 gracefully, but
3806 * that's still outside the scope for POSIX time manipulation, so I don't
3807 * care.
3808 */
3809
3810 year = 1900 + ptm->tm_year;
3811 month = ptm->tm_mon;
3812 mday = ptm->tm_mday;
3813 /* allow given yday with no month & mday to dominate the result */
3814 if (ptm->tm_yday >= 0 && mday <= 0 && month <= 0) {
3815 month = 0;
3816 mday = 0;
3817 jday = 1 + ptm->tm_yday;
3818 }
3819 else {
3820 jday = 0;
3821 }
3822 if (month >= 2)
3823 month+=2;
3824 else
3825 month+=14, year--;
3826 yearday = DAYS_PER_YEAR * year + year/4 - year/100 + year/400;
3827 yearday += month*MONTH_TO_DAYS + mday + jday;
3828 /*
3829 * Note that we don't know when leap-seconds were or will be,
3830 * so we have to trust the user if we get something which looks
3831 * like a sensible leap-second. Wild values for seconds will
3832 * be rationalised, however.
3833 */
3834 if ((unsigned) ptm->tm_sec <= 60) {
3835 secs = 0;
3836 }
3837 else {
3838 secs = ptm->tm_sec;
3839 ptm->tm_sec = 0;
3840 }
3841 secs += 60 * ptm->tm_min;
3842 secs += SECS_PER_HOUR * ptm->tm_hour;
3843 if (secs < 0) {
3844 if (secs-(secs/SECS_PER_DAY*SECS_PER_DAY) < 0) {
3845 /* got negative remainder, but need positive time */
3846 /* back off an extra day to compensate */
3847 yearday += (secs/SECS_PER_DAY)-1;
3848 secs -= SECS_PER_DAY * (secs/SECS_PER_DAY - 1);
3849 }
3850 else {
3851 yearday += (secs/SECS_PER_DAY);
3852 secs -= SECS_PER_DAY * (secs/SECS_PER_DAY);
3853 }
3854 }
3855 else if (secs >= SECS_PER_DAY) {
3856 yearday += (secs/SECS_PER_DAY);
3857 secs %= SECS_PER_DAY;
3858 }
3859 ptm->tm_hour = secs/SECS_PER_HOUR;
3860 secs %= SECS_PER_HOUR;
3861 ptm->tm_min = secs/60;
3862 secs %= 60;
3863 ptm->tm_sec += secs;
3864 /* done with time of day effects */
3865 /*
3866 * The algorithm for yearday has (so far) left it high by 428.
3867 * To avoid mistaking a legitimate Feb 29 as Mar 1, we need to
3868 * bias it by 123 while trying to figure out what year it
3869 * really represents. Even with this tweak, the reverse
3870 * translation fails for years before A.D. 0001.
3871 * It would still fail for Feb 29, but we catch that one below.
3872 */
3873 jday = yearday; /* save for later fixup vis-a-vis Jan 1 */
3874 yearday -= YEAR_ADJUST;
3875 year = (yearday / DAYS_PER_QCENT) * 400;
3876 yearday %= DAYS_PER_QCENT;
3877 odd_cent = yearday / DAYS_PER_CENT;
3878 year += odd_cent * 100;
3879 yearday %= DAYS_PER_CENT;
3880 year += (yearday / DAYS_PER_QYEAR) * 4;
3881 yearday %= DAYS_PER_QYEAR;
3882 odd_year = yearday / DAYS_PER_YEAR;
3883 year += odd_year;
3884 yearday %= DAYS_PER_YEAR;
3885 if (!yearday && (odd_cent==4 || odd_year==4)) { /* catch Feb 29 */
3886 month = 1;
3887 yearday = 29;
3888 }
3889 else {
3890 yearday += YEAR_ADJUST; /* recover March 1st crock */
3891 month = yearday*DAYS_TO_MONTH;
3892 yearday -= month*MONTH_TO_DAYS;
3893 /* recover other leap-year adjustment */
3894 if (month > 13) {
3895 month-=14;
3896 year++;
3897 }
3898 else {
3899 month-=2;
3900 }
3901 }
3902 ptm->tm_year = year - 1900;
3903 if (yearday) {
3904 ptm->tm_mday = yearday;
3905 ptm->tm_mon = month;
3906 }
3907 else {
3908 ptm->tm_mday = 31;
3909 ptm->tm_mon = month - 1;
3910 }
3911 /* re-build yearday based on Jan 1 to get tm_yday */
3912 year--;
3913 yearday = year*DAYS_PER_YEAR + year/4 - year/100 + year/400;
3914 yearday += 14*MONTH_TO_DAYS + 1;
3915 ptm->tm_yday = jday - yearday;
3916 /* fix tm_wday if not overridden by caller */
3917 if ((unsigned)ptm->tm_wday > 6)
3918 ptm->tm_wday = (jday + WEEKDAY_BIAS) % 7;
3919}
b3c85772
JH		 3920
3921char *
e1ec3a88 3922Perl_my_strftime(pTHX_ const char *fmt, int sec, int min, int hour, int mday, int mon, int year, int wday, int yday, int isdst)
b3c85772
JH		 3923{
3924#ifdef HAS_STRFTIME
3925 char *buf;
3926 int buflen;
3927 struct tm mytm;
3928 int len;
3929
7918f24d
NC		 3930 PERL_ARGS_ASSERT_MY_STRFTIME;
3931
b3c85772
JH		 3932 init_tm(&mytm); /* XXX workaround - see init_tm() above */
3933 mytm.tm_sec = sec;
3934 mytm.tm_min = min;
3935 mytm.tm_hour = hour;
3936 mytm.tm_mday = mday;
3937 mytm.tm_mon = mon;
3938 mytm.tm_year = year;
3939 mytm.tm_wday = wday;
3940 mytm.tm_yday = yday;
3941 mytm.tm_isdst = isdst;
3942 mini_mktime(&mytm);
c473feec
SR		 3943 /* use libc to get the values for tm_gmtoff and tm_zone [perl #18238] */
3944#if defined(HAS_MKTIME) && (defined(HAS_TM_TM_GMTOFF) || defined(HAS_TM_TM_ZONE))
3945 STMT_START {
3946 struct tm mytm2;
3947 mytm2 = mytm;
3948 mktime(&mytm2);
3949#ifdef HAS_TM_TM_GMTOFF
3950 mytm.tm_gmtoff = mytm2.tm_gmtoff;
3951#endif
3952#ifdef HAS_TM_TM_ZONE
3953 mytm.tm_zone = mytm2.tm_zone;
3954#endif
3955 } STMT_END;
3956#endif
b3c85772 3957 buflen = 64;
a02a5408 3958 Newx(buf, buflen, char);
b3c85772
JH		 3959 len = strftime(buf, buflen, fmt, &mytm);
3960 /*
877f6a72 3961 ** The following is needed to handle to the situation where
b3c85772
JH		 3962 ** tmpbuf overflows. Basically we want to allocate a buffer
3963 ** and try repeatedly. The reason why it is so complicated
3964 ** is that getting a return value of 0 from strftime can indicate
3965 ** one of the following:
3966 ** 1. buffer overflowed,
3967 ** 2. illegal conversion specifier, or
3968 ** 3. the format string specifies nothing to be returned(not
3969 ** an error). This could be because format is an empty string
3970 ** or it specifies %p that yields an empty string in some locale.
3971 ** If there is a better way to make it portable, go ahead by
3972 ** all means.
3973 */
3974 if ((len > 0 && len < buflen) || (len == 0 && *fmt == '\0'))
3975 return buf;
3976 else {
3977 /* Possibly buf overflowed - try again with a bigger buf */
e1ec3a88 3978 const int fmtlen = strlen(fmt);
7743c307 3979 int bufsize = fmtlen + buflen;
877f6a72 3980
a02a5408 3981 Newx(buf, bufsize, char);
b3c85772
JH		 3982 while (buf) {
3983 buflen = strftime(buf, bufsize, fmt, &mytm);
3984 if (buflen > 0 && buflen < bufsize)
3985 break;
3986 /* heuristic to prevent out-of-memory errors */
3987 if (bufsize > 100*fmtlen) {
3988 Safefree(buf);
3989 buf = NULL;
3990 break;
3991 }
7743c307
SH		 3992 bufsize *= 2;
3993 Renew(buf, bufsize, char);
b3c85772
JH		 3994 }
3995 return buf;
3996 }
3997#else
3998 Perl_croak(aTHX_ "panic: no strftime");
27da23d5 3999 return NULL;
b3c85772
JH		 4000#endif
4001}
4002
877f6a72
NIS		 4003
4004#define SV_CWD_RETURN_UNDEF \
4005sv_setsv(sv, &PL_sv_undef); \
4006return FALSE
4007
4008#define SV_CWD_ISDOT(dp) \
4009 (dp->d_name[0] == '.' && (dp->d_name[1] == '\0' || \
3aed30dc 4010 (dp->d_name[1] == '.' && dp->d_name[2] == '\0')))
877f6a72
NIS		 4011
4012/*
ccfc67b7
JH		 4013=head1 Miscellaneous Functions
4014
89423764 4015=for apidoc getcwd_sv
877f6a72
NIS		 4016
4017Fill the sv with current working directory
4018
4019=cut
4020*/
4021
4022/* Originally written in Perl by John Bazik; rewritten in C by Ben Sugars.
4023 * rewritten again by dougm, optimized for use with xs TARG, and to prefer
4024 * getcwd(3) if available
4025 * Comments from the orignal:
4026 * This is a faster version of getcwd. It's also more dangerous
4027 * because you might chdir out of a directory that you can't chdir
4028 * back into. */
4029
877f6a72 4030int
89423764 4031Perl_getcwd_sv(pTHX_ register SV *sv)
877f6a72
NIS		 4032{
4033#ifndef PERL_MICRO
97aff369 4034 dVAR;
ea715489
JH		 4035#ifndef INCOMPLETE_TAINTS
4036 SvTAINTED_on(sv);
4037#endif
4038
7918f24d
NC		 4039 PERL_ARGS_ASSERT_GETCWD_SV;
4040
8f95b30d
JH		 4041#ifdef HAS_GETCWD
4042 {
60e110a8
DM		 4043 char buf[MAXPATHLEN];
4044
3aed30dc 4045 /* Some getcwd()s automatically allocate a buffer of the given
60e110a8
DM		 4046 * size from the heap if they are given a NULL buffer pointer.
4047 * The problem is that this behaviour is not portable. */
3aed30dc 4048 if (getcwd(buf, sizeof(buf) - 1)) {
42d9b98d 4049 sv_setpv(sv, buf);
3aed30dc
HS		 4050 return TRUE;
4051 }
4052 else {
4053 sv_setsv(sv, &PL_sv_undef);
4054 return FALSE;
4055 }
8f95b30d
JH		 4056 }
4057
4058#else
4059
c623ac67 4060 Stat_t statbuf;
877f6a72 4061 int orig_cdev, orig_cino, cdev, cino, odev, oino, tdev, tino;
4373e329 4062 int pathlen=0;
877f6a72 4063 Direntry_t *dp;
877f6a72 4064
862a34c6 4065 SvUPGRADE(sv, SVt_PV);
877f6a72 4066
877f6a72 4067 if (PerlLIO_lstat(".", &statbuf) < 0) {
3aed30dc 4068 SV_CWD_RETURN_UNDEF;
877f6a72
NIS		 4069 }
4070
4071 orig_cdev = statbuf.st_dev;
4072 orig_cino = statbuf.st_ino;
4073 cdev = orig_cdev;
4074 cino = orig_cino;
4075
4076 for (;;) {
4373e329 4077 DIR *dir;
f56ed502 4078 int namelen;
3aed30dc
HS		 4079 odev = cdev;
4080 oino = cino;
4081
4082 if (PerlDir_chdir("..") < 0) {
4083 SV_CWD_RETURN_UNDEF;
4084 }
4085 if (PerlLIO_stat(".", &statbuf) < 0) {
4086 SV_CWD_RETURN_UNDEF;
4087 }
4088
4089 cdev = statbuf.st_dev;
4090 cino = statbuf.st_ino;
4091
4092 if (odev == cdev && oino == cino) {
4093 break;
4094 }
4095 if (!(dir = PerlDir_open("."))) {
4096 SV_CWD_RETURN_UNDEF;
4097 }
4098
4099 while ((dp = PerlDir_read(dir)) != NULL) {
877f6a72 4100#ifdef DIRNAMLEN
f56ed502 4101 namelen = dp->d_namlen;
877f6a72 4102#else
f56ed502 4103 namelen = strlen(dp->d_name);
877f6a72 4104#endif
3aed30dc
HS		 4105 /* skip . and .. */
4106 if (SV_CWD_ISDOT(dp)) {
4107 continue;
4108 }
4109
4110 if (PerlLIO_lstat(dp->d_name, &statbuf) < 0) {
4111 SV_CWD_RETURN_UNDEF;
4112 }
4113
4114 tdev = statbuf.st_dev;
4115 tino = statbuf.st_ino;
4116 if (tino == oino && tdev == odev) {
4117 break;
4118 }
cb5953d6
JH		 4119 }
4120
3aed30dc
HS		 4121 if (!dp) {
4122 SV_CWD_RETURN_UNDEF;
4123 }
4124
4125 if (pathlen + namelen + 1 >= MAXPATHLEN) {
4126 SV_CWD_RETURN_UNDEF;
4127 }
877f6a72 4128
3aed30dc
HS		 4129 SvGROW(sv, pathlen + namelen + 1);
4130
4131 if (pathlen) {
4132 /* shift down */
95a20fc0 4133 Move(SvPVX_const(sv), SvPVX(sv) + namelen + 1, pathlen, char);
3aed30dc 4134 }
877f6a72 4135
3aed30dc
HS		 4136 /* prepend current directory to the front */
4137 *SvPVX(sv) = '/';
4138 Move(dp->d_name, SvPVX(sv)+1, namelen, char);
4139 pathlen += (namelen + 1);
877f6a72
NIS		 4140
4141#ifdef VOID_CLOSEDIR
3aed30dc 4142 PerlDir_close(dir);
877f6a72 4143#else
3aed30dc
HS		 4144 if (PerlDir_close(dir) < 0) {
4145 SV_CWD_RETURN_UNDEF;
4146 }
877f6a72
NIS		 4147#endif
4148 }
4149
60e110a8 4150 if (pathlen) {
3aed30dc
HS		 4151 SvCUR_set(sv, pathlen);
4152 *SvEND(sv) = '\0';
4153 SvPOK_only(sv);
877f6a72 4154
95a20fc0 4155 if (PerlDir_chdir(SvPVX_const(sv)) < 0) {
3aed30dc
HS		 4156 SV_CWD_RETURN_UNDEF;
4157 }
877f6a72
NIS		 4158 }
4159 if (PerlLIO_stat(".", &statbuf) < 0) {
3aed30dc 4160 SV_CWD_RETURN_UNDEF;
877f6a72
NIS		 4161 }
4162
4163 cdev = statbuf.st_dev;
4164 cino = statbuf.st_ino;
4165
4166 if (cdev != orig_cdev || cino != orig_cino) {
3aed30dc
HS		 4167 Perl_croak(aTHX_ "Unstable directory path, "
4168 "current directory changed unexpectedly");
877f6a72 4169 }
877f6a72
NIS		 4170
4171 return TRUE;
793b8d8e
JH		 4172#endif
4173
877f6a72
NIS		 4174#else
4175 return FALSE;
4176#endif
4177}
4178
c812d146 4179#define VERSION_MAX 0x7FFFFFFF
f4758303 4180/*
b0f01acb
JP		 4181=for apidoc scan_version
4182
4183Returns a pointer to the next character after the parsed
4184version string, as well as upgrading the passed in SV to
4185an RV.
4186
4187Function must be called with an already existing SV like
4188
137d6fc0 4189 sv = newSV(0);
abc25d8c 4190 s = scan_version(s, SV *sv, bool qv);
b0f01acb
JP		 4191
4192Performs some preprocessing to the string to ensure that
4193it has the correct characteristics of a version. Flags the
4194object if it contains an underscore (which denotes this
abc25d8c 4195is an alpha version). The boolean qv denotes that the version
137d6fc0
JP		 4196should be interpreted as if it had multiple decimals, even if
4197it doesn't.
b0f01acb
JP		 4198
4199=cut
4200*/
4201
9137345a 4202const char *
e1ec3a88 4203Perl_scan_version(pTHX_ const char *s, SV *rv, bool qv)
b0f01acb 4204{
e0218a61 4205 const char *start;
9137345a
JP		 4206 const char *pos;
4207 const char *last;
4208 int saw_period = 0;
cb5772bb 4209 int alpha = 0;
9137345a 4210 int width = 3;
c812d146 4211 bool vinf = FALSE;
7452cf6a
AL		 4212 AV * const av = newAV();
4213 SV * const hv = newSVrv(rv, "version"); /* create an SV and upgrade the RV */
7918f24d
NC		 4214
4215 PERL_ARGS_ASSERT_SCAN_VERSION;
4216
9137345a 4217 (void)sv_upgrade(hv, SVt_PVHV); /* needs to be an HV type */
cb5772bb 4218
e0218a61
JP		 4219 while (isSPACE(*s)) /* leading whitespace is OK */
4220 s++;
4221
8cb289bd
RGS		 4222 start = last = s;
4223
9137345a
JP		 4224 if (*s == 'v') {
4225 s++; /* get past 'v' */
4226 qv = 1; /* force quoted version processing */
4227 }
4228
8cb289bd 4229 pos = s;
9137345a
JP		 4230
4231 /* pre-scan the input string to check for decimals/underbars */
f941e658 4232 while ( *pos == '.' || *pos == '_' || *pos == ',' || isDIGIT(*pos) )
ad63d80f
JP		 4233 {
4234 if ( *pos == '.' )
4235 {
cb5772bb 4236 if ( alpha )
5f89c282 4237 Perl_croak(aTHX_ "Invalid version format (underscores before decimal)");
ad63d80f 4238 saw_period++ ;
9137345a 4239 last = pos;
46314c13 4240 }
ad63d80f
JP		 4241 else if ( *pos == '_' )
4242 {
cb5772bb 4243 if ( alpha )
5f89c282 4244 Perl_croak(aTHX_ "Invalid version format (multiple underscores)");
cb5772bb 4245 alpha = 1;
9137345a 4246 width = pos - last - 1; /* natural width of sub-version */
ad63d80f 4247 }
f941e658
JP		 4248 else if ( *pos == ',' && isDIGIT(pos[1]) )
4249 {
4250 saw_period++ ;
4251 last = pos;
4252 }
4253
ad63d80f
JP		 4254 pos++;
4255 }
ad63d80f 4256
34ba6322
SP		 4257 if ( alpha && !saw_period )
4258 Perl_croak(aTHX_ "Invalid version format (alpha without decimal)");
4259
f34c6aaf
JP		 4260 if ( alpha && saw_period && width == 0 )
4261 Perl_croak(aTHX_ "Invalid version format (misplaced _ in number)");
4262
e0218a61 4263 if ( saw_period > 1 )
137d6fc0 4264 qv = 1; /* force quoted version processing */
9137345a 4265
c812d146 4266 last = pos;
9137345a
JP		 4267 pos = s;
4268
4269 if ( qv )
ef8f7699 4270 (void)hv_stores(MUTABLE_HV(hv), "qv", newSViv(qv));
cb5772bb 4271 if ( alpha )
ef8f7699 4272 (void)hv_stores(MUTABLE_HV(hv), "alpha", newSViv(alpha));
9137345a 4273 if ( !qv && width < 3 )
ef8f7699 4274 (void)hv_stores(MUTABLE_HV(hv), "width", newSViv(width));
9137345a 4275
ad63d80f 4276 while (isDIGIT(*pos))
46314c13 4277 pos++;
ad63d80f
JP		 4278 if (!isALPHA(*pos)) {
4279 I32 rev;
4280
ad63d80f
JP		 4281 for (;;) {
4282 rev = 0;
4283 {
129318bd 4284 /* this is atoi() that delimits on underscores */
9137345a 4285 const char *end = pos;
129318bd 4286 I32 mult = 1;
c812d146 4287 I32 orev;
9137345a 4288
129318bd
JP		 4289 /* the following if() will only be true after the decimal
4290 * point of a version originally created with a bare
4291 * floating point number, i.e. not quoted in any way
4292 */
e0218a61 4293 if ( !qv && s > start && saw_period == 1 ) {
c76df65e 4294 mult *= 100;
129318bd 4295 while ( s < end ) {
c812d146 4296 orev = rev;
129318bd
JP		 4297 rev += (*s - '0') * mult;
4298 mult /= 10;
c812d146
JP		 4299 if ( (PERL_ABS(orev) > PERL_ABS(rev))
4300 || (PERL_ABS(rev) > VERSION_MAX )) {
4301 if(ckWARN(WARN_OVERFLOW))
4302 Perl_warner(aTHX_ packWARN(WARN_OVERFLOW),
4303 "Integer overflow in version %d",VERSION_MAX);
4304 s = end - 1;
4305 rev = VERSION_MAX;
4306 vinf = 1;
4307 }
129318bd 4308 s++;
9137345a
JP		 4309 if ( *s == '_' )
4310 s++;
129318bd
JP		 4311 }
4312 }
4313 else {
4314 while (--end >= s) {
c812d146 4315 orev = rev;
129318bd
JP		 4316 rev += (*end - '0') * mult;
4317 mult *= 10;
c812d146
JP		 4318 if ( (PERL_ABS(orev) > PERL_ABS(rev))
4319 || (PERL_ABS(rev) > VERSION_MAX )) {
4320 if(ckWARN(WARN_OVERFLOW))
4321 Perl_warner(aTHX_ packWARN(WARN_OVERFLOW),
4322 "Integer overflow in version");
4323 end = s - 1;
4324 rev = VERSION_MAX;
4325 vinf = 1;
4326 }
129318bd
JP		 4327 }
4328 }
4329 }
9137345a 4330
129318bd 4331 /* Append revision */
9137345a 4332 av_push(av, newSViv(rev));
c812d146
JP		 4333 if ( vinf ) {
4334 s = last;
4335 break;
4336 }
4337 else if ( *pos == '.' )
9137345a
JP		 4338 s = ++pos;
4339 else if ( *pos == '_' && isDIGIT(pos[1]) )
ad63d80f 4340 s = ++pos;
f941e658
JP		 4341 else if ( *pos == ',' && isDIGIT(pos[1]) )
4342 s = ++pos;
ad63d80f
JP		 4343 else if ( isDIGIT(*pos) )
4344 s = pos;
b0f01acb 4345 else {
ad63d80f
JP		 4346 s = pos;
4347 break;
4348 }
9137345a
JP		 4349 if ( qv ) {
4350 while ( isDIGIT(*pos) )
4351 pos++;
4352 }
4353 else {
4354 int digits = 0;
4355 while ( ( isDIGIT(*pos) || *pos == '_' ) && digits < 3 ) {
4356 if ( *pos != '_' )
4357 digits++;
4358 pos++;
4359 }
b0f01acb
JP		 4360 }
4361 }
4362 }
9137345a
JP		 4363 if ( qv ) { /* quoted versions always get at least three terms*/
4364 I32 len = av_len(av);
4edfc503
NC		 4365 /* This for loop appears to trigger a compiler bug on OS X, as it
4366 loops infinitely. Yes, len is negative. No, it makes no sense.
4367 Compiler in question is:
4368 gcc version 3.3 20030304 (Apple Computer, Inc. build 1640)
4369 for ( len = 2 - len; len > 0; len-- )
502c6561 4370 av_push(MUTABLE_AV(sv), newSViv(0));
4edfc503
NC		 4371 */
4372 len = 2 - len;
4373 while (len-- > 0)
9137345a 4374 av_push(av, newSViv(0));
b9381830 4375 }
9137345a 4376
8cb289bd 4377 /* need to save off the current version string for later */
c812d146
JP		 4378 if ( vinf ) {
4379 SV * orig = newSVpvn("v.Inf", sizeof("v.Inf")-1);
ef8f7699
NC		 4380 (void)hv_stores(MUTABLE_HV(hv), "original", orig);
4381 (void)hv_stores(MUTABLE_HV(hv), "vinf", newSViv(1));
c812d146
JP		 4382 }
4383 else if ( s > start ) {
8cb289bd
RGS		 4384 SV * orig = newSVpvn(start,s-start);
4385 if ( qv && saw_period == 1 && *start != 'v' ) {
4386 /* need to insert a v to be consistent */
4387 sv_insert(orig, 0, 0, "v", 1);
4388 }
ef8f7699 4389 (void)hv_stores(MUTABLE_HV(hv), "original", orig);
8cb289bd
RGS		 4390 }
4391 else {
76f68e9b 4392 (void)hv_stores(MUTABLE_HV(hv), "original", newSVpvs("0"));
9137345a 4393 av_push(av, newSViv(0));
8cb289bd
RGS		 4394 }
4395
4396 /* And finally, store the AV in the hash */
daba3364 4397 (void)hv_stores(MUTABLE_HV(hv), "version", newRV_noinc(MUTABLE_SV(av)));
9137345a 4398
92dcf8ce
JP		 4399 /* fix RT#19517 - special case 'undef' as string */
4400 if ( *s == 'u' && strEQ(s,"undef") ) {
4401 s += 5;
4402 }
4403
9137345a 4404 return s;
b0f01acb
JP		 4405}
4406
4407/*
4408=for apidoc new_version
4409
4410Returns a new version object based on the passed in SV:
4411
4412 SV *sv = new_version(SV *ver);
4413
4414Does not alter the passed in ver SV. See "upg_version" if you
4415want to upgrade the SV.
4416
4417=cut
4418*/
4419
4420SV *
4421Perl_new_version(pTHX_ SV *ver)
4422{
97aff369 4423 dVAR;
2d03de9c 4424 SV * const rv = newSV(0);
7918f24d 4425 PERL_ARGS_ASSERT_NEW_VERSION;
d7aa5382
JP		 4426 if ( sv_derived_from(ver,"version") ) /* can just copy directly */
4427 {
4428 I32 key;
53c1dcc0 4429 AV * const av = newAV();
9137345a
JP		 4430 AV *sav;
4431 /* This will get reblessed later if a derived class*/
e0218a61 4432 SV * const hv = newSVrv(rv, "version");
9137345a
JP		 4433 (void)sv_upgrade(hv, SVt_PVHV); /* needs to be an HV type */
4434
4435 if ( SvROK(ver) )
4436 ver = SvRV(ver);
4437
4438 /* Begin copying all of the elements */
ef8f7699
NC		 4439 if ( hv_exists(MUTABLE_HV(ver), "qv", 2) )
4440 (void)hv_stores(MUTABLE_HV(hv), "qv", newSViv(1));
9137345a 4441
ef8f7699
NC		 4442 if ( hv_exists(MUTABLE_HV(ver), "alpha", 5) )
4443 (void)hv_stores(MUTABLE_HV(hv), "alpha", newSViv(1));
9137345a 4444
ef8f7699 4445 if ( hv_exists(MUTABLE_HV(ver), "width", 5 ) )
d7aa5382 4446 {
ef8f7699
NC		 4447 const I32 width = SvIV(*hv_fetchs(MUTABLE_HV(ver), "width", FALSE));
4448 (void)hv_stores(MUTABLE_HV(hv), "width", newSViv(width));
d7aa5382 4449 }
9137345a 4450
ef8f7699 4451 if ( hv_exists(MUTABLE_HV(ver), "original", 8 ) )
8cb289bd 4452 {
ef8f7699
NC		 4453 SV * pv = *hv_fetchs(MUTABLE_HV(ver), "original", FALSE);
4454 (void)hv_stores(MUTABLE_HV(hv), "original", newSVsv(pv));
8cb289bd
RGS		 4455 }
4456
502c6561 4457 sav = MUTABLE_AV(SvRV(*hv_fetchs(MUTABLE_HV(ver), "version", FALSE)));
9137345a
JP		 4458 /* This will get reblessed later if a derived class*/
4459 for ( key = 0; key <= av_len(sav); key++ )
4460 {
4461 const I32 rev = SvIV(*av_fetch(sav, key, FALSE));
4462 av_push(av, newSViv(rev));
4463 }
4464
daba3364 4465 (void)hv_stores(MUTABLE_HV(hv), "version", newRV_noinc(MUTABLE_SV(av)));
d7aa5382
JP		 4466 return rv;
4467 }
ad63d80f 4468#ifdef SvVOK
4f2da183 4469 {
3c21775b 4470 const MAGIC* const mg = SvVSTRING_mg(ver);
4f2da183
NC		 4471 if ( mg ) { /* already a v-string */
4472 const STRLEN len = mg->mg_len;
4473 char * const version = savepvn( (const char*)mg->mg_ptr, len);
4474 sv_setpvn(rv,version,len);
8cb289bd
RGS		 4475 /* this is for consistency with the pure Perl class */
4476 if ( *version != 'v' )
4477 sv_insert(rv, 0, 0, "v", 1);
4f2da183
NC		 4478 Safefree(version);
4479 }
4480 else {
ad63d80f 4481#endif
4f2da183 4482 sv_setsv(rv,ver); /* make a duplicate */
137d6fc0 4483#ifdef SvVOK
4f2da183 4484 }
26ec6fc3 4485 }
137d6fc0 4486#endif
ac0e6a2f 4487 return upg_version(rv, FALSE);
b0f01acb
JP		 4488}
4489
4490/*
4491=for apidoc upg_version
4492
4493In-place upgrade of the supplied SV to a version object.
4494
ac0e6a2f 4495 SV *sv = upg_version(SV *sv, bool qv);
b0f01acb 4496
ac0e6a2f
RGS		 4497Returns a pointer to the upgraded SV. Set the boolean qv if you want
4498to force this SV to be interpreted as an "extended" version.
b0f01acb
JP		 4499
4500=cut
4501*/
4502
4503SV *
ac0e6a2f 4504Perl_upg_version(pTHX_ SV *ver, bool qv)
b0f01acb 4505{
cd57dc11 4506 const char *version, *s;
4f2da183
NC		 4507#ifdef SvVOK
4508 const MAGIC *mg;
4509#endif
137d6fc0 4510
7918f24d
NC		 4511 PERL_ARGS_ASSERT_UPG_VERSION;
4512
ac0e6a2f 4513 if ( SvNOK(ver) && !( SvPOK(ver) && sv_len(ver) == 3 ) )
137d6fc0 4514 {
ac0e6a2f 4515 /* may get too much accuracy */
137d6fc0 4516 char tbuf[64];
b5b5a8f0
RGS		 4517#ifdef USE_LOCALE_NUMERIC
4518 char *loc = setlocale(LC_NUMERIC, "C");
4519#endif
63e3af20 4520 STRLEN len = my_snprintf(tbuf, sizeof(tbuf), "%.9"NVff, SvNVX(ver));
b5b5a8f0
RGS		 4521#ifdef USE_LOCALE_NUMERIC
4522 setlocale(LC_NUMERIC, loc);
4523#endif
c8a14fb6 4524 while (tbuf[len-1] == '0' && len > 0) len--;
8cb289bd 4525 if ( tbuf[len-1] == '.' ) len--; /* eat the trailing decimal */
86c11942 4526 version = savepvn(tbuf, len);
137d6fc0 4527 }
ad63d80f 4528#ifdef SvVOK
666cce26 4529 else if ( (mg = SvVSTRING_mg(ver)) ) { /* already a v-string */
ad63d80f 4530 version = savepvn( (const char*)mg->mg_ptr,mg->mg_len );
137d6fc0 4531 qv = 1;
b0f01acb 4532 }
ad63d80f 4533#endif
137d6fc0
JP		 4534 else /* must be a string or something like a string */
4535 {
ac0e6a2f
RGS		 4536 STRLEN len;
4537 version = savepv(SvPV(ver,len));
4538#ifndef SvVOK
4539# if PERL_VERSION > 5
4540 /* This will only be executed for 5.6.0 - 5.8.0 inclusive */
4541 if ( len == 3 && !instr(version,".") && !instr(version,"_") ) {
4542 /* may be a v-string */
4543 SV * const nsv = sv_newmortal();
4544 const char *nver;
4545 const char *pos;
4546 int saw_period = 0;
8cb289bd 4547 sv_setpvf(nsv,"v%vd",ver);
ac0e6a2f
RGS		 4548 pos = nver = savepv(SvPV_nolen(nsv));
4549
4550 /* scan the resulting formatted string */
8cb289bd 4551 pos++; /* skip the leading 'v' */
ac0e6a2f
RGS		 4552 while ( *pos == '.' || isDIGIT(*pos) ) {
4553 if ( *pos == '.' )
4554 saw_period++ ;
4555 pos++;
4556 }
4557
4558 /* is definitely a v-string */
4559 if ( saw_period == 2 ) {
4560 Safefree(version);
4561 version = nver;
4562 }
4563 }
4564# endif
4565#endif
137d6fc0 4566 }
92dcf8ce 4567
cd57dc11 4568 s = scan_version(version, ver, qv);
808ee47e 4569 if ( *s != '\0' )
92dcf8ce 4570 if(ckWARN(WARN_MISC))
808ee47e 4571 Perl_warner(aTHX_ packWARN(WARN_MISC),
92dcf8ce
JP		 4572 "Version string '%s' contains invalid data; "
4573 "ignoring: '%s'", version, s);
137d6fc0 4574 Safefree(version);
ad63d80f 4575 return ver;
b0f01acb
JP		 4576}
4577
e0218a61
JP		 4578/*
4579=for apidoc vverify
4580
4581Validates that the SV contains a valid version object.
4582
4583 bool vverify(SV *vobj);
4584
4585Note that it only confirms the bare minimum structure (so as not to get
4586confused by derived classes which may contain additional hash entries):
4587
4588=over 4
4589
cb5772bb 4590=item * The SV contains a [reference to a] hash
e0218a61
JP		 4591
4592=item * The hash contains a "version" key
4593
cb5772bb 4594=item * The "version" key has [a reference to] an AV as its value
e0218a61
JP		 4595
4596=back
4597
4598=cut
4599*/
4600
4601bool
4602Perl_vverify(pTHX_ SV *vs)
4603{
4604 SV *sv;
7918f24d
NC		 4605
4606 PERL_ARGS_ASSERT_VVERIFY;
4607
e0218a61
JP		 4608 if ( SvROK(vs) )
4609 vs = SvRV(vs);
4610
4611 /* see if the appropriate elements exist */
4612 if ( SvTYPE(vs) == SVt_PVHV
ef8f7699
NC		 4613 && hv_exists(MUTABLE_HV(vs), "version", 7)
4614 && (sv = SvRV(*hv_fetchs(MUTABLE_HV(vs), "version", FALSE)))
e0218a61
JP		 4615 && SvTYPE(sv) == SVt_PVAV )
4616 return TRUE;
4617 else
4618 return FALSE;
4619}
b0f01acb
JP		 4620
4621/*
4622=for apidoc vnumify
4623
ad63d80f
JP		 4624Accepts a version object and returns the normalized floating
4625point representation. Call like:
b0f01acb 4626
ad63d80f 4627 sv = vnumify(rv);
b0f01acb 4628
ad63d80f
JP		 4629NOTE: you can pass either the object directly or the SV
4630contained within the RV.
b0f01acb
JP		 4631
4632=cut
4633*/
4634
4635SV *
ad63d80f 4636Perl_vnumify(pTHX_ SV *vs)
b0f01acb 4637{
ad63d80f 4638 I32 i, len, digit;
9137345a
JP		 4639 int width;
4640 bool alpha = FALSE;
53c1dcc0 4641 SV * const sv = newSV(0);
9137345a 4642 AV *av;
7918f24d
NC		 4643
4644 PERL_ARGS_ASSERT_VNUMIFY;
4645
ad63d80f
JP		 4646 if ( SvROK(vs) )
4647 vs = SvRV(vs);
9137345a 4648
e0218a61
JP		 4649 if ( !vverify(vs) )
4650 Perl_croak(aTHX_ "Invalid version object");
4651
9137345a 4652 /* see if various flags exist */
ef8f7699 4653 if ( hv_exists(MUTABLE_HV(vs), "alpha", 5 ) )
9137345a 4654 alpha = TRUE;
ef8f7699
NC		 4655 if ( hv_exists(MUTABLE_HV(vs), "width", 5 ) )
4656 width = SvIV(*hv_fetchs(MUTABLE_HV(vs), "width", FALSE));
9137345a
JP		 4657 else
4658 width = 3;
4659
4660
4661 /* attempt to retrieve the version array */
502c6561 4662 if ( !(av = MUTABLE_AV(SvRV(*hv_fetchs(MUTABLE_HV(vs), "version", FALSE))) ) ) {
396482e1 4663 sv_catpvs(sv,"0");
9137345a
JP		 4664 return sv;
4665 }
4666
4667 len = av_len(av);
46314c13
JP		 4668 if ( len == -1 )
4669 {
396482e1 4670 sv_catpvs(sv,"0");
46314c13
JP		 4671 return sv;
4672 }
9137345a
JP		 4673
4674 digit = SvIV(*av_fetch(av, 0, 0));
261fcdab 4675 Perl_sv_setpvf(aTHX_ sv, "%d.", (int)PERL_ABS(digit));
13f8f398 4676 for ( i = 1 ; i < len ; i++ )
b0f01acb 4677 {
9137345a
JP		 4678 digit = SvIV(*av_fetch(av, i, 0));
4679 if ( width < 3 ) {
43eaf59d 4680 const int denom = (width == 2 ? 10 : 100);
53c1dcc0 4681 const div_t term = div((int)PERL_ABS(digit),denom);
261fcdab 4682 Perl_sv_catpvf(aTHX_ sv, "%0*d_%d", width, term.quot, term.rem);
9137345a
JP		 4683 }
4684 else {
261fcdab 4685 Perl_sv_catpvf(aTHX_ sv, "%0*d", width, (int)digit);
9137345a 4686 }
b0f01acb 4687 }
13f8f398
JP		 4688
4689 if ( len > 0 )
4690 {
9137345a
JP		 4691 digit = SvIV(*av_fetch(av, len, 0));
4692 if ( alpha && width == 3 ) /* alpha version */
396482e1 4693 sv_catpvs(sv,"_");
261fcdab 4694 Perl_sv_catpvf(aTHX_ sv, "%0*d", width, (int)digit);
13f8f398 4695 }
e0218a61 4696 else /* len == 0 */
13f8f398 4697 {
396482e1 4698 sv_catpvs(sv, "000");
13f8f398 4699 }
b0f01acb
JP		 4700 return sv;
4701}
4702
4703/*
b9381830 4704=for apidoc vnormal
b0f01acb 4705
ad63d80f
JP		 4706Accepts a version object and returns the normalized string
4707representation. Call like:
b0f01acb 4708
b9381830 4709 sv = vnormal(rv);
b0f01acb 4710
ad63d80f
JP		 4711NOTE: you can pass either the object directly or the SV
4712contained within the RV.
b0f01acb
JP		 4713
4714=cut
4715*/
4716
4717SV *
b9381830 4718Perl_vnormal(pTHX_ SV *vs)
b0f01acb 4719{
ad63d80f 4720 I32 i, len, digit;
9137345a 4721 bool alpha = FALSE;
2d03de9c 4722 SV * const sv = newSV(0);
9137345a 4723 AV *av;
7918f24d
NC		 4724
4725 PERL_ARGS_ASSERT_VNORMAL;
4726
ad63d80f
JP		 4727 if ( SvROK(vs) )
4728 vs = SvRV(vs);
9137345a 4729
e0218a61
JP		 4730 if ( !vverify(vs) )
4731 Perl_croak(aTHX_ "Invalid version object");
4732
ef8f7699 4733 if ( hv_exists(MUTABLE_HV(vs), "alpha", 5 ) )
9137345a 4734 alpha = TRUE;
502c6561 4735 av = MUTABLE_AV(SvRV(*hv_fetchs(MUTABLE_HV(vs), "version", FALSE)));
9137345a
JP		 4736
4737 len = av_len(av);
e0218a61
JP		 4738 if ( len == -1 )
4739 {
396482e1 4740 sv_catpvs(sv,"");
46314c13
JP		 4741 return sv;
4742 }
9137345a 4743 digit = SvIV(*av_fetch(av, 0, 0));
261fcdab 4744 Perl_sv_setpvf(aTHX_ sv, "v%"IVdf, (IV)digit);
cb5772bb 4745 for ( i = 1 ; i < len ; i++ ) {
9137345a 4746 digit = SvIV(*av_fetch(av, i, 0));
261fcdab 4747 Perl_sv_catpvf(aTHX_ sv, ".%"IVdf, (IV)digit);
9137345a
JP		 4748 }
4749
e0218a61
JP		 4750 if ( len > 0 )
4751 {
9137345a
JP		 4752 /* handle last digit specially */
4753 digit = SvIV(*av_fetch(av, len, 0));
4754 if ( alpha )
261fcdab 4755 Perl_sv_catpvf(aTHX_ sv, "_%"IVdf, (IV)digit);
ad63d80f 4756 else
261fcdab 4757 Perl_sv_catpvf(aTHX_ sv, ".%"IVdf, (IV)digit);
b0f01acb 4758 }
9137345a 4759
137d6fc0
JP		 4760 if ( len <= 2 ) { /* short version, must be at least three */
4761 for ( len = 2 - len; len != 0; len-- )
396482e1 4762 sv_catpvs(sv,".0");
137d6fc0 4763 }
b0f01acb 4764 return sv;
9137345a 4765}
b0f01acb 4766
ad63d80f 4767/*
b9381830
JP		 4768=for apidoc vstringify
4769
4770In order to maintain maximum compatibility with earlier versions
4771of Perl, this function will return either the floating point
4772notation or the multiple dotted notation, depending on whether
4773the original version contained 1 or more dots, respectively
4774
4775=cut
4776*/
4777
4778SV *
4779Perl_vstringify(pTHX_ SV *vs)
4780{
7918f24d
NC		 4781 PERL_ARGS_ASSERT_VSTRINGIFY;
4782
b9381830
JP		 4783 if ( SvROK(vs) )
4784 vs = SvRV(vs);
219bf418 4785
e0218a61
JP		 4786 if ( !vverify(vs) )
4787 Perl_croak(aTHX_ "Invalid version object");
4788
ef8f7699 4789 if (hv_exists(MUTABLE_HV(vs), "original", sizeof("original") - 1)) {
219bf418 4790 SV *pv;
ef8f7699 4791 pv = *hv_fetchs(MUTABLE_HV(vs), "original", FALSE);
219bf418
RGS		 4792 if ( SvPOK(pv) )
4793 return newSVsv(pv);
4794 else
4795 return &PL_sv_undef;
4796 }
4797 else {
ef8f7699 4798 if ( hv_exists(MUTABLE_HV(vs), "qv", 2) )
219bf418
RGS		 4799 return vnormal(vs);
4800 else
4801 return vnumify(vs);
4802 }
b9381830
JP		 4803}
4804
4805/*
ad63d80f
JP		 4806=for apidoc vcmp
4807
4808Version object aware cmp. Both operands must already have been
4809converted into version objects.
4810
4811=cut
4812*/
4813
4814int
9137345a 4815Perl_vcmp(pTHX_ SV *lhv, SV *rhv)
ad63d80f
JP		 4816{
4817 I32 i,l,m,r,retval;
9137345a
JP		 4818 bool lalpha = FALSE;
4819 bool ralpha = FALSE;
4820 I32 left = 0;
4821 I32 right = 0;
4822 AV *lav, *rav;
7918f24d
NC		 4823
4824 PERL_ARGS_ASSERT_VCMP;
4825
9137345a
JP		 4826 if ( SvROK(lhv) )
4827 lhv = SvRV(lhv);
4828 if ( SvROK(rhv) )
4829 rhv = SvRV(rhv);
4830
e0218a61
JP		 4831 if ( !vverify(lhv) )
4832 Perl_croak(aTHX_ "Invalid version object");
4833
4834 if ( !vverify(rhv) )
4835 Perl_croak(aTHX_ "Invalid version object");
4836
9137345a 4837 /* get the left hand term */
502c6561 4838 lav = MUTABLE_AV(SvRV(*hv_fetchs(MUTABLE_HV(lhv), "version", FALSE)));
ef8f7699 4839 if ( hv_exists(MUTABLE_HV(lhv), "alpha", 5 ) )
9137345a
JP		 4840 lalpha = TRUE;
4841
4842 /* and the right hand term */
502c6561 4843 rav = MUTABLE_AV(SvRV(*hv_fetchs(MUTABLE_HV(rhv), "version", FALSE)));
ef8f7699 4844 if ( hv_exists(MUTABLE_HV(rhv), "alpha", 5 ) )
9137345a
JP		 4845 ralpha = TRUE;
4846
4847 l = av_len(lav);
4848 r = av_len(rav);
ad63d80f
JP		 4849 m = l < r ? l : r;
4850 retval = 0;
4851 i = 0;
4852 while ( i <= m && retval == 0 )
4853 {
9137345a
JP		 4854 left = SvIV(*av_fetch(lav,i,0));
4855 right = SvIV(*av_fetch(rav,i,0));
4856 if ( left < right )
ad63d80f 4857 retval = -1;
9137345a 4858 if ( left > right )
ad63d80f
JP		 4859 retval = +1;
4860 i++;
4861 }
4862
9137345a
JP		 4863 /* tiebreaker for alpha with identical terms */
4864 if ( retval == 0 && l == r && left == right && ( lalpha || ralpha ) )
4865 {
4866 if ( lalpha && !ralpha )
4867 {
4868 retval = -1;
4869 }
4870 else if ( ralpha && !lalpha)
4871 {
4872 retval = +1;
4873 }
4874 }
4875
137d6fc0 4876 if ( l != r && retval == 0 ) /* possible match except for trailing 0's */
129318bd 4877 {
137d6fc0 4878 if ( l < r )
129318bd 4879 {
137d6fc0
JP		 4880 while ( i <= r && retval == 0 )
4881 {
9137345a 4882 if ( SvIV(*av_fetch(rav,i,0)) != 0 )
137d6fc0
JP		 4883 retval = -1; /* not a match after all */
4884 i++;
4885 }
4886 }
4887 else
4888 {
4889 while ( i <= l && retval == 0 )
4890 {
9137345a 4891 if ( SvIV(*av_fetch(lav,i,0)) != 0 )
137d6fc0
JP		 4892 retval = +1; /* not a match after all */
4893 i++;
4894 }
129318bd
JP		 4895 }
4896 }
ad63d80f
JP		 4897 return retval;
4898}
4899
c95c94b1 4900#if !defined(HAS_SOCKETPAIR) && defined(HAS_SOCKET) && defined(AF_INET) && defined(PF_INET) && defined(SOCK_DGRAM) && defined(HAS_SELECT)
2bc69dc4
NIS		 4901# define EMULATE_SOCKETPAIR_UDP
4902#endif
4903
4904#ifdef EMULATE_SOCKETPAIR_UDP
02fc2eee
NC		 4905static int
4906S_socketpair_udp (int fd[2]) {
e10bb1e9 4907 dTHX;
02fc2eee
NC		 4908 /* Fake a datagram socketpair using UDP to localhost. */
4909 int sockets[2] = {-1, -1};
4910 struct sockaddr_in addresses[2];
4911 int i;
3aed30dc 4912 Sock_size_t size = sizeof(struct sockaddr_in);
ae92b34e 4913 unsigned short port;
02fc2eee
NC		 4914 int got;
4915
3aed30dc 4916 memset(&addresses, 0, sizeof(addresses));
02fc2eee
NC		 4917 i = 1;
4918 do {
3aed30dc
HS		 4919 sockets[i] = PerlSock_socket(AF_INET, SOCK_DGRAM, PF_INET);
4920 if (sockets[i] == -1)
4921 goto tidy_up_and_fail;
4922
4923 addresses[i].sin_family = AF_INET;
4924 addresses[i].sin_addr.s_addr = htonl(INADDR_LOOPBACK);
4925 addresses[i].sin_port = 0; /* kernel choses port. */
4926 if (PerlSock_bind(sockets[i], (struct sockaddr *) &addresses[i],
4927 sizeof(struct sockaddr_in)) == -1)
4928 goto tidy_up_and_fail;
02fc2eee
NC		 4929 } while (i--);
4930
4931 /* Now have 2 UDP sockets. Find out which port each is connected to, and
4932 for each connect the other socket to it. */
4933 i = 1;
4934 do {
3aed30dc
HS		 4935 if (PerlSock_getsockname(sockets[i], (struct sockaddr *) &addresses[i],
4936 &size) == -1)
4937 goto tidy_up_and_fail;
4938 if (size != sizeof(struct sockaddr_in))
4939 goto abort_tidy_up_and_fail;
4940 /* !1 is 0, !0 is 1 */
4941 if (PerlSock_connect(sockets[!i], (struct sockaddr *) &addresses[i],
4942 sizeof(struct sockaddr_in)) == -1)
4943 goto tidy_up_and_fail;
02fc2eee
NC		 4944 } while (i--);
4945
4946 /* Now we have 2 sockets connected to each other. I don't trust some other
4947 process not to have already sent a packet to us (by random) so send
4948 a packet from each to the other. */
4949 i = 1;
4950 do {
3aed30dc
HS		 4951 /* I'm going to send my own port number. As a short.
4952 (Who knows if someone somewhere has sin_port as a bitfield and needs
4953 this routine. (I'm assuming crays have socketpair)) */
4954 port = addresses[i].sin_port;
4955 got = PerlLIO_write(sockets[i], &port, sizeof(port));
4956 if (got != sizeof(port)) {
4957 if (got == -1)
4958 goto tidy_up_and_fail;
4959 goto abort_tidy_up_and_fail;
4960 }
02fc2eee
NC		 4961 } while (i--);
4962
4963 /* Packets sent. I don't trust them to have arrived though.
4964 (As I understand it Solaris TCP stack is multithreaded. Non-blocking
4965 connect to localhost will use a second kernel thread. In 2.6 the
4966 first thread running the connect() returns before the second completes,
4967 so EINPROGRESS> In 2.7 the improved stack is faster and connect()
4968 returns 0. Poor programs have tripped up. One poor program's authors'
4969 had a 50-1 reverse stock split. Not sure how connected these were.)
4970 So I don't trust someone not to have an unpredictable UDP stack.
4971 */
4972
4973 {
3aed30dc
HS		 4974 struct timeval waitfor = {0, 100000}; /* You have 0.1 seconds */
4975 int max = sockets[1] > sockets[0] ? sockets[1] : sockets[0];
4976 fd_set rset;
4977
4978 FD_ZERO(&rset);
ea407a0c
NC		 4979 FD_SET((unsigned int)sockets[0], &rset);
4980 FD_SET((unsigned int)sockets[1], &rset);
3aed30dc
HS		 4981
4982 got = PerlSock_select(max + 1, &rset, NULL, NULL, &waitfor);
4983 if (got != 2 || !FD_ISSET(sockets[0], &rset)
4984 || !FD_ISSET(sockets[1], &rset)) {
4985 /* I hope this is portable and appropriate. */
4986 if (got == -1)
4987 goto tidy_up_and_fail;
4988 goto abort_tidy_up_and_fail;
4989 }
02fc2eee 4990 }
f4758303 4991
02fc2eee
NC		 4992 /* And the paranoia department even now doesn't trust it to have arrive
4993 (hence MSG_DONTWAIT). Or that what arrives was sent by us. */
4994 {
3aed30dc
HS		 4995 struct sockaddr_in readfrom;
4996 unsigned short buffer[2];
02fc2eee 4997
3aed30dc
HS		 4998 i = 1;
4999 do {
02fc2eee 5000#ifdef MSG_DONTWAIT
3aed30dc
HS		 5001 got = PerlSock_recvfrom(sockets[i], (char *) &buffer,
5002 sizeof(buffer), MSG_DONTWAIT,
5003 (struct sockaddr *) &readfrom, &size);
02fc2eee 5004#else
3aed30dc
HS		 5005 got = PerlSock_recvfrom(sockets[i], (char *) &buffer,
5006 sizeof(buffer), 0,
5007 (struct sockaddr *) &readfrom, &size);
e10bb1e9 5008#endif
02fc2eee 5009
3aed30dc
HS		 5010 if (got == -1)
5011 goto tidy_up_and_fail;
5012 if (got != sizeof(port)
5013 || size != sizeof(struct sockaddr_in)
5014 /* Check other socket sent us its port. */
5015 || buffer[0] != (unsigned short) addresses[!i].sin_port
5016 /* Check kernel says we got the datagram from that socket */
5017 || readfrom.sin_family != addresses[!i].sin_family
5018 || readfrom.sin_addr.s_addr != addresses[!i].sin_addr.s_addr
5019 || readfrom.sin_port != addresses[!i].sin_port)
5020 goto abort_tidy_up_and_fail;
5021 } while (i--);
02fc2eee
NC		 5022 }
5023 /* My caller (my_socketpair) has validated that this is non-NULL */
5024 fd[0] = sockets[0];
5025 fd[1] = sockets[1];
5026 /* I hereby declare this connection open. May God bless all who cross
5027 her. */
5028 return 0;
5029
5030 abort_tidy_up_and_fail:
5031 errno = ECONNABORTED;
5032 tidy_up_and_fail:
5033 {
4ee39169 5034 dSAVE_ERRNO;
3aed30dc
HS		 5035 if (sockets[0] != -1)
5036 PerlLIO_close(sockets[0]);
5037 if (sockets[1] != -1)
5038 PerlLIO_close(sockets[1]);
4ee39169 5039 RESTORE_ERRNO;
3aed30dc 5040 return -1;
02fc2eee
NC		 5041 }
5042}
85ca448a 5043#endif /* EMULATE_SOCKETPAIR_UDP */
02fc2eee 5044
b5ac89c3 5045#if !defined(HAS_SOCKETPAIR) && defined(HAS_SOCKET) && defined(AF_INET) && defined(PF_INET)
02fc2eee
NC		 5046int
5047Perl_my_socketpair (int family, int type, int protocol, int fd[2]) {
5048 /* Stevens says that family must be AF_LOCAL, protocol 0.
2948e0bd 5049 I'm going to enforce that, then ignore it, and use TCP (or UDP). */
e10bb1e9 5050 dTHX;
02fc2eee
NC		 5051 int listener = -1;
5052 int connector = -1;
5053 int acceptor = -1;
5054 struct sockaddr_in listen_addr;
5055 struct sockaddr_in connect_addr;
5056 Sock_size_t size;
5057
50458334
JH		 5058 if (protocol
5059#ifdef AF_UNIX
5060 || family != AF_UNIX
5061#endif
3aed30dc
HS		 5062 ) {
5063 errno = EAFNOSUPPORT;
5064 return -1;
02fc2eee 5065 }
2948e0bd 5066 if (!fd) {
3aed30dc
HS		 5067 errno = EINVAL;
5068 return -1;
2948e0bd 5069 }
02fc2eee 5070
2bc69dc4 5071#ifdef EMULATE_SOCKETPAIR_UDP
02fc2eee 5072 if (type == SOCK_DGRAM)
3aed30dc 5073 return S_socketpair_udp(fd);
2bc69dc4 5074#endif
02fc2eee 5075
3aed30dc 5076 listener = PerlSock_socket(AF_INET, type, 0);
02fc2eee 5077 if (listener == -1)
3aed30dc
HS		 5078 return -1;
5079 memset(&listen_addr, 0, sizeof(listen_addr));
02fc2eee 5080 listen_addr.sin_family = AF_INET;
3aed30dc 5081 listen_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
02fc2eee 5082 listen_addr.sin_port = 0; /* kernel choses port. */
3aed30dc
HS		 5083 if (PerlSock_bind(listener, (struct sockaddr *) &listen_addr,
5084 sizeof(listen_addr)) == -1)
5085 goto tidy_up_and_fail;
e10bb1e9 5086 if (PerlSock_listen(listener, 1) == -1)
3aed30dc 5087 goto tidy_up_and_fail;
02fc2eee 5088
3aed30dc 5089 connector = PerlSock_socket(AF_INET, type, 0);
02fc2eee 5090 if (connector == -1)
3aed30dc 5091 goto tidy_up_and_fail;
02fc2eee 5092 /* We want to find out the port number to connect to. */
3aed30dc
HS		 5093 size = sizeof(connect_addr);
5094 if (PerlSock_getsockname(listener, (struct sockaddr *) &connect_addr,
5095 &size) == -1)
5096 goto tidy_up_and_fail;
5097 if (size != sizeof(connect_addr))
5098 goto abort_tidy_up_and_fail;
e10bb1e9 5099 if (PerlSock_connect(connector, (struct sockaddr *) &connect_addr,
3aed30dc
HS		 5100 sizeof(connect_addr)) == -1)
5101 goto tidy_up_and_fail;
02fc2eee 5102
3aed30dc
HS		 5103 size = sizeof(listen_addr);
5104 acceptor = PerlSock_accept(listener, (struct sockaddr *) &listen_addr,
5105 &size);
02fc2eee 5106 if (acceptor == -1)
3aed30dc
HS		 5107 goto tidy_up_and_fail;
5108 if (size != sizeof(listen_addr))
5109 goto abort_tidy_up_and_fail;
5110 PerlLIO_close(listener);
02fc2eee
NC		 5111 /* Now check we are talking to ourself by matching port and host on the
5112 two sockets. */
3aed30dc
HS		 5113 if (PerlSock_getsockname(connector, (struct sockaddr *) &connect_addr,
5114 &size) == -1)
5115 goto tidy_up_and_fail;
5116 if (size != sizeof(connect_addr)
5117 || listen_addr.sin_family != connect_addr.sin_family
5118 || listen_addr.sin_addr.s_addr != connect_addr.sin_addr.s_addr
5119 || listen_addr.sin_port != connect_addr.sin_port) {
5120 goto abort_tidy_up_and_fail;
02fc2eee
NC		 5121 }
5122 fd[0] = connector;
5123 fd[1] = acceptor;
5124 return 0;
5125
5126 abort_tidy_up_and_fail:
27da23d5
JH		 5127#ifdef ECONNABORTED
5128 errno = ECONNABORTED; /* This would be the standard thing to do. */
5129#else
5130# ifdef ECONNREFUSED
5131 errno = ECONNREFUSED; /* E.g. Symbian does not have ECONNABORTED. */
5132# else
5133 errno = ETIMEDOUT; /* Desperation time. */
5134# endif
5135#endif
02fc2eee
NC		 5136 tidy_up_and_fail:
5137 {
4ee39169 5138 dSAVE_ERRNO;
3aed30dc
HS		 5139 if (listener != -1)
5140 PerlLIO_close(listener);
5141 if (connector != -1)
5142 PerlLIO_close(connector);
5143 if (acceptor != -1)
5144 PerlLIO_close(acceptor);
4ee39169 5145 RESTORE_ERRNO;
3aed30dc 5146 return -1;
02fc2eee
NC		 5147 }
5148}
85ca448a 5149#else
48ea76d1
JH		 5150/* In any case have a stub so that there's code corresponding
5151 * to the my_socketpair in global.sym. */
5152int
5153Perl_my_socketpair (int family, int type, int protocol, int fd[2]) {
daf16542 5154#ifdef HAS_SOCKETPAIR
48ea76d1 5155 return socketpair(family, type, protocol, fd);
daf16542
JH		 5156#else
5157 return -1;
5158#endif
48ea76d1
JH		 5159}
5160#endif
5161
68795e93
NIS		 5162/*
5163
5164=for apidoc sv_nosharing
5165
5166Dummy routine which "shares" an SV when there is no sharing module present.
d5b2b27b
NC		 5167Or "locks" it. Or "unlocks" it. In other words, ignores its single SV argument.
5168Exists to avoid test for a NULL function pointer and because it could
5169potentially warn under some level of strict-ness.
68795e93
NIS		 5170
5171=cut
5172*/
5173
5174void
5175Perl_sv_nosharing(pTHX_ SV *sv)
5176{
96a5add6 5177 PERL_UNUSED_CONTEXT;
53c1dcc0 5178 PERL_UNUSED_ARG(sv);
68795e93
NIS		 5179}
5180
eba16661
JH		 5181/*
5182
5183=for apidoc sv_destroyable
5184
5185Dummy routine which reports that object can be destroyed when there is no
5186sharing module present. It ignores its single SV argument, and returns
5187'true'. Exists to avoid test for a NULL function pointer and because it
5188could potentially warn under some level of strict-ness.
5189
5190=cut
5191*/
5192
5193bool
5194Perl_sv_destroyable(pTHX_ SV *sv)
5195{
5196 PERL_UNUSED_CONTEXT;
5197 PERL_UNUSED_ARG(sv);
5198 return TRUE;
5199}
5200
a05d7ebb 5201U32
e1ec3a88 5202Perl_parse_unicode_opts(pTHX_ const char **popt)
a05d7ebb 5203{
e1ec3a88 5204 const char *p = *popt;
a05d7ebb
JH		 5205 U32 opt = 0;
5206
7918f24d
NC		 5207 PERL_ARGS_ASSERT_PARSE_UNICODE_OPTS;
5208
a05d7ebb
JH		 5209 if (*p) {
5210 if (isDIGIT(*p)) {
5211 opt = (U32) atoi(p);
35da51f7
AL		 5212 while (isDIGIT(*p))
5213 p++;
7c91f477 5214 if (*p && *p != '\n' && *p != '\r')
a05d7ebb
JH		 5215 Perl_croak(aTHX_ "Unknown Unicode option letter '%c'", *p);
5216 }
5217 else {
5218 for (; *p; p++) {
5219 switch (*p) {
5220 case PERL_UNICODE_STDIN:
5221 opt |= PERL_UNICODE_STDIN_FLAG; break;
5222 case PERL_UNICODE_STDOUT:
5223 opt |= PERL_UNICODE_STDOUT_FLAG; break;
5224 case PERL_UNICODE_STDERR:
5225 opt |= PERL_UNICODE_STDERR_FLAG; break;
5226 case PERL_UNICODE_STD:
5227 opt |= PERL_UNICODE_STD_FLAG; break;
5228 case PERL_UNICODE_IN:
5229 opt |= PERL_UNICODE_IN_FLAG; break;
5230 case PERL_UNICODE_OUT:
5231 opt |= PERL_UNICODE_OUT_FLAG; break;
5232 case PERL_UNICODE_INOUT:
5233 opt |= PERL_UNICODE_INOUT_FLAG; break;
5234 case PERL_UNICODE_LOCALE:
5235 opt |= PERL_UNICODE_LOCALE_FLAG; break;
5236 case PERL_UNICODE_ARGV:
5237 opt |= PERL_UNICODE_ARGV_FLAG; break;
5a22a2bb
NC		 5238 case PERL_UNICODE_UTF8CACHEASSERT:
5239 opt |= PERL_UNICODE_UTF8CACHEASSERT_FLAG; break;
a05d7ebb 5240 default:
7c91f477
JH		 5241 if (*p != '\n' && *p != '\r')
5242 Perl_croak(aTHX_
5243 "Unknown Unicode option letter '%c'", *p);
a05d7ebb
JH		 5244 }
5245 }
5246 }
5247 }
5248 else
5249 opt = PERL_UNICODE_DEFAULT_FLAGS;
5250
5251 if (opt & ~PERL_UNICODE_ALL_FLAGS)
06e66572 5252 Perl_croak(aTHX_ "Unknown Unicode option value %"UVuf,
a05d7ebb
JH		 5253 (UV) (opt & ~PERL_UNICODE_ALL_FLAGS));
5254
5255 *popt = p;
5256
5257 return opt;
5258}
5259
132efe8b
JH		 5260U32
5261Perl_seed(pTHX)
5262{
97aff369 5263 dVAR;
132efe8b
JH		 5264 /*
5265 * This is really just a quick hack which grabs various garbage
5266 * values. It really should be a real hash algorithm which
5267 * spreads the effect of every input bit onto every output bit,
5268 * if someone who knows about such things would bother to write it.
5269 * Might be a good idea to add that function to CORE as well.
5270 * No numbers below come from careful analysis or anything here,
5271 * except they are primes and SEED_C1 > 1E6 to get a full-width
5272 * value from (tv_sec * SEED_C1 + tv_usec). The multipliers should
5273 * probably be bigger too.
5274 */
5275#if RANDBITS > 16
5276# define SEED_C1 1000003
5277#define SEED_C4 73819
5278#else
5279# define SEED_C1 25747
5280#define SEED_C4 20639
5281#endif
5282#define SEED_C2 3
5283#define SEED_C3 269
5284#define SEED_C5 26107
5285
5286#ifndef PERL_NO_DEV_RANDOM
5287 int fd;
5288#endif
5289 U32 u;
5290#ifdef VMS
5291# include <starlet.h>
5292 /* when[] = (low 32 bits, high 32 bits) of time since epoch
5293 * in 100-ns units, typically incremented ever 10 ms. */
5294 unsigned int when[2];
5295#else
5296# ifdef HAS_GETTIMEOFDAY
5297 struct timeval when;
5298# else
5299 Time_t when;
5300# endif
5301#endif
5302
5303/* This test is an escape hatch, this symbol isn't set by Configure. */
5304#ifndef PERL_NO_DEV_RANDOM
5305#ifndef PERL_RANDOM_DEVICE
5306 /* /dev/random isn't used by default because reads from it will block
5307 * if there isn't enough entropy available. You can compile with
5308 * PERL_RANDOM_DEVICE to it if you'd prefer Perl to block until there
5309 * is enough real entropy to fill the seed. */
5310# define PERL_RANDOM_DEVICE "/dev/urandom"
5311#endif
5312 fd = PerlLIO_open(PERL_RANDOM_DEVICE, 0);
5313 if (fd != -1) {
27da23d5 5314 if (PerlLIO_read(fd, (void*)&u, sizeof u) != sizeof u)
132efe8b
JH		 5315 u = 0;
5316 PerlLIO_close(fd);
5317 if (u)
5318 return u;
5319 }
5320#endif
5321
5322#ifdef VMS
5323 _ckvmssts(sys$gettim(when));
5324 u = (U32)SEED_C1 * when[0] + (U32)SEED_C2 * when[1];
5325#else
5326# ifdef HAS_GETTIMEOFDAY
5327 PerlProc_gettimeofday(&when,NULL);
5328 u = (U32)SEED_C1 * when.tv_sec + (U32)SEED_C2 * when.tv_usec;
5329# else
5330 (void)time(&when);
5331 u = (U32)SEED_C1 * when;
5332# endif
5333#endif
5334 u += SEED_C3 * (U32)PerlProc_getpid();
5335 u += SEED_C4 * (U32)PTR2UV(PL_stack_sp);
5336#ifndef PLAN9 /* XXX Plan9 assembler chokes on this; fix needed */
5337 u += SEED_C5 * (U32)PTR2UV(&when);
5338#endif
5339 return u;
5340}
5341
bed60192 5342UV
a783c5f4 5343Perl_get_hash_seed(pTHX)
bed60192 5344{
97aff369 5345 dVAR;
e1ec3a88 5346 const char *s = PerlEnv_getenv("PERL_HASH_SEED");
bed60192
JH		 5347 UV myseed = 0;
5348
5349 if (s)
35da51f7
AL		 5350 while (isSPACE(*s))
5351 s++;
bed60192
JH		 5352 if (s && isDIGIT(*s))
5353 myseed = (UV)Atoul(s);
5354 else
5355#ifdef USE_HASH_SEED_EXPLICIT
5356 if (s)
5357#endif
5358 {
5359 /* Compute a random seed */
5360 (void)seedDrand01((Rand_seed_t)seed());
bed60192
JH		 5361 myseed = (UV)(Drand01() * (NV)UV_MAX);
5362#if RANDBITS < (UVSIZE * 8)
5363 /* Since there are not enough randbits to to reach all
5364 * the bits of a UV, the low bits might need extra
5365 * help. Sum in another random number that will
5366 * fill in the low bits. */
5367 myseed +=
5368 (UV)(Drand01() * (NV)((1 << ((UVSIZE * 8 - RANDBITS))) - 1));
5369#endif /* RANDBITS < (UVSIZE * 8) */
6cfd5ea7
JH		 5370 if (myseed == 0) { /* Superparanoia. */
5371 myseed = (UV)(Drand01() * (NV)UV_MAX); /* One more chance. */
5372 if (myseed == 0)
5373 Perl_croak(aTHX_ "Your random numbers are not that random");
5374 }
bed60192 5375 }
008fb0c0 5376 PL_rehash_seed_set = TRUE;
bed60192
JH		 5377
5378 return myseed;
5379}
27da23d5 5380
ed221c57
AL		 5381#ifdef USE_ITHREADS
5382bool
5383Perl_stashpv_hvname_match(pTHX_ const COP *c, const HV *hv)
5384{
5385 const char * const stashpv = CopSTASHPV(c);
5386 const char * const name = HvNAME_get(hv);
96a5add6 5387 PERL_UNUSED_CONTEXT;
7918f24d 5388 PERL_ARGS_ASSERT_STASHPV_HVNAME_MATCH;
ed221c57
AL		 5389
5390 if (stashpv == name)
5391 return TRUE;
5392 if (stashpv && name)
5393 if (strEQ(stashpv, name))
5394 return TRUE;
5395 return FALSE;
5396}
5397#endif
5398
5399
27da23d5
JH		 5400#ifdef PERL_GLOBAL_STRUCT
5401
bae1192d
JH		 5402#define PERL_GLOBAL_STRUCT_INIT
5403#include "opcode.h" /* the ppaddr and check */
5404
27da23d5
JH		 5405struct perl_vars *
5406Perl_init_global_struct(pTHX)
5407{
5408 struct perl_vars *plvarsp = NULL;
bae1192d 5409# ifdef PERL_GLOBAL_STRUCT
7452cf6a
AL		 5410 const IV nppaddr = sizeof(Gppaddr)/sizeof(Perl_ppaddr_t);
5411 const IV ncheck = sizeof(Gcheck) /sizeof(Perl_check_t);
27da23d5
JH		 5412# ifdef PERL_GLOBAL_STRUCT_PRIVATE
5413 /* PerlMem_malloc() because can't use even safesysmalloc() this early. */
5414 plvarsp = (struct perl_vars*)PerlMem_malloc(sizeof(struct perl_vars));
5415 if (!plvarsp)
5416 exit(1);
5417# else
5418 plvarsp = PL_VarsPtr;
5419# endif /* PERL_GLOBAL_STRUCT_PRIVATE */
aadb217d
JH		 5420# undef PERLVAR
5421# undef PERLVARA
5422# undef PERLVARI
5423# undef PERLVARIC
5424# undef PERLVARISC
27da23d5
JH		 5425# define PERLVAR(var,type) /**/
5426# define PERLVARA(var,n,type) /**/
5427# define PERLVARI(var,type,init) plvarsp->var = init;
5428# define PERLVARIC(var,type,init) plvarsp->var = init;
5429# define PERLVARISC(var,init) Copy(init, plvarsp->var, sizeof(init), char);
5430# include "perlvars.h"
5431# undef PERLVAR
5432# undef PERLVARA
5433# undef PERLVARI
5434# undef PERLVARIC
5435# undef PERLVARISC
5436# ifdef PERL_GLOBAL_STRUCT
bae1192d
JH		 5437 plvarsp->Gppaddr =
5438 (Perl_ppaddr_t*)
5439 PerlMem_malloc(nppaddr * sizeof(Perl_ppaddr_t));
27da23d5
JH		 5440 if (!plvarsp->Gppaddr)
5441 exit(1);
bae1192d
JH		 5442 plvarsp->Gcheck =
5443 (Perl_check_t*)
5444 PerlMem_malloc(ncheck * sizeof(Perl_check_t));
27da23d5
JH		 5445 if (!plvarsp->Gcheck)
5446 exit(1);
5447 Copy(Gppaddr, plvarsp->Gppaddr, nppaddr, Perl_ppaddr_t);
5448 Copy(Gcheck, plvarsp->Gcheck, ncheck, Perl_check_t);
5449# endif
5450# ifdef PERL_SET_VARS
5451 PERL_SET_VARS(plvarsp);
5452# endif
bae1192d
JH		 5453# undef PERL_GLOBAL_STRUCT_INIT
5454# endif
27da23d5
JH		 5455 return plvarsp;
5456}
5457
5458#endif /* PERL_GLOBAL_STRUCT */
5459
5460#ifdef PERL_GLOBAL_STRUCT
5461
5462void
5463Perl_free_global_struct(pTHX_ struct perl_vars *plvarsp)
5464{
7918f24d 5465 PERL_ARGS_ASSERT_FREE_GLOBAL_STRUCT;
bae1192d 5466# ifdef PERL_GLOBAL_STRUCT
27da23d5
JH		 5467# ifdef PERL_UNSET_VARS
5468 PERL_UNSET_VARS(plvarsp);
5469# endif
5470 free(plvarsp->Gppaddr);
5471 free(plvarsp->Gcheck);
bae1192d 5472# ifdef PERL_GLOBAL_STRUCT_PRIVATE
27da23d5 5473 free(plvarsp);
bae1192d
JH		 5474# endif
5475# endif
27da23d5
JH		 5476}
5477
5478#endif /* PERL_GLOBAL_STRUCT */
5479
fe4f188c
JH		 5480#ifdef PERL_MEM_LOG
5481
1cd8acb5 5482/* -DPERL_MEM_LOG: the Perl_mem_log_..() is compiled, including the
73d1d973
JC		 5483 * the default implementation, unless -DPERL_MEM_LOG_NOIMPL is also
5484 * given, and you supply your own implementation.
65ceff02 5485 *
2e5b5004 5486 * The default implementation reads a single env var, PERL_MEM_LOG,
1cd8acb5
JC		 5487 * expecting one or more of the following:
5488 *
5489 * \d+ - fd fd to write to : must be 1st (atoi)
2e5b5004 5490 * 'm' - memlog was PERL_MEM_LOG=1
1cd8acb5
JC		 5491 * 's' - svlog was PERL_SV_LOG=1
5492 * 't' - timestamp was PERL_MEM_LOG_TIMESTAMP=1
0b0ab801 5493 *
1cd8acb5
JC		 5494 * This makes the logger controllable enough that it can reasonably be
5495 * added to the system perl.
65ceff02
JH		 5496 */
5497
1cd8acb5 5498/* -DPERL_MEM_LOG_SPRINTF_BUF_SIZE=X: size of a (stack-allocated) buffer
65ceff02
JH		 5499 * the Perl_mem_log_...() will use (either via sprintf or snprintf).
5500 */
e352bcff
JH		 5501#define PERL_MEM_LOG_SPRINTF_BUF_SIZE 128
5502
1cd8acb5
JC		 5503/* -DPERL_MEM_LOG_FD=N: the file descriptor the Perl_mem_log_...()
5504 * writes to. In the default logger, this is settable at runtime.
65ceff02
JH		 5505 */
5506#ifndef PERL_MEM_LOG_FD
5507# define PERL_MEM_LOG_FD 2 /* If STDERR is too boring for you. */
5508#endif
5509
73d1d973 5510#ifndef PERL_MEM_LOG_NOIMPL
d7a2c63c
MHM		 5511
5512# ifdef DEBUG_LEAKING_SCALARS
5513# define SV_LOG_SERIAL_FMT " [%lu]"
5514# define _SV_LOG_SERIAL_ARG(sv) , (unsigned long) (sv)->sv_debug_serial
5515# else
5516# define SV_LOG_SERIAL_FMT
5517# define _SV_LOG_SERIAL_ARG(sv)
5518# endif
5519
0b0ab801 5520static void
73d1d973
JC		 5521S_mem_log_common(enum mem_log_type mlt, const UV n,
5522 const UV typesize, const char *type_name, const SV *sv,
5523 Malloc_t oldalloc, Malloc_t newalloc,
5524 const char *filename, const int linenumber,
5525 const char *funcname)
0b0ab801 5526{
1cd8acb5 5527 const char *pmlenv;
4ca7bcef 5528
1cd8acb5 5529 PERL_ARGS_ASSERT_MEM_LOG_COMMON;
4ca7bcef 5530
1cd8acb5
JC		 5531 pmlenv = PerlEnv_getenv("PERL_MEM_LOG");
5532 if (!pmlenv)
5533 return;
5534 if (mlt < MLT_NEW_SV ? strchr(pmlenv,'m') : strchr(pmlenv,'s'))
65ceff02
JH		 5535 {
5536 /* We can't use SVs or PerlIO for obvious reasons,
5537 * so we'll use stdio and low-level IO instead. */
5538 char buf[PERL_MEM_LOG_SPRINTF_BUF_SIZE];
1cd8acb5 5539
5b692037 5540# ifdef HAS_GETTIMEOFDAY
0b0ab801
MHM		 5541# define MEM_LOG_TIME_FMT "%10d.%06d: "
5542# define MEM_LOG_TIME_ARG (int)tv.tv_sec, (int)tv.tv_usec
5543 struct timeval tv;
65ceff02 5544 gettimeofday(&tv, 0);
0b0ab801
MHM		 5545# else
5546# define MEM_LOG_TIME_FMT "%10d: "
5547# define MEM_LOG_TIME_ARG (int)when
5548 Time_t when;
5549 (void)time(&when);
5b692037
JH		 5550# endif
5551 /* If there are other OS specific ways of hires time than
40d04ec4 5552 * gettimeofday() (see ext/Time-HiRes), the easiest way is
5b692037
JH		 5553 * probably that they would be used to fill in the struct
5554 * timeval. */
65ceff02 5555 {
0b0ab801 5556 STRLEN len;
1cd8acb5
JC		 5557 int fd = atoi(pmlenv);
5558 if (!fd)
5559 fd = PERL_MEM_LOG_FD;
0b0ab801 5560
1cd8acb5 5561 if (strchr(pmlenv, 't')) {
0b0ab801
MHM		 5562 len = my_snprintf(buf, sizeof(buf),
5563 MEM_LOG_TIME_FMT, MEM_LOG_TIME_ARG);
5564 PerlLIO_write(fd, buf, len);
5565 }
0b0ab801
MHM		 5566 switch (mlt) {
5567 case MLT_ALLOC:
5568 len = my_snprintf(buf, sizeof(buf),
5569 "alloc: %s:%d:%s: %"IVdf" %"UVuf
5570 " %s = %"IVdf": %"UVxf"\n",
5571 filename, linenumber, funcname, n, typesize,
bef8a128 5572 type_name, n * typesize, PTR2UV(newalloc));
0b0ab801
MHM		 5573 break;
5574 case MLT_REALLOC:
5575 len = my_snprintf(buf, sizeof(buf),
5576 "realloc: %s:%d:%s: %"IVdf" %"UVuf
5577 " %s = %"IVdf": %"UVxf" -> %"UVxf"\n",
5578 filename, linenumber, funcname, n, typesize,
bef8a128 5579 type_name, n * typesize, PTR2UV(oldalloc),
0b0ab801
MHM		 5580 PTR2UV(newalloc));
5581 break;
5582 case MLT_FREE:
5583 len = my_snprintf(buf, sizeof(buf),
5584 "free: %s:%d:%s: %"UVxf"\n",
5585 filename, linenumber, funcname,
5586 PTR2UV(oldalloc));
5587 break;
d7a2c63c
MHM		 5588 case MLT_NEW_SV:
5589 case MLT_DEL_SV:
5590 len = my_snprintf(buf, sizeof(buf),
5591 "%s_SV: %s:%d:%s: %"UVxf SV_LOG_SERIAL_FMT "\n",
5592 mlt == MLT_NEW_SV ? "new" : "del",
5593 filename, linenumber, funcname,
5594 PTR2UV(sv) _SV_LOG_SERIAL_ARG(sv));
5595 break;
73d1d973
JC		 5596 default:
5597 len = 0;
0b0ab801
MHM		 5598 }
5599 PerlLIO_write(fd, buf, len);
65ceff02
JH		 5600 }
5601 }
0b0ab801 5602}
73d1d973
JC		 5603#endif /* !PERL_MEM_LOG_NOIMPL */
5604
5605#ifndef PERL_MEM_LOG_NOIMPL
5606# define \
5607 mem_log_common_if(alty, num, tysz, tynm, sv, oal, nal, flnm, ln, fnnm) \
5608 mem_log_common (alty, num, tysz, tynm, sv, oal, nal, flnm, ln, fnnm)
5609#else
5610/* this is suboptimal, but bug compatible. User is providing their
5611 own implemenation, but is getting these functions anyway, and they
5612 do nothing. But _NOIMPL users should be able to cope or fix */
5613# define \
5614 mem_log_common_if(alty, num, tysz, tynm, u, oal, nal, flnm, ln, fnnm) \
5615 /* mem_log_common_if_PERL_MEM_LOG_NOIMPL */
0b0ab801
MHM		 5616#endif
5617
5618Malloc_t
73d1d973
JC		 5619Perl_mem_log_alloc(const UV n, const UV typesize, const char *type_name,
5620 Malloc_t newalloc,
5621 const char *filename, const int linenumber,
5622 const char *funcname)
5623{
5624 mem_log_common_if(MLT_ALLOC, n, typesize, type_name,
5625 NULL, NULL, newalloc,
5626 filename, linenumber, funcname);
fe4f188c
JH		 5627 return newalloc;
5628}
5629
5630Malloc_t
73d1d973
JC		 5631Perl_mem_log_realloc(const UV n, const UV typesize, const char *type_name,
5632 Malloc_t oldalloc, Malloc_t newalloc,
5633 const char *filename, const int linenumber,
5634 const char *funcname)
5635{
5636 mem_log_common_if(MLT_REALLOC, n, typesize, type_name,
5637 NULL, oldalloc, newalloc,
5638 filename, linenumber, funcname);
fe4f188c
JH		 5639 return newalloc;
5640}
5641
5642Malloc_t
73d1d973
JC		 5643Perl_mem_log_free(Malloc_t oldalloc,
5644 const char *filename, const int linenumber,
5645 const char *funcname)
fe4f188c 5646{
73d1d973
JC		 5647 mem_log_common_if(MLT_FREE, 0, 0, "", NULL, oldalloc, NULL,
5648 filename, linenumber, funcname);
fe4f188c
JH		 5649 return oldalloc;
5650}
5651
d7a2c63c 5652void
73d1d973
JC		 5653Perl_mem_log_new_sv(const SV *sv,
5654 const char *filename, const int linenumber,
5655 const char *funcname)
d7a2c63c 5656{
73d1d973
JC		 5657 mem_log_common_if(MLT_NEW_SV, 0, 0, "", sv, NULL, NULL,
5658 filename, linenumber, funcname);
d7a2c63c
MHM		 5659}
5660
5661void
73d1d973
JC		 5662Perl_mem_log_del_sv(const SV *sv,
5663 const char *filename, const int linenumber,
5664 const char *funcname)
d7a2c63c 5665{
73d1d973
JC		 5666 mem_log_common_if(MLT_DEL_SV, 0, 0, "", sv, NULL, NULL,
5667 filename, linenumber, funcname);
d7a2c63c
MHM		 5668}
5669
fe4f188c
JH		 5670#endif /* PERL_MEM_LOG */
5671
66610fdd 5672/*
ce582cee
NC		 5673=for apidoc my_sprintf
5674
5675The C library C<sprintf>, wrapped if necessary, to ensure that it will return
5676the length of the string written to the buffer. Only rare pre-ANSI systems
5677need the wrapper function - usually this is a direct call to C<sprintf>.
5678
5679=cut
5680*/
5681#ifndef SPRINTF_RETURNS_STRLEN
5682int
5683Perl_my_sprintf(char *buffer, const char* pat, ...)
5684{
5685 va_list args;
7918f24d 5686 PERL_ARGS_ASSERT_MY_SPRINTF;
ce582cee
NC		 5687 va_start(args, pat);
5688 vsprintf(buffer, pat, args);
5689 va_end(args);
5690 return strlen(buffer);
5691}
5692#endif
5693
d9fad198
JH		 5694/*
5695=for apidoc my_snprintf
5696
5697The C library C<snprintf> functionality, if available and
5b692037 5698standards-compliant (uses C<vsnprintf>, actually). However, if the
d9fad198 5699C<vsnprintf> is not available, will unfortunately use the unsafe
5b692037
JH		 5700C<vsprintf> which can overrun the buffer (there is an overrun check,
5701but that may be too late). Consider using C<sv_vcatpvf> instead, or
5702getting C<vsnprintf>.
d9fad198
JH		 5703
5704=cut
5705*/
5706int
5707Perl_my_snprintf(char *buffer, const Size_t len, const char *format, ...)
d9fad198
JH		 5708{
5709 dTHX;
5710 int retval;
5711 va_list ap;
7918f24d 5712 PERL_ARGS_ASSERT_MY_SNPRINTF;
d9fad198 5713 va_start(ap, format);
5b692037 5714#ifdef HAS_VSNPRINTF
d9fad198
JH		 5715 retval = vsnprintf(buffer, len, format, ap);
5716#else
5717 retval = vsprintf(buffer, format, ap);
5718#endif
5719 va_end(ap);
1208b3dd 5720 /* vsnprintf() shows failure with >= len, vsprintf() with < 0 */
625dac9d 5721 if (retval < 0 || (len > 0 && (Size_t)retval >= len))
5b692037 5722 Perl_croak(aTHX_ "panic: my_snprintf buffer overflow");
d9fad198
JH		 5723 return retval;
5724}
5725
5726/*
5727=for apidoc my_vsnprintf
5728
5b692037
JH		 5729The C library C<vsnprintf> if available and standards-compliant.
5730However, if if the C<vsnprintf> is not available, will unfortunately
5731use the unsafe C<vsprintf> which can overrun the buffer (there is an
5732overrun check, but that may be too late). Consider using
5733C<sv_vcatpvf> instead, or getting C<vsnprintf>.
d9fad198
JH		 5734
5735=cut
5736*/
5737int
5738Perl_my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap)
d9fad198
JH		 5739{
5740 dTHX;
5741 int retval;
d9fad198
JH		 5742#ifdef NEED_VA_COPY
5743 va_list apc;
7918f24d
NC		 5744
5745 PERL_ARGS_ASSERT_MY_VSNPRINTF;
5746
239fec62 5747 Perl_va_copy(ap, apc);
5b692037 5748# ifdef HAS_VSNPRINTF
d9fad198
JH		 5749 retval = vsnprintf(buffer, len, format, apc);
5750# else
5751 retval = vsprintf(buffer, format, apc);
5752# endif
5753#else
5b692037 5754# ifdef HAS_VSNPRINTF
d9fad198
JH		 5755 retval = vsnprintf(buffer, len, format, ap);
5756# else
5757 retval = vsprintf(buffer, format, ap);
5758# endif
5b692037 5759#endif /* #ifdef NEED_VA_COPY */
1208b3dd 5760 /* vsnprintf() shows failure with >= len, vsprintf() with < 0 */
625dac9d 5761 if (retval < 0 || (len > 0 && (Size_t)retval >= len))
5b692037 5762 Perl_croak(aTHX_ "panic: my_vsnprintf buffer overflow");
d9fad198
JH		 5763 return retval;
5764}
5765
b0269e46
AB		 5766void
5767Perl_my_clearenv(pTHX)
5768{
5769 dVAR;
5770#if ! defined(PERL_MICRO)
5771# if defined(PERL_IMPLICIT_SYS) || defined(WIN32)
5772 PerlEnv_clearenv();
5773# else /* ! (PERL_IMPLICIT_SYS || WIN32) */
5774# if defined(USE_ENVIRON_ARRAY)
5775# if defined(USE_ITHREADS)
5776 /* only the parent thread can clobber the process environment */
5777 if (PL_curinterp == aTHX)
5778# endif /* USE_ITHREADS */
5779 {
5780# if ! defined(PERL_USE_SAFE_PUTENV)
5781 if ( !PL_use_safe_putenv) {
5782 I32 i;
5783 if (environ == PL_origenviron)
5784 environ = (char**)safesysmalloc(sizeof(char*));
5785 else
5786 for (i = 0; environ[i]; i++)
5787 (void)safesysfree(environ[i]);
5788 }
5789 environ[0] = NULL;
5790# else /* PERL_USE_SAFE_PUTENV */
5791# if defined(HAS_CLEARENV)
5792 (void)clearenv();
5793# elif defined(HAS_UNSETENV)
5794 int bsiz = 80; /* Most envvar names will be shorter than this. */
d1307786
JH		 5795 int bufsiz = bsiz * sizeof(char); /* sizeof(char) paranoid? */
5796 char *buf = (char*)safesysmalloc(bufsiz);
b0269e46
AB		 5797 while (*environ != NULL) {
5798 char *e = strchr(*environ, '=');
b57a0404 5799 int l = e ? e - *environ : (int)strlen(*environ);
b0269e46
AB		 5800 if (bsiz < l + 1) {
5801 (void)safesysfree(buf);
1bdfa2de 5802 bsiz = l + 1; /* + 1 for the \0. */
d1307786 5803 buf = (char*)safesysmalloc(bufsiz);
b0269e46 5804 }
82d8bb49
NC		 5805 memcpy(buf, *environ, l);
5806 buf[l] = '\0';
b0269e46
AB		 5807 (void)unsetenv(buf);
5808 }
5809 (void)safesysfree(buf);
5810# else /* ! HAS_CLEARENV && ! HAS_UNSETENV */
5811 /* Just null environ and accept the leakage. */
5812 *environ = NULL;
5813# endif /* HAS_CLEARENV || HAS_UNSETENV */
5814# endif /* ! PERL_USE_SAFE_PUTENV */
5815 }
5816# endif /* USE_ENVIRON_ARRAY */
5817# endif /* PERL_IMPLICIT_SYS || WIN32 */
5818#endif /* PERL_MICRO */
5819}
5820
f16dd614
DM		 5821#ifdef PERL_IMPLICIT_CONTEXT
5822
53d44271 5823/* Implements the MY_CXT_INIT macro. The first time a module is loaded,
f16dd614
DM		 5824the global PL_my_cxt_index is incremented, and that value is assigned to
5825that module's static my_cxt_index (who's address is passed as an arg).
5826Then, for each interpreter this function is called for, it makes sure a
5827void* slot is available to hang the static data off, by allocating or
5828extending the interpreter's PL_my_cxt_list array */
5829
53d44271 5830#ifndef PERL_GLOBAL_STRUCT_PRIVATE
f16dd614
DM		 5831void *
5832Perl_my_cxt_init(pTHX_ int *index, size_t size)
5833{
97aff369 5834 dVAR;
f16dd614 5835 void *p;
7918f24d 5836 PERL_ARGS_ASSERT_MY_CXT_INIT;
f16dd614
DM		 5837 if (*index == -1) {
5838 /* this module hasn't been allocated an index yet */
5839 MUTEX_LOCK(&PL_my_ctx_mutex);
5840 *index = PL_my_cxt_index++;
5841 MUTEX_UNLOCK(&PL_my_ctx_mutex);
5842 }
5843
5844 /* make sure the array is big enough */
4c901e72
DM		 5845 if (PL_my_cxt_size <= *index) {
5846 if (PL_my_cxt_size) {
5847 while (PL_my_cxt_size <= *index)
f16dd614
DM		 5848 PL_my_cxt_size *= 2;
5849 Renew(PL_my_cxt_list, PL_my_cxt_size, void *);
5850 }
5851 else {
5852 PL_my_cxt_size = 16;
5853 Newx(PL_my_cxt_list, PL_my_cxt_size, void *);
5854 }
5855 }
5856 /* newSV() allocates one more than needed */
5857 p = (void*)SvPVX(newSV(size-1));
5858 PL_my_cxt_list[*index] = p;
5859 Zero(p, size, char);
5860 return p;
5861}
53d44271
JH		 5862
5863#else /* #ifndef PERL_GLOBAL_STRUCT_PRIVATE */
5864
5865int
5866Perl_my_cxt_index(pTHX_ const char *my_cxt_key)
5867{
5868 dVAR;
5869 int index;
5870
7918f24d
NC		 5871 PERL_ARGS_ASSERT_MY_CXT_INDEX;
5872
53d44271
JH		 5873 for (index = 0; index < PL_my_cxt_index; index++) {
5874 const char *key = PL_my_cxt_keys[index];
5875 /* try direct pointer compare first - there are chances to success,
5876 * and it's much faster.
5877 */
5878 if ((key == my_cxt_key) || strEQ(key, my_cxt_key))
5879 return index;
5880 }
5881 return -1;
5882}
5883
5884void *
5885Perl_my_cxt_init(pTHX_ const char *my_cxt_key, size_t size)
5886{
5887 dVAR;
5888 void *p;
5889 int index;
5890
7918f24d
NC		 5891 PERL_ARGS_ASSERT_MY_CXT_INIT;
5892
53d44271
JH		 5893 index = Perl_my_cxt_index(aTHX_ my_cxt_key);
5894 if (index == -1) {
5895 /* this module hasn't been allocated an index yet */
5896 MUTEX_LOCK(&PL_my_ctx_mutex);
5897 index = PL_my_cxt_index++;
5898 MUTEX_UNLOCK(&PL_my_ctx_mutex);
5899 }
5900
5901 /* make sure the array is big enough */
5902 if (PL_my_cxt_size <= index) {
5903 int old_size = PL_my_cxt_size;
5904 int i;
5905 if (PL_my_cxt_size) {
5906 while (PL_my_cxt_size <= index)
5907 PL_my_cxt_size *= 2;
5908 Renew(PL_my_cxt_list, PL_my_cxt_size, void *);
5909 Renew(PL_my_cxt_keys, PL_my_cxt_size, const char *);
5910 }
5911 else {
5912 PL_my_cxt_size = 16;
5913 Newx(PL_my_cxt_list, PL_my_cxt_size, void *);
5914 Newx(PL_my_cxt_keys, PL_my_cxt_size, const char *);
5915 }
5916 for (i = old_size; i < PL_my_cxt_size; i++) {
5917 PL_my_cxt_keys[i] = 0;
5918 PL_my_cxt_list[i] = 0;
5919 }
5920 }
5921 PL_my_cxt_keys[index] = my_cxt_key;
5922 /* newSV() allocates one more than needed */
5923 p = (void*)SvPVX(newSV(size-1));
5924 PL_my_cxt_list[index] = p;
5925 Zero(p, size, char);
5926 return p;
5927}
5928#endif /* #ifndef PERL_GLOBAL_STRUCT_PRIVATE */
5929#endif /* PERL_IMPLICIT_CONTEXT */
f16dd614 5930
a6cc4119
SP		 5931#ifndef HAS_STRLCAT
5932Size_t
5933Perl_my_strlcat(char *dst, const char *src, Size_t size)
5934{
5935 Size_t used, length, copy;
5936
5937 used = strlen(dst);
5938 length = strlen(src);
5939 if (size > 0 && used < size - 1) {
5940 copy = (length >= size - used) ? size - used - 1 : length;
5941 memcpy(dst + used, src, copy);
5942 dst[used + copy] = '\0';
5943 }
5944 return used + length;
5945}
5946#endif
5947
5948#ifndef HAS_STRLCPY
5949Size_t
5950Perl_my_strlcpy(char *dst, const char *src, Size_t size)
5951{
5952 Size_t length, copy;
5953
5954 length = strlen(src);
5955 if (size > 0) {
5956 copy = (length >= size) ? size - 1 : length;
5957 memcpy(dst, src, copy);
5958 dst[copy] = '\0';
5959 }
5960 return length;
5961}
5962#endif
5963
17dd9954
JH		 5964#if defined(_MSC_VER) && (_MSC_VER >= 1300) && (_MSC_VER < 1400) && (WINVER < 0x0500)
5965/* VC7 or 7.1, building with pre-VC7 runtime libraries. */
5966long _ftol( double ); /* Defined by VC6 C libs. */
5967long _ftol2( double dblSource ) { return _ftol( dblSource ); }
5968#endif
5969
c51f309c
NC		 5970void
5971Perl_get_db_sub(pTHX_ SV **svp, CV *cv)
5972{
5973 dVAR;
5974 SV * const dbsv = GvSVn(PL_DBsub);
5975 /* We do not care about using sv to call CV;
5976 * it's for informational purposes only.
5977 */
5978
7918f24d
NC		 5979 PERL_ARGS_ASSERT_GET_DB_SUB;
5980
c51f309c
NC		 5981 save_item(dbsv);
5982 if (!PERLDB_SUB_NN) {
5983 GV * const gv = CvGV(cv);
5984
5985 if ( svp && ((CvFLAGS(cv) & (CVf_ANON | CVf_CLONED))
5986 || strEQ(GvNAME(gv), "END")
5987 || ((GvCV(gv) != cv) && /* Could be imported, and old sub redefined. */
159b6efe
NC		 5988 !( (SvTYPE(*svp) == SVt_PVGV)
5989 && (GvCV((const GV *)*svp) == cv) )))) {
c51f309c
NC		 5990 /* Use GV from the stack as a fallback. */
5991 /* GV is potentially non-unique, or contain different CV. */
daba3364 5992 SV * const tmp = newRV(MUTABLE_SV(cv));
c51f309c
NC		 5993 sv_setsv(dbsv, tmp);
5994 SvREFCNT_dec(tmp);
5995 }
5996 else {
5997 gv_efullname3(dbsv, gv, NULL);
5998 }
5999 }
6000 else {
6001 const int type = SvTYPE(dbsv);
6002 if (type < SVt_PVIV && type != SVt_IV)
6003 sv_upgrade(dbsv, SVt_PVIV);
6004 (void)SvIOK_on(dbsv);
6005 SvIV_set(dbsv, PTR2IV(cv)); /* Do it the quickest way */
6006 }
6007}
6008
3497a01f 6009int
08ea85eb 6010Perl_my_dirfd(pTHX_ DIR * dir) {
3497a01f
SP		 6011
6012 /* Most dirfd implementations have problems when passed NULL. */
6013 if(!dir)
6014 return -1;
6015#ifdef HAS_DIRFD
6016 return dirfd(dir);
6017#elif defined(HAS_DIR_DD_FD)
6018 return dir->dd_fd;
6019#else
6020 Perl_die(aTHX_ PL_no_func, "dirfd");
6021 /* NOT REACHED */
6022 return 0;
6023#endif
6024}
6025
f7e71195
AB		 6026REGEXP *
6027Perl_get_re_arg(pTHX_ SV *sv) {
6028 SV *tmpsv;
f7e71195
AB		 6029
6030 if (sv) {
6031 if (SvMAGICAL(sv))
6032 mg_get(sv);
6033 if (SvROK(sv) &&
daba3364 6034 (tmpsv = MUTABLE_SV(SvRV(sv))) && /* assign deliberate */
5c35adbb 6035 SvTYPE(tmpsv) == SVt_REGEXP)
f7e71195 6036 {
d2f13c59 6037 return (REGEXP*) tmpsv;
f7e71195
AB		 6038 }
6039 }
6040
6041 return NULL;
6042}
6043
ce582cee 6044/*
66610fdd
RGS		 6045 * Local variables:
6046 * c-indentation-style: bsd
6047 * c-basic-offset: 4
6048 * indent-tabs-mode: t
6049 * End:
6050 *
37442d52
RGS		 6051 * ex: set ts=8 sts=4 sw=4 noet:
6052 */
Unnamed repository; edit this file 'description' to name the repository.