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
fix broken parsing of /\x{ab}/
[perl5.git] / util.c
CommitLineData
a0d0e21e 1/* util.c
a687059c 2 *
3818b22b 3 * Copyright (c) 1991-2000, Larry Wall
a687059c 4 *
d48672a2
LW		 5 * You may distribute under the terms of either the GNU General Public
6 * License or the Artistic License, as specified in the README file.
8d063cd8 7 *
8d063cd8 8 */
a0d0e21e
LW		 9
10/*
11 * "Very useful, no doubt, that was to Saruman; yet it seems that he was
12 * not content." --Gandalf
13 */
8d063cd8 14
8d063cd8 15#include "EXTERN.h"
864dbfa3 16#define PERL_IN_UTIL_C
8d063cd8 17#include "perl.h"
62b28dd9 18
e1dfb34b 19#if !defined(NSIG) || defined(M_UNIX) || defined(M_XENIX)
a687059c 20#include <signal.h>
62b28dd9 21#endif
a687059c 22
36477c24 23#ifndef SIG_ERR
24# define SIG_ERR ((Sighandler_t) -1)
25#endif
26
bd4080b3 27/* XXX If this causes problems, set i_unistd=undef in the hint file. */
85e6fe83 28#ifdef I_UNISTD
8990e307
LW		 29# include <unistd.h>
30#endif
31
a687059c
LW		 32#ifdef I_VFORK
33# include <vfork.h>
34#endif
35
94b6baf5
AD		 36/* Put this after #includes because fork and vfork prototypes may
37 conflict.
38*/
39#ifndef HAS_VFORK
40# define vfork fork
41#endif
42
ff68c719 43#ifdef I_SYS_WAIT
44# include <sys/wait.h>
45#endif
46
097ee67d
JH		 47#ifdef I_LOCALE
48# include <locale.h>
49#endif
50
8d063cd8 51#define FLUSH
8d063cd8 52
a0d0e21e 53#ifdef LEAKTEST
a0d0e21e 54
8c52afec
IZ		 55long xcount[MAXXCOUNT];
56long lastxcount[MAXXCOUNT];
57long xycount[MAXXCOUNT][MAXYCOUNT];
58long lastxycount[MAXXCOUNT][MAXYCOUNT];
59
a0d0e21e 60#endif
a863c7d1 61
16cebae2
GS		 62#if defined(HAS_FCNTL) && defined(F_SETFD) && !defined(FD_CLOEXEC)
63# define FD_CLOEXEC 1 /* NeXT needs this */
64#endif
65
f2517201 66/* paranoid version of system's malloc() */
8d063cd8 67
a687059c
LW		 68/* NOTE: Do not call the next three routines directly. Use the macros
69 * in handy.h, so that we can easily redefine everything to do tracking of
70 * allocated hunks back to the original New to track down any memory leaks.
20cec16a 71 * XXX This advice seems to be widely ignored :-( --AD August 1996.
a687059c
LW		 72 */
73
bd4080b3 74Malloc_t
4f63d024 75Perl_safesysmalloc(MEM_SIZE size)
8d063cd8 76{
54aff467 77 dTHX;
bd4080b3 78 Malloc_t ptr;
55497cff 79#ifdef HAS_64K_LIMIT
62b28dd9 80 if (size > 0xffff) {
bf49b057 81 PerlIO_printf(Perl_error_log,
16cebae2 82 "Allocation too large: %lx\n", size) FLUSH;
54aff467 83 my_exit(1);
62b28dd9 84 }
55497cff 85#endif /* HAS_64K_LIMIT */
34de22dd
LW		 86#ifdef DEBUGGING
87 if ((long)size < 0)
4f63d024 88 Perl_croak_nocontext("panic: malloc");
34de22dd 89#endif
6ad3d225 90 ptr = PerlMem_malloc(size?size:1); /* malloc(0) is NASTY on our system */
da927450 91 PERL_ALLOC_CHECK(ptr);
97835f67 92 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) malloc %ld bytes\n",PTR2UV(ptr),(long)PL_an++,(long)size));
8d063cd8
LW		 93 if (ptr != Nullch)
94 return ptr;
3280af22 95 else if (PL_nomemok)
7c0587c8 96 return Nullch;
8d063cd8 97 else {
bf49b057 98 PerlIO_puts(Perl_error_log,PL_no_mem) FLUSH;
54aff467 99 my_exit(1);
4e35701f 100 return Nullch;
8d063cd8
LW		 101 }
102 /*NOTREACHED*/
103}
104
f2517201 105/* paranoid version of system's realloc() */
8d063cd8 106
bd4080b3 107Malloc_t
4f63d024 108Perl_safesysrealloc(Malloc_t where,MEM_SIZE size)
8d063cd8 109{
54aff467 110 dTHX;
bd4080b3 111 Malloc_t ptr;
9a34ef1d 112#if !defined(STANDARD_C) && !defined(HAS_REALLOC_PROTOTYPE) && !defined(PERL_MICRO)
6ad3d225 113 Malloc_t PerlMem_realloc();
ecfc5424 114#endif /* !defined(STANDARD_C) && !defined(HAS_REALLOC_PROTOTYPE) */
8d063cd8 115
55497cff 116#ifdef HAS_64K_LIMIT
5f05dabc 117 if (size > 0xffff) {
bf49b057 118 PerlIO_printf(Perl_error_log,
5f05dabc 119 "Reallocation too large: %lx\n", size) FLUSH;
54aff467 120 my_exit(1);
5f05dabc 121 }
55497cff 122#endif /* HAS_64K_LIMIT */
7614df0c 123 if (!size) {
f2517201 124 safesysfree(where);
7614df0c
JD		 125 return NULL;
126 }
127
378cc40b 128 if (!where)
f2517201 129 return safesysmalloc(size);
34de22dd
LW		 130#ifdef DEBUGGING
131 if ((long)size < 0)
4f63d024 132 Perl_croak_nocontext("panic: realloc");
34de22dd 133#endif
7614df0c 134 ptr = PerlMem_realloc(where,size);
da927450 135 PERL_ALLOC_CHECK(ptr);
cd39f2b6 136
97835f67
JH		 137 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) rfree\n",PTR2UV(where),(long)PL_an++));
138 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) realloc %ld bytes\n",PTR2UV(ptr),(long)PL_an++,(long)size));
79072805 139
8d063cd8
LW		 140 if (ptr != Nullch)
141 return ptr;
3280af22 142 else if (PL_nomemok)
7c0587c8 143 return Nullch;
8d063cd8 144 else {
bf49b057 145 PerlIO_puts(Perl_error_log,PL_no_mem) FLUSH;
54aff467 146 my_exit(1);
4e35701f 147 return Nullch;
8d063cd8
LW		 148 }
149 /*NOTREACHED*/
150}
151
f2517201 152/* safe version of system's free() */
8d063cd8 153
54310121 154Free_t
4f63d024 155Perl_safesysfree(Malloc_t where)
8d063cd8 156{
155aba94 157#ifdef PERL_IMPLICIT_SYS
54aff467 158 dTHX;
155aba94 159#endif
97835f67 160 DEBUG_m( PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) free\n",PTR2UV(where),(long)PL_an++));
378cc40b 161 if (where) {
de3bb511 162 /*SUPPRESS 701*/
6ad3d225 163 PerlMem_free(where);
378cc40b 164 }
8d063cd8
LW		 165}
166
f2517201 167/* safe version of system's calloc() */
1050c9ca 168
bd4080b3 169Malloc_t
4f63d024 170Perl_safesyscalloc(MEM_SIZE count, MEM_SIZE size)
1050c9ca 171{
54aff467 172 dTHX;
bd4080b3 173 Malloc_t ptr;
1050c9ca 174
55497cff 175#ifdef HAS_64K_LIMIT
5f05dabc 176 if (size * count > 0xffff) {
bf49b057 177 PerlIO_printf(Perl_error_log,
5f05dabc 178 "Allocation too large: %lx\n", size * count) FLUSH;
54aff467 179 my_exit(1);
5f05dabc 180 }
55497cff 181#endif /* HAS_64K_LIMIT */
1050c9ca 182#ifdef DEBUGGING
183 if ((long)size < 0 || (long)count < 0)
4f63d024 184 Perl_croak_nocontext("panic: calloc");
1050c9ca 185#endif
0b7c1c42 186 size *= count;
6ad3d225 187 ptr = PerlMem_malloc(size?size:1); /* malloc(0) is NASTY on our system */
da927450 188 PERL_ALLOC_CHECK(ptr);
97835f67 189 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) calloc %ld x %ld bytes\n",PTR2UV(ptr),(long)PL_an++,(long)count,(long)size));
1050c9ca 190 if (ptr != Nullch) {
191 memset((void*)ptr, 0, size);
192 return ptr;
193 }
3280af22 194 else if (PL_nomemok)
1050c9ca 195 return Nullch;
196 else {
bf49b057 197 PerlIO_puts(Perl_error_log,PL_no_mem) FLUSH;
54aff467 198 my_exit(1);
4e35701f 199 return Nullch;
1050c9ca 200 }
201 /*NOTREACHED*/
202}
203
a687059c
LW		 204#ifdef LEAKTEST
205
8c52afec
IZ		 206struct mem_test_strut {
207 union {
208 long type;
209 char c[2];
210 } u;
211 long size;
212};
213
214# define ALIGN sizeof(struct mem_test_strut)
215
216# define sizeof_chunk(ch) (((struct mem_test_strut*) (ch))->size)
217# define typeof_chunk(ch) \
218 (((struct mem_test_strut*) (ch))->u.c[0] + ((struct mem_test_strut*) (ch))->u.c[1]*100)
219# define set_typeof_chunk(ch,t) \
220 (((struct mem_test_strut*) (ch))->u.c[0] = t % 100, ((struct mem_test_strut*) (ch))->u.c[1] = t / 100)
221#define SIZE_TO_Y(size) ( (size) > MAXY_SIZE \
222 ? MAXYCOUNT - 1 \
223 : ( (size) > 40 \
224 ? ((size) - 1)/8 + 5 \
225 : ((size) - 1)/4))
8d063cd8 226
bd4080b3 227Malloc_t
4f63d024 228Perl_safexmalloc(I32 x, MEM_SIZE size)
8d063cd8 229{
8c52afec 230 register char* where = (char*)safemalloc(size + ALIGN);
8d063cd8 231
8c52afec
IZ		 232 xcount[x] += size;
233 xycount[x][SIZE_TO_Y(size)]++;
234 set_typeof_chunk(where, x);
235 sizeof_chunk(where) = size;
236 return (Malloc_t)(where + ALIGN);
8d063cd8 237}
8d063cd8 238
bd4080b3 239Malloc_t
4f63d024 240Perl_safexrealloc(Malloc_t wh, MEM_SIZE size)
a687059c 241{
8c52afec
IZ		 242 char *where = (char*)wh;
243
244 if (!wh)
245 return safexmalloc(0,size);
246
247 {
248 MEM_SIZE old = sizeof_chunk(where - ALIGN);
249 int t = typeof_chunk(where - ALIGN);
250 register char* new = (char*)saferealloc(where - ALIGN, size + ALIGN);
251
252 xycount[t][SIZE_TO_Y(old)]--;
253 xycount[t][SIZE_TO_Y(size)]++;
254 xcount[t] += size - old;
255 sizeof_chunk(new) = size;
256 return (Malloc_t)(new + ALIGN);
257 }
a687059c
LW		 258}
259
260void
4f63d024 261Perl_safexfree(Malloc_t wh)
a687059c 262{
79072805 263 I32 x;
8c52afec
IZ		 264 char *where = (char*)wh;
265 MEM_SIZE size;
266
a687059c
LW		 267 if (!where)
268 return;
269 where -= ALIGN;
8c52afec 270 size = sizeof_chunk(where);
a687059c 271 x = where[0] + 100 * where[1];
8c52afec
IZ		 272 xcount[x] -= size;
273 xycount[x][SIZE_TO_Y(size)]--;
a687059c
LW		 274 safefree(where);
275}
276
bd4080b3 277Malloc_t
4f63d024 278Perl_safexcalloc(I32 x,MEM_SIZE count, MEM_SIZE size)
1050c9ca 279{
8c52afec
IZ		 280 register char * where = (char*)safexmalloc(x, size * count + ALIGN);
281 xcount[x] += size;
282 xycount[x][SIZE_TO_Y(size)]++;
283 memset((void*)(where + ALIGN), 0, size * count);
284 set_typeof_chunk(where, x);
285 sizeof_chunk(where) = size;
286 return (Malloc_t)(where + ALIGN);
1050c9ca 287}
288
864dbfa3 289STATIC void
cea2e8a9 290S_xstat(pTHX_ int flag)
8d063cd8 291{
8c52afec
IZ		 292 register I32 i, j, total = 0;
293 I32 subtot[MAXYCOUNT];
8d063cd8 294
8c52afec
IZ		 295 for (j = 0; j < MAXYCOUNT; j++) {
296 subtot[j] = 0;
297 }
298
bf49b057 299 PerlIO_printf(Perl_debug_log, " Id subtot 4 8 12 16 20 24 28 32 36 40 48 56 64 72 80 80+\n", total);
a687059c 300 for (i = 0; i < MAXXCOUNT; i++) {
8c52afec
IZ		 301 total += xcount[i];
302 for (j = 0; j < MAXYCOUNT; j++) {
303 subtot[j] += xycount[i][j];
304 }
305 if (flag == 0
306 ? xcount[i] /* Have something */
307 : (flag == 2
308 ? xcount[i] != lastxcount[i] /* Changed */
309 : xcount[i] > lastxcount[i])) { /* Growed */
bf49b057 310 PerlIO_printf(Perl_debug_log,"%2d %02d %7ld ", i / 100, i % 100,
8c52afec 311 flag == 2 ? xcount[i] - lastxcount[i] : xcount[i]);
a687059c 312 lastxcount[i] = xcount[i];
8c52afec
IZ		 313 for (j = 0; j < MAXYCOUNT; j++) {
314 if ( flag == 0
315 ? xycount[i][j] /* Have something */
316 : (flag == 2
317 ? xycount[i][j] != lastxycount[i][j] /* Changed */
318 : xycount[i][j] > lastxycount[i][j])) { /* Growed */
bf49b057 319 PerlIO_printf(Perl_debug_log,"%3ld ",
8c52afec
IZ		 320 flag == 2
321 ? xycount[i][j] - lastxycount[i][j]
322 : xycount[i][j]);
323 lastxycount[i][j] = xycount[i][j];
324 } else {
bf49b057 325 PerlIO_printf(Perl_debug_log, " . ", xycount[i][j]);
8c52afec
IZ		 326 }
327 }
bf49b057 328 PerlIO_printf(Perl_debug_log, "\n");
8c52afec
IZ		 329 }
330 }
331 if (flag != 2) {
bf49b057 332 PerlIO_printf(Perl_debug_log, "Total %7ld ", total);
8c52afec
IZ		 333 for (j = 0; j < MAXYCOUNT; j++) {
334 if (subtot[j]) {
bf49b057 335 PerlIO_printf(Perl_debug_log, "%3ld ", subtot[j]);
8c52afec 336 } else {
bf49b057 337 PerlIO_printf(Perl_debug_log, " . ");
8c52afec 338 }
8d063cd8 339 }
bf49b057 340 PerlIO_printf(Perl_debug_log, "\n");
8d063cd8 341 }
8d063cd8 342}
a687059c
LW		 343
344#endif /* LEAKTEST */
8d063cd8
LW		 345
346/* copy a string up to some (non-backslashed) delimiter, if any */
347
348char *
864dbfa3 349Perl_delimcpy(pTHX_ register char *to, register char *toend, register char *from, register char *fromend, register int delim, I32 *retlen)
8d063cd8 350{
fc36a67e 351 register I32 tolen;
352 for (tolen = 0; from < fromend; from++, tolen++) {
378cc40b
LW		 353 if (*from == '\\') {
354 if (from[1] == delim)
355 from++;
fc36a67e 356 else {
357 if (to < toend)
358 *to++ = *from;
359 tolen++;
360 from++;
361 }
378cc40b 362 }
bedebaa5 363 else if (*from == delim)
8d063cd8 364 break;
fc36a67e 365 if (to < toend)
366 *to++ = *from;
8d063cd8 367 }
bedebaa5
CS		 368 if (to < toend)
369 *to = '\0';
fc36a67e 370 *retlen = tolen;
8d063cd8
LW		 371 return from;
372}
373
374/* return ptr to little string in big string, NULL if not found */
378cc40b 375/* This routine was donated by Corey Satten. */
8d063cd8
LW		 376
377char *
864dbfa3 378Perl_instr(pTHX_ register const char *big, register const char *little)
378cc40b 379{
08105a92 380 register const char *s, *x;
79072805 381 register I32 first;
378cc40b 382
a687059c 383 if (!little)
08105a92 384 return (char*)big;
a687059c 385 first = *little++;
378cc40b 386 if (!first)
08105a92 387 return (char*)big;
378cc40b
LW		 388 while (*big) {
389 if (*big++ != first)
390 continue;
391 for (x=big,s=little; *s; /**/ ) {
392 if (!*x)
393 return Nullch;
394 if (*s++ != *x++) {
395 s--;
396 break;
397 }
398 }
399 if (!*s)
08105a92 400 return (char*)(big-1);
378cc40b
LW		 401 }
402 return Nullch;
403}
8d063cd8 404
a687059c
LW		 405/* same as instr but allow embedded nulls */
406
407char *
864dbfa3 408Perl_ninstr(pTHX_ register const char *big, register const char *bigend, const char *little, const char *lend)
8d063cd8 409{
08105a92 410 register const char *s, *x;
79072805 411 register I32 first = *little;
08105a92 412 register const char *littleend = lend;
378cc40b 413
a0d0e21e 414 if (!first && little >= littleend)
08105a92 415 return (char*)big;
de3bb511
LW		 416 if (bigend - big < littleend - little)
417 return Nullch;
a687059c
LW		 418 bigend -= littleend - little++;
419 while (big <= bigend) {
420 if (*big++ != first)
421 continue;
422 for (x=big,s=little; s < littleend; /**/ ) {
423 if (*s++ != *x++) {
424 s--;
425 break;
426 }
427 }
428 if (s >= littleend)
08105a92 429 return (char*)(big-1);
378cc40b 430 }
a687059c
LW		 431 return Nullch;
432}
433
434/* reverse of the above--find last substring */
435
436char *
864dbfa3 437Perl_rninstr(pTHX_ register const char *big, const char *bigend, const char *little, const char *lend)
a687059c 438{
08105a92
GS		 439 register const char *bigbeg;
440 register const char *s, *x;
79072805 441 register I32 first = *little;
08105a92 442 register const char *littleend = lend;
a687059c 443
a0d0e21e 444 if (!first && little >= littleend)
08105a92 445 return (char*)bigend;
a687059c
LW		 446 bigbeg = big;
447 big = bigend - (littleend - little++);
448 while (big >= bigbeg) {
449 if (*big-- != first)
450 continue;
451 for (x=big+2,s=little; s < littleend; /**/ ) {
452 if (*s++ != *x++) {
453 s--;
454 break;
455 }
456 }
457 if (s >= littleend)
08105a92 458 return (char*)(big+1);
378cc40b 459 }
a687059c 460 return Nullch;
378cc40b 461}
a687059c 462
bbce6d69 463/*
464 * Set up for a new ctype locale.
465 */
55497cff 466void
864dbfa3 467Perl_new_ctype(pTHX_ const char *newctype)
ef7eada9 468{
36477c24 469#ifdef USE_LOCALE_CTYPE
470
bbce6d69 471 int i;
ef7eada9 472
bbce6d69 473 for (i = 0; i < 256; i++) {
474 if (isUPPER_LC(i))
22c35a8c 475 PL_fold_locale[i] = toLOWER_LC(i);
bbce6d69 476 else if (isLOWER_LC(i))
22c35a8c 477 PL_fold_locale[i] = toUPPER_LC(i);
bbce6d69 478 else
22c35a8c 479 PL_fold_locale[i] = i;
bbce6d69 480 }
bbce6d69 481
36477c24 482#endif /* USE_LOCALE_CTYPE */
483}
bbce6d69 484
485/*
486 * Set up for a new collation locale.
487 */
488void
864dbfa3 489Perl_new_collate(pTHX_ const char *newcoll)
bbce6d69 490{
36477c24 491#ifdef USE_LOCALE_COLLATE
492
bbce6d69 493 if (! newcoll) {
3280af22
NIS		 494 if (PL_collation_name) {
495 ++PL_collation_ix;
496 Safefree(PL_collation_name);
497 PL_collation_name = NULL;
498 PL_collation_standard = TRUE;
499 PL_collxfrm_base = 0;
500 PL_collxfrm_mult = 2;
bbce6d69 501 }
502 return;
503 }
504
3280af22
NIS		 505 if (! PL_collation_name || strNE(PL_collation_name, newcoll)) {
506 ++PL_collation_ix;
507 Safefree(PL_collation_name);
508 PL_collation_name = savepv(newcoll);
509 PL_collation_standard = (strEQ(newcoll, "C") || strEQ(newcoll, "POSIX"));
bbce6d69 510
bbce6d69 511 {
512 /* 2: at most so many chars ('a', 'b'). */
513 /* 50: surely no system expands a char more. */
514#define XFRMBUFSIZE (2 * 50)
515 char xbuf[XFRMBUFSIZE];
516 Size_t fa = strxfrm(xbuf, "a", XFRMBUFSIZE);
517 Size_t fb = strxfrm(xbuf, "ab", XFRMBUFSIZE);
518 SSize_t mult = fb - fa;
519 if (mult < 1)
cea2e8a9 520 Perl_croak(aTHX_ "strxfrm() gets absurd");
3280af22
NIS		 521 PL_collxfrm_base = (fa > mult) ? (fa - mult) : 0;
522 PL_collxfrm_mult = mult;
bbce6d69 523 }
bbce6d69 524 }
bbce6d69 525
36477c24 526#endif /* USE_LOCALE_COLLATE */
527}
bbce6d69 528
097ee67d 529void
51371543 530Perl_set_numeric_radix(pTHX)
097ee67d
JH		 531{
532#ifdef USE_LOCALE_NUMERIC
533# ifdef HAS_LOCALECONV
534 struct lconv* lc;
535
536 lc = localeconv();
537 if (lc && lc->decimal_point)
538 /* We assume that decimal separator aka the radix
539 * character is always a single character. If it
540 * ever is a string, this needs to be rethunk. */
541 PL_numeric_radix = *lc->decimal_point;
542 else
543 PL_numeric_radix = 0;
544# endif /* HAS_LOCALECONV */
097ee67d
JH		 545#endif /* USE_LOCALE_NUMERIC */
546}
547
bbce6d69 548/*
549 * Set up for a new numeric locale.
550 */
551void
864dbfa3 552Perl_new_numeric(pTHX_ const char *newnum)
bbce6d69 553{
36477c24 554#ifdef USE_LOCALE_NUMERIC
555
bbce6d69 556 if (! newnum) {
3280af22
NIS		 557 if (PL_numeric_name) {
558 Safefree(PL_numeric_name);
559 PL_numeric_name = NULL;
560 PL_numeric_standard = TRUE;
561 PL_numeric_local = TRUE;
bbce6d69 562 }
563 return;
564 }
565
3280af22
NIS		 566 if (! PL_numeric_name || strNE(PL_numeric_name, newnum)) {
567 Safefree(PL_numeric_name);
568 PL_numeric_name = savepv(newnum);
569 PL_numeric_standard = (strEQ(newnum, "C") || strEQ(newnum, "POSIX"));
570 PL_numeric_local = TRUE;
51371543 571 set_numeric_radix();
bbce6d69 572 }
36477c24 573
574#endif /* USE_LOCALE_NUMERIC */
bbce6d69 575}
576
577void
864dbfa3 578Perl_set_numeric_standard(pTHX)
bbce6d69 579{
5f05dabc 580#ifdef USE_LOCALE_NUMERIC
581
3280af22 582 if (! PL_numeric_standard) {
bbce6d69 583 setlocale(LC_NUMERIC, "C");
3280af22
NIS		 584 PL_numeric_standard = TRUE;
585 PL_numeric_local = FALSE;
bbce6d69 586 }
5f05dabc 587
588#endif /* USE_LOCALE_NUMERIC */
bbce6d69 589}
590
591void
864dbfa3 592Perl_set_numeric_local(pTHX)
bbce6d69 593{
5f05dabc 594#ifdef USE_LOCALE_NUMERIC
595
3280af22
NIS		 596 if (! PL_numeric_local) {
597 setlocale(LC_NUMERIC, PL_numeric_name);
598 PL_numeric_standard = FALSE;
599 PL_numeric_local = TRUE;
51371543 600 set_numeric_radix();
bbce6d69 601 }
bbce6d69 602
36477c24 603#endif /* USE_LOCALE_NUMERIC */
5f05dabc 604}
36477c24 605
36477c24 606/*
607 * Initialize locale awareness.
608 */
f0c5b223 609int
864dbfa3 610Perl_init_i18nl10n(pTHX_ int printwarn)
f0c5b223
TB		 611{
612 int ok = 1;
613 /* returns
614 * 1 = set ok or not applicable,
615 * 0 = fallback to C locale,
616 * -1 = fallback to C locale failed
617 */
bbce6d69 618
36477c24 619#ifdef USE_LOCALE
bbce6d69 620
36477c24 621#ifdef USE_LOCALE_CTYPE
bbce6d69 622 char *curctype = NULL;
36477c24 623#endif /* USE_LOCALE_CTYPE */
624#ifdef USE_LOCALE_COLLATE
bbce6d69 625 char *curcoll = NULL;
36477c24 626#endif /* USE_LOCALE_COLLATE */
627#ifdef USE_LOCALE_NUMERIC
bbce6d69 628 char *curnum = NULL;
36477c24 629#endif /* USE_LOCALE_NUMERIC */
3aeabbed
JH		 630#ifdef __GLIBC__
631 char *language = PerlEnv_getenv("LANGUAGE");
632#endif
76e3520e
GS		 633 char *lc_all = PerlEnv_getenv("LC_ALL");
634 char *lang = PerlEnv_getenv("LANG");
bbce6d69 635 bool setlocale_failure = FALSE;
f0c5b223 636
02b32252
CS		 637#ifdef LOCALE_ENVIRON_REQUIRED
638
639 /*
640 * Ultrix setlocale(..., "") fails if there are no environment
641 * variables from which to get a locale name.
642 */
643
644 bool done = FALSE;
645
646#ifdef LC_ALL
647 if (lang) {
648 if (setlocale(LC_ALL, ""))
649 done = TRUE;
650 else
651 setlocale_failure = TRUE;
652 }
0644c9cb 653 if (!setlocale_failure) {
02b32252 654#ifdef USE_LOCALE_CTYPE
0644c9cb
IS		 655 if (! (curctype =
656 setlocale(LC_CTYPE,
657 (!done && (lang || PerlEnv_getenv("LC_CTYPE")))
02b32252
CS		 658 ? "" : Nullch)))
659 setlocale_failure = TRUE;
660#endif /* USE_LOCALE_CTYPE */
661#ifdef USE_LOCALE_COLLATE
0644c9cb
IS		 662 if (! (curcoll =
663 setlocale(LC_COLLATE,
664 (!done && (lang || PerlEnv_getenv("LC_COLLATE")))
02b32252
CS		 665 ? "" : Nullch)))
666 setlocale_failure = TRUE;
667#endif /* USE_LOCALE_COLLATE */
668#ifdef USE_LOCALE_NUMERIC
0644c9cb
IS		 669 if (! (curnum =
670 setlocale(LC_NUMERIC,
671 (!done && (lang || PerlEnv_getenv("LC_NUMERIC")))
02b32252
CS		 672 ? "" : Nullch)))
673 setlocale_failure = TRUE;
674#endif /* USE_LOCALE_NUMERIC */
675 }
676
0644c9cb 677#endif /* LC_ALL */
02b32252 678
0644c9cb 679#endif /* !LOCALE_ENVIRON_REQUIRED */
5f05dabc 680
0644c9cb 681#ifdef LC_ALL
bbce6d69 682 if (! setlocale(LC_ALL, ""))
683 setlocale_failure = TRUE;
0644c9cb 684#endif /* LC_ALL */
bbce6d69 685
0644c9cb 686 if (!setlocale_failure) {
36477c24 687#ifdef USE_LOCALE_CTYPE
0644c9cb
IS		 688 if (! (curctype = setlocale(LC_CTYPE, "")))
689 setlocale_failure = TRUE;
36477c24 690#endif /* USE_LOCALE_CTYPE */
691#ifdef USE_LOCALE_COLLATE
0644c9cb
IS		 692 if (! (curcoll = setlocale(LC_COLLATE, "")))
693 setlocale_failure = TRUE;
36477c24 694#endif /* USE_LOCALE_COLLATE */
695#ifdef USE_LOCALE_NUMERIC
0644c9cb
IS		 696 if (! (curnum = setlocale(LC_NUMERIC, "")))
697 setlocale_failure = TRUE;
36477c24 698#endif /* USE_LOCALE_NUMERIC */
0644c9cb 699 }
02b32252 700
5f05dabc 701 if (setlocale_failure) {
702 char *p;
703 bool locwarn = (printwarn > 1 ||
155aba94
GS		 704 (printwarn &&
705 (!(p = PerlEnv_getenv("PERL_BADLANG")) || atoi(p))));
20cec16a 706
5f05dabc 707 if (locwarn) {
708#ifdef LC_ALL
709
bf49b057 710 PerlIO_printf(Perl_error_log,
5f05dabc 711 "perl: warning: Setting locale failed.\n");
712
713#else /* !LC_ALL */
714
bf49b057 715 PerlIO_printf(Perl_error_log,
bbce6d69 716 "perl: warning: Setting locale failed for the categories:\n\t");
36477c24 717#ifdef USE_LOCALE_CTYPE
bbce6d69 718 if (! curctype)
bf49b057 719 PerlIO_printf(Perl_error_log, "LC_CTYPE ");
36477c24 720#endif /* USE_LOCALE_CTYPE */
721#ifdef USE_LOCALE_COLLATE
bbce6d69 722 if (! curcoll)
bf49b057 723 PerlIO_printf(Perl_error_log, "LC_COLLATE ");
36477c24 724#endif /* USE_LOCALE_COLLATE */
725#ifdef USE_LOCALE_NUMERIC
bbce6d69 726 if (! curnum)
bf49b057 727 PerlIO_printf(Perl_error_log, "LC_NUMERIC ");
36477c24 728#endif /* USE_LOCALE_NUMERIC */
bf49b057 729 PerlIO_printf(Perl_error_log, "\n");
bbce6d69 730
5f05dabc 731#endif /* LC_ALL */
732
bf49b057 733 PerlIO_printf(Perl_error_log,
bbce6d69 734 "perl: warning: Please check that your locale settings:\n");
ef7eada9 735
3aeabbed 736#ifdef __GLIBC__
bf49b057 737 PerlIO_printf(Perl_error_log,
3aeabbed
JH		 738 "\tLANGUAGE = %c%s%c,\n",
739 language ? '"' : '(',
740 language ? language : "unset",
741 language ? '"' : ')');
742#endif
743
bf49b057 744 PerlIO_printf(Perl_error_log,
bbce6d69 745 "\tLC_ALL = %c%s%c,\n",
746 lc_all ? '"' : '(',
747 lc_all ? lc_all : "unset",
748 lc_all ? '"' : ')');
5f05dabc 749
750 {
751 char **e;
752 for (e = environ; *e; e++) {
753 if (strnEQ(*e, "LC_", 3)
754 && strnNE(*e, "LC_ALL=", 7)
755 && (p = strchr(*e, '=')))
bf49b057 756 PerlIO_printf(Perl_error_log, "\t%.*s = \"%s\",\n",
fb73857a 757 (int)(p - *e), *e, p + 1);
5f05dabc 758 }
759 }
760
bf49b057 761 PerlIO_printf(Perl_error_log,
bbce6d69 762 "\tLANG = %c%s%c\n",
5f05dabc 763 lang ? '"' : '(',
bbce6d69 764 lang ? lang : "unset",
765 lang ? '"' : ')');
ef7eada9 766
bf49b057 767 PerlIO_printf(Perl_error_log,
bbce6d69 768 " are supported and installed on your system.\n");
5f05dabc 769 }
ef7eada9 770
5f05dabc 771#ifdef LC_ALL
772
773 if (setlocale(LC_ALL, "C")) {
774 if (locwarn)
bf49b057 775 PerlIO_printf(Perl_error_log,
5f05dabc 776 "perl: warning: Falling back to the standard locale (\"C\").\n");
bbce6d69 777 ok = 0;
ef7eada9 778 }
5f05dabc 779 else {
780 if (locwarn)
bf49b057 781 PerlIO_printf(Perl_error_log,
5f05dabc 782 "perl: warning: Failed to fall back to the standard locale (\"C\").\n");
783 ok = -1;
784 }
bbce6d69 785
5f05dabc 786#else /* ! LC_ALL */
787
788 if (0
36477c24 789#ifdef USE_LOCALE_CTYPE
5f05dabc 790 || !(curctype || setlocale(LC_CTYPE, "C"))
36477c24 791#endif /* USE_LOCALE_CTYPE */
792#ifdef USE_LOCALE_COLLATE
5f05dabc 793 || !(curcoll || setlocale(LC_COLLATE, "C"))
36477c24 794#endif /* USE_LOCALE_COLLATE */
795#ifdef USE_LOCALE_NUMERIC
5f05dabc 796 || !(curnum || setlocale(LC_NUMERIC, "C"))
36477c24 797#endif /* USE_LOCALE_NUMERIC */
5f05dabc 798 )
799 {
800 if (locwarn)
bf49b057 801 PerlIO_printf(Perl_error_log,
5f05dabc 802 "perl: warning: Cannot fall back to the standard locale (\"C\").\n");
803 ok = -1;
bbce6d69 804 }
5f05dabc 805
bbce6d69 806#endif /* ! LC_ALL */
5f05dabc 807
808#ifdef USE_LOCALE_CTYPE
809 curctype = setlocale(LC_CTYPE, Nullch);
810#endif /* USE_LOCALE_CTYPE */
811#ifdef USE_LOCALE_COLLATE
812 curcoll = setlocale(LC_COLLATE, Nullch);
813#endif /* USE_LOCALE_COLLATE */
814#ifdef USE_LOCALE_NUMERIC
815 curnum = setlocale(LC_NUMERIC, Nullch);
816#endif /* USE_LOCALE_NUMERIC */
ef7eada9
JH		 817 }
818
36477c24 819#ifdef USE_LOCALE_CTYPE
864dbfa3 820 new_ctype(curctype);
36477c24 821#endif /* USE_LOCALE_CTYPE */
bbce6d69 822
36477c24 823#ifdef USE_LOCALE_COLLATE
864dbfa3 824 new_collate(curcoll);
36477c24 825#endif /* USE_LOCALE_COLLATE */
bbce6d69 826
36477c24 827#ifdef USE_LOCALE_NUMERIC
864dbfa3 828 new_numeric(curnum);
36477c24 829#endif /* USE_LOCALE_NUMERIC */
ef7eada9 830
36477c24 831#endif /* USE_LOCALE */
ef7eada9 832
f0c5b223
TB		 833 return ok;
834}
835
bbce6d69 836/* Backwards compatibility. */
837int
864dbfa3 838Perl_init_i18nl14n(pTHX_ int printwarn)
bbce6d69 839{
864dbfa3 840 return init_i18nl10n(printwarn);
bbce6d69 841}
ef7eada9 842
36477c24 843#ifdef USE_LOCALE_COLLATE
ef7eada9 844
bbce6d69 845/*
846 * mem_collxfrm() is a bit like strxfrm() but with two important
847 * differences. First, it handles embedded NULs. Second, it allocates
848 * a bit more memory than needed for the transformed data itself.
849 * The real transformed data begins at offset sizeof(collationix).
850 * Please see sv_collxfrm() to see how this is used.
851 */
852char *
864dbfa3 853Perl_mem_collxfrm(pTHX_ const char *s, STRLEN len, STRLEN *xlen)
bbce6d69 854{
855 char *xbuf;
76e3520e 856 STRLEN xAlloc, xin, xout; /* xalloc is a reserved word in VC */
bbce6d69 857
858 /* the first sizeof(collationix) bytes are used by sv_collxfrm(). */
859 /* the +1 is for the terminating NUL. */
860
3280af22 861 xAlloc = sizeof(PL_collation_ix) + PL_collxfrm_base + (PL_collxfrm_mult * len) + 1;
76e3520e 862 New(171, xbuf, xAlloc, char);
bbce6d69 863 if (! xbuf)
864 goto bad;
865
3280af22
NIS		 866 *(U32*)xbuf = PL_collation_ix;
867 xout = sizeof(PL_collation_ix);
bbce6d69 868 for (xin = 0; xin < len; ) {
869 SSize_t xused;
870
871 for (;;) {
76e3520e 872 xused = strxfrm(xbuf + xout, s + xin, xAlloc - xout);
bbce6d69 873 if (xused == -1)
874 goto bad;
76e3520e 875 if (xused < xAlloc - xout)
bbce6d69 876 break;
76e3520e
GS		 877 xAlloc = (2 * xAlloc) + 1;
878 Renew(xbuf, xAlloc, char);
bbce6d69 879 if (! xbuf)
880 goto bad;
881 }
ef7eada9 882
bbce6d69 883 xin += strlen(s + xin) + 1;
884 xout += xused;
885
886 /* Embedded NULs are understood but silently skipped
887 * because they make no sense in locale collation. */
888 }
ef7eada9 889
bbce6d69 890 xbuf[xout] = '\0';
3280af22 891 *xlen = xout - sizeof(PL_collation_ix);
bbce6d69 892 return xbuf;
893
894 bad:
895 Safefree(xbuf);
896 *xlen = 0;
897 return NULL;
ef7eada9
JH		 898}
899
36477c24 900#endif /* USE_LOCALE_COLLATE */
bbce6d69 901
cf93c79d
IZ		 902#define FBM_TABLE_OFFSET 2 /* Number of bytes between EOS and table*/
903
904/* As a space optimization, we do not compile tables for strings of length
905 0 and 1, and for strings of length 2 unless FBMcf_TAIL. These are
906 special-cased in fbm_instr().
907
908 If FBMcf_TAIL, the table is created as if the string has a trailing \n. */
909
954c1994
GS		 910/*
911=for apidoc fbm_compile
912
913Analyses the string in order to make fast searches on it using fbm_instr()
914-- the Boyer-Moore algorithm.
915
916=cut
917*/
918
378cc40b 919void
7506f9c3 920Perl_fbm_compile(pTHX_ SV *sv, U32 flags)
378cc40b 921{
942e002e
GS		 922 register U8 *s;
923 register U8 *table;
79072805 924 register U32 i;
0b71040e 925 STRLEN len;
79072805
LW		 926 I32 rarest = 0;
927 U32 frequency = 256;
928
cf93c79d
IZ		 929 if (flags & FBMcf_TAIL)
930 sv_catpvn(sv, "\n", 1); /* Taken into account in fbm_instr() */
942e002e 931 s = (U8*)SvPV_force(sv, len);
07f14f54 932 (void)SvUPGRADE(sv, SVt_PVBM);
cf93c79d
IZ		 933 if (len == 0) /* TAIL might be on on a zero-length string. */
934 return;
02128f11 935 if (len > 2) {
7506f9c3 936 U8 mlen;
cf93c79d
IZ		 937 unsigned char *sb;
938
7506f9c3 939 if (len > 255)
cf93c79d 940 mlen = 255;
7506f9c3
GS		 941 else
942 mlen = (U8)len;
943 Sv_Grow(sv, len + 256 + FBM_TABLE_OFFSET);
cf93c79d 944 table = (unsigned char*)(SvPVX(sv) + len + FBM_TABLE_OFFSET);
7506f9c3
GS		 945 s = table - 1 - FBM_TABLE_OFFSET; /* last char */
946 memset((void*)table, mlen, 256);
947 table[-1] = (U8)flags;
02128f11 948 i = 0;
7506f9c3 949 sb = s - mlen + 1; /* first char (maybe) */
cf93c79d
IZ		 950 while (s >= sb) {
951 if (table[*s] == mlen)
7506f9c3 952 table[*s] = (U8)i;
cf93c79d
IZ		 953 s--, i++;
954 }
378cc40b 955 }
bbce6d69 956 sv_magic(sv, Nullsv, 'B', Nullch, 0); /* deep magic */
79072805 957 SvVALID_on(sv);
378cc40b 958
463ee0b2 959 s = (unsigned char*)(SvPVX(sv)); /* deeper magic */
bbce6d69 960 for (i = 0; i < len; i++) {
22c35a8c 961 if (PL_freq[s[i]] < frequency) {
bbce6d69 962 rarest = i;
22c35a8c 963 frequency = PL_freq[s[i]];
378cc40b
LW		 964 }
965 }
79072805
LW		 966 BmRARE(sv) = s[rarest];
967 BmPREVIOUS(sv) = rarest;
cf93c79d
IZ		 968 BmUSEFUL(sv) = 100; /* Initial value */
969 if (flags & FBMcf_TAIL)
970 SvTAIL_on(sv);
7506f9c3
GS		 971 DEBUG_r(PerlIO_printf(Perl_debug_log, "rarest char %c at %d\n",
972 BmRARE(sv),BmPREVIOUS(sv)));
378cc40b
LW		 973}
974
cf93c79d
IZ		 975/* If SvTAIL(littlestr), it has a fake '\n' at end. */
976/* If SvTAIL is actually due to \Z or \z, this gives false positives
977 if multiline */
978
954c1994
GS		 979/*
980=for apidoc fbm_instr
981
982Returns the location of the SV in the string delimited by C<str> and
983C<strend>. It returns C<Nullch> if the string can't be found. The C<sv>
984does not have to be fbm_compiled, but the search will not be as fast
985then.
986
987=cut
988*/
989
378cc40b 990char *
864dbfa3 991Perl_fbm_instr(pTHX_ unsigned char *big, register unsigned char *bigend, SV *littlestr, U32 flags)
378cc40b 992{
a687059c 993 register unsigned char *s;
cf93c79d
IZ		 994 STRLEN l;
995 register unsigned char *little = (unsigned char *)SvPV(littlestr,l);
996 register STRLEN littlelen = l;
997 register I32 multiline = flags & FBMrf_MULTILINE;
998
999 if (bigend - big < littlelen) {
cf93c79d
IZ		 1000 if ( SvTAIL(littlestr)
1001 && (bigend - big == littlelen - 1)
1002 && (littlelen == 1
155aba94 1003 || (*big == *little && memEQ(big, little, littlelen - 1))))
cf93c79d
IZ		 1004 return (char*)big;
1005 return Nullch;
1006 }
378cc40b 1007
cf93c79d 1008 if (littlelen <= 2) { /* Special-cased */
cf93c79d
IZ		 1009
1010 if (littlelen == 1) {
1011 if (SvTAIL(littlestr) && !multiline) { /* Anchor only! */
1012 /* Know that bigend != big. */
1013 if (bigend[-1] == '\n')
1014 return (char *)(bigend - 1);
1015 return (char *) bigend;
1016 }
1017 s = big;
1018 while (s < bigend) {
1019 if (*s == *little)
1020 return (char *)s;
1021 s++;
1022 }
1023 if (SvTAIL(littlestr))
1024 return (char *) bigend;
1025 return Nullch;
1026 }
1027 if (!littlelen)
1028 return (char*)big; /* Cannot be SvTAIL! */
1029
1030 /* littlelen is 2 */
1031 if (SvTAIL(littlestr) && !multiline) {
1032 if (bigend[-1] == '\n' && bigend[-2] == *little)
1033 return (char*)bigend - 2;
1034 if (bigend[-1] == *little)
1035 return (char*)bigend - 1;
1036 return Nullch;
1037 }
1038 {
1039 /* This should be better than FBM if c1 == c2, and almost
1040 as good otherwise: maybe better since we do less indirection.
1041 And we save a lot of memory by caching no table. */
1042 register unsigned char c1 = little[0];
1043 register unsigned char c2 = little[1];
1044
1045 s = big + 1;
1046 bigend--;
1047 if (c1 != c2) {
1048 while (s <= bigend) {
1049 if (s[0] == c2) {
1050 if (s[-1] == c1)
1051 return (char*)s - 1;
1052 s += 2;
1053 continue;
3fe6f2dc 1054 }
cf93c79d
IZ		 1055 next_chars:
1056 if (s[0] == c1) {
1057 if (s == bigend)
1058 goto check_1char_anchor;
1059 if (s[1] == c2)
1060 return (char*)s;
1061 else {
1062 s++;
1063 goto next_chars;
1064 }
1065 }
1066 else
1067 s += 2;
1068 }
1069 goto check_1char_anchor;
1070 }
1071 /* Now c1 == c2 */
1072 while (s <= bigend) {
1073 if (s[0] == c1) {
1074 if (s[-1] == c1)
1075 return (char*)s - 1;
1076 if (s == bigend)
1077 goto check_1char_anchor;
1078 if (s[1] == c1)
1079 return (char*)s;
1080 s += 3;
02128f11 1081 }
c277df42 1082 else
cf93c79d 1083 s += 2;
c277df42 1084 }
c277df42 1085 }
cf93c79d
IZ		 1086 check_1char_anchor: /* One char and anchor! */
1087 if (SvTAIL(littlestr) && (*bigend == *little))
1088 return (char *)bigend; /* bigend is already decremented. */
1089 return Nullch;
d48672a2 1090 }
cf93c79d 1091 if (SvTAIL(littlestr) && !multiline) { /* tail anchored? */
bbce6d69 1092 s = bigend - littlelen;
7506f9c3 1093 if (s >= big && bigend[-1] == '\n' && *s == *little
cf93c79d
IZ		 1094 /* Automatically of length > 2 */
1095 && memEQ((char*)s + 1, (char*)little + 1, littlelen - 2))
7506f9c3 1096 {
bbce6d69 1097 return (char*)s; /* how sweet it is */
7506f9c3
GS		 1098 }
1099 if (s[1] == *little
1100 && memEQ((char*)s + 2, (char*)little + 1, littlelen - 2))
1101 {
cf93c79d 1102 return (char*)s + 1; /* how sweet it is */
7506f9c3 1103 }
02128f11
IZ		 1104 return Nullch;
1105 }
cf93c79d
IZ		 1106 if (SvTYPE(littlestr) != SVt_PVBM || !SvVALID(littlestr)) {
1107 char *b = ninstr((char*)big,(char*)bigend,
1108 (char*)little, (char*)little + littlelen);
1109
1110 if (!b && SvTAIL(littlestr)) { /* Automatically multiline! */
1111 /* Chop \n from littlestr: */
1112 s = bigend - littlelen + 1;
7506f9c3
GS		 1113 if (*s == *little
1114 && memEQ((char*)s + 1, (char*)little + 1, littlelen - 2))
1115 {
3fe6f2dc 1116 return (char*)s;
7506f9c3 1117 }
cf93c79d 1118 return Nullch;
a687059c 1119 }
cf93c79d 1120 return b;
a687059c 1121 }
cf93c79d
IZ		 1122
1123 { /* Do actual FBM. */
1124 register unsigned char *table = little + littlelen + FBM_TABLE_OFFSET;
1125 register unsigned char *oldlittle;
1126
1127 if (littlelen > bigend - big)
1128 return Nullch;
1129 --littlelen; /* Last char found by table lookup */
1130
1131 s = big + littlelen;
1132 little += littlelen; /* last char */
1133 oldlittle = little;
1134 if (s < bigend) {
1135 register I32 tmp;
1136
1137 top2:
1138 /*SUPPRESS 560*/
7506f9c3 1139 if ((tmp = table[*s])) {
62b28dd9 1140#ifdef POINTERRIGOR
cf93c79d
IZ		 1141 if (bigend - s > tmp) {
1142 s += tmp;
1143 goto top2;
1144 }
bbce6d69 1145 s += tmp;
62b28dd9 1146#else
cf93c79d 1147 if ((s += tmp) < bigend)
62b28dd9 1148 goto top2;
cf93c79d
IZ		 1149#endif
1150 goto check_end;
1151 }
1152 else { /* less expensive than calling strncmp() */
1153 register unsigned char *olds = s;
1154
1155 tmp = littlelen;
1156
1157 while (tmp--) {
1158 if (*--s == *--little)
1159 continue;
cf93c79d
IZ		 1160 s = olds + 1; /* here we pay the price for failure */
1161 little = oldlittle;
1162 if (s < bigend) /* fake up continue to outer loop */
1163 goto top2;
1164 goto check_end;
1165 }
1166 return (char *)s;
a687059c 1167 }
378cc40b 1168 }
cf93c79d
IZ		 1169 check_end:
1170 if ( s == bigend && (table[-1] & FBMcf_TAIL)
1171 && memEQ(bigend - littlelen, oldlittle - littlelen, littlelen) )
1172 return (char*)bigend - littlelen;
1173 return Nullch;
378cc40b 1174 }
378cc40b
LW		 1175}
1176
c277df42
IZ		 1177/* start_shift, end_shift are positive quantities which give offsets
1178 of ends of some substring of bigstr.
1179 If `last' we want the last occurence.
1180 old_posp is the way of communication between consequent calls if
1181 the next call needs to find the .
1182 The initial *old_posp should be -1.
cf93c79d
IZ		 1183
1184 Note that we take into account SvTAIL, so one can get extra
1185 optimizations if _ALL flag is set.
c277df42
IZ		 1186 */
1187
cf93c79d
IZ		 1188/* If SvTAIL is actually due to \Z or \z, this gives false positives
1189 if PL_multiline. In fact if !PL_multiline the autoritative answer
1190 is not supported yet. */
1191
378cc40b 1192char *
864dbfa3 1193Perl_screaminstr(pTHX_ SV *bigstr, SV *littlestr, I32 start_shift, I32 end_shift, I32 *old_posp, I32 last)
378cc40b 1194{
5c0ca799 1195 dTHR;
a687059c
LW		 1196 register unsigned char *s, *x;
1197 register unsigned char *big;
79072805
LW		 1198 register I32 pos;
1199 register I32 previous;
1200 register I32 first;
a687059c 1201 register unsigned char *little;
c277df42 1202 register I32 stop_pos;
a687059c 1203 register unsigned char *littleend;
c277df42 1204 I32 found = 0;
378cc40b 1205
c277df42 1206 if (*old_posp == -1
3280af22 1207 ? (pos = PL_screamfirst[BmRARE(littlestr)]) < 0
cf93c79d
IZ		 1208 : (((pos = *old_posp), pos += PL_screamnext[pos]) == 0)) {
1209 cant_find:
1210 if ( BmRARE(littlestr) == '\n'
1211 && BmPREVIOUS(littlestr) == SvCUR(littlestr) - 1) {
1212 little = (unsigned char *)(SvPVX(littlestr));
1213 littleend = little + SvCUR(littlestr);
1214 first = *little++;
1215 goto check_tail;
1216 }
378cc40b 1217 return Nullch;
cf93c79d
IZ		 1218 }
1219
463ee0b2 1220 little = (unsigned char *)(SvPVX(littlestr));
79072805 1221 littleend = little + SvCUR(littlestr);
378cc40b 1222 first = *little++;
c277df42 1223 /* The value of pos we can start at: */
79072805 1224 previous = BmPREVIOUS(littlestr);
463ee0b2 1225 big = (unsigned char *)(SvPVX(bigstr));
c277df42
IZ		 1226 /* The value of pos we can stop at: */
1227 stop_pos = SvCUR(bigstr) - end_shift - (SvCUR(littlestr) - 1 - previous);
cf93c79d
IZ		 1228 if (previous + start_shift > stop_pos) {
1229 if (previous + start_shift == stop_pos + 1) /* A fake '\n'? */
1230 goto check_tail;
1231 return Nullch;
1232 }
c277df42 1233 while (pos < previous + start_shift) {
3280af22 1234 if (!(pos += PL_screamnext[pos]))
cf93c79d 1235 goto cant_find;
378cc40b 1236 }
de3bb511 1237#ifdef POINTERRIGOR
bbce6d69 1238 do {
ef64f398 1239 if (pos >= stop_pos) break;
bbce6d69 1240 if (big[pos-previous] != first)
1241 continue;
1242 for (x=big+pos+1-previous,s=little; s < littleend; /**/ ) {
bbce6d69 1243 if (*s++ != *x++) {
1244 s--;
1245 break;
de3bb511 1246 }
bbce6d69 1247 }
c277df42
IZ		 1248 if (s == littleend) {
1249 *old_posp = pos;
1250 if (!last) return (char *)(big+pos-previous);
1251 found = 1;
1252 }
6b88bc9c 1253 } while ( pos += PL_screamnext[pos] );
c277df42 1254 return (last && found) ? (char *)(big+(*old_posp)-previous) : Nullch;
de3bb511
LW		 1255#else /* !POINTERRIGOR */
1256 big -= previous;
bbce6d69 1257 do {
ef64f398 1258 if (pos >= stop_pos) break;
bbce6d69 1259 if (big[pos] != first)
1260 continue;
1261 for (x=big+pos+1,s=little; s < littleend; /**/ ) {
bbce6d69 1262 if (*s++ != *x++) {
1263 s--;
1264 break;
378cc40b 1265 }
bbce6d69 1266 }
c277df42
IZ		 1267 if (s == littleend) {
1268 *old_posp = pos;
1269 if (!last) return (char *)(big+pos);
1270 found = 1;
1271 }
3280af22 1272 } while ( pos += PL_screamnext[pos] );
cf93c79d
IZ		 1273 if (last && found)
1274 return (char *)(big+(*old_posp));
de3bb511 1275#endif /* POINTERRIGOR */
cf93c79d
IZ		 1276 check_tail:
1277 if (!SvTAIL(littlestr) || (end_shift > 0))
1278 return Nullch;
1279 /* Ignore the trailing "\n". This code is not microoptimized */
1280 big = (unsigned char *)(SvPVX(bigstr) + SvCUR(bigstr));
1281 stop_pos = littleend - little; /* Actual littlestr len */
1282 if (stop_pos == 0)
1283 return (char*)big;
1284 big -= stop_pos;
1285 if (*big == first
1286 && ((stop_pos == 1) || memEQ(big + 1, little, stop_pos - 1)))
1287 return (char*)big;
1288 return Nullch;
8d063cd8
LW		 1289}
1290
79072805 1291I32
864dbfa3 1292Perl_ibcmp(pTHX_ const char *s1, const char *s2, register I32 len)
79072805 1293{
bbce6d69 1294 register U8 *a = (U8 *)s1;
1295 register U8 *b = (U8 *)s2;
79072805 1296 while (len--) {
22c35a8c 1297 if (*a != *b && *a != PL_fold[*b])
bbce6d69 1298 return 1;
1299 a++,b++;
1300 }
1301 return 0;
1302}
1303
1304I32
864dbfa3 1305Perl_ibcmp_locale(pTHX_ const char *s1, const char *s2, register I32 len)
bbce6d69 1306{
1307 register U8 *a = (U8 *)s1;
1308 register U8 *b = (U8 *)s2;
1309 while (len--) {
22c35a8c 1310 if (*a != *b && *a != PL_fold_locale[*b])
bbce6d69 1311 return 1;
1312 a++,b++;
79072805
LW		 1313 }
1314 return 0;
1315}
1316
8d063cd8
LW		 1317/* copy a string to a safe spot */
1318
954c1994
GS		 1319/*
1320=for apidoc savepv
1321
1322Copy a string to a safe spot. This does not use an SV.
1323
1324=cut
1325*/
1326
8d063cd8 1327char *
864dbfa3 1328Perl_savepv(pTHX_ const char *sv)
8d063cd8 1329{
a687059c 1330 register char *newaddr;
8d063cd8 1331
79072805
LW		 1332 New(902,newaddr,strlen(sv)+1,char);
1333 (void)strcpy(newaddr,sv);
8d063cd8
LW		 1334 return newaddr;
1335}
1336
a687059c
LW		 1337/* same thing but with a known length */
1338
954c1994
GS		 1339/*
1340=for apidoc savepvn
1341
1342Copy a string to a safe spot. The C<len> indicates number of bytes to
1343copy. This does not use an SV.
1344
1345=cut
1346*/
1347
a687059c 1348char *
864dbfa3 1349Perl_savepvn(pTHX_ const char *sv, register I32 len)
a687059c
LW		 1350{
1351 register char *newaddr;
1352
1353 New(903,newaddr,len+1,char);
79072805 1354 Copy(sv,newaddr,len,char); /* might not be null terminated */
a687059c
LW		 1355 newaddr[len] = '\0'; /* is now */
1356 return newaddr;
1357}
1358
cea2e8a9 1359/* the SV for Perl_form() and mess() is not kept in an arena */
fc36a67e 1360
76e3520e 1361STATIC SV *
cea2e8a9 1362S_mess_alloc(pTHX)
fc36a67e 1363{
e72dc28c 1364 dTHR;
fc36a67e 1365 SV *sv;
1366 XPVMG *any;
1367
e72dc28c
GS		 1368 if (!PL_dirty)
1369 return sv_2mortal(newSVpvn("",0));
1370
0372dbb6
GS		 1371 if (PL_mess_sv)
1372 return PL_mess_sv;
1373
fc36a67e 1374 /* Create as PVMG now, to avoid any upgrading later */
1375 New(905, sv, 1, SV);
1376 Newz(905, any, 1, XPVMG);
1377 SvFLAGS(sv) = SVt_PVMG;
1378 SvANY(sv) = (void*)any;
1379 SvREFCNT(sv) = 1 << 30; /* practically infinite */
e72dc28c 1380 PL_mess_sv = sv;
fc36a67e 1381 return sv;
1382}
1383
c5be433b 1384#if defined(PERL_IMPLICIT_CONTEXT)
cea2e8a9
GS		 1385char *
1386Perl_form_nocontext(const char* pat, ...)
1387{
1388 dTHX;
c5be433b 1389 char *retval;
cea2e8a9
GS		 1390 va_list args;
1391 va_start(args, pat);
c5be433b 1392 retval = vform(pat, &args);
cea2e8a9 1393 va_end(args);
c5be433b 1394 return retval;
cea2e8a9 1395}
c5be433b 1396#endif /* PERL_IMPLICIT_CONTEXT */
cea2e8a9 1397
8990e307 1398char *
864dbfa3 1399Perl_form(pTHX_ const char* pat, ...)
8990e307 1400{
c5be433b 1401 char *retval;
46fc3d4c 1402 va_list args;
46fc3d4c 1403 va_start(args, pat);
c5be433b 1404 retval = vform(pat, &args);
46fc3d4c 1405 va_end(args);
c5be433b
GS		 1406 return retval;
1407}
1408
1409char *
1410Perl_vform(pTHX_ const char *pat, va_list *args)
1411{
1412 SV *sv = mess_alloc();
1413 sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
e72dc28c 1414 return SvPVX(sv);
46fc3d4c 1415}
a687059c 1416
5a844595
GS		 1417#if defined(PERL_IMPLICIT_CONTEXT)
1418SV *
1419Perl_mess_nocontext(const char *pat, ...)
1420{
1421 dTHX;
1422 SV *retval;
1423 va_list args;
1424 va_start(args, pat);
1425 retval = vmess(pat, &args);
1426 va_end(args);
1427 return retval;
1428}
1429#endif /* PERL_IMPLICIT_CONTEXT */
1430
06bf62c7 1431SV *
5a844595
GS		 1432Perl_mess(pTHX_ const char *pat, ...)
1433{
1434 SV *retval;
1435 va_list args;
1436 va_start(args, pat);
1437 retval = vmess(pat, &args);
1438 va_end(args);
1439 return retval;
1440}
1441
1442SV *
1443Perl_vmess(pTHX_ const char *pat, va_list *args)
46fc3d4c 1444{
e72dc28c 1445 SV *sv = mess_alloc();
46fc3d4c 1446 static char dgd[] = " during global destruction.\n";
1447
fc36a67e 1448 sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
46fc3d4c 1449 if (!SvCUR(sv) || *(SvEND(sv) - 1) != '\n') {
e858de61 1450 dTHR;
57843af0 1451 if (CopLINE(PL_curcop))
ed094faf
GS		 1452 Perl_sv_catpvf(aTHX_ sv, " at %s line %"IVdf,
1453 CopFILE(PL_curcop), (IV)CopLINE(PL_curcop));
515f54a1
GS		 1454 if (GvIO(PL_last_in_gv) && IoLINES(GvIOp(PL_last_in_gv))) {
1455 bool line_mode = (RsSIMPLE(PL_rs) &&
7c1e0849 1456 SvCUR(PL_rs) == 1 && *SvPVX(PL_rs) == '\n');
57def98f 1457 Perl_sv_catpvf(aTHX_ sv, ", <%s> %s %"IVdf,
cf2093f6
JH		 1458 PL_last_in_gv == PL_argvgv ? "" : GvNAME(PL_last_in_gv),
1459 line_mode ? "line" : "chunk",
1460 (IV)IoLINES(GvIOp(PL_last_in_gv)));
a687059c 1461 }
9efbc0eb 1462#ifdef USE_THREADS
e8e6f333
GS		 1463 if (thr->tid)
1464 Perl_sv_catpvf(aTHX_ sv, " thread %ld", thr->tid);
9efbc0eb 1465#endif
515f54a1 1466 sv_catpv(sv, PL_dirty ? dgd : ".\n");
a687059c 1467 }
06bf62c7 1468 return sv;
a687059c
LW		 1469}
1470
c5be433b
GS		 1471OP *
1472Perl_vdie(pTHX_ const char* pat, va_list *args)
36477c24 1473{
5dc0d613 1474 dTHR;
36477c24 1475 char *message;
3280af22 1476 int was_in_eval = PL_in_eval;
36477c24 1477 HV *stash;
1478 GV *gv;
1479 CV *cv;
06bf62c7
GS		 1480 SV *msv;
1481 STRLEN msglen;
36477c24 1482
bf49b057 1483 DEBUG_S(PerlIO_printf(Perl_debug_log,
199100c8 1484 "%p: die: curstack = %p, mainstack = %p\n",
533c011a 1485 thr, PL_curstack, PL_mainstack));
36477c24 1486
06bf62c7 1487 if (pat) {
5a844595
GS		 1488 msv = vmess(pat, args);
1489 if (PL_errors && SvCUR(PL_errors)) {
1490 sv_catsv(PL_errors, msv);
1491 message = SvPV(PL_errors, msglen);
1492 SvCUR_set(PL_errors, 0);
1493 }
1494 else
1495 message = SvPV(msv,msglen);
06bf62c7
GS		 1496 }
1497 else {
1498 message = Nullch;
0f79a09d 1499 msglen = 0;
06bf62c7 1500 }
36477c24 1501
bf49b057 1502 DEBUG_S(PerlIO_printf(Perl_debug_log,
199100c8 1503 "%p: die: message = %s\ndiehook = %p\n",
533c011a 1504 thr, message, PL_diehook));
3280af22 1505 if (PL_diehook) {
cea2e8a9 1506 /* sv_2cv might call Perl_croak() */
3280af22 1507 SV *olddiehook = PL_diehook;
1738f5c4 1508 ENTER;
3280af22
NIS		 1509 SAVESPTR(PL_diehook);
1510 PL_diehook = Nullsv;
1738f5c4
CS		 1511 cv = sv_2cv(olddiehook, &stash, &gv, 0);
1512 LEAVE;
1513 if (cv && !CvDEPTH(cv) && (CvROOT(cv) || CvXSUB(cv))) {
1514 dSP;
774d564b 1515 SV *msg;
1516
1517 ENTER;
3a1f2dc9 1518 save_re_context();
79cb57f6 1519 if (message) {
06bf62c7 1520 msg = newSVpvn(message, msglen);
4e6ea2c3
GS		 1521 SvREADONLY_on(msg);
1522 SAVEFREESV(msg);
1523 }
1524 else {
1525 msg = ERRSV;
1526 }
1738f5c4 1527
e788e7d3 1528 PUSHSTACKi(PERLSI_DIEHOOK);
924508f0 1529 PUSHMARK(SP);
1738f5c4
CS		 1530 XPUSHs(msg);
1531 PUTBACK;
0cdb2077 1532 call_sv((SV*)cv, G_DISCARD);
d3acc0f7 1533 POPSTACK;
774d564b 1534 LEAVE;
1738f5c4 1535 }
36477c24 1536 }
1537
06bf62c7 1538 PL_restartop = die_where(message, msglen);
bf49b057 1539 DEBUG_S(PerlIO_printf(Perl_debug_log,
7c06b590 1540 "%p: die: restartop = %p, was_in_eval = %d, top_env = %p\n",
533c011a 1541 thr, PL_restartop, was_in_eval, PL_top_env));
3280af22 1542 if ((!PL_restartop && was_in_eval) || PL_top_env->je_prev)
6224f72b 1543 JMPENV_JUMP(3);
3280af22 1544 return PL_restartop;
36477c24 1545}
1546
c5be433b 1547#if defined(PERL_IMPLICIT_CONTEXT)
cea2e8a9
GS		 1548OP *
1549Perl_die_nocontext(const char* pat, ...)
a687059c 1550{
cea2e8a9
GS		 1551 dTHX;
1552 OP *o;
a687059c 1553 va_list args;
cea2e8a9 1554 va_start(args, pat);
c5be433b 1555 o = vdie(pat, &args);
cea2e8a9
GS		 1556 va_end(args);
1557 return o;
1558}
c5be433b 1559#endif /* PERL_IMPLICIT_CONTEXT */
cea2e8a9
GS		 1560
1561OP *
1562Perl_die(pTHX_ const char* pat, ...)
1563{
1564 OP *o;
1565 va_list args;
1566 va_start(args, pat);
c5be433b 1567 o = vdie(pat, &args);
cea2e8a9
GS		 1568 va_end(args);
1569 return o;
1570}
1571
c5be433b
GS		 1572void
1573Perl_vcroak(pTHX_ const char* pat, va_list *args)
cea2e8a9
GS		 1574{
1575 dTHR;
de3bb511 1576 char *message;
748a9306
LW		 1577 HV *stash;
1578 GV *gv;
1579 CV *cv;
06bf62c7
GS		 1580 SV *msv;
1581 STRLEN msglen;
a687059c 1582
5a844595
GS		 1583 msv = vmess(pat, args);
1584 if (PL_errors && SvCUR(PL_errors)) {
1585 sv_catsv(PL_errors, msv);
1586 message = SvPV(PL_errors, msglen);
1587 SvCUR_set(PL_errors, 0);
1588 }
1589 else
1590 message = SvPV(msv,msglen);
1591
b900a521
JH		 1592 DEBUG_S(PerlIO_printf(Perl_debug_log, "croak: 0x%"UVxf" %s",
1593 PTR2UV(thr), message));
5a844595 1594
3280af22 1595 if (PL_diehook) {
cea2e8a9 1596 /* sv_2cv might call Perl_croak() */
3280af22 1597 SV *olddiehook = PL_diehook;
1738f5c4 1598 ENTER;
3280af22
NIS		 1599 SAVESPTR(PL_diehook);
1600 PL_diehook = Nullsv;
20cec16a 1601 cv = sv_2cv(olddiehook, &stash, &gv, 0);
1738f5c4
CS		 1602 LEAVE;
1603 if (cv && !CvDEPTH(cv) && (CvROOT(cv) || CvXSUB(cv))) {
20cec16a 1604 dSP;
774d564b 1605 SV *msg;
1606
1607 ENTER;
3a1f2dc9 1608 save_re_context();
06bf62c7 1609 msg = newSVpvn(message, msglen);
774d564b 1610 SvREADONLY_on(msg);
1611 SAVEFREESV(msg);
20cec16a 1612
e788e7d3 1613 PUSHSTACKi(PERLSI_DIEHOOK);
924508f0 1614 PUSHMARK(SP);
1738f5c4 1615 XPUSHs(msg);
20cec16a 1616 PUTBACK;
864dbfa3 1617 call_sv((SV*)cv, G_DISCARD);
d3acc0f7 1618 POPSTACK;
774d564b 1619 LEAVE;
20cec16a 1620 }
748a9306 1621 }
3280af22 1622 if (PL_in_eval) {
06bf62c7 1623 PL_restartop = die_where(message, msglen);
6224f72b 1624 JMPENV_JUMP(3);
a0d0e21e 1625 }
d175a3f0
GS		 1626 {
1627#ifdef USE_SFIO
1628 /* SFIO can really mess with your errno */
1629 int e = errno;
1630#endif
bf49b057
GS		 1631 PerlIO *serr = Perl_error_log;
1632
1633 PerlIO_write(serr, message, msglen);
1634 (void)PerlIO_flush(serr);
d175a3f0
GS		 1635#ifdef USE_SFIO
1636 errno = e;
1637#endif
1638 }
f86702cc 1639 my_failure_exit();
a687059c
LW		 1640}
1641
c5be433b 1642#if defined(PERL_IMPLICIT_CONTEXT)
8990e307 1643void
cea2e8a9 1644Perl_croak_nocontext(const char *pat, ...)
a687059c 1645{
cea2e8a9 1646 dTHX;
a687059c 1647 va_list args;
cea2e8a9 1648 va_start(args, pat);
c5be433b 1649 vcroak(pat, &args);
cea2e8a9
GS		 1650 /* NOTREACHED */
1651 va_end(args);
1652}
1653#endif /* PERL_IMPLICIT_CONTEXT */
1654
954c1994
GS		 1655/*
1656=for apidoc croak
1657
1658This is the XSUB-writer's interface to Perl's C<die> function. Use this
1659function the same way you use the C C<printf> function. See
1660C<warn>.
1661
1662=cut
1663*/
1664
cea2e8a9
GS		 1665void
1666Perl_croak(pTHX_ const char *pat, ...)
1667{
1668 va_list args;
1669 va_start(args, pat);
c5be433b 1670 vcroak(pat, &args);
cea2e8a9
GS		 1671 /* NOTREACHED */
1672 va_end(args);
1673}
1674
c5be433b
GS		 1675void
1676Perl_vwarn(pTHX_ const char* pat, va_list *args)
cea2e8a9 1677{
de3bb511 1678 char *message;
748a9306
LW		 1679 HV *stash;
1680 GV *gv;
1681 CV *cv;
06bf62c7
GS		 1682 SV *msv;
1683 STRLEN msglen;
a687059c 1684
5a844595 1685 msv = vmess(pat, args);
06bf62c7 1686 message = SvPV(msv, msglen);
a687059c 1687
3280af22 1688 if (PL_warnhook) {
cea2e8a9 1689 /* sv_2cv might call Perl_warn() */
11343788 1690 dTHR;
3280af22 1691 SV *oldwarnhook = PL_warnhook;
1738f5c4 1692 ENTER;
3280af22
NIS		 1693 SAVESPTR(PL_warnhook);
1694 PL_warnhook = Nullsv;
20cec16a 1695 cv = sv_2cv(oldwarnhook, &stash, &gv, 0);
1738f5c4
CS		 1696 LEAVE;
1697 if (cv && !CvDEPTH(cv) && (CvROOT(cv) || CvXSUB(cv))) {
20cec16a 1698 dSP;
774d564b 1699 SV *msg;
1700
1701 ENTER;
3a1f2dc9 1702 save_re_context();
06bf62c7 1703 msg = newSVpvn(message, msglen);
774d564b 1704 SvREADONLY_on(msg);
1705 SAVEFREESV(msg);
1706
e788e7d3 1707 PUSHSTACKi(PERLSI_WARNHOOK);
924508f0 1708 PUSHMARK(SP);
774d564b 1709 XPUSHs(msg);
20cec16a 1710 PUTBACK;
864dbfa3 1711 call_sv((SV*)cv, G_DISCARD);
d3acc0f7 1712 POPSTACK;
774d564b 1713 LEAVE;
20cec16a 1714 return;
1715 }
748a9306 1716 }
bf49b057
GS		 1717 {
1718 PerlIO *serr = Perl_error_log;
1719
1720 PerlIO_write(serr, message, msglen);
a687059c 1721#ifdef LEAKTEST
bf49b057
GS		 1722 DEBUG_L(*message == '!'
1723 ? (xstat(message[1]=='!'
1724 ? (message[2]=='!' ? 2 : 1)
1725 : 0)
1726 , 0)
1727 : 0);
a687059c 1728#endif
bf49b057
GS		 1729 (void)PerlIO_flush(serr);
1730 }
a687059c 1731}
8d063cd8 1732
c5be433b 1733#if defined(PERL_IMPLICIT_CONTEXT)
cea2e8a9
GS		 1734void
1735Perl_warn_nocontext(const char *pat, ...)
1736{
1737 dTHX;
1738 va_list args;
1739 va_start(args, pat);
c5be433b 1740 vwarn(pat, &args);
cea2e8a9
GS		 1741 va_end(args);
1742}
1743#endif /* PERL_IMPLICIT_CONTEXT */
1744
954c1994
GS		 1745/*
1746=for apidoc warn
1747
1748This is the XSUB-writer's interface to Perl's C<warn> function. Use this
1749function the same way you use the C C<printf> function. See
1750C<croak>.
1751
1752=cut
1753*/
1754
cea2e8a9
GS		 1755void
1756Perl_warn(pTHX_ const char *pat, ...)
1757{
1758 va_list args;
1759 va_start(args, pat);
c5be433b 1760 vwarn(pat, &args);
cea2e8a9
GS		 1761 va_end(args);
1762}
1763
c5be433b
GS		 1764#if defined(PERL_IMPLICIT_CONTEXT)
1765void
1766Perl_warner_nocontext(U32 err, const char *pat, ...)
1767{
1768 dTHX;
1769 va_list args;
1770 va_start(args, pat);
1771 vwarner(err, pat, &args);
1772 va_end(args);
1773}
1774#endif /* PERL_IMPLICIT_CONTEXT */
1775
599cee73 1776void
864dbfa3 1777Perl_warner(pTHX_ U32 err, const char* pat,...)
599cee73
PM		 1778{
1779 va_list args;
c5be433b
GS		 1780 va_start(args, pat);
1781 vwarner(err, pat, &args);
1782 va_end(args);
1783}
1784
1785void
1786Perl_vwarner(pTHX_ U32 err, const char* pat, va_list* args)
1787{
1788 dTHR;
599cee73
PM		 1789 char *message;
1790 HV *stash;
1791 GV *gv;
1792 CV *cv;
06bf62c7
GS		 1793 SV *msv;
1794 STRLEN msglen;
599cee73 1795
5a844595 1796 msv = vmess(pat, args);
06bf62c7 1797 message = SvPV(msv, msglen);
599cee73
PM		 1798
1799 if (ckDEAD(err)) {
1800#ifdef USE_THREADS
b900a521 1801 DEBUG_S(PerlIO_printf(Perl_debug_log, "croak: 0x%"UVxf" %s", PTR2UV(thr), message));
599cee73
PM		 1802#endif /* USE_THREADS */
1803 if (PL_diehook) {
cea2e8a9 1804 /* sv_2cv might call Perl_croak() */
599cee73
PM		 1805 SV *olddiehook = PL_diehook;
1806 ENTER;
1807 SAVESPTR(PL_diehook);
1808 PL_diehook = Nullsv;
1809 cv = sv_2cv(olddiehook, &stash, &gv, 0);
1810 LEAVE;
1811 if (cv && !CvDEPTH(cv) && (CvROOT(cv) || CvXSUB(cv))) {
1812 dSP;
1813 SV *msg;
1814
1815 ENTER;
3a1f2dc9 1816 save_re_context();
06bf62c7 1817 msg = newSVpvn(message, msglen);
599cee73
PM		 1818 SvREADONLY_on(msg);
1819 SAVEFREESV(msg);
1820
3a1f2dc9 1821 PUSHSTACKi(PERLSI_DIEHOOK);
599cee73
PM		 1822 PUSHMARK(sp);
1823 XPUSHs(msg);
1824 PUTBACK;
864dbfa3 1825 call_sv((SV*)cv, G_DISCARD);
3a1f2dc9 1826 POPSTACK;
599cee73
PM		 1827 LEAVE;
1828 }
1829 }
1830 if (PL_in_eval) {
06bf62c7 1831 PL_restartop = die_where(message, msglen);
599cee73
PM		 1832 JMPENV_JUMP(3);
1833 }
bf49b057
GS		 1834 {
1835 PerlIO *serr = Perl_error_log;
1836 PerlIO_write(serr, message, msglen);
1837 (void)PerlIO_flush(serr);
1838 }
599cee73
PM		 1839 my_failure_exit();
1840
1841 }
1842 else {
1843 if (PL_warnhook) {
cea2e8a9 1844 /* sv_2cv might call Perl_warn() */
599cee73
PM		 1845 dTHR;
1846 SV *oldwarnhook = PL_warnhook;
1847 ENTER;
1848 SAVESPTR(PL_warnhook);
1849 PL_warnhook = Nullsv;
1850 cv = sv_2cv(oldwarnhook, &stash, &gv, 0);
3a1f2dc9 1851 LEAVE;
599cee73
PM		 1852 if (cv && !CvDEPTH(cv) && (CvROOT(cv) || CvXSUB(cv))) {
1853 dSP;
1854 SV *msg;
1855
1856 ENTER;
3a1f2dc9 1857 save_re_context();
06bf62c7 1858 msg = newSVpvn(message, msglen);
599cee73
PM		 1859 SvREADONLY_on(msg);
1860 SAVEFREESV(msg);
1861
3a1f2dc9 1862 PUSHSTACKi(PERLSI_WARNHOOK);
599cee73
PM		 1863 PUSHMARK(sp);
1864 XPUSHs(msg);
1865 PUTBACK;
864dbfa3 1866 call_sv((SV*)cv, G_DISCARD);
3a1f2dc9 1867 POPSTACK;
599cee73
PM		 1868 LEAVE;
1869 return;
1870 }
1871 }
bf49b057
GS		 1872 {
1873 PerlIO *serr = Perl_error_log;
1874 PerlIO_write(serr, message, msglen);
599cee73 1875#ifdef LEAKTEST
bf49b057 1876 DEBUG_L(xstat());
599cee73 1877#endif
bf49b057
GS		 1878 (void)PerlIO_flush(serr);
1879 }
599cee73
PM		 1880 }
1881}
1882
a0d0e21e 1883#ifndef VMS /* VMS' my_setenv() is in VMS.c */
d308986b 1884#if !defined(WIN32) && !defined(__CYGWIN__)
8d063cd8 1885void
864dbfa3 1886Perl_my_setenv(pTHX_ char *nam, char *val)
8d063cd8 1887{
f2517201
GS		 1888#ifndef PERL_USE_SAFE_PUTENV
1889 /* most putenv()s leak, so we manipulate environ directly */
79072805 1890 register I32 i=setenv_getix(nam); /* where does it go? */
8d063cd8 1891
3280af22 1892 if (environ == PL_origenviron) { /* need we copy environment? */
79072805
LW		 1893 I32 j;
1894 I32 max;
fe14fcc3
LW		 1895 char **tmpenv;
1896
de3bb511 1897 /*SUPPRESS 530*/
fe14fcc3 1898 for (max = i; environ[max]; max++) ;
f2517201
GS		 1899 tmpenv = (char**)safesysmalloc((max+2) * sizeof(char*));
1900 for (j=0; j<max; j++) { /* copy environment */
1901 tmpenv[j] = (char*)safesysmalloc((strlen(environ[j])+1)*sizeof(char));
1902 strcpy(tmpenv[j], environ[j]);
1903 }
fe14fcc3
LW		 1904 tmpenv[max] = Nullch;
1905 environ = tmpenv; /* tell exec where it is now */
1906 }
a687059c 1907 if (!val) {
f2517201 1908 safesysfree(environ[i]);
a687059c
LW		 1909 while (environ[i]) {
1910 environ[i] = environ[i+1];
1911 i++;
1912 }
1913 return;
1914 }
8d063cd8 1915 if (!environ[i]) { /* does not exist yet */
f2517201 1916 environ = (char**)safesysrealloc(environ, (i+2) * sizeof(char*));
8d063cd8
LW		 1917 environ[i+1] = Nullch; /* make sure it's null terminated */
1918 }
fe14fcc3 1919 else
f2517201
GS		 1920 safesysfree(environ[i]);
1921 environ[i] = (char*)safesysmalloc((strlen(nam)+strlen(val)+2) * sizeof(char));
1922
a687059c 1923 (void)sprintf(environ[i],"%s=%s",nam,val);/* all that work just for this */
f2517201
GS		 1924
1925#else /* PERL_USE_SAFE_PUTENV */
1926 char *new_env;
1927
1928 new_env = (char*)safesysmalloc((strlen(nam) + strlen(val) + 2) * sizeof(char));
f2517201 1929 (void)sprintf(new_env,"%s=%s",nam,val);/* all that work just for this */
f2517201
GS		 1930 (void)putenv(new_env);
1931#endif /* PERL_USE_SAFE_PUTENV */
8d063cd8
LW		 1932}
1933
d308986b
GS		 1934#else /* WIN32 || __CYGWIN__ */
1935#if defined(__CYGWIN__)
1cab015a
EF		 1936/*
1937 * Save environ of perl.exe, currently Cygwin links in separate environ's
1938 * for each exe/dll. Probably should be a member of impure_ptr.
1939 */
1940static char ***Perl_main_environ;
1941
1942EXTERN_C void
1943Perl_my_setenv_init(char ***penviron)
1944{
1945 Perl_main_environ = penviron;
1946}
1947
1948void
0a9fdc5d 1949Perl_my_setenv(pTHX_ char *nam, char *val)
1cab015a
EF		 1950{
1951 /* You can not directly manipulate the environ[] array because
1952 * the routines do some additional work that syncs the Cygwin
1953 * environment with the Windows environment.
1954 */
1955 char *oldstr = environ[setenv_getix(nam)];
1956
1957 if (!val) {
1958 if (!oldstr)
1959 return;
1960 unsetenv(nam);
d702ae42 1961 safesysfree(oldstr);
1cab015a
EF		 1962 return;
1963 }
1964 setenv(nam, val, 1);
1965 environ = *Perl_main_environ; /* environ realloc can occur in setenv */
1966 if(oldstr && environ[setenv_getix(nam)] != oldstr)
d702ae42 1967 safesysfree(oldstr);
1cab015a 1968}
3e3baf6d 1969#else /* if WIN32 */
68dc0745 1970
1971void
864dbfa3 1972Perl_my_setenv(pTHX_ char *nam,char *val)
68dc0745 1973{
3e3baf6d
TB		 1974
1975#ifdef USE_WIN32_RTL_ENV
1976
68dc0745 1977 register char *envstr;
1978 STRLEN namlen = strlen(nam);
3e3baf6d
TB		 1979 STRLEN vallen;
1980 char *oldstr = environ[setenv_getix(nam)];
1981
1982 /* putenv() has totally broken semantics in both the Borland
1983 * and Microsoft CRTLs. They either store the passed pointer in
1984 * the environment without making a copy, or make a copy and don't
1985 * free it. And on top of that, they dont free() old entries that
1986 * are being replaced/deleted. This means the caller must
1987 * free any old entries somehow, or we end up with a memory
1988 * leak every time my_setenv() is called. One might think
1989 * one could directly manipulate environ[], like the UNIX code
1990 * above, but direct changes to environ are not allowed when
1991 * calling putenv(), since the RTLs maintain an internal
1992 * *copy* of environ[]. Bad, bad, *bad* stink.
1993 * GSAR 97-06-07
1994 */
68dc0745 1995
3e3baf6d
TB		 1996 if (!val) {
1997 if (!oldstr)
1998 return;
1999 val = "";
2000 vallen = 0;
2001 }
2002 else
2003 vallen = strlen(val);
f2517201 2004 envstr = (char*)safesysmalloc((namlen + vallen + 3) * sizeof(char));
68dc0745 2005 (void)sprintf(envstr,"%s=%s",nam,val);
76e3520e 2006 (void)PerlEnv_putenv(envstr);
3e3baf6d 2007 if (oldstr)
f2517201 2008 safesysfree(oldstr);
3e3baf6d 2009#ifdef _MSC_VER
f2517201 2010 safesysfree(envstr); /* MSVCRT leaks without this */
3e3baf6d
TB		 2011#endif
2012
2013#else /* !USE_WIN32_RTL_ENV */
2014
ac5c734f
GS		 2015 register char *envstr;
2016 STRLEN len = strlen(nam) + 3;
2017 if (!val) {
2018 val = "";
2019 }
2020 len += strlen(val);
2021 New(904, envstr, len, char);
2022 (void)sprintf(envstr,"%s=%s",nam,val);
2023 (void)PerlEnv_putenv(envstr);
2024 Safefree(envstr);
3e3baf6d
TB		 2025
2026#endif
2027}
2028
2029#endif /* WIN32 */
1cab015a 2030#endif
3e3baf6d
TB		 2031
2032I32
864dbfa3 2033Perl_setenv_getix(pTHX_ char *nam)
3e3baf6d
TB		 2034{
2035 register I32 i, len = strlen(nam);
2036
2037 for (i = 0; environ[i]; i++) {
2038 if (
2039#ifdef WIN32
2040 strnicmp(environ[i],nam,len) == 0
2041#else
2042 strnEQ(environ[i],nam,len)
2043#endif
2044 && environ[i][len] == '=')
2045 break; /* strnEQ must come first to avoid */
2046 } /* potential SEGV's */
2047 return i;
68dc0745 2048}
2049
a0d0e21e 2050#endif /* !VMS */
378cc40b 2051
16d20bd9 2052#ifdef UNLINK_ALL_VERSIONS
79072805 2053I32
864dbfa3 2054Perl_unlnk(pTHX_ char *f) /* unlink all versions of a file */
378cc40b 2055{
79072805 2056 I32 i;
378cc40b 2057
6ad3d225 2058 for (i = 0; PerlLIO_unlink(f) >= 0; i++) ;
378cc40b
LW		 2059 return i ? 0 : -1;
2060}
2061#endif
2062
7a3f2258 2063/* this is a drop-in replacement for bcopy() */
85e6fe83 2064#if !defined(HAS_BCOPY) || !defined(HAS_SAFE_BCOPY)
378cc40b 2065char *
7a3f2258 2066Perl_my_bcopy(register const char *from,register char *to,register I32 len)
378cc40b
LW		 2067{
2068 char *retval = to;
2069
7c0587c8
LW		 2070 if (from - to >= 0) {
2071 while (len--)
2072 *to++ = *from++;
2073 }
2074 else {
2075 to += len;
2076 from += len;
2077 while (len--)
faf8582f 2078 *(--to) = *(--from);
7c0587c8 2079 }
378cc40b
LW		 2080 return retval;
2081}
ffed7fef 2082#endif
378cc40b 2083
7a3f2258 2084/* this is a drop-in replacement for memset() */
fc36a67e 2085#ifndef HAS_MEMSET
2086void *
7a3f2258 2087Perl_my_memset(register char *loc, register I32 ch, register I32 len)
fc36a67e 2088{
2089 char *retval = loc;
2090
2091 while (len--)
2092 *loc++ = ch;
2093 return retval;
2094}
2095#endif
2096
7a3f2258 2097/* this is a drop-in replacement for bzero() */
7c0587c8 2098#if !defined(HAS_BZERO) && !defined(HAS_MEMSET)
378cc40b 2099char *
7a3f2258 2100Perl_my_bzero(register char *loc, register I32 len)
378cc40b
LW		 2101{
2102 char *retval = loc;
2103
2104 while (len--)
2105 *loc++ = 0;
2106 return retval;
2107}
2108#endif
7c0587c8 2109
7a3f2258 2110/* this is a drop-in replacement for memcmp() */
36477c24 2111#if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP)
79072805 2112I32
7a3f2258 2113Perl_my_memcmp(const char *s1, const char *s2, register I32 len)
7c0587c8 2114{
36477c24 2115 register U8 *a = (U8 *)s1;
2116 register U8 *b = (U8 *)s2;
79072805 2117 register I32 tmp;
7c0587c8
LW		 2118
2119 while (len--) {
36477c24 2120 if (tmp = *a++ - *b++)
7c0587c8
LW		 2121 return tmp;
2122 }
2123 return 0;
2124}
36477c24 2125#endif /* !HAS_MEMCMP || !HAS_SANE_MEMCMP */
a687059c 2126
fe14fcc3 2127#ifndef HAS_VPRINTF
a687059c 2128
85e6fe83 2129#ifdef USE_CHAR_VSPRINTF
a687059c
LW		 2130char *
2131#else
2132int
2133#endif
08105a92 2134vsprintf(char *dest, const char *pat, char *args)
a687059c
LW		 2135{
2136 FILE fakebuf;
2137
2138 fakebuf._ptr = dest;
2139 fakebuf._cnt = 32767;
35c8bce7
LW		 2140#ifndef _IOSTRG
2141#define _IOSTRG 0
2142#endif
a687059c
LW		 2143 fakebuf._flag = _IOWRT|_IOSTRG;
2144 _doprnt(pat, args, &fakebuf); /* what a kludge */
2145 (void)putc('\0', &fakebuf);
85e6fe83 2146#ifdef USE_CHAR_VSPRINTF
a687059c
LW		 2147 return(dest);
2148#else
2149 return 0; /* perl doesn't use return value */
2150#endif
2151}
2152
fe14fcc3 2153#endif /* HAS_VPRINTF */
a687059c
LW		 2154
2155#ifdef MYSWAP
ffed7fef 2156#if BYTEORDER != 0x4321
a687059c 2157short
864dbfa3 2158Perl_my_swap(pTHX_ short s)
a687059c
LW		 2159{
2160#if (BYTEORDER & 1) == 0
2161 short result;
2162
2163 result = ((s & 255) << 8) + ((s >> 8) & 255);
2164 return result;
2165#else
2166 return s;
2167#endif
2168}
2169
2170long
864dbfa3 2171Perl_my_htonl(pTHX_ long l)
a687059c
LW		 2172{
2173 union {
2174 long result;
ffed7fef 2175 char c[sizeof(long)];
a687059c
LW		 2176 } u;
2177
ffed7fef 2178#if BYTEORDER == 0x1234
a687059c
LW		 2179 u.c[0] = (l >> 24) & 255;
2180 u.c[1] = (l >> 16) & 255;
2181 u.c[2] = (l >> 8) & 255;
2182 u.c[3] = l & 255;
2183 return u.result;
2184#else
ffed7fef 2185#if ((BYTEORDER - 0x1111) & 0x444) || !(BYTEORDER & 0xf)
cea2e8a9 2186 Perl_croak(aTHX_ "Unknown BYTEORDER\n");
a687059c 2187#else
79072805
LW		 2188 register I32 o;
2189 register I32 s;
a687059c 2190
ffed7fef
LW		 2191 for (o = BYTEORDER - 0x1111, s = 0; s < (sizeof(long)*8); o >>= 4, s += 8) {
2192 u.c[o & 0xf] = (l >> s) & 255;
a687059c
LW		 2193 }
2194 return u.result;
2195#endif
2196#endif
2197}
2198
2199long
864dbfa3 2200Perl_my_ntohl(pTHX_ long l)
a687059c
LW		 2201{
2202 union {
2203 long l;
ffed7fef 2204 char c[sizeof(long)];
a687059c
LW		 2205 } u;
2206
ffed7fef 2207#if BYTEORDER == 0x1234
a687059c
LW		 2208 u.c[0] = (l >> 24) & 255;
2209 u.c[1] = (l >> 16) & 255;
2210 u.c[2] = (l >> 8) & 255;
2211 u.c[3] = l & 255;
2212 return u.l;
2213#else
ffed7fef 2214#if ((BYTEORDER - 0x1111) & 0x444) || !(BYTEORDER & 0xf)
cea2e8a9 2215 Perl_croak(aTHX_ "Unknown BYTEORDER\n");
a687059c 2216#else
79072805
LW		 2217 register I32 o;
2218 register I32 s;
a687059c
LW		 2219
2220 u.l = l;
2221 l = 0;
ffed7fef
LW		 2222 for (o = BYTEORDER - 0x1111, s = 0; s < (sizeof(long)*8); o >>= 4, s += 8) {
2223 l |= (u.c[o & 0xf] & 255) << s;
a687059c
LW		 2224 }
2225 return l;
2226#endif
2227#endif
2228}
2229
ffed7fef 2230#endif /* BYTEORDER != 0x4321 */
988174c1
LW		 2231#endif /* MYSWAP */
2232
2233/*
2234 * Little-endian byte order functions - 'v' for 'VAX', or 'reVerse'.
2235 * If these functions are defined,
2236 * the BYTEORDER is neither 0x1234 nor 0x4321.
2237 * However, this is not assumed.
2238 * -DWS
2239 */
2240
2241#define HTOV(name,type) \
2242 type \
ba106d47 2243 name (register type n) \
988174c1
LW		 2244 { \
2245 union { \
2246 type value; \
2247 char c[sizeof(type)]; \
2248 } u; \
79072805
LW		 2249 register I32 i; \
2250 register I32 s; \
988174c1
LW		 2251 for (i = 0, s = 0; i < sizeof(u.c); i++, s += 8) { \
2252 u.c[i] = (n >> s) & 0xFF; \
2253 } \
2254 return u.value; \
2255 }
2256
2257#define VTOH(name,type) \
2258 type \
ba106d47 2259 name (register type n) \
988174c1
LW		 2260 { \
2261 union { \
2262 type value; \
2263 char c[sizeof(type)]; \
2264 } u; \
79072805
LW		 2265 register I32 i; \
2266 register I32 s; \
988174c1
LW		 2267 u.value = n; \
2268 n = 0; \
2269 for (i = 0, s = 0; i < sizeof(u.c); i++, s += 8) { \
2270 n += (u.c[i] & 0xFF) << s; \
2271 } \
2272 return n; \
2273 }
2274
2275#if defined(HAS_HTOVS) && !defined(htovs)
2276HTOV(htovs,short)
2277#endif
2278#if defined(HAS_HTOVL) && !defined(htovl)
2279HTOV(htovl,long)
2280#endif
2281#if defined(HAS_VTOHS) && !defined(vtohs)
2282VTOH(vtohs,short)
2283#endif
2284#if defined(HAS_VTOHL) && !defined(vtohl)
2285VTOH(vtohl,long)
2286#endif
a687059c 2287
5f05dabc 2288 /* VMS' my_popen() is in VMS.c, same with OS/2. */
cd39f2b6 2289#if (!defined(DOSISH) || defined(HAS_FORK) || defined(AMIGAOS)) && !defined(VMS) && !defined(__OPEN_VM) && !defined(EPOC) && !defined(MACOS_TRADITIONAL)
760ac839 2290PerlIO *
864dbfa3 2291Perl_my_popen(pTHX_ char *cmd, char *mode)
a687059c
LW		 2292{
2293 int p[2];
8ac85365 2294 register I32 This, that;
d8a83dd3 2295 register Pid_t pid;
79072805 2296 SV *sv;
1738f5c4 2297 I32 doexec = strNE(cmd,"-");
e446cec8
IZ		 2298 I32 did_pipes = 0;
2299 int pp[2];
a687059c 2300
45bc9206 2301 PERL_FLUSHALL_FOR_CHILD;
ddcf38b7
IZ		 2302#ifdef OS2
2303 if (doexec) {
2304 return my_syspopen(cmd,mode);
2305 }
2306#endif
8ac85365
NIS		 2307 This = (*mode == 'w');
2308 that = !This;
3280af22 2309 if (doexec && PL_tainting) {
bbce6d69 2310 taint_env();
2311 taint_proper("Insecure %s%s", "EXEC");
d48672a2 2312 }
c2267164
IZ		 2313 if (PerlProc_pipe(p) < 0)
2314 return Nullfp;
e446cec8
IZ		 2315 if (doexec && PerlProc_pipe(pp) >= 0)
2316 did_pipes = 1;
a687059c
LW		 2317 while ((pid = (doexec?vfork():fork())) < 0) {
2318 if (errno != EAGAIN) {
6ad3d225 2319 PerlLIO_close(p[This]);
e446cec8
IZ		 2320 if (did_pipes) {
2321 PerlLIO_close(pp[0]);
2322 PerlLIO_close(pp[1]);
2323 }
a687059c 2324 if (!doexec)
cea2e8a9 2325 Perl_croak(aTHX_ "Can't fork");
a687059c
LW		 2326 return Nullfp;
2327 }
2328 sleep(5);
2329 }
2330 if (pid == 0) {
79072805
LW		 2331 GV* tmpgv;
2332
30ac6d9b
GS		 2333#undef THIS
2334#undef THAT
a687059c 2335#define THIS that
8ac85365 2336#define THAT This
6ad3d225 2337 PerlLIO_close(p[THAT]);
e446cec8
IZ		 2338 if (did_pipes) {
2339 PerlLIO_close(pp[0]);
2340#if defined(HAS_FCNTL) && defined(F_SETFD)
2341 fcntl(pp[1], F_SETFD, FD_CLOEXEC);
2342#endif
2343 }
a687059c 2344 if (p[THIS] != (*mode == 'r')) {
6ad3d225
GS		 2345 PerlLIO_dup2(p[THIS], *mode == 'r');
2346 PerlLIO_close(p[THIS]);
a687059c 2347 }
4435c477 2348#ifndef OS2
a687059c 2349 if (doexec) {
a0d0e21e 2350#if !defined(HAS_FCNTL) || !defined(F_SETFD)
ae986130
LW		 2351 int fd;
2352
2353#ifndef NOFILE
2354#define NOFILE 20
2355#endif
6b88bc9c 2356 for (fd = PL_maxsysfd + 1; fd < NOFILE; fd++)
e446cec8
IZ		 2357 if (fd != pp[1])
2358 PerlLIO_close(fd);
ae986130 2359#endif
e446cec8 2360 do_exec3(cmd,pp[1],did_pipes); /* may or may not use the shell */
6ad3d225 2361 PerlProc__exit(1);
a687059c 2362 }
4435c477 2363#endif /* defined OS2 */
de3bb511 2364 /*SUPPRESS 560*/
155aba94 2365 if ((tmpgv = gv_fetchpv("$",TRUE, SVt_PV)))
7766f137 2366 sv_setiv(GvSV(tmpgv), PerlProc_getpid());
3280af22
NIS		 2367 PL_forkprocess = 0;
2368 hv_clear(PL_pidstatus); /* we have no children */
a687059c
LW		 2369 return Nullfp;
2370#undef THIS
2371#undef THAT
2372 }
62b28dd9 2373 do_execfree(); /* free any memory malloced by child on vfork */
6ad3d225 2374 PerlLIO_close(p[that]);
e446cec8
IZ		 2375 if (did_pipes)
2376 PerlLIO_close(pp[1]);
8ac85365 2377 if (p[that] < p[This]) {
6ad3d225
GS		 2378 PerlLIO_dup2(p[This], p[that]);
2379 PerlLIO_close(p[This]);
8ac85365 2380 p[This] = p[that];
62b28dd9 2381 }
3280af22 2382 sv = *av_fetch(PL_fdpid,p[This],TRUE);
a0d0e21e 2383 (void)SvUPGRADE(sv,SVt_IV);
463ee0b2 2384 SvIVX(sv) = pid;
3280af22 2385 PL_forkprocess = pid;
e446cec8
IZ		 2386 if (did_pipes && pid > 0) {
2387 int errkid;
2388 int n = 0, n1;
2389
2390 while (n < sizeof(int)) {
2391 n1 = PerlLIO_read(pp[0],
2392 (void*)(((char*)&errkid)+n),
2393 (sizeof(int)) - n);
2394 if (n1 <= 0)
2395 break;
2396 n += n1;
2397 }
2f96c702
IZ		 2398 PerlLIO_close(pp[0]);
2399 did_pipes = 0;
e446cec8
IZ		 2400 if (n) { /* Error */
2401 if (n != sizeof(int))
cea2e8a9 2402 Perl_croak(aTHX_ "panic: kid popen errno read");
e446cec8
IZ		 2403 errno = errkid; /* Propagate errno from kid */
2404 return Nullfp;
2405 }
2406 }
2407 if (did_pipes)
2408 PerlLIO_close(pp[0]);
8ac85365 2409 return PerlIO_fdopen(p[This], mode);
a687059c 2410}
7c0587c8 2411#else
55497cff 2412#if defined(atarist) || defined(DJGPP)
7c0587c8 2413FILE *popen();
760ac839 2414PerlIO *
864dbfa3 2415Perl_my_popen(pTHX_ char *cmd, char *mode)
7c0587c8 2416{
760ac839 2417 /* Needs work for PerlIO ! */
55497cff 2418 /* used 0 for 2nd parameter to PerlIO-exportFILE; apparently not used */
45bc9206 2419 PERL_FLUSHALL_FOR_CHILD;
55497cff 2420 return popen(PerlIO_exportFILE(cmd, 0), mode);
7c0587c8
LW		 2421}
2422#endif
2423
2424#endif /* !DOSISH */
a687059c 2425
748a9306 2426#ifdef DUMP_FDS
35ff7856 2427void
864dbfa3 2428Perl_dump_fds(pTHX_ char *s)
ae986130
LW		 2429{
2430 int fd;
2431 struct stat tmpstatbuf;
2432
bf49b057 2433 PerlIO_printf(Perl_debug_log,"%s", s);
ae986130 2434 for (fd = 0; fd < 32; fd++) {
6ad3d225 2435 if (PerlLIO_fstat(fd,&tmpstatbuf) >= 0)
bf49b057 2436 PerlIO_printf(Perl_debug_log," %d",fd);
ae986130 2437 }
bf49b057 2438 PerlIO_printf(Perl_debug_log,"\n");
ae986130 2439}
35ff7856 2440#endif /* DUMP_FDS */
ae986130 2441
fe14fcc3 2442#ifndef HAS_DUP2
fec02dd3 2443int
ba106d47 2444dup2(int oldfd, int newfd)
a687059c 2445{
a0d0e21e 2446#if defined(HAS_FCNTL) && defined(F_DUPFD)
fec02dd3
AD		 2447 if (oldfd == newfd)
2448 return oldfd;
6ad3d225 2449 PerlLIO_close(newfd);
fec02dd3 2450 return fcntl(oldfd, F_DUPFD, newfd);
62b28dd9 2451#else
fc36a67e 2452#define DUP2_MAX_FDS 256
2453 int fdtmp[DUP2_MAX_FDS];
79072805 2454 I32 fdx = 0;
ae986130
LW		 2455 int fd;
2456
fe14fcc3 2457 if (oldfd == newfd)
fec02dd3 2458 return oldfd;
6ad3d225 2459 PerlLIO_close(newfd);
fc36a67e 2460 /* good enough for low fd's... */
6ad3d225 2461 while ((fd = PerlLIO_dup(oldfd)) != newfd && fd >= 0) {
fc36a67e 2462 if (fdx >= DUP2_MAX_FDS) {
6ad3d225 2463 PerlLIO_close(fd);
fc36a67e 2464 fd = -1;
2465 break;
2466 }
ae986130 2467 fdtmp[fdx++] = fd;
fc36a67e 2468 }
ae986130 2469 while (fdx > 0)
6ad3d225 2470 PerlLIO_close(fdtmp[--fdx]);
fec02dd3 2471 return fd;
62b28dd9 2472#endif
a687059c
LW		 2473}
2474#endif
2475
ff68c719 2476
2477#ifdef HAS_SIGACTION
2478
2479Sighandler_t
864dbfa3 2480Perl_rsignal(pTHX_ int signo, Sighandler_t handler)
ff68c719 2481{
2482 struct sigaction act, oact;
2483
2484 act.sa_handler = handler;
2485 sigemptyset(&act.sa_mask);
2486 act.sa_flags = 0;
2487#ifdef SA_RESTART
2488 act.sa_flags |= SA_RESTART; /* SVR4, 4.3+BSD */
2489#endif
85264bed
CS		 2490#ifdef SA_NOCLDWAIT
2491 if (signo == SIGCHLD && handler == (Sighandler_t)SIG_IGN)
2492 act.sa_flags |= SA_NOCLDWAIT;
2493#endif
ff68c719 2494 if (sigaction(signo, &act, &oact) == -1)
36477c24 2495 return SIG_ERR;
ff68c719 2496 else
36477c24 2497 return oact.sa_handler;
ff68c719 2498}
2499
2500Sighandler_t
864dbfa3 2501Perl_rsignal_state(pTHX_ int signo)
ff68c719 2502{
2503 struct sigaction oact;
2504
2505 if (sigaction(signo, (struct sigaction *)NULL, &oact) == -1)
2506 return SIG_ERR;
2507 else
2508 return oact.sa_handler;
2509}
2510
2511int
864dbfa3 2512Perl_rsignal_save(pTHX_ int signo, Sighandler_t handler, Sigsave_t *save)
ff68c719 2513{
2514 struct sigaction act;
2515
2516 act.sa_handler = handler;
2517 sigemptyset(&act.sa_mask);
2518 act.sa_flags = 0;
2519#ifdef SA_RESTART
2520 act.sa_flags |= SA_RESTART; /* SVR4, 4.3+BSD */
2521#endif
85264bed
CS		 2522#ifdef SA_NOCLDWAIT
2523 if (signo == SIGCHLD && handler == (Sighandler_t)SIG_IGN)
2524 act.sa_flags |= SA_NOCLDWAIT;
2525#endif
ff68c719 2526 return sigaction(signo, &act, save);
2527}
2528
2529int
864dbfa3 2530Perl_rsignal_restore(pTHX_ int signo, Sigsave_t *save)
ff68c719 2531{
2532 return sigaction(signo, save, (struct sigaction *)NULL);
2533}
2534
2535#else /* !HAS_SIGACTION */
2536
2537Sighandler_t
864dbfa3 2538Perl_rsignal(pTHX_ int signo, Sighandler_t handler)
ff68c719 2539{
6ad3d225 2540 return PerlProc_signal(signo, handler);
ff68c719 2541}
2542
2543static int sig_trapped;
2544
2545static
2546Signal_t
4e35701f 2547sig_trap(int signo)
ff68c719 2548{
2549 sig_trapped++;
2550}
2551
2552Sighandler_t
864dbfa3 2553Perl_rsignal_state(pTHX_ int signo)
ff68c719 2554{
2555 Sighandler_t oldsig;
2556
2557 sig_trapped = 0;
6ad3d225
GS		 2558 oldsig = PerlProc_signal(signo, sig_trap);
2559 PerlProc_signal(signo, oldsig);
ff68c719 2560 if (sig_trapped)
7766f137 2561 PerlProc_kill(PerlProc_getpid(), signo);
ff68c719 2562 return oldsig;
2563}
2564
2565int
864dbfa3 2566Perl_rsignal_save(pTHX_ int signo, Sighandler_t handler, Sigsave_t *save)
ff68c719 2567{
6ad3d225 2568 *save = PerlProc_signal(signo, handler);
ff68c719 2569 return (*save == SIG_ERR) ? -1 : 0;
2570}
2571
2572int
864dbfa3 2573Perl_rsignal_restore(pTHX_ int signo, Sigsave_t *save)
ff68c719 2574{
6ad3d225 2575 return (PerlProc_signal(signo, *save) == SIG_ERR) ? -1 : 0;
ff68c719 2576}
2577
2578#endif /* !HAS_SIGACTION */
2579
5f05dabc 2580 /* VMS' my_pclose() is in VMS.c; same with OS/2 */
cd39f2b6 2581#if (!defined(DOSISH) || defined(HAS_FORK) || defined(AMIGAOS)) && !defined(VMS) && !defined(__OPEN_VM) && !defined(EPOC) && !defined(MACOS_TRADITIONAL)
79072805 2582I32
864dbfa3 2583Perl_my_pclose(pTHX_ PerlIO *ptr)
a687059c 2584{
ff68c719 2585 Sigsave_t hstat, istat, qstat;
a687059c 2586 int status;
a0d0e21e 2587 SV **svp;
d8a83dd3
JH		 2588 Pid_t pid;
2589 Pid_t pid2;
03136e13
CS		 2590 bool close_failed;
2591 int saved_errno;
2592#ifdef VMS
2593 int saved_vaxc_errno;
2594#endif
22fae026
TM		 2595#ifdef WIN32
2596 int saved_win32_errno;
2597#endif
a687059c 2598
3280af22 2599 svp = av_fetch(PL_fdpid,PerlIO_fileno(ptr),TRUE);
d8a83dd3 2600 pid = SvIVX(*svp);
a0d0e21e 2601 SvREFCNT_dec(*svp);
3280af22 2602 *svp = &PL_sv_undef;
ddcf38b7
IZ		 2603#ifdef OS2
2604 if (pid == -1) { /* Opened by popen. */
2605 return my_syspclose(ptr);
2606 }
2607#endif
03136e13
CS		 2608 if ((close_failed = (PerlIO_close(ptr) == EOF))) {
2609 saved_errno = errno;
2610#ifdef VMS
2611 saved_vaxc_errno = vaxc$errno;
2612#endif
22fae026
TM		 2613#ifdef WIN32
2614 saved_win32_errno = GetLastError();
2615#endif
03136e13 2616 }
7c0587c8 2617#ifdef UTS
6ad3d225 2618 if(PerlProc_kill(pid, 0) < 0) { return(pid); } /* HOM 12/23/91 */
7c0587c8 2619#endif
ff68c719 2620 rsignal_save(SIGHUP, SIG_IGN, &hstat);
2621 rsignal_save(SIGINT, SIG_IGN, &istat);
2622 rsignal_save(SIGQUIT, SIG_IGN, &qstat);
748a9306 2623 do {
1d3434b8
GS		 2624 pid2 = wait4pid(pid, &status, 0);
2625 } while (pid2 == -1 && errno == EINTR);
ff68c719 2626 rsignal_restore(SIGHUP, &hstat);
2627 rsignal_restore(SIGINT, &istat);
2628 rsignal_restore(SIGQUIT, &qstat);
03136e13
CS		 2629 if (close_failed) {
2630 SETERRNO(saved_errno, saved_vaxc_errno);
2631 return -1;
2632 }
1d3434b8 2633 return(pid2 < 0 ? pid2 : status == 0 ? 0 : (errno = 0, status));
20188a90 2634}
4633a7c4
LW		 2635#endif /* !DOSISH */
2636
cd39f2b6 2637#if (!defined(DOSISH) || defined(OS2) || defined(WIN32)) && !defined(MACOS_TRADITIONAL)
79072805 2638I32
d8a83dd3 2639Perl_wait4pid(pTHX_ Pid_t pid, int *statusp, int flags)
20188a90 2640{
79072805
LW		 2641 SV *sv;
2642 SV** svp;
fc36a67e 2643 char spid[TYPE_CHARS(int)];
20188a90
LW		 2644
2645 if (!pid)
2646 return -1;
20188a90 2647 if (pid > 0) {
7b0972df 2648 sprintf(spid, "%"IVdf, (IV)pid);
3280af22
NIS		 2649 svp = hv_fetch(PL_pidstatus,spid,strlen(spid),FALSE);
2650 if (svp && *svp != &PL_sv_undef) {
463ee0b2 2651 *statusp = SvIVX(*svp);
3280af22 2652 (void)hv_delete(PL_pidstatus,spid,strlen(spid),G_DISCARD);
20188a90
LW		 2653 return pid;
2654 }
2655 }
2656 else {
79072805 2657 HE *entry;
20188a90 2658
3280af22 2659 hv_iterinit(PL_pidstatus);
155aba94 2660 if ((entry = hv_iternext(PL_pidstatus))) {
a0d0e21e 2661 pid = atoi(hv_iterkey(entry,(I32*)statusp));
3280af22 2662 sv = hv_iterval(PL_pidstatus,entry);
463ee0b2 2663 *statusp = SvIVX(sv);
7b0972df 2664 sprintf(spid, "%"IVdf, (IV)pid);
3280af22 2665 (void)hv_delete(PL_pidstatus,spid,strlen(spid),G_DISCARD);
20188a90
LW		 2666 return pid;
2667 }
2668 }
79072805 2669#ifdef HAS_WAITPID
367f3c24
IZ		 2670# ifdef HAS_WAITPID_RUNTIME
2671 if (!HAS_WAITPID_RUNTIME)
2672 goto hard_way;
2673# endif
f55ee38a 2674 return PerlProc_waitpid(pid,statusp,flags);
367f3c24
IZ		 2675#endif
2676#if !defined(HAS_WAITPID) && defined(HAS_WAIT4)
a0d0e21e 2677 return wait4((pid==-1)?0:pid,statusp,flags,Null(struct rusage *));
367f3c24
IZ		 2678#endif
2679#if !defined(HAS_WAITPID) && !defined(HAS_WAIT4) || defined(HAS_WAITPID_RUNTIME)
2680 hard_way:
a0d0e21e
LW		 2681 {
2682 I32 result;
2683 if (flags)
cea2e8a9 2684 Perl_croak(aTHX_ "Can't do waitpid with flags");
a0d0e21e 2685 else {
76e3520e 2686 while ((result = PerlProc_wait(statusp)) != pid && pid > 0 && result >= 0)
a0d0e21e
LW		 2687 pidgone(result,*statusp);
2688 if (result < 0)
2689 *statusp = -1;
2690 }
2691 return result;
a687059c
LW		 2692 }
2693#endif
a687059c 2694}
2d7a9237 2695#endif /* !DOSISH || OS2 || WIN32 */
a687059c 2696
7c0587c8 2697void
de3bb511 2698/*SUPPRESS 590*/
d8a83dd3 2699Perl_pidgone(pTHX_ Pid_t pid, int status)
a687059c 2700{
79072805 2701 register SV *sv;
fc36a67e 2702 char spid[TYPE_CHARS(int)];
a687059c 2703
7b0972df 2704 sprintf(spid, "%"IVdf, (IV)pid);
3280af22 2705 sv = *hv_fetch(PL_pidstatus,spid,strlen(spid),TRUE);
a0d0e21e 2706 (void)SvUPGRADE(sv,SVt_IV);
463ee0b2 2707 SvIVX(sv) = status;
20188a90 2708 return;
a687059c
LW		 2709}
2710
55497cff 2711#if defined(atarist) || defined(OS2) || defined(DJGPP)
7c0587c8 2712int pclose();
ddcf38b7
IZ		 2713#ifdef HAS_FORK
2714int /* Cannot prototype with I32
2715 in os2ish.h. */
ba106d47 2716my_syspclose(PerlIO *ptr)
ddcf38b7 2717#else
79072805 2718I32
864dbfa3 2719Perl_my_pclose(pTHX_ PerlIO *ptr)
ddcf38b7 2720#endif
a687059c 2721{
760ac839
LW		 2722 /* Needs work for PerlIO ! */
2723 FILE *f = PerlIO_findFILE(ptr);
2724 I32 result = pclose(f);
933fea7f
GS		 2725#if defined(DJGPP)
2726 result = (result << 8) & 0xff00;
2727#endif
760ac839
LW		 2728 PerlIO_releaseFILE(ptr,f);
2729 return result;
a687059c 2730}
7c0587c8 2731#endif
9f68db38
LW		 2732
2733void
864dbfa3 2734Perl_repeatcpy(pTHX_ register char *to, register const char *from, I32 len, register I32 count)
9f68db38 2735{
79072805 2736 register I32 todo;
08105a92 2737 register const char *frombase = from;
9f68db38
LW		 2738
2739 if (len == 1) {
08105a92 2740 register const char c = *from;
9f68db38 2741 while (count-- > 0)
5926133d 2742 *to++ = c;
9f68db38
LW		 2743 return;
2744 }
2745 while (count-- > 0) {
2746 for (todo = len; todo > 0; todo--) {
2747 *to++ = *from++;
2748 }
2749 from = frombase;
2750 }
2751}
0f85fab0 2752
463ee0b2 2753U32
65202027 2754Perl_cast_ulong(pTHX_ NV f)
0f85fab0
LW		 2755{
2756 long along;
2757
27e2fb84 2758#if CASTFLAGS & 2
34de22dd
LW		 2759# define BIGDOUBLE 2147483648.0
2760 if (f >= BIGDOUBLE)
2761 return (unsigned long)(f-(long)(f/BIGDOUBLE)*BIGDOUBLE)|0x80000000;
2762#endif
0f85fab0
LW		 2763 if (f >= 0.0)
2764 return (unsigned long)f;
2765 along = (long)f;
2766 return (unsigned long)along;
2767}
ed6116ce 2768# undef BIGDOUBLE
5d94fbed 2769
5d94fbed
AD		 2770/* Unfortunately, on some systems the cast_uv() function doesn't
2771 work with the system-supplied definition of ULONG_MAX. The
2772 comparison (f >= ULONG_MAX) always comes out true. It must be a
2773 problem with the compiler constant folding.
2774
2775 In any case, this workaround should be fine on any two's complement
2776 system. If it's not, supply a '-DMY_ULONG_MAX=whatever' in your
2777 ccflags.
2778 --Andy Dougherty <doughera@lafcol.lafayette.edu>
2779*/
1eb770ff 2780
2781/* Code modified to prefer proper named type ranges, I32, IV, or UV, instead
2782 of LONG_(MIN/MAX).
2783 -- Kenneth Albanowski <kjahds@kjahds.com>
2784*/
2785
20cec16a 2786#ifndef MY_UV_MAX
2787# define MY_UV_MAX ((UV)IV_MAX * (UV)2 + (UV)1)
5d94fbed
AD		 2788#endif
2789
ed6116ce 2790I32
65202027 2791Perl_cast_i32(pTHX_ NV f)
ed6116ce 2792{
20cec16a 2793 if (f >= I32_MAX)
2794 return (I32) I32_MAX;
2795 if (f <= I32_MIN)
2796 return (I32) I32_MIN;
ed6116ce
LW		 2797 return (I32) f;
2798}
a0d0e21e
LW		 2799
2800IV
65202027 2801Perl_cast_iv(pTHX_ NV f)
a0d0e21e 2802{
25da4f38
IZ		 2803 if (f >= IV_MAX) {
2804 UV uv;
2805
65202027 2806 if (f >= (NV)UV_MAX)
25da4f38
IZ		 2807 return (IV) UV_MAX;
2808 uv = (UV) f;
2809 return (IV)uv;
2810 }
20cec16a 2811 if (f <= IV_MIN)
2812 return (IV) IV_MIN;
a0d0e21e
LW		 2813 return (IV) f;
2814}
5d94fbed
AD		 2815
2816UV
65202027 2817Perl_cast_uv(pTHX_ NV f)
5d94fbed 2818{
20cec16a 2819 if (f >= MY_UV_MAX)
2820 return (UV) MY_UV_MAX;
25da4f38
IZ		 2821 if (f < 0) {
2822 IV iv;
2823
2824 if (f < IV_MIN)
2825 return (UV)IV_MIN;
2826 iv = (IV) f;
2827 return (UV) iv;
2828 }
5d94fbed
AD		 2829 return (UV) f;
2830}
2831
fe14fcc3 2832#ifndef HAS_RENAME
79072805 2833I32
864dbfa3 2834Perl_same_dirent(pTHX_ char *a, char *b)
62b28dd9 2835{
93a17b20
LW		 2836 char *fa = strrchr(a,'/');
2837 char *fb = strrchr(b,'/');
62b28dd9
LW		 2838 struct stat tmpstatbuf1;
2839 struct stat tmpstatbuf2;
46fc3d4c 2840 SV *tmpsv = sv_newmortal();
62b28dd9
LW		 2841
2842 if (fa)
2843 fa++;
2844 else
2845 fa = a;
2846 if (fb)
2847 fb++;
2848 else
2849 fb = b;
2850 if (strNE(a,b))
2851 return FALSE;
2852 if (fa == a)
46fc3d4c 2853 sv_setpv(tmpsv, ".");
62b28dd9 2854 else
46fc3d4c 2855 sv_setpvn(tmpsv, a, fa - a);
c6ed36e1 2856 if (PerlLIO_stat(SvPVX(tmpsv), &tmpstatbuf1) < 0)
62b28dd9
LW		 2857 return FALSE;
2858 if (fb == b)
46fc3d4c 2859 sv_setpv(tmpsv, ".");
62b28dd9 2860 else
46fc3d4c 2861 sv_setpvn(tmpsv, b, fb - b);
c6ed36e1 2862 if (PerlLIO_stat(SvPVX(tmpsv), &tmpstatbuf2) < 0)
62b28dd9
LW		 2863 return FALSE;
2864 return tmpstatbuf1.st_dev == tmpstatbuf2.st_dev &&
2865 tmpstatbuf1.st_ino == tmpstatbuf2.st_ino;
2866}
fe14fcc3
LW		 2867#endif /* !HAS_RENAME */
2868
9e24b6e2 2869NV
864dbfa3 2870Perl_scan_bin(pTHX_ char *start, I32 len, I32 *retlen)
4f19785b
WSI		 2871{
2872 register char *s = start;
9e24b6e2
JH		 2873 register NV rnv = 0.0;
2874 register UV ruv = 0;
252aa082 2875 register bool seenb = FALSE;
9e24b6e2 2876 register bool overflowed = FALSE;
252aa082
JH		 2877
2878 for (; len-- && *s; s++) {
2879 if (!(*s == '0' || *s == '1')) {
b21ed0a9
GS		 2880 if (*s == '_' && len && *retlen
2881 && (s[1] == '0' || s[1] == '1'))
2882 {
2883 --len;
2884 ++s;
2885 }
2886 else if (seenb == FALSE && *s == 'b' && ruv == 0) {
252aa082
JH		 2887 /* Disallow 0bbb0b0bbb... */
2888 seenb = TRUE;
252aa082
JH		 2889 continue;
2890 }
2891 else {
2892 dTHR;
627300f0
JH		 2893 if (ckWARN(WARN_DIGIT))
2894 Perl_warner(aTHX_ WARN_DIGIT,
252aa082
JH		 2895 "Illegal binary digit '%c' ignored", *s);
2896 break;
2897 }
9e24b6e2
JH		 2898 }
2899 if (!overflowed) {
2900 register UV xuv = ruv << 1;
2901
2902 if ((xuv >> 1) != ruv) {
2903 dTHR;
2904 overflowed = TRUE;
2905 rnv = (NV) ruv;
627300f0
JH		 2906 if (ckWARN_d(WARN_OVERFLOW))
2907 Perl_warner(aTHX_ WARN_OVERFLOW,
9e24b6e2 2908 "Integer overflow in binary number");
b21ed0a9
GS		 2909 }
2910 else
9e24b6e2
JH		 2911 ruv = xuv | (*s - '0');
2912 }
2913 if (overflowed) {
2914 rnv *= 2;
2915 /* If an NV has not enough bits in its mantissa to
2916 * represent an UV this summing of small low-order numbers
2917 * is a waste of time (because the NV cannot preserve
2918 * the low-order bits anyway): we could just remember when
2919 * did we overflow and in the end just multiply rnv by the
2cc4c2dc 2920 * right amount. */
9e24b6e2 2921 rnv += (*s - '0');
f248d071 2922 }
4f19785b 2923 }
9e24b6e2
JH		 2924 if (!overflowed)
2925 rnv = (NV) ruv;
893fe2c2 2926 if ( ( overflowed && rnv > 4294967295.0)
15041a67 2927#if UVSIZE > 4
893fe2c2
JH		 2928 || (!overflowed && ruv > 0xffffffff )
2929#endif
2930 ) {
252aa082 2931 dTHR;
627300f0
JH		 2932 if (ckWARN(WARN_PORTABLE))
2933 Perl_warner(aTHX_ WARN_PORTABLE,
252aa082 2934 "Binary number > 0b11111111111111111111111111111111 non-portable");
4f19785b
WSI		 2935 }
2936 *retlen = s - start;
9e24b6e2 2937 return rnv;
4f19785b 2938}
9e24b6e2
JH		 2939
2940NV
864dbfa3 2941Perl_scan_oct(pTHX_ char *start, I32 len, I32 *retlen)
fe14fcc3
LW		 2942{
2943 register char *s = start;
9e24b6e2
JH		 2944 register NV rnv = 0.0;
2945 register UV ruv = 0;
2946 register bool overflowed = FALSE;
252aa082
JH		 2947
2948 for (; len-- && *s; s++) {
2949 if (!(*s >= '0' && *s <= '7')) {
b21ed0a9
GS		 2950 if (*s == '_' && len && *retlen
2951 && (s[1] >= '0' && s[1] <= '7'))
2952 {
2953 --len;
2954 ++s;
2955 }
252aa082 2956 else {
f84f607d
JH		 2957 /* Allow \octal to work the DWIM way (that is, stop scanning
2958 * as soon as non-octal characters are seen, complain only iff
2959 * someone seems to want to use the digits eight and nine). */
252aa082
JH		 2960 if (*s == '8' || *s == '9') {
2961 dTHR;
627300f0
JH		 2962 if (ckWARN(WARN_DIGIT))
2963 Perl_warner(aTHX_ WARN_DIGIT,
252aa082
JH		 2964 "Illegal octal digit '%c' ignored", *s);
2965 }
2966 break;
2967 }
55497cff 2968 }
9e24b6e2 2969 if (!overflowed) {
893fe2c2 2970 register UV xuv = ruv << 3;
9e24b6e2
JH		 2971
2972 if ((xuv >> 3) != ruv) {
2973 dTHR;
2974 overflowed = TRUE;
2975 rnv = (NV) ruv;
627300f0
JH		 2976 if (ckWARN_d(WARN_OVERFLOW))
2977 Perl_warner(aTHX_ WARN_OVERFLOW,
9e24b6e2 2978 "Integer overflow in octal number");
b21ed0a9
GS		 2979 }
2980 else
9e24b6e2
JH		 2981 ruv = xuv | (*s - '0');
2982 }
2983 if (overflowed) {
2984 rnv *= 8.0;
2985 /* If an NV has not enough bits in its mantissa to
2986 * represent an UV this summing of small low-order numbers
2987 * is a waste of time (because the NV cannot preserve
2988 * the low-order bits anyway): we could just remember when
2989 * did we overflow and in the end just multiply rnv by the
2990 * right amount of 8-tuples. */
2991 rnv += (NV)(*s - '0');
2992 }
fe14fcc3 2993 }
9e24b6e2
JH		 2994 if (!overflowed)
2995 rnv = (NV) ruv;
893fe2c2 2996 if ( ( overflowed && rnv > 4294967295.0)
15041a67 2997#if UVSIZE > 4
893fe2c2
JH		 2998 || (!overflowed && ruv > 0xffffffff )
2999#endif
3000 ) {
d008e5eb 3001 dTHR;
627300f0
JH		 3002 if (ckWARN(WARN_PORTABLE))
3003 Perl_warner(aTHX_ WARN_PORTABLE,
252aa082 3004 "Octal number > 037777777777 non-portable");
d008e5eb 3005 }
fe14fcc3 3006 *retlen = s - start;
9e24b6e2 3007 return rnv;
fe14fcc3
LW		 3008}
3009
9e24b6e2 3010NV
864dbfa3 3011Perl_scan_hex(pTHX_ char *start, I32 len, I32 *retlen)
fe14fcc3
LW		 3012{
3013 register char *s = start;
9e24b6e2
JH		 3014 register NV rnv = 0.0;
3015 register UV ruv = 0;
252aa082 3016 register bool seenx = FALSE;
9e24b6e2 3017 register bool overflowed = FALSE;
9e24b6e2 3018 char *hexdigit;
fe14fcc3 3019
9e24b6e2
JH		 3020 for (; len-- && *s; s++) {
3021 hexdigit = strchr((char *) PL_hexdigit, *s);
3022 if (!hexdigit) {
b21ed0a9
GS		 3023 if (*s == '_' && len && *retlen && s[1]
3024 && (hexdigit = strchr((char *) PL_hexdigit, s[1])))
3025 {
3026 --len;
3027 ++s;
3028 }
3029 else if (seenx == FALSE && *s == 'x' && ruv == 0) {
252aa082
JH		 3030 /* Disallow 0xxx0x0xxx... */
3031 seenx = TRUE;
252aa082
JH		 3032 continue;
3033 }
a0ed51b3 3034 else {
d008e5eb 3035 dTHR;
627300f0
JH		 3036 if (ckWARN(WARN_DIGIT))
3037 Perl_warner(aTHX_ WARN_DIGIT,
252aa082 3038 "Illegal hexadecimal digit '%c' ignored", *s);
a0ed51b3
LW		 3039 break;
3040 }
3041 }
9e24b6e2
JH		 3042 if (!overflowed) {
3043 register UV xuv = ruv << 4;
3044
3045 if ((xuv >> 4) != ruv) {
3046 dTHR;
3047 overflowed = TRUE;
3048 rnv = (NV) ruv;
627300f0
JH		 3049 if (ckWARN_d(WARN_OVERFLOW))
3050 Perl_warner(aTHX_ WARN_OVERFLOW,
9e24b6e2 3051 "Integer overflow in hexadecimal number");
b21ed0a9
GS		 3052 }
3053 else
9e24b6e2
JH		 3054 ruv = xuv | ((hexdigit - PL_hexdigit) & 15);
3055 }
3056 if (overflowed) {
3057 rnv *= 16.0;
3058 /* If an NV has not enough bits in its mantissa to
3059 * represent an UV this summing of small low-order numbers
3060 * is a waste of time (because the NV cannot preserve
3061 * the low-order bits anyway): we could just remember when
3062 * did we overflow and in the end just multiply rnv by the
3063 * right amount of 16-tuples. */
3064 rnv += (NV)((hexdigit - PL_hexdigit) & 15);
3065 }
6ff81951 3066 }
9e24b6e2
JH		 3067 if (!overflowed)
3068 rnv = (NV) ruv;
893fe2c2 3069 if ( ( overflowed && rnv > 4294967295.0)
15041a67 3070#if UVSIZE > 4
893fe2c2
JH		 3071 || (!overflowed && ruv > 0xffffffff )
3072#endif
3073 ) {
252aa082 3074 dTHR;
627300f0
JH		 3075 if (ckWARN(WARN_PORTABLE))
3076 Perl_warner(aTHX_ WARN_PORTABLE,
252aa082
JH		 3077 "Hexadecimal number > 0xffffffff non-portable");
3078 }
fe14fcc3 3079 *retlen = s - start;
9e24b6e2 3080 return rnv;
fe14fcc3 3081}
760ac839 3082
491527d0 3083char*
864dbfa3 3084Perl_find_script(pTHX_ char *scriptname, bool dosearch, char **search_ext, I32 flags)
491527d0
GS		 3085{
3086 dTHR;
3087 char *xfound = Nullch;
3088 char *xfailed = Nullch;
0f31cffe 3089 char tmpbuf[MAXPATHLEN];
491527d0
GS		 3090 register char *s;
3091 I32 len;
3092 int retval;
3093#if defined(DOSISH) && !defined(OS2) && !defined(atarist)
3094# define SEARCH_EXTS ".bat", ".cmd", NULL
3095# define MAX_EXT_LEN 4
3096#endif
3097#ifdef OS2
3098# define SEARCH_EXTS ".cmd", ".btm", ".bat", ".pl", NULL
3099# define MAX_EXT_LEN 4
3100#endif
3101#ifdef VMS
3102# define SEARCH_EXTS ".pl", ".com", NULL
3103# define MAX_EXT_LEN 4
3104#endif
3105 /* additional extensions to try in each dir if scriptname not found */
3106#ifdef SEARCH_EXTS
3107 char *exts[] = { SEARCH_EXTS };
3108 char **ext = search_ext ? search_ext : exts;
3109 int extidx = 0, i = 0;
3110 char *curext = Nullch;
3111#else
3112# define MAX_EXT_LEN 0
3113#endif
3114
3115 /*
3116 * If dosearch is true and if scriptname does not contain path
3117 * delimiters, search the PATH for scriptname.
3118 *
3119 * If SEARCH_EXTS is also defined, will look for each
3120 * scriptname{SEARCH_EXTS} whenever scriptname is not found
3121 * while searching the PATH.
3122 *
3123 * Assuming SEARCH_EXTS is C<".foo",".bar",NULL>, PATH search
3124 * proceeds as follows:
3125 * If DOSISH or VMSISH:
3126 * + look for ./scriptname{,.foo,.bar}
3127 * + search the PATH for scriptname{,.foo,.bar}
3128 *
3129 * If !DOSISH:
3130 * + look *only* in the PATH for scriptname{,.foo,.bar} (note
3131 * this will not look in '.' if it's not in the PATH)
3132 */
84486fc6 3133 tmpbuf[0] = '\0';
491527d0
GS		 3134
3135#ifdef VMS
3136# ifdef ALWAYS_DEFTYPES
3137 len = strlen(scriptname);
3138 if (!(len == 1 && *scriptname == '-') && scriptname[len-1] != ':') {
3139 int hasdir, idx = 0, deftypes = 1;
3140 bool seen_dot = 1;
3141
3142 hasdir = !dosearch || (strpbrk(scriptname,":[</") != Nullch) ;
3143# else
3144 if (dosearch) {
3145 int hasdir, idx = 0, deftypes = 1;
3146 bool seen_dot = 1;
3147
3148 hasdir = (strpbrk(scriptname,":[</") != Nullch) ;
3149# endif
3150 /* The first time through, just add SEARCH_EXTS to whatever we
3151 * already have, so we can check for default file types. */
3152 while (deftypes ||
84486fc6 3153 (!hasdir && my_trnlnm("DCL$PATH",tmpbuf,idx++)) )
491527d0
GS		 3154 {
3155 if (deftypes) {
3156 deftypes = 0;
84486fc6 3157 *tmpbuf = '\0';
491527d0 3158 }
84486fc6
GS		 3159 if ((strlen(tmpbuf) + strlen(scriptname)
3160 + MAX_EXT_LEN) >= sizeof tmpbuf)
491527d0 3161 continue; /* don't search dir with too-long name */
84486fc6 3162 strcat(tmpbuf, scriptname);
491527d0
GS		 3163#else /* !VMS */
3164
3165#ifdef DOSISH
3166 if (strEQ(scriptname, "-"))
3167 dosearch = 0;
3168 if (dosearch) { /* Look in '.' first. */
3169 char *cur = scriptname;
3170#ifdef SEARCH_EXTS
3171 if ((curext = strrchr(scriptname,'.'))) /* possible current ext */
3172 while (ext[i])
3173 if (strEQ(ext[i++],curext)) {
3174 extidx = -1; /* already has an ext */
3175 break;
3176 }
3177 do {
3178#endif
3179 DEBUG_p(PerlIO_printf(Perl_debug_log,
3180 "Looking for %s\n",cur));
017f25f1
IZ		 3181 if (PerlLIO_stat(cur,&PL_statbuf) >= 0
3182 && !S_ISDIR(PL_statbuf.st_mode)) {
491527d0
GS		 3183 dosearch = 0;
3184 scriptname = cur;
3185#ifdef SEARCH_EXTS
3186 break;
3187#endif
3188 }
3189#ifdef SEARCH_EXTS
3190 if (cur == scriptname) {
3191 len = strlen(scriptname);
84486fc6 3192 if (len+MAX_EXT_LEN+1 >= sizeof(tmpbuf))
491527d0 3193 break;
84486fc6 3194 cur = strcpy(tmpbuf, scriptname);
491527d0
GS		 3195 }
3196 } while (extidx >= 0 && ext[extidx] /* try an extension? */
84486fc6 3197 && strcpy(tmpbuf+len, ext[extidx++]));
491527d0
GS		 3198#endif
3199 }
3200#endif
3201
cd39f2b6
JH		 3202#ifdef MACOS_TRADITIONAL
3203 if (dosearch && !strchr(scriptname, ':') &&
3204 (s = PerlEnv_getenv("Commands")))
3205#else
491527d0
GS		 3206 if (dosearch && !strchr(scriptname, '/')
3207#ifdef DOSISH
3208 && !strchr(scriptname, '\\')
3209#endif
cd39f2b6
JH		 3210 && (s = PerlEnv_getenv("PATH")))
3211#endif
3212 {
491527d0
GS		 3213 bool seen_dot = 0;
3214
3280af22
NIS		 3215 PL_bufend = s + strlen(s);
3216 while (s < PL_bufend) {
cd39f2b6
JH		 3217#ifdef MACOS_TRADITIONAL
3218 s = delimcpy(tmpbuf, tmpbuf + sizeof tmpbuf, s, PL_bufend,
3219 ',',
3220 &len);
3221#else
491527d0
GS		 3222#if defined(atarist) || defined(DOSISH)
3223 for (len = 0; *s
3224# ifdef atarist
3225 && *s != ','
3226# endif
3227 && *s != ';'; len++, s++) {
84486fc6
GS		 3228 if (len < sizeof tmpbuf)
3229 tmpbuf[len] = *s;
491527d0 3230 }
84486fc6
GS		 3231 if (len < sizeof tmpbuf)
3232 tmpbuf[len] = '\0';
491527d0 3233#else /* ! (atarist || DOSISH) */
3280af22 3234 s = delimcpy(tmpbuf, tmpbuf + sizeof tmpbuf, s, PL_bufend,
491527d0
GS		 3235 ':',
3236 &len);
3237#endif /* ! (atarist || DOSISH) */
cd39f2b6 3238#endif /* MACOS_TRADITIONAL */
3280af22 3239 if (s < PL_bufend)
491527d0 3240 s++;
84486fc6 3241 if (len + 1 + strlen(scriptname) + MAX_EXT_LEN >= sizeof tmpbuf)
491527d0 3242 continue; /* don't search dir with too-long name */
cd39f2b6
JH		 3243#ifdef MACOS_TRADITIONAL
3244 if (len && tmpbuf[len - 1] != ':')
3245 tmpbuf[len++] = ':';
3246#else
491527d0 3247 if (len
61ae2fbf 3248#if defined(atarist) || defined(__MINT__) || defined(DOSISH)
84486fc6
GS		 3249 && tmpbuf[len - 1] != '/'
3250 && tmpbuf[len - 1] != '\\'
491527d0
GS		 3251#endif
3252 )
84486fc6
GS		 3253 tmpbuf[len++] = '/';
3254 if (len == 2 && tmpbuf[0] == '.')
491527d0 3255 seen_dot = 1;
cd39f2b6 3256#endif
84486fc6 3257 (void)strcpy(tmpbuf + len, scriptname);
491527d0
GS		 3258#endif /* !VMS */
3259
3260#ifdef SEARCH_EXTS
84486fc6 3261 len = strlen(tmpbuf);
491527d0
GS		 3262 if (extidx > 0) /* reset after previous loop */
3263 extidx = 0;
3264 do {
3265#endif
84486fc6 3266 DEBUG_p(PerlIO_printf(Perl_debug_log, "Looking for %s\n",tmpbuf));
3280af22 3267 retval = PerlLIO_stat(tmpbuf,&PL_statbuf);
017f25f1
IZ		 3268 if (S_ISDIR(PL_statbuf.st_mode)) {
3269 retval = -1;
3270 }
491527d0
GS		 3271#ifdef SEARCH_EXTS
3272 } while ( retval < 0 /* not there */
3273 && extidx>=0 && ext[extidx] /* try an extension? */
84486fc6 3274 && strcpy(tmpbuf+len, ext[extidx++])
491527d0
GS		 3275 );
3276#endif
3277 if (retval < 0)
3278 continue;
3280af22
NIS		 3279 if (S_ISREG(PL_statbuf.st_mode)
3280 && cando(S_IRUSR,TRUE,&PL_statbuf)
73811745 3281#if !defined(DOSISH) && !defined(MACOS_TRADITIONAL)
3280af22 3282 && cando(S_IXUSR,TRUE,&PL_statbuf)
491527d0
GS		 3283#endif
3284 )
3285 {
84486fc6 3286 xfound = tmpbuf; /* bingo! */
491527d0
GS		 3287 break;
3288 }
3289 if (!xfailed)
84486fc6 3290 xfailed = savepv(tmpbuf);
491527d0
GS		 3291 }
3292#ifndef DOSISH
017f25f1
IZ		 3293 if (!xfound && !seen_dot && !xfailed &&
3294 (PerlLIO_stat(scriptname,&PL_statbuf) < 0
3295 || S_ISDIR(PL_statbuf.st_mode)))
491527d0
GS		 3296#endif
3297 seen_dot = 1; /* Disable message. */
9ccb31f9
GS		 3298 if (!xfound) {
3299 if (flags & 1) { /* do or die? */
cea2e8a9 3300 Perl_croak(aTHX_ "Can't %s %s%s%s",
9ccb31f9
GS		 3301 (xfailed ? "execute" : "find"),
3302 (xfailed ? xfailed : scriptname),
3303 (xfailed ? "" : " on PATH"),
3304 (xfailed || seen_dot) ? "" : ", '.' not in PATH");
3305 }
3306 scriptname = Nullch;
3307 }
491527d0
GS		 3308 if (xfailed)
3309 Safefree(xfailed);
3310 scriptname = xfound;
3311 }
9ccb31f9 3312 return (scriptname ? savepv(scriptname) : Nullch);
491527d0
GS		 3313}
3314
ba869deb
GS		 3315#ifndef PERL_GET_CONTEXT_DEFINED
3316
3317void *
3318Perl_get_context(void)
3319{
3320#if defined(USE_THREADS) || defined(USE_ITHREADS)
3321# ifdef OLD_PTHREADS_API
3322 pthread_addr_t t;
3323 if (pthread_getspecific(PL_thr_key, &t))
3324 Perl_croak_nocontext("panic: pthread_getspecific");
3325 return (void*)t;
3326# else
c44d3fdb
GS		 3327# ifdef I_MACH_CTHREADS
3328 return (void*)cthread_data(cthread_self());
3329# else
ba869deb
GS		 3330 return (void*)pthread_getspecific(PL_thr_key);
3331# endif
c44d3fdb 3332# endif
ba869deb
GS		 3333#else
3334 return (void*)NULL;
3335#endif
3336}
3337
3338void
3339Perl_set_context(void *t)
3340{
3341#if defined(USE_THREADS) || defined(USE_ITHREADS)
c44d3fdb
GS		 3342# ifdef I_MACH_CTHREADS
3343 cthread_set_data(cthread_self(), t);
3344# else
ba869deb
GS		 3345 if (pthread_setspecific(PL_thr_key, t))
3346 Perl_croak_nocontext("panic: pthread_setspecific");
c44d3fdb 3347# endif
ba869deb
GS		 3348#endif
3349}
3350
3351#endif /* !PERL_GET_CONTEXT_DEFINED */
491527d0 3352
11343788 3353#ifdef USE_THREADS
ba869deb 3354
12ca11f6
MB		 3355#ifdef FAKE_THREADS
3356/* Very simplistic scheduler for now */
3357void
3358schedule(void)
3359{
c7848ba1 3360 thr = thr->i.next_run;
12ca11f6
MB		 3361}
3362
3363void
864dbfa3 3364Perl_cond_init(pTHX_ perl_cond *cp)
12ca11f6
MB		 3365{
3366 *cp = 0;
3367}
3368
3369void
864dbfa3 3370Perl_cond_signal(pTHX_ perl_cond *cp)
12ca11f6 3371{
51dd5992 3372 perl_os_thread t;
12ca11f6
MB		 3373 perl_cond cond = *cp;
3374
3375 if (!cond)
3376 return;
3377 t = cond->thread;
3378 /* Insert t in the runnable queue just ahead of us */
c7848ba1
MB		 3379 t->i.next_run = thr->i.next_run;
3380 thr->i.next_run->i.prev_run = t;
3381 t->i.prev_run = thr;
3382 thr->i.next_run = t;
3383 thr->i.wait_queue = 0;
12ca11f6
MB		 3384 /* Remove from the wait queue */
3385 *cp = cond->next;
3386 Safefree(cond);
3387}
3388
3389void
864dbfa3 3390Perl_cond_broadcast(pTHX_ perl_cond *cp)
12ca11f6 3391{
51dd5992 3392 perl_os_thread t;
12ca11f6
MB		 3393 perl_cond cond, cond_next;
3394
3395 for (cond = *cp; cond; cond = cond_next) {
3396 t = cond->thread;
3397 /* Insert t in the runnable queue just ahead of us */
c7848ba1
MB		 3398 t->i.next_run = thr->i.next_run;
3399 thr->i.next_run->i.prev_run = t;
3400 t->i.prev_run = thr;
3401 thr->i.next_run = t;
3402 thr->i.wait_queue = 0;
12ca11f6
MB		 3403 /* Remove from the wait queue */
3404 cond_next = cond->next;
3405 Safefree(cond);
3406 }
3407 *cp = 0;
3408}
3409
3410void
864dbfa3 3411Perl_cond_wait(pTHX_ perl_cond *cp)
12ca11f6
MB		 3412{
3413 perl_cond cond;
3414
c7848ba1 3415 if (thr->i.next_run == thr)
cea2e8a9 3416 Perl_croak(aTHX_ "panic: perl_cond_wait called by last runnable thread");
12ca11f6 3417
0f15f207 3418 New(666, cond, 1, struct perl_wait_queue);
12ca11f6
MB		 3419 cond->thread = thr;
3420 cond->next = *cp;
3421 *cp = cond;
c7848ba1 3422 thr->i.wait_queue = cond;
12ca11f6 3423 /* Remove ourselves from runnable queue */
c7848ba1
MB		 3424 thr->i.next_run->i.prev_run = thr->i.prev_run;
3425 thr->i.prev_run->i.next_run = thr->i.next_run;
12ca11f6
MB		 3426}
3427#endif /* FAKE_THREADS */
3428
f93b4edd 3429MAGIC *
864dbfa3 3430Perl_condpair_magic(pTHX_ SV *sv)
f93b4edd
MB		 3431{
3432 MAGIC *mg;
3433
3434 SvUPGRADE(sv, SVt_PVMG);
3435 mg = mg_find(sv, 'm');
3436 if (!mg) {
3437 condpair_t *cp;
3438
3439 New(53, cp, 1, condpair_t);
3440 MUTEX_INIT(&cp->mutex);
3441 COND_INIT(&cp->owner_cond);
3442 COND_INIT(&cp->cond);
3443 cp->owner = 0;
1feb2720 3444 LOCK_CRED_MUTEX; /* XXX need separate mutex? */
f93b4edd
MB		 3445 mg = mg_find(sv, 'm');
3446 if (mg) {
3447 /* someone else beat us to initialising it */
1feb2720 3448 UNLOCK_CRED_MUTEX; /* XXX need separate mutex? */
f93b4edd
MB		 3449 MUTEX_DESTROY(&cp->mutex);
3450 COND_DESTROY(&cp->owner_cond);
3451 COND_DESTROY(&cp->cond);
3452 Safefree(cp);
3453 }
3454 else {
3455 sv_magic(sv, Nullsv, 'm', 0, 0);
3456 mg = SvMAGIC(sv);
3457 mg->mg_ptr = (char *)cp;
565764a8 3458 mg->mg_len = sizeof(cp);
1feb2720 3459 UNLOCK_CRED_MUTEX; /* XXX need separate mutex? */
bf49b057 3460 DEBUG_S(WITH_THR(PerlIO_printf(Perl_debug_log,
c7848ba1 3461 "%p: condpair_magic %p\n", thr, sv));)
f93b4edd
MB		 3462 }
3463 }
3464 return mg;
3465}
a863c7d1
MB		 3466
3467/*
199100c8
MB		 3468 * Make a new perl thread structure using t as a prototype. Some of the
3469 * fields for the new thread are copied from the prototype thread, t,
3470 * so t should not be running in perl at the time this function is
3471 * called. The use by ext/Thread/Thread.xs in core perl (where t is the
3472 * thread calling new_struct_thread) clearly satisfies this constraint.
a863c7d1 3473 */
52e1cb5e 3474struct perl_thread *
864dbfa3 3475Perl_new_struct_thread(pTHX_ struct perl_thread *t)
a863c7d1 3476{
c5be433b 3477#if !defined(PERL_IMPLICIT_CONTEXT)
52e1cb5e 3478 struct perl_thread *thr;
cea2e8a9 3479#endif
a863c7d1 3480 SV *sv;
199100c8
MB		 3481 SV **svp;
3482 I32 i;
3483
79cb57f6 3484 sv = newSVpvn("", 0);
52e1cb5e
JH		 3485 SvGROW(sv, sizeof(struct perl_thread) + 1);
3486 SvCUR_set(sv, sizeof(struct perl_thread));
199100c8 3487 thr = (Thread) SvPVX(sv);
949ced2d 3488#ifdef DEBUGGING
52e1cb5e 3489 memset(thr, 0xab, sizeof(struct perl_thread));
533c011a
NIS		 3490 PL_markstack = 0;
3491 PL_scopestack = 0;
3492 PL_savestack = 0;
3493 PL_retstack = 0;
3494 PL_dirty = 0;
3495 PL_localizing = 0;
949ced2d
GS		 3496 Zero(&PL_hv_fetch_ent_mh, 1, HE);
3497#else
3498 Zero(thr, 1, struct perl_thread);
3499#endif
199100c8
MB		 3500
3501 thr->oursv = sv;
cea2e8a9 3502 init_stacks();
a863c7d1 3503
533c011a 3504 PL_curcop = &PL_compiling;
c5be433b 3505 thr->interp = t->interp;
199100c8 3506 thr->cvcache = newHV();
54b9620d 3507 thr->threadsv = newAV();
a863c7d1 3508 thr->specific = newAV();
79cb57f6 3509 thr->errsv = newSVpvn("", 0);
a863c7d1
MB		 3510 thr->flags = THRf_R_JOINABLE;
3511 MUTEX_INIT(&thr->mutex);
199100c8 3512
5c831c24 3513 JMPENV_BOOTSTRAP;
533c011a 3514
faef0170 3515 PL_in_eval = EVAL_NULL; /* ~(EVAL_INEVAL|EVAL_WARNONLY|EVAL_KEEPERR) */
533c011a
NIS		 3516 PL_restartop = 0;
3517
b099ddc0 3518 PL_statname = NEWSV(66,0);
5a844595 3519 PL_errors = newSVpvn("", 0);
b099ddc0 3520 PL_maxscream = -1;
0b94c7bb
GS		 3521 PL_regcompp = MEMBER_TO_FPTR(Perl_pregcomp);
3522 PL_regexecp = MEMBER_TO_FPTR(Perl_regexec_flags);
3523 PL_regint_start = MEMBER_TO_FPTR(Perl_re_intuit_start);
3524 PL_regint_string = MEMBER_TO_FPTR(Perl_re_intuit_string);
3525 PL_regfree = MEMBER_TO_FPTR(Perl_pregfree);
b099ddc0
GS		 3526 PL_regindent = 0;
3527 PL_reginterp_cnt = 0;
3528 PL_lastscream = Nullsv;
3529 PL_screamfirst = 0;
3530 PL_screamnext = 0;
3531 PL_reg_start_tmp = 0;
3532 PL_reg_start_tmpl = 0;
14ed4b74 3533 PL_reg_poscache = Nullch;
b099ddc0
GS		 3534
3535 /* parent thread's data needs to be locked while we make copy */
3536 MUTEX_LOCK(&t->mutex);
3537
14dd3ad8 3538#ifdef PERL_FLEXIBLE_EXCEPTIONS
312caa8e 3539 PL_protect = t->Tprotect;
14dd3ad8 3540#endif
312caa8e 3541
b099ddc0
GS		 3542 PL_curcop = t->Tcurcop; /* XXX As good a guess as any? */
3543 PL_defstash = t->Tdefstash; /* XXX maybe these should */
3544 PL_curstash = t->Tcurstash; /* always be set to main? */
3545
6b88bc9c 3546 PL_tainted = t->Ttainted;
84fee439
NIS		 3547 PL_curpm = t->Tcurpm; /* XXX No PMOP ref count */
3548 PL_nrs = newSVsv(t->Tnrs);
3549 PL_rs = SvREFCNT_inc(PL_nrs);
3550 PL_last_in_gv = Nullgv;
3551 PL_ofslen = t->Tofslen;
3552 PL_ofs = savepvn(t->Tofs, PL_ofslen);
3553 PL_defoutgv = (GV*)SvREFCNT_inc(t->Tdefoutgv);
3554 PL_chopset = t->Tchopset;
84fee439
NIS		 3555 PL_bodytarget = newSVsv(t->Tbodytarget);
3556 PL_toptarget = newSVsv(t->Ttoptarget);
5c831c24
GS		 3557 if (t->Tformtarget == t->Ttoptarget)
3558 PL_formtarget = PL_toptarget;
3559 else
3560 PL_formtarget = PL_bodytarget;
533c011a 3561
54b9620d
MB		 3562 /* Initialise all per-thread SVs that the template thread used */
3563 svp = AvARRAY(t->threadsv);
93965878 3564 for (i = 0; i <= AvFILLp(t->threadsv); i++, svp++) {
533c011a 3565 if (*svp && *svp != &PL_sv_undef) {
199100c8 3566 SV *sv = newSVsv(*svp);
54b9620d 3567 av_store(thr->threadsv, i, sv);
533c011a 3568 sv_magic(sv, 0, 0, &PL_threadsv_names[i], 1);
bf49b057 3569 DEBUG_S(PerlIO_printf(Perl_debug_log,
f1dbda3d
JH		 3570 "new_struct_thread: copied threadsv %"IVdf" %p->%p\n",
3571 (IV)i, t, thr));
199100c8
MB		 3572 }
3573 }
940cb80d 3574 thr->threadsvp = AvARRAY(thr->threadsv);
199100c8 3575
533c011a
NIS		 3576 MUTEX_LOCK(&PL_threads_mutex);
3577 PL_nthreads++;
3578 thr->tid = ++PL_threadnum;
199100c8
MB		 3579 thr->next = t->next;
3580 thr->prev = t;
3581 t->next = thr;
3582 thr->next->prev = thr;
533c011a 3583 MUTEX_UNLOCK(&PL_threads_mutex);
a863c7d1 3584
b099ddc0
GS		 3585 /* done copying parent's state */
3586 MUTEX_UNLOCK(&t->mutex);
3587
a863c7d1 3588#ifdef HAVE_THREAD_INTERN
4f63d024 3589 Perl_init_thread_intern(thr);
a863c7d1 3590#endif /* HAVE_THREAD_INTERN */
a863c7d1
MB		 3591 return thr;
3592}
11343788 3593#endif /* USE_THREADS */
760ac839
LW		 3594
3595#ifdef HUGE_VAL
3596/*
3597 * This hack is to force load of "huge" support from libm.a
3598 * So it is in perl for (say) POSIX to use.
3599 * Needed for SunOS with Sun's 'acc' for example.
3600 */
65202027 3601NV
8ac85365 3602Perl_huge(void)
760ac839
LW		 3603{
3604 return HUGE_VAL;
3605}
3606#endif
4e35701f 3607
22239a37
NIS		 3608#ifdef PERL_GLOBAL_STRUCT
3609struct perl_vars *
864dbfa3 3610Perl_GetVars(pTHX)
22239a37 3611{
533c011a 3612 return &PL_Vars;
22239a37 3613}
31fb1209
NIS		 3614#endif
3615
3616char **
864dbfa3 3617Perl_get_op_names(pTHX)
31fb1209 3618{
22c35a8c 3619 return PL_op_name;
31fb1209
NIS		 3620}
3621
3622char **
864dbfa3 3623Perl_get_op_descs(pTHX)
31fb1209 3624{
22c35a8c 3625 return PL_op_desc;
31fb1209 3626}
9e6b2b00
GS		 3627
3628char *
864dbfa3 3629Perl_get_no_modify(pTHX)
9e6b2b00 3630{
22c35a8c 3631 return (char*)PL_no_modify;
9e6b2b00
GS		 3632}
3633
3634U32 *
864dbfa3 3635Perl_get_opargs(pTHX)
9e6b2b00 3636{
22c35a8c 3637 return PL_opargs;
9e6b2b00 3638}
51aa15f3 3639
0cb96387
GS		 3640PPADDR_t*
3641Perl_get_ppaddr(pTHX)
3642{
3643 return &PL_ppaddr;
3644}
3645
a6c40364
GS		 3646#ifndef HAS_GETENV_LEN
3647char *
864dbfa3 3648Perl_getenv_len(pTHX_ char *env_elem, unsigned long *len)
a6c40364
GS		 3649{
3650 char *env_trans = PerlEnv_getenv(env_elem);
3651 if (env_trans)
3652 *len = strlen(env_trans);
3653 return env_trans;
f675dbe5
CB		 3654}
3655#endif
3656
dc9e4912
GS		 3657
3658MGVTBL*
864dbfa3 3659Perl_get_vtbl(pTHX_ int vtbl_id)
dc9e4912
GS		 3660{
3661 MGVTBL* result = Null(MGVTBL*);
3662
3663 switch(vtbl_id) {
3664 case want_vtbl_sv:
3665 result = &PL_vtbl_sv;
3666 break;
3667 case want_vtbl_env:
3668 result = &PL_vtbl_env;
3669 break;
3670 case want_vtbl_envelem:
3671 result = &PL_vtbl_envelem;
3672 break;
3673 case want_vtbl_sig:
3674 result = &PL_vtbl_sig;
3675 break;
3676 case want_vtbl_sigelem:
3677 result = &PL_vtbl_sigelem;
3678 break;
3679 case want_vtbl_pack:
3680 result = &PL_vtbl_pack;
3681 break;
3682 case want_vtbl_packelem:
3683 result = &PL_vtbl_packelem;
3684 break;
3685 case want_vtbl_dbline:
3686 result = &PL_vtbl_dbline;
3687 break;
3688 case want_vtbl_isa:
3689 result = &PL_vtbl_isa;
3690 break;
3691 case want_vtbl_isaelem:
3692 result = &PL_vtbl_isaelem;
3693 break;
3694 case want_vtbl_arylen:
3695 result = &PL_vtbl_arylen;
3696 break;
3697 case want_vtbl_glob:
3698 result = &PL_vtbl_glob;
3699 break;
3700 case want_vtbl_mglob:
3701 result = &PL_vtbl_mglob;
3702 break;
3703 case want_vtbl_nkeys:
3704 result = &PL_vtbl_nkeys;
3705 break;
3706 case want_vtbl_taint:
3707 result = &PL_vtbl_taint;
3708 break;
3709 case want_vtbl_substr:
3710 result = &PL_vtbl_substr;
3711 break;
3712 case want_vtbl_vec:
3713 result = &PL_vtbl_vec;
3714 break;
3715 case want_vtbl_pos:
3716 result = &PL_vtbl_pos;
3717 break;
3718 case want_vtbl_bm:
3719 result = &PL_vtbl_bm;
3720 break;
3721 case want_vtbl_fm:
3722 result = &PL_vtbl_fm;
3723 break;
3724 case want_vtbl_uvar:
3725 result = &PL_vtbl_uvar;
3726 break;
3727#ifdef USE_THREADS
3728 case want_vtbl_mutex:
3729 result = &PL_vtbl_mutex;
3730 break;
3731#endif
3732 case want_vtbl_defelem:
3733 result = &PL_vtbl_defelem;
3734 break;
3735 case want_vtbl_regexp:
3736 result = &PL_vtbl_regexp;
3737 break;
3738 case want_vtbl_regdata:
3739 result = &PL_vtbl_regdata;
3740 break;
3741 case want_vtbl_regdatum:
3742 result = &PL_vtbl_regdatum;
3743 break;
3c90161d 3744#ifdef USE_LOCALE_COLLATE
dc9e4912
GS		 3745 case want_vtbl_collxfrm:
3746 result = &PL_vtbl_collxfrm;
3747 break;
3c90161d 3748#endif
dc9e4912
GS		 3749 case want_vtbl_amagic:
3750 result = &PL_vtbl_amagic;
3751 break;
3752 case want_vtbl_amagicelem:
3753 result = &PL_vtbl_amagicelem;
3754 break;
810b8aa5
GS		 3755 case want_vtbl_backref:
3756 result = &PL_vtbl_backref;
3757 break;
dc9e4912
GS		 3758 }
3759 return result;
3760}
3761
767df6a1 3762I32
864dbfa3 3763Perl_my_fflush_all(pTHX)
767df6a1
JH		 3764{
3765#ifdef FFLUSH_NULL
ce720889 3766 return PerlIO_flush(NULL);
767df6a1
JH		 3767#else
3768 long open_max = -1;
ed39a0f2 3769# if defined(FFLUSH_ALL) && defined(HAS_STDIO_STREAM_ARRAY)
d2201af2
AD		 3770# ifdef PERL_FFLUSH_ALL_FOPEN_MAX
3771 open_max = PERL_FFLUSH_ALL_FOPEN_MAX;
3772# else
767df6a1
JH		 3773# if defined(HAS_SYSCONF) && defined(_SC_OPEN_MAX)
3774 open_max = sysconf(_SC_OPEN_MAX);
3775# else
3776# ifdef FOPEN_MAX
d2201af2 3777 open_max = FOPEN_MAX;
767df6a1
JH		 3778# else
3779# ifdef OPEN_MAX
d2201af2 3780 open_max = OPEN_MAX;
767df6a1
JH		 3781# else
3782# ifdef _NFILE
d2201af2 3783 open_max = _NFILE;
767df6a1
JH		 3784# endif
3785# endif
3786# endif
3787# endif
d2201af2 3788# endif
767df6a1
JH		 3789 if (open_max > 0) {
3790 long i;
3791 for (i = 0; i < open_max; i++)
d2201af2
AD		 3792 if (STDIO_STREAM_ARRAY[i]._file >= 0 &&
3793 STDIO_STREAM_ARRAY[i]._file < open_max &&
3794 STDIO_STREAM_ARRAY[i]._flag)
3795 PerlIO_flush(&STDIO_STREAM_ARRAY[i]);
767df6a1
JH		 3796 return 0;
3797 }
3798# endif
3799 SETERRNO(EBADF,RMS$_IFI);
3800 return EOF;
3801#endif
3802}
097ee67d 3803
65202027 3804NV
69282e91
GS		 3805Perl_my_atof(pTHX_ const char* s)
3806{
097ee67d 3807#ifdef USE_LOCALE_NUMERIC
d43ce814 3808 if ((PL_hints & HINT_LOCALE) && PL_numeric_local) {
65202027 3809 NV x, y;
097ee67d 3810
65202027 3811 x = Perl_atof(s);
097ee67d 3812 SET_NUMERIC_STANDARD();
65202027 3813 y = Perl_atof(s);
097ee67d
JH		 3814 SET_NUMERIC_LOCAL();
3815 if ((y < 0.0 && y < x) || (y > 0.0 && y > x))
3816 return y;
3817 return x;
65202027
DS		 3818 }
3819 else
3820 return Perl_atof(s);
097ee67d 3821#else
65202027 3822 return Perl_atof(s);
097ee67d
JH		 3823#endif
3824}
69282e91
GS		 3825
3826void
3827Perl_report_closed_fh(pTHX_ GV *gv, IO *io, const char *func, const char *obj)
3828{
3829 SV *sv;
3830 char *name;
3831
3832 assert(gv);
3833
3834 sv = sv_newmortal();
3835 gv_efullname3(sv, gv, Nullch);
3836 name = SvPVX(sv);
3837
3838 Perl_warner(aTHX_ WARN_CLOSED, "%s() on closed %s %s", func, obj, name);
3839
3840 if (io && IoDIRP(io))
3841 Perl_warner(aTHX_ WARN_CLOSED,
cc507455 3842 "\t(Are you trying to call %s() on dirhandle %s?)\n",
69282e91
GS		 3843 func, name);
3844}
Unnamed repository; edit this file 'description' to name the repository.