3 * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 * 2000, 2001, 2002, 2003, 2004, 2005, by Larry Wall and others
6 * You may distribute under the terms of either the GNU General Public
7 * License or the Artistic License, as specified in the README file.
12 * "Very useful, no doubt, that was to Saruman; yet it seems that he was
13 * not content." --Gandalf
16 /* This file contains assorted utility routines.
17 * Which is a polite way of saying any stuff that people couldn't think of
18 * a better place for. Amongst other things, it includes the warning and
19 * dieing stuff, plus wrappers for malloc code.
23 #define PERL_IN_UTIL_C
29 # define SIG_ERR ((Sighandler_t) -1)
34 /* Missing protos on LynxOS */
39 # include <sys/wait.h>
44 # include <sys/select.h>
50 #if defined(HAS_FCNTL) && defined(F_SETFD) && !defined(FD_CLOEXEC)
51 # define FD_CLOEXEC 1 /* NeXT needs this */
54 /* NOTE: Do not call the next three routines directly. Use the macros
55 * in handy.h, so that we can easily redefine everything to do tracking of
56 * allocated hunks back to the original New to track down any memory leaks.
57 * XXX This advice seems to be widely ignored :-( --AD August 1996.
63 /* Can't use PerlIO to write as it allocates memory */
64 PerlLIO_write(PerlIO_fileno(Perl_error_log),
65 PL_no_mem, strlen(PL_no_mem));
70 /* paranoid version of system's malloc() */
73 Perl_safesysmalloc(MEM_SIZE size)
79 PerlIO_printf(Perl_error_log,
80 "Allocation too large: %lx\n", size) FLUSH;
83 #endif /* HAS_64K_LIMIT */
84 #ifdef PERL_TRACK_MEMPOOL
89 Perl_croak_nocontext("panic: malloc");
91 ptr = (Malloc_t)PerlMem_malloc(size?size:1); /* malloc(0) is NASTY on our system */
92 PERL_ALLOC_CHECK(ptr);
93 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) malloc %ld bytes\n",PTR2UV(ptr),(long)PL_an++,(long)size));
95 #ifdef PERL_TRACK_MEMPOOL
97 ptr = (Malloc_t)((char*)ptr+sTHX);
104 return S_write_no_mem(aTHX);
109 /* paranoid version of system's realloc() */
112 Perl_safesysrealloc(Malloc_t where,MEM_SIZE size)
116 #if !defined(STANDARD_C) && !defined(HAS_REALLOC_PROTOTYPE) && !defined(PERL_MICRO)
117 Malloc_t PerlMem_realloc();
118 #endif /* !defined(STANDARD_C) && !defined(HAS_REALLOC_PROTOTYPE) */
122 PerlIO_printf(Perl_error_log,
123 "Reallocation too large: %lx\n", size) FLUSH;
126 #endif /* HAS_64K_LIMIT */
133 return safesysmalloc(size);
134 #ifdef PERL_TRACK_MEMPOOL
135 where = (Malloc_t)((char*)where-sTHX);
137 if (*(tTHX*)where != aTHX) {
138 /* int *nowhere = NULL; *nowhere = 0; */
139 Perl_croak_nocontext("panic: realloc from wrong pool");
144 Perl_croak_nocontext("panic: realloc");
146 ptr = (Malloc_t)PerlMem_realloc(where,size);
147 PERL_ALLOC_CHECK(ptr);
149 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) rfree\n",PTR2UV(where),(long)PL_an++));
150 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) realloc %ld bytes\n",PTR2UV(ptr),(long)PL_an++,(long)size));
153 #ifdef PERL_TRACK_MEMPOOL
154 ptr = (Malloc_t)((char*)ptr+sTHX);
161 return S_write_no_mem(aTHX);
166 /* safe version of system's free() */
169 Perl_safesysfree(Malloc_t where)
172 #if defined(PERL_IMPLICIT_SYS) || defined(PERL_TRACK_MEMPOOL)
175 DEBUG_m( PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) free\n",PTR2UV(where),(long)PL_an++));
177 #ifdef PERL_TRACK_MEMPOOL
178 where = (Malloc_t)((char*)where-sTHX);
179 if (*(tTHX*)where != aTHX) {
180 /* int *nowhere = NULL; *nowhere = 0; */
181 Perl_croak_nocontext("panic: free from wrong pool");
188 /* safe version of system's calloc() */
191 Perl_safesyscalloc(MEM_SIZE count, MEM_SIZE size)
197 if (size * count > 0xffff) {
198 PerlIO_printf(Perl_error_log,
199 "Allocation too large: %lx\n", size * count) FLUSH;
202 #endif /* HAS_64K_LIMIT */
204 if ((long)size < 0 || (long)count < 0)
205 Perl_croak_nocontext("panic: calloc");
208 #ifdef PERL_TRACK_MEMPOOL
211 ptr = (Malloc_t)PerlMem_malloc(size?size:1); /* malloc(0) is NASTY on our system */
212 PERL_ALLOC_CHECK(ptr);
213 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));
215 memset((void*)ptr, 0, size);
216 #ifdef PERL_TRACK_MEMPOOL
218 ptr = (Malloc_t)((char*)ptr+sTHX);
225 return S_write_no_mem(aTHX);
230 /* These must be defined when not using Perl's malloc for binary
235 Malloc_t Perl_malloc (MEM_SIZE nbytes)
238 return (Malloc_t)PerlMem_malloc(nbytes);
241 Malloc_t Perl_calloc (MEM_SIZE elements, MEM_SIZE size)
244 return (Malloc_t)PerlMem_calloc(elements, size);
247 Malloc_t Perl_realloc (Malloc_t where, MEM_SIZE nbytes)
250 return (Malloc_t)PerlMem_realloc(where, nbytes);
253 Free_t Perl_mfree (Malloc_t where)
261 /* copy a string up to some (non-backslashed) delimiter, if any */
264 Perl_delimcpy(pTHX_ register char *to, register const char *toend, register const char *from, register const char *fromend, register int delim, I32 *retlen)
267 for (tolen = 0; from < fromend; from++, tolen++) {
269 if (from[1] == delim)
278 else if (*from == delim)
289 /* return ptr to little string in big string, NULL if not found */
290 /* This routine was donated by Corey Satten. */
293 Perl_instr(pTHX_ register const char *big, register const char *little)
303 register const char *s, *x;
306 for (x=big,s=little; *s; /**/ ) {
315 return (char*)(big-1);
320 /* same as instr but allow embedded nulls */
323 Perl_ninstr(pTHX_ register const char *big, register const char *bigend, const char *little, const char *lend)
325 register const I32 first = *little;
326 register const char * const littleend = lend;
328 if (!first && little >= littleend)
330 if (bigend - big < littleend - little)
332 bigend -= littleend - little++;
333 while (big <= bigend) {
334 register const char *s, *x;
337 for (x=big,s=little; s < littleend; /**/ ) {
344 return (char*)(big-1);
349 /* reverse of the above--find last substring */
352 Perl_rninstr(pTHX_ register const char *big, const char *bigend, const char *little, const char *lend)
354 register const char *bigbeg;
355 register const I32 first = *little;
356 register const char * const littleend = lend;
358 if (!first && little >= littleend)
359 return (char*)bigend;
361 big = bigend - (littleend - little++);
362 while (big >= bigbeg) {
363 register const char *s, *x;
366 for (x=big+2,s=little; s < littleend; /**/ ) {
373 return (char*)(big+1);
378 #define FBM_TABLE_OFFSET 2 /* Number of bytes between EOS and table*/
380 /* As a space optimization, we do not compile tables for strings of length
381 0 and 1, and for strings of length 2 unless FBMcf_TAIL. These are
382 special-cased in fbm_instr().
384 If FBMcf_TAIL, the table is created as if the string has a trailing \n. */
387 =head1 Miscellaneous Functions
389 =for apidoc fbm_compile
391 Analyses the string in order to make fast searches on it using fbm_instr()
392 -- the Boyer-Moore algorithm.
398 Perl_fbm_compile(pTHX_ SV *sv, U32 flags)
400 register const U8 *s;
406 if (flags & FBMcf_TAIL) {
407 MAGIC * const mg = SvUTF8(sv) && SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_utf8) : NULL;
408 sv_catpvn(sv, "\n", 1); /* Taken into account in fbm_instr() */
409 if (mg && mg->mg_len >= 0)
412 s = (U8*)SvPV_force_mutable(sv, len);
413 SvUPGRADE(sv, SVt_PVBM);
414 if (len == 0) /* TAIL might be on a zero-length string. */
417 const unsigned char *sb;
418 const U8 mlen = (len>255) ? 255 : (U8)len;
421 Sv_Grow(sv, len + 256 + FBM_TABLE_OFFSET);
422 table = (unsigned char*)(SvPVX_mutable(sv) + len + FBM_TABLE_OFFSET);
423 s = table - 1 - FBM_TABLE_OFFSET; /* last char */
424 memset((void*)table, mlen, 256);
425 table[-1] = (U8)flags;
427 sb = s - mlen + 1; /* first char (maybe) */
429 if (table[*s] == mlen)
434 sv_magic(sv, Nullsv, PERL_MAGIC_bm, Nullch, 0); /* deep magic */
437 s = (const unsigned char*)(SvPVX_const(sv)); /* deeper magic */
438 for (i = 0; i < len; i++) {
439 if (PL_freq[s[i]] < frequency) {
441 frequency = PL_freq[s[i]];
444 BmRARE(sv) = s[rarest];
445 BmPREVIOUS(sv) = (U16)rarest;
446 BmUSEFUL(sv) = 100; /* Initial value */
447 if (flags & FBMcf_TAIL)
449 DEBUG_r(PerlIO_printf(Perl_debug_log, "rarest char %c at %d\n",
450 BmRARE(sv),BmPREVIOUS(sv)));
453 /* If SvTAIL(littlestr), it has a fake '\n' at end. */
454 /* If SvTAIL is actually due to \Z or \z, this gives false positives
458 =for apidoc fbm_instr
460 Returns the location of the SV in the string delimited by C<str> and
461 C<strend>. It returns C<Nullch> if the string can't be found. The C<sv>
462 does not have to be fbm_compiled, but the search will not be as fast
469 Perl_fbm_instr(pTHX_ unsigned char *big, register unsigned char *bigend, SV *littlestr, U32 flags)
471 register unsigned char *s;
473 register const unsigned char *little
474 = (const unsigned char *)SvPV_const(littlestr,l);
475 register STRLEN littlelen = l;
476 register const I32 multiline = flags & FBMrf_MULTILINE;
478 if ((STRLEN)(bigend - big) < littlelen) {
479 if ( SvTAIL(littlestr)
480 && ((STRLEN)(bigend - big) == littlelen - 1)
482 || (*big == *little &&
483 memEQ((char *)big, (char *)little, littlelen - 1))))
488 if (littlelen <= 2) { /* Special-cased */
490 if (littlelen == 1) {
491 if (SvTAIL(littlestr) && !multiline) { /* Anchor only! */
492 /* Know that bigend != big. */
493 if (bigend[-1] == '\n')
494 return (char *)(bigend - 1);
495 return (char *) bigend;
503 if (SvTAIL(littlestr))
504 return (char *) bigend;
508 return (char*)big; /* Cannot be SvTAIL! */
511 if (SvTAIL(littlestr) && !multiline) {
512 if (bigend[-1] == '\n' && bigend[-2] == *little)
513 return (char*)bigend - 2;
514 if (bigend[-1] == *little)
515 return (char*)bigend - 1;
519 /* This should be better than FBM if c1 == c2, and almost
520 as good otherwise: maybe better since we do less indirection.
521 And we save a lot of memory by caching no table. */
522 const unsigned char c1 = little[0];
523 const unsigned char c2 = little[1];
528 while (s <= bigend) {
538 goto check_1char_anchor;
549 goto check_1char_anchor;
552 while (s <= bigend) {
557 goto check_1char_anchor;
566 check_1char_anchor: /* One char and anchor! */
567 if (SvTAIL(littlestr) && (*bigend == *little))
568 return (char *)bigend; /* bigend is already decremented. */
571 if (SvTAIL(littlestr) && !multiline) { /* tail anchored? */
572 s = bigend - littlelen;
573 if (s >= big && bigend[-1] == '\n' && *s == *little
574 /* Automatically of length > 2 */
575 && memEQ((char*)s + 1, (char*)little + 1, littlelen - 2))
577 return (char*)s; /* how sweet it is */
580 && memEQ((char*)s + 2, (char*)little + 1, littlelen - 2))
582 return (char*)s + 1; /* how sweet it is */
586 if (SvTYPE(littlestr) != SVt_PVBM || !SvVALID(littlestr)) {
587 char * const b = ninstr((char*)big,(char*)bigend,
588 (char*)little, (char*)little + littlelen);
590 if (!b && SvTAIL(littlestr)) { /* Automatically multiline! */
591 /* Chop \n from littlestr: */
592 s = bigend - littlelen + 1;
594 && memEQ((char*)s + 1, (char*)little + 1, littlelen - 2))
603 { /* Do actual FBM. */
604 register const unsigned char * const table = little + littlelen + FBM_TABLE_OFFSET;
605 register const unsigned char *oldlittle;
607 if (littlelen > (STRLEN)(bigend - big))
609 --littlelen; /* Last char found by table lookup */
612 little += littlelen; /* last char */
618 if ((tmp = table[*s])) {
619 if ((s += tmp) < bigend)
623 else { /* less expensive than calling strncmp() */
624 register unsigned char * const olds = s;
629 if (*--s == *--little)
631 s = olds + 1; /* here we pay the price for failure */
633 if (s < bigend) /* fake up continue to outer loop */
641 if ( s == bigend && (table[-1] & FBMcf_TAIL)
642 && memEQ((char *)(bigend - littlelen),
643 (char *)(oldlittle - littlelen), littlelen) )
644 return (char*)bigend - littlelen;
649 /* start_shift, end_shift are positive quantities which give offsets
650 of ends of some substring of bigstr.
651 If "last" we want the last occurrence.
652 old_posp is the way of communication between consequent calls if
653 the next call needs to find the .
654 The initial *old_posp should be -1.
656 Note that we take into account SvTAIL, so one can get extra
657 optimizations if _ALL flag is set.
660 /* If SvTAIL is actually due to \Z or \z, this gives false positives
661 if PL_multiline. In fact if !PL_multiline the authoritative answer
662 is not supported yet. */
665 Perl_screaminstr(pTHX_ SV *bigstr, SV *littlestr, I32 start_shift, I32 end_shift, I32 *old_posp, I32 last)
667 register const unsigned char *big;
669 register I32 previous;
671 register const unsigned char *little;
672 register I32 stop_pos;
673 register const unsigned char *littleend;
677 ? (pos = PL_screamfirst[BmRARE(littlestr)]) < 0
678 : (((pos = *old_posp), pos += PL_screamnext[pos]) == 0)) {
680 if ( BmRARE(littlestr) == '\n'
681 && BmPREVIOUS(littlestr) == SvCUR(littlestr) - 1) {
682 little = (const unsigned char *)(SvPVX_const(littlestr));
683 littleend = little + SvCUR(littlestr);
690 little = (const unsigned char *)(SvPVX_const(littlestr));
691 littleend = little + SvCUR(littlestr);
693 /* The value of pos we can start at: */
694 previous = BmPREVIOUS(littlestr);
695 big = (const unsigned char *)(SvPVX_const(bigstr));
696 /* The value of pos we can stop at: */
697 stop_pos = SvCUR(bigstr) - end_shift - (SvCUR(littlestr) - 1 - previous);
698 if (previous + start_shift > stop_pos) {
700 stop_pos does not include SvTAIL in the count, so this check is incorrect
701 (I think) - see [ID 20010618.006] and t/op/study.t. HVDS 2001/06/19
704 if (previous + start_shift == stop_pos + 1) /* A fake '\n'? */
709 while (pos < previous + start_shift) {
710 if (!(pos += PL_screamnext[pos]))
715 register const unsigned char *s, *x;
716 if (pos >= stop_pos) break;
717 if (big[pos] != first)
719 for (x=big+pos+1,s=little; s < littleend; /**/ ) {
725 if (s == littleend) {
727 if (!last) return (char *)(big+pos);
730 } while ( pos += PL_screamnext[pos] );
732 return (char *)(big+(*old_posp));
734 if (!SvTAIL(littlestr) || (end_shift > 0))
736 /* Ignore the trailing "\n". This code is not microoptimized */
737 big = (const unsigned char *)(SvPVX_const(bigstr) + SvCUR(bigstr));
738 stop_pos = littleend - little; /* Actual littlestr len */
743 && ((stop_pos == 1) ||
744 memEQ((char *)(big + 1), (char *)little, stop_pos - 1)))
750 Perl_ibcmp(pTHX_ const char *s1, const char *s2, register I32 len)
752 register const U8 *a = (const U8 *)s1;
753 register const U8 *b = (const U8 *)s2;
755 if (*a != *b && *a != PL_fold[*b])
763 Perl_ibcmp_locale(pTHX_ const char *s1, const char *s2, register I32 len)
766 register const U8 *a = (const U8 *)s1;
767 register const U8 *b = (const U8 *)s2;
769 if (*a != *b && *a != PL_fold_locale[*b])
776 /* copy a string to a safe spot */
779 =head1 Memory Management
783 Perl's version of C<strdup()>. Returns a pointer to a newly allocated
784 string which is a duplicate of C<pv>. The size of the string is
785 determined by C<strlen()>. The memory allocated for the new string can
786 be freed with the C<Safefree()> function.
792 Perl_savepv(pTHX_ const char *pv)
798 const STRLEN pvlen = strlen(pv)+1;
799 Newx(newaddr,pvlen,char);
800 return memcpy(newaddr,pv,pvlen);
805 /* same thing but with a known length */
810 Perl's version of what C<strndup()> would be if it existed. Returns a
811 pointer to a newly allocated string which is a duplicate of the first
812 C<len> bytes from C<pv>. The memory allocated for the new string can be
813 freed with the C<Safefree()> function.
819 Perl_savepvn(pTHX_ const char *pv, register I32 len)
821 register char *newaddr;
823 Newx(newaddr,len+1,char);
824 /* Give a meaning to NULL pointer mainly for the use in sv_magic() */
826 /* might not be null terminated */
828 return (char *) CopyD(pv,newaddr,len,char);
831 return (char *) ZeroD(newaddr,len+1,char);
836 =for apidoc savesharedpv
838 A version of C<savepv()> which allocates the duplicate string in memory
839 which is shared between threads.
844 Perl_savesharedpv(pTHX_ const char *pv)
846 register char *newaddr;
851 pvlen = strlen(pv)+1;
852 newaddr = (char*)PerlMemShared_malloc(pvlen);
854 return S_write_no_mem(aTHX);
856 return memcpy(newaddr,pv,pvlen);
862 A version of C<savepv()>/C<savepvn()> which gets the string to duplicate from
863 the passed in SV using C<SvPV()>
869 Perl_savesvpv(pTHX_ SV *sv)
872 const char * const pv = SvPV_const(sv, len);
873 register char *newaddr;
876 Newx(newaddr,len,char);
877 return (char *) CopyD(pv,newaddr,len,char);
881 /* the SV for Perl_form() and mess() is not kept in an arena */
890 return sv_2mortal(newSVpvn("",0));
895 /* Create as PVMG now, to avoid any upgrading later */
897 Newxz(any, 1, XPVMG);
898 SvFLAGS(sv) = SVt_PVMG;
899 SvANY(sv) = (void*)any;
901 SvREFCNT(sv) = 1 << 30; /* practically infinite */
906 #if defined(PERL_IMPLICIT_CONTEXT)
908 Perl_form_nocontext(const char* pat, ...)
914 retval = vform(pat, &args);
918 #endif /* PERL_IMPLICIT_CONTEXT */
921 =head1 Miscellaneous Functions
924 Takes a sprintf-style format pattern and conventional
925 (non-SV) arguments and returns the formatted string.
927 (char *) Perl_form(pTHX_ const char* pat, ...)
929 can be used any place a string (char *) is required:
931 char * s = Perl_form("%d.%d",major,minor);
933 Uses a single private buffer so if you want to format several strings you
934 must explicitly copy the earlier strings away (and free the copies when you
941 Perl_form(pTHX_ const char* pat, ...)
946 retval = vform(pat, &args);
952 Perl_vform(pTHX_ const char *pat, va_list *args)
954 SV * const sv = mess_alloc();
955 sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
959 #if defined(PERL_IMPLICIT_CONTEXT)
961 Perl_mess_nocontext(const char *pat, ...)
967 retval = vmess(pat, &args);
971 #endif /* PERL_IMPLICIT_CONTEXT */
974 Perl_mess(pTHX_ const char *pat, ...)
979 retval = vmess(pat, &args);
985 S_closest_cop(pTHX_ COP *cop, const OP *o)
987 /* Look for PL_op starting from o. cop is the last COP we've seen. */
989 if (!o || o == PL_op) return cop;
991 if (o->op_flags & OPf_KIDS) {
993 for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling)
997 /* If the OP_NEXTSTATE has been optimised away we can still use it
998 * the get the file and line number. */
1000 if (kid->op_type == OP_NULL && kid->op_targ == OP_NEXTSTATE)
1003 /* Keep searching, and return when we've found something. */
1005 new_cop = closest_cop(cop, kid);
1006 if (new_cop) return new_cop;
1010 /* Nothing found. */
1016 Perl_vmess(pTHX_ const char *pat, va_list *args)
1018 SV * const sv = mess_alloc();
1019 static const char dgd[] = " during global destruction.\n";
1021 sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
1022 if (!SvCUR(sv) || *(SvEND(sv) - 1) != '\n') {
1025 * Try and find the file and line for PL_op. This will usually be
1026 * PL_curcop, but it might be a cop that has been optimised away. We
1027 * can try to find such a cop by searching through the optree starting
1028 * from the sibling of PL_curcop.
1031 const COP *cop = closest_cop(PL_curcop, PL_curcop->op_sibling);
1032 if (!cop) cop = PL_curcop;
1035 Perl_sv_catpvf(aTHX_ sv, " at %s line %"IVdf,
1036 OutCopFILE(cop), (IV)CopLINE(cop));
1037 if (GvIO(PL_last_in_gv) && IoLINES(GvIOp(PL_last_in_gv))) {
1038 const bool line_mode = (RsSIMPLE(PL_rs) &&
1039 SvCUR(PL_rs) == 1 && *SvPVX_const(PL_rs) == '\n');
1040 Perl_sv_catpvf(aTHX_ sv, ", <%s> %s %"IVdf,
1041 PL_last_in_gv == PL_argvgv ?
1042 "" : GvNAME(PL_last_in_gv),
1043 line_mode ? "line" : "chunk",
1044 (IV)IoLINES(GvIOp(PL_last_in_gv)));
1046 sv_catpv(sv, PL_dirty ? dgd : ".\n");
1052 Perl_write_to_stderr(pTHX_ const char* message, int msglen)
1058 if (PL_stderrgv && SvREFCNT(PL_stderrgv)
1059 && (io = GvIO(PL_stderrgv))
1060 && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar)))
1067 SAVESPTR(PL_stderrgv);
1068 PL_stderrgv = Nullgv;
1070 PUSHSTACKi(PERLSI_MAGIC);
1074 PUSHs(SvTIED_obj((SV*)io, mg));
1075 PUSHs(sv_2mortal(newSVpvn(message, msglen)));
1077 call_method("PRINT", G_SCALAR);
1085 /* SFIO can really mess with your errno */
1086 const int e = errno;
1088 PerlIO * const serr = Perl_error_log;
1090 PERL_WRITE_MSG_TO_CONSOLE(serr, message, msglen);
1091 (void)PerlIO_flush(serr);
1098 /* Common code used by vcroak, vdie and vwarner */
1101 S_vdie_common(pTHX_ const char *message, STRLEN msglen, I32 utf8)
1106 /* sv_2cv might call Perl_croak() */
1107 SV * const olddiehook = PL_diehook;
1111 SAVESPTR(PL_diehook);
1112 PL_diehook = Nullsv;
1113 cv = sv_2cv(olddiehook, &stash, &gv, 0);
1115 if (cv && !CvDEPTH(cv) && (CvROOT(cv) || CvXSUB(cv))) {
1122 msg = newSVpvn(message, msglen);
1123 SvFLAGS(msg) |= utf8;
1131 PUSHSTACKi(PERLSI_DIEHOOK);
1135 call_sv((SV*)cv, G_DISCARD);
1142 S_vdie_croak_common(pTHX_ const char* pat, va_list* args, STRLEN* msglen,
1146 const char *message;
1149 SV * const msv = vmess(pat, args);
1150 if (PL_errors && SvCUR(PL_errors)) {
1151 sv_catsv(PL_errors, msv);
1152 message = SvPV_const(PL_errors, *msglen);
1153 SvCUR_set(PL_errors, 0);
1156 message = SvPV_const(msv,*msglen);
1157 *utf8 = SvUTF8(msv);
1163 DEBUG_S(PerlIO_printf(Perl_debug_log,
1164 "%p: die/croak: message = %s\ndiehook = %p\n",
1165 thr, message, PL_diehook));
1167 S_vdie_common(aTHX_ message, *msglen, *utf8);
1173 Perl_vdie(pTHX_ const char* pat, va_list *args)
1175 const char *message;
1176 const int was_in_eval = PL_in_eval;
1180 DEBUG_S(PerlIO_printf(Perl_debug_log,
1181 "%p: die: curstack = %p, mainstack = %p\n",
1182 thr, PL_curstack, PL_mainstack));
1184 message = vdie_croak_common(pat, args, &msglen, &utf8);
1186 PL_restartop = die_where(message, msglen);
1187 SvFLAGS(ERRSV) |= utf8;
1188 DEBUG_S(PerlIO_printf(Perl_debug_log,
1189 "%p: die: restartop = %p, was_in_eval = %d, top_env = %p\n",
1190 thr, PL_restartop, was_in_eval, PL_top_env));
1191 if ((!PL_restartop && was_in_eval) || PL_top_env->je_prev)
1193 return PL_restartop;
1196 #if defined(PERL_IMPLICIT_CONTEXT)
1198 Perl_die_nocontext(const char* pat, ...)
1203 va_start(args, pat);
1204 o = vdie(pat, &args);
1208 #endif /* PERL_IMPLICIT_CONTEXT */
1211 Perl_die(pTHX_ const char* pat, ...)
1215 va_start(args, pat);
1216 o = vdie(pat, &args);
1222 Perl_vcroak(pTHX_ const char* pat, va_list *args)
1224 const char *message;
1228 message = S_vdie_croak_common(aTHX_ pat, args, &msglen, &utf8);
1231 PL_restartop = die_where(message, msglen);
1232 SvFLAGS(ERRSV) |= utf8;
1236 message = SvPVx_const(ERRSV, msglen);
1238 write_to_stderr(message, msglen);
1242 #if defined(PERL_IMPLICIT_CONTEXT)
1244 Perl_croak_nocontext(const char *pat, ...)
1248 va_start(args, pat);
1253 #endif /* PERL_IMPLICIT_CONTEXT */
1256 =head1 Warning and Dieing
1260 This is the XSUB-writer's interface to Perl's C<die> function.
1261 Normally call this function the same way you call the C C<printf>
1262 function. Calling C<croak> returns control directly to Perl,
1263 sidestepping the normal C order of execution. See C<warn>.
1265 If you want to throw an exception object, assign the object to
1266 C<$@> and then pass C<Nullch> to croak():
1268 errsv = get_sv("@", TRUE);
1269 sv_setsv(errsv, exception_object);
1276 Perl_croak(pTHX_ const char *pat, ...)
1279 va_start(args, pat);
1286 Perl_vwarn(pTHX_ const char* pat, va_list *args)
1290 SV * const msv = vmess(pat, args);
1291 const I32 utf8 = SvUTF8(msv);
1292 const char * const message = SvPV_const(msv, msglen);
1295 /* sv_2cv might call Perl_warn() */
1296 SV * const oldwarnhook = PL_warnhook;
1302 SAVESPTR(PL_warnhook);
1303 PL_warnhook = Nullsv;
1304 cv = sv_2cv(oldwarnhook, &stash, &gv, 0);
1306 if (cv && !CvDEPTH(cv) && (CvROOT(cv) || CvXSUB(cv))) {
1311 SAVESPTR(PL_warnhook);
1312 PL_warnhook = Nullsv;
1314 msg = newSVpvn(message, msglen);
1315 SvFLAGS(msg) |= utf8;
1319 PUSHSTACKi(PERLSI_WARNHOOK);
1323 call_sv((SV*)cv, G_DISCARD);
1330 write_to_stderr(message, msglen);
1333 #if defined(PERL_IMPLICIT_CONTEXT)
1335 Perl_warn_nocontext(const char *pat, ...)
1339 va_start(args, pat);
1343 #endif /* PERL_IMPLICIT_CONTEXT */
1348 This is the XSUB-writer's interface to Perl's C<warn> function. Call this
1349 function the same way you call the C C<printf> function. See C<croak>.
1355 Perl_warn(pTHX_ const char *pat, ...)
1358 va_start(args, pat);
1363 #if defined(PERL_IMPLICIT_CONTEXT)
1365 Perl_warner_nocontext(U32 err, const char *pat, ...)
1369 va_start(args, pat);
1370 vwarner(err, pat, &args);
1373 #endif /* PERL_IMPLICIT_CONTEXT */
1376 Perl_warner(pTHX_ U32 err, const char* pat,...)
1379 va_start(args, pat);
1380 vwarner(err, pat, &args);
1385 Perl_vwarner(pTHX_ U32 err, const char* pat, va_list* args)
1389 SV * const msv = vmess(pat, args);
1391 const char * const message = SvPV_const(msv, msglen);
1392 const I32 utf8 = SvUTF8(msv);
1396 S_vdie_common(aTHX_ message, msglen, utf8);
1399 PL_restartop = die_where(message, msglen);
1400 SvFLAGS(ERRSV) |= utf8;
1403 write_to_stderr(message, msglen);
1407 Perl_vwarn(aTHX_ pat, args);
1411 /* implements the ckWARN? macros */
1414 Perl_ckwarn(pTHX_ U32 w)
1419 && PL_curcop->cop_warnings != pWARN_NONE
1421 PL_curcop->cop_warnings == pWARN_ALL
1422 || isWARN_on(PL_curcop->cop_warnings, unpackWARN1(w))
1423 || (unpackWARN2(w) &&
1424 isWARN_on(PL_curcop->cop_warnings, unpackWARN2(w)))
1425 || (unpackWARN3(w) &&
1426 isWARN_on(PL_curcop->cop_warnings, unpackWARN3(w)))
1427 || (unpackWARN4(w) &&
1428 isWARN_on(PL_curcop->cop_warnings, unpackWARN4(w)))
1433 isLEXWARN_off && PL_dowarn & G_WARN_ON
1438 /* implements the ckWARN?_d macro */
1441 Perl_ckwarn_d(pTHX_ U32 w)
1445 || PL_curcop->cop_warnings == pWARN_ALL
1447 PL_curcop->cop_warnings != pWARN_NONE
1449 isWARN_on(PL_curcop->cop_warnings, unpackWARN1(w))
1450 || (unpackWARN2(w) &&
1451 isWARN_on(PL_curcop->cop_warnings, unpackWARN2(w)))
1452 || (unpackWARN3(w) &&
1453 isWARN_on(PL_curcop->cop_warnings, unpackWARN3(w)))
1454 || (unpackWARN4(w) &&
1455 isWARN_on(PL_curcop->cop_warnings, unpackWARN4(w)))
1463 /* since we've already done strlen() for both nam and val
1464 * we can use that info to make things faster than
1465 * sprintf(s, "%s=%s", nam, val)
1467 #define my_setenv_format(s, nam, nlen, val, vlen) \
1468 Copy(nam, s, nlen, char); \
1470 Copy(val, s+(nlen+1), vlen, char); \
1471 *(s+(nlen+1+vlen)) = '\0'
1473 #ifdef USE_ENVIRON_ARRAY
1474 /* VMS' my_setenv() is in vms.c */
1475 #if !defined(WIN32) && !defined(NETWARE)
1477 Perl_my_setenv(pTHX_ const char *nam, const char *val)
1481 /* only parent thread can modify process environment */
1482 if (PL_curinterp == aTHX)
1485 #ifndef PERL_USE_SAFE_PUTENV
1486 if (!PL_use_safe_putenv) {
1487 /* most putenv()s leak, so we manipulate environ directly */
1488 register I32 i=setenv_getix(nam); /* where does it go? */
1491 if (environ == PL_origenviron) { /* need we copy environment? */
1496 for (max = i; environ[max]; max++) ;
1497 tmpenv = (char**)safesysmalloc((max+2) * sizeof(char*));
1498 for (j=0; j<max; j++) { /* copy environment */
1499 const int len = strlen(environ[j]);
1500 tmpenv[j] = (char*)safesysmalloc((len+1)*sizeof(char));
1501 Copy(environ[j], tmpenv[j], len+1, char);
1503 tmpenv[max] = Nullch;
1504 environ = tmpenv; /* tell exec where it is now */
1507 safesysfree(environ[i]);
1508 while (environ[i]) {
1509 environ[i] = environ[i+1];
1514 if (!environ[i]) { /* does not exist yet */
1515 environ = (char**)safesysrealloc(environ, (i+2) * sizeof(char*));
1516 environ[i+1] = Nullch; /* make sure it's null terminated */
1519 safesysfree(environ[i]);
1523 environ[i] = (char*)safesysmalloc((nlen+vlen+2) * sizeof(char));
1524 /* all that work just for this */
1525 my_setenv_format(environ[i], nam, nlen, val, vlen);
1528 # if defined(__CYGWIN__) || defined(EPOC) || defined(__SYMBIAN32__)
1529 # if defined(HAS_UNSETENV)
1531 (void)unsetenv(nam);
1533 (void)setenv(nam, val, 1);
1535 # else /* ! HAS_UNSETENV */
1536 (void)setenv(nam, val, 1);
1537 # endif /* HAS_UNSETENV */
1539 # if defined(HAS_UNSETENV)
1541 (void)unsetenv(nam);
1543 const int nlen = strlen(nam);
1544 const int vlen = strlen(val);
1545 char * const new_env =
1546 (char*)safesysmalloc((nlen + vlen + 2) * sizeof(char));
1547 my_setenv_format(new_env, nam, nlen, val, vlen);
1548 (void)putenv(new_env);
1550 # else /* ! HAS_UNSETENV */
1552 const int nlen = strlen(nam);
1558 new_env = (char*)safesysmalloc((nlen + vlen + 2) * sizeof(char));
1559 /* all that work just for this */
1560 my_setenv_format(new_env, nam, nlen, val, vlen);
1561 (void)putenv(new_env);
1562 # endif /* HAS_UNSETENV */
1563 # endif /* __CYGWIN__ */
1564 #ifndef PERL_USE_SAFE_PUTENV
1570 #else /* WIN32 || NETWARE */
1573 Perl_my_setenv(pTHX_ const char *nam, const char *val)
1576 register char *envstr;
1577 const int nlen = strlen(nam);
1584 Newx(envstr, nlen+vlen+2, char);
1585 my_setenv_format(envstr, nam, nlen, val, vlen);
1586 (void)PerlEnv_putenv(envstr);
1590 #endif /* WIN32 || NETWARE */
1594 Perl_setenv_getix(pTHX_ const char *nam)
1597 register const I32 len = strlen(nam);
1599 for (i = 0; environ[i]; i++) {
1602 strnicmp(environ[i],nam,len) == 0
1604 strnEQ(environ[i],nam,len)
1606 && environ[i][len] == '=')
1607 break; /* strnEQ must come first to avoid */
1608 } /* potential SEGV's */
1611 #endif /* !PERL_MICRO */
1613 #endif /* !VMS && !EPOC*/
1615 #ifdef UNLINK_ALL_VERSIONS
1617 Perl_unlnk(pTHX_ const char *f) /* unlink all versions of a file */
1621 for (i = 0; PerlLIO_unlink(f) >= 0; i++) ;
1626 /* this is a drop-in replacement for bcopy() */
1627 #if (!defined(HAS_MEMCPY) && !defined(HAS_BCOPY)) || (!defined(HAS_MEMMOVE) && !defined(HAS_SAFE_MEMCPY) && !defined(HAS_SAFE_BCOPY))
1629 Perl_my_bcopy(register const char *from,register char *to,register I32 len)
1631 char * const retval = to;
1633 if (from - to >= 0) {
1641 *(--to) = *(--from);
1647 /* this is a drop-in replacement for memset() */
1650 Perl_my_memset(register char *loc, register I32 ch, register I32 len)
1652 char * const retval = loc;
1660 /* this is a drop-in replacement for bzero() */
1661 #if !defined(HAS_BZERO) && !defined(HAS_MEMSET)
1663 Perl_my_bzero(register char *loc, register I32 len)
1665 char * const retval = loc;
1673 /* this is a drop-in replacement for memcmp() */
1674 #if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP)
1676 Perl_my_memcmp(const char *s1, const char *s2, register I32 len)
1678 register const U8 *a = (const U8 *)s1;
1679 register const U8 *b = (const U8 *)s2;
1683 if ((tmp = *a++ - *b++))
1688 #endif /* !HAS_MEMCMP || !HAS_SANE_MEMCMP */
1692 #ifdef USE_CHAR_VSPRINTF
1697 vsprintf(char *dest, const char *pat, char *args)
1701 fakebuf._ptr = dest;
1702 fakebuf._cnt = 32767;
1706 fakebuf._flag = _IOWRT|_IOSTRG;
1707 _doprnt(pat, args, &fakebuf); /* what a kludge */
1708 (void)putc('\0', &fakebuf);
1709 #ifdef USE_CHAR_VSPRINTF
1712 return 0; /* perl doesn't use return value */
1716 #endif /* HAS_VPRINTF */
1719 #if BYTEORDER != 0x4321
1721 Perl_my_swap(pTHX_ short s)
1723 #if (BYTEORDER & 1) == 0
1726 result = ((s & 255) << 8) + ((s >> 8) & 255);
1734 Perl_my_htonl(pTHX_ long l)
1738 char c[sizeof(long)];
1741 #if BYTEORDER == 0x1234
1742 u.c[0] = (l >> 24) & 255;
1743 u.c[1] = (l >> 16) & 255;
1744 u.c[2] = (l >> 8) & 255;
1748 #if ((BYTEORDER - 0x1111) & 0x444) || !(BYTEORDER & 0xf)
1749 Perl_croak(aTHX_ "Unknown BYTEORDER\n");
1754 for (o = BYTEORDER - 0x1111, s = 0; s < (sizeof(long)*8); o >>= 4, s += 8) {
1755 u.c[o & 0xf] = (l >> s) & 255;
1763 Perl_my_ntohl(pTHX_ long l)
1767 char c[sizeof(long)];
1770 #if BYTEORDER == 0x1234
1771 u.c[0] = (l >> 24) & 255;
1772 u.c[1] = (l >> 16) & 255;
1773 u.c[2] = (l >> 8) & 255;
1777 #if ((BYTEORDER - 0x1111) & 0x444) || !(BYTEORDER & 0xf)
1778 Perl_croak(aTHX_ "Unknown BYTEORDER\n");
1785 for (o = BYTEORDER - 0x1111, s = 0; s < (sizeof(long)*8); o >>= 4, s += 8) {
1786 l |= (u.c[o & 0xf] & 255) << s;
1793 #endif /* BYTEORDER != 0x4321 */
1797 * Little-endian byte order functions - 'v' for 'VAX', or 'reVerse'.
1798 * If these functions are defined,
1799 * the BYTEORDER is neither 0x1234 nor 0x4321.
1800 * However, this is not assumed.
1804 #define HTOLE(name,type) \
1806 name (register type n) \
1810 char c[sizeof(type)]; \
1813 register I32 s = 0; \
1814 for (i = 0; i < sizeof(u.c); i++, s += 8) { \
1815 u.c[i] = (n >> s) & 0xFF; \
1820 #define LETOH(name,type) \
1822 name (register type n) \
1826 char c[sizeof(type)]; \
1829 register I32 s = 0; \
1832 for (i = 0; i < sizeof(u.c); i++, s += 8) { \
1833 n |= ((type)(u.c[i] & 0xFF)) << s; \
1839 * Big-endian byte order functions.
1842 #define HTOBE(name,type) \
1844 name (register type n) \
1848 char c[sizeof(type)]; \
1851 register I32 s = 8*(sizeof(u.c)-1); \
1852 for (i = 0; i < sizeof(u.c); i++, s -= 8) { \
1853 u.c[i] = (n >> s) & 0xFF; \
1858 #define BETOH(name,type) \
1860 name (register type n) \
1864 char c[sizeof(type)]; \
1867 register I32 s = 8*(sizeof(u.c)-1); \
1870 for (i = 0; i < sizeof(u.c); i++, s -= 8) { \
1871 n |= ((type)(u.c[i] & 0xFF)) << s; \
1877 * If we just can't do it...
1880 #define NOT_AVAIL(name,type) \
1882 name (register type n) \
1884 Perl_croak_nocontext(#name "() not available"); \
1885 return n; /* not reached */ \
1889 #if defined(HAS_HTOVS) && !defined(htovs)
1892 #if defined(HAS_HTOVL) && !defined(htovl)
1895 #if defined(HAS_VTOHS) && !defined(vtohs)
1898 #if defined(HAS_VTOHL) && !defined(vtohl)
1902 #ifdef PERL_NEED_MY_HTOLE16
1904 HTOLE(Perl_my_htole16,U16)
1906 NOT_AVAIL(Perl_my_htole16,U16)
1909 #ifdef PERL_NEED_MY_LETOH16
1911 LETOH(Perl_my_letoh16,U16)
1913 NOT_AVAIL(Perl_my_letoh16,U16)
1916 #ifdef PERL_NEED_MY_HTOBE16
1918 HTOBE(Perl_my_htobe16,U16)
1920 NOT_AVAIL(Perl_my_htobe16,U16)
1923 #ifdef PERL_NEED_MY_BETOH16
1925 BETOH(Perl_my_betoh16,U16)
1927 NOT_AVAIL(Perl_my_betoh16,U16)
1931 #ifdef PERL_NEED_MY_HTOLE32
1933 HTOLE(Perl_my_htole32,U32)
1935 NOT_AVAIL(Perl_my_htole32,U32)
1938 #ifdef PERL_NEED_MY_LETOH32
1940 LETOH(Perl_my_letoh32,U32)
1942 NOT_AVAIL(Perl_my_letoh32,U32)
1945 #ifdef PERL_NEED_MY_HTOBE32
1947 HTOBE(Perl_my_htobe32,U32)
1949 NOT_AVAIL(Perl_my_htobe32,U32)
1952 #ifdef PERL_NEED_MY_BETOH32
1954 BETOH(Perl_my_betoh32,U32)
1956 NOT_AVAIL(Perl_my_betoh32,U32)
1960 #ifdef PERL_NEED_MY_HTOLE64
1962 HTOLE(Perl_my_htole64,U64)
1964 NOT_AVAIL(Perl_my_htole64,U64)
1967 #ifdef PERL_NEED_MY_LETOH64
1969 LETOH(Perl_my_letoh64,U64)
1971 NOT_AVAIL(Perl_my_letoh64,U64)
1974 #ifdef PERL_NEED_MY_HTOBE64
1976 HTOBE(Perl_my_htobe64,U64)
1978 NOT_AVAIL(Perl_my_htobe64,U64)
1981 #ifdef PERL_NEED_MY_BETOH64
1983 BETOH(Perl_my_betoh64,U64)
1985 NOT_AVAIL(Perl_my_betoh64,U64)
1989 #ifdef PERL_NEED_MY_HTOLES
1990 HTOLE(Perl_my_htoles,short)
1992 #ifdef PERL_NEED_MY_LETOHS
1993 LETOH(Perl_my_letohs,short)
1995 #ifdef PERL_NEED_MY_HTOBES
1996 HTOBE(Perl_my_htobes,short)
1998 #ifdef PERL_NEED_MY_BETOHS
1999 BETOH(Perl_my_betohs,short)
2002 #ifdef PERL_NEED_MY_HTOLEI
2003 HTOLE(Perl_my_htolei,int)
2005 #ifdef PERL_NEED_MY_LETOHI
2006 LETOH(Perl_my_letohi,int)
2008 #ifdef PERL_NEED_MY_HTOBEI
2009 HTOBE(Perl_my_htobei,int)
2011 #ifdef PERL_NEED_MY_BETOHI
2012 BETOH(Perl_my_betohi,int)
2015 #ifdef PERL_NEED_MY_HTOLEL
2016 HTOLE(Perl_my_htolel,long)
2018 #ifdef PERL_NEED_MY_LETOHL
2019 LETOH(Perl_my_letohl,long)
2021 #ifdef PERL_NEED_MY_HTOBEL
2022 HTOBE(Perl_my_htobel,long)
2024 #ifdef PERL_NEED_MY_BETOHL
2025 BETOH(Perl_my_betohl,long)
2029 Perl_my_swabn(void *ptr, int n)
2031 register char *s = (char *)ptr;
2032 register char *e = s + (n-1);
2035 for (n /= 2; n > 0; s++, e--, n--) {
2043 Perl_my_popen_list(pTHX_ char *mode, int n, SV **args)
2045 #if (!defined(DOSISH) || defined(HAS_FORK) || defined(AMIGAOS)) && !defined(OS2) && !defined(VMS) && !defined(__OPEN_VM) && !defined(EPOC) && !defined(MACOS_TRADITIONAL) && !defined(NETWARE)
2047 register I32 This, that;
2053 PERL_FLUSHALL_FOR_CHILD;
2054 This = (*mode == 'w');
2058 taint_proper("Insecure %s%s", "EXEC");
2060 if (PerlProc_pipe(p) < 0)
2062 /* Try for another pipe pair for error return */
2063 if (PerlProc_pipe(pp) >= 0)
2065 while ((pid = PerlProc_fork()) < 0) {
2066 if (errno != EAGAIN) {
2067 PerlLIO_close(p[This]);
2068 PerlLIO_close(p[that]);
2070 PerlLIO_close(pp[0]);
2071 PerlLIO_close(pp[1]);
2083 /* Close parent's end of error status pipe (if any) */
2085 PerlLIO_close(pp[0]);
2086 #if defined(HAS_FCNTL) && defined(F_SETFD)
2087 /* Close error pipe automatically if exec works */
2088 fcntl(pp[1], F_SETFD, FD_CLOEXEC);
2091 /* Now dup our end of _the_ pipe to right position */
2092 if (p[THIS] != (*mode == 'r')) {
2093 PerlLIO_dup2(p[THIS], *mode == 'r');
2094 PerlLIO_close(p[THIS]);
2095 if (p[THAT] != (*mode == 'r')) /* if dup2() didn't close it */
2096 PerlLIO_close(p[THAT]); /* close parent's end of _the_ pipe */
2099 PerlLIO_close(p[THAT]); /* close parent's end of _the_ pipe */
2100 #if !defined(HAS_FCNTL) || !defined(F_SETFD)
2101 /* No automatic close - do it by hand */
2108 for (fd = PL_maxsysfd + 1; fd < NOFILE; fd++) {
2114 do_aexec5(Nullsv, args-1, args-1+n, pp[1], did_pipes);
2120 do_execfree(); /* free any memory malloced by child on fork */
2122 PerlLIO_close(pp[1]);
2123 /* Keep the lower of the two fd numbers */
2124 if (p[that] < p[This]) {
2125 PerlLIO_dup2(p[This], p[that]);
2126 PerlLIO_close(p[This]);
2130 PerlLIO_close(p[that]); /* close child's end of pipe */
2133 sv = *av_fetch(PL_fdpid,p[This],TRUE);
2135 SvUPGRADE(sv,SVt_IV);
2137 PL_forkprocess = pid;
2138 /* If we managed to get status pipe check for exec fail */
2139 if (did_pipes && pid > 0) {
2143 while (n < sizeof(int)) {
2144 n1 = PerlLIO_read(pp[0],
2145 (void*)(((char*)&errkid)+n),
2151 PerlLIO_close(pp[0]);
2153 if (n) { /* Error */
2155 PerlLIO_close(p[This]);
2156 if (n != sizeof(int))
2157 Perl_croak(aTHX_ "panic: kid popen errno read");
2159 pid2 = wait4pid(pid, &status, 0);
2160 } while (pid2 == -1 && errno == EINTR);
2161 errno = errkid; /* Propagate errno from kid */
2166 PerlLIO_close(pp[0]);
2167 return PerlIO_fdopen(p[This], mode);
2169 Perl_croak(aTHX_ "List form of piped open not implemented");
2170 return (PerlIO *) NULL;
2174 /* VMS' my_popen() is in VMS.c, same with OS/2. */
2175 #if (!defined(DOSISH) || defined(HAS_FORK) || defined(AMIGAOS)) && !defined(VMS) && !defined(__OPEN_VM) && !defined(EPOC) && !defined(MACOS_TRADITIONAL)
2177 Perl_my_popen(pTHX_ const char *cmd, const char *mode)
2180 register I32 This, that;
2183 const I32 doexec = !(*cmd == '-' && cmd[1] == '\0');
2187 PERL_FLUSHALL_FOR_CHILD;
2190 return my_syspopen(aTHX_ cmd,mode);
2193 This = (*mode == 'w');
2195 if (doexec && PL_tainting) {
2197 taint_proper("Insecure %s%s", "EXEC");
2199 if (PerlProc_pipe(p) < 0)
2201 if (doexec && PerlProc_pipe(pp) >= 0)
2203 while ((pid = PerlProc_fork()) < 0) {
2204 if (errno != EAGAIN) {
2205 PerlLIO_close(p[This]);
2206 PerlLIO_close(p[that]);
2208 PerlLIO_close(pp[0]);
2209 PerlLIO_close(pp[1]);
2212 Perl_croak(aTHX_ "Can't fork");
2225 PerlLIO_close(pp[0]);
2226 #if defined(HAS_FCNTL) && defined(F_SETFD)
2227 fcntl(pp[1], F_SETFD, FD_CLOEXEC);
2230 if (p[THIS] != (*mode == 'r')) {
2231 PerlLIO_dup2(p[THIS], *mode == 'r');
2232 PerlLIO_close(p[THIS]);
2233 if (p[THAT] != (*mode == 'r')) /* if dup2() didn't close it */
2234 PerlLIO_close(p[THAT]);
2237 PerlLIO_close(p[THAT]);
2240 #if !defined(HAS_FCNTL) || !defined(F_SETFD)
2247 for (fd = PL_maxsysfd + 1; fd < NOFILE; fd++)
2252 /* may or may not use the shell */
2253 do_exec3(cmd, pp[1], did_pipes);
2256 #endif /* defined OS2 */
2257 if ((tmpgv = gv_fetchpv("$",TRUE, SVt_PV))) {
2258 SvREADONLY_off(GvSV(tmpgv));
2259 sv_setiv(GvSV(tmpgv), PerlProc_getpid());
2260 SvREADONLY_on(GvSV(tmpgv));
2262 #ifdef THREADS_HAVE_PIDS
2263 PL_ppid = (IV)getppid();
2266 #ifdef PERL_USES_PL_PIDSTATUS
2267 hv_clear(PL_pidstatus); /* we have no children */
2273 do_execfree(); /* free any memory malloced by child on vfork */
2275 PerlLIO_close(pp[1]);
2276 if (p[that] < p[This]) {
2277 PerlLIO_dup2(p[This], p[that]);
2278 PerlLIO_close(p[This]);
2282 PerlLIO_close(p[that]);
2285 sv = *av_fetch(PL_fdpid,p[This],TRUE);
2287 SvUPGRADE(sv,SVt_IV);
2289 PL_forkprocess = pid;
2290 if (did_pipes && pid > 0) {
2294 while (n < sizeof(int)) {
2295 n1 = PerlLIO_read(pp[0],
2296 (void*)(((char*)&errkid)+n),
2302 PerlLIO_close(pp[0]);
2304 if (n) { /* Error */
2306 PerlLIO_close(p[This]);
2307 if (n != sizeof(int))
2308 Perl_croak(aTHX_ "panic: kid popen errno read");
2310 pid2 = wait4pid(pid, &status, 0);
2311 } while (pid2 == -1 && errno == EINTR);
2312 errno = errkid; /* Propagate errno from kid */
2317 PerlLIO_close(pp[0]);
2318 return PerlIO_fdopen(p[This], mode);
2321 #if defined(atarist) || defined(EPOC)
2324 Perl_my_popen(pTHX_ char *cmd, char *mode)
2326 PERL_FLUSHALL_FOR_CHILD;
2327 /* Call system's popen() to get a FILE *, then import it.
2328 used 0 for 2nd parameter to PerlIO_importFILE;
2331 return PerlIO_importFILE(popen(cmd, mode), 0);
2335 FILE *djgpp_popen();
2337 Perl_my_popen(pTHX_ char *cmd, char *mode)
2339 PERL_FLUSHALL_FOR_CHILD;
2340 /* Call system's popen() to get a FILE *, then import it.
2341 used 0 for 2nd parameter to PerlIO_importFILE;
2344 return PerlIO_importFILE(djgpp_popen(cmd, mode), 0);
2349 #endif /* !DOSISH */
2351 /* this is called in parent before the fork() */
2353 Perl_atfork_lock(void)
2356 #if defined(USE_ITHREADS)
2357 /* locks must be held in locking order (if any) */
2359 MUTEX_LOCK(&PL_malloc_mutex);
2365 /* this is called in both parent and child after the fork() */
2367 Perl_atfork_unlock(void)
2370 #if defined(USE_ITHREADS)
2371 /* locks must be released in same order as in atfork_lock() */
2373 MUTEX_UNLOCK(&PL_malloc_mutex);
2382 #if defined(HAS_FORK)
2384 #if defined(USE_ITHREADS) && !defined(HAS_PTHREAD_ATFORK)
2389 /* atfork_lock() and atfork_unlock() are installed as pthread_atfork()
2390 * handlers elsewhere in the code */
2395 /* this "canna happen" since nothing should be calling here if !HAS_FORK */
2396 Perl_croak_nocontext("fork() not available");
2398 #endif /* HAS_FORK */
2403 Perl_dump_fds(pTHX_ char *s)
2408 PerlIO_printf(Perl_debug_log,"%s", s);
2409 for (fd = 0; fd < 32; fd++) {
2410 if (PerlLIO_fstat(fd,&tmpstatbuf) >= 0)
2411 PerlIO_printf(Perl_debug_log," %d",fd);
2413 PerlIO_printf(Perl_debug_log,"\n");
2416 #endif /* DUMP_FDS */
2420 dup2(int oldfd, int newfd)
2422 #if defined(HAS_FCNTL) && defined(F_DUPFD)
2425 PerlLIO_close(newfd);
2426 return fcntl(oldfd, F_DUPFD, newfd);
2428 #define DUP2_MAX_FDS 256
2429 int fdtmp[DUP2_MAX_FDS];
2435 PerlLIO_close(newfd);
2436 /* good enough for low fd's... */
2437 while ((fd = PerlLIO_dup(oldfd)) != newfd && fd >= 0) {
2438 if (fdx >= DUP2_MAX_FDS) {
2446 PerlLIO_close(fdtmp[--fdx]);
2453 #ifdef HAS_SIGACTION
2455 #ifdef MACOS_TRADITIONAL
2456 /* We don't want restart behavior on MacOS */
2461 Perl_rsignal(pTHX_ int signo, Sighandler_t handler)
2464 struct sigaction act, oact;
2467 /* only "parent" interpreter can diddle signals */
2468 if (PL_curinterp != aTHX)
2469 return (Sighandler_t) SIG_ERR;
2472 act.sa_handler = (void(*)(int))handler;
2473 sigemptyset(&act.sa_mask);
2476 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
2477 act.sa_flags |= SA_RESTART; /* SVR4, 4.3+BSD */
2479 #if defined(SA_NOCLDWAIT) && !defined(BSDish) /* See [perl #18849] */
2480 if (signo == SIGCHLD && handler == (Sighandler_t) SIG_IGN)
2481 act.sa_flags |= SA_NOCLDWAIT;
2483 if (sigaction(signo, &act, &oact) == -1)
2484 return (Sighandler_t) SIG_ERR;
2486 return (Sighandler_t) oact.sa_handler;
2490 Perl_rsignal_state(pTHX_ int signo)
2492 struct sigaction oact;
2494 if (sigaction(signo, (struct sigaction *)NULL, &oact) == -1)
2495 return (Sighandler_t) SIG_ERR;
2497 return (Sighandler_t) oact.sa_handler;
2501 Perl_rsignal_save(pTHX_ int signo, Sighandler_t handler, Sigsave_t *save)
2504 struct sigaction act;
2507 /* only "parent" interpreter can diddle signals */
2508 if (PL_curinterp != aTHX)
2512 act.sa_handler = (void(*)(int))handler;
2513 sigemptyset(&act.sa_mask);
2516 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
2517 act.sa_flags |= SA_RESTART; /* SVR4, 4.3+BSD */
2519 #if defined(SA_NOCLDWAIT) && !defined(BSDish) /* See [perl #18849] */
2520 if (signo == SIGCHLD && handler == (Sighandler_t) SIG_IGN)
2521 act.sa_flags |= SA_NOCLDWAIT;
2523 return sigaction(signo, &act, save);
2527 Perl_rsignal_restore(pTHX_ int signo, Sigsave_t *save)
2531 /* only "parent" interpreter can diddle signals */
2532 if (PL_curinterp != aTHX)
2536 return sigaction(signo, save, (struct sigaction *)NULL);
2539 #else /* !HAS_SIGACTION */
2542 Perl_rsignal(pTHX_ int signo, Sighandler_t handler)
2544 #if defined(USE_ITHREADS) && !defined(WIN32)
2545 /* only "parent" interpreter can diddle signals */
2546 if (PL_curinterp != aTHX)
2547 return (Sighandler_t) SIG_ERR;
2550 return PerlProc_signal(signo, handler);
2562 Perl_rsignal_state(pTHX_ int signo)
2565 Sighandler_t oldsig;
2567 #if defined(USE_ITHREADS) && !defined(WIN32)
2568 /* only "parent" interpreter can diddle signals */
2569 if (PL_curinterp != aTHX)
2570 return (Sighandler_t) SIG_ERR;
2574 oldsig = PerlProc_signal(signo, sig_trap);
2575 PerlProc_signal(signo, oldsig);
2577 PerlProc_kill(PerlProc_getpid(), signo);
2582 Perl_rsignal_save(pTHX_ int signo, Sighandler_t handler, Sigsave_t *save)
2584 #if defined(USE_ITHREADS) && !defined(WIN32)
2585 /* only "parent" interpreter can diddle signals */
2586 if (PL_curinterp != aTHX)
2589 *save = PerlProc_signal(signo, handler);
2590 return (*save == (Sighandler_t) SIG_ERR) ? -1 : 0;
2594 Perl_rsignal_restore(pTHX_ int signo, Sigsave_t *save)
2596 #if defined(USE_ITHREADS) && !defined(WIN32)
2597 /* only "parent" interpreter can diddle signals */
2598 if (PL_curinterp != aTHX)
2601 return (PerlProc_signal(signo, *save) == (Sighandler_t) SIG_ERR) ? -1 : 0;
2604 #endif /* !HAS_SIGACTION */
2605 #endif /* !PERL_MICRO */
2607 /* VMS' my_pclose() is in VMS.c; same with OS/2 */
2608 #if (!defined(DOSISH) || defined(HAS_FORK) || defined(AMIGAOS)) && !defined(VMS) && !defined(__OPEN_VM) && !defined(EPOC) && !defined(MACOS_TRADITIONAL)
2610 Perl_my_pclose(pTHX_ PerlIO *ptr)
2612 Sigsave_t hstat, istat, qstat;
2618 int saved_errno = 0;
2620 int saved_win32_errno;
2624 svp = av_fetch(PL_fdpid,PerlIO_fileno(ptr),TRUE);
2626 pid = (SvTYPE(*svp) == SVt_IV) ? SvIVX(*svp) : -1;
2628 *svp = &PL_sv_undef;
2630 if (pid == -1) { /* Opened by popen. */
2631 return my_syspclose(ptr);
2634 if ((close_failed = (PerlIO_close(ptr) == EOF))) {
2635 saved_errno = errno;
2637 saved_win32_errno = GetLastError();
2641 if(PerlProc_kill(pid, 0) < 0) { return(pid); } /* HOM 12/23/91 */
2644 rsignal_save(SIGHUP, (Sighandler_t) SIG_IGN, &hstat);
2645 rsignal_save(SIGINT, (Sighandler_t) SIG_IGN, &istat);
2646 rsignal_save(SIGQUIT, (Sighandler_t) SIG_IGN, &qstat);
2649 pid2 = wait4pid(pid, &status, 0);
2650 } while (pid2 == -1 && errno == EINTR);
2652 rsignal_restore(SIGHUP, &hstat);
2653 rsignal_restore(SIGINT, &istat);
2654 rsignal_restore(SIGQUIT, &qstat);
2657 SETERRNO(saved_errno, 0);
2660 return(pid2 < 0 ? pid2 : status == 0 ? 0 : (errno = 0, status));
2662 #endif /* !DOSISH */
2664 #if (!defined(DOSISH) || defined(OS2) || defined(WIN32) || defined(NETWARE)) && !defined(MACOS_TRADITIONAL)
2666 Perl_wait4pid(pTHX_ Pid_t pid, int *statusp, int flags)
2671 #ifdef PERL_USES_PL_PIDSTATUS
2674 /* The keys in PL_pidstatus are now the raw 4 (or 8) bytes of the
2675 pid, rather than a string form. */
2676 SV * const * const svp = hv_fetch(PL_pidstatus,(const char*) &pid,sizeof(Pid_t),FALSE);
2677 if (svp && *svp != &PL_sv_undef) {
2678 *statusp = SvIVX(*svp);
2679 (void)hv_delete(PL_pidstatus,(const char*) &pid,sizeof(Pid_t),
2687 hv_iterinit(PL_pidstatus);
2688 if ((entry = hv_iternext(PL_pidstatus))) {
2689 SV * const sv = hv_iterval(PL_pidstatus,entry);
2691 const char * const spid = hv_iterkey(entry,&len);
2693 assert (len == sizeof(Pid_t));
2694 memcpy((char *)&pid, spid, len);
2695 *statusp = SvIVX(sv);
2696 /* The hash iterator is currently on this entry, so simply
2697 calling hv_delete would trigger the lazy delete, which on
2698 aggregate does more work, beacuse next call to hv_iterinit()
2699 would spot the flag, and have to call the delete routine,
2700 while in the meantime any new entries can't re-use that
2702 hv_iterinit(PL_pidstatus);
2703 (void)hv_delete(PL_pidstatus,spid,len,G_DISCARD);
2710 # ifdef HAS_WAITPID_RUNTIME
2711 if (!HAS_WAITPID_RUNTIME)
2714 result = PerlProc_waitpid(pid,statusp,flags);
2717 #if !defined(HAS_WAITPID) && defined(HAS_WAIT4)
2718 result = wait4((pid==-1)?0:pid,statusp,flags,Null(struct rusage *));
2721 #ifdef PERL_USES_PL_PIDSTATUS
2722 #if defined(HAS_WAITPID) && defined(HAS_WAITPID_RUNTIME)
2727 Perl_croak(aTHX_ "Can't do waitpid with flags");
2729 while ((result = PerlProc_wait(statusp)) != pid && pid > 0 && result >= 0)
2730 pidgone(result,*statusp);
2736 #if defined(HAS_WAITPID) || defined(HAS_WAIT4)
2739 if (result < 0 && errno == EINTR) {
2744 #endif /* !DOSISH || OS2 || WIN32 || NETWARE */
2746 #ifdef PERL_USES_PL_PIDSTATUS
2748 Perl_pidgone(pTHX_ Pid_t pid, int status)
2752 sv = *hv_fetch(PL_pidstatus,(const char*)&pid,sizeof(Pid_t),TRUE);
2753 SvUPGRADE(sv,SVt_IV);
2754 SvIV_set(sv, status);
2759 #if defined(atarist) || defined(OS2) || defined(EPOC)
2762 int /* Cannot prototype with I32
2764 my_syspclose(PerlIO *ptr)
2767 Perl_my_pclose(pTHX_ PerlIO *ptr)
2770 /* Needs work for PerlIO ! */
2771 FILE * const f = PerlIO_findFILE(ptr);
2772 const I32 result = pclose(f);
2773 PerlIO_releaseFILE(ptr,f);
2781 Perl_my_pclose(pTHX_ PerlIO *ptr)
2783 /* Needs work for PerlIO ! */
2784 FILE * const f = PerlIO_findFILE(ptr);
2785 I32 result = djgpp_pclose(f);
2786 result = (result << 8) & 0xff00;
2787 PerlIO_releaseFILE(ptr,f);
2793 Perl_repeatcpy(pTHX_ register char *to, register const char *from, I32 len, register I32 count)
2796 register const char * const frombase = from;
2799 register const char c = *from;
2804 while (count-- > 0) {
2805 for (todo = len; todo > 0; todo--) {
2814 Perl_same_dirent(pTHX_ const char *a, const char *b)
2816 char *fa = strrchr(a,'/');
2817 char *fb = strrchr(b,'/');
2820 SV * const tmpsv = sv_newmortal();
2833 sv_setpvn(tmpsv, ".", 1);
2835 sv_setpvn(tmpsv, a, fa - a);
2836 if (PerlLIO_stat(SvPVX_const(tmpsv), &tmpstatbuf1) < 0)
2839 sv_setpvn(tmpsv, ".", 1);
2841 sv_setpvn(tmpsv, b, fb - b);
2842 if (PerlLIO_stat(SvPVX_const(tmpsv), &tmpstatbuf2) < 0)
2844 return tmpstatbuf1.st_dev == tmpstatbuf2.st_dev &&
2845 tmpstatbuf1.st_ino == tmpstatbuf2.st_ino;
2847 #endif /* !HAS_RENAME */
2850 Perl_find_script(pTHX_ const char *scriptname, bool dosearch,
2851 const char *const *const search_ext, I32 flags)
2853 const char *xfound = Nullch;
2854 char *xfailed = Nullch;
2855 char tmpbuf[MAXPATHLEN];
2859 #if defined(DOSISH) && !defined(OS2) && !defined(atarist)
2860 # define SEARCH_EXTS ".bat", ".cmd", NULL
2861 # define MAX_EXT_LEN 4
2864 # define SEARCH_EXTS ".cmd", ".btm", ".bat", ".pl", NULL
2865 # define MAX_EXT_LEN 4
2868 # define SEARCH_EXTS ".pl", ".com", NULL
2869 # define MAX_EXT_LEN 4
2871 /* additional extensions to try in each dir if scriptname not found */
2873 static const char *const exts[] = { SEARCH_EXTS };
2874 const char *const *const ext = search_ext ? search_ext : exts;
2875 int extidx = 0, i = 0;
2876 const char *curext = Nullch;
2878 PERL_UNUSED_ARG(search_ext);
2879 # define MAX_EXT_LEN 0
2883 * If dosearch is true and if scriptname does not contain path
2884 * delimiters, search the PATH for scriptname.
2886 * If SEARCH_EXTS is also defined, will look for each
2887 * scriptname{SEARCH_EXTS} whenever scriptname is not found
2888 * while searching the PATH.
2890 * Assuming SEARCH_EXTS is C<".foo",".bar",NULL>, PATH search
2891 * proceeds as follows:
2892 * If DOSISH or VMSISH:
2893 * + look for ./scriptname{,.foo,.bar}
2894 * + search the PATH for scriptname{,.foo,.bar}
2897 * + look *only* in the PATH for scriptname{,.foo,.bar} (note
2898 * this will not look in '.' if it's not in the PATH)
2903 # ifdef ALWAYS_DEFTYPES
2904 len = strlen(scriptname);
2905 if (!(len == 1 && *scriptname == '-') && scriptname[len-1] != ':') {
2906 int idx = 0, deftypes = 1;
2909 const int hasdir = !dosearch || (strpbrk(scriptname,":[</") != Nullch);
2912 int idx = 0, deftypes = 1;
2915 const int hasdir = (strpbrk(scriptname,":[</") != Nullch);
2917 /* The first time through, just add SEARCH_EXTS to whatever we
2918 * already have, so we can check for default file types. */
2920 (!hasdir && my_trnlnm("DCL$PATH",tmpbuf,idx++)) )
2926 if ((strlen(tmpbuf) + strlen(scriptname)
2927 + MAX_EXT_LEN) >= sizeof tmpbuf)
2928 continue; /* don't search dir with too-long name */
2929 strcat(tmpbuf, scriptname);
2933 if (strEQ(scriptname, "-"))
2935 if (dosearch) { /* Look in '.' first. */
2936 const char *cur = scriptname;
2938 if ((curext = strrchr(scriptname,'.'))) /* possible current ext */
2940 if (strEQ(ext[i++],curext)) {
2941 extidx = -1; /* already has an ext */
2946 DEBUG_p(PerlIO_printf(Perl_debug_log,
2947 "Looking for %s\n",cur));
2948 if (PerlLIO_stat(cur,&PL_statbuf) >= 0
2949 && !S_ISDIR(PL_statbuf.st_mode)) {
2957 if (cur == scriptname) {
2958 len = strlen(scriptname);
2959 if (len+MAX_EXT_LEN+1 >= sizeof(tmpbuf))
2961 /* FIXME? Convert to memcpy */
2962 cur = strcpy(tmpbuf, scriptname);
2964 } while (extidx >= 0 && ext[extidx] /* try an extension? */
2965 && strcpy(tmpbuf+len, ext[extidx++]));
2970 #ifdef MACOS_TRADITIONAL
2971 if (dosearch && !strchr(scriptname, ':') &&
2972 (s = PerlEnv_getenv("Commands")))
2974 if (dosearch && !strchr(scriptname, '/')
2976 && !strchr(scriptname, '\\')
2978 && (s = PerlEnv_getenv("PATH")))
2983 PL_bufend = s + strlen(s);
2984 while (s < PL_bufend) {
2985 #ifdef MACOS_TRADITIONAL
2986 s = delimcpy(tmpbuf, tmpbuf + sizeof tmpbuf, s, PL_bufend,
2990 #if defined(atarist) || defined(DOSISH)
2995 && *s != ';'; len++, s++) {
2996 if (len < sizeof tmpbuf)
2999 if (len < sizeof tmpbuf)
3001 #else /* ! (atarist || DOSISH) */
3002 s = delimcpy(tmpbuf, tmpbuf + sizeof tmpbuf, s, PL_bufend,
3005 #endif /* ! (atarist || DOSISH) */
3006 #endif /* MACOS_TRADITIONAL */
3009 if (len + 1 + strlen(scriptname) + MAX_EXT_LEN >= sizeof tmpbuf)
3010 continue; /* don't search dir with too-long name */
3011 #ifdef MACOS_TRADITIONAL
3012 if (len && tmpbuf[len - 1] != ':')
3013 tmpbuf[len++] = ':';
3016 # if defined(atarist) || defined(__MINT__) || defined(DOSISH)
3017 && tmpbuf[len - 1] != '/'
3018 && tmpbuf[len - 1] != '\\'
3021 tmpbuf[len++] = '/';
3022 if (len == 2 && tmpbuf[0] == '.')
3025 /* FIXME? Convert to memcpy by storing previous strlen(scriptname)
3027 (void)strcpy(tmpbuf + len, scriptname);
3031 len = strlen(tmpbuf);
3032 if (extidx > 0) /* reset after previous loop */
3036 DEBUG_p(PerlIO_printf(Perl_debug_log, "Looking for %s\n",tmpbuf));
3037 retval = PerlLIO_stat(tmpbuf,&PL_statbuf);
3038 if (S_ISDIR(PL_statbuf.st_mode)) {
3042 } while ( retval < 0 /* not there */
3043 && extidx>=0 && ext[extidx] /* try an extension? */
3044 && strcpy(tmpbuf+len, ext[extidx++])
3049 if (S_ISREG(PL_statbuf.st_mode)
3050 && cando(S_IRUSR,TRUE,&PL_statbuf)
3051 #if !defined(DOSISH) && !defined(MACOS_TRADITIONAL)
3052 && cando(S_IXUSR,TRUE,&PL_statbuf)
3056 xfound = tmpbuf; /* bingo! */
3060 xfailed = savepv(tmpbuf);
3063 if (!xfound && !seen_dot && !xfailed &&
3064 (PerlLIO_stat(scriptname,&PL_statbuf) < 0
3065 || S_ISDIR(PL_statbuf.st_mode)))
3067 seen_dot = 1; /* Disable message. */
3069 if (flags & 1) { /* do or die? */
3070 Perl_croak(aTHX_ "Can't %s %s%s%s",
3071 (xfailed ? "execute" : "find"),
3072 (xfailed ? xfailed : scriptname),
3073 (xfailed ? "" : " on PATH"),
3074 (xfailed || seen_dot) ? "" : ", '.' not in PATH");
3076 scriptname = Nullch;
3079 scriptname = xfound;
3081 return (scriptname ? savepv(scriptname) : Nullch);
3084 #ifndef PERL_GET_CONTEXT_DEFINED
3087 Perl_get_context(void)
3090 #if defined(USE_ITHREADS)
3091 # ifdef OLD_PTHREADS_API
3093 if (pthread_getspecific(PL_thr_key, &t))
3094 Perl_croak_nocontext("panic: pthread_getspecific");
3097 # ifdef I_MACH_CTHREADS
3098 return (void*)cthread_data(cthread_self());
3100 return (void*)PTHREAD_GETSPECIFIC(PL_thr_key);
3109 Perl_set_context(void *t)
3112 #if defined(USE_ITHREADS)
3113 # ifdef I_MACH_CTHREADS
3114 cthread_set_data(cthread_self(), t);
3116 if (pthread_setspecific(PL_thr_key, t))
3117 Perl_croak_nocontext("panic: pthread_setspecific");
3124 #endif /* !PERL_GET_CONTEXT_DEFINED */
3126 #if defined(PERL_GLOBAL_STRUCT) && !defined(PERL_GLOBAL_STRUCT_PRIVATE)
3135 Perl_get_op_names(pTHX)
3137 return (char **)PL_op_name;
3141 Perl_get_op_descs(pTHX)
3143 return (char **)PL_op_desc;
3147 Perl_get_no_modify(pTHX)
3149 return PL_no_modify;
3153 Perl_get_opargs(pTHX)
3155 return (U32 *)PL_opargs;
3159 Perl_get_ppaddr(pTHX)
3162 return (PPADDR_t*)PL_ppaddr;
3165 #ifndef HAS_GETENV_LEN
3167 Perl_getenv_len(pTHX_ const char *env_elem, unsigned long *len)
3169 char * const env_trans = PerlEnv_getenv(env_elem);
3171 *len = strlen(env_trans);
3178 Perl_get_vtbl(pTHX_ int vtbl_id)
3180 const MGVTBL* result;
3184 result = &PL_vtbl_sv;
3187 result = &PL_vtbl_env;
3189 case want_vtbl_envelem:
3190 result = &PL_vtbl_envelem;
3193 result = &PL_vtbl_sig;
3195 case want_vtbl_sigelem:
3196 result = &PL_vtbl_sigelem;
3198 case want_vtbl_pack:
3199 result = &PL_vtbl_pack;
3201 case want_vtbl_packelem:
3202 result = &PL_vtbl_packelem;
3204 case want_vtbl_dbline:
3205 result = &PL_vtbl_dbline;
3208 result = &PL_vtbl_isa;
3210 case want_vtbl_isaelem:
3211 result = &PL_vtbl_isaelem;
3213 case want_vtbl_arylen:
3214 result = &PL_vtbl_arylen;
3216 case want_vtbl_glob:
3217 result = &PL_vtbl_glob;
3219 case want_vtbl_mglob:
3220 result = &PL_vtbl_mglob;
3222 case want_vtbl_nkeys:
3223 result = &PL_vtbl_nkeys;
3225 case want_vtbl_taint:
3226 result = &PL_vtbl_taint;
3228 case want_vtbl_substr:
3229 result = &PL_vtbl_substr;
3232 result = &PL_vtbl_vec;
3235 result = &PL_vtbl_pos;
3238 result = &PL_vtbl_bm;
3241 result = &PL_vtbl_fm;
3243 case want_vtbl_uvar:
3244 result = &PL_vtbl_uvar;
3246 case want_vtbl_defelem:
3247 result = &PL_vtbl_defelem;
3249 case want_vtbl_regexp:
3250 result = &PL_vtbl_regexp;
3252 case want_vtbl_regdata:
3253 result = &PL_vtbl_regdata;
3255 case want_vtbl_regdatum:
3256 result = &PL_vtbl_regdatum;
3258 #ifdef USE_LOCALE_COLLATE
3259 case want_vtbl_collxfrm:
3260 result = &PL_vtbl_collxfrm;
3263 case want_vtbl_amagic:
3264 result = &PL_vtbl_amagic;
3266 case want_vtbl_amagicelem:
3267 result = &PL_vtbl_amagicelem;
3269 case want_vtbl_backref:
3270 result = &PL_vtbl_backref;
3272 case want_vtbl_utf8:
3273 result = &PL_vtbl_utf8;
3276 result = Null(MGVTBL*);
3279 return (MGVTBL*)result;
3283 Perl_my_fflush_all(pTHX)
3285 #if defined(USE_PERLIO) || defined(FFLUSH_NULL) || defined(USE_SFIO)
3286 return PerlIO_flush(NULL);
3288 # if defined(HAS__FWALK)
3289 extern int fflush(FILE *);
3290 /* undocumented, unprototyped, but very useful BSDism */
3291 extern void _fwalk(int (*)(FILE *));
3295 # if defined(FFLUSH_ALL) && defined(HAS_STDIO_STREAM_ARRAY)
3297 # ifdef PERL_FFLUSH_ALL_FOPEN_MAX
3298 open_max = PERL_FFLUSH_ALL_FOPEN_MAX;
3300 # if defined(HAS_SYSCONF) && defined(_SC_OPEN_MAX)
3301 open_max = sysconf(_SC_OPEN_MAX);
3304 open_max = FOPEN_MAX;
3307 open_max = OPEN_MAX;
3318 for (i = 0; i < open_max; i++)
3319 if (STDIO_STREAM_ARRAY[i]._file >= 0 &&
3320 STDIO_STREAM_ARRAY[i]._file < open_max &&
3321 STDIO_STREAM_ARRAY[i]._flag)
3322 PerlIO_flush(&STDIO_STREAM_ARRAY[i]);
3326 SETERRNO(EBADF,RMS_IFI);
3333 Perl_report_evil_fh(pTHX_ const GV *gv, const IO *io, I32 op)
3335 const char * const func =
3336 op == OP_READLINE ? "readline" : /* "<HANDLE>" not nice */
3337 op == OP_LEAVEWRITE ? "write" : /* "write exit" not nice */
3339 const char * const pars = OP_IS_FILETEST(op) ? "" : "()";
3340 const char * const type = OP_IS_SOCKET(op)
3341 || (gv && io && IoTYPE(io) == IoTYPE_SOCKET)
3342 ? "socket" : "filehandle";
3343 const char * const name = gv && isGV(gv) ? GvENAME(gv) : NULL;
3345 if (op == OP_phoney_OUTPUT_ONLY || op == OP_phoney_INPUT_ONLY) {
3346 if (ckWARN(WARN_IO)) {
3347 const char * const direction = (op == OP_phoney_INPUT_ONLY) ? "in" : "out";
3349 Perl_warner(aTHX_ packWARN(WARN_IO),
3350 "Filehandle %s opened only for %sput",
3353 Perl_warner(aTHX_ packWARN(WARN_IO),
3354 "Filehandle opened only for %sput", direction);
3361 if (gv && io && IoTYPE(io) == IoTYPE_CLOSED) {
3363 warn_type = WARN_CLOSED;
3367 warn_type = WARN_UNOPENED;
3370 if (ckWARN(warn_type)) {
3371 if (name && *name) {
3372 Perl_warner(aTHX_ packWARN(warn_type),
3373 "%s%s on %s %s %s", func, pars, vile, type, name);
3374 if (io && IoDIRP(io) && !(IoFLAGS(io) & IOf_FAKE_DIRP))
3376 aTHX_ packWARN(warn_type),
3377 "\t(Are you trying to call %s%s on dirhandle %s?)\n",
3382 Perl_warner(aTHX_ packWARN(warn_type),
3383 "%s%s on %s %s", func, pars, vile, type);
3384 if (gv && io && IoDIRP(io) && !(IoFLAGS(io) & IOf_FAKE_DIRP))
3386 aTHX_ packWARN(warn_type),
3387 "\t(Are you trying to call %s%s on dirhandle?)\n",
3396 /* in ASCII order, not that it matters */
3397 static const char controllablechars[] = "?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_";
3400 Perl_ebcdic_control(pTHX_ int ch)
3408 if ((ctlp = strchr(controllablechars, ch)) == 0) {
3409 Perl_die(aTHX_ "unrecognised control character '%c'\n", ch);
3412 if (ctlp == controllablechars)
3413 return('\177'); /* DEL */
3415 return((unsigned char)(ctlp - controllablechars - 1));
3416 } else { /* Want uncontrol */
3417 if (ch == '\177' || ch == -1)
3419 else if (ch == '\157')
3421 else if (ch == '\174')
3423 else if (ch == '^') /* '\137' in 1047, '\260' in 819 */
3425 else if (ch == '\155')
3427 else if (0 < ch && ch < (sizeof(controllablechars) - 1))
3428 return(controllablechars[ch+1]);
3430 Perl_die(aTHX_ "invalid control request: '\\%03o'\n", ch & 0xFF);
3435 /* To workaround core dumps from the uninitialised tm_zone we get the
3436 * system to give us a reasonable struct to copy. This fix means that
3437 * strftime uses the tm_zone and tm_gmtoff values returned by
3438 * localtime(time()). That should give the desired result most of the
3439 * time. But probably not always!
3441 * This does not address tzname aspects of NETaa14816.
3446 # ifndef STRUCT_TM_HASZONE
3447 # define STRUCT_TM_HASZONE
3451 #ifdef STRUCT_TM_HASZONE /* Backward compat */
3452 # ifndef HAS_TM_TM_ZONE
3453 # define HAS_TM_TM_ZONE
3458 Perl_init_tm(pTHX_ struct tm *ptm) /* see mktime, strftime and asctime */
3460 #ifdef HAS_TM_TM_ZONE
3462 const struct tm* my_tm;
3464 my_tm = localtime(&now);
3466 Copy(my_tm, ptm, 1, struct tm);
3468 PERL_UNUSED_ARG(ptm);
3473 * mini_mktime - normalise struct tm values without the localtime()
3474 * semantics (and overhead) of mktime().
3477 Perl_mini_mktime(pTHX_ struct tm *ptm)
3481 int month, mday, year, jday;
3482 int odd_cent, odd_year;
3484 #define DAYS_PER_YEAR 365
3485 #define DAYS_PER_QYEAR (4*DAYS_PER_YEAR+1)
3486 #define DAYS_PER_CENT (25*DAYS_PER_QYEAR-1)
3487 #define DAYS_PER_QCENT (4*DAYS_PER_CENT+1)
3488 #define SECS_PER_HOUR (60*60)
3489 #define SECS_PER_DAY (24*SECS_PER_HOUR)
3490 /* parentheses deliberately absent on these two, otherwise they don't work */
3491 #define MONTH_TO_DAYS 153/5
3492 #define DAYS_TO_MONTH 5/153
3493 /* offset to bias by March (month 4) 1st between month/mday & year finding */
3494 #define YEAR_ADJUST (4*MONTH_TO_DAYS+1)
3495 /* as used here, the algorithm leaves Sunday as day 1 unless we adjust it */
3496 #define WEEKDAY_BIAS 6 /* (1+6)%7 makes Sunday 0 again */
3499 * Year/day algorithm notes:
3501 * With a suitable offset for numeric value of the month, one can find
3502 * an offset into the year by considering months to have 30.6 (153/5) days,
3503 * using integer arithmetic (i.e., with truncation). To avoid too much
3504 * messing about with leap days, we consider January and February to be
3505 * the 13th and 14th month of the previous year. After that transformation,
3506 * we need the month index we use to be high by 1 from 'normal human' usage,
3507 * so the month index values we use run from 4 through 15.
3509 * Given that, and the rules for the Gregorian calendar (leap years are those
3510 * divisible by 4 unless also divisible by 100, when they must be divisible
3511 * by 400 instead), we can simply calculate the number of days since some
3512 * arbitrary 'beginning of time' by futzing with the (adjusted) year number,
3513 * the days we derive from our month index, and adding in the day of the
3514 * month. The value used here is not adjusted for the actual origin which
3515 * it normally would use (1 January A.D. 1), since we're not exposing it.
3516 * We're only building the value so we can turn around and get the
3517 * normalised values for the year, month, day-of-month, and day-of-year.
3519 * For going backward, we need to bias the value we're using so that we find
3520 * the right year value. (Basically, we don't want the contribution of
3521 * March 1st to the number to apply while deriving the year). Having done
3522 * that, we 'count up' the contribution to the year number by accounting for
3523 * full quadracenturies (400-year periods) with their extra leap days, plus
3524 * the contribution from full centuries (to avoid counting in the lost leap
3525 * days), plus the contribution from full quad-years (to count in the normal
3526 * leap days), plus the leftover contribution from any non-leap years.
3527 * At this point, if we were working with an actual leap day, we'll have 0
3528 * days left over. This is also true for March 1st, however. So, we have
3529 * to special-case that result, and (earlier) keep track of the 'odd'
3530 * century and year contributions. If we got 4 extra centuries in a qcent,
3531 * or 4 extra years in a qyear, then it's a leap day and we call it 29 Feb.
3532 * Otherwise, we add back in the earlier bias we removed (the 123 from
3533 * figuring in March 1st), find the month index (integer division by 30.6),
3534 * and the remainder is the day-of-month. We then have to convert back to
3535 * 'real' months (including fixing January and February from being 14/15 in
3536 * the previous year to being in the proper year). After that, to get
3537 * tm_yday, we work with the normalised year and get a new yearday value for
3538 * January 1st, which we subtract from the yearday value we had earlier,
3539 * representing the date we've re-built. This is done from January 1
3540 * because tm_yday is 0-origin.
3542 * Since POSIX time routines are only guaranteed to work for times since the
3543 * UNIX epoch (00:00:00 1 Jan 1970 UTC), the fact that this algorithm
3544 * applies Gregorian calendar rules even to dates before the 16th century
3545 * doesn't bother me. Besides, you'd need cultural context for a given
3546 * date to know whether it was Julian or Gregorian calendar, and that's
3547 * outside the scope for this routine. Since we convert back based on the
3548 * same rules we used to build the yearday, you'll only get strange results
3549 * for input which needed normalising, or for the 'odd' century years which
3550 * were leap years in the Julian calander but not in the Gregorian one.
3551 * I can live with that.
3553 * This algorithm also fails to handle years before A.D. 1 gracefully, but
3554 * that's still outside the scope for POSIX time manipulation, so I don't
3558 year = 1900 + ptm->tm_year;
3559 month = ptm->tm_mon;
3560 mday = ptm->tm_mday;
3561 /* allow given yday with no month & mday to dominate the result */
3562 if (ptm->tm_yday >= 0 && mday <= 0 && month <= 0) {
3565 jday = 1 + ptm->tm_yday;
3574 yearday = DAYS_PER_YEAR * year + year/4 - year/100 + year/400;
3575 yearday += month*MONTH_TO_DAYS + mday + jday;
3577 * Note that we don't know when leap-seconds were or will be,
3578 * so we have to trust the user if we get something which looks
3579 * like a sensible leap-second. Wild values for seconds will
3580 * be rationalised, however.
3582 if ((unsigned) ptm->tm_sec <= 60) {
3589 secs += 60 * ptm->tm_min;
3590 secs += SECS_PER_HOUR * ptm->tm_hour;
3592 if (secs-(secs/SECS_PER_DAY*SECS_PER_DAY) < 0) {
3593 /* got negative remainder, but need positive time */
3594 /* back off an extra day to compensate */
3595 yearday += (secs/SECS_PER_DAY)-1;
3596 secs -= SECS_PER_DAY * (secs/SECS_PER_DAY - 1);
3599 yearday += (secs/SECS_PER_DAY);
3600 secs -= SECS_PER_DAY * (secs/SECS_PER_DAY);
3603 else if (secs >= SECS_PER_DAY) {
3604 yearday += (secs/SECS_PER_DAY);
3605 secs %= SECS_PER_DAY;
3607 ptm->tm_hour = secs/SECS_PER_HOUR;
3608 secs %= SECS_PER_HOUR;
3609 ptm->tm_min = secs/60;
3611 ptm->tm_sec += secs;
3612 /* done with time of day effects */
3614 * The algorithm for yearday has (so far) left it high by 428.
3615 * To avoid mistaking a legitimate Feb 29 as Mar 1, we need to
3616 * bias it by 123 while trying to figure out what year it
3617 * really represents. Even with this tweak, the reverse
3618 * translation fails for years before A.D. 0001.
3619 * It would still fail for Feb 29, but we catch that one below.
3621 jday = yearday; /* save for later fixup vis-a-vis Jan 1 */
3622 yearday -= YEAR_ADJUST;
3623 year = (yearday / DAYS_PER_QCENT) * 400;
3624 yearday %= DAYS_PER_QCENT;
3625 odd_cent = yearday / DAYS_PER_CENT;
3626 year += odd_cent * 100;
3627 yearday %= DAYS_PER_CENT;
3628 year += (yearday / DAYS_PER_QYEAR) * 4;
3629 yearday %= DAYS_PER_QYEAR;
3630 odd_year = yearday / DAYS_PER_YEAR;
3632 yearday %= DAYS_PER_YEAR;
3633 if (!yearday && (odd_cent==4 || odd_year==4)) { /* catch Feb 29 */
3638 yearday += YEAR_ADJUST; /* recover March 1st crock */
3639 month = yearday*DAYS_TO_MONTH;
3640 yearday -= month*MONTH_TO_DAYS;
3641 /* recover other leap-year adjustment */
3650 ptm->tm_year = year - 1900;
3652 ptm->tm_mday = yearday;
3653 ptm->tm_mon = month;
3657 ptm->tm_mon = month - 1;
3659 /* re-build yearday based on Jan 1 to get tm_yday */
3661 yearday = year*DAYS_PER_YEAR + year/4 - year/100 + year/400;
3662 yearday += 14*MONTH_TO_DAYS + 1;
3663 ptm->tm_yday = jday - yearday;
3664 /* fix tm_wday if not overridden by caller */
3665 if ((unsigned)ptm->tm_wday > 6)
3666 ptm->tm_wday = (jday + WEEKDAY_BIAS) % 7;
3670 Perl_my_strftime(pTHX_ const char *fmt, int sec, int min, int hour, int mday, int mon, int year, int wday, int yday, int isdst)
3678 init_tm(&mytm); /* XXX workaround - see init_tm() above */
3681 mytm.tm_hour = hour;
3682 mytm.tm_mday = mday;
3684 mytm.tm_year = year;
3685 mytm.tm_wday = wday;
3686 mytm.tm_yday = yday;
3687 mytm.tm_isdst = isdst;
3689 /* use libc to get the values for tm_gmtoff and tm_zone [perl #18238] */
3690 #if defined(HAS_MKTIME) && (defined(HAS_TM_TM_GMTOFF) || defined(HAS_TM_TM_ZONE))
3695 #ifdef HAS_TM_TM_GMTOFF
3696 mytm.tm_gmtoff = mytm2.tm_gmtoff;
3698 #ifdef HAS_TM_TM_ZONE
3699 mytm.tm_zone = mytm2.tm_zone;
3704 Newx(buf, buflen, char);
3705 len = strftime(buf, buflen, fmt, &mytm);
3707 ** The following is needed to handle to the situation where
3708 ** tmpbuf overflows. Basically we want to allocate a buffer
3709 ** and try repeatedly. The reason why it is so complicated
3710 ** is that getting a return value of 0 from strftime can indicate
3711 ** one of the following:
3712 ** 1. buffer overflowed,
3713 ** 2. illegal conversion specifier, or
3714 ** 3. the format string specifies nothing to be returned(not
3715 ** an error). This could be because format is an empty string
3716 ** or it specifies %p that yields an empty string in some locale.
3717 ** If there is a better way to make it portable, go ahead by
3720 if ((len > 0 && len < buflen) || (len == 0 && *fmt == '\0'))
3723 /* Possibly buf overflowed - try again with a bigger buf */
3724 const int fmtlen = strlen(fmt);
3725 const int bufsize = fmtlen + buflen;
3727 Newx(buf, bufsize, char);
3729 buflen = strftime(buf, bufsize, fmt, &mytm);
3730 if (buflen > 0 && buflen < bufsize)
3732 /* heuristic to prevent out-of-memory errors */
3733 if (bufsize > 100*fmtlen) {
3738 Renew(buf, bufsize*2, char);
3743 Perl_croak(aTHX_ "panic: no strftime");
3749 #define SV_CWD_RETURN_UNDEF \
3750 sv_setsv(sv, &PL_sv_undef); \
3753 #define SV_CWD_ISDOT(dp) \
3754 (dp->d_name[0] == '.' && (dp->d_name[1] == '\0' || \
3755 (dp->d_name[1] == '.' && dp->d_name[2] == '\0')))
3758 =head1 Miscellaneous Functions
3760 =for apidoc getcwd_sv
3762 Fill the sv with current working directory
3767 /* Originally written in Perl by John Bazik; rewritten in C by Ben Sugars.
3768 * rewritten again by dougm, optimized for use with xs TARG, and to prefer
3769 * getcwd(3) if available
3770 * Comments from the orignal:
3771 * This is a faster version of getcwd. It's also more dangerous
3772 * because you might chdir out of a directory that you can't chdir
3776 Perl_getcwd_sv(pTHX_ register SV *sv)
3780 #ifndef INCOMPLETE_TAINTS
3786 char buf[MAXPATHLEN];
3788 /* Some getcwd()s automatically allocate a buffer of the given
3789 * size from the heap if they are given a NULL buffer pointer.
3790 * The problem is that this behaviour is not portable. */
3791 if (getcwd(buf, sizeof(buf) - 1)) {
3796 sv_setsv(sv, &PL_sv_undef);
3804 int orig_cdev, orig_cino, cdev, cino, odev, oino, tdev, tino;
3808 SvUPGRADE(sv, SVt_PV);
3810 if (PerlLIO_lstat(".", &statbuf) < 0) {
3811 SV_CWD_RETURN_UNDEF;
3814 orig_cdev = statbuf.st_dev;
3815 orig_cino = statbuf.st_ino;
3824 if (PerlDir_chdir("..") < 0) {
3825 SV_CWD_RETURN_UNDEF;
3827 if (PerlLIO_stat(".", &statbuf) < 0) {
3828 SV_CWD_RETURN_UNDEF;
3831 cdev = statbuf.st_dev;
3832 cino = statbuf.st_ino;
3834 if (odev == cdev && oino == cino) {
3837 if (!(dir = PerlDir_open("."))) {
3838 SV_CWD_RETURN_UNDEF;
3841 while ((dp = PerlDir_read(dir)) != NULL) {
3843 const int namelen = dp->d_namlen;
3845 const int namelen = strlen(dp->d_name);
3848 if (SV_CWD_ISDOT(dp)) {
3852 if (PerlLIO_lstat(dp->d_name, &statbuf) < 0) {
3853 SV_CWD_RETURN_UNDEF;
3856 tdev = statbuf.st_dev;
3857 tino = statbuf.st_ino;
3858 if (tino == oino && tdev == odev) {
3864 SV_CWD_RETURN_UNDEF;
3867 if (pathlen + namelen + 1 >= MAXPATHLEN) {
3868 SV_CWD_RETURN_UNDEF;
3871 SvGROW(sv, pathlen + namelen + 1);
3875 Move(SvPVX_const(sv), SvPVX(sv) + namelen + 1, pathlen, char);
3878 /* prepend current directory to the front */
3880 Move(dp->d_name, SvPVX(sv)+1, namelen, char);
3881 pathlen += (namelen + 1);
3883 #ifdef VOID_CLOSEDIR
3886 if (PerlDir_close(dir) < 0) {
3887 SV_CWD_RETURN_UNDEF;
3893 SvCUR_set(sv, pathlen);
3897 if (PerlDir_chdir(SvPVX_const(sv)) < 0) {
3898 SV_CWD_RETURN_UNDEF;
3901 if (PerlLIO_stat(".", &statbuf) < 0) {
3902 SV_CWD_RETURN_UNDEF;
3905 cdev = statbuf.st_dev;
3906 cino = statbuf.st_ino;
3908 if (cdev != orig_cdev || cino != orig_cino) {
3909 Perl_croak(aTHX_ "Unstable directory path, "
3910 "current directory changed unexpectedly");
3922 =for apidoc scan_version
3924 Returns a pointer to the next character after the parsed
3925 version string, as well as upgrading the passed in SV to
3928 Function must be called with an already existing SV like
3931 s = scan_version(s,SV *sv, bool qv);
3933 Performs some preprocessing to the string to ensure that
3934 it has the correct characteristics of a version. Flags the
3935 object if it contains an underscore (which denotes this
3936 is a alpha version). The boolean qv denotes that the version
3937 should be interpreted as if it had multiple decimals, even if
3944 Perl_scan_version(pTHX_ const char *s, SV *rv, bool qv)
3952 AV * const av = newAV();
3953 SV * const hv = newSVrv(rv, "version"); /* create an SV and upgrade the RV */
3954 (void)sv_upgrade(hv, SVt_PVHV); /* needs to be an HV type */
3956 #ifndef NODEFAULT_SHAREKEYS
3957 HvSHAREKEYS_on(hv); /* key-sharing on by default */
3960 while (isSPACE(*s)) /* leading whitespace is OK */
3964 s++; /* get past 'v' */
3965 qv = 1; /* force quoted version processing */
3968 start = last = pos = s;
3970 /* pre-scan the input string to check for decimals/underbars */
3971 while ( *pos == '.' || *pos == '_' || isDIGIT(*pos) )
3976 Perl_croak(aTHX_ "Invalid version format (underscores before decimal)");
3980 else if ( *pos == '_' )
3983 Perl_croak(aTHX_ "Invalid version format (multiple underscores)");
3985 width = pos - last - 1; /* natural width of sub-version */
3990 if ( saw_period > 1 )
3991 qv = 1; /* force quoted version processing */
3996 hv_store((HV *)hv, "qv", 2, newSViv(qv), 0);
3998 hv_store((HV *)hv, "alpha", 5, newSViv(alpha), 0);
3999 if ( !qv && width < 3 )
4000 hv_store((HV *)hv, "width", 5, newSViv(width), 0);
4002 while (isDIGIT(*pos))
4004 if (!isALPHA(*pos)) {
4010 /* this is atoi() that delimits on underscores */
4011 const char *end = pos;
4015 /* the following if() will only be true after the decimal
4016 * point of a version originally created with a bare
4017 * floating point number, i.e. not quoted in any way
4019 if ( !qv && s > start && saw_period == 1 ) {
4023 rev += (*s - '0') * mult;
4025 if ( PERL_ABS(orev) > PERL_ABS(rev) )
4026 Perl_croak(aTHX_ "Integer overflow in version");
4033 while (--end >= s) {
4035 rev += (*end - '0') * mult;
4037 if ( PERL_ABS(orev) > PERL_ABS(rev) )
4038 Perl_croak(aTHX_ "Integer overflow in version");
4043 /* Append revision */
4044 av_push(av, newSViv(rev));
4045 if ( *pos == '.' && isDIGIT(pos[1]) )
4047 else if ( *pos == '_' && isDIGIT(pos[1]) )
4049 else if ( isDIGIT(*pos) )
4056 while ( isDIGIT(*pos) )
4061 while ( ( isDIGIT(*pos) || *pos == '_' ) && digits < 3 ) {
4069 if ( qv ) { /* quoted versions always get at least three terms*/
4070 I32 len = av_len(av);
4071 /* This for loop appears to trigger a compiler bug on OS X, as it
4072 loops infinitely. Yes, len is negative. No, it makes no sense.
4073 Compiler in question is:
4074 gcc version 3.3 20030304 (Apple Computer, Inc. build 1640)
4075 for ( len = 2 - len; len > 0; len-- )
4076 av_push((AV *)sv, newSViv(0));
4080 av_push(av, newSViv(0));
4083 if ( av_len(av) == -1 ) /* oops, someone forgot to pass a value */
4084 av_push(av, newSViv(0));
4086 /* And finally, store the AV in the hash */
4087 hv_store((HV *)hv, "version", 7, newRV_noinc((SV *)av), 0);
4092 =for apidoc new_version
4094 Returns a new version object based on the passed in SV:
4096 SV *sv = new_version(SV *ver);
4098 Does not alter the passed in ver SV. See "upg_version" if you
4099 want to upgrade the SV.
4105 Perl_new_version(pTHX_ SV *ver)
4107 SV * const rv = newSV(0);
4108 if ( sv_derived_from(ver,"version") ) /* can just copy directly */
4111 AV * const av = newAV();
4113 /* This will get reblessed later if a derived class*/
4114 SV * const hv = newSVrv(rv, "version");
4115 (void)sv_upgrade(hv, SVt_PVHV); /* needs to be an HV type */
4116 #ifndef NODEFAULT_SHAREKEYS
4117 HvSHAREKEYS_on(hv); /* key-sharing on by default */
4123 /* Begin copying all of the elements */
4124 if ( hv_exists((HV *)ver, "qv", 2) )
4125 hv_store((HV *)hv, "qv", 2, &PL_sv_yes, 0);
4127 if ( hv_exists((HV *)ver, "alpha", 5) )
4128 hv_store((HV *)hv, "alpha", 5, &PL_sv_yes, 0);
4130 if ( hv_exists((HV*)ver, "width", 5 ) )
4132 const I32 width = SvIV(*hv_fetch((HV*)ver, "width", 5, FALSE));
4133 hv_store((HV *)hv, "width", 5, newSViv(width), 0);
4136 sav = (AV *)SvRV(*hv_fetch((HV*)ver, "version", 7, FALSE));
4137 /* This will get reblessed later if a derived class*/
4138 for ( key = 0; key <= av_len(sav); key++ )
4140 const I32 rev = SvIV(*av_fetch(sav, key, FALSE));
4141 av_push(av, newSViv(rev));
4144 hv_store((HV *)hv, "version", 7, newRV_noinc((SV *)av), 0);
4148 if ( SvVOK(ver) ) { /* already a v-string */
4149 const MAGIC* const mg = mg_find(ver,PERL_MAGIC_vstring);
4150 const STRLEN len = mg->mg_len;
4151 char * const version = savepvn( (const char*)mg->mg_ptr, len);
4152 sv_setpvn(rv,version,len);
4157 sv_setsv(rv,ver); /* make a duplicate */
4166 =for apidoc upg_version
4168 In-place upgrade of the supplied SV to a version object.
4170 SV *sv = upg_version(SV *sv);
4172 Returns a pointer to the upgraded SV.
4178 Perl_upg_version(pTHX_ SV *ver)
4183 if ( SvNOK(ver) ) /* may get too much accuracy */
4186 const STRLEN len = my_sprintf(tbuf,"%.9"NVgf, SvNVX(ver));
4187 version = savepvn(tbuf, len);
4190 else if ( SvVOK(ver) ) { /* already a v-string */
4191 const MAGIC* const mg = mg_find(ver,PERL_MAGIC_vstring);
4192 version = savepvn( (const char*)mg->mg_ptr,mg->mg_len );
4196 else /* must be a string or something like a string */
4198 version = savepv(SvPV_nolen(ver));
4200 (void)scan_version(version, ver, qv);
4208 Validates that the SV contains a valid version object.
4210 bool vverify(SV *vobj);
4212 Note that it only confirms the bare minimum structure (so as not to get
4213 confused by derived classes which may contain additional hash entries):
4217 =item * The SV contains a [reference to a] hash
4219 =item * The hash contains a "version" key
4221 =item * The "version" key has [a reference to] an AV as its value
4229 Perl_vverify(pTHX_ SV *vs)
4235 /* see if the appropriate elements exist */
4236 if ( SvTYPE(vs) == SVt_PVHV
4237 && hv_exists((HV*)vs, "version", 7)
4238 && (sv = SvRV(*hv_fetch((HV*)vs, "version", 7, FALSE)))
4239 && SvTYPE(sv) == SVt_PVAV )
4248 Accepts a version object and returns the normalized floating
4249 point representation. Call like:
4253 NOTE: you can pass either the object directly or the SV
4254 contained within the RV.
4260 Perl_vnumify(pTHX_ SV *vs)
4265 SV * const sv = newSV(0);
4271 Perl_croak(aTHX_ "Invalid version object");
4273 /* see if various flags exist */
4274 if ( hv_exists((HV*)vs, "alpha", 5 ) )
4276 if ( hv_exists((HV*)vs, "width", 5 ) )
4277 width = SvIV(*hv_fetch((HV*)vs, "width", 5, FALSE));
4282 /* attempt to retrieve the version array */
4283 if ( !(av = (AV *)SvRV(*hv_fetch((HV*)vs, "version", 7, FALSE)) ) ) {
4284 sv_catpvn(sv,"0",1);
4291 sv_catpvn(sv,"0",1);
4295 digit = SvIV(*av_fetch(av, 0, 0));
4296 Perl_sv_setpvf(aTHX_ sv, "%d.", (int)PERL_ABS(digit));
4297 for ( i = 1 ; i < len ; i++ )
4299 digit = SvIV(*av_fetch(av, i, 0));
4301 const int denom = (width == 2 ? 10 : 100);
4302 const div_t term = div((int)PERL_ABS(digit),denom);
4303 Perl_sv_catpvf(aTHX_ sv, "%0*d_%d", width, term.quot, term.rem);
4306 Perl_sv_catpvf(aTHX_ sv, "%0*d", width, (int)digit);
4312 digit = SvIV(*av_fetch(av, len, 0));
4313 if ( alpha && width == 3 ) /* alpha version */
4314 sv_catpvn(sv,"_",1);
4315 Perl_sv_catpvf(aTHX_ sv, "%0*d", width, (int)digit);
4319 sv_catpvn(sv,"000",3);
4327 Accepts a version object and returns the normalized string
4328 representation. Call like:
4332 NOTE: you can pass either the object directly or the SV
4333 contained within the RV.
4339 Perl_vnormal(pTHX_ SV *vs)
4343 SV * const sv = newSV(0);
4349 Perl_croak(aTHX_ "Invalid version object");
4351 if ( hv_exists((HV*)vs, "alpha", 5 ) )
4353 av = (AV *)SvRV(*hv_fetch((HV*)vs, "version", 7, FALSE));
4361 digit = SvIV(*av_fetch(av, 0, 0));
4362 Perl_sv_setpvf(aTHX_ sv, "v%"IVdf, (IV)digit);
4363 for ( i = 1 ; i < len ; i++ ) {
4364 digit = SvIV(*av_fetch(av, i, 0));
4365 Perl_sv_catpvf(aTHX_ sv, ".%"IVdf, (IV)digit);
4370 /* handle last digit specially */
4371 digit = SvIV(*av_fetch(av, len, 0));
4373 Perl_sv_catpvf(aTHX_ sv, "_%"IVdf, (IV)digit);
4375 Perl_sv_catpvf(aTHX_ sv, ".%"IVdf, (IV)digit);
4378 if ( len <= 2 ) { /* short version, must be at least three */
4379 for ( len = 2 - len; len != 0; len-- )
4380 sv_catpvn(sv,".0",2);
4386 =for apidoc vstringify
4388 In order to maintain maximum compatibility with earlier versions
4389 of Perl, this function will return either the floating point
4390 notation or the multiple dotted notation, depending on whether
4391 the original version contained 1 or more dots, respectively
4397 Perl_vstringify(pTHX_ SV *vs)
4403 Perl_croak(aTHX_ "Invalid version object");
4405 if ( hv_exists((HV *)vs, "qv", 2) )
4414 Version object aware cmp. Both operands must already have been
4415 converted into version objects.
4421 Perl_vcmp(pTHX_ SV *lhv, SV *rhv)
4424 bool lalpha = FALSE;
4425 bool ralpha = FALSE;
4434 if ( !vverify(lhv) )
4435 Perl_croak(aTHX_ "Invalid version object");
4437 if ( !vverify(rhv) )
4438 Perl_croak(aTHX_ "Invalid version object");
4440 /* get the left hand term */
4441 lav = (AV *)SvRV(*hv_fetch((HV*)lhv, "version", 7, FALSE));
4442 if ( hv_exists((HV*)lhv, "alpha", 5 ) )
4445 /* and the right hand term */
4446 rav = (AV *)SvRV(*hv_fetch((HV*)rhv, "version", 7, FALSE));
4447 if ( hv_exists((HV*)rhv, "alpha", 5 ) )
4455 while ( i <= m && retval == 0 )
4457 left = SvIV(*av_fetch(lav,i,0));
4458 right = SvIV(*av_fetch(rav,i,0));
4466 /* tiebreaker for alpha with identical terms */
4467 if ( retval == 0 && l == r && left == right && ( lalpha || ralpha ) )
4469 if ( lalpha && !ralpha )
4473 else if ( ralpha && !lalpha)
4479 if ( l != r && retval == 0 ) /* possible match except for trailing 0's */
4483 while ( i <= r && retval == 0 )
4485 if ( SvIV(*av_fetch(rav,i,0)) != 0 )
4486 retval = -1; /* not a match after all */
4492 while ( i <= l && retval == 0 )
4494 if ( SvIV(*av_fetch(lav,i,0)) != 0 )
4495 retval = +1; /* not a match after all */
4503 #if !defined(HAS_SOCKETPAIR) && defined(HAS_SOCKET) && defined(AF_INET) && defined(PF_INET) && defined(SOCK_DGRAM) && defined(HAS_SELECT)
4504 # define EMULATE_SOCKETPAIR_UDP
4507 #ifdef EMULATE_SOCKETPAIR_UDP
4509 S_socketpair_udp (int fd[2]) {
4511 /* Fake a datagram socketpair using UDP to localhost. */
4512 int sockets[2] = {-1, -1};
4513 struct sockaddr_in addresses[2];
4515 Sock_size_t size = sizeof(struct sockaddr_in);
4516 unsigned short port;
4519 memset(&addresses, 0, sizeof(addresses));
4522 sockets[i] = PerlSock_socket(AF_INET, SOCK_DGRAM, PF_INET);
4523 if (sockets[i] == -1)
4524 goto tidy_up_and_fail;
4526 addresses[i].sin_family = AF_INET;
4527 addresses[i].sin_addr.s_addr = htonl(INADDR_LOOPBACK);
4528 addresses[i].sin_port = 0; /* kernel choses port. */
4529 if (PerlSock_bind(sockets[i], (struct sockaddr *) &addresses[i],
4530 sizeof(struct sockaddr_in)) == -1)
4531 goto tidy_up_and_fail;
4534 /* Now have 2 UDP sockets. Find out which port each is connected to, and
4535 for each connect the other socket to it. */
4538 if (PerlSock_getsockname(sockets[i], (struct sockaddr *) &addresses[i],
4540 goto tidy_up_and_fail;
4541 if (size != sizeof(struct sockaddr_in))
4542 goto abort_tidy_up_and_fail;
4543 /* !1 is 0, !0 is 1 */
4544 if (PerlSock_connect(sockets[!i], (struct sockaddr *) &addresses[i],
4545 sizeof(struct sockaddr_in)) == -1)
4546 goto tidy_up_and_fail;
4549 /* Now we have 2 sockets connected to each other. I don't trust some other
4550 process not to have already sent a packet to us (by random) so send
4551 a packet from each to the other. */
4554 /* I'm going to send my own port number. As a short.
4555 (Who knows if someone somewhere has sin_port as a bitfield and needs
4556 this routine. (I'm assuming crays have socketpair)) */
4557 port = addresses[i].sin_port;
4558 got = PerlLIO_write(sockets[i], &port, sizeof(port));
4559 if (got != sizeof(port)) {
4561 goto tidy_up_and_fail;
4562 goto abort_tidy_up_and_fail;
4566 /* Packets sent. I don't trust them to have arrived though.
4567 (As I understand it Solaris TCP stack is multithreaded. Non-blocking
4568 connect to localhost will use a second kernel thread. In 2.6 the
4569 first thread running the connect() returns before the second completes,
4570 so EINPROGRESS> In 2.7 the improved stack is faster and connect()
4571 returns 0. Poor programs have tripped up. One poor program's authors'
4572 had a 50-1 reverse stock split. Not sure how connected these were.)
4573 So I don't trust someone not to have an unpredictable UDP stack.
4577 struct timeval waitfor = {0, 100000}; /* You have 0.1 seconds */
4578 int max = sockets[1] > sockets[0] ? sockets[1] : sockets[0];
4582 FD_SET(sockets[0], &rset);
4583 FD_SET(sockets[1], &rset);
4585 got = PerlSock_select(max + 1, &rset, NULL, NULL, &waitfor);
4586 if (got != 2 || !FD_ISSET(sockets[0], &rset)
4587 || !FD_ISSET(sockets[1], &rset)) {
4588 /* I hope this is portable and appropriate. */
4590 goto tidy_up_and_fail;
4591 goto abort_tidy_up_and_fail;
4595 /* And the paranoia department even now doesn't trust it to have arrive
4596 (hence MSG_DONTWAIT). Or that what arrives was sent by us. */
4598 struct sockaddr_in readfrom;
4599 unsigned short buffer[2];
4604 got = PerlSock_recvfrom(sockets[i], (char *) &buffer,
4605 sizeof(buffer), MSG_DONTWAIT,
4606 (struct sockaddr *) &readfrom, &size);
4608 got = PerlSock_recvfrom(sockets[i], (char *) &buffer,
4610 (struct sockaddr *) &readfrom, &size);
4614 goto tidy_up_and_fail;
4615 if (got != sizeof(port)
4616 || size != sizeof(struct sockaddr_in)
4617 /* Check other socket sent us its port. */
4618 || buffer[0] != (unsigned short) addresses[!i].sin_port
4619 /* Check kernel says we got the datagram from that socket */
4620 || readfrom.sin_family != addresses[!i].sin_family
4621 || readfrom.sin_addr.s_addr != addresses[!i].sin_addr.s_addr
4622 || readfrom.sin_port != addresses[!i].sin_port)
4623 goto abort_tidy_up_and_fail;
4626 /* My caller (my_socketpair) has validated that this is non-NULL */
4629 /* I hereby declare this connection open. May God bless all who cross
4633 abort_tidy_up_and_fail:
4634 errno = ECONNABORTED;
4637 const int save_errno = errno;
4638 if (sockets[0] != -1)
4639 PerlLIO_close(sockets[0]);
4640 if (sockets[1] != -1)
4641 PerlLIO_close(sockets[1]);
4646 #endif /* EMULATE_SOCKETPAIR_UDP */
4648 #if !defined(HAS_SOCKETPAIR) && defined(HAS_SOCKET) && defined(AF_INET) && defined(PF_INET)
4650 Perl_my_socketpair (int family, int type, int protocol, int fd[2]) {
4651 /* Stevens says that family must be AF_LOCAL, protocol 0.
4652 I'm going to enforce that, then ignore it, and use TCP (or UDP). */
4657 struct sockaddr_in listen_addr;
4658 struct sockaddr_in connect_addr;
4663 || family != AF_UNIX
4666 errno = EAFNOSUPPORT;
4674 #ifdef EMULATE_SOCKETPAIR_UDP
4675 if (type == SOCK_DGRAM)
4676 return S_socketpair_udp(fd);
4679 listener = PerlSock_socket(AF_INET, type, 0);
4682 memset(&listen_addr, 0, sizeof(listen_addr));
4683 listen_addr.sin_family = AF_INET;
4684 listen_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
4685 listen_addr.sin_port = 0; /* kernel choses port. */
4686 if (PerlSock_bind(listener, (struct sockaddr *) &listen_addr,
4687 sizeof(listen_addr)) == -1)
4688 goto tidy_up_and_fail;
4689 if (PerlSock_listen(listener, 1) == -1)
4690 goto tidy_up_and_fail;
4692 connector = PerlSock_socket(AF_INET, type, 0);
4693 if (connector == -1)
4694 goto tidy_up_and_fail;
4695 /* We want to find out the port number to connect to. */
4696 size = sizeof(connect_addr);
4697 if (PerlSock_getsockname(listener, (struct sockaddr *) &connect_addr,
4699 goto tidy_up_and_fail;
4700 if (size != sizeof(connect_addr))
4701 goto abort_tidy_up_and_fail;
4702 if (PerlSock_connect(connector, (struct sockaddr *) &connect_addr,
4703 sizeof(connect_addr)) == -1)
4704 goto tidy_up_and_fail;
4706 size = sizeof(listen_addr);
4707 acceptor = PerlSock_accept(listener, (struct sockaddr *) &listen_addr,
4710 goto tidy_up_and_fail;
4711 if (size != sizeof(listen_addr))
4712 goto abort_tidy_up_and_fail;
4713 PerlLIO_close(listener);
4714 /* Now check we are talking to ourself by matching port and host on the
4716 if (PerlSock_getsockname(connector, (struct sockaddr *) &connect_addr,
4718 goto tidy_up_and_fail;
4719 if (size != sizeof(connect_addr)
4720 || listen_addr.sin_family != connect_addr.sin_family
4721 || listen_addr.sin_addr.s_addr != connect_addr.sin_addr.s_addr
4722 || listen_addr.sin_port != connect_addr.sin_port) {
4723 goto abort_tidy_up_and_fail;
4729 abort_tidy_up_and_fail:
4731 errno = ECONNABORTED; /* This would be the standard thing to do. */
4733 # ifdef ECONNREFUSED
4734 errno = ECONNREFUSED; /* E.g. Symbian does not have ECONNABORTED. */
4736 errno = ETIMEDOUT; /* Desperation time. */
4741 const int save_errno = errno;
4743 PerlLIO_close(listener);
4744 if (connector != -1)
4745 PerlLIO_close(connector);
4747 PerlLIO_close(acceptor);
4753 /* In any case have a stub so that there's code corresponding
4754 * to the my_socketpair in global.sym. */
4756 Perl_my_socketpair (int family, int type, int protocol, int fd[2]) {
4757 #ifdef HAS_SOCKETPAIR
4758 return socketpair(family, type, protocol, fd);
4767 =for apidoc sv_nosharing
4769 Dummy routine which "shares" an SV when there is no sharing module present.
4770 Or "locks" it. Or "unlocks" it. In other words, ignores its single SV argument.
4771 Exists to avoid test for a NULL function pointer and because it could
4772 potentially warn under some level of strict-ness.
4778 Perl_sv_nosharing(pTHX_ SV *sv)
4780 PERL_UNUSED_ARG(sv);
4784 Perl_parse_unicode_opts(pTHX_ const char **popt)
4786 const char *p = *popt;
4791 opt = (U32) atoi(p);
4792 while (isDIGIT(*p)) p++;
4793 if (*p && *p != '\n' && *p != '\r')
4794 Perl_croak(aTHX_ "Unknown Unicode option letter '%c'", *p);
4799 case PERL_UNICODE_STDIN:
4800 opt |= PERL_UNICODE_STDIN_FLAG; break;
4801 case PERL_UNICODE_STDOUT:
4802 opt |= PERL_UNICODE_STDOUT_FLAG; break;
4803 case PERL_UNICODE_STDERR:
4804 opt |= PERL_UNICODE_STDERR_FLAG; break;
4805 case PERL_UNICODE_STD:
4806 opt |= PERL_UNICODE_STD_FLAG; break;
4807 case PERL_UNICODE_IN:
4808 opt |= PERL_UNICODE_IN_FLAG; break;
4809 case PERL_UNICODE_OUT:
4810 opt |= PERL_UNICODE_OUT_FLAG; break;
4811 case PERL_UNICODE_INOUT:
4812 opt |= PERL_UNICODE_INOUT_FLAG; break;
4813 case PERL_UNICODE_LOCALE:
4814 opt |= PERL_UNICODE_LOCALE_FLAG; break;
4815 case PERL_UNICODE_ARGV:
4816 opt |= PERL_UNICODE_ARGV_FLAG; break;
4818 if (*p != '\n' && *p != '\r')
4820 "Unknown Unicode option letter '%c'", *p);
4826 opt = PERL_UNICODE_DEFAULT_FLAGS;
4828 if (opt & ~PERL_UNICODE_ALL_FLAGS)
4829 Perl_croak(aTHX_ "Unknown Unicode option value %"UVuf,
4830 (UV) (opt & ~PERL_UNICODE_ALL_FLAGS));
4841 * This is really just a quick hack which grabs various garbage
4842 * values. It really should be a real hash algorithm which
4843 * spreads the effect of every input bit onto every output bit,
4844 * if someone who knows about such things would bother to write it.
4845 * Might be a good idea to add that function to CORE as well.
4846 * No numbers below come from careful analysis or anything here,
4847 * except they are primes and SEED_C1 > 1E6 to get a full-width
4848 * value from (tv_sec * SEED_C1 + tv_usec). The multipliers should
4849 * probably be bigger too.
4852 # define SEED_C1 1000003
4853 #define SEED_C4 73819
4855 # define SEED_C1 25747
4856 #define SEED_C4 20639
4860 #define SEED_C5 26107
4862 #ifndef PERL_NO_DEV_RANDOM
4867 # include <starlet.h>
4868 /* when[] = (low 32 bits, high 32 bits) of time since epoch
4869 * in 100-ns units, typically incremented ever 10 ms. */
4870 unsigned int when[2];
4872 # ifdef HAS_GETTIMEOFDAY
4873 struct timeval when;
4879 /* This test is an escape hatch, this symbol isn't set by Configure. */
4880 #ifndef PERL_NO_DEV_RANDOM
4881 #ifndef PERL_RANDOM_DEVICE
4882 /* /dev/random isn't used by default because reads from it will block
4883 * if there isn't enough entropy available. You can compile with
4884 * PERL_RANDOM_DEVICE to it if you'd prefer Perl to block until there
4885 * is enough real entropy to fill the seed. */
4886 # define PERL_RANDOM_DEVICE "/dev/urandom"
4888 fd = PerlLIO_open(PERL_RANDOM_DEVICE, 0);
4890 if (PerlLIO_read(fd, (void*)&u, sizeof u) != sizeof u)
4899 _ckvmssts(sys$gettim(when));
4900 u = (U32)SEED_C1 * when[0] + (U32)SEED_C2 * when[1];
4902 # ifdef HAS_GETTIMEOFDAY
4903 PerlProc_gettimeofday(&when,NULL);
4904 u = (U32)SEED_C1 * when.tv_sec + (U32)SEED_C2 * when.tv_usec;
4907 u = (U32)SEED_C1 * when;
4910 u += SEED_C3 * (U32)PerlProc_getpid();
4911 u += SEED_C4 * (U32)PTR2UV(PL_stack_sp);
4912 #ifndef PLAN9 /* XXX Plan9 assembler chokes on this; fix needed */
4913 u += SEED_C5 * (U32)PTR2UV(&when);
4919 Perl_get_hash_seed(pTHX)
4921 const char *s = PerlEnv_getenv("PERL_HASH_SEED");
4925 while (isSPACE(*s)) s++;
4926 if (s && isDIGIT(*s))
4927 myseed = (UV)Atoul(s);
4929 #ifdef USE_HASH_SEED_EXPLICIT
4933 /* Compute a random seed */
4934 (void)seedDrand01((Rand_seed_t)seed());
4935 myseed = (UV)(Drand01() * (NV)UV_MAX);
4936 #if RANDBITS < (UVSIZE * 8)
4937 /* Since there are not enough randbits to to reach all
4938 * the bits of a UV, the low bits might need extra
4939 * help. Sum in another random number that will
4940 * fill in the low bits. */
4942 (UV)(Drand01() * (NV)((1 << ((UVSIZE * 8 - RANDBITS))) - 1));
4943 #endif /* RANDBITS < (UVSIZE * 8) */
4944 if (myseed == 0) { /* Superparanoia. */
4945 myseed = (UV)(Drand01() * (NV)UV_MAX); /* One more chance. */
4947 Perl_croak(aTHX_ "Your random numbers are not that random");
4950 PL_rehash_seed_set = TRUE;
4957 Perl_stashpv_hvname_match(pTHX_ const COP *c, const HV *hv)
4959 const char * const stashpv = CopSTASHPV(c);
4960 const char * const name = HvNAME_get(hv);
4962 if (stashpv == name)
4964 if (stashpv && name)
4965 if (strEQ(stashpv, name))
4972 #ifdef PERL_GLOBAL_STRUCT
4975 Perl_init_global_struct(pTHX)
4977 struct perl_vars *plvarsp = NULL;
4978 #ifdef PERL_GLOBAL_STRUCT
4979 # define PERL_GLOBAL_STRUCT_INIT
4980 # include "opcode.h" /* the ppaddr and check */
4981 const IV nppaddr = sizeof(Gppaddr)/sizeof(Perl_ppaddr_t);
4982 const IV ncheck = sizeof(Gcheck) /sizeof(Perl_check_t);
4983 # ifdef PERL_GLOBAL_STRUCT_PRIVATE
4984 /* PerlMem_malloc() because can't use even safesysmalloc() this early. */
4985 plvarsp = (struct perl_vars*)PerlMem_malloc(sizeof(struct perl_vars));
4989 plvarsp = PL_VarsPtr;
4990 # endif /* PERL_GLOBAL_STRUCT_PRIVATE */
4996 # define PERLVAR(var,type) /**/
4997 # define PERLVARA(var,n,type) /**/
4998 # define PERLVARI(var,type,init) plvarsp->var = init;
4999 # define PERLVARIC(var,type,init) plvarsp->var = init;
5000 # define PERLVARISC(var,init) Copy(init, plvarsp->var, sizeof(init), char);
5001 # include "perlvars.h"
5007 # ifdef PERL_GLOBAL_STRUCT
5008 plvarsp->Gppaddr = PerlMem_malloc(nppaddr * sizeof(Perl_ppaddr_t));
5009 if (!plvarsp->Gppaddr)
5011 plvarsp->Gcheck = PerlMem_malloc(ncheck * sizeof(Perl_check_t));
5012 if (!plvarsp->Gcheck)
5014 Copy(Gppaddr, plvarsp->Gppaddr, nppaddr, Perl_ppaddr_t);
5015 Copy(Gcheck, plvarsp->Gcheck, ncheck, Perl_check_t);
5017 # ifdef PERL_SET_VARS
5018 PERL_SET_VARS(plvarsp);
5020 # undef PERL_GLOBAL_STRUCT_INIT
5025 #endif /* PERL_GLOBAL_STRUCT */
5027 #ifdef PERL_GLOBAL_STRUCT
5030 Perl_free_global_struct(pTHX_ struct perl_vars *plvarsp)
5032 #ifdef PERL_GLOBAL_STRUCT
5033 # ifdef PERL_UNSET_VARS
5034 PERL_UNSET_VARS(plvarsp);
5036 free(plvarsp->Gppaddr);
5037 free(plvarsp->Gcheck);
5038 # ifdef PERL_GLOBAL_STRUCT_PRIVATE
5044 #endif /* PERL_GLOBAL_STRUCT */
5048 #define PERL_MEM_LOG_SPRINTF_BUF_SIZE 128
5051 Perl_mem_log_alloc(const UV n, const UV typesize, const char *typename, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname)
5053 #ifdef PERL_MEM_LOG_STDERR
5054 /* We can't use PerlIO for obvious reasons. */
5055 char buf[PERL_MEM_LOG_SPRINTF_BUF_SIZE];
5056 const STRLEN len = my_sprintf(buf,
5057 "alloc: %s:%d:%s: %"IVdf" %"UVuf
5058 " %s = %"IVdf": %"UVxf"\n",
5059 filename, linenumber, funcname, n, typesize,
5060 typename, n * typesize, PTR2UV(newalloc));
5061 PerlLIO_write(2, buf, len));
5067 Perl_mem_log_realloc(const UV n, const UV typesize, const char *typename, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname)
5069 #ifdef PERL_MEM_LOG_STDERR
5070 /* We can't use PerlIO for obvious reasons. */
5071 char buf[PERL_MEM_LOG_SPRINTF_BUF_SIZE];
5072 const STRLEN len = my_sprintf(buf, "realloc: %s:%d:%s: %"IVdf" %"UVuf
5073 " %s = %"IVdf": %"UVxf" -> %"UVxf"\n",
5074 filename, linenumber, funcname, n, typesize,
5075 typename, n * typesize, PTR2UV(oldalloc),
5077 PerlLIO_write(2, buf, len);
5083 Perl_mem_log_free(Malloc_t oldalloc, const char *filename, const int linenumber, const char *funcname)
5085 #ifdef PERL_MEM_LOG_STDERR
5086 /* We can't use PerlIO for obvious reasons. */
5087 char buf[PERL_MEM_LOG_SPRINTF_BUF_SIZE];
5088 const STRLEN len = my_sprintf(buf, "free: %s:%d:%s: %"UVxf"\n",
5089 filename, linenumber, funcname,
5091 PerlLIO_write(2, buf, len);
5096 #endif /* PERL_MEM_LOG */
5099 =for apidoc my_sprintf
5101 The C library C<sprintf>, wrapped if necessary, to ensure that it will return
5102 the length of the string written to the buffer. Only rare pre-ANSI systems
5103 need the wrapper function - usually this is a direct call to C<sprintf>.
5107 #ifndef SPRINTF_RETURNS_STRLEN
5109 Perl_my_sprintf(char *buffer, const char* pat, ...)
5112 va_start(args, pat);
5113 vsprintf(buffer, pat, args);
5115 return strlen(buffer);
5120 Perl_my_clearenv(pTHX)
5123 #if ! defined(PERL_MICRO)
5124 # if defined(PERL_IMPLICIT_SYS) || defined(WIN32)
5126 # else /* ! (PERL_IMPLICIT_SYS || WIN32) */
5127 # if defined(USE_ENVIRON_ARRAY)
5128 # if defined(USE_ITHREADS)
5129 /* only the parent thread can clobber the process environment */
5130 if (PL_curinterp == aTHX)
5131 # endif /* USE_ITHREADS */
5133 # if ! defined(PERL_USE_SAFE_PUTENV)
5134 if ( !PL_use_safe_putenv) {
5136 if (environ == PL_origenviron)
5137 environ = (char**)safesysmalloc(sizeof(char*));
5139 for (i = 0; environ[i]; i++)
5140 (void)safesysfree(environ[i]);
5143 # else /* PERL_USE_SAFE_PUTENV */
5144 # if defined(HAS_CLEARENV)
5146 # elif defined(HAS_UNSETENV)
5147 int bsiz = 80; /* Most envvar names will be shorter than this. */
5148 char *buf = (char*)safesysmalloc(bsiz * sizeof(char));
5149 while (*environ != NULL) {
5150 char *e = strchr(*environ, '=');
5151 int l = e ? e - *environ : strlen(*environ);
5153 (void)safesysfree(buf);
5155 buf = (char*)safesysmalloc(bsiz * sizeof(char));
5157 strncpy(buf, *environ, l);
5159 (void)unsetenv(buf);
5161 (void)safesysfree(buf);
5162 # else /* ! HAS_CLEARENV && ! HAS_UNSETENV */
5163 /* Just null environ and accept the leakage. */
5165 # endif /* HAS_CLEARENV || HAS_UNSETENV */
5166 # endif /* ! PERL_USE_SAFE_PUTENV */
5168 # endif /* USE_ENVIRON_ARRAY */
5169 # endif /* PERL_IMPLICIT_SYS || WIN32 */
5170 #endif /* PERL_MICRO */
5175 * c-indentation-style: bsd
5177 * indent-tabs-mode: t
5180 * ex: set ts=8 sts=4 sw=4 noet: