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 # include <sys/wait.h>
39 # include <sys/select.h>
45 #if defined(HAS_FCNTL) && defined(F_SETFD) && !defined(FD_CLOEXEC)
46 # define FD_CLOEXEC 1 /* NeXT needs this */
49 /* NOTE: Do not call the next three routines directly. Use the macros
50 * in handy.h, so that we can easily redefine everything to do tracking of
51 * allocated hunks back to the original New to track down any memory leaks.
52 * XXX This advice seems to be widely ignored :-( --AD August 1996.
55 /* paranoid version of system's malloc() */
58 Perl_safesysmalloc(MEM_SIZE size)
64 PerlIO_printf(Perl_error_log,
65 "Allocation too large: %lx\n", size) FLUSH;
68 #endif /* HAS_64K_LIMIT */
71 Perl_croak_nocontext("panic: malloc");
73 ptr = (Malloc_t)PerlMem_malloc(size?size:1); /* malloc(0) is NASTY on our system */
74 PERL_ALLOC_CHECK(ptr);
75 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) malloc %ld bytes\n",PTR2UV(ptr),(long)PL_an++,(long)size));
81 /* Can't use PerlIO to write as it allocates memory */
82 PerlLIO_write(PerlIO_fileno(Perl_error_log),
83 PL_no_mem, strlen(PL_no_mem));
90 /* paranoid version of system's realloc() */
93 Perl_safesysrealloc(Malloc_t where,MEM_SIZE size)
97 #if !defined(STANDARD_C) && !defined(HAS_REALLOC_PROTOTYPE) && !defined(PERL_MICRO)
98 Malloc_t PerlMem_realloc();
99 #endif /* !defined(STANDARD_C) && !defined(HAS_REALLOC_PROTOTYPE) */
103 PerlIO_printf(Perl_error_log,
104 "Reallocation too large: %lx\n", size) FLUSH;
107 #endif /* HAS_64K_LIMIT */
114 return safesysmalloc(size);
117 Perl_croak_nocontext("panic: realloc");
119 ptr = (Malloc_t)PerlMem_realloc(where,size);
120 PERL_ALLOC_CHECK(ptr);
122 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) rfree\n",PTR2UV(where),(long)PL_an++));
123 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) realloc %ld bytes\n",PTR2UV(ptr),(long)PL_an++,(long)size));
130 /* Can't use PerlIO to write as it allocates memory */
131 PerlLIO_write(PerlIO_fileno(Perl_error_log),
132 PL_no_mem, strlen(PL_no_mem));
139 /* safe version of system's free() */
142 Perl_safesysfree(Malloc_t where)
144 #ifdef PERL_IMPLICIT_SYS
147 DEBUG_m( PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) free\n",PTR2UV(where),(long)PL_an++));
154 /* safe version of system's calloc() */
157 Perl_safesyscalloc(MEM_SIZE count, MEM_SIZE size)
163 if (size * count > 0xffff) {
164 PerlIO_printf(Perl_error_log,
165 "Allocation too large: %lx\n", size * count) FLUSH;
168 #endif /* HAS_64K_LIMIT */
170 if ((long)size < 0 || (long)count < 0)
171 Perl_croak_nocontext("panic: calloc");
174 ptr = (Malloc_t)PerlMem_malloc(size?size:1); /* malloc(0) is NASTY on our system */
175 PERL_ALLOC_CHECK(ptr);
176 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));
178 memset((void*)ptr, 0, size);
184 /* Can't use PerlIO to write as it allocates memory */
185 PerlLIO_write(PerlIO_fileno(Perl_error_log),
186 PL_no_mem, strlen(PL_no_mem));
193 /* These must be defined when not using Perl's malloc for binary
198 Malloc_t Perl_malloc (MEM_SIZE nbytes)
201 return (Malloc_t)PerlMem_malloc(nbytes);
204 Malloc_t Perl_calloc (MEM_SIZE elements, MEM_SIZE size)
207 return (Malloc_t)PerlMem_calloc(elements, size);
210 Malloc_t Perl_realloc (Malloc_t where, MEM_SIZE nbytes)
213 return (Malloc_t)PerlMem_realloc(where, nbytes);
216 Free_t Perl_mfree (Malloc_t where)
224 /* copy a string up to some (non-backslashed) delimiter, if any */
227 Perl_delimcpy(pTHX_ register char *to, register char *toend, register char *from, register char *fromend, register int delim, I32 *retlen)
230 for (tolen = 0; from < fromend; from++, tolen++) {
232 if (from[1] == delim)
241 else if (*from == delim)
252 /* return ptr to little string in big string, NULL if not found */
253 /* This routine was donated by Corey Satten. */
256 Perl_instr(pTHX_ register const char *big, register const char *little)
258 register const char *s, *x;
269 for (x=big,s=little; *s; /**/ ) {
278 return (char*)(big-1);
283 /* same as instr but allow embedded nulls */
286 Perl_ninstr(pTHX_ register const char *big, register const char *bigend, const char *little, const char *lend)
288 register const char *s, *x;
289 register I32 first = *little;
290 register const char *littleend = lend;
292 if (!first && little >= littleend)
294 if (bigend - big < littleend - little)
296 bigend -= littleend - little++;
297 while (big <= bigend) {
300 for (x=big,s=little; s < littleend; /**/ ) {
307 return (char*)(big-1);
312 /* reverse of the above--find last substring */
315 Perl_rninstr(pTHX_ register const char *big, const char *bigend, const char *little, const char *lend)
317 register const char *bigbeg;
318 register const char *s, *x;
319 register I32 first = *little;
320 register const char *littleend = lend;
322 if (!first && little >= littleend)
323 return (char*)bigend;
325 big = bigend - (littleend - little++);
326 while (big >= bigbeg) {
329 for (x=big+2,s=little; s < littleend; /**/ ) {
336 return (char*)(big+1);
341 #define FBM_TABLE_OFFSET 2 /* Number of bytes between EOS and table*/
343 /* As a space optimization, we do not compile tables for strings of length
344 0 and 1, and for strings of length 2 unless FBMcf_TAIL. These are
345 special-cased in fbm_instr().
347 If FBMcf_TAIL, the table is created as if the string has a trailing \n. */
350 =head1 Miscellaneous Functions
352 =for apidoc fbm_compile
354 Analyses the string in order to make fast searches on it using fbm_instr()
355 -- the Boyer-Moore algorithm.
361 Perl_fbm_compile(pTHX_ SV *sv, U32 flags)
370 if (flags & FBMcf_TAIL) {
371 MAGIC *mg = SvUTF8(sv) && SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_utf8) : NULL;
372 sv_catpvn(sv, "\n", 1); /* Taken into account in fbm_instr() */
373 if (mg && mg->mg_len >= 0)
376 s = (U8*)SvPV_force(sv, len);
377 (void)SvUPGRADE(sv, SVt_PVBM);
378 if (len == 0) /* TAIL might be on a zero-length string. */
388 Sv_Grow(sv, len + 256 + FBM_TABLE_OFFSET);
389 table = (unsigned char*)(SvPVX(sv) + len + FBM_TABLE_OFFSET);
390 s = table - 1 - FBM_TABLE_OFFSET; /* last char */
391 memset((void*)table, mlen, 256);
392 table[-1] = (U8)flags;
394 sb = s - mlen + 1; /* first char (maybe) */
396 if (table[*s] == mlen)
401 sv_magic(sv, Nullsv, PERL_MAGIC_bm, Nullch, 0); /* deep magic */
404 s = (unsigned char*)(SvPVX(sv)); /* deeper magic */
405 for (i = 0; i < len; i++) {
406 if (PL_freq[s[i]] < frequency) {
408 frequency = PL_freq[s[i]];
411 BmRARE(sv) = s[rarest];
412 BmPREVIOUS(sv) = (U16)rarest;
413 BmUSEFUL(sv) = 100; /* Initial value */
414 if (flags & FBMcf_TAIL)
416 DEBUG_r(PerlIO_printf(Perl_debug_log, "rarest char %c at %d\n",
417 BmRARE(sv),BmPREVIOUS(sv)));
420 /* If SvTAIL(littlestr), it has a fake '\n' at end. */
421 /* If SvTAIL is actually due to \Z or \z, this gives false positives
425 =for apidoc fbm_instr
427 Returns the location of the SV in the string delimited by C<str> and
428 C<strend>. It returns C<Nullch> if the string can't be found. The C<sv>
429 does not have to be fbm_compiled, but the search will not be as fast
436 Perl_fbm_instr(pTHX_ unsigned char *big, register unsigned char *bigend, SV *littlestr, U32 flags)
438 register unsigned char *s;
440 register unsigned char *little = (unsigned char *)SvPV(littlestr,l);
441 register STRLEN littlelen = l;
442 register I32 multiline = flags & FBMrf_MULTILINE;
444 if ((STRLEN)(bigend - big) < littlelen) {
445 if ( SvTAIL(littlestr)
446 && ((STRLEN)(bigend - big) == littlelen - 1)
448 || (*big == *little &&
449 memEQ((char *)big, (char *)little, littlelen - 1))))
454 if (littlelen <= 2) { /* Special-cased */
456 if (littlelen == 1) {
457 if (SvTAIL(littlestr) && !multiline) { /* Anchor only! */
458 /* Know that bigend != big. */
459 if (bigend[-1] == '\n')
460 return (char *)(bigend - 1);
461 return (char *) bigend;
469 if (SvTAIL(littlestr))
470 return (char *) bigend;
474 return (char*)big; /* Cannot be SvTAIL! */
477 if (SvTAIL(littlestr) && !multiline) {
478 if (bigend[-1] == '\n' && bigend[-2] == *little)
479 return (char*)bigend - 2;
480 if (bigend[-1] == *little)
481 return (char*)bigend - 1;
485 /* This should be better than FBM if c1 == c2, and almost
486 as good otherwise: maybe better since we do less indirection.
487 And we save a lot of memory by caching no table. */
488 register unsigned char c1 = little[0];
489 register unsigned char c2 = little[1];
494 while (s <= bigend) {
504 goto check_1char_anchor;
515 goto check_1char_anchor;
518 while (s <= bigend) {
523 goto check_1char_anchor;
532 check_1char_anchor: /* One char and anchor! */
533 if (SvTAIL(littlestr) && (*bigend == *little))
534 return (char *)bigend; /* bigend is already decremented. */
537 if (SvTAIL(littlestr) && !multiline) { /* tail anchored? */
538 s = bigend - littlelen;
539 if (s >= big && bigend[-1] == '\n' && *s == *little
540 /* Automatically of length > 2 */
541 && memEQ((char*)s + 1, (char*)little + 1, littlelen - 2))
543 return (char*)s; /* how sweet it is */
546 && memEQ((char*)s + 2, (char*)little + 1, littlelen - 2))
548 return (char*)s + 1; /* how sweet it is */
552 if (SvTYPE(littlestr) != SVt_PVBM || !SvVALID(littlestr)) {
553 char *b = ninstr((char*)big,(char*)bigend,
554 (char*)little, (char*)little + littlelen);
556 if (!b && SvTAIL(littlestr)) { /* Automatically multiline! */
557 /* Chop \n from littlestr: */
558 s = bigend - littlelen + 1;
560 && memEQ((char*)s + 1, (char*)little + 1, littlelen - 2))
569 { /* Do actual FBM. */
570 register unsigned char *table = little + littlelen + FBM_TABLE_OFFSET;
571 register unsigned char *oldlittle;
573 if (littlelen > (STRLEN)(bigend - big))
575 --littlelen; /* Last char found by table lookup */
578 little += littlelen; /* last char */
585 if ((tmp = table[*s])) {
586 if ((s += tmp) < bigend)
590 else { /* less expensive than calling strncmp() */
591 register unsigned char *olds = s;
596 if (*--s == *--little)
598 s = olds + 1; /* here we pay the price for failure */
600 if (s < bigend) /* fake up continue to outer loop */
608 if ( s == bigend && (table[-1] & FBMcf_TAIL)
609 && memEQ((char *)(bigend - littlelen),
610 (char *)(oldlittle - littlelen), littlelen) )
611 return (char*)bigend - littlelen;
616 /* start_shift, end_shift are positive quantities which give offsets
617 of ends of some substring of bigstr.
618 If `last' we want the last occurrence.
619 old_posp is the way of communication between consequent calls if
620 the next call needs to find the .
621 The initial *old_posp should be -1.
623 Note that we take into account SvTAIL, so one can get extra
624 optimizations if _ALL flag is set.
627 /* If SvTAIL is actually due to \Z or \z, this gives false positives
628 if PL_multiline. In fact if !PL_multiline the authoritative answer
629 is not supported yet. */
632 Perl_screaminstr(pTHX_ SV *bigstr, SV *littlestr, I32 start_shift, I32 end_shift, I32 *old_posp, I32 last)
634 register unsigned char *s, *x;
635 register unsigned char *big;
637 register I32 previous;
639 register unsigned char *little;
640 register I32 stop_pos;
641 register unsigned char *littleend;
645 ? (pos = PL_screamfirst[BmRARE(littlestr)]) < 0
646 : (((pos = *old_posp), pos += PL_screamnext[pos]) == 0)) {
648 if ( BmRARE(littlestr) == '\n'
649 && BmPREVIOUS(littlestr) == SvCUR(littlestr) - 1) {
650 little = (unsigned char *)(SvPVX(littlestr));
651 littleend = little + SvCUR(littlestr);
658 little = (unsigned char *)(SvPVX(littlestr));
659 littleend = little + SvCUR(littlestr);
661 /* The value of pos we can start at: */
662 previous = BmPREVIOUS(littlestr);
663 big = (unsigned char *)(SvPVX(bigstr));
664 /* The value of pos we can stop at: */
665 stop_pos = SvCUR(bigstr) - end_shift - (SvCUR(littlestr) - 1 - previous);
666 if (previous + start_shift > stop_pos) {
668 stop_pos does not include SvTAIL in the count, so this check is incorrect
669 (I think) - see [ID 20010618.006] and t/op/study.t. HVDS 2001/06/19
672 if (previous + start_shift == stop_pos + 1) /* A fake '\n'? */
677 while (pos < previous + start_shift) {
678 if (!(pos += PL_screamnext[pos]))
683 if (pos >= stop_pos) break;
684 if (big[pos] != first)
686 for (x=big+pos+1,s=little; s < littleend; /**/ ) {
692 if (s == littleend) {
694 if (!last) return (char *)(big+pos);
697 } while ( pos += PL_screamnext[pos] );
699 return (char *)(big+(*old_posp));
701 if (!SvTAIL(littlestr) || (end_shift > 0))
703 /* Ignore the trailing "\n". This code is not microoptimized */
704 big = (unsigned char *)(SvPVX(bigstr) + SvCUR(bigstr));
705 stop_pos = littleend - little; /* Actual littlestr len */
710 && ((stop_pos == 1) ||
711 memEQ((char *)(big + 1), (char *)little, stop_pos - 1)))
717 Perl_ibcmp(pTHX_ const char *s1, const char *s2, register I32 len)
719 register U8 *a = (U8 *)s1;
720 register U8 *b = (U8 *)s2;
722 if (*a != *b && *a != PL_fold[*b])
730 Perl_ibcmp_locale(pTHX_ const char *s1, const char *s2, register I32 len)
732 register U8 *a = (U8 *)s1;
733 register U8 *b = (U8 *)s2;
735 if (*a != *b && *a != PL_fold_locale[*b])
742 /* copy a string to a safe spot */
745 =head1 Memory Management
749 Perl's version of C<strdup()>. Returns a pointer to a newly allocated
750 string which is a duplicate of C<pv>. The size of the string is
751 determined by C<strlen()>. The memory allocated for the new string can
752 be freed with the C<Safefree()> function.
758 Perl_savepv(pTHX_ const char *pv)
760 register char *newaddr;
764 New(902,newaddr,strlen(pv)+1,char);
765 return strcpy(newaddr,pv);
768 /* same thing but with a known length */
773 Perl's version of what C<strndup()> would be if it existed. Returns a
774 pointer to a newly allocated string which is a duplicate of the first
775 C<len> bytes from C<pv>. The memory allocated for the new string can be
776 freed with the C<Safefree()> function.
782 Perl_savepvn(pTHX_ const char *pv, register I32 len)
784 register char *newaddr;
786 New(903,newaddr,len+1,char);
787 /* Give a meaning to NULL pointer mainly for the use in sv_magic() */
789 /* might not be null terminated */
791 return CopyD(pv,newaddr,len,char);
794 return ZeroD(newaddr,len+1,char);
799 =for apidoc savesharedpv
801 A version of C<savepv()> which allocates the duplicate string in memory
802 which is shared between threads.
807 Perl_savesharedpv(pTHX_ const char *pv)
809 register char *newaddr;
813 newaddr = (char*)PerlMemShared_malloc(strlen(pv)+1);
815 PerlLIO_write(PerlIO_fileno(Perl_error_log),
816 PL_no_mem, strlen(PL_no_mem));
819 return strcpy(newaddr,pv);
825 A version of C<savepv()>/C<savepvn()> which gets the string to duplicate from
826 the passed in SV using C<SvPV()>
832 Perl_savesvpv(pTHX_ SV *sv)
835 const char *pv = SvPV(sv, len);
836 register char *newaddr;
838 New(903,newaddr,++len,char);
839 return CopyD(pv,newaddr,len,char);
843 /* the SV for Perl_form() and mess() is not kept in an arena */
852 return sv_2mortal(newSVpvn("",0));
857 /* Create as PVMG now, to avoid any upgrading later */
859 Newz(905, any, 1, XPVMG);
860 SvFLAGS(sv) = SVt_PVMG;
861 SvANY(sv) = (void*)any;
862 SvREFCNT(sv) = 1 << 30; /* practically infinite */
867 #if defined(PERL_IMPLICIT_CONTEXT)
869 Perl_form_nocontext(const char* pat, ...)
875 retval = vform(pat, &args);
879 #endif /* PERL_IMPLICIT_CONTEXT */
882 =head1 Miscellaneous Functions
885 Takes a sprintf-style format pattern and conventional
886 (non-SV) arguments and returns the formatted string.
888 (char *) Perl_form(pTHX_ const char* pat, ...)
890 can be used any place a string (char *) is required:
892 char * s = Perl_form("%d.%d",major,minor);
894 Uses a single private buffer so if you want to format several strings you
895 must explicitly copy the earlier strings away (and free the copies when you
902 Perl_form(pTHX_ const char* pat, ...)
907 retval = vform(pat, &args);
913 Perl_vform(pTHX_ const char *pat, va_list *args)
915 SV *sv = mess_alloc();
916 sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
920 #if defined(PERL_IMPLICIT_CONTEXT)
922 Perl_mess_nocontext(const char *pat, ...)
928 retval = vmess(pat, &args);
932 #endif /* PERL_IMPLICIT_CONTEXT */
935 Perl_mess(pTHX_ const char *pat, ...)
940 retval = vmess(pat, &args);
946 S_closest_cop(pTHX_ COP *cop, OP *o)
948 /* Look for PL_op starting from o. cop is the last COP we've seen. */
950 if (!o || o == PL_op) return cop;
952 if (o->op_flags & OPf_KIDS) {
954 for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling)
958 /* If the OP_NEXTSTATE has been optimised away we can still use it
959 * the get the file and line number. */
961 if (kid->op_type == OP_NULL && kid->op_targ == OP_NEXTSTATE)
964 /* Keep searching, and return when we've found something. */
966 new_cop = closest_cop(cop, kid);
967 if (new_cop) return new_cop;
977 Perl_vmess(pTHX_ const char *pat, va_list *args)
979 SV *sv = mess_alloc();
980 static char dgd[] = " during global destruction.\n";
983 sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
984 if (!SvCUR(sv) || *(SvEND(sv) - 1) != '\n') {
987 * Try and find the file and line for PL_op. This will usually be
988 * PL_curcop, but it might be a cop that has been optimised away. We
989 * can try to find such a cop by searching through the optree starting
990 * from the sibling of PL_curcop.
993 cop = closest_cop(PL_curcop, PL_curcop->op_sibling);
994 if (!cop) cop = PL_curcop;
997 Perl_sv_catpvf(aTHX_ sv, " at %s line %"IVdf,
998 OutCopFILE(cop), (IV)CopLINE(cop));
999 if (GvIO(PL_last_in_gv) && IoLINES(GvIOp(PL_last_in_gv))) {
1000 bool line_mode = (RsSIMPLE(PL_rs) &&
1001 SvCUR(PL_rs) == 1 && *SvPVX(PL_rs) == '\n');
1002 Perl_sv_catpvf(aTHX_ sv, ", <%s> %s %"IVdf,
1003 PL_last_in_gv == PL_argvgv ?
1004 "" : GvNAME(PL_last_in_gv),
1005 line_mode ? "line" : "chunk",
1006 (IV)IoLINES(GvIOp(PL_last_in_gv)));
1008 sv_catpv(sv, PL_dirty ? dgd : ".\n");
1014 Perl_write_to_stderr(pTHX_ const char* message, int msglen)
1019 if (PL_stderrgv && SvREFCNT(PL_stderrgv)
1020 && (io = GvIO(PL_stderrgv))
1021 && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar)))
1028 SAVESPTR(PL_stderrgv);
1029 PL_stderrgv = Nullgv;
1031 PUSHSTACKi(PERLSI_MAGIC);
1035 PUSHs(SvTIED_obj((SV*)io, mg));
1036 PUSHs(sv_2mortal(newSVpvn(message, msglen)));
1038 call_method("PRINT", G_SCALAR);
1046 /* SFIO can really mess with your errno */
1049 PerlIO *serr = Perl_error_log;
1051 PERL_WRITE_MSG_TO_CONSOLE(serr, message, msglen);
1052 (void)PerlIO_flush(serr);
1059 /* Common code used by vcroak, vdie and vwarner */
1061 void S_vdie_common(pTHX_ const char *message, STRLEN msglen, I32 utf8);
1064 S_vdie_croak_common(pTHX_ const char* pat, va_list* args, STRLEN* msglen,
1070 SV *msv = vmess(pat, args);
1071 if (PL_errors && SvCUR(PL_errors)) {
1072 sv_catsv(PL_errors, msv);
1073 message = SvPV(PL_errors, *msglen);
1074 SvCUR_set(PL_errors, 0);
1077 message = SvPV(msv,*msglen);
1078 *utf8 = SvUTF8(msv);
1084 DEBUG_S(PerlIO_printf(Perl_debug_log,
1085 "%p: die/croak: message = %s\ndiehook = %p\n",
1086 thr, message, PL_diehook));
1088 S_vdie_common(aTHX_ message, *msglen, *utf8);
1094 S_vdie_common(pTHX_ const char *message, STRLEN msglen, I32 utf8)
1099 /* sv_2cv might call Perl_croak() */
1100 SV *olddiehook = PL_diehook;
1104 SAVESPTR(PL_diehook);
1105 PL_diehook = Nullsv;
1106 cv = sv_2cv(olddiehook, &stash, &gv, 0);
1108 if (cv && !CvDEPTH(cv) && (CvROOT(cv) || CvXSUB(cv))) {
1115 msg = newSVpvn(message, msglen);
1116 SvFLAGS(msg) |= utf8;
1124 PUSHSTACKi(PERLSI_DIEHOOK);
1128 call_sv((SV*)cv, G_DISCARD);
1135 Perl_vdie(pTHX_ const char* pat, va_list *args)
1138 int was_in_eval = PL_in_eval;
1142 DEBUG_S(PerlIO_printf(Perl_debug_log,
1143 "%p: die: curstack = %p, mainstack = %p\n",
1144 thr, PL_curstack, PL_mainstack));
1146 message = S_vdie_croak_common(aTHX_ pat, args, &msglen, &utf8);
1148 PL_restartop = die_where(message, msglen);
1149 SvFLAGS(ERRSV) |= utf8;
1150 DEBUG_S(PerlIO_printf(Perl_debug_log,
1151 "%p: die: restartop = %p, was_in_eval = %d, top_env = %p\n",
1152 thr, PL_restartop, was_in_eval, PL_top_env));
1153 if ((!PL_restartop && was_in_eval) || PL_top_env->je_prev)
1155 return PL_restartop;
1158 #if defined(PERL_IMPLICIT_CONTEXT)
1160 Perl_die_nocontext(const char* pat, ...)
1165 va_start(args, pat);
1166 o = vdie(pat, &args);
1170 #endif /* PERL_IMPLICIT_CONTEXT */
1173 Perl_die(pTHX_ const char* pat, ...)
1177 va_start(args, pat);
1178 o = vdie(pat, &args);
1184 Perl_vcroak(pTHX_ const char* pat, va_list *args)
1190 message = S_vdie_croak_common(aTHX_ pat, args, &msglen, &utf8);
1193 PL_restartop = die_where(message, msglen);
1194 SvFLAGS(ERRSV) |= utf8;
1198 message = SvPVx(ERRSV, msglen);
1200 write_to_stderr(message, msglen);
1204 #if defined(PERL_IMPLICIT_CONTEXT)
1206 Perl_croak_nocontext(const char *pat, ...)
1210 va_start(args, pat);
1215 #endif /* PERL_IMPLICIT_CONTEXT */
1218 =head1 Warning and Dieing
1222 This is the XSUB-writer's interface to Perl's C<die> function.
1223 Normally call this function the same way you call the C C<printf>
1224 function. Calling C<croak> returns control directly to Perl,
1225 sidestepping the normal C order of execution. See C<warn>.
1227 If you want to throw an exception object, assign the object to
1228 C<$@> and then pass C<Nullch> to croak():
1230 errsv = get_sv("@", TRUE);
1231 sv_setsv(errsv, exception_object);
1238 Perl_croak(pTHX_ const char *pat, ...)
1241 va_start(args, pat);
1248 Perl_vwarn(pTHX_ const char* pat, va_list *args)
1258 msv = vmess(pat, args);
1260 message = SvPV(msv, msglen);
1263 /* sv_2cv might call Perl_warn() */
1264 SV *oldwarnhook = PL_warnhook;
1266 SAVESPTR(PL_warnhook);
1267 PL_warnhook = Nullsv;
1268 cv = sv_2cv(oldwarnhook, &stash, &gv, 0);
1270 if (cv && !CvDEPTH(cv) && (CvROOT(cv) || CvXSUB(cv))) {
1276 msg = newSVpvn(message, msglen);
1277 SvFLAGS(msg) |= utf8;
1281 PUSHSTACKi(PERLSI_WARNHOOK);
1285 call_sv((SV*)cv, G_DISCARD);
1292 write_to_stderr(message, msglen);
1295 #if defined(PERL_IMPLICIT_CONTEXT)
1297 Perl_warn_nocontext(const char *pat, ...)
1301 va_start(args, pat);
1305 #endif /* PERL_IMPLICIT_CONTEXT */
1310 This is the XSUB-writer's interface to Perl's C<warn> function. Call this
1311 function the same way you call the C C<printf> function. See C<croak>.
1317 Perl_warn(pTHX_ const char *pat, ...)
1320 va_start(args, pat);
1325 #if defined(PERL_IMPLICIT_CONTEXT)
1327 Perl_warner_nocontext(U32 err, const char *pat, ...)
1331 va_start(args, pat);
1332 vwarner(err, pat, &args);
1335 #endif /* PERL_IMPLICIT_CONTEXT */
1338 Perl_warner(pTHX_ U32 err, const char* pat,...)
1341 va_start(args, pat);
1342 vwarner(err, pat, &args);
1347 Perl_vwarner(pTHX_ U32 err, const char* pat, va_list* args)
1350 SV *msv = vmess(pat, args);
1352 char *message = SvPV(msv, msglen);
1353 I32 utf8 = SvUTF8(msv);
1357 S_vdie_common(aTHX_ message, msglen, utf8);
1360 PL_restartop = die_where(message, msglen);
1361 SvFLAGS(ERRSV) |= utf8;
1364 write_to_stderr(message, msglen);
1368 Perl_vwarn(aTHX_ pat, args);
1372 /* since we've already done strlen() for both nam and val
1373 * we can use that info to make things faster than
1374 * sprintf(s, "%s=%s", nam, val)
1376 #define my_setenv_format(s, nam, nlen, val, vlen) \
1377 Copy(nam, s, nlen, char); \
1379 Copy(val, s+(nlen+1), vlen, char); \
1380 *(s+(nlen+1+vlen)) = '\0'
1382 #ifdef USE_ENVIRON_ARRAY
1383 /* VMS' my_setenv() is in vms.c */
1384 #if !defined(WIN32) && !defined(NETWARE)
1386 Perl_my_setenv(pTHX_ char *nam, char *val)
1389 /* only parent thread can modify process environment */
1390 if (PL_curinterp == aTHX)
1393 #ifndef PERL_USE_SAFE_PUTENV
1394 if (!PL_use_safe_putenv) {
1395 /* most putenv()s leak, so we manipulate environ directly */
1396 register I32 i=setenv_getix(nam); /* where does it go? */
1399 if (environ == PL_origenviron) { /* need we copy environment? */
1405 for (max = i; environ[max]; max++) ;
1406 tmpenv = (char**)safesysmalloc((max+2) * sizeof(char*));
1407 for (j=0; j<max; j++) { /* copy environment */
1408 int len = strlen(environ[j]);
1409 tmpenv[j] = (char*)safesysmalloc((len+1)*sizeof(char));
1410 Copy(environ[j], tmpenv[j], len+1, char);
1412 tmpenv[max] = Nullch;
1413 environ = tmpenv; /* tell exec where it is now */
1416 safesysfree(environ[i]);
1417 while (environ[i]) {
1418 environ[i] = environ[i+1];
1423 if (!environ[i]) { /* does not exist yet */
1424 environ = (char**)safesysrealloc(environ, (i+2) * sizeof(char*));
1425 environ[i+1] = Nullch; /* make sure it's null terminated */
1428 safesysfree(environ[i]);
1432 environ[i] = (char*)safesysmalloc((nlen+vlen+2) * sizeof(char));
1433 /* all that work just for this */
1434 my_setenv_format(environ[i], nam, nlen, val, vlen);
1437 # if defined(__CYGWIN__) || defined( EPOC)
1438 setenv(nam, val, 1);
1441 int nlen = strlen(nam), vlen;
1446 new_env = (char*)safesysmalloc((nlen + vlen + 2) * sizeof(char));
1447 /* all that work just for this */
1448 my_setenv_format(new_env, nam, nlen, val, vlen);
1449 (void)putenv(new_env);
1450 # endif /* __CYGWIN__ */
1451 #ifndef PERL_USE_SAFE_PUTENV
1457 #else /* WIN32 || NETWARE */
1460 Perl_my_setenv(pTHX_ char *nam,char *val)
1462 register char *envstr;
1463 int nlen = strlen(nam), vlen;
1469 New(904, envstr, nlen+vlen+2, char);
1470 my_setenv_format(envstr, nam, nlen, val, vlen);
1471 (void)PerlEnv_putenv(envstr);
1475 #endif /* WIN32 || NETWARE */
1479 Perl_setenv_getix(pTHX_ char *nam)
1481 register I32 i, len = strlen(nam);
1483 for (i = 0; environ[i]; i++) {
1486 strnicmp(environ[i],nam,len) == 0
1488 strnEQ(environ[i],nam,len)
1490 && environ[i][len] == '=')
1491 break; /* strnEQ must come first to avoid */
1492 } /* potential SEGV's */
1495 #endif /* !PERL_MICRO */
1497 #endif /* !VMS && !EPOC*/
1499 #ifdef UNLINK_ALL_VERSIONS
1501 Perl_unlnk(pTHX_ char *f) /* unlink all versions of a file */
1505 for (i = 0; PerlLIO_unlink(f) >= 0; i++) ;
1510 /* this is a drop-in replacement for bcopy() */
1511 #if (!defined(HAS_MEMCPY) && !defined(HAS_BCOPY)) || (!defined(HAS_MEMMOVE) && !defined(HAS_SAFE_MEMCPY) && !defined(HAS_SAFE_BCOPY))
1513 Perl_my_bcopy(register const char *from,register char *to,register I32 len)
1517 if (from - to >= 0) {
1525 *(--to) = *(--from);
1531 /* this is a drop-in replacement for memset() */
1534 Perl_my_memset(register char *loc, register I32 ch, register I32 len)
1544 /* this is a drop-in replacement for bzero() */
1545 #if !defined(HAS_BZERO) && !defined(HAS_MEMSET)
1547 Perl_my_bzero(register char *loc, register I32 len)
1557 /* this is a drop-in replacement for memcmp() */
1558 #if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP)
1560 Perl_my_memcmp(const char *s1, const char *s2, register I32 len)
1562 register U8 *a = (U8 *)s1;
1563 register U8 *b = (U8 *)s2;
1567 if (tmp = *a++ - *b++)
1572 #endif /* !HAS_MEMCMP || !HAS_SANE_MEMCMP */
1576 #ifdef USE_CHAR_VSPRINTF
1581 vsprintf(char *dest, const char *pat, char *args)
1585 fakebuf._ptr = dest;
1586 fakebuf._cnt = 32767;
1590 fakebuf._flag = _IOWRT|_IOSTRG;
1591 _doprnt(pat, args, &fakebuf); /* what a kludge */
1592 (void)putc('\0', &fakebuf);
1593 #ifdef USE_CHAR_VSPRINTF
1596 return 0; /* perl doesn't use return value */
1600 #endif /* HAS_VPRINTF */
1603 #if BYTEORDER != 0x4321
1605 Perl_my_swap(pTHX_ short s)
1607 #if (BYTEORDER & 1) == 0
1610 result = ((s & 255) << 8) + ((s >> 8) & 255);
1618 Perl_my_htonl(pTHX_ long l)
1622 char c[sizeof(long)];
1625 #if BYTEORDER == 0x1234
1626 u.c[0] = (l >> 24) & 255;
1627 u.c[1] = (l >> 16) & 255;
1628 u.c[2] = (l >> 8) & 255;
1632 #if ((BYTEORDER - 0x1111) & 0x444) || !(BYTEORDER & 0xf)
1633 Perl_croak(aTHX_ "Unknown BYTEORDER\n");
1638 for (o = BYTEORDER - 0x1111, s = 0; s < (sizeof(long)*8); o >>= 4, s += 8) {
1639 u.c[o & 0xf] = (l >> s) & 255;
1647 Perl_my_ntohl(pTHX_ long l)
1651 char c[sizeof(long)];
1654 #if BYTEORDER == 0x1234
1655 u.c[0] = (l >> 24) & 255;
1656 u.c[1] = (l >> 16) & 255;
1657 u.c[2] = (l >> 8) & 255;
1661 #if ((BYTEORDER - 0x1111) & 0x444) || !(BYTEORDER & 0xf)
1662 Perl_croak(aTHX_ "Unknown BYTEORDER\n");
1669 for (o = BYTEORDER - 0x1111, s = 0; s < (sizeof(long)*8); o >>= 4, s += 8) {
1670 l |= (u.c[o & 0xf] & 255) << s;
1677 #endif /* BYTEORDER != 0x4321 */
1681 * Little-endian byte order functions - 'v' for 'VAX', or 'reVerse'.
1682 * If these functions are defined,
1683 * the BYTEORDER is neither 0x1234 nor 0x4321.
1684 * However, this is not assumed.
1688 #define HTOLE(name,type) \
1690 name (register type n) \
1694 char c[sizeof(type)]; \
1697 register I32 s = 0; \
1698 for (i = 0; i < sizeof(u.c); i++, s += 8) { \
1699 u.c[i] = (n >> s) & 0xFF; \
1704 #define LETOH(name,type) \
1706 name (register type n) \
1710 char c[sizeof(type)]; \
1713 register I32 s = 0; \
1716 for (i = 0; i < sizeof(u.c); i++, s += 8) { \
1717 n |= ((type)(u.c[i] & 0xFF)) << s; \
1723 * Big-endian byte order functions.
1726 #define HTOBE(name,type) \
1728 name (register type n) \
1732 char c[sizeof(type)]; \
1735 register I32 s = 8*(sizeof(u.c)-1); \
1736 for (i = 0; i < sizeof(u.c); i++, s -= 8) { \
1737 u.c[i] = (n >> s) & 0xFF; \
1742 #define BETOH(name,type) \
1744 name (register type n) \
1748 char c[sizeof(type)]; \
1751 register I32 s = 8*(sizeof(u.c)-1); \
1754 for (i = 0; i < sizeof(u.c); i++, s -= 8) { \
1755 n |= ((type)(u.c[i] & 0xFF)) << s; \
1761 * If we just can't do it...
1764 #define NOT_AVAIL(name,type) \
1766 name (register type n) \
1768 Perl_croak_nocontext(#name "() not available"); \
1769 return n; /* not reached */ \
1773 #if defined(HAS_HTOVS) && !defined(htovs)
1776 #if defined(HAS_HTOVL) && !defined(htovl)
1779 #if defined(HAS_VTOHS) && !defined(vtohs)
1782 #if defined(HAS_VTOHL) && !defined(vtohl)
1786 #ifdef PERL_NEED_MY_HTOLE16
1788 HTOLE(Perl_my_htole16,U16)
1790 NOT_AVAIL(Perl_my_htole16,U16)
1793 #ifdef PERL_NEED_MY_LETOH16
1795 LETOH(Perl_my_letoh16,U16)
1797 NOT_AVAIL(Perl_my_letoh16,U16)
1800 #ifdef PERL_NEED_MY_HTOBE16
1802 HTOBE(Perl_my_htobe16,U16)
1804 NOT_AVAIL(Perl_my_htobe16,U16)
1807 #ifdef PERL_NEED_MY_BETOH16
1809 BETOH(Perl_my_betoh16,U16)
1811 NOT_AVAIL(Perl_my_betoh16,U16)
1815 #ifdef PERL_NEED_MY_HTOLE32
1817 HTOLE(Perl_my_htole32,U32)
1819 NOT_AVAIL(Perl_my_htole32,U32)
1822 #ifdef PERL_NEED_MY_LETOH32
1824 LETOH(Perl_my_letoh32,U32)
1826 NOT_AVAIL(Perl_my_letoh32,U32)
1829 #ifdef PERL_NEED_MY_HTOBE32
1831 HTOBE(Perl_my_htobe32,U32)
1833 NOT_AVAIL(Perl_my_htobe32,U32)
1836 #ifdef PERL_NEED_MY_BETOH32
1838 BETOH(Perl_my_betoh32,U32)
1840 NOT_AVAIL(Perl_my_betoh32,U32)
1844 #ifdef PERL_NEED_MY_HTOLE64
1846 HTOLE(Perl_my_htole64,U64)
1848 NOT_AVAIL(Perl_my_htole64,U64)
1851 #ifdef PERL_NEED_MY_LETOH64
1853 LETOH(Perl_my_letoh64,U64)
1855 NOT_AVAIL(Perl_my_letoh64,U64)
1858 #ifdef PERL_NEED_MY_HTOBE64
1860 HTOBE(Perl_my_htobe64,U64)
1862 NOT_AVAIL(Perl_my_htobe64,U64)
1865 #ifdef PERL_NEED_MY_BETOH64
1867 BETOH(Perl_my_betoh64,U64)
1869 NOT_AVAIL(Perl_my_betoh64,U64)
1873 #ifdef PERL_NEED_MY_HTOLES
1874 HTOLE(Perl_my_htoles,short)
1876 #ifdef PERL_NEED_MY_LETOHS
1877 LETOH(Perl_my_letohs,short)
1879 #ifdef PERL_NEED_MY_HTOBES
1880 HTOBE(Perl_my_htobes,short)
1882 #ifdef PERL_NEED_MY_BETOHS
1883 BETOH(Perl_my_betohs,short)
1886 #ifdef PERL_NEED_MY_HTOLEI
1887 HTOLE(Perl_my_htolei,int)
1889 #ifdef PERL_NEED_MY_LETOHI
1890 LETOH(Perl_my_letohi,int)
1892 #ifdef PERL_NEED_MY_HTOBEI
1893 HTOBE(Perl_my_htobei,int)
1895 #ifdef PERL_NEED_MY_BETOHI
1896 BETOH(Perl_my_betohi,int)
1899 #ifdef PERL_NEED_MY_HTOLEL
1900 HTOLE(Perl_my_htolel,long)
1902 #ifdef PERL_NEED_MY_LETOHL
1903 LETOH(Perl_my_letohl,long)
1905 #ifdef PERL_NEED_MY_HTOBEL
1906 HTOBE(Perl_my_htobel,long)
1908 #ifdef PERL_NEED_MY_BETOHL
1909 BETOH(Perl_my_betohl,long)
1913 Perl_my_swabn(void *ptr, int n)
1915 register char *s = (char *)ptr;
1916 register char *e = s + (n-1);
1919 for (n /= 2; n > 0; s++, e--, n--) {
1927 Perl_my_popen_list(pTHX_ char *mode, int n, SV **args)
1929 #if (!defined(DOSISH) || defined(HAS_FORK) || defined(AMIGAOS)) && !defined(OS2) && !defined(VMS) && !defined(__OPEN_VM) && !defined(EPOC) && !defined(MACOS_TRADITIONAL) && !defined(NETWARE)
1931 register I32 This, that;
1937 PERL_FLUSHALL_FOR_CHILD;
1938 This = (*mode == 'w');
1942 taint_proper("Insecure %s%s", "EXEC");
1944 if (PerlProc_pipe(p) < 0)
1946 /* Try for another pipe pair for error return */
1947 if (PerlProc_pipe(pp) >= 0)
1949 while ((pid = PerlProc_fork()) < 0) {
1950 if (errno != EAGAIN) {
1951 PerlLIO_close(p[This]);
1952 PerlLIO_close(p[that]);
1954 PerlLIO_close(pp[0]);
1955 PerlLIO_close(pp[1]);
1967 /* Close parent's end of error status pipe (if any) */
1969 PerlLIO_close(pp[0]);
1970 #if defined(HAS_FCNTL) && defined(F_SETFD)
1971 /* Close error pipe automatically if exec works */
1972 fcntl(pp[1], F_SETFD, FD_CLOEXEC);
1975 /* Now dup our end of _the_ pipe to right position */
1976 if (p[THIS] != (*mode == 'r')) {
1977 PerlLIO_dup2(p[THIS], *mode == 'r');
1978 PerlLIO_close(p[THIS]);
1979 if (p[THAT] != (*mode == 'r')) /* if dup2() didn't close it */
1980 PerlLIO_close(p[THAT]); /* close parent's end of _the_ pipe */
1983 PerlLIO_close(p[THAT]); /* close parent's end of _the_ pipe */
1984 #if !defined(HAS_FCNTL) || !defined(F_SETFD)
1985 /* No automatic close - do it by hand */
1992 for (fd = PL_maxsysfd + 1; fd < NOFILE; fd++) {
1998 do_aexec5(Nullsv, args-1, args-1+n, pp[1], did_pipes);
2004 do_execfree(); /* free any memory malloced by child on fork */
2006 PerlLIO_close(pp[1]);
2007 /* Keep the lower of the two fd numbers */
2008 if (p[that] < p[This]) {
2009 PerlLIO_dup2(p[This], p[that]);
2010 PerlLIO_close(p[This]);
2014 PerlLIO_close(p[that]); /* close child's end of pipe */
2017 sv = *av_fetch(PL_fdpid,p[This],TRUE);
2019 (void)SvUPGRADE(sv,SVt_IV);
2021 PL_forkprocess = pid;
2022 /* If we managed to get status pipe check for exec fail */
2023 if (did_pipes && pid > 0) {
2027 while (n < sizeof(int)) {
2028 n1 = PerlLIO_read(pp[0],
2029 (void*)(((char*)&errkid)+n),
2035 PerlLIO_close(pp[0]);
2037 if (n) { /* Error */
2039 PerlLIO_close(p[This]);
2040 if (n != sizeof(int))
2041 Perl_croak(aTHX_ "panic: kid popen errno read");
2043 pid2 = wait4pid(pid, &status, 0);
2044 } while (pid2 == -1 && errno == EINTR);
2045 errno = errkid; /* Propagate errno from kid */
2050 PerlLIO_close(pp[0]);
2051 return PerlIO_fdopen(p[This], mode);
2053 Perl_croak(aTHX_ "List form of piped open not implemented");
2054 return (PerlIO *) NULL;
2058 /* VMS' my_popen() is in VMS.c, same with OS/2. */
2059 #if (!defined(DOSISH) || defined(HAS_FORK) || defined(AMIGAOS)) && !defined(VMS) && !defined(__OPEN_VM) && !defined(EPOC) && !defined(MACOS_TRADITIONAL)
2061 Perl_my_popen(pTHX_ char *cmd, char *mode)
2064 register I32 This, that;
2067 I32 doexec = !(*cmd == '-' && cmd[1] == '\0');
2071 PERL_FLUSHALL_FOR_CHILD;
2074 return my_syspopen(aTHX_ cmd,mode);
2077 This = (*mode == 'w');
2079 if (doexec && PL_tainting) {
2081 taint_proper("Insecure %s%s", "EXEC");
2083 if (PerlProc_pipe(p) < 0)
2085 if (doexec && PerlProc_pipe(pp) >= 0)
2087 while ((pid = PerlProc_fork()) < 0) {
2088 if (errno != EAGAIN) {
2089 PerlLIO_close(p[This]);
2090 PerlLIO_close(p[that]);
2092 PerlLIO_close(pp[0]);
2093 PerlLIO_close(pp[1]);
2096 Perl_croak(aTHX_ "Can't fork");
2109 PerlLIO_close(pp[0]);
2110 #if defined(HAS_FCNTL) && defined(F_SETFD)
2111 fcntl(pp[1], F_SETFD, FD_CLOEXEC);
2114 if (p[THIS] != (*mode == 'r')) {
2115 PerlLIO_dup2(p[THIS], *mode == 'r');
2116 PerlLIO_close(p[THIS]);
2117 if (p[THAT] != (*mode == 'r')) /* if dup2() didn't close it */
2118 PerlLIO_close(p[THAT]);
2121 PerlLIO_close(p[THAT]);
2124 #if !defined(HAS_FCNTL) || !defined(F_SETFD)
2133 for (fd = PL_maxsysfd + 1; fd < NOFILE; fd++)
2138 /* may or may not use the shell */
2139 do_exec3(cmd, pp[1], did_pipes);
2142 #endif /* defined OS2 */
2144 if ((tmpgv = gv_fetchpv("$",TRUE, SVt_PV))) {
2145 SvREADONLY_off(GvSV(tmpgv));
2146 sv_setiv(GvSV(tmpgv), PerlProc_getpid());
2147 SvREADONLY_on(GvSV(tmpgv));
2149 #ifdef THREADS_HAVE_PIDS
2150 PL_ppid = (IV)getppid();
2153 hv_clear(PL_pidstatus); /* we have no children */
2158 do_execfree(); /* free any memory malloced by child on vfork */
2160 PerlLIO_close(pp[1]);
2161 if (p[that] < p[This]) {
2162 PerlLIO_dup2(p[This], p[that]);
2163 PerlLIO_close(p[This]);
2167 PerlLIO_close(p[that]);
2170 sv = *av_fetch(PL_fdpid,p[This],TRUE);
2172 (void)SvUPGRADE(sv,SVt_IV);
2174 PL_forkprocess = pid;
2175 if (did_pipes && pid > 0) {
2179 while (n < sizeof(int)) {
2180 n1 = PerlLIO_read(pp[0],
2181 (void*)(((char*)&errkid)+n),
2187 PerlLIO_close(pp[0]);
2189 if (n) { /* Error */
2191 PerlLIO_close(p[This]);
2192 if (n != sizeof(int))
2193 Perl_croak(aTHX_ "panic: kid popen errno read");
2195 pid2 = wait4pid(pid, &status, 0);
2196 } while (pid2 == -1 && errno == EINTR);
2197 errno = errkid; /* Propagate errno from kid */
2202 PerlLIO_close(pp[0]);
2203 return PerlIO_fdopen(p[This], mode);
2206 #if defined(atarist) || defined(EPOC)
2209 Perl_my_popen(pTHX_ char *cmd, char *mode)
2211 PERL_FLUSHALL_FOR_CHILD;
2212 /* Call system's popen() to get a FILE *, then import it.
2213 used 0 for 2nd parameter to PerlIO_importFILE;
2216 return PerlIO_importFILE(popen(cmd, mode), 0);
2220 FILE *djgpp_popen();
2222 Perl_my_popen(pTHX_ char *cmd, char *mode)
2224 PERL_FLUSHALL_FOR_CHILD;
2225 /* Call system's popen() to get a FILE *, then import it.
2226 used 0 for 2nd parameter to PerlIO_importFILE;
2229 return PerlIO_importFILE(djgpp_popen(cmd, mode), 0);
2234 #endif /* !DOSISH */
2236 /* this is called in parent before the fork() */
2238 Perl_atfork_lock(void)
2240 #if defined(USE_ITHREADS)
2241 /* locks must be held in locking order (if any) */
2243 MUTEX_LOCK(&PL_malloc_mutex);
2249 /* this is called in both parent and child after the fork() */
2251 Perl_atfork_unlock(void)
2253 #if defined(USE_ITHREADS)
2254 /* locks must be released in same order as in atfork_lock() */
2256 MUTEX_UNLOCK(&PL_malloc_mutex);
2265 #if defined(HAS_FORK)
2267 #if defined(USE_ITHREADS) && !defined(HAS_PTHREAD_ATFORK)
2272 /* atfork_lock() and atfork_unlock() are installed as pthread_atfork()
2273 * handlers elsewhere in the code */
2278 /* this "canna happen" since nothing should be calling here if !HAS_FORK */
2279 Perl_croak_nocontext("fork() not available");
2281 #endif /* HAS_FORK */
2286 Perl_dump_fds(pTHX_ char *s)
2291 PerlIO_printf(Perl_debug_log,"%s", s);
2292 for (fd = 0; fd < 32; fd++) {
2293 if (PerlLIO_fstat(fd,&tmpstatbuf) >= 0)
2294 PerlIO_printf(Perl_debug_log," %d",fd);
2296 PerlIO_printf(Perl_debug_log,"\n");
2298 #endif /* DUMP_FDS */
2302 dup2(int oldfd, int newfd)
2304 #if defined(HAS_FCNTL) && defined(F_DUPFD)
2307 PerlLIO_close(newfd);
2308 return fcntl(oldfd, F_DUPFD, newfd);
2310 #define DUP2_MAX_FDS 256
2311 int fdtmp[DUP2_MAX_FDS];
2317 PerlLIO_close(newfd);
2318 /* good enough for low fd's... */
2319 while ((fd = PerlLIO_dup(oldfd)) != newfd && fd >= 0) {
2320 if (fdx >= DUP2_MAX_FDS) {
2328 PerlLIO_close(fdtmp[--fdx]);
2335 #ifdef HAS_SIGACTION
2337 #ifdef MACOS_TRADITIONAL
2338 /* We don't want restart behavior on MacOS */
2343 Perl_rsignal(pTHX_ int signo, Sighandler_t handler)
2345 struct sigaction act, oact;
2348 /* only "parent" interpreter can diddle signals */
2349 if (PL_curinterp != aTHX)
2353 act.sa_handler = handler;
2354 sigemptyset(&act.sa_mask);
2357 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
2358 act.sa_flags |= SA_RESTART; /* SVR4, 4.3+BSD */
2360 #if defined(SA_NOCLDWAIT) && !defined(BSDish) /* See [perl #18849] */
2361 if (signo == SIGCHLD && handler == (Sighandler_t)SIG_IGN)
2362 act.sa_flags |= SA_NOCLDWAIT;
2364 if (sigaction(signo, &act, &oact) == -1)
2367 return oact.sa_handler;
2371 Perl_rsignal_state(pTHX_ int signo)
2373 struct sigaction oact;
2375 if (sigaction(signo, (struct sigaction *)NULL, &oact) == -1)
2378 return oact.sa_handler;
2382 Perl_rsignal_save(pTHX_ int signo, Sighandler_t handler, Sigsave_t *save)
2384 struct sigaction act;
2387 /* only "parent" interpreter can diddle signals */
2388 if (PL_curinterp != aTHX)
2392 act.sa_handler = handler;
2393 sigemptyset(&act.sa_mask);
2396 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
2397 act.sa_flags |= SA_RESTART; /* SVR4, 4.3+BSD */
2399 #if defined(SA_NOCLDWAIT) && !defined(BSDish) /* See [perl #18849] */
2400 if (signo == SIGCHLD && handler == (Sighandler_t)SIG_IGN)
2401 act.sa_flags |= SA_NOCLDWAIT;
2403 return sigaction(signo, &act, save);
2407 Perl_rsignal_restore(pTHX_ int signo, Sigsave_t *save)
2410 /* only "parent" interpreter can diddle signals */
2411 if (PL_curinterp != aTHX)
2415 return sigaction(signo, save, (struct sigaction *)NULL);
2418 #else /* !HAS_SIGACTION */
2421 Perl_rsignal(pTHX_ int signo, Sighandler_t handler)
2423 #if defined(USE_ITHREADS) && !defined(WIN32)
2424 /* only "parent" interpreter can diddle signals */
2425 if (PL_curinterp != aTHX)
2429 return PerlProc_signal(signo, handler);
2432 static int sig_trapped; /* XXX signals are process-wide anyway, so we
2433 ignore the implications of this for threading */
2443 Perl_rsignal_state(pTHX_ int signo)
2445 Sighandler_t oldsig;
2447 #if defined(USE_ITHREADS) && !defined(WIN32)
2448 /* only "parent" interpreter can diddle signals */
2449 if (PL_curinterp != aTHX)
2454 oldsig = PerlProc_signal(signo, sig_trap);
2455 PerlProc_signal(signo, oldsig);
2457 PerlProc_kill(PerlProc_getpid(), signo);
2462 Perl_rsignal_save(pTHX_ int signo, Sighandler_t handler, Sigsave_t *save)
2464 #if defined(USE_ITHREADS) && !defined(WIN32)
2465 /* only "parent" interpreter can diddle signals */
2466 if (PL_curinterp != aTHX)
2469 *save = PerlProc_signal(signo, handler);
2470 return (*save == SIG_ERR) ? -1 : 0;
2474 Perl_rsignal_restore(pTHX_ int signo, Sigsave_t *save)
2476 #if defined(USE_ITHREADS) && !defined(WIN32)
2477 /* only "parent" interpreter can diddle signals */
2478 if (PL_curinterp != aTHX)
2481 return (PerlProc_signal(signo, *save) == SIG_ERR) ? -1 : 0;
2484 #endif /* !HAS_SIGACTION */
2485 #endif /* !PERL_MICRO */
2487 /* VMS' my_pclose() is in VMS.c; same with OS/2 */
2488 #if (!defined(DOSISH) || defined(HAS_FORK) || defined(AMIGAOS)) && !defined(VMS) && !defined(__OPEN_VM) && !defined(EPOC) && !defined(MACOS_TRADITIONAL)
2490 Perl_my_pclose(pTHX_ PerlIO *ptr)
2492 Sigsave_t hstat, istat, qstat;
2498 int saved_errno = 0;
2500 int saved_vaxc_errno;
2503 int saved_win32_errno;
2507 svp = av_fetch(PL_fdpid,PerlIO_fileno(ptr),TRUE);
2509 pid = (SvTYPE(*svp) == SVt_IV) ? SvIVX(*svp) : -1;
2511 *svp = &PL_sv_undef;
2513 if (pid == -1) { /* Opened by popen. */
2514 return my_syspclose(ptr);
2517 if ((close_failed = (PerlIO_close(ptr) == EOF))) {
2518 saved_errno = errno;
2520 saved_vaxc_errno = vaxc$errno;
2523 saved_win32_errno = GetLastError();
2527 if(PerlProc_kill(pid, 0) < 0) { return(pid); } /* HOM 12/23/91 */
2530 rsignal_save(SIGHUP, SIG_IGN, &hstat);
2531 rsignal_save(SIGINT, SIG_IGN, &istat);
2532 rsignal_save(SIGQUIT, SIG_IGN, &qstat);
2535 pid2 = wait4pid(pid, &status, 0);
2536 } while (pid2 == -1 && errno == EINTR);
2538 rsignal_restore(SIGHUP, &hstat);
2539 rsignal_restore(SIGINT, &istat);
2540 rsignal_restore(SIGQUIT, &qstat);
2543 SETERRNO(saved_errno, saved_vaxc_errno);
2546 return(pid2 < 0 ? pid2 : status == 0 ? 0 : (errno = 0, status));
2548 #endif /* !DOSISH */
2550 #if (!defined(DOSISH) || defined(OS2) || defined(WIN32) || defined(NETWARE)) && !defined(MACOS_TRADITIONAL)
2552 Perl_wait4pid(pTHX_ Pid_t pid, int *statusp, int flags)
2557 #if !defined(HAS_WAITPID) && !defined(HAS_WAIT4) || defined(HAS_WAITPID_RUNTIME)
2561 char spid[TYPE_CHARS(IV)];
2564 sprintf(spid, "%"IVdf, (IV)pid);
2565 svp = hv_fetch(PL_pidstatus,spid,strlen(spid),FALSE);
2566 if (svp && *svp != &PL_sv_undef) {
2567 *statusp = SvIVX(*svp);
2568 (void)hv_delete(PL_pidstatus,spid,strlen(spid),G_DISCARD);
2575 hv_iterinit(PL_pidstatus);
2576 if ((entry = hv_iternext(PL_pidstatus))) {
2577 pid = atoi(hv_iterkey(entry,(I32*)statusp));
2578 sv = hv_iterval(PL_pidstatus,entry);
2579 *statusp = SvIVX(sv);
2580 sprintf(spid, "%"IVdf, (IV)pid);
2581 (void)hv_delete(PL_pidstatus,spid,strlen(spid),G_DISCARD);
2588 # ifdef HAS_WAITPID_RUNTIME
2589 if (!HAS_WAITPID_RUNTIME)
2592 result = PerlProc_waitpid(pid,statusp,flags);
2595 #if !defined(HAS_WAITPID) && defined(HAS_WAIT4)
2596 result = wait4((pid==-1)?0:pid,statusp,flags,Null(struct rusage *));
2599 #if !defined(HAS_WAITPID) && !defined(HAS_WAIT4) || defined(HAS_WAITPID_RUNTIME)
2603 Perl_croak(aTHX_ "Can't do waitpid with flags");
2605 while ((result = PerlProc_wait(statusp)) != pid && pid > 0 && result >= 0)
2606 pidgone(result,*statusp);
2613 if (result < 0 && errno == EINTR) {
2618 #endif /* !DOSISH || OS2 || WIN32 || NETWARE */
2622 Perl_pidgone(pTHX_ Pid_t pid, int status)
2625 char spid[TYPE_CHARS(IV)];
2627 sprintf(spid, "%"IVdf, (IV)pid);
2628 sv = *hv_fetch(PL_pidstatus,spid,strlen(spid),TRUE);
2629 (void)SvUPGRADE(sv,SVt_IV);
2634 #if defined(atarist) || defined(OS2) || defined(EPOC)
2637 int /* Cannot prototype with I32
2639 my_syspclose(PerlIO *ptr)
2642 Perl_my_pclose(pTHX_ PerlIO *ptr)
2645 /* Needs work for PerlIO ! */
2646 FILE *f = PerlIO_findFILE(ptr);
2647 I32 result = pclose(f);
2648 PerlIO_releaseFILE(ptr,f);
2656 Perl_my_pclose(pTHX_ PerlIO *ptr)
2658 /* Needs work for PerlIO ! */
2659 FILE *f = PerlIO_findFILE(ptr);
2660 I32 result = djgpp_pclose(f);
2661 result = (result << 8) & 0xff00;
2662 PerlIO_releaseFILE(ptr,f);
2668 Perl_repeatcpy(pTHX_ register char *to, register const char *from, I32 len, register I32 count)
2671 register const char *frombase = from;
2674 register const char c = *from;
2679 while (count-- > 0) {
2680 for (todo = len; todo > 0; todo--) {
2689 Perl_same_dirent(pTHX_ char *a, char *b)
2691 char *fa = strrchr(a,'/');
2692 char *fb = strrchr(b,'/');
2695 SV *tmpsv = sv_newmortal();
2708 sv_setpv(tmpsv, ".");
2710 sv_setpvn(tmpsv, a, fa - a);
2711 if (PerlLIO_stat(SvPVX(tmpsv), &tmpstatbuf1) < 0)
2714 sv_setpv(tmpsv, ".");
2716 sv_setpvn(tmpsv, b, fb - b);
2717 if (PerlLIO_stat(SvPVX(tmpsv), &tmpstatbuf2) < 0)
2719 return tmpstatbuf1.st_dev == tmpstatbuf2.st_dev &&
2720 tmpstatbuf1.st_ino == tmpstatbuf2.st_ino;
2722 #endif /* !HAS_RENAME */
2725 Perl_find_script(pTHX_ char *scriptname, bool dosearch, char **search_ext, I32 flags)
2727 char *xfound = Nullch;
2728 char *xfailed = Nullch;
2729 char tmpbuf[MAXPATHLEN];
2733 #if defined(DOSISH) && !defined(OS2) && !defined(atarist)
2734 # define SEARCH_EXTS ".bat", ".cmd", NULL
2735 # define MAX_EXT_LEN 4
2738 # define SEARCH_EXTS ".cmd", ".btm", ".bat", ".pl", NULL
2739 # define MAX_EXT_LEN 4
2742 # define SEARCH_EXTS ".pl", ".com", NULL
2743 # define MAX_EXT_LEN 4
2745 /* additional extensions to try in each dir if scriptname not found */
2747 char *exts[] = { SEARCH_EXTS };
2748 char **ext = search_ext ? search_ext : exts;
2749 int extidx = 0, i = 0;
2750 char *curext = Nullch;
2752 # define MAX_EXT_LEN 0
2756 * If dosearch is true and if scriptname does not contain path
2757 * delimiters, search the PATH for scriptname.
2759 * If SEARCH_EXTS is also defined, will look for each
2760 * scriptname{SEARCH_EXTS} whenever scriptname is not found
2761 * while searching the PATH.
2763 * Assuming SEARCH_EXTS is C<".foo",".bar",NULL>, PATH search
2764 * proceeds as follows:
2765 * If DOSISH or VMSISH:
2766 * + look for ./scriptname{,.foo,.bar}
2767 * + search the PATH for scriptname{,.foo,.bar}
2770 * + look *only* in the PATH for scriptname{,.foo,.bar} (note
2771 * this will not look in '.' if it's not in the PATH)
2776 # ifdef ALWAYS_DEFTYPES
2777 len = strlen(scriptname);
2778 if (!(len == 1 && *scriptname == '-') && scriptname[len-1] != ':') {
2779 int hasdir, idx = 0, deftypes = 1;
2782 hasdir = !dosearch || (strpbrk(scriptname,":[</") != Nullch) ;
2785 int hasdir, idx = 0, deftypes = 1;
2788 hasdir = (strpbrk(scriptname,":[</") != Nullch) ;
2790 /* The first time through, just add SEARCH_EXTS to whatever we
2791 * already have, so we can check for default file types. */
2793 (!hasdir && my_trnlnm("DCL$PATH",tmpbuf,idx++)) )
2799 if ((strlen(tmpbuf) + strlen(scriptname)
2800 + MAX_EXT_LEN) >= sizeof tmpbuf)
2801 continue; /* don't search dir with too-long name */
2802 strcat(tmpbuf, scriptname);
2806 if (strEQ(scriptname, "-"))
2808 if (dosearch) { /* Look in '.' first. */
2809 char *cur = scriptname;
2811 if ((curext = strrchr(scriptname,'.'))) /* possible current ext */
2813 if (strEQ(ext[i++],curext)) {
2814 extidx = -1; /* already has an ext */
2819 DEBUG_p(PerlIO_printf(Perl_debug_log,
2820 "Looking for %s\n",cur));
2821 if (PerlLIO_stat(cur,&PL_statbuf) >= 0
2822 && !S_ISDIR(PL_statbuf.st_mode)) {
2830 if (cur == scriptname) {
2831 len = strlen(scriptname);
2832 if (len+MAX_EXT_LEN+1 >= sizeof(tmpbuf))
2834 cur = strcpy(tmpbuf, scriptname);
2836 } while (extidx >= 0 && ext[extidx] /* try an extension? */
2837 && strcpy(tmpbuf+len, ext[extidx++]));
2842 #ifdef MACOS_TRADITIONAL
2843 if (dosearch && !strchr(scriptname, ':') &&
2844 (s = PerlEnv_getenv("Commands")))
2846 if (dosearch && !strchr(scriptname, '/')
2848 && !strchr(scriptname, '\\')
2850 && (s = PerlEnv_getenv("PATH")))
2855 PL_bufend = s + strlen(s);
2856 while (s < PL_bufend) {
2857 #ifdef MACOS_TRADITIONAL
2858 s = delimcpy(tmpbuf, tmpbuf + sizeof tmpbuf, s, PL_bufend,
2862 #if defined(atarist) || defined(DOSISH)
2867 && *s != ';'; len++, s++) {
2868 if (len < sizeof tmpbuf)
2871 if (len < sizeof tmpbuf)
2873 #else /* ! (atarist || DOSISH) */
2874 s = delimcpy(tmpbuf, tmpbuf + sizeof tmpbuf, s, PL_bufend,
2877 #endif /* ! (atarist || DOSISH) */
2878 #endif /* MACOS_TRADITIONAL */
2881 if (len + 1 + strlen(scriptname) + MAX_EXT_LEN >= sizeof tmpbuf)
2882 continue; /* don't search dir with too-long name */
2883 #ifdef MACOS_TRADITIONAL
2884 if (len && tmpbuf[len - 1] != ':')
2885 tmpbuf[len++] = ':';
2888 #if defined(atarist) || defined(__MINT__) || defined(DOSISH)
2889 && tmpbuf[len - 1] != '/'
2890 && tmpbuf[len - 1] != '\\'
2893 tmpbuf[len++] = '/';
2894 if (len == 2 && tmpbuf[0] == '.')
2897 (void)strcpy(tmpbuf + len, scriptname);
2901 len = strlen(tmpbuf);
2902 if (extidx > 0) /* reset after previous loop */
2906 DEBUG_p(PerlIO_printf(Perl_debug_log, "Looking for %s\n",tmpbuf));
2907 retval = PerlLIO_stat(tmpbuf,&PL_statbuf);
2908 if (S_ISDIR(PL_statbuf.st_mode)) {
2912 } while ( retval < 0 /* not there */
2913 && extidx>=0 && ext[extidx] /* try an extension? */
2914 && strcpy(tmpbuf+len, ext[extidx++])
2919 if (S_ISREG(PL_statbuf.st_mode)
2920 && cando(S_IRUSR,TRUE,&PL_statbuf)
2921 #if !defined(DOSISH) && !defined(MACOS_TRADITIONAL)
2922 && cando(S_IXUSR,TRUE,&PL_statbuf)
2926 xfound = tmpbuf; /* bingo! */
2930 xfailed = savepv(tmpbuf);
2933 if (!xfound && !seen_dot && !xfailed &&
2934 (PerlLIO_stat(scriptname,&PL_statbuf) < 0
2935 || S_ISDIR(PL_statbuf.st_mode)))
2937 seen_dot = 1; /* Disable message. */
2939 if (flags & 1) { /* do or die? */
2940 Perl_croak(aTHX_ "Can't %s %s%s%s",
2941 (xfailed ? "execute" : "find"),
2942 (xfailed ? xfailed : scriptname),
2943 (xfailed ? "" : " on PATH"),
2944 (xfailed || seen_dot) ? "" : ", '.' not in PATH");
2946 scriptname = Nullch;
2950 scriptname = xfound;
2952 return (scriptname ? savepv(scriptname) : Nullch);
2955 #ifndef PERL_GET_CONTEXT_DEFINED
2958 Perl_get_context(void)
2960 #if defined(USE_ITHREADS)
2961 # ifdef OLD_PTHREADS_API
2963 if (pthread_getspecific(PL_thr_key, &t))
2964 Perl_croak_nocontext("panic: pthread_getspecific");
2967 # ifdef I_MACH_CTHREADS
2968 return (void*)cthread_data(cthread_self());
2970 return (void*)PTHREAD_GETSPECIFIC(PL_thr_key);
2979 Perl_set_context(void *t)
2981 #if defined(USE_ITHREADS)
2982 # ifdef I_MACH_CTHREADS
2983 cthread_set_data(cthread_self(), t);
2985 if (pthread_setspecific(PL_thr_key, t))
2986 Perl_croak_nocontext("panic: pthread_setspecific");
2991 #endif /* !PERL_GET_CONTEXT_DEFINED */
2993 #ifdef PERL_GLOBAL_STRUCT
3002 Perl_get_op_names(pTHX)
3008 Perl_get_op_descs(pTHX)
3014 Perl_get_no_modify(pTHX)
3016 return (char*)PL_no_modify;
3020 Perl_get_opargs(pTHX)
3026 Perl_get_ppaddr(pTHX)
3028 return (PPADDR_t*)PL_ppaddr;
3031 #ifndef HAS_GETENV_LEN
3033 Perl_getenv_len(pTHX_ const char *env_elem, unsigned long *len)
3035 char *env_trans = PerlEnv_getenv(env_elem);
3037 *len = strlen(env_trans);
3044 Perl_get_vtbl(pTHX_ int vtbl_id)
3046 MGVTBL* result = Null(MGVTBL*);
3050 result = &PL_vtbl_sv;
3053 result = &PL_vtbl_env;
3055 case want_vtbl_envelem:
3056 result = &PL_vtbl_envelem;
3059 result = &PL_vtbl_sig;
3061 case want_vtbl_sigelem:
3062 result = &PL_vtbl_sigelem;
3064 case want_vtbl_pack:
3065 result = &PL_vtbl_pack;
3067 case want_vtbl_packelem:
3068 result = &PL_vtbl_packelem;
3070 case want_vtbl_dbline:
3071 result = &PL_vtbl_dbline;
3074 result = &PL_vtbl_isa;
3076 case want_vtbl_isaelem:
3077 result = &PL_vtbl_isaelem;
3079 case want_vtbl_arylen:
3080 result = &PL_vtbl_arylen;
3082 case want_vtbl_glob:
3083 result = &PL_vtbl_glob;
3085 case want_vtbl_mglob:
3086 result = &PL_vtbl_mglob;
3088 case want_vtbl_nkeys:
3089 result = &PL_vtbl_nkeys;
3091 case want_vtbl_taint:
3092 result = &PL_vtbl_taint;
3094 case want_vtbl_substr:
3095 result = &PL_vtbl_substr;
3098 result = &PL_vtbl_vec;
3101 result = &PL_vtbl_pos;
3104 result = &PL_vtbl_bm;
3107 result = &PL_vtbl_fm;
3109 case want_vtbl_uvar:
3110 result = &PL_vtbl_uvar;
3112 case want_vtbl_defelem:
3113 result = &PL_vtbl_defelem;
3115 case want_vtbl_regexp:
3116 result = &PL_vtbl_regexp;
3118 case want_vtbl_regdata:
3119 result = &PL_vtbl_regdata;
3121 case want_vtbl_regdatum:
3122 result = &PL_vtbl_regdatum;
3124 #ifdef USE_LOCALE_COLLATE
3125 case want_vtbl_collxfrm:
3126 result = &PL_vtbl_collxfrm;
3129 case want_vtbl_amagic:
3130 result = &PL_vtbl_amagic;
3132 case want_vtbl_amagicelem:
3133 result = &PL_vtbl_amagicelem;
3135 case want_vtbl_backref:
3136 result = &PL_vtbl_backref;
3138 case want_vtbl_utf8:
3139 result = &PL_vtbl_utf8;
3146 Perl_my_fflush_all(pTHX)
3148 #if defined(USE_PERLIO) || defined(FFLUSH_NULL) || defined(USE_SFIO)
3149 return PerlIO_flush(NULL);
3151 # if defined(HAS__FWALK)
3152 extern int fflush(FILE *);
3153 /* undocumented, unprototyped, but very useful BSDism */
3154 extern void _fwalk(int (*)(FILE *));
3158 # if defined(FFLUSH_ALL) && defined(HAS_STDIO_STREAM_ARRAY)
3160 # ifdef PERL_FFLUSH_ALL_FOPEN_MAX
3161 open_max = PERL_FFLUSH_ALL_FOPEN_MAX;
3163 # if defined(HAS_SYSCONF) && defined(_SC_OPEN_MAX)
3164 open_max = sysconf(_SC_OPEN_MAX);
3167 open_max = FOPEN_MAX;
3170 open_max = OPEN_MAX;
3181 for (i = 0; i < open_max; i++)
3182 if (STDIO_STREAM_ARRAY[i]._file >= 0 &&
3183 STDIO_STREAM_ARRAY[i]._file < open_max &&
3184 STDIO_STREAM_ARRAY[i]._flag)
3185 PerlIO_flush(&STDIO_STREAM_ARRAY[i]);
3189 SETERRNO(EBADF,RMS_IFI);
3196 Perl_report_evil_fh(pTHX_ GV *gv, IO *io, I32 op)
3199 op == OP_READLINE ? "readline" : /* "<HANDLE>" not nice */
3200 op == OP_LEAVEWRITE ? "write" : /* "write exit" not nice */
3202 char *pars = OP_IS_FILETEST(op) ? "" : "()";
3203 char *type = OP_IS_SOCKET(op)
3204 || (gv && io && IoTYPE(io) == IoTYPE_SOCKET)
3205 ? "socket" : "filehandle";
3208 if (gv && isGV(gv)) {
3212 if (op == OP_phoney_OUTPUT_ONLY || op == OP_phoney_INPUT_ONLY) {
3213 if (ckWARN(WARN_IO)) {
3214 const char *direction = (op == OP_phoney_INPUT_ONLY) ? "in" : "out";
3216 Perl_warner(aTHX_ packWARN(WARN_IO),
3217 "Filehandle %s opened only for %sput",
3220 Perl_warner(aTHX_ packWARN(WARN_IO),
3221 "Filehandle opened only for %sput", direction);
3228 if (gv && io && IoTYPE(io) == IoTYPE_CLOSED) {
3230 warn_type = WARN_CLOSED;
3234 warn_type = WARN_UNOPENED;
3237 if (ckWARN(warn_type)) {
3238 if (name && *name) {
3239 Perl_warner(aTHX_ packWARN(warn_type),
3240 "%s%s on %s %s %s", func, pars, vile, type, name);
3241 if (io && IoDIRP(io) && !(IoFLAGS(io) & IOf_FAKE_DIRP))
3243 aTHX_ packWARN(warn_type),
3244 "\t(Are you trying to call %s%s on dirhandle %s?)\n",
3249 Perl_warner(aTHX_ packWARN(warn_type),
3250 "%s%s on %s %s", func, pars, vile, type);
3251 if (gv && io && IoDIRP(io) && !(IoFLAGS(io) & IOf_FAKE_DIRP))
3253 aTHX_ packWARN(warn_type),
3254 "\t(Are you trying to call %s%s on dirhandle?)\n",
3263 /* in ASCII order, not that it matters */
3264 static const char controllablechars[] = "?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_";
3267 Perl_ebcdic_control(pTHX_ int ch)
3275 if ((ctlp = strchr(controllablechars, ch)) == 0) {
3276 Perl_die(aTHX_ "unrecognised control character '%c'\n", ch);
3279 if (ctlp == controllablechars)
3280 return('\177'); /* DEL */
3282 return((unsigned char)(ctlp - controllablechars - 1));
3283 } else { /* Want uncontrol */
3284 if (ch == '\177' || ch == -1)
3286 else if (ch == '\157')
3288 else if (ch == '\174')
3290 else if (ch == '^') /* '\137' in 1047, '\260' in 819 */
3292 else if (ch == '\155')
3294 else if (0 < ch && ch < (sizeof(controllablechars) - 1))
3295 return(controllablechars[ch+1]);
3297 Perl_die(aTHX_ "invalid control request: '\\%03o'\n", ch & 0xFF);
3302 /* To workaround core dumps from the uninitialised tm_zone we get the
3303 * system to give us a reasonable struct to copy. This fix means that
3304 * strftime uses the tm_zone and tm_gmtoff values returned by
3305 * localtime(time()). That should give the desired result most of the
3306 * time. But probably not always!
3308 * This does not address tzname aspects of NETaa14816.
3313 # ifndef STRUCT_TM_HASZONE
3314 # define STRUCT_TM_HASZONE
3318 #ifdef STRUCT_TM_HASZONE /* Backward compat */
3319 # ifndef HAS_TM_TM_ZONE
3320 # define HAS_TM_TM_ZONE
3325 Perl_init_tm(pTHX_ struct tm *ptm) /* see mktime, strftime and asctime */
3327 #ifdef HAS_TM_TM_ZONE
3330 Copy(localtime(&now), ptm, 1, struct tm);
3335 * mini_mktime - normalise struct tm values without the localtime()
3336 * semantics (and overhead) of mktime().
3339 Perl_mini_mktime(pTHX_ struct tm *ptm)
3343 int month, mday, year, jday;
3344 int odd_cent, odd_year;
3346 #define DAYS_PER_YEAR 365
3347 #define DAYS_PER_QYEAR (4*DAYS_PER_YEAR+1)
3348 #define DAYS_PER_CENT (25*DAYS_PER_QYEAR-1)
3349 #define DAYS_PER_QCENT (4*DAYS_PER_CENT+1)
3350 #define SECS_PER_HOUR (60*60)
3351 #define SECS_PER_DAY (24*SECS_PER_HOUR)
3352 /* parentheses deliberately absent on these two, otherwise they don't work */
3353 #define MONTH_TO_DAYS 153/5
3354 #define DAYS_TO_MONTH 5/153
3355 /* offset to bias by March (month 4) 1st between month/mday & year finding */
3356 #define YEAR_ADJUST (4*MONTH_TO_DAYS+1)
3357 /* as used here, the algorithm leaves Sunday as day 1 unless we adjust it */
3358 #define WEEKDAY_BIAS 6 /* (1+6)%7 makes Sunday 0 again */
3361 * Year/day algorithm notes:
3363 * With a suitable offset for numeric value of the month, one can find
3364 * an offset into the year by considering months to have 30.6 (153/5) days,
3365 * using integer arithmetic (i.e., with truncation). To avoid too much
3366 * messing about with leap days, we consider January and February to be
3367 * the 13th and 14th month of the previous year. After that transformation,
3368 * we need the month index we use to be high by 1 from 'normal human' usage,
3369 * so the month index values we use run from 4 through 15.
3371 * Given that, and the rules for the Gregorian calendar (leap years are those
3372 * divisible by 4 unless also divisible by 100, when they must be divisible
3373 * by 400 instead), we can simply calculate the number of days since some
3374 * arbitrary 'beginning of time' by futzing with the (adjusted) year number,
3375 * the days we derive from our month index, and adding in the day of the
3376 * month. The value used here is not adjusted for the actual origin which
3377 * it normally would use (1 January A.D. 1), since we're not exposing it.
3378 * We're only building the value so we can turn around and get the
3379 * normalised values for the year, month, day-of-month, and day-of-year.
3381 * For going backward, we need to bias the value we're using so that we find
3382 * the right year value. (Basically, we don't want the contribution of
3383 * March 1st to the number to apply while deriving the year). Having done
3384 * that, we 'count up' the contribution to the year number by accounting for
3385 * full quadracenturies (400-year periods) with their extra leap days, plus
3386 * the contribution from full centuries (to avoid counting in the lost leap
3387 * days), plus the contribution from full quad-years (to count in the normal
3388 * leap days), plus the leftover contribution from any non-leap years.
3389 * At this point, if we were working with an actual leap day, we'll have 0
3390 * days left over. This is also true for March 1st, however. So, we have
3391 * to special-case that result, and (earlier) keep track of the 'odd'
3392 * century and year contributions. If we got 4 extra centuries in a qcent,
3393 * or 4 extra years in a qyear, then it's a leap day and we call it 29 Feb.
3394 * Otherwise, we add back in the earlier bias we removed (the 123 from
3395 * figuring in March 1st), find the month index (integer division by 30.6),
3396 * and the remainder is the day-of-month. We then have to convert back to
3397 * 'real' months (including fixing January and February from being 14/15 in
3398 * the previous year to being in the proper year). After that, to get
3399 * tm_yday, we work with the normalised year and get a new yearday value for
3400 * January 1st, which we subtract from the yearday value we had earlier,
3401 * representing the date we've re-built. This is done from January 1
3402 * because tm_yday is 0-origin.
3404 * Since POSIX time routines are only guaranteed to work for times since the
3405 * UNIX epoch (00:00:00 1 Jan 1970 UTC), the fact that this algorithm
3406 * applies Gregorian calendar rules even to dates before the 16th century
3407 * doesn't bother me. Besides, you'd need cultural context for a given
3408 * date to know whether it was Julian or Gregorian calendar, and that's
3409 * outside the scope for this routine. Since we convert back based on the
3410 * same rules we used to build the yearday, you'll only get strange results
3411 * for input which needed normalising, or for the 'odd' century years which
3412 * were leap years in the Julian calander but not in the Gregorian one.
3413 * I can live with that.
3415 * This algorithm also fails to handle years before A.D. 1 gracefully, but
3416 * that's still outside the scope for POSIX time manipulation, so I don't
3420 year = 1900 + ptm->tm_year;
3421 month = ptm->tm_mon;
3422 mday = ptm->tm_mday;
3423 /* allow given yday with no month & mday to dominate the result */
3424 if (ptm->tm_yday >= 0 && mday <= 0 && month <= 0) {
3427 jday = 1 + ptm->tm_yday;
3436 yearday = DAYS_PER_YEAR * year + year/4 - year/100 + year/400;
3437 yearday += month*MONTH_TO_DAYS + mday + jday;
3439 * Note that we don't know when leap-seconds were or will be,
3440 * so we have to trust the user if we get something which looks
3441 * like a sensible leap-second. Wild values for seconds will
3442 * be rationalised, however.
3444 if ((unsigned) ptm->tm_sec <= 60) {
3451 secs += 60 * ptm->tm_min;
3452 secs += SECS_PER_HOUR * ptm->tm_hour;
3454 if (secs-(secs/SECS_PER_DAY*SECS_PER_DAY) < 0) {
3455 /* got negative remainder, but need positive time */
3456 /* back off an extra day to compensate */
3457 yearday += (secs/SECS_PER_DAY)-1;
3458 secs -= SECS_PER_DAY * (secs/SECS_PER_DAY - 1);
3461 yearday += (secs/SECS_PER_DAY);
3462 secs -= SECS_PER_DAY * (secs/SECS_PER_DAY);
3465 else if (secs >= SECS_PER_DAY) {
3466 yearday += (secs/SECS_PER_DAY);
3467 secs %= SECS_PER_DAY;
3469 ptm->tm_hour = secs/SECS_PER_HOUR;
3470 secs %= SECS_PER_HOUR;
3471 ptm->tm_min = secs/60;
3473 ptm->tm_sec += secs;
3474 /* done with time of day effects */
3476 * The algorithm for yearday has (so far) left it high by 428.
3477 * To avoid mistaking a legitimate Feb 29 as Mar 1, we need to
3478 * bias it by 123 while trying to figure out what year it
3479 * really represents. Even with this tweak, the reverse
3480 * translation fails for years before A.D. 0001.
3481 * It would still fail for Feb 29, but we catch that one below.
3483 jday = yearday; /* save for later fixup vis-a-vis Jan 1 */
3484 yearday -= YEAR_ADJUST;
3485 year = (yearday / DAYS_PER_QCENT) * 400;
3486 yearday %= DAYS_PER_QCENT;
3487 odd_cent = yearday / DAYS_PER_CENT;
3488 year += odd_cent * 100;
3489 yearday %= DAYS_PER_CENT;
3490 year += (yearday / DAYS_PER_QYEAR) * 4;
3491 yearday %= DAYS_PER_QYEAR;
3492 odd_year = yearday / DAYS_PER_YEAR;
3494 yearday %= DAYS_PER_YEAR;
3495 if (!yearday && (odd_cent==4 || odd_year==4)) { /* catch Feb 29 */
3500 yearday += YEAR_ADJUST; /* recover March 1st crock */
3501 month = yearday*DAYS_TO_MONTH;
3502 yearday -= month*MONTH_TO_DAYS;
3503 /* recover other leap-year adjustment */
3512 ptm->tm_year = year - 1900;
3514 ptm->tm_mday = yearday;
3515 ptm->tm_mon = month;
3519 ptm->tm_mon = month - 1;
3521 /* re-build yearday based on Jan 1 to get tm_yday */
3523 yearday = year*DAYS_PER_YEAR + year/4 - year/100 + year/400;
3524 yearday += 14*MONTH_TO_DAYS + 1;
3525 ptm->tm_yday = jday - yearday;
3526 /* fix tm_wday if not overridden by caller */
3527 if ((unsigned)ptm->tm_wday > 6)
3528 ptm->tm_wday = (jday + WEEKDAY_BIAS) % 7;
3532 Perl_my_strftime(pTHX_ char *fmt, int sec, int min, int hour, int mday, int mon, int year, int wday, int yday, int isdst)
3540 init_tm(&mytm); /* XXX workaround - see init_tm() above */
3543 mytm.tm_hour = hour;
3544 mytm.tm_mday = mday;
3546 mytm.tm_year = year;
3547 mytm.tm_wday = wday;
3548 mytm.tm_yday = yday;
3549 mytm.tm_isdst = isdst;
3551 /* use libc to get the values for tm_gmtoff and tm_zone [perl #18238] */
3552 #if defined(HAS_MKTIME) && (defined(HAS_TM_TM_GMTOFF) || defined(HAS_TM_TM_ZONE))
3557 #ifdef HAS_TM_TM_GMTOFF
3558 mytm.tm_gmtoff = mytm2.tm_gmtoff;
3560 #ifdef HAS_TM_TM_ZONE
3561 mytm.tm_zone = mytm2.tm_zone;
3566 New(0, buf, buflen, char);
3567 len = strftime(buf, buflen, fmt, &mytm);
3569 ** The following is needed to handle to the situation where
3570 ** tmpbuf overflows. Basically we want to allocate a buffer
3571 ** and try repeatedly. The reason why it is so complicated
3572 ** is that getting a return value of 0 from strftime can indicate
3573 ** one of the following:
3574 ** 1. buffer overflowed,
3575 ** 2. illegal conversion specifier, or
3576 ** 3. the format string specifies nothing to be returned(not
3577 ** an error). This could be because format is an empty string
3578 ** or it specifies %p that yields an empty string in some locale.
3579 ** If there is a better way to make it portable, go ahead by
3582 if ((len > 0 && len < buflen) || (len == 0 && *fmt == '\0'))
3585 /* Possibly buf overflowed - try again with a bigger buf */
3586 int fmtlen = strlen(fmt);
3587 int bufsize = fmtlen + buflen;
3589 New(0, buf, bufsize, char);
3591 buflen = strftime(buf, bufsize, fmt, &mytm);
3592 if (buflen > 0 && buflen < bufsize)
3594 /* heuristic to prevent out-of-memory errors */
3595 if (bufsize > 100*fmtlen) {
3601 Renew(buf, bufsize, char);
3606 Perl_croak(aTHX_ "panic: no strftime");
3611 #define SV_CWD_RETURN_UNDEF \
3612 sv_setsv(sv, &PL_sv_undef); \
3615 #define SV_CWD_ISDOT(dp) \
3616 (dp->d_name[0] == '.' && (dp->d_name[1] == '\0' || \
3617 (dp->d_name[1] == '.' && dp->d_name[2] == '\0')))
3620 =head1 Miscellaneous Functions
3622 =for apidoc getcwd_sv
3624 Fill the sv with current working directory
3629 /* Originally written in Perl by John Bazik; rewritten in C by Ben Sugars.
3630 * rewritten again by dougm, optimized for use with xs TARG, and to prefer
3631 * getcwd(3) if available
3632 * Comments from the orignal:
3633 * This is a faster version of getcwd. It's also more dangerous
3634 * because you might chdir out of a directory that you can't chdir
3638 Perl_getcwd_sv(pTHX_ register SV *sv)
3642 #ifndef INCOMPLETE_TAINTS
3648 char buf[MAXPATHLEN];
3650 /* Some getcwd()s automatically allocate a buffer of the given
3651 * size from the heap if they are given a NULL buffer pointer.
3652 * The problem is that this behaviour is not portable. */
3653 if (getcwd(buf, sizeof(buf) - 1)) {
3654 STRLEN len = strlen(buf);
3655 sv_setpvn(sv, buf, len);
3659 sv_setsv(sv, &PL_sv_undef);
3667 int orig_cdev, orig_cino, cdev, cino, odev, oino, tdev, tino;
3668 int namelen, pathlen=0;
3672 (void)SvUPGRADE(sv, SVt_PV);
3674 if (PerlLIO_lstat(".", &statbuf) < 0) {
3675 SV_CWD_RETURN_UNDEF;
3678 orig_cdev = statbuf.st_dev;
3679 orig_cino = statbuf.st_ino;
3687 if (PerlDir_chdir("..") < 0) {
3688 SV_CWD_RETURN_UNDEF;
3690 if (PerlLIO_stat(".", &statbuf) < 0) {
3691 SV_CWD_RETURN_UNDEF;
3694 cdev = statbuf.st_dev;
3695 cino = statbuf.st_ino;
3697 if (odev == cdev && oino == cino) {
3700 if (!(dir = PerlDir_open("."))) {
3701 SV_CWD_RETURN_UNDEF;
3704 while ((dp = PerlDir_read(dir)) != NULL) {
3706 namelen = dp->d_namlen;
3708 namelen = strlen(dp->d_name);
3711 if (SV_CWD_ISDOT(dp)) {
3715 if (PerlLIO_lstat(dp->d_name, &statbuf) < 0) {
3716 SV_CWD_RETURN_UNDEF;
3719 tdev = statbuf.st_dev;
3720 tino = statbuf.st_ino;
3721 if (tino == oino && tdev == odev) {
3727 SV_CWD_RETURN_UNDEF;
3730 if (pathlen + namelen + 1 >= MAXPATHLEN) {
3731 SV_CWD_RETURN_UNDEF;
3734 SvGROW(sv, pathlen + namelen + 1);
3738 Move(SvPVX(sv), SvPVX(sv) + namelen + 1, pathlen, char);
3741 /* prepend current directory to the front */
3743 Move(dp->d_name, SvPVX(sv)+1, namelen, char);
3744 pathlen += (namelen + 1);
3746 #ifdef VOID_CLOSEDIR
3749 if (PerlDir_close(dir) < 0) {
3750 SV_CWD_RETURN_UNDEF;
3756 SvCUR_set(sv, pathlen);
3760 if (PerlDir_chdir(SvPVX(sv)) < 0) {
3761 SV_CWD_RETURN_UNDEF;
3764 if (PerlLIO_stat(".", &statbuf) < 0) {
3765 SV_CWD_RETURN_UNDEF;
3768 cdev = statbuf.st_dev;
3769 cino = statbuf.st_ino;
3771 if (cdev != orig_cdev || cino != orig_cino) {
3772 Perl_croak(aTHX_ "Unstable directory path, "
3773 "current directory changed unexpectedly");
3785 =for apidoc scan_version
3787 Returns a pointer to the next character after the parsed
3788 version string, as well as upgrading the passed in SV to
3791 Function must be called with an already existing SV like
3794 s = scan_version(s,SV *sv, bool qv);
3796 Performs some preprocessing to the string to ensure that
3797 it has the correct characteristics of a version. Flags the
3798 object if it contains an underscore (which denotes this
3799 is a alpha version). The boolean qv denotes that the version
3800 should be interpreted as if it had multiple decimals, even if
3807 Perl_scan_version(pTHX_ char *s, SV *rv, bool qv)
3809 const char *start = s;
3813 SV* sv = newSVrv(rv, "version"); /* create an SV and upgrade the RV */
3814 (void)sv_upgrade(sv, SVt_PVAV); /* needs to be an AV type */
3817 /* pre-scan the imput string to check for decimals */
3818 while ( *pos == '.' || *pos == '_' || isDIGIT(*pos) )
3823 Perl_croak(aTHX_ "Invalid version format (underscores before decimal)");
3826 else if ( *pos == '_' )
3829 Perl_croak(aTHX_ "Invalid version format (multiple underscores)");
3837 pos++; /* get past 'v' */
3838 qv = 1; /* force quoted version processing */
3840 while (isDIGIT(*pos))
3842 if (!isALPHA(*pos)) {
3845 if (*s == 'v') s++; /* get past 'v' */
3850 /* this is atoi() that delimits on underscores */
3854 if ( s < pos && s > start && *(s-1) == '_' ) {
3855 mult *= -1; /* alpha version */
3857 /* the following if() will only be true after the decimal
3858 * point of a version originally created with a bare
3859 * floating point number, i.e. not quoted in any way
3861 if ( !qv && s > start+1 && saw_period == 1 ) {
3865 rev += (*s - '0') * mult;
3867 if ( PERL_ABS(orev) > PERL_ABS(rev) )
3868 Perl_croak(aTHX_ "Integer overflow in version");
3873 while (--end >= s) {
3875 rev += (*end - '0') * mult;
3877 if ( PERL_ABS(orev) > PERL_ABS(rev) )
3878 Perl_croak(aTHX_ "Integer overflow in version");
3883 /* Append revision */
3884 av_push((AV *)sv, newSViv(rev));
3885 if ( (*pos == '.' || *pos == '_') && isDIGIT(pos[1]))
3887 else if ( isDIGIT(*pos) )
3893 while ( isDIGIT(*pos) ) {
3894 if ( saw_period == 1 && pos-s == 3 )
3900 if ( qv ) { /* quoted versions always become full version objects */
3901 I32 len = av_len((AV *)sv);
3902 /* This for loop appears to trigger a compiler bug on OS X, as it
3903 loops infinitely. Yes, len is negative. No, it makes no sense.
3904 Compiler in question is:
3905 gcc version 3.3 20030304 (Apple Computer, Inc. build 1640)
3906 for ( len = 2 - len; len > 0; len-- )
3907 av_push((AV *)sv, newSViv(0));
3911 av_push((AV *)sv, newSViv(0));
3917 =for apidoc new_version
3919 Returns a new version object based on the passed in SV:
3921 SV *sv = new_version(SV *ver);
3923 Does not alter the passed in ver SV. See "upg_version" if you
3924 want to upgrade the SV.
3930 Perl_new_version(pTHX_ SV *ver)
3933 if ( sv_derived_from(ver,"version") ) /* can just copy directly */
3936 AV *av = (AV *)SvRV(ver);
3937 SV* sv = newSVrv(rv, "version"); /* create an SV and upgrade the RV */
3938 (void)sv_upgrade(sv, SVt_PVAV); /* needs to be an AV type */
3940 for ( key = 0; key <= av_len(av); key++ )
3942 I32 rev = SvIV(*av_fetch(av, key, FALSE));
3943 av_push((AV *)sv, newSViv(rev));
3948 if ( SvVOK(ver) ) { /* already a v-string */
3950 MAGIC* mg = mg_find(ver,PERL_MAGIC_vstring);
3951 version = savepvn( (const char*)mg->mg_ptr,mg->mg_len );
3952 sv_setpv(rv,version);
3957 sv_setsv(rv,ver); /* make a duplicate */
3966 =for apidoc upg_version
3968 In-place upgrade of the supplied SV to a version object.
3970 SV *sv = upg_version(SV *sv);
3972 Returns a pointer to the upgraded SV.
3978 Perl_upg_version(pTHX_ SV *ver)
3983 if ( SvNOK(ver) ) /* may get too much accuracy */
3986 sprintf(tbuf,"%.9"NVgf, SvNVX(ver));
3987 version = savepv(tbuf);
3990 else if ( SvVOK(ver) ) { /* already a v-string */
3991 MAGIC* mg = mg_find(ver,PERL_MAGIC_vstring);
3992 version = savepvn( (const char*)mg->mg_ptr,mg->mg_len );
3996 else /* must be a string or something like a string */
3998 version = savesvpv(ver);
4000 (void)scan_version(version, ver, qv);
4009 Accepts a version object and returns the normalized floating
4010 point representation. Call like:
4014 NOTE: you can pass either the object directly or the SV
4015 contained within the RV.
4021 Perl_vnumify(pTHX_ SV *vs)
4027 len = av_len((AV *)vs);
4030 Perl_sv_catpv(aTHX_ sv,"0");
4033 digit = SvIVX(*av_fetch((AV *)vs, 0, 0));
4034 Perl_sv_setpvf(aTHX_ sv,"%d.", (int)PERL_ABS(digit));
4035 for ( i = 1 ; i < len ; i++ )
4037 digit = SvIVX(*av_fetch((AV *)vs, i, 0));
4038 Perl_sv_catpvf(aTHX_ sv,"%03d", (int)PERL_ABS(digit));
4043 digit = SvIVX(*av_fetch((AV *)vs, len, 0));
4044 if ( (int)PERL_ABS(digit) != 0 || len == 1 )
4046 if ( digit < 0 ) /* alpha version */
4047 Perl_sv_catpv(aTHX_ sv,"_");
4048 /* Don't display additional trailing zeros */
4049 Perl_sv_catpvf(aTHX_ sv,"%03d", (int)PERL_ABS(digit));
4054 Perl_sv_catpv(aTHX_ sv,"000");
4062 Accepts a version object and returns the normalized string
4063 representation. Call like:
4067 NOTE: you can pass either the object directly or the SV
4068 contained within the RV.
4074 Perl_vnormal(pTHX_ SV *vs)
4080 len = av_len((AV *)vs);
4083 Perl_sv_catpv(aTHX_ sv,"");
4086 digit = SvIVX(*av_fetch((AV *)vs, 0, 0));
4087 Perl_sv_setpvf(aTHX_ sv,"%"IVdf,(IV)digit);
4088 for ( i = 1 ; i <= len ; i++ )
4090 digit = SvIVX(*av_fetch((AV *)vs, i, 0));
4092 Perl_sv_catpvf(aTHX_ sv,"_%"IVdf,(IV)-digit);
4094 Perl_sv_catpvf(aTHX_ sv,".%"IVdf,(IV)digit);
4097 if ( len <= 2 ) { /* short version, must be at least three */
4098 for ( len = 2 - len; len != 0; len-- )
4099 Perl_sv_catpv(aTHX_ sv,".0");
4106 =for apidoc vstringify
4108 In order to maintain maximum compatibility with earlier versions
4109 of Perl, this function will return either the floating point
4110 notation or the multiple dotted notation, depending on whether
4111 the original version contained 1 or more dots, respectively
4117 Perl_vstringify(pTHX_ SV *vs)
4122 len = av_len((AV *)vs);
4123 digit = SvIVX(*av_fetch((AV *)vs, len, 0));
4125 if ( len < 2 || ( len == 2 && digit < 0 ) )
4134 Version object aware cmp. Both operands must already have been
4135 converted into version objects.
4141 Perl_vcmp(pTHX_ SV *lsv, SV *rsv)
4148 l = av_len((AV *)lsv);
4149 r = av_len((AV *)rsv);
4153 while ( i <= m && retval == 0 )
4155 I32 left = SvIV(*av_fetch((AV *)lsv,i,0));
4156 I32 right = SvIV(*av_fetch((AV *)rsv,i,0));
4157 bool lalpha = left < 0 ? 1 : 0;
4158 bool ralpha = right < 0 ? 1 : 0;
4161 if ( left < right || (left == right && lalpha && !ralpha) )
4163 if ( left > right || (left == right && ralpha && !lalpha) )
4168 if ( l != r && retval == 0 ) /* possible match except for trailing 0's */
4172 while ( i <= r && retval == 0 )
4174 if ( SvIV(*av_fetch((AV *)rsv,i,0)) != 0 )
4175 retval = -1; /* not a match after all */
4181 while ( i <= l && retval == 0 )
4183 if ( SvIV(*av_fetch((AV *)lsv,i,0)) != 0 )
4184 retval = +1; /* not a match after all */
4192 #if !defined(HAS_SOCKETPAIR) && defined(HAS_SOCKET) && defined(AF_INET) && defined(PF_INET) && defined(SOCK_DGRAM) && defined(HAS_SELECT)
4193 # define EMULATE_SOCKETPAIR_UDP
4196 #ifdef EMULATE_SOCKETPAIR_UDP
4198 S_socketpair_udp (int fd[2]) {
4200 /* Fake a datagram socketpair using UDP to localhost. */
4201 int sockets[2] = {-1, -1};
4202 struct sockaddr_in addresses[2];
4204 Sock_size_t size = sizeof(struct sockaddr_in);
4205 unsigned short port;
4208 memset(&addresses, 0, sizeof(addresses));
4211 sockets[i] = PerlSock_socket(AF_INET, SOCK_DGRAM, PF_INET);
4212 if (sockets[i] == -1)
4213 goto tidy_up_and_fail;
4215 addresses[i].sin_family = AF_INET;
4216 addresses[i].sin_addr.s_addr = htonl(INADDR_LOOPBACK);
4217 addresses[i].sin_port = 0; /* kernel choses port. */
4218 if (PerlSock_bind(sockets[i], (struct sockaddr *) &addresses[i],
4219 sizeof(struct sockaddr_in)) == -1)
4220 goto tidy_up_and_fail;
4223 /* Now have 2 UDP sockets. Find out which port each is connected to, and
4224 for each connect the other socket to it. */
4227 if (PerlSock_getsockname(sockets[i], (struct sockaddr *) &addresses[i],
4229 goto tidy_up_and_fail;
4230 if (size != sizeof(struct sockaddr_in))
4231 goto abort_tidy_up_and_fail;
4232 /* !1 is 0, !0 is 1 */
4233 if (PerlSock_connect(sockets[!i], (struct sockaddr *) &addresses[i],
4234 sizeof(struct sockaddr_in)) == -1)
4235 goto tidy_up_and_fail;
4238 /* Now we have 2 sockets connected to each other. I don't trust some other
4239 process not to have already sent a packet to us (by random) so send
4240 a packet from each to the other. */
4243 /* I'm going to send my own port number. As a short.
4244 (Who knows if someone somewhere has sin_port as a bitfield and needs
4245 this routine. (I'm assuming crays have socketpair)) */
4246 port = addresses[i].sin_port;
4247 got = PerlLIO_write(sockets[i], &port, sizeof(port));
4248 if (got != sizeof(port)) {
4250 goto tidy_up_and_fail;
4251 goto abort_tidy_up_and_fail;
4255 /* Packets sent. I don't trust them to have arrived though.
4256 (As I understand it Solaris TCP stack is multithreaded. Non-blocking
4257 connect to localhost will use a second kernel thread. In 2.6 the
4258 first thread running the connect() returns before the second completes,
4259 so EINPROGRESS> In 2.7 the improved stack is faster and connect()
4260 returns 0. Poor programs have tripped up. One poor program's authors'
4261 had a 50-1 reverse stock split. Not sure how connected these were.)
4262 So I don't trust someone not to have an unpredictable UDP stack.
4266 struct timeval waitfor = {0, 100000}; /* You have 0.1 seconds */
4267 int max = sockets[1] > sockets[0] ? sockets[1] : sockets[0];
4271 FD_SET(sockets[0], &rset);
4272 FD_SET(sockets[1], &rset);
4274 got = PerlSock_select(max + 1, &rset, NULL, NULL, &waitfor);
4275 if (got != 2 || !FD_ISSET(sockets[0], &rset)
4276 || !FD_ISSET(sockets[1], &rset)) {
4277 /* I hope this is portable and appropriate. */
4279 goto tidy_up_and_fail;
4280 goto abort_tidy_up_and_fail;
4284 /* And the paranoia department even now doesn't trust it to have arrive
4285 (hence MSG_DONTWAIT). Or that what arrives was sent by us. */
4287 struct sockaddr_in readfrom;
4288 unsigned short buffer[2];
4293 got = PerlSock_recvfrom(sockets[i], (char *) &buffer,
4294 sizeof(buffer), MSG_DONTWAIT,
4295 (struct sockaddr *) &readfrom, &size);
4297 got = PerlSock_recvfrom(sockets[i], (char *) &buffer,
4299 (struct sockaddr *) &readfrom, &size);
4303 goto tidy_up_and_fail;
4304 if (got != sizeof(port)
4305 || size != sizeof(struct sockaddr_in)
4306 /* Check other socket sent us its port. */
4307 || buffer[0] != (unsigned short) addresses[!i].sin_port
4308 /* Check kernel says we got the datagram from that socket */
4309 || readfrom.sin_family != addresses[!i].sin_family
4310 || readfrom.sin_addr.s_addr != addresses[!i].sin_addr.s_addr
4311 || readfrom.sin_port != addresses[!i].sin_port)
4312 goto abort_tidy_up_and_fail;
4315 /* My caller (my_socketpair) has validated that this is non-NULL */
4318 /* I hereby declare this connection open. May God bless all who cross
4322 abort_tidy_up_and_fail:
4323 errno = ECONNABORTED;
4326 int save_errno = errno;
4327 if (sockets[0] != -1)
4328 PerlLIO_close(sockets[0]);
4329 if (sockets[1] != -1)
4330 PerlLIO_close(sockets[1]);
4335 #endif /* EMULATE_SOCKETPAIR_UDP */
4337 #if !defined(HAS_SOCKETPAIR) && defined(HAS_SOCKET) && defined(AF_INET) && defined(PF_INET)
4339 Perl_my_socketpair (int family, int type, int protocol, int fd[2]) {
4340 /* Stevens says that family must be AF_LOCAL, protocol 0.
4341 I'm going to enforce that, then ignore it, and use TCP (or UDP). */
4346 struct sockaddr_in listen_addr;
4347 struct sockaddr_in connect_addr;
4352 || family != AF_UNIX
4355 errno = EAFNOSUPPORT;
4363 #ifdef EMULATE_SOCKETPAIR_UDP
4364 if (type == SOCK_DGRAM)
4365 return S_socketpair_udp(fd);
4368 listener = PerlSock_socket(AF_INET, type, 0);
4371 memset(&listen_addr, 0, sizeof(listen_addr));
4372 listen_addr.sin_family = AF_INET;
4373 listen_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
4374 listen_addr.sin_port = 0; /* kernel choses port. */
4375 if (PerlSock_bind(listener, (struct sockaddr *) &listen_addr,
4376 sizeof(listen_addr)) == -1)
4377 goto tidy_up_and_fail;
4378 if (PerlSock_listen(listener, 1) == -1)
4379 goto tidy_up_and_fail;
4381 connector = PerlSock_socket(AF_INET, type, 0);
4382 if (connector == -1)
4383 goto tidy_up_and_fail;
4384 /* We want to find out the port number to connect to. */
4385 size = sizeof(connect_addr);
4386 if (PerlSock_getsockname(listener, (struct sockaddr *) &connect_addr,
4388 goto tidy_up_and_fail;
4389 if (size != sizeof(connect_addr))
4390 goto abort_tidy_up_and_fail;
4391 if (PerlSock_connect(connector, (struct sockaddr *) &connect_addr,
4392 sizeof(connect_addr)) == -1)
4393 goto tidy_up_and_fail;
4395 size = sizeof(listen_addr);
4396 acceptor = PerlSock_accept(listener, (struct sockaddr *) &listen_addr,
4399 goto tidy_up_and_fail;
4400 if (size != sizeof(listen_addr))
4401 goto abort_tidy_up_and_fail;
4402 PerlLIO_close(listener);
4403 /* Now check we are talking to ourself by matching port and host on the
4405 if (PerlSock_getsockname(connector, (struct sockaddr *) &connect_addr,
4407 goto tidy_up_and_fail;
4408 if (size != sizeof(connect_addr)
4409 || listen_addr.sin_family != connect_addr.sin_family
4410 || listen_addr.sin_addr.s_addr != connect_addr.sin_addr.s_addr
4411 || listen_addr.sin_port != connect_addr.sin_port) {
4412 goto abort_tidy_up_and_fail;
4418 abort_tidy_up_and_fail:
4419 errno = ECONNABORTED; /* I hope this is portable and appropriate. */
4422 int save_errno = errno;
4424 PerlLIO_close(listener);
4425 if (connector != -1)
4426 PerlLIO_close(connector);
4428 PerlLIO_close(acceptor);
4434 /* In any case have a stub so that there's code corresponding
4435 * to the my_socketpair in global.sym. */
4437 Perl_my_socketpair (int family, int type, int protocol, int fd[2]) {
4438 #ifdef HAS_SOCKETPAIR
4439 return socketpair(family, type, protocol, fd);
4448 =for apidoc sv_nosharing
4450 Dummy routine which "shares" an SV when there is no sharing module present.
4451 Exists to avoid test for a NULL function pointer and because it could potentially warn under
4452 some level of strict-ness.
4458 Perl_sv_nosharing(pTHX_ SV *sv)
4463 =for apidoc sv_nolocking
4465 Dummy routine which "locks" an SV when there is no locking module present.
4466 Exists to avoid test for a NULL function pointer and because it could potentially warn under
4467 some level of strict-ness.
4473 Perl_sv_nolocking(pTHX_ SV *sv)
4479 =for apidoc sv_nounlocking
4481 Dummy routine which "unlocks" an SV when there is no locking module present.
4482 Exists to avoid test for a NULL function pointer and because it could potentially warn under
4483 some level of strict-ness.
4489 Perl_sv_nounlocking(pTHX_ SV *sv)
4494 Perl_parse_unicode_opts(pTHX_ char **popt)
4501 opt = (U32) atoi(p);
4502 while (isDIGIT(*p)) p++;
4503 if (*p && *p != '\n' && *p != '\r')
4504 Perl_croak(aTHX_ "Unknown Unicode option letter '%c'", *p);
4509 case PERL_UNICODE_STDIN:
4510 opt |= PERL_UNICODE_STDIN_FLAG; break;
4511 case PERL_UNICODE_STDOUT:
4512 opt |= PERL_UNICODE_STDOUT_FLAG; break;
4513 case PERL_UNICODE_STDERR:
4514 opt |= PERL_UNICODE_STDERR_FLAG; break;
4515 case PERL_UNICODE_STD:
4516 opt |= PERL_UNICODE_STD_FLAG; break;
4517 case PERL_UNICODE_IN:
4518 opt |= PERL_UNICODE_IN_FLAG; break;
4519 case PERL_UNICODE_OUT:
4520 opt |= PERL_UNICODE_OUT_FLAG; break;
4521 case PERL_UNICODE_INOUT:
4522 opt |= PERL_UNICODE_INOUT_FLAG; break;
4523 case PERL_UNICODE_LOCALE:
4524 opt |= PERL_UNICODE_LOCALE_FLAG; break;
4525 case PERL_UNICODE_ARGV:
4526 opt |= PERL_UNICODE_ARGV_FLAG; break;
4528 if (*p != '\n' && *p != '\r')
4530 "Unknown Unicode option letter '%c'", *p);
4536 opt = PERL_UNICODE_DEFAULT_FLAGS;
4538 if (opt & ~PERL_UNICODE_ALL_FLAGS)
4539 Perl_croak(aTHX_ "Unknown Unicode option value %"UVuf,
4540 (UV) (opt & ~PERL_UNICODE_ALL_FLAGS));
4551 * This is really just a quick hack which grabs various garbage
4552 * values. It really should be a real hash algorithm which
4553 * spreads the effect of every input bit onto every output bit,
4554 * if someone who knows about such things would bother to write it.
4555 * Might be a good idea to add that function to CORE as well.
4556 * No numbers below come from careful analysis or anything here,
4557 * except they are primes and SEED_C1 > 1E6 to get a full-width
4558 * value from (tv_sec * SEED_C1 + tv_usec). The multipliers should
4559 * probably be bigger too.
4562 # define SEED_C1 1000003
4563 #define SEED_C4 73819
4565 # define SEED_C1 25747
4566 #define SEED_C4 20639
4570 #define SEED_C5 26107
4572 #ifndef PERL_NO_DEV_RANDOM
4577 # include <starlet.h>
4578 /* when[] = (low 32 bits, high 32 bits) of time since epoch
4579 * in 100-ns units, typically incremented ever 10 ms. */
4580 unsigned int when[2];
4582 # ifdef HAS_GETTIMEOFDAY
4583 struct timeval when;
4589 /* This test is an escape hatch, this symbol isn't set by Configure. */
4590 #ifndef PERL_NO_DEV_RANDOM
4591 #ifndef PERL_RANDOM_DEVICE
4592 /* /dev/random isn't used by default because reads from it will block
4593 * if there isn't enough entropy available. You can compile with
4594 * PERL_RANDOM_DEVICE to it if you'd prefer Perl to block until there
4595 * is enough real entropy to fill the seed. */
4596 # define PERL_RANDOM_DEVICE "/dev/urandom"
4598 fd = PerlLIO_open(PERL_RANDOM_DEVICE, 0);
4600 if (PerlLIO_read(fd, &u, sizeof u) != sizeof u)
4609 _ckvmssts(sys$gettim(when));
4610 u = (U32)SEED_C1 * when[0] + (U32)SEED_C2 * when[1];
4612 # ifdef HAS_GETTIMEOFDAY
4613 PerlProc_gettimeofday(&when,NULL);
4614 u = (U32)SEED_C1 * when.tv_sec + (U32)SEED_C2 * when.tv_usec;
4617 u = (U32)SEED_C1 * when;
4620 u += SEED_C3 * (U32)PerlProc_getpid();
4621 u += SEED_C4 * (U32)PTR2UV(PL_stack_sp);
4622 #ifndef PLAN9 /* XXX Plan9 assembler chokes on this; fix needed */
4623 u += SEED_C5 * (U32)PTR2UV(&when);
4629 Perl_get_hash_seed(pTHX)
4631 char *s = PerlEnv_getenv("PERL_HASH_SEED");
4635 while (isSPACE(*s)) s++;
4636 if (s && isDIGIT(*s))
4637 myseed = (UV)Atoul(s);
4639 #ifdef USE_HASH_SEED_EXPLICIT
4643 /* Compute a random seed */
4644 (void)seedDrand01((Rand_seed_t)seed());
4645 myseed = (UV)(Drand01() * (NV)UV_MAX);
4646 #if RANDBITS < (UVSIZE * 8)
4647 /* Since there are not enough randbits to to reach all
4648 * the bits of a UV, the low bits might need extra
4649 * help. Sum in another random number that will
4650 * fill in the low bits. */
4652 (UV)(Drand01() * (NV)((1 << ((UVSIZE * 8 - RANDBITS))) - 1));
4653 #endif /* RANDBITS < (UVSIZE * 8) */
4654 if (myseed == 0) { /* Superparanoia. */
4655 myseed = (UV)(Drand01() * (NV)UV_MAX); /* One more chance. */
4657 Perl_croak(aTHX_ "Your random numbers are not that random");
4660 PL_rehash_seed_set = TRUE;