perl.c

   1 /*    perl.c
   2  *
   3  *    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   4  *    2000, 2001, 2002, 2003, 2004, 2005, by Larry Wall and others
   5  *
   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.
   8  *
   9  */
  10
  11 /*
  12  * "A ship then new they built for him/of mithril and of elven glass" --Bilbo
  13  */
  14
  15 /* This file contains the top-level functions that are used to create, use
  16  * and destroy a perl interpreter, plus the functions used by XS code to
  17  * call back into perl. Note that it does not contain the actual main()
  18  * function of the interpreter; that can be found in perlmain.c
  19  */
  20
  21 /* PSz 12 Nov 03
  22  *
  23  * Be proud that perl(1) may proclaim:
  24  *   Setuid Perl scripts are safer than C programs ...
  25  * Do not abandon (deprecate) suidperl. Do not advocate C wrappers.
  26  *
  27  * The flow was: perl starts, notices script is suid, execs suidperl with same
  28  * arguments; suidperl opens script, checks many things, sets itself with
  29  * right UID, execs perl with similar arguments but with script pre-opened on
  30  * /dev/fd/xxx; perl checks script is as should be and does work. This was
  31  * insecure: see perlsec(1) for many problems with this approach.
  32  *
  33  * The "correct" flow should be: perl starts, opens script and notices it is
  34  * suid, checks many things, execs suidperl with similar arguments but with
  35  * script on /dev/fd/xxx; suidperl checks script and /dev/fd/xxx object are
  36  * same, checks arguments match #! line, sets itself with right UID, execs
  37  * perl with same arguments; perl checks many things and does work.
  38  *
  39  * (Opening the script in perl instead of suidperl, we "lose" scripts that
  40  * are readable to the target UID but not to the invoker. Where did
  41  * unreadable scripts work anyway?)
  42  *
  43  * For now, suidperl and perl are pretty much the same large and cumbersome
  44  * program, so suidperl can check its argument list (see comments elsewhere).
  45  *
  46  * References:
  47  * Original bug report:
  48  *   http://bugs.perl.org/index.html?req=bug_id&bug_id=20010322.218
  49  *   http://rt.perl.org/rt2/Ticket/Display.html?id=6511
  50  * Comments and discussion with Debian:
  51  *   http://bugs.debian.org/203426
  52  *   http://bugs.debian.org/220486
  53  * Debian Security Advisory DSA 431-1 (does not fully fix problem):
  54  *   http://www.debian.org/security/2004/dsa-431
  55  * CVE candidate:
  56  *   http://cve.mitre.org/cgi-bin/cvename.cgi?name=CAN-2003-0618
  57  * Previous versions of this patch sent to perl5-porters:
  58  *   http://www.mail-archive.com/perl5-porters@perl.org/msg71953.html
  59  *   http://www.mail-archive.com/perl5-porters@perl.org/msg75245.html
  60  *   http://www.mail-archive.com/perl5-porters@perl.org/msg75563.html
  61  *   http://www.mail-archive.com/perl5-porters@perl.org/msg75635.html
  62  *
  63 Paul Szabo - psz@maths.usyd.edu.au  http://www.maths.usyd.edu.au:8000/u/psz/
  64 School of Mathematics and Statistics  University of Sydney   2006  Australia
  65  *
  66  */
  67 /* PSz 13 Nov 03
  68  * Use truthful, neat, specific error messages.
  69  * Cannot always hide the truth; security must not depend on doing so.
  70  */
  71
  72 /* PSz 18 Feb 04
  73  * Use global(?), thread-local fdscript for easier checks.
  74  * (I do not understand how we could possibly get a thread race:
  75  * do not all threads go through the same initialization? Or in
  76  * fact, are not threads started only after we get the script and
  77  * so know what to do? Oh well, make things super-safe...)
  78  */
  79
  80 #include "EXTERN.h"
  81 #define PERL_IN_PERL_C
  82 #include "perl.h"
  83 #include "patchlevel.h"                 /* for local_patches */
  84
  85 #ifdef NETWARE
  86 #include "nwutil.h"
  87 char *nw_get_sitelib(const char *pl);
  88 #endif
  89
  90 /* XXX If this causes problems, set i_unistd=undef in the hint file.  */
  91 #ifdef I_UNISTD
  92 #include <unistd.h>
  93 #endif
  94
  95 #ifdef __BEOS__
  96 #  define HZ 1000000
  97 #endif
  98
  99 #ifndef HZ
 100 #  ifdef CLK_TCK
 101 #    define HZ CLK_TCK
 102 #  else
 103 #    define HZ 60
 104 #  endif
 105 #endif
 106
 107 #if !defined(STANDARD_C) && !defined(HAS_GETENV_PROTOTYPE) && !defined(PERL_MICRO)
 108 char *getenv (char *); /* Usually in <stdlib.h> */
 109 #endif
 110
 111 static I32 read_e_script(pTHX_ int idx, SV *buf_sv, int maxlen);
 112
 113 #ifdef IAMSUID
 114 #ifndef DOSUID
 115 #define DOSUID
 116 #endif
 117 #endif /* IAMSUID */
 118
 119 #ifdef SETUID_SCRIPTS_ARE_SECURE_NOW
 120 #ifdef DOSUID
 121 #undef DOSUID
 122 #endif
 123 #endif
 124
 125 static void
 126 S_init_tls_and_interp(PerlInterpreter *my_perl)
 127 {
 128     dVAR;
 129     if (!PL_curinterp) {
 130         PERL_SET_INTERP(my_perl);
 131 #if defined(USE_ITHREADS)
 132         INIT_THREADS;
 133         ALLOC_THREAD_KEY;
 134         PERL_SET_THX(my_perl);
 135         OP_REFCNT_INIT;
 136         MUTEX_INIT(&PL_dollarzero_mutex);
 137 #  endif
 138     }
 139     else {
 140         PERL_SET_THX(my_perl);
 141     }
 142 }
 143
 144 #ifdef PERL_IMPLICIT_SYS
 145 PerlInterpreter *
 146 perl_alloc_using(struct IPerlMem* ipM, struct IPerlMem* ipMS,
 147                  struct IPerlMem* ipMP, struct IPerlEnv* ipE,
 148                  struct IPerlStdIO* ipStd, struct IPerlLIO* ipLIO,
 149                  struct IPerlDir* ipD, struct IPerlSock* ipS,
 150                  struct IPerlProc* ipP)
 151 {
 152     PerlInterpreter *my_perl;
 153     /* New() needs interpreter, so call malloc() instead */
 154     my_perl = (PerlInterpreter*)(*ipM->pMalloc)(ipM, sizeof(PerlInterpreter));
 155     S_init_tls_and_interp(my_perl);
 156     Zero(my_perl, 1, PerlInterpreter);
 157     PL_Mem = ipM;
 158     PL_MemShared = ipMS;
 159     PL_MemParse = ipMP;
 160     PL_Env = ipE;
 161     PL_StdIO = ipStd;
 162     PL_LIO = ipLIO;
 163     PL_Dir = ipD;
 164     PL_Sock = ipS;
 165     PL_Proc = ipP;
 166
 167     return my_perl;
 168 }
 169 #else
 170
 171 /*
 172 =head1 Embedding Functions
 173
 174 =for apidoc perl_alloc
 175
 176 Allocates a new Perl interpreter.  See L<perlembed>.
 177
 178 =cut
 179 */
 180
 181 PerlInterpreter *
 182 perl_alloc(void)
 183 {
 184     PerlInterpreter *my_perl;
 185
 186     /* New() needs interpreter, so call malloc() instead */
 187     my_perl = (PerlInterpreter*)PerlMem_malloc(sizeof(PerlInterpreter));
 188
 189     S_init_tls_and_interp(my_perl);
 190     return (PerlInterpreter *) ZeroD(my_perl, 1, PerlInterpreter);
 191 }
 192 #endif /* PERL_IMPLICIT_SYS */
 193
 194 /*
 195 =for apidoc perl_construct
 196
 197 Initializes a new Perl interpreter.  See L<perlembed>.
 198
 199 =cut
 200 */
 201
 202 void
 203 perl_construct(pTHXx)
 204 {
 205     dVAR;
 206 #ifdef MULTIPLICITY
 207     init_interp();
 208     PL_perl_destruct_level = 1;
 209 #else
 210    if (PL_perl_destruct_level > 0)
 211        init_interp();
 212 #endif
 213    /* Init the real globals (and main thread)? */
 214     if (!PL_linestr) {
 215         PL_curcop = &PL_compiling;      /* needed by ckWARN, right away */
 216
 217         PL_linestr = NEWSV(65,79);
 218         sv_upgrade(PL_linestr,SVt_PVIV);
 219
 220         if (!SvREADONLY(&PL_sv_undef)) {
 221             /* set read-only and try to insure than we wont see REFCNT==0
 222                very often */
 223
 224             SvREADONLY_on(&PL_sv_undef);
 225             SvREFCNT(&PL_sv_undef) = (~(U32)0)/2;
 226
 227             sv_setpv(&PL_sv_no,PL_No);
 228             /* value lookup in void context - happens to have the side effect
 229                of caching the numeric forms.  */
 230             SvIV(&PL_sv_no);
 231             SvNV(&PL_sv_no);
 232             SvREADONLY_on(&PL_sv_no);
 233             SvREFCNT(&PL_sv_no) = (~(U32)0)/2;
 234
 235             sv_setpv(&PL_sv_yes,PL_Yes);
 236             SvIV(&PL_sv_yes);
 237             SvNV(&PL_sv_yes);
 238             SvREADONLY_on(&PL_sv_yes);
 239             SvREFCNT(&PL_sv_yes) = (~(U32)0)/2;
 240
 241             SvREADONLY_on(&PL_sv_placeholder);
 242             SvREFCNT(&PL_sv_placeholder) = (~(U32)0)/2;
 243         }
 244
 245         PL_sighandlerp = Perl_sighandler;
 246         PL_pidstatus = newHV();
 247     }
 248
 249     PL_rs = newSVpvn("\n", 1);
 250
 251     init_stacks();
 252
 253     init_ids();
 254     PL_lex_state = LEX_NOTPARSING;
 255
 256     JMPENV_BOOTSTRAP;
 257     STATUS_ALL_SUCCESS;
 258
 259     init_i18nl10n(1);
 260     SET_NUMERIC_STANDARD();
 261
 262 #if defined(LOCAL_PATCH_COUNT)
 263     PL_localpatches = local_patches;    /* For possible -v */
 264 #endif
 265
 266 #ifdef HAVE_INTERP_INTERN
 267     sys_intern_init();
 268 #endif
 269
 270     PerlIO_init(aTHX);                  /* Hook to IO system */
 271
 272     PL_fdpid = newAV();                 /* for remembering popen pids by fd */
 273     PL_modglobal = newHV();             /* pointers to per-interpreter module globals */
 274     PL_errors = newSVpvn("",0);
 275     sv_setpvn(PERL_DEBUG_PAD(0), "", 0);        /* For regex debugging. */
 276     sv_setpvn(PERL_DEBUG_PAD(1), "", 0);        /* ext/re needs these */
 277     sv_setpvn(PERL_DEBUG_PAD(2), "", 0);        /* even without DEBUGGING. */
 278 #ifdef USE_ITHREADS
 279     PL_regex_padav = newAV();
 280     av_push(PL_regex_padav,(SV*)newAV());    /* First entry is an array of empty elements */
 281     PL_regex_pad = AvARRAY(PL_regex_padav);
 282 #endif
 283 #ifdef USE_REENTRANT_API
 284     Perl_reentrant_init(aTHX);
 285 #endif
 286
 287     /* Note that strtab is a rather special HV.  Assumptions are made
 288        about not iterating on it, and not adding tie magic to it.
 289        It is properly deallocated in perl_destruct() */
 290     PL_strtab = newHV();
 291
 292     HvSHAREKEYS_off(PL_strtab);                 /* mandatory */
 293     hv_ksplit(PL_strtab, 512);
 294
 295 #if defined(__DYNAMIC__) && (defined(NeXT) || defined(__NeXT__))
 296     _dyld_lookup_and_bind
 297         ("__environ", (unsigned long *) &environ_pointer, NULL);
 298 #endif /* environ */
 299
 300 #ifndef PERL_MICRO
 301 #   ifdef  USE_ENVIRON_ARRAY
 302     PL_origenviron = environ;
 303 #   endif
 304 #endif
 305
 306     /* Use sysconf(_SC_CLK_TCK) if available, if not
 307      * available or if the sysconf() fails, use the HZ.
 308      * BeOS has those, but returns the wrong value.
 309      * The HZ if not originally defined has been by now
 310      * been defined as CLK_TCK, if available. */
 311 #if defined(HAS_SYSCONF) && defined(_SC_CLK_TCK) && !defined(__BEOS__)
 312     PL_clocktick = sysconf(_SC_CLK_TCK);
 313     if (PL_clocktick <= 0)
 314 #endif
 315          PL_clocktick = HZ;
 316
 317     PL_stashcache = newHV();
 318
 319     PL_patchlevel = newSVpv(
 320             Perl_form(aTHX_ "%d.%d.%d",
 321             (int)PERL_REVISION,
 322             (int)PERL_VERSION,
 323             (int)PERL_SUBVERSION ), 0
 324     );
 325
 326 #ifdef HAS_MMAP
 327     if (!PL_mmap_page_size) {
 328 #if defined(HAS_SYSCONF) && (defined(_SC_PAGESIZE) || defined(_SC_MMAP_PAGE_SIZE))
 329       {
 330         SETERRNO(0, SS_NORMAL);
 331 #   ifdef _SC_PAGESIZE
 332         PL_mmap_page_size = sysconf(_SC_PAGESIZE);
 333 #   else
 334         PL_mmap_page_size = sysconf(_SC_MMAP_PAGE_SIZE);
 335 #   endif
 336         if ((long) PL_mmap_page_size < 0) {
 337           if (errno) {
 338             SV *error = ERRSV;
 339             char *msg;
 340             STRLEN n_a;
 341             (void) SvUPGRADE(error, SVt_PV);
 342             msg = SvPVx(error, n_a);
 343             Perl_croak(aTHX_ "panic: sysconf: %s", msg);
 344           }
 345           else
 346             Perl_croak(aTHX_ "panic: sysconf: pagesize unknown");
 347         }
 348       }
 349 #else
 350 #   ifdef HAS_GETPAGESIZE
 351       PL_mmap_page_size = getpagesize();
 352 #   else
 353 #       if defined(I_SYS_PARAM) && defined(PAGESIZE)
 354       PL_mmap_page_size = PAGESIZE;       /* compiletime, bad */
 355 #       endif
 356 #   endif
 357 #endif
 358       if (PL_mmap_page_size <= 0)
 359         Perl_croak(aTHX_ "panic: bad pagesize %" IVdf,
 360                    (IV) PL_mmap_page_size);
 361     }
 362 #endif /* HAS_MMAP */
 363
 364 #if defined(HAS_TIMES) && defined(PERL_NEED_TIMESBASE)
 365     PL_timesbase.tms_utime  = 0;
 366     PL_timesbase.tms_stime  = 0;
 367     PL_timesbase.tms_cutime = 0;
 368     PL_timesbase.tms_cstime = 0;
 369 #endif
 370
 371     ENTER;
 372 }
 373
 374 /*
 375 =for apidoc nothreadhook
 376
 377 Stub that provides thread hook for perl_destruct when there are
 378 no threads.
 379
 380 =cut
 381 */
 382
 383 int
 384 Perl_nothreadhook(pTHX)
 385 {
 386     return 0;
 387 }
 388
 389 /*
 390 =for apidoc perl_destruct
 391
 392 Shuts down a Perl interpreter.  See L<perlembed>.
 393
 394 =cut
 395 */
 396
 397 int
 398 perl_destruct(pTHXx)
 399 {
 400     dVAR;
 401     volatile int destruct_level;  /* 0=none, 1=full, 2=full with checks */
 402     HV *hv;
 403
 404     /* wait for all pseudo-forked children to finish */
 405     PERL_WAIT_FOR_CHILDREN;
 406
 407     destruct_level = PL_perl_destruct_level;
 408 #ifdef DEBUGGING
 409     {
 410         char *s;
 411         if ((s = PerlEnv_getenv("PERL_DESTRUCT_LEVEL"))) {
 412             const int i = atoi(s);
 413             if (destruct_level < i)
 414                 destruct_level = i;
 415         }
 416     }
 417 #endif
 418
 419     if (PL_exit_flags & PERL_EXIT_DESTRUCT_END) {
 420         dJMPENV;
 421         int x = 0;
 422
 423         JMPENV_PUSH(x);
 424         if (PL_endav && !PL_minus_c)
 425             call_list(PL_scopestack_ix, PL_endav);
 426         JMPENV_POP;
 427     }
 428     LEAVE;
 429     FREETMPS;
 430
 431     /* Need to flush since END blocks can produce output */
 432     my_fflush_all();
 433
 434     if (CALL_FPTR(PL_threadhook)(aTHX)) {
 435         /* Threads hook has vetoed further cleanup */
 436         return STATUS_NATIVE_EXPORT;
 437     }
 438
 439     /* We must account for everything.  */
 440
 441     /* Destroy the main CV and syntax tree */
 442     if (PL_main_root) {
 443         /* ensure comppad/curpad to refer to main's pad */
 444         if (CvPADLIST(PL_main_cv)) {
 445             PAD_SET_CUR_NOSAVE(CvPADLIST(PL_main_cv), 1);
 446         }
 447         op_free(PL_main_root);
 448         PL_main_root = Nullop;
 449     }
 450     PL_curcop = &PL_compiling;
 451     PL_main_start = Nullop;
 452     SvREFCNT_dec(PL_main_cv);
 453     PL_main_cv = Nullcv;
 454     PL_dirty = TRUE;
 455
 456     /* Tell PerlIO we are about to tear things apart in case
 457        we have layers which are using resources that should
 458        be cleaned up now.
 459      */
 460
 461     PerlIO_destruct(aTHX);
 462
 463     if (PL_sv_objcount) {
 464         /*
 465          * Try to destruct global references.  We do this first so that the
 466          * destructors and destructees still exist.  Some sv's might remain.
 467          * Non-referenced objects are on their own.
 468          */
 469         sv_clean_objs();
 470         PL_sv_objcount = 0;
 471     }
 472
 473     /* unhook hooks which will soon be, or use, destroyed data */
 474     SvREFCNT_dec(PL_warnhook);
 475     PL_warnhook = Nullsv;
 476     SvREFCNT_dec(PL_diehook);
 477     PL_diehook = Nullsv;
 478
 479     /* call exit list functions */
 480     while (PL_exitlistlen-- > 0)
 481         PL_exitlist[PL_exitlistlen].fn(aTHX_ PL_exitlist[PL_exitlistlen].ptr);
 482
 483     Safefree(PL_exitlist);
 484
 485     PL_exitlist = NULL;
 486     PL_exitlistlen = 0;
 487
 488     if (destruct_level == 0){
 489
 490         DEBUG_P(debprofdump());
 491
 492 #if defined(PERLIO_LAYERS)
 493         /* No more IO - including error messages ! */
 494         PerlIO_cleanup(aTHX);
 495 #endif
 496
 497         /* The exit() function will do everything that needs doing. */
 498         return STATUS_NATIVE_EXPORT;
 499     }
 500
 501     /* jettison our possibly duplicated environment */
 502     /* if PERL_USE_SAFE_PUTENV is defined environ will not have been copied
 503      * so we certainly shouldn't free it here
 504      */
 505 #ifndef PERL_MICRO
 506 #if defined(USE_ENVIRON_ARRAY) && !defined(PERL_USE_SAFE_PUTENV)
 507     if (environ != PL_origenviron && !PL_use_safe_putenv
 508 #ifdef USE_ITHREADS
 509         /* only main thread can free environ[0] contents */
 510         && PL_curinterp == aTHX
 511 #endif
 512         )
 513     {
 514         I32 i;
 515
 516         for (i = 0; environ[i]; i++)
 517             safesysfree(environ[i]);
 518
 519         /* Must use safesysfree() when working with environ. */
 520         safesysfree(environ);
 521
 522         environ = PL_origenviron;
 523     }
 524 #endif
 525 #endif /* !PERL_MICRO */
 526
 527     /* reset so print() ends up where we expect */
 528     setdefout(Nullgv);
 529
 530 #ifdef USE_ITHREADS
 531     /* the syntax tree is shared between clones
 532      * so op_free(PL_main_root) only ReREFCNT_dec's
 533      * REGEXPs in the parent interpreter
 534      * we need to manually ReREFCNT_dec for the clones
 535      */
 536     {
 537         I32 i = AvFILLp(PL_regex_padav) + 1;
 538         SV **ary = AvARRAY(PL_regex_padav);
 539
 540         while (i) {
 541             SV *resv = ary[--i];
 542             REGEXP *re = INT2PTR(REGEXP *,SvIVX(resv));
 543
 544             if (SvFLAGS(resv) & SVf_BREAK) {
 545                 /* this is PL_reg_curpm, already freed
 546                  * flag is set in regexec.c:S_regtry
 547                  */
 548                 SvFLAGS(resv) &= ~SVf_BREAK;
 549             }
 550             else if(SvREPADTMP(resv)) {
 551               SvREPADTMP_off(resv);
 552             }
 553             else {
 554                 ReREFCNT_dec(re);
 555             }
 556         }
 557     }
 558     SvREFCNT_dec(PL_regex_padav);
 559     PL_regex_padav = Nullav;
 560     PL_regex_pad = NULL;
 561 #endif
 562
 563     SvREFCNT_dec((SV*) PL_stashcache);
 564     PL_stashcache = NULL;
 565
 566     /* loosen bonds of global variables */
 567
 568     if(PL_rsfp) {
 569         (void)PerlIO_close(PL_rsfp);
 570         PL_rsfp = Nullfp;
 571     }
 572
 573     /* Filters for program text */
 574     SvREFCNT_dec(PL_rsfp_filters);
 575     PL_rsfp_filters = Nullav;
 576
 577     /* switches */
 578     PL_preprocess   = FALSE;
 579     PL_minus_n      = FALSE;
 580     PL_minus_p      = FALSE;
 581     PL_minus_l      = FALSE;
 582     PL_minus_a      = FALSE;
 583     PL_minus_F      = FALSE;
 584     PL_doswitches   = FALSE;
 585     PL_dowarn       = G_WARN_OFF;
 586     PL_doextract    = FALSE;
 587     PL_sawampersand = FALSE;    /* must save all match strings */
 588     PL_unsafe       = FALSE;
 589
 590     Safefree(PL_inplace);
 591     PL_inplace = Nullch;
 592     SvREFCNT_dec(PL_patchlevel);
 593
 594     if (PL_e_script) {
 595         SvREFCNT_dec(PL_e_script);
 596         PL_e_script = Nullsv;
 597     }
 598
 599     PL_perldb = 0;
 600
 601     /* magical thingies */
 602
 603     SvREFCNT_dec(PL_ofs_sv);    /* $, */
 604     PL_ofs_sv = Nullsv;
 605
 606     SvREFCNT_dec(PL_ors_sv);    /* $\ */
 607     PL_ors_sv = Nullsv;
 608
 609     SvREFCNT_dec(PL_rs);        /* $/ */
 610     PL_rs = Nullsv;
 611
 612     PL_multiline = 0;           /* $* */
 613     Safefree(PL_osname);        /* $^O */
 614     PL_osname = Nullch;
 615
 616     SvREFCNT_dec(PL_statname);
 617     PL_statname = Nullsv;
 618     PL_statgv = Nullgv;
 619
 620     /* defgv, aka *_ should be taken care of elsewhere */
 621
 622     /* clean up after study() */
 623     SvREFCNT_dec(PL_lastscream);
 624     PL_lastscream = Nullsv;
 625     Safefree(PL_screamfirst);
 626     PL_screamfirst = 0;
 627     Safefree(PL_screamnext);
 628     PL_screamnext  = 0;
 629
 630     /* float buffer */
 631     Safefree(PL_efloatbuf);
 632     PL_efloatbuf = Nullch;
 633     PL_efloatsize = 0;
 634
 635     /* startup and shutdown function lists */
 636     SvREFCNT_dec(PL_beginav);
 637     SvREFCNT_dec(PL_beginav_save);
 638     SvREFCNT_dec(PL_endav);
 639     SvREFCNT_dec(PL_checkav);
 640     SvREFCNT_dec(PL_checkav_save);
 641     SvREFCNT_dec(PL_initav);
 642     PL_beginav = Nullav;
 643     PL_beginav_save = Nullav;
 644     PL_endav = Nullav;
 645     PL_checkav = Nullav;
 646     PL_checkav_save = Nullav;
 647     PL_initav = Nullav;
 648
 649     /* shortcuts just get cleared */
 650     PL_envgv = Nullgv;
 651     PL_incgv = Nullgv;
 652     PL_hintgv = Nullgv;
 653     PL_errgv = Nullgv;
 654     PL_argvgv = Nullgv;
 655     PL_argvoutgv = Nullgv;
 656     PL_stdingv = Nullgv;
 657     PL_stderrgv = Nullgv;
 658     PL_last_in_gv = Nullgv;
 659     PL_replgv = Nullgv;
 660     PL_DBgv = Nullgv;
 661     PL_DBline = Nullgv;
 662     PL_DBsub = Nullgv;
 663     PL_DBsingle = Nullsv;
 664     PL_DBtrace = Nullsv;
 665     PL_DBsignal = Nullsv;
 666     PL_DBassertion = Nullsv;
 667     PL_DBcv = Nullcv;
 668     PL_dbargs = Nullav;
 669     PL_debstash = Nullhv;
 670
 671     SvREFCNT_dec(PL_argvout_stack);
 672     PL_argvout_stack = Nullav;
 673
 674     SvREFCNT_dec(PL_modglobal);
 675     PL_modglobal = Nullhv;
 676     SvREFCNT_dec(PL_preambleav);
 677     PL_preambleav = Nullav;
 678     SvREFCNT_dec(PL_subname);
 679     PL_subname = Nullsv;
 680     SvREFCNT_dec(PL_linestr);
 681     PL_linestr = Nullsv;
 682     SvREFCNT_dec(PL_pidstatus);
 683     PL_pidstatus = Nullhv;
 684     SvREFCNT_dec(PL_toptarget);
 685     PL_toptarget = Nullsv;
 686     SvREFCNT_dec(PL_bodytarget);
 687     PL_bodytarget = Nullsv;
 688     PL_formtarget = Nullsv;
 689
 690     /* free locale stuff */
 691 #ifdef USE_LOCALE_COLLATE
 692     Safefree(PL_collation_name);
 693     PL_collation_name = Nullch;
 694 #endif
 695
 696 #ifdef USE_LOCALE_NUMERIC
 697     Safefree(PL_numeric_name);
 698     PL_numeric_name = Nullch;
 699     SvREFCNT_dec(PL_numeric_radix_sv);
 700     PL_numeric_radix_sv = Nullsv;
 701 #endif
 702
 703     /* clear utf8 character classes */
 704     SvREFCNT_dec(PL_utf8_alnum);
 705     SvREFCNT_dec(PL_utf8_alnumc);
 706     SvREFCNT_dec(PL_utf8_ascii);
 707     SvREFCNT_dec(PL_utf8_alpha);
 708     SvREFCNT_dec(PL_utf8_space);
 709     SvREFCNT_dec(PL_utf8_cntrl);
 710     SvREFCNT_dec(PL_utf8_graph);
 711     SvREFCNT_dec(PL_utf8_digit);
 712     SvREFCNT_dec(PL_utf8_upper);
 713     SvREFCNT_dec(PL_utf8_lower);
 714     SvREFCNT_dec(PL_utf8_print);
 715     SvREFCNT_dec(PL_utf8_punct);
 716     SvREFCNT_dec(PL_utf8_xdigit);
 717     SvREFCNT_dec(PL_utf8_mark);
 718     SvREFCNT_dec(PL_utf8_toupper);
 719     SvREFCNT_dec(PL_utf8_totitle);
 720     SvREFCNT_dec(PL_utf8_tolower);
 721     SvREFCNT_dec(PL_utf8_tofold);
 722     SvREFCNT_dec(PL_utf8_idstart);
 723     SvREFCNT_dec(PL_utf8_idcont);
 724     PL_utf8_alnum       = Nullsv;
 725     PL_utf8_alnumc      = Nullsv;
 726     PL_utf8_ascii       = Nullsv;
 727     PL_utf8_alpha       = Nullsv;
 728     PL_utf8_space       = Nullsv;
 729     PL_utf8_cntrl       = Nullsv;
 730     PL_utf8_graph       = Nullsv;
 731     PL_utf8_digit       = Nullsv;
 732     PL_utf8_upper       = Nullsv;
 733     PL_utf8_lower       = Nullsv;
 734     PL_utf8_print       = Nullsv;
 735     PL_utf8_punct       = Nullsv;
 736     PL_utf8_xdigit      = Nullsv;
 737     PL_utf8_mark        = Nullsv;
 738     PL_utf8_toupper     = Nullsv;
 739     PL_utf8_totitle     = Nullsv;
 740     PL_utf8_tolower     = Nullsv;
 741     PL_utf8_tofold      = Nullsv;
 742     PL_utf8_idstart     = Nullsv;
 743     PL_utf8_idcont      = Nullsv;
 744
 745     if (!specialWARN(PL_compiling.cop_warnings))
 746         SvREFCNT_dec(PL_compiling.cop_warnings);
 747     PL_compiling.cop_warnings = Nullsv;
 748     if (!specialCopIO(PL_compiling.cop_io))
 749         SvREFCNT_dec(PL_compiling.cop_io);
 750     PL_compiling.cop_io = Nullsv;
 751     CopFILE_free(&PL_compiling);
 752     CopSTASH_free(&PL_compiling);
 753
 754     /* Prepare to destruct main symbol table.  */
 755
 756     hv = PL_defstash;
 757     PL_defstash = 0;
 758     SvREFCNT_dec(hv);
 759     SvREFCNT_dec(PL_curstname);
 760     PL_curstname = Nullsv;
 761
 762     /* clear queued errors */
 763     SvREFCNT_dec(PL_errors);
 764     PL_errors = Nullsv;
 765
 766     FREETMPS;
 767     if (destruct_level >= 2 && ckWARN_d(WARN_INTERNAL)) {
 768         if (PL_scopestack_ix != 0)
 769             Perl_warner(aTHX_ packWARN(WARN_INTERNAL),
 770                  "Unbalanced scopes: %ld more ENTERs than LEAVEs\n",
 771                  (long)PL_scopestack_ix);
 772         if (PL_savestack_ix != 0)
 773             Perl_warner(aTHX_ packWARN(WARN_INTERNAL),
 774                  "Unbalanced saves: %ld more saves than restores\n",
 775                  (long)PL_savestack_ix);
 776         if (PL_tmps_floor != -1)
 777             Perl_warner(aTHX_ packWARN(WARN_INTERNAL),"Unbalanced tmps: %ld more allocs than frees\n",
 778                  (long)PL_tmps_floor + 1);
 779         if (cxstack_ix != -1)
 780             Perl_warner(aTHX_ packWARN(WARN_INTERNAL),"Unbalanced context: %ld more PUSHes than POPs\n",
 781                  (long)cxstack_ix + 1);
 782     }
 783
 784     /* Now absolutely destruct everything, somehow or other, loops or no. */
 785     SvFLAGS(PL_fdpid) |= SVTYPEMASK;            /* don't clean out pid table now */
 786     SvFLAGS(PL_strtab) |= SVTYPEMASK;           /* don't clean out strtab now */
 787
 788     /* the 2 is for PL_fdpid and PL_strtab */
 789     while (PL_sv_count > 2 && sv_clean_all())
 790         ;
 791
 792     SvFLAGS(PL_fdpid) &= ~SVTYPEMASK;
 793     SvFLAGS(PL_fdpid) |= SVt_PVAV;
 794     SvFLAGS(PL_strtab) &= ~SVTYPEMASK;
 795     SvFLAGS(PL_strtab) |= SVt_PVHV;
 796
 797     AvREAL_off(PL_fdpid);               /* no surviving entries */
 798     SvREFCNT_dec(PL_fdpid);             /* needed in io_close() */
 799     PL_fdpid = Nullav;
 800
 801 #ifdef HAVE_INTERP_INTERN
 802     sys_intern_clear();
 803 #endif
 804
 805     /* Destruct the global string table. */
 806     {
 807         /* Yell and reset the HeVAL() slots that are still holding refcounts,
 808          * so that sv_free() won't fail on them.
 809          */
 810         I32 riter;
 811         I32 max;
 812         HE *hent;
 813         HE **array;
 814
 815         riter = 0;
 816         max = HvMAX(PL_strtab);
 817         array = HvARRAY(PL_strtab);
 818         hent = array[0];
 819         for (;;) {
 820             if (hent && ckWARN_d(WARN_INTERNAL)) {
 821                 Perl_warner(aTHX_ packWARN(WARN_INTERNAL),
 822                      "Unbalanced string table refcount: (%d) for \"%s\"",
 823                      HeVAL(hent) - Nullsv, HeKEY(hent));
 824                 HeVAL(hent) = Nullsv;
 825                 hent = HeNEXT(hent);
 826             }
 827             if (!hent) {
 828                 if (++riter > max)
 829                     break;
 830                 hent = array[riter];
 831             }
 832         }
 833     }
 834     SvREFCNT_dec(PL_strtab);
 835
 836 #ifdef USE_ITHREADS
 837     /* free the pointer table used for cloning */
 838     ptr_table_free(PL_ptr_table);
 839     PL_ptr_table = (PTR_TBL_t*)NULL;
 840 #endif
 841
 842     /* free special SVs */
 843
 844     SvREFCNT(&PL_sv_yes) = 0;
 845     sv_clear(&PL_sv_yes);
 846     SvANY(&PL_sv_yes) = NULL;
 847     SvFLAGS(&PL_sv_yes) = 0;
 848
 849     SvREFCNT(&PL_sv_no) = 0;
 850     sv_clear(&PL_sv_no);
 851     SvANY(&PL_sv_no) = NULL;
 852     SvFLAGS(&PL_sv_no) = 0;
 853
 854     {
 855         int i;
 856         for (i=0; i<=2; i++) {
 857             SvREFCNT(PERL_DEBUG_PAD(i)) = 0;
 858             sv_clear(PERL_DEBUG_PAD(i));
 859             SvANY(PERL_DEBUG_PAD(i)) = NULL;
 860             SvFLAGS(PERL_DEBUG_PAD(i)) = 0;
 861         }
 862     }
 863
 864     if (PL_sv_count != 0 && ckWARN_d(WARN_INTERNAL))
 865         Perl_warner(aTHX_ packWARN(WARN_INTERNAL),"Scalars leaked: %ld\n", (long)PL_sv_count);
 866
 867 #ifdef DEBUG_LEAKING_SCALARS
 868     if (PL_sv_count != 0) {
 869         SV* sva;
 870         SV* sv;
 871         register SV* svend;
 872
 873         for (sva = PL_sv_arenaroot; sva; sva = (SV*)SvANY(sva)) {
 874             svend = &sva[SvREFCNT(sva)];
 875             for (sv = sva + 1; sv < svend; ++sv) {
 876                 if (SvTYPE(sv) != SVTYPEMASK) {
 877                     PerlIO_printf(Perl_debug_log, "leaked: sv=0x%p"
 878                         " flags=0x08%"UVxf
 879                         " refcnt=%"UVuf pTHX__FORMAT "\n"
 880                         "\tallocated at %s:%d %s %s%s\n",
 881                         sv, sv->sv_flags, sv->sv_refcnt pTHX__VALUE,
 882                         sv->sv_debug_file ? sv->sv_debug_file : "(unknown)",
 883                         sv->sv_debug_line,
 884                         sv->sv_debug_inpad ? "for" : "by",
 885                         sv->sv_debug_optype ?
 886                             PL_op_name[sv->sv_debug_optype]: "(none)",
 887                         sv->sv_debug_cloned ? " (cloned)" : ""
 888                     );
 889                 }
 890             }
 891         }
 892     }
 893 #endif
 894     PL_sv_count = 0;
 895
 896
 897 #if defined(PERLIO_LAYERS)
 898     /* No more IO - including error messages ! */
 899     PerlIO_cleanup(aTHX);
 900 #endif
 901
 902     /* sv_undef needs to stay immortal until after PerlIO_cleanup
 903        as currently layers use it rather than Nullsv as a marker
 904        for no arg - and will try and SvREFCNT_dec it.
 905      */
 906     SvREFCNT(&PL_sv_undef) = 0;
 907     SvREADONLY_off(&PL_sv_undef);
 908
 909     Safefree(PL_origfilename);
 910     PL_origfilename = Nullch;
 911     Safefree(PL_reg_start_tmp);
 912     PL_reg_start_tmp = (char**)NULL;
 913     PL_reg_start_tmpl = 0;
 914     if (PL_reg_curpm)
 915         Safefree(PL_reg_curpm);
 916     Safefree(PL_reg_poscache);
 917     free_tied_hv_pool();
 918     Safefree(PL_op_mask);
 919     Safefree(PL_psig_ptr);
 920     PL_psig_ptr = (SV**)NULL;
 921     Safefree(PL_psig_name);
 922     PL_psig_name = (SV**)NULL;
 923     Safefree(PL_bitcount);
 924     PL_bitcount = Nullch;
 925     Safefree(PL_psig_pend);
 926     PL_psig_pend = (int*)NULL;
 927     PL_formfeed = Nullsv;
 928     Safefree(PL_ofmt);
 929     PL_ofmt = Nullch;
 930     nuke_stacks();
 931     PL_tainting = FALSE;
 932     PL_taint_warn = FALSE;
 933     PL_hints = 0;               /* Reset hints. Should hints be per-interpreter ? */
 934     PL_debug = 0;
 935
 936     DEBUG_P(debprofdump());
 937
 938 #ifdef USE_REENTRANT_API
 939     Perl_reentrant_free(aTHX);
 940 #endif
 941
 942     sv_free_arenas();
 943
 944     /* As the absolutely last thing, free the non-arena SV for mess() */
 945
 946     if (PL_mess_sv) {
 947         /* it could have accumulated taint magic */
 948         if (SvTYPE(PL_mess_sv) >= SVt_PVMG) {
 949             MAGIC* mg;
 950             MAGIC* moremagic;
 951             for (mg = SvMAGIC(PL_mess_sv); mg; mg = moremagic) {
 952                 moremagic = mg->mg_moremagic;
 953                 if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global
 954                                                 && mg->mg_len >= 0)
 955                     Safefree(mg->mg_ptr);
 956                 Safefree(mg);
 957             }
 958         }
 959         /* we know that type >= SVt_PV */
 960         SvOOK_off(PL_mess_sv);
 961         Safefree(SvPVX(PL_mess_sv));
 962         Safefree(SvANY(PL_mess_sv));
 963         Safefree(PL_mess_sv);
 964         PL_mess_sv = Nullsv;
 965     }
 966     return STATUS_NATIVE_EXPORT;
 967 }
 968
 969 /*
 970 =for apidoc perl_free
 971
 972 Releases a Perl interpreter.  See L<perlembed>.
 973
 974 =cut
 975 */
 976
 977 void
 978 perl_free(pTHXx)
 979 {
 980 #if defined(WIN32) || defined(NETWARE)
 981 #  if defined(PERL_IMPLICIT_SYS)
 982 #    ifdef NETWARE
 983     void *host = nw_internal_host;
 984 #    else
 985     void *host = w32_internal_host;
 986 #    endif
 987     PerlMem_free(aTHXx);
 988 #    ifdef NETWARE
 989     nw_delete_internal_host(host);
 990 #    else
 991     win32_delete_internal_host(host);
 992 #    endif
 993 #  else
 994     PerlMem_free(aTHXx);
 995 #  endif
 996 #else
 997     PerlMem_free(aTHXx);
 998 #endif
 999 }
1000
1001 #if defined(USE_5005THREADS) || defined(USE_ITHREADS)
1002 /* provide destructors to clean up the thread key when libperl is unloaded */
1003 #ifndef WIN32 /* handled during DLL_PROCESS_DETACH in win32/perllib.c */
1004
1005 #if defined(__hpux) && !defined(__GNUC__)
1006 #pragma fini "perl_fini"
1007 #endif
1008
1009 #if defined(__GNUC__) && defined(__attribute__)
1010 /* want to make sure __attribute__ works here even
1011  * for -Dd_attribut=undef builds.
1012  */
1013 #undef __attribute__
1014 #endif
1015
1016 static void __attribute__((destructor))
1017 perl_fini()
1018 {
1019     dVAR;
1020     if (PL_curinterp)
1021         FREE_THREAD_KEY;
1022 }
1023
1024 #endif /* WIN32 */
1025 #endif /* THREADS */
1026
1027 void
1028 Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr)
1029 {
1030     Renew(PL_exitlist, PL_exitlistlen+1, PerlExitListEntry);
1031     PL_exitlist[PL_exitlistlen].fn = fn;
1032     PL_exitlist[PL_exitlistlen].ptr = ptr;
1033     ++PL_exitlistlen;
1034 }
1035
1036 #ifdef HAS_PROCSELFEXE
1037 /* This is a function so that we don't hold on to MAXPATHLEN
1038    bytes of stack longer than necessary
1039  */
1040 STATIC void
1041 S_procself_val(pTHX_ SV *sv, const char *arg0)
1042 {
1043     char buf[MAXPATHLEN];
1044     int len = readlink(PROCSELFEXE_PATH, buf, sizeof(buf) - 1);
1045
1046     /* On Playstation2 Linux V1.0 (kernel 2.2.1) readlink(/proc/self/exe)
1047        includes a spurious NUL which will cause $^X to fail in system
1048        or backticks (this will prevent extensions from being built and
1049        many tests from working). readlink is not meant to add a NUL.
1050        Normal readlink works fine.
1051      */
1052     if (len > 0 && buf[len-1] == '\0') {
1053       len--;
1054     }
1055
1056     /* FreeBSD's implementation is acknowledged to be imperfect, sometimes
1057        returning the text "unknown" from the readlink rather than the path
1058        to the executable (or returning an error from the readlink).  Any valid
1059        path has a '/' in it somewhere, so use that to validate the result.
1060        See http://www.freebsd.org/cgi/query-pr.cgi?pr=35703
1061     */
1062     if (len > 0 && memchr(buf, '/', len)) {
1063         sv_setpvn(sv,buf,len);
1064     }
1065     else {
1066         sv_setpv(sv,arg0);
1067     }
1068 }
1069 #endif /* HAS_PROCSELFEXE */
1070
1071 STATIC void
1072 S_set_caret_X(pTHX) {
1073     GV* tmpgv = gv_fetchpv("\030",TRUE, SVt_PV); /* $^X */
1074     if (tmpgv) {
1075 #ifdef HAS_PROCSELFEXE
1076         S_procself_val(aTHX_ GvSV(tmpgv), PL_origargv[0]);
1077 #else
1078 #ifdef OS2
1079         sv_setpv(GvSV(tmpgv), os2_execname(aTHX));
1080 #else
1081         sv_setpv(GvSV(tmpgv),PL_origargv[0]);
1082 #endif
1083 #endif
1084     }
1085 }
1086
1087 /*
1088 =for apidoc perl_parse
1089
1090 Tells a Perl interpreter to parse a Perl script.  See L<perlembed>.
1091
1092 =cut
1093 */
1094
1095 int
1096 perl_parse(pTHXx_ XSINIT_t xsinit, int argc, char **argv, char **env)
1097 {
1098     dVAR;
1099     I32 oldscope;
1100     int ret;
1101     dJMPENV;
1102
1103 #ifdef SETUID_SCRIPTS_ARE_SECURE_NOW
1104 #ifdef IAMSUID
1105 #undef IAMSUID
1106     Perl_croak(aTHX_ "suidperl is no longer needed since the kernel can now execute\n\
1107 setuid perl scripts securely.\n");
1108 #endif /* IAMSUID */
1109 #endif
1110
1111 #if defined(USE_HASH_SEED) || defined(USE_HASH_SEED_EXPLICIT)
1112     /* [perl #22371] Algorimic Complexity Attack on Perl 5.6.1, 5.8.0
1113      * This MUST be done before any hash stores or fetches take place.
1114      * If you set PL_rehash_seed (and assumedly also PL_rehash_seed_set)
1115      * yourself, it is your responsibility to provide a good random seed!
1116      * You can also define PERL_HASH_SEED in compile time, see hv.h. */
1117     if (!PL_rehash_seed_set)
1118          PL_rehash_seed = get_hash_seed();
1119     {
1120          char *s = PerlEnv_getenv("PERL_HASH_SEED_DEBUG");
1121
1122          if (s) {
1123               int i = atoi(s);
1124
1125               if (i == 1)
1126                    PerlIO_printf(Perl_debug_log, "HASH_SEED = %"UVuf"\n",
1127                                  PL_rehash_seed);
1128          }
1129     }
1130 #endif /* #if defined(USE_HASH_SEED) || defined(USE_HASH_SEED_EXPLICIT) */
1131
1132     PL_origargc = argc;
1133     PL_origargv = argv;
1134
1135     {
1136         /* Set PL_origalen be the sum of the contiguous argv[]
1137          * elements plus the size of the env in case that it is
1138          * contiguous with the argv[].  This is used in mg.c:Perl_magic_set()
1139          * as the maximum modifiable length of $0.  In the worst case
1140          * the area we are able to modify is limited to the size of
1141          * the original argv[0].  (See below for 'contiguous', though.)
1142          * --jhi */
1143          const char *s = NULL;
1144          int i;
1145          UV mask =
1146            ~(UV)(PTRSIZE == 4 ? 3 : PTRSIZE == 8 ? 7 : PTRSIZE == 16 ? 15 : 0);
1147          /* Do the mask check only if the args seem like aligned. */
1148          UV aligned =
1149            (mask < ~(UV)0) && ((PTR2UV(argv[0]) & mask) == PTR2UV(argv[0]));
1150
1151          /* See if all the arguments are contiguous in memory.  Note
1152           * that 'contiguous' is a loose term because some platforms
1153           * align the argv[] and the envp[].  If the arguments look
1154           * like non-aligned, assume that they are 'strictly' or
1155           * 'traditionally' contiguous.  If the arguments look like
1156           * aligned, we just check that they are within aligned
1157           * PTRSIZE bytes.  As long as no system has something bizarre
1158           * like the argv[] interleaved with some other data, we are
1159           * fine.  (Did I just evoke Murphy's Law?)  --jhi */
1160          if (PL_origargv && PL_origargc >= 1 && (s = PL_origargv[0])) {
1161               while (*s) s++;
1162               for (i = 1; i < PL_origargc; i++) {
1163                    if ((PL_origargv[i] == s + 1
1164 #ifdef OS2
1165                         || PL_origargv[i] == s + 2
1166 #endif
1167                             )
1168                        ||
1169                        (aligned &&
1170                         (PL_origargv[i] >  s &&
1171                          PL_origargv[i] <=
1172                          INT2PTR(char *, PTR2UV(s + PTRSIZE) & mask)))
1173                         )
1174                    {
1175                         s = PL_origargv[i];
1176                         while (*s) s++;
1177                    }
1178                    else
1179                         break;
1180               }
1181          }
1182          /* Can we grab env area too to be used as the area for $0? */
1183          if (PL_origenviron) {
1184               if ((PL_origenviron[0] == s + 1
1185 #ifdef OS2
1186                    || (PL_origenviron[0] == s + 9 && (s += 8))
1187 #endif
1188                   )
1189                   ||
1190                   (aligned &&
1191                    (PL_origenviron[0] >  s &&
1192                     PL_origenviron[0] <=
1193                     INT2PTR(char *, PTR2UV(s + PTRSIZE) & mask)))
1194                  )
1195               {
1196 #ifndef OS2
1197                    s = PL_origenviron[0];
1198                    while (*s) s++;
1199 #endif
1200                    my_setenv("NoNe  SuCh", Nullch);
1201                    /* Force copy of environment. */
1202                    for (i = 1; PL_origenviron[i]; i++) {
1203                         if (PL_origenviron[i] == s + 1
1204                             ||
1205                             (aligned &&
1206                              (PL_origenviron[i] >  s &&
1207                               PL_origenviron[i] <=
1208                               INT2PTR(char *, PTR2UV(s + PTRSIZE) & mask)))
1209                            )
1210                         {
1211                              s = PL_origenviron[i];
1212                              while (*s) s++;
1213                         }
1214                         else
1215                              break;
1216                    }
1217               }
1218          }
1219          PL_origalen = s - PL_origargv[0] + 1;
1220     }
1221
1222     if (PL_do_undump) {
1223
1224         /* Come here if running an undumped a.out. */
1225
1226         PL_origfilename = savepv(argv[0]);
1227         PL_do_undump = FALSE;
1228         cxstack_ix = -1;                /* start label stack again */
1229         init_ids();
1230         assert (!PL_tainted);
1231         TAINT;
1232         S_set_caret_X(aTHX);
1233         TAINT_NOT;
1234         init_postdump_symbols(argc,argv,env);
1235         return 0;
1236     }
1237
1238     if (PL_main_root) {
1239         op_free(PL_main_root);
1240         PL_main_root = Nullop;
1241     }
1242     PL_main_start = Nullop;
1243     SvREFCNT_dec(PL_main_cv);
1244     PL_main_cv = Nullcv;
1245
1246     time(&PL_basetime);
1247     oldscope = PL_scopestack_ix;
1248     PL_dowarn = G_WARN_OFF;
1249
1250     JMPENV_PUSH(ret);
1251     switch (ret) {
1252     case 0:
1253         parse_body(env,xsinit);
1254         if (PL_checkav)
1255             call_list(oldscope, PL_checkav);
1256         ret = 0;
1257         break;
1258     case 1:
1259         STATUS_ALL_FAILURE;
1260         /* FALL THROUGH */
1261     case 2:
1262         /* my_exit() was called */
1263         while (PL_scopestack_ix > oldscope)
1264             LEAVE;
1265         FREETMPS;
1266         PL_curstash = PL_defstash;
1267         if (PL_checkav)
1268             call_list(oldscope, PL_checkav);
1269         ret = STATUS_NATIVE_EXPORT;
1270         break;
1271     case 3:
1272         PerlIO_printf(Perl_error_log, "panic: top_env\n");
1273         ret = 1;
1274         break;
1275     }
1276     JMPENV_POP;
1277     return ret;
1278 }
1279
1280 STATIC void *
1281 S_parse_body(pTHX_ char **env, XSINIT_t xsinit)
1282 {
1283     dVAR;
1284     int argc = PL_origargc;
1285     char **argv = PL_origargv;
1286     const char *scriptname = NULL;
1287     VOL bool dosearch = FALSE;
1288     const char *validarg = "";
1289     register SV *sv;
1290     register char *s;
1291     const char *cddir = Nullch;
1292     bool minus_f = FALSE;
1293
1294     PL_fdscript = -1;
1295     PL_suidscript = -1;
1296     sv_setpvn(PL_linestr,"",0);
1297     sv = newSVpvn("",0);                /* first used for -I flags */
1298     SAVEFREESV(sv);
1299     init_main_stash();
1300
1301     for (argc--,argv++; argc > 0; argc--,argv++) {
1302         if (argv[0][0] != '-' || !argv[0][1])
1303             break;
1304 #ifdef DOSUID
1305     if (*validarg)
1306         validarg = " PHOOEY ";
1307     else
1308         validarg = argv[0];
1309     /*
1310      * Can we rely on the kernel to start scripts with argv[1] set to
1311      * contain all #! line switches (the whole line)? (argv[0] is set to
1312      * the interpreter name, argv[2] to the script name; argv[3] and
1313      * above may contain other arguments.)
1314      */
1315 #endif
1316         s = argv[0]+1;
1317       reswitch:
1318         switch (*s) {
1319         case 'C':
1320 #ifndef PERL_STRICT_CR
1321         case '\r':
1322 #endif
1323         case ' ':
1324         case '0':
1325         case 'F':
1326         case 'a':
1327         case 'c':
1328         case 'd':
1329         case 'D':
1330         case 'h':
1331         case 'i':
1332         case 'l':
1333         case 'M':
1334         case 'm':
1335         case 'n':
1336         case 'p':
1337         case 's':
1338         case 'u':
1339         case 'U':
1340         case 'v':
1341         case 'W':
1342         case 'X':
1343         case 'w':
1344         case 'A':
1345             if ((s = moreswitches(s)))
1346                 goto reswitch;
1347             break;
1348
1349         case 't':
1350             CHECK_MALLOC_TOO_LATE_FOR('t');
1351             if( !PL_tainting ) {
1352                  PL_taint_warn = TRUE;
1353                  PL_tainting = TRUE;
1354             }
1355             s++;
1356             goto reswitch;
1357         case 'T':
1358             CHECK_MALLOC_TOO_LATE_FOR('T');
1359             PL_tainting = TRUE;
1360             PL_taint_warn = FALSE;
1361             s++;
1362             goto reswitch;
1363
1364         case 'e':
1365 #ifdef MACOS_TRADITIONAL
1366             /* ignore -e for Dev:Pseudo argument */
1367             if (argv[1] && !strcmp(argv[1], "Dev:Pseudo"))
1368                 break;
1369 #endif
1370             forbid_setid("-e");
1371             if (!PL_e_script) {
1372                 PL_e_script = newSVpvn("",0);
1373                 filter_add(read_e_script, NULL);
1374             }
1375             if (*++s)
1376                 sv_catpv(PL_e_script, s);
1377             else if (argv[1]) {
1378                 sv_catpv(PL_e_script, argv[1]);
1379                 argc--,argv++;
1380             }
1381             else
1382                 Perl_croak(aTHX_ "No code specified for -e");
1383             sv_catpv(PL_e_script, "\n");
1384             break;
1385
1386         case 'f':
1387             minus_f = TRUE;
1388             s++;
1389             goto reswitch;
1390
1391         case 'I':       /* -I handled both here and in moreswitches() */
1392             forbid_setid("-I");
1393             if (!*++s && (s=argv[1]) != Nullch) {
1394                 argc--,argv++;
1395             }
1396             if (s && *s) {
1397                 char *p;
1398                 STRLEN len = strlen(s);
1399                 p = savepvn(s, len);
1400                 incpush(p, TRUE, TRUE, FALSE, FALSE);
1401                 sv_catpvn(sv, "-I", 2);
1402                 sv_catpvn(sv, p, len);
1403                 sv_catpvn(sv, " ", 1);
1404                 Safefree(p);
1405             }
1406             else
1407                 Perl_croak(aTHX_ "No directory specified for -I");
1408             break;
1409         case 'P':
1410             forbid_setid("-P");
1411             PL_preprocess = TRUE;
1412             s++;
1413             goto reswitch;
1414         case 'S':
1415             forbid_setid("-S");
1416             dosearch = TRUE;
1417             s++;
1418             goto reswitch;
1419         case 'V':
1420             if (!PL_preambleav)
1421                 PL_preambleav = newAV();
1422             av_push(PL_preambleav, newSVpv("use Config qw(myconfig config_vars)",0));
1423             if (*++s != ':')  {
1424                 STRLEN opts;
1425
1426                 PL_Sv = newSVpv("print myconfig();",0);
1427 #ifdef VMS
1428                 sv_catpv(PL_Sv,"print \"\\nCharacteristics of this PERLSHR image: \\n\",");
1429 #else
1430                 sv_catpv(PL_Sv,"print \"\\nCharacteristics of this binary (from libperl): \\n\",");
1431 #endif
1432                 opts = SvCUR(PL_Sv);
1433
1434                 sv_catpv(PL_Sv,"\"  Compile-time options:");
1435 #  ifdef DEBUGGING
1436                 sv_catpv(PL_Sv," DEBUGGING");
1437 #  endif
1438 #  ifdef MULTIPLICITY
1439                 sv_catpv(PL_Sv," MULTIPLICITY");
1440 #  endif
1441 #  ifdef USE_5005THREADS
1442                 sv_catpv(PL_Sv," USE_5005THREADS");
1443 #  endif
1444 #  ifdef USE_ITHREADS
1445                 sv_catpv(PL_Sv," USE_ITHREADS");
1446 #  endif
1447 #  ifdef USE_64_BIT_INT
1448                 sv_catpv(PL_Sv," USE_64_BIT_INT");
1449 #  endif
1450 #  ifdef USE_64_BIT_ALL
1451                 sv_catpv(PL_Sv," USE_64_BIT_ALL");
1452 #  endif
1453 #  ifdef USE_LONG_DOUBLE
1454                 sv_catpv(PL_Sv," USE_LONG_DOUBLE");
1455 #  endif
1456 #  ifdef USE_LARGE_FILES
1457                 sv_catpv(PL_Sv," USE_LARGE_FILES");
1458 #  endif
1459 #  ifdef USE_SOCKS
1460                 sv_catpv(PL_Sv," USE_SOCKS");
1461 #  endif
1462 #  ifdef USE_SITECUSTOMIZE
1463                 sv_catpv(PL_Sv," USE_SITECUSTOMIZE");
1464 #  endif
1465 #  ifdef PERL_IMPLICIT_CONTEXT
1466                 sv_catpv(PL_Sv," PERL_IMPLICIT_CONTEXT");
1467 #  endif
1468 #  ifdef PERL_IMPLICIT_SYS
1469                 sv_catpv(PL_Sv," PERL_IMPLICIT_SYS");
1470 #  endif
1471
1472                 while (SvCUR(PL_Sv) > opts+76) {
1473                     /* find last space after "options: " and before col 76 */
1474
1475                     const char *space;
1476                     char *pv = SvPV_nolen(PL_Sv);
1477                     const char c = pv[opts+76];
1478                     pv[opts+76] = '\0';
1479                     space = strrchr(pv+opts+26, ' ');
1480                     pv[opts+76] = c;
1481                     if (!space) break; /* "Can't happen" */
1482
1483                     /* break the line before that space */
1484
1485                     opts = space - pv;
1486                     sv_insert(PL_Sv, opts, 0,
1487                               "\\n                       ", 25);
1488                 }
1489
1490                 sv_catpv(PL_Sv,"\\n\",");
1491
1492 #if defined(LOCAL_PATCH_COUNT)
1493                 if (LOCAL_PATCH_COUNT > 0) {
1494                     int i;
1495                     sv_catpv(PL_Sv,"\"  Locally applied patches:\\n\",");
1496                     for (i = 1; i <= LOCAL_PATCH_COUNT; i++) {
1497                         if (PL_localpatches[i])
1498                             Perl_sv_catpvf(aTHX_ PL_Sv,"q%c\t%s\n%c,",
1499                                     0, PL_localpatches[i], 0);
1500                     }
1501                 }
1502 #endif
1503                 Perl_sv_catpvf(aTHX_ PL_Sv,"\"  Built under %s\\n\"",OSNAME);
1504 #ifdef __DATE__
1505 #  ifdef __TIME__
1506                 Perl_sv_catpvf(aTHX_ PL_Sv,",\"  Compiled at %s %s\\n\"",__DATE__,__TIME__);
1507 #  else
1508                 Perl_sv_catpvf(aTHX_ PL_Sv,",\"  Compiled on %s\\n\"",__DATE__);
1509 #  endif
1510 #endif
1511                 sv_catpv(PL_Sv, "; \
1512 $\"=\"\\n    \"; \
1513 @env = map { \"$_=\\\"$ENV{$_}\\\"\" } sort grep {/^PERL/} keys %ENV; ");
1514 #ifdef __CYGWIN__
1515                 sv_catpv(PL_Sv,"\
1516 push @env, \"CYGWIN=\\\"$ENV{CYGWIN}\\\"\";");
1517 #endif
1518                 sv_catpv(PL_Sv, "\
1519 print \"  \\%ENV:\\n    @env\\n\" if @env; \
1520 print \"  \\@INC:\\n    @INC\\n\";");
1521             }
1522             else {
1523                 PL_Sv = newSVpv("config_vars(qw(",0);
1524                 sv_catpv(PL_Sv, ++s);
1525                 sv_catpv(PL_Sv, "))");
1526                 s += strlen(s);
1527             }
1528             av_push(PL_preambleav, PL_Sv);
1529             scriptname = BIT_BUCKET;    /* don't look for script or read stdin */
1530             goto reswitch;
1531         case 'x':
1532             PL_doextract = TRUE;
1533             s++;
1534             if (*s)
1535                 cddir = s;
1536             break;
1537         case 0:
1538             break;
1539         case '-':
1540             if (!*++s || isSPACE(*s)) {
1541                 argc--,argv++;
1542                 goto switch_end;
1543             }
1544             /* catch use of gnu style long options */
1545             if (strEQ(s, "version")) {
1546                 s = (char *)"v";
1547                 goto reswitch;
1548             }
1549             if (strEQ(s, "help")) {
1550                 s = (char *)"h";
1551                 goto reswitch;
1552             }
1553             s--;
1554             /* FALL THROUGH */
1555         default:
1556             Perl_croak(aTHX_ "Unrecognized switch: -%s  (-h will show valid options)",s);
1557         }
1558     }
1559   switch_end:
1560
1561     if (
1562 #ifndef SECURE_INTERNAL_GETENV
1563         !PL_tainting &&
1564 #endif
1565         (s = PerlEnv_getenv("PERL5OPT")))
1566     {
1567         const char *popt = s;
1568         while (isSPACE(*s))
1569             s++;
1570         if (*s == '-' && *(s+1) == 'T') {
1571             CHECK_MALLOC_TOO_LATE_FOR('T');
1572             PL_tainting = TRUE;
1573             PL_taint_warn = FALSE;
1574         }
1575         else {
1576             char *popt_copy = Nullch;
1577             while (s && *s) {
1578                 char *d;
1579                 while (isSPACE(*s))
1580                     s++;
1581                 if (*s == '-') {
1582                     s++;
1583                     if (isSPACE(*s))
1584                         continue;
1585                 }
1586                 d = s;
1587                 if (!*s)
1588                     break;
1589                 if (!strchr("DIMUdmtwA", *s))
1590                     Perl_croak(aTHX_ "Illegal switch in PERL5OPT: -%c", *s);
1591                 while (++s && *s) {
1592                     if (isSPACE(*s)) {
1593                         if (!popt_copy) {
1594                             popt_copy = SvPVX(sv_2mortal(newSVpv(popt,0)));
1595                             s = popt_copy + (s - popt);
1596                             d = popt_copy + (d - popt);
1597                         }
1598                         *s++ = '\0';
1599                         break;
1600                     }
1601                 }
1602                 if (*d == 't') {
1603                     if( !PL_tainting ) {
1604                         PL_taint_warn = TRUE;
1605                         PL_tainting = TRUE;
1606                     }
1607                 } else {
1608                     moreswitches(d);
1609                 }
1610             }
1611         }
1612     }
1613
1614 #ifdef USE_SITECUSTOMIZE
1615     if (!minus_f) {
1616         if (!PL_preambleav)
1617             PL_preambleav = newAV();
1618         av_unshift(PL_preambleav, 1);
1619         (void)av_store(PL_preambleav, 0, Perl_newSVpvf(aTHX_ "BEGIN { do '%s/sitecustomize.pl' }", SITELIB_EXP));
1620     }
1621 #endif
1622
1623     if (PL_taint_warn && PL_dowarn != G_WARN_ALL_OFF) {
1624        PL_compiling.cop_warnings = newSVpvn(WARN_TAINTstring, WARNsize);
1625     }
1626
1627     if (!scriptname)
1628         scriptname = argv[0];
1629     if (PL_e_script) {
1630         argc++,argv--;
1631         scriptname = BIT_BUCKET;        /* don't look for script or read stdin */
1632     }
1633     else if (scriptname == Nullch) {
1634 #ifdef MSDOS
1635         if ( PerlLIO_isatty(PerlIO_fileno(PerlIO_stdin())) )
1636             moreswitches("h");
1637 #endif
1638         scriptname = "-";
1639     }
1640
1641     /* Set $^X early so that it can be used for relocatable paths in @INC  */
1642     assert (!PL_tainted);
1643     TAINT;
1644     S_set_caret_X(aTHX);
1645     TAINT_NOT;
1646     init_perllib();
1647
1648     open_script(scriptname,dosearch,sv);
1649
1650     validate_suid(validarg, scriptname);
1651
1652 #ifndef PERL_MICRO
1653 #if defined(SIGCHLD) || defined(SIGCLD)
1654     {
1655 #ifndef SIGCHLD
1656 #  define SIGCHLD SIGCLD
1657 #endif
1658         Sighandler_t sigstate = rsignal_state(SIGCHLD);
1659         if (sigstate == SIG_IGN) {
1660             if (ckWARN(WARN_SIGNAL))
1661                 Perl_warner(aTHX_ packWARN(WARN_SIGNAL),
1662                             "Can't ignore signal CHLD, forcing to default");
1663             (void)rsignal(SIGCHLD, (Sighandler_t)SIG_DFL);
1664         }
1665     }
1666 #endif
1667 #endif
1668
1669 #ifdef MACOS_TRADITIONAL
1670     if (PL_doextract || gMacPerl_AlwaysExtract) {
1671 #else
1672     if (PL_doextract) {
1673 #endif
1674         find_beginning();
1675         if (cddir && PerlDir_chdir( (char *)cddir ) < 0)
1676             Perl_croak(aTHX_ "Can't chdir to %s",cddir);
1677
1678     }
1679
1680     PL_main_cv = PL_compcv = (CV*)NEWSV(1104,0);
1681     sv_upgrade((SV *)PL_compcv, SVt_PVCV);
1682     CvUNIQUE_on(PL_compcv);
1683
1684     CvPADLIST(PL_compcv) = pad_new(0);
1685 #ifdef USE_5005THREADS
1686     CvOWNER(PL_compcv) = 0;
1687     New(666, CvMUTEXP(PL_compcv), 1, perl_mutex);
1688     MUTEX_INIT(CvMUTEXP(PL_compcv));
1689 #endif /* USE_5005THREADS */
1690
1691     boot_core_PerlIO();
1692     boot_core_UNIVERSAL();
1693     boot_core_xsutils();
1694
1695     if (xsinit)
1696         (*xsinit)(aTHX);        /* in case linked C routines want magical variables */
1697 #ifndef PERL_MICRO
1698 #if defined(VMS) || defined(WIN32) || defined(DJGPP) || defined(__CYGWIN__) || defined(EPOC)
1699     init_os_extras();
1700 #endif
1701 #endif
1702
1703 #ifdef USE_SOCKS
1704 #   ifdef HAS_SOCKS5_INIT
1705     socks5_init(argv[0]);
1706 #   else
1707     SOCKSinit(argv[0]);
1708 #   endif
1709 #endif
1710
1711     init_predump_symbols();
1712     /* init_postdump_symbols not currently designed to be called */
1713     /* more than once (ENV isn't cleared first, for example)     */
1714     /* But running with -u leaves %ENV & @ARGV undefined!    XXX */
1715     if (!PL_do_undump)
1716         init_postdump_symbols(argc,argv,env);
1717
1718     /* PL_unicode is turned on by -C, or by $ENV{PERL_UNICODE},
1719      * or explicitly in some platforms.
1720      * locale.c:Perl_init_i18nl10n() if the environment
1721      * look like the user wants to use UTF-8. */
1722 #if defined(SYMBIAN)
1723     PL_unicode = PERL_UNICODE_STD_FLAG; /* See PERL_SYMBIAN_CONSOLE_UTF8. */
1724 #endif
1725     if (PL_unicode) {
1726          /* Requires init_predump_symbols(). */
1727          if (!(PL_unicode & PERL_UNICODE_LOCALE_FLAG) || PL_utf8locale) {
1728               IO* io;
1729               PerlIO* fp;
1730               SV* sv;
1731
1732               /* Turn on UTF-8-ness on STDIN, STDOUT, STDERR
1733                * and the default open disciplines. */
1734               if ((PL_unicode & PERL_UNICODE_STDIN_FLAG) &&
1735                   PL_stdingv  && (io = GvIO(PL_stdingv)) &&
1736                   (fp = IoIFP(io)))
1737                    PerlIO_binmode(aTHX_ fp, IoTYPE(io), 0, ":utf8");
1738               if ((PL_unicode & PERL_UNICODE_STDOUT_FLAG) &&
1739                   PL_defoutgv && (io = GvIO(PL_defoutgv)) &&
1740                   (fp = IoOFP(io)))
1741                    PerlIO_binmode(aTHX_ fp, IoTYPE(io), 0, ":utf8");
1742               if ((PL_unicode & PERL_UNICODE_STDERR_FLAG) &&
1743                   PL_stderrgv && (io = GvIO(PL_stderrgv)) &&
1744                   (fp = IoOFP(io)))
1745                    PerlIO_binmode(aTHX_ fp, IoTYPE(io), 0, ":utf8");
1746               if ((PL_unicode & PERL_UNICODE_INOUT_FLAG) &&
1747                   (sv = GvSV(gv_fetchpv("\017PEN", TRUE, SVt_PV)))) {
1748                    U32 in  = PL_unicode & PERL_UNICODE_IN_FLAG;
1749                    U32 out = PL_unicode & PERL_UNICODE_OUT_FLAG;
1750                    if (in) {
1751                         if (out)
1752                              sv_setpvn(sv, ":utf8\0:utf8", 11);
1753                         else
1754                              sv_setpvn(sv, ":utf8\0", 6);
1755                    }
1756                    else if (out)
1757                         sv_setpvn(sv, "\0:utf8", 6);
1758                    SvSETMAGIC(sv);
1759               }
1760          }
1761     }
1762
1763     if ((s = PerlEnv_getenv("PERL_SIGNALS"))) {
1764          if (strEQ(s, "unsafe"))
1765               PL_signals |=  PERL_SIGNALS_UNSAFE_FLAG;
1766          else if (strEQ(s, "safe"))
1767               PL_signals &= ~PERL_SIGNALS_UNSAFE_FLAG;
1768          else
1769               Perl_croak(aTHX_ "PERL_SIGNALS illegal: \"%s\"", s);
1770     }
1771
1772     init_lexer();
1773
1774     /* now parse the script */
1775
1776     SETERRNO(0,SS_NORMAL);
1777     PL_error_count = 0;
1778 #ifdef MACOS_TRADITIONAL
1779     if (gMacPerl_SyntaxError = (yyparse() || PL_error_count)) {
1780         if (PL_minus_c)
1781             Perl_croak(aTHX_ "%s had compilation errors.\n", MacPerl_MPWFileName(PL_origfilename));
1782         else {
1783             Perl_croak(aTHX_ "Execution of %s aborted due to compilation errors.\n",
1784                        MacPerl_MPWFileName(PL_origfilename));
1785         }
1786     }
1787 #else
1788     if (yyparse() || PL_error_count) {
1789         if (PL_minus_c)
1790             Perl_croak(aTHX_ "%s had compilation errors.\n", PL_origfilename);
1791         else {
1792             Perl_croak(aTHX_ "Execution of %s aborted due to compilation errors.\n",
1793                        PL_origfilename);
1794         }
1795     }
1796 #endif
1797     CopLINE_set(PL_curcop, 0);
1798     PL_curstash = PL_defstash;
1799     PL_preprocess = FALSE;
1800     if (PL_e_script) {
1801         SvREFCNT_dec(PL_e_script);
1802         PL_e_script = Nullsv;
1803     }
1804
1805     if (PL_do_undump)
1806         my_unexec();
1807
1808     if (isWARN_ONCE) {
1809         SAVECOPFILE(PL_curcop);
1810         SAVECOPLINE(PL_curcop);
1811         gv_check(PL_defstash);
1812     }
1813
1814     LEAVE;
1815     FREETMPS;
1816
1817 #ifdef MYMALLOC
1818     if ((s=PerlEnv_getenv("PERL_DEBUG_MSTATS")) && atoi(s) >= 2)
1819         dump_mstats("after compilation:");
1820 #endif
1821
1822     ENTER;
1823     PL_restartop = 0;
1824     return NULL;
1825 }
1826
1827 /*
1828 =for apidoc perl_run
1829
1830 Tells a Perl interpreter to run.  See L<perlembed>.
1831
1832 =cut
1833 */
1834
1835 int
1836 perl_run(pTHXx)
1837 {
1838     I32 oldscope;
1839     int ret = 0;
1840     dJMPENV;
1841
1842     oldscope = PL_scopestack_ix;
1843 #ifdef VMS
1844     VMSISH_HUSHED = 0;
1845 #endif
1846
1847     JMPENV_PUSH(ret);
1848     switch (ret) {
1849     case 1:
1850         cxstack_ix = -1;                /* start context stack again */
1851         goto redo_body;
1852     case 0:                             /* normal completion */
1853  redo_body:
1854         run_body(oldscope);
1855         /* FALL THROUGH */
1856     case 2:                             /* my_exit() */
1857         while (PL_scopestack_ix > oldscope)
1858             LEAVE;
1859         FREETMPS;
1860         PL_curstash = PL_defstash;
1861         if (!(PL_exit_flags & PERL_EXIT_DESTRUCT_END) &&
1862             PL_endav && !PL_minus_c)
1863             call_list(oldscope, PL_endav);
1864 #ifdef MYMALLOC
1865         if (PerlEnv_getenv("PERL_DEBUG_MSTATS"))
1866             dump_mstats("after execution:  ");
1867 #endif
1868         ret = STATUS_NATIVE_EXPORT;
1869         break;
1870     case 3:
1871         if (PL_restartop) {
1872             POPSTACK_TO(PL_mainstack);
1873             goto redo_body;
1874         }
1875         PerlIO_printf(Perl_error_log, "panic: restartop\n");
1876         FREETMPS;
1877         ret = 1;
1878         break;
1879     }
1880
1881     JMPENV_POP;
1882     return ret;
1883 }
1884
1885
1886 STATIC void
1887 S_run_body(pTHX_ I32 oldscope)
1888 {
1889     DEBUG_r(PerlIO_printf(Perl_debug_log, "%s $` $& $' support.\n",
1890                     PL_sawampersand ? "Enabling" : "Omitting"));
1891
1892     if (!PL_restartop) {
1893         DEBUG_x(dump_all());
1894         if (!DEBUG_q_TEST)
1895           PERL_DEBUG(PerlIO_printf(Perl_debug_log, "\nEXECUTING...\n\n"));
1896         DEBUG_S(PerlIO_printf(Perl_debug_log, "main thread is 0x%"UVxf"\n",
1897                               PTR2UV(thr)));
1898
1899         if (PL_minus_c) {
1900 #ifdef MACOS_TRADITIONAL
1901             PerlIO_printf(Perl_error_log, "%s%s syntax OK\n",
1902                 (gMacPerl_ErrorFormat ? "# " : ""),
1903                 MacPerl_MPWFileName(PL_origfilename));
1904 #else
1905             PerlIO_printf(Perl_error_log, "%s syntax OK\n", PL_origfilename);
1906 #endif
1907             my_exit(0);
1908         }
1909         if (PERLDB_SINGLE && PL_DBsingle)
1910             sv_setiv(PL_DBsingle, 1);
1911         if (PL_initav)
1912             call_list(oldscope, PL_initav);
1913     }
1914
1915     /* do it */
1916
1917     if (PL_restartop) {
1918         PL_op = PL_restartop;
1919         PL_restartop = 0;
1920         CALLRUNOPS(aTHX);
1921     }
1922     else if (PL_main_start) {
1923         CvDEPTH(PL_main_cv) = 1;
1924         PL_op = PL_main_start;
1925         CALLRUNOPS(aTHX);
1926     }
1927     my_exit(0);
1928     /* NOTREACHED */
1929 }
1930
1931 /*
1932 =head1 SV Manipulation Functions
1933
1934 =for apidoc p||get_sv
1935
1936 Returns the SV of the specified Perl scalar.  If C<create> is set and the
1937 Perl variable does not exist then it will be created.  If C<create> is not
1938 set and the variable does not exist then NULL is returned.
1939
1940 =cut
1941 */
1942
1943 SV*
1944 Perl_get_sv(pTHX_ const char *name, I32 create)
1945 {
1946     GV *gv;
1947 #ifdef USE_5005THREADS
1948     if (name[1] == '\0' && !isALPHA(name[0])) {
1949         PADOFFSET tmp = find_threadsv(name);
1950         if (tmp != NOT_IN_PAD)
1951             return THREADSV(tmp);
1952     }
1953 #endif /* USE_5005THREADS */
1954     gv = gv_fetchpv(name, create, SVt_PV);
1955     if (gv)
1956         return GvSV(gv);
1957     return Nullsv;
1958 }
1959
1960 /*
1961 =head1 Array Manipulation Functions
1962
1963 =for apidoc p||get_av
1964
1965 Returns the AV of the specified Perl array.  If C<create> is set and the
1966 Perl variable does not exist then it will be created.  If C<create> is not
1967 set and the variable does not exist then NULL is returned.
1968
1969 =cut
1970 */
1971
1972 AV*
1973 Perl_get_av(pTHX_ const char *name, I32 create)
1974 {
1975     GV* gv = gv_fetchpv(name, create, SVt_PVAV);
1976     if (create)
1977         return GvAVn(gv);
1978     if (gv)
1979         return GvAV(gv);
1980     return Nullav;
1981 }
1982
1983 /*
1984 =head1 Hash Manipulation Functions
1985
1986 =for apidoc p||get_hv
1987
1988 Returns the HV of the specified Perl hash.  If C<create> is set and the
1989 Perl variable does not exist then it will be created.  If C<create> is not
1990 set and the variable does not exist then NULL is returned.
1991
1992 =cut
1993 */
1994
1995 HV*
1996 Perl_get_hv(pTHX_ const char *name, I32 create)
1997 {
1998     GV* gv = gv_fetchpv(name, create, SVt_PVHV);
1999     if (create)
2000         return GvHVn(gv);
2001     if (gv)
2002         return GvHV(gv);
2003     return Nullhv;
2004 }
2005
2006 /*
2007 =head1 CV Manipulation Functions
2008
2009 =for apidoc p||get_cv
2010
2011 Returns the CV of the specified Perl subroutine.  If C<create> is set and
2012 the Perl subroutine does not exist then it will be declared (which has the
2013 same effect as saying C<sub name;>).  If C<create> is not set and the
2014 subroutine does not exist then NULL is returned.
2015
2016 =cut
2017 */
2018
2019 CV*
2020 Perl_get_cv(pTHX_ const char *name, I32 create)
2021 {
2022     GV* gv = gv_fetchpv(name, create, SVt_PVCV);
2023     /* XXX unsafe for threads if eval_owner isn't held */
2024     /* XXX this is probably not what they think they're getting.
2025      * It has the same effect as "sub name;", i.e. just a forward
2026      * declaration! */
2027     if (create && !GvCVu(gv))
2028         return newSUB(start_subparse(FALSE, 0),
2029                       newSVOP(OP_CONST, 0, newSVpv(name,0)),
2030                       Nullop,
2031                       Nullop);
2032     if (gv)
2033         return GvCVu(gv);
2034     return Nullcv;
2035 }
2036
2037 /* Be sure to refetch the stack pointer after calling these routines. */
2038
2039 /*
2040
2041 =head1 Callback Functions
2042
2043 =for apidoc p||call_argv
2044
2045 Performs a callback to the specified Perl sub.  See L<perlcall>.
2046
2047 =cut
2048 */
2049
2050 I32
2051 Perl_call_argv(pTHX_ const char *sub_name, I32 flags, register char **argv)
2052
2053                         /* See G_* flags in cop.h */
2054                         /* null terminated arg list */
2055 {
2056     dSP;
2057
2058     PUSHMARK(SP);
2059     if (argv) {
2060         while (*argv) {
2061             XPUSHs(sv_2mortal(newSVpv(*argv,0)));
2062             argv++;
2063         }
2064         PUTBACK;
2065     }
2066     return call_pv(sub_name, flags);
2067 }
2068
2069 /*
2070 =for apidoc p||call_pv
2071
2072 Performs a callback to the specified Perl sub.  See L<perlcall>.
2073
2074 =cut
2075 */
2076
2077 I32
2078 Perl_call_pv(pTHX_ const char *sub_name, I32 flags)
2079                         /* name of the subroutine */
2080                         /* See G_* flags in cop.h */
2081 {
2082     return call_sv((SV*)get_cv(sub_name, TRUE), flags);
2083 }
2084
2085 /*
2086 =for apidoc p||call_method
2087
2088 Performs a callback to the specified Perl method.  The blessed object must
2089 be on the stack.  See L<perlcall>.
2090
2091 =cut
2092 */
2093
2094 I32
2095 Perl_call_method(pTHX_ const char *methname, I32 flags)
2096                         /* name of the subroutine */
2097                         /* See G_* flags in cop.h */
2098 {
2099     return call_sv(sv_2mortal(newSVpv(methname,0)), flags | G_METHOD);
2100 }
2101
2102 /* May be called with any of a CV, a GV, or an SV containing the name. */
2103 /*
2104 =for apidoc p||call_sv
2105
2106 Performs a callback to the Perl sub whose name is in the SV.  See
2107 L<perlcall>.
2108
2109 =cut
2110 */
2111
2112 I32
2113 Perl_call_sv(pTHX_ SV *sv, I32 flags)
2114                         /* See G_* flags in cop.h */
2115 {
2116     dVAR; dSP;
2117     LOGOP myop;         /* fake syntax tree node */
2118     UNOP method_op;
2119     I32 oldmark;
2120     volatile I32 retval = 0;
2121     I32 oldscope;
2122     bool oldcatch = CATCH_GET;
2123     int ret;
2124     OP* oldop = PL_op;
2125     dJMPENV;
2126
2127     if (flags & G_DISCARD) {
2128         ENTER;
2129         SAVETMPS;
2130     }
2131
2132     Zero(&myop, 1, LOGOP);
2133     myop.op_next = Nullop;
2134     if (!(flags & G_NOARGS))
2135         myop.op_flags |= OPf_STACKED;
2136     myop.op_flags |= ((flags & G_VOID) ? OPf_WANT_VOID :
2137                       (flags & G_ARRAY) ? OPf_WANT_LIST :
2138                       OPf_WANT_SCALAR);
2139     SAVEOP();
2140     PL_op = (OP*)&myop;
2141
2142     EXTEND(PL_stack_sp, 1);
2143     *++PL_stack_sp = sv;
2144     oldmark = TOPMARK;
2145     oldscope = PL_scopestack_ix;
2146
2147     if (PERLDB_SUB && PL_curstash != PL_debstash
2148            /* Handle first BEGIN of -d. */
2149           && (PL_DBcv || (PL_DBcv = GvCV(PL_DBsub)))
2150            /* Try harder, since this may have been a sighandler, thus
2151             * curstash may be meaningless. */
2152           && (SvTYPE(sv) != SVt_PVCV || CvSTASH((CV*)sv) != PL_debstash)
2153           && !(flags & G_NODEBUG))
2154         PL_op->op_private |= OPpENTERSUB_DB;
2155
2156     if (flags & G_METHOD) {
2157         Zero(&method_op, 1, UNOP);
2158         method_op.op_next = PL_op;
2159         method_op.op_ppaddr = PL_ppaddr[OP_METHOD];
2160         myop.op_ppaddr = PL_ppaddr[OP_ENTERSUB];
2161         PL_op = (OP*)&method_op;
2162     }
2163
2164     if (!(flags & G_EVAL)) {
2165         CATCH_SET(TRUE);
2166         call_body((OP*)&myop, FALSE);
2167         retval = PL_stack_sp - (PL_stack_base + oldmark);
2168         CATCH_SET(oldcatch);
2169     }
2170     else {
2171         myop.op_other = (OP*)&myop;
2172         PL_markstack_ptr--;
2173         /* we're trying to emulate pp_entertry() here */
2174         {
2175             register PERL_CONTEXT *cx;
2176             I32 gimme = GIMME_V;
2177
2178             ENTER;
2179             SAVETMPS;
2180
2181             PUSHBLOCK(cx, (CXt_EVAL|CXp_TRYBLOCK), PL_stack_sp);
2182             PUSHEVAL(cx, 0, 0);
2183             PL_eval_root = PL_op;             /* Only needed so that goto works right. */
2184
2185             PL_in_eval = EVAL_INEVAL;
2186             if (flags & G_KEEPERR)
2187                 PL_in_eval |= EVAL_KEEPERR;
2188             else
2189                 sv_setpv(ERRSV,"");
2190         }
2191         PL_markstack_ptr++;
2192
2193         JMPENV_PUSH(ret);
2194         switch (ret) {
2195         case 0:
2196  redo_body:
2197             call_body((OP*)&myop, FALSE);
2198             retval = PL_stack_sp - (PL_stack_base + oldmark);
2199             if (!(flags & G_KEEPERR))
2200                 sv_setpv(ERRSV,"");
2201             break;
2202         case 1:
2203             STATUS_ALL_FAILURE;
2204             /* FALL THROUGH */
2205         case 2:
2206             /* my_exit() was called */
2207             PL_curstash = PL_defstash;
2208             FREETMPS;
2209             JMPENV_POP;
2210             if (PL_statusvalue && !(PL_exit_flags & PERL_EXIT_EXPECTED))
2211                 Perl_croak(aTHX_ "Callback called exit");
2212             my_exit_jump();
2213             /* NOTREACHED */
2214         case 3:
2215             if (PL_restartop) {
2216                 PL_op = PL_restartop;
2217                 PL_restartop = 0;
2218                 goto redo_body;
2219             }
2220             PL_stack_sp = PL_stack_base + oldmark;
2221             if (flags & G_ARRAY)
2222                 retval = 0;
2223             else {
2224                 retval = 1;
2225                 *++PL_stack_sp = &PL_sv_undef;
2226             }
2227             break;
2228         }
2229
2230         if (PL_scopestack_ix > oldscope) {
2231             SV **newsp;
2232             PMOP *newpm;
2233             I32 gimme;
2234             register PERL_CONTEXT *cx;
2235             I32 optype;
2236
2237             POPBLOCK(cx,newpm);
2238             POPEVAL(cx);
2239             PL_curpm = newpm;
2240             LEAVE;
2241         }
2242         JMPENV_POP;
2243     }
2244
2245     if (flags & G_DISCARD) {
2246         PL_stack_sp = PL_stack_base + oldmark;
2247         retval = 0;
2248         FREETMPS;
2249         LEAVE;
2250     }
2251     PL_op = oldop;
2252     return retval;
2253 }
2254
2255 STATIC void
2256 S_call_body(pTHX_ const OP *myop, bool is_eval)
2257 {
2258     if (PL_op == myop) {
2259         if (is_eval)
2260             PL_op = Perl_pp_entereval(aTHX);    /* this doesn't do a POPMARK */
2261         else
2262             PL_op = Perl_pp_entersub(aTHX);     /* this does */
2263     }
2264     if (PL_op)
2265         CALLRUNOPS(aTHX);
2266 }
2267
2268 /* Eval a string. The G_EVAL flag is always assumed. */
2269
2270 /*
2271 =for apidoc p||eval_sv
2272
2273 Tells Perl to C<eval> the string in the SV.
2274
2275 =cut
2276 */
2277
2278 I32
2279 Perl_eval_sv(pTHX_ SV *sv, I32 flags)
2280
2281                         /* See G_* flags in cop.h */
2282 {
2283     dSP;
2284     UNOP myop;          /* fake syntax tree node */
2285     volatile I32 oldmark = SP - PL_stack_base;
2286     volatile I32 retval = 0;
2287     I32 oldscope;
2288     int ret;
2289     OP* oldop = PL_op;
2290     dJMPENV;
2291
2292     if (flags & G_DISCARD) {
2293         ENTER;
2294         SAVETMPS;
2295     }
2296
2297     SAVEOP();
2298     PL_op = (OP*)&myop;
2299     Zero(PL_op, 1, UNOP);
2300     EXTEND(PL_stack_sp, 1);
2301     *++PL_stack_sp = sv;
2302     oldscope = PL_scopestack_ix;
2303
2304     if (!(flags & G_NOARGS))
2305         myop.op_flags = OPf_STACKED;
2306     myop.op_next = Nullop;
2307     myop.op_type = OP_ENTEREVAL;
2308     myop.op_flags |= ((flags & G_VOID) ? OPf_WANT_VOID :
2309                       (flags & G_ARRAY) ? OPf_WANT_LIST :
2310                       OPf_WANT_SCALAR);
2311     if (flags & G_KEEPERR)
2312         myop.op_flags |= OPf_SPECIAL;
2313
2314     /* fail now; otherwise we could fail after the JMPENV_PUSH but
2315      * before a PUSHEVAL, which corrupts the stack after a croak */
2316     TAINT_PROPER("eval_sv()");
2317
2318     JMPENV_PUSH(ret);
2319     switch (ret) {
2320     case 0:
2321  redo_body:
2322         call_body((OP*)&myop,TRUE);
2323         retval = PL_stack_sp - (PL_stack_base + oldmark);
2324         if (!(flags & G_KEEPERR))
2325             sv_setpv(ERRSV,"");
2326         break;
2327     case 1:
2328         STATUS_ALL_FAILURE;
2329         /* FALL THROUGH */
2330     case 2:
2331         /* my_exit() was called */
2332         PL_curstash = PL_defstash;
2333         FREETMPS;
2334         JMPENV_POP;
2335         if (PL_statusvalue && !(PL_exit_flags & PERL_EXIT_EXPECTED))
2336             Perl_croak(aTHX_ "Callback called exit");
2337         my_exit_jump();
2338         /* NOTREACHED */
2339     case 3:
2340         if (PL_restartop) {
2341             PL_op = PL_restartop;
2342             PL_restartop = 0;
2343             goto redo_body;
2344         }
2345         PL_stack_sp = PL_stack_base + oldmark;
2346         if (flags & G_ARRAY)
2347             retval = 0;
2348         else {
2349             retval = 1;
2350             *++PL_stack_sp = &PL_sv_undef;
2351         }
2352         break;
2353     }
2354
2355     JMPENV_POP;
2356     if (flags & G_DISCARD) {
2357         PL_stack_sp = PL_stack_base + oldmark;
2358         retval = 0;
2359         FREETMPS;
2360         LEAVE;
2361     }
2362     PL_op = oldop;
2363     return retval;
2364 }
2365
2366 /*
2367 =for apidoc p||eval_pv
2368
2369 Tells Perl to C<eval> the given string and return an SV* result.
2370
2371 =cut
2372 */
2373
2374 SV*
2375 Perl_eval_pv(pTHX_ const char *p, I32 croak_on_error)
2376 {
2377     dSP;
2378     SV* sv = newSVpv(p, 0);
2379
2380     eval_sv(sv, G_SCALAR);
2381     SvREFCNT_dec(sv);
2382
2383     SPAGAIN;
2384     sv = POPs;
2385     PUTBACK;
2386
2387     if (croak_on_error && SvTRUE(ERRSV)) {
2388         STRLEN n_a;
2389         Perl_croak(aTHX_ SvPVx(ERRSV, n_a));
2390     }
2391
2392     return sv;
2393 }
2394
2395 /* Require a module. */
2396
2397 /*
2398 =head1 Embedding Functions
2399
2400 =for apidoc p||require_pv
2401
2402 Tells Perl to C<require> the file named by the string argument.  It is
2403 analogous to the Perl code C<eval "require '$file'">.  It's even
2404 implemented that way; consider using load_module instead.
2405
2406 =cut */
2407
2408 void
2409 Perl_require_pv(pTHX_ const char *pv)
2410 {
2411     SV* sv;
2412     dSP;
2413     PUSHSTACKi(PERLSI_REQUIRE);
2414     PUTBACK;
2415     sv = sv_newmortal();
2416     sv_setpv(sv, "require '");
2417     sv_catpv(sv, pv);
2418     sv_catpv(sv, "'");
2419     eval_sv(sv, G_DISCARD);
2420     SPAGAIN;
2421     POPSTACK;
2422 }
2423
2424 void
2425 Perl_magicname(pTHX_ const char *sym, const char *name, I32 namlen)
2426 {
2427     register GV *gv;
2428
2429     if ((gv = gv_fetchpv(sym,TRUE, SVt_PV)))
2430         sv_magic(GvSV(gv), (SV*)gv, PERL_MAGIC_sv, name, namlen);
2431 }
2432
2433 STATIC void
2434 S_usage(pTHX_ const char *name)         /* XXX move this out into a module ? */
2435 {
2436     /* This message really ought to be max 23 lines.
2437      * Removed -h because the user already knows that option. Others? */
2438
2439     static const char * const usage_msg[] = {
2440 "-0[octal]       specify record separator (\\0, if no argument)",
2441 "-a              autosplit mode with -n or -p (splits $_ into @F)",
2442 "-C[number/list] enables the listed Unicode features",
2443 "-c              check syntax only (runs BEGIN and CHECK blocks)",
2444 "-d[:debugger]   run program under debugger",
2445 "-D[number/list] set debugging flags (argument is a bit mask or alphabets)",
2446 "-e program      one line of program (several -e's allowed, omit programfile)",
2447 "-f              don't do $sitelib/sitecustomize.pl at startup",
2448 "-F/pattern/     split() pattern for -a switch (//'s are optional)",
2449 "-i[extension]   edit <> files in place (makes backup if extension supplied)",
2450 "-Idirectory     specify @INC/#include directory (several -I's allowed)",
2451 "-l[octal]       enable line ending processing, specifies line terminator",
2452 "-[mM][-]module  execute `use/no module...' before executing program",
2453 "-n              assume 'while (<>) { ... }' loop around program",
2454 "-p              assume loop like -n but print line also, like sed",
2455 "-P              run program through C preprocessor before compilation",
2456 "-s              enable rudimentary parsing for switches after programfile",
2457 "-S              look for programfile using PATH environment variable",
2458 "-t              enable tainting warnings",
2459 "-T              enable tainting checks",
2460 "-u              dump core after parsing program",
2461 "-U              allow unsafe operations",
2462 "-v              print version, subversion (includes VERY IMPORTANT perl info)",
2463 "-V[:variable]   print configuration summary (or a single Config.pm variable)",
2464 "-w              enable many useful warnings (RECOMMENDED)",
2465 "-W              enable all warnings",
2466 "-x[directory]   strip off text before #!perl line and perhaps cd to directory",
2467 "-X              disable all warnings",
2468 "\n",
2469 NULL
2470 };
2471     const char * const *p = usage_msg;
2472
2473     PerlIO_printf(PerlIO_stdout(),
2474                   "\nUsage: %s [switches] [--] [programfile] [arguments]",
2475                   name);
2476     while (*p)
2477         PerlIO_printf(PerlIO_stdout(), "\n  %s", *p++);
2478 }
2479
2480 /* convert a string of -D options (or digits) into an int.
2481  * sets *s to point to the char after the options */
2482
2483 #ifdef DEBUGGING
2484 int
2485 Perl_get_debug_opts(pTHX_ const char **s, bool givehelp)
2486 {
2487     static const char * const usage_msgd[] = {
2488       " Debugging flag values: (see also -d)",
2489       "  p  Tokenizing and parsing (with v, displays parse stack)",
2490       "  s  Stack snapshots (with v, displays all stacks)",
2491       "  l  Context (loop) stack processing",
2492       "  t  Trace execution",
2493       "  o  Method and overloading resolution",
2494       "  c  String/numeric conversions",
2495       "  P  Print profiling info, preprocessor command for -P, source file input state",
2496       "  m  Memory allocation",
2497       "  f  Format processing",
2498       "  r  Regular expression parsing and execution",
2499       "  x  Syntax tree dump",
2500       "  u  Tainting checks",
2501       "  H  Hash dump -- usurps values()",
2502       "  X  Scratchpad allocation",
2503       "  D  Cleaning up",
2504       "  S  Thread synchronization",
2505       "  T  Tokenising",
2506       "  R  Include reference counts of dumped variables (eg when using -Ds)",
2507       "  J  Do not s,t,P-debug (Jump over) opcodes within package DB",
2508       "  v  Verbose: use in conjunction with other flags",
2509       "  C  Copy On Write",
2510       "  A  Consistency checks on internal structures",
2511       "  q  quiet - currently only suppresses the 'EXECUTING' message",
2512       NULL
2513     };
2514     int i = 0;
2515     if (isALPHA(**s)) {
2516         /* if adding extra options, remember to update DEBUG_MASK */
2517         static const char debopts[] = "psltocPmfrxu HXDSTRJvCAq";
2518
2519         for (; isALNUM(**s); (*s)++) {
2520             const char *d = strchr(debopts,**s);
2521             if (d)
2522                 i |= 1 << (d - debopts);
2523             else if (ckWARN_d(WARN_DEBUGGING))
2524                 Perl_warner(aTHX_ packWARN(WARN_DEBUGGING),
2525                     "invalid option -D%c, use -D'' to see choices\n", **s);
2526         }
2527     }
2528     else if (isDIGIT(**s)) {
2529         i = atoi(*s);
2530         for (; isALNUM(**s); (*s)++) ;
2531     }
2532     else if (givehelp) {
2533       const char **p = usage_msgd;
2534       while (*p) PerlIO_printf(PerlIO_stdout(), "%s\n", *p++);
2535     }
2536 #  ifdef EBCDIC
2537     if ((i & DEBUG_p_FLAG) && ckWARN_d(WARN_DEBUGGING))
2538         Perl_warner(aTHX_ packWARN(WARN_DEBUGGING),
2539                 "-Dp not implemented on this platform\n");
2540 #  endif
2541     return i;
2542 }
2543 #endif
2544
2545 /* This routine handles any switches that can be given during run */
2546
2547 char *
2548 Perl_moreswitches(pTHX_ char *s)
2549 {
2550     dVAR;
2551     STRLEN numlen;
2552     UV rschar;
2553
2554     switch (*s) {
2555     case '0':
2556     {
2557          I32 flags = 0;
2558
2559          SvREFCNT_dec(PL_rs);
2560          if (s[1] == 'x' && s[2]) {
2561               char *e;
2562               U8 *tmps;
2563
2564               for (s += 2, e = s; *e; e++);
2565               numlen = e - s;
2566               flags = PERL_SCAN_SILENT_ILLDIGIT;
2567               rschar = (U32)grok_hex(s, &numlen, &flags, NULL);
2568               if (s + numlen < e) {
2569                    rschar = 0; /* Grandfather -0xFOO as -0 -xFOO. */
2570                    numlen = 0;
2571                    s--;
2572               }
2573               PL_rs = newSVpvn("", 0);
2574               SvGROW(PL_rs, (STRLEN)(UNISKIP(rschar) + 1));
2575               tmps = (U8*)SvPVX(PL_rs);
2576               uvchr_to_utf8(tmps, rschar);
2577               SvCUR_set(PL_rs, UNISKIP(rschar));
2578               SvUTF8_on(PL_rs);
2579          }
2580          else {
2581               numlen = 4;
2582               rschar = (U32)grok_oct(s, &numlen, &flags, NULL);
2583               if (rschar & ~((U8)~0))
2584                    PL_rs = &PL_sv_undef;
2585               else if (!rschar && numlen >= 2)
2586                    PL_rs = newSVpvn("", 0);
2587               else {
2588                    char ch = (char)rschar;
2589                    PL_rs = newSVpvn(&ch, 1);
2590               }
2591          }
2592          sv_setsv(get_sv("/", TRUE), PL_rs);
2593          return s + numlen;
2594     }
2595     case 'C':
2596         s++;
2597         PL_unicode = parse_unicode_opts( (const char **)&s );
2598         return s;
2599     case 'F':
2600         PL_minus_F = TRUE;
2601         PL_splitstr = ++s;
2602         while (*s && !isSPACE(*s)) ++s;
2603         *s = '\0';
2604         PL_splitstr = savepv(PL_splitstr);
2605         return s;
2606     case 'a':
2607         PL_minus_a = TRUE;
2608         s++;
2609         return s;
2610     case 'c':
2611         PL_minus_c = TRUE;
2612         s++;
2613         return s;
2614     case 'd':
2615         forbid_setid("-d");
2616         s++;
2617
2618         /* -dt indicates to the debugger that threads will be used */
2619         if (*s == 't' && !isALNUM(s[1])) {
2620             ++s;
2621             my_setenv("PERL5DB_THREADED", "1");
2622         }
2623
2624         /* The following permits -d:Mod to accepts arguments following an =
2625            in the fashion that -MSome::Mod does. */
2626         if (*s == ':' || *s == '=') {
2627             const char *start;
2628             SV *sv;
2629             sv = newSVpv("use Devel::", 0);
2630             start = ++s;
2631             /* We now allow -d:Module=Foo,Bar */
2632             while(isALNUM(*s) || *s==':') ++s;
2633             if (*s != '=')
2634                 sv_catpv(sv, start);
2635             else {
2636                 sv_catpvn(sv, start, s-start);
2637                 sv_catpv(sv, " split(/,/,q{");
2638                 sv_catpv(sv, ++s);
2639                 sv_catpv(sv, "})");
2640             }
2641             s += strlen(s);
2642             my_setenv("PERL5DB", SvPV(sv, PL_na));
2643         }
2644         if (!PL_perldb) {
2645             PL_perldb = PERLDB_ALL;
2646             init_debugger();
2647         }
2648         return s;
2649     case 'D':
2650     {
2651 #ifdef DEBUGGING
2652         forbid_setid("-D");
2653         s++;
2654         PL_debug = get_debug_opts( (const char **)&s, 1) | DEBUG_TOP_FLAG;
2655 #else /* !DEBUGGING */
2656         if (ckWARN_d(WARN_DEBUGGING))
2657             Perl_warner(aTHX_ packWARN(WARN_DEBUGGING),
2658                    "Recompile perl with -DDEBUGGING to use -D switch (did you mean -d ?)\n");
2659         for (s++; isALNUM(*s); s++) ;
2660 #endif
2661         /*SUPPRESS 530*/
2662         return s;
2663     }
2664     case 'h':
2665         usage(PL_origargv[0]);
2666         my_exit(0);
2667     case 'i':
2668         if (PL_inplace)
2669             Safefree(PL_inplace);
2670 #if defined(__CYGWIN__) /* do backup extension automagically */
2671         if (*(s+1) == '\0') {
2672         PL_inplace = savepv(".bak");
2673         return s+1;
2674         }
2675 #endif /* __CYGWIN__ */
2676         PL_inplace = savepv(s+1);
2677         /*SUPPRESS 530*/
2678         for (s = PL_inplace; *s && !isSPACE(*s); s++) ;
2679         if (*s) {
2680             *s++ = '\0';
2681             if (*s == '-')      /* Additional switches on #! line. */
2682                 s++;
2683         }
2684         return s;
2685     case 'I':   /* -I handled both here and in parse_body() */
2686         forbid_setid("-I");
2687         ++s;
2688         while (*s && isSPACE(*s))
2689             ++s;
2690         if (*s) {
2691             char *e, *p;
2692             p = s;
2693             /* ignore trailing spaces (possibly followed by other switches) */
2694             do {
2695                 for (e = p; *e && !isSPACE(*e); e++) ;
2696                 p = e;
2697                 while (isSPACE(*p))
2698                     p++;
2699             } while (*p && *p != '-');
2700             e = savepvn(s, e-s);
2701             incpush(e, TRUE, TRUE, FALSE, FALSE);
2702             Safefree(e);
2703             s = p;
2704             if (*s == '-')
2705                 s++;
2706         }
2707         else
2708             Perl_croak(aTHX_ "No directory specified for -I");
2709         return s;
2710     case 'l':
2711         PL_minus_l = TRUE;
2712         s++;
2713         if (PL_ors_sv) {
2714             SvREFCNT_dec(PL_ors_sv);
2715             PL_ors_sv = Nullsv;
2716         }
2717         if (isDIGIT(*s)) {
2718             I32 flags = 0;
2719             PL_ors_sv = newSVpvn("\n",1);
2720             numlen = 3 + (*s == '0');
2721             *SvPVX(PL_ors_sv) = (char)grok_oct(s, &numlen, &flags, NULL);
2722             s += numlen;
2723         }
2724         else {
2725             if (RsPARA(PL_rs)) {
2726                 PL_ors_sv = newSVpvn("\n\n",2);
2727             }
2728             else {
2729                 PL_ors_sv = newSVsv(PL_rs);
2730             }
2731         }
2732         return s;
2733     case 'A':
2734         forbid_setid("-A");
2735         if (!PL_preambleav)
2736             PL_preambleav = newAV();
2737         if (*++s) {
2738             SV *sv = newSVpv("use assertions::activate split(/,/,q", 0);
2739             sv_catpvn(sv, "\0", 1);     /* Use NUL as q//-delimiter. */
2740             sv_catpv(sv,s);
2741             sv_catpvn(sv, "\0)", 2);
2742             s+=strlen(s);
2743             av_push(PL_preambleav, sv);
2744         }
2745         else
2746             av_push(PL_preambleav, newSVpvn("use assertions::activate",24));
2747         return s;
2748     case 'M':
2749         forbid_setid("-M");     /* XXX ? */
2750         /* FALL THROUGH */
2751     case 'm':
2752         forbid_setid("-m");     /* XXX ? */
2753         if (*++s) {
2754             char *start;
2755             SV *sv;
2756             const char *use = "use ";
2757             /* -M-foo == 'no foo'       */
2758             if (*s == '-') { use = "no "; ++s; }
2759             sv = newSVpv(use,0);
2760             start = s;
2761             /* We allow -M'Module qw(Foo Bar)'  */
2762             while(isALNUM(*s) || *s==':') ++s;
2763             if (*s != '=') {
2764                 sv_catpv(sv, start);
2765                 if (*(start-1) == 'm') {
2766                     if (*s != '\0')
2767                         Perl_croak(aTHX_ "Can't use '%c' after -mname", *s);
2768                     sv_catpv( sv, " ()");
2769                 }
2770             } else {
2771                 if (s == start)
2772                     Perl_croak(aTHX_ "Module name required with -%c option",
2773                                s[-1]);
2774                 sv_catpvn(sv, start, s-start);
2775                 sv_catpv(sv, " split(/,/,q");
2776                 sv_catpvn(sv, "\0)", 1);        /* Use NUL as q//-delimiter. */
2777                 sv_catpv(sv, ++s);
2778                 sv_catpvn(sv,  "\0)", 2);
2779             }
2780             s += strlen(s);
2781             if (!PL_preambleav)
2782                 PL_preambleav = newAV();
2783             av_push(PL_preambleav, sv);
2784         }
2785         else
2786             Perl_croak(aTHX_ "Missing argument to -%c", *(s-1));
2787         return s;
2788     case 'n':
2789         PL_minus_n = TRUE;
2790         s++;
2791         return s;
2792     case 'p':
2793         PL_minus_p = TRUE;
2794         s++;
2795         return s;
2796     case 's':
2797         forbid_setid("-s");
2798         PL_doswitches = TRUE;
2799         s++;
2800         return s;
2801     case 't':
2802         if (!PL_tainting)
2803             TOO_LATE_FOR('t');
2804         s++;
2805         return s;
2806     case 'T':
2807         if (!PL_tainting)
2808             TOO_LATE_FOR('T');
2809         s++;
2810         return s;
2811     case 'u':
2812 #ifdef MACOS_TRADITIONAL
2813         Perl_croak(aTHX_ "Believe me, you don't want to use \"-u\" on a Macintosh");
2814 #endif
2815         PL_do_undump = TRUE;
2816         s++;
2817         return s;
2818     case 'U':
2819         PL_unsafe = TRUE;
2820         s++;
2821         return s;
2822     case 'v':
2823         if (!sv_derived_from(PL_patchlevel, "version"))
2824                 (void *)upg_version(PL_patchlevel);
2825 #if !defined(DGUX)
2826         PerlIO_printf(PerlIO_stdout(),
2827                 Perl_form(aTHX_ "\nThis is perl, v%"SVf" built for %s",
2828                     vstringify(PL_patchlevel),
2829                     ARCHNAME));
2830 #else /* DGUX */
2831 /* Adjust verbose output as in the perl that ships with the DG/UX OS from EMC */
2832         PerlIO_printf(PerlIO_stdout(),
2833                 Perl_form(aTHX_ "\nThis is perl, v%"SVf"\n",
2834                     vstringify(PL_patchlevel)));
2835         PerlIO_printf(PerlIO_stdout(),
2836                         Perl_form(aTHX_ "        built under %s at %s %s\n",
2837                                         OSNAME, __DATE__, __TIME__));
2838         PerlIO_printf(PerlIO_stdout(),
2839                         Perl_form(aTHX_ "        OS Specific Release: %s\n",
2840                                         OSVERS));
2841 #endif /* !DGUX */
2842
2843 #if defined(LOCAL_PATCH_COUNT)
2844         if (LOCAL_PATCH_COUNT > 0)
2845             PerlIO_printf(PerlIO_stdout(),
2846                           "\n(with %d registered patch%s, "
2847                           "see perl -V for more detail)",
2848                           (int)LOCAL_PATCH_COUNT,
2849                           (LOCAL_PATCH_COUNT!=1) ? "es" : "");
2850 #endif
2851
2852         PerlIO_printf(PerlIO_stdout(),
2853                       "\n\nCopyright 1987-2005, Larry Wall\n");
2854 #ifdef MACOS_TRADITIONAL
2855         PerlIO_printf(PerlIO_stdout(),
2856                       "\nMac OS port Copyright 1991-2002, Matthias Neeracher;\n"
2857                       "maintained by Chris Nandor\n");
2858 #endif
2859 #ifdef MSDOS
2860         PerlIO_printf(PerlIO_stdout(),
2861                       "\nMS-DOS port Copyright (c) 1989, 1990, Diomidis Spinellis\n");
2862 #endif
2863 #ifdef DJGPP
2864         PerlIO_printf(PerlIO_stdout(),
2865                       "djgpp v2 port (jpl5003c) by Hirofumi Watanabe, 1996\n"
2866                       "djgpp v2 port (perl5004+) by Laszlo Molnar, 1997-1999\n");
2867 #endif
2868 #ifdef OS2
2869         PerlIO_printf(PerlIO_stdout(),
2870                       "\n\nOS/2 port Copyright (c) 1990, 1991, Raymond Chen, Kai Uwe Rommel\n"
2871                       "Version 5 port Copyright (c) 1994-2002, Andreas Kaiser, Ilya Zakharevich\n");
2872 #endif
2873 #ifdef atarist
2874         PerlIO_printf(PerlIO_stdout(),
2875                       "atariST series port, ++jrb  bammi@cadence.com\n");
2876 #endif
2877 #ifdef __BEOS__
2878         PerlIO_printf(PerlIO_stdout(),
2879                       "BeOS port Copyright Tom Spindler, 1997-1999\n");
2880 #endif
2881 #ifdef MPE
2882         PerlIO_printf(PerlIO_stdout(),
2883                       "MPE/iX port Copyright by Mark Klein and Mark Bixby, 1996-2003\n");
2884 #endif
2885 #ifdef OEMVS
2886         PerlIO_printf(PerlIO_stdout(),
2887                       "MVS (OS390) port by Mortice Kern Systems, 1997-1999\n");
2888 #endif
2889 #ifdef __VOS__
2890         PerlIO_printf(PerlIO_stdout(),
2891                       "Stratus VOS port by Paul.Green@stratus.com, 1997-2002\n");
2892 #endif
2893 #ifdef __OPEN_VM
2894         PerlIO_printf(PerlIO_stdout(),
2895                       "VM/ESA port by Neale Ferguson, 1998-1999\n");
2896 #endif
2897 #ifdef POSIX_BC
2898         PerlIO_printf(PerlIO_stdout(),
2899                       "BS2000 (POSIX) port by Start Amadeus GmbH, 1998-1999\n");
2900 #endif
2901 #ifdef __MINT__
2902         PerlIO_printf(PerlIO_stdout(),
2903                       "MiNT port by Guido Flohr, 1997-1999\n");
2904 #endif
2905 #ifdef EPOC
2906         PerlIO_printf(PerlIO_stdout(),
2907                       "EPOC port by Olaf Flebbe, 1999-2002\n");
2908 #endif
2909 #ifdef UNDER_CE
2910         PerlIO_printf(PerlIO_stdout(),"WINCE port by Rainer Keuchel, 2001-2002\n");
2911         PerlIO_printf(PerlIO_stdout(),"Built on " __DATE__ " " __TIME__ "\n\n");
2912         wce_hitreturn();
2913 #endif
2914 #ifdef SYMBIAN
2915         PerlIO_printf(PerlIO_stdout(),
2916                       "Symbian port by Nokia, 2004-2005\n");
2917 #endif
2918 #ifdef BINARY_BUILD_NOTICE
2919         BINARY_BUILD_NOTICE;
2920 #endif
2921         PerlIO_printf(PerlIO_stdout(),
2922                       "\n\
2923 Perl may be copied only under the terms of either the Artistic License or the\n\
2924 GNU General Public License, which may be found in the Perl 5 source kit.\n\n\
2925 Complete documentation for Perl, including FAQ lists, should be found on\n\
2926 this system using `man perl' or `perldoc perl'.  If you have access to the\n\
2927 Internet, point your browser at http://www.perl.org/, the Perl Home Page.\n\n");
2928         my_exit(0);
2929     case 'w':
2930         if (! (PL_dowarn & G_WARN_ALL_MASK))
2931             PL_dowarn |= G_WARN_ON;
2932         s++;
2933         return s;
2934     case 'W':
2935         PL_dowarn = G_WARN_ALL_ON|G_WARN_ON;
2936         if (!specialWARN(PL_compiling.cop_warnings))
2937             SvREFCNT_dec(PL_compiling.cop_warnings);
2938         PL_compiling.cop_warnings = pWARN_ALL ;
2939         s++;
2940         return s;
2941     case 'X':
2942         PL_dowarn = G_WARN_ALL_OFF;
2943         if (!specialWARN(PL_compiling.cop_warnings))
2944             SvREFCNT_dec(PL_compiling.cop_warnings);
2945         PL_compiling.cop_warnings = pWARN_NONE ;
2946         s++;
2947         return s;
2948     case '*':
2949     case ' ':
2950         if (s[1] == '-')        /* Additional switches on #! line. */
2951             return s+2;
2952         break;
2953     case '-':
2954     case 0:
2955 #if defined(WIN32) || !defined(PERL_STRICT_CR)
2956     case '\r':
2957 #endif
2958     case '\n':
2959     case '\t':
2960         break;
2961 #ifdef ALTERNATE_SHEBANG
2962     case 'S':                   /* OS/2 needs -S on "extproc" line. */
2963         break;
2964 #endif
2965     case 'P':
2966         if (PL_preprocess)
2967             return s+1;
2968         /* FALL THROUGH */
2969     default:
2970         Perl_croak(aTHX_ "Can't emulate -%.1s on #! line",s);
2971     }
2972     return Nullch;
2973 }
2974
2975 /* compliments of Tom Christiansen */
2976
2977 /* unexec() can be found in the Gnu emacs distribution */
2978 /* Known to work with -DUNEXEC and using unexelf.c from GNU emacs-20.2 */
2979
2980 void
2981 Perl_my_unexec(pTHX)
2982 {
2983 #ifdef UNEXEC
2984     SV*    prog;
2985     SV*    file;
2986     int    status = 1;
2987     extern int etext;
2988
2989     prog = newSVpv(BIN_EXP, 0);
2990     sv_catpv(prog, "/perl");
2991     file = newSVpv(PL_origfilename, 0);
2992     sv_catpv(file, ".perldump");
2993
2994     unexec(SvPVX(file), SvPVX(prog), &etext, sbrk(0), 0);
2995     /* unexec prints msg to stderr in case of failure */
2996     PerlProc_exit(status);
2997 #else
2998 #  ifdef VMS
2999 #    include <lib$routines.h>
3000      lib$signal(SS$_DEBUG);  /* ssdef.h #included from vmsish.h */
3001 #  else
3002     ABORT();            /* for use with undump */
3003 #  endif
3004 #endif
3005 }
3006
3007 /* initialize curinterp */
3008 STATIC void
3009 S_init_interp(pTHX)
3010 {
3011
3012 #ifdef MULTIPLICITY
3013 #  define PERLVAR(var,type)
3014 #  define PERLVARA(var,n,type)
3015 #  if defined(PERL_IMPLICIT_CONTEXT)
3016 #    if defined(USE_5005THREADS)
3017 #      define PERLVARI(var,type,init)           PERL_GET_INTERP->var = init;
3018 #      define PERLVARIC(var,type,init)          PERL_GET_INTERP->var = init;
3019 #    else /* !USE_5005THREADS */
3020 #      define PERLVARI(var,type,init)           aTHX->var = init;
3021 #      define PERLVARIC(var,type,init)  aTHX->var = init;
3022 #    endif /* USE_5005THREADS */
3023 #  else
3024 #    define PERLVARI(var,type,init)     PERL_GET_INTERP->var = init;
3025 #    define PERLVARIC(var,type,init)    PERL_GET_INTERP->var = init;
3026 #  endif
3027 #  include "intrpvar.h"
3028 #  ifndef USE_5005THREADS
3029 #    include "thrdvar.h"
3030 #  endif
3031 #  undef PERLVAR
3032 #  undef PERLVARA
3033 #  undef PERLVARI
3034 #  undef PERLVARIC
3035 #else
3036 #  define PERLVAR(var,type)
3037 #  define PERLVARA(var,n,type)
3038 #  define PERLVARI(var,type,init)       PL_##var = init;
3039 #  define PERLVARIC(var,type,init)      PL_##var = init;
3040 #  include "intrpvar.h"
3041 #  ifndef USE_5005THREADS
3042 #    include "thrdvar.h"
3043 #  endif
3044 #  undef PERLVAR
3045 #  undef PERLVARA
3046 #  undef PERLVARI
3047 #  undef PERLVARIC
3048 #endif
3049
3050 }
3051
3052 STATIC void
3053 S_init_main_stash(pTHX)
3054 {
3055     GV *gv;
3056
3057     PL_curstash = PL_defstash = newHV();
3058     PL_curstname = newSVpvn("main",4);
3059     gv = gv_fetchpv("main::",TRUE, SVt_PVHV);
3060     SvREFCNT_dec(GvHV(gv));
3061     GvHV(gv) = (HV*)SvREFCNT_inc(PL_defstash);
3062     SvREADONLY_on(gv);
3063     HvNAME(PL_defstash) = savepvn("main", 4);
3064     PL_incgv = gv_HVadd(gv_AVadd(gv_fetchpv("INC",TRUE, SVt_PVAV)));
3065     GvMULTI_on(PL_incgv);
3066     PL_hintgv = gv_fetchpv("\010",TRUE, SVt_PV); /* ^H */
3067     GvMULTI_on(PL_hintgv);
3068     PL_defgv = gv_fetchpv("_",TRUE, SVt_PVAV);
3069     PL_errgv = gv_HVadd(gv_fetchpv("@", TRUE, SVt_PV));
3070     GvMULTI_on(PL_errgv);
3071     PL_replgv = gv_fetchpv("\022", TRUE, SVt_PV); /* ^R */
3072     GvMULTI_on(PL_replgv);
3073     (void)Perl_form(aTHX_ "%240s","");  /* Preallocate temp - for immediate signals. */
3074     sv_grow(ERRSV, 240);        /* Preallocate - for immediate signals. */
3075     sv_setpvn(ERRSV, "", 0);
3076     PL_curstash = PL_defstash;
3077     CopSTASH_set(&PL_compiling, PL_defstash);
3078     PL_debstash = GvHV(gv_fetchpv("DB::", GV_ADDMULTI, SVt_PVHV));
3079     PL_globalstash = GvHV(gv_fetchpv("CORE::GLOBAL::", GV_ADDMULTI, SVt_PVHV));
3080     /* We must init $/ before switches are processed. */
3081     sv_setpvn(get_sv("/", TRUE), "\n", 1);
3082 }
3083
3084 /* PSz 18 Nov 03  fdscript now global but do not change prototype */
3085 STATIC void
3086 S_open_script(pTHX_ const char *scriptname, bool dosearch, SV *sv)
3087 {
3088 #ifndef IAMSUID
3089     const char *quote;
3090     const char *code;
3091     const char *cpp_discard_flag;
3092     const char *perl;
3093 #endif
3094     dVAR;
3095
3096     PL_fdscript = -1;
3097     PL_suidscript = -1;
3098
3099     if (PL_e_script) {
3100         PL_origfilename = savepvn("-e", 2);
3101     }
3102     else {
3103         /* if find_script() returns, it returns a malloc()-ed value */
3104         scriptname = PL_origfilename = find_script(scriptname, dosearch, NULL, 1);
3105
3106         if (strnEQ(scriptname, "/dev/fd/", 8) && isDIGIT(scriptname[8]) ) {
3107             const char *s = scriptname + 8;
3108             PL_fdscript = atoi(s);
3109             while (isDIGIT(*s))
3110                 s++;
3111             if (*s) {
3112                 /* PSz 18 Feb 04
3113                  * Tell apart "normal" usage of fdscript, e.g.
3114                  * with bash on FreeBSD:
3115                  *   perl <( echo '#!perl -DA'; echo 'print "$0\n"')
3116                  * from usage in suidperl.
3117                  * Does any "normal" usage leave garbage after the number???
3118                  * Is it a mistake to use a similar /dev/fd/ construct for
3119                  * suidperl?
3120                  */
3121                 PL_suidscript = 1;
3122                 /* PSz 20 Feb 04
3123                  * Be supersafe and do some sanity-checks.
3124                  * Still, can we be sure we got the right thing?
3125                  */
3126                 if (*s != '/') {
3127                     Perl_croak(aTHX_ "Wrong syntax (suid) fd script name \"%s\"\n", s);
3128                 }
3129                 if (! *(s+1)) {
3130                     Perl_croak(aTHX_ "Missing (suid) fd script name\n");
3131                 }
3132                 scriptname = savepv(s + 1);
3133                 Safefree(PL_origfilename);
3134                 PL_origfilename = (char *)scriptname;
3135             }
3136         }
3137     }
3138
3139     CopFILE_free(PL_curcop);
3140     CopFILE_set(PL_curcop, PL_origfilename);
3141     if (*PL_origfilename == '-' && PL_origfilename[1] == '\0')
3142         scriptname = (char *)"";
3143     if (PL_fdscript >= 0) {
3144         PL_rsfp = PerlIO_fdopen(PL_fdscript,PERL_SCRIPT_MODE);
3145 #       if defined(HAS_FCNTL) && defined(F_SETFD)
3146             if (PL_rsfp)
3147                 /* ensure close-on-exec */
3148                 fcntl(PerlIO_fileno(PL_rsfp),F_SETFD,1);
3149 #       endif
3150     }
3151 #ifdef IAMSUID
3152     else {
3153         Perl_croak(aTHX_ "sperl needs fd script\n"
3154                    "You should not call sperl directly; do you need to "
3155                    "change a #! line\nfrom sperl to perl?\n");
3156
3157 /* PSz 11 Nov 03
3158  * Do not open (or do other fancy stuff) while setuid.
3159  * Perl does the open, and hands script to suidperl on a fd;
3160  * suidperl only does some checks, sets up UIDs and re-execs
3161  * perl with that fd as it has always done.
3162  */
3163     }
3164     if (PL_suidscript != 1) {
3165         Perl_croak(aTHX_ "suidperl needs (suid) fd script\n");
3166     }
3167 #else /* IAMSUID */
3168     else if (PL_preprocess) {
3169         const char *cpp_cfg = CPPSTDIN;
3170         SV *cpp = newSVpvn("",0);
3171         SV *cmd = NEWSV(0,0);
3172
3173         if (cpp_cfg[0] == 0) /* PERL_MICRO? */
3174              Perl_croak(aTHX_ "Can't run with cpp -P with CPPSTDIN undefined");
3175         if (strEQ(cpp_cfg, "cppstdin"))
3176             Perl_sv_catpvf(aTHX_ cpp, "%s/", BIN_EXP);
3177         sv_catpv(cpp, cpp_cfg);
3178
3179 #       ifndef VMS
3180             sv_catpvn(sv, "-I", 2);
3181             sv_catpv(sv,PRIVLIB_EXP);
3182 #       endif
3183
3184         DEBUG_P(PerlIO_printf(Perl_debug_log,
3185                               "PL_preprocess: scriptname=\"%s\", cpp=\"%s\", sv=\"%s\", CPPMINUS=\"%s\"\n",
3186                               scriptname, SvPVX (cpp), SvPVX (sv), CPPMINUS));
3187
3188 #       if defined(MSDOS) || defined(WIN32) || defined(VMS)
3189             quote = "\"";
3190 #       else
3191             quote = "'";
3192 #       endif
3193
3194 #       ifdef VMS
3195             cpp_discard_flag = "";
3196 #       else
3197             cpp_discard_flag = "-C";
3198 #       endif
3199
3200 #       ifdef OS2
3201             perl = os2_execname(aTHX);
3202 #       else
3203             perl = PL_origargv[0];
3204 #       endif
3205
3206
3207         /* This strips off Perl comments which might interfere with
3208            the C pre-processor, including #!.  #line directives are
3209            deliberately stripped to avoid confusion with Perl's version
3210            of #line.  FWP played some golf with it so it will fit
3211            into VMS's 255 character buffer.
3212         */
3213         if( PL_doextract )
3214             code = "(1../^#!.*perl/i)|/^\\s*#(?!\\s*((ifn?|un)def|(el|end)?if|define|include|else|error|pragma)\\b)/||!($|=1)||print";
3215         else
3216             code = "/^\\s*#(?!\\s*((ifn?|un)def|(el|end)?if|define|include|else|error|pragma)\\b)/||!($|=1)||print";
3217
3218         Perl_sv_setpvf(aTHX_ cmd, "\
3219 %s -ne%s%s%s %s | %"SVf" %s %"SVf" %s",
3220                        perl, quote, code, quote, scriptname, cpp,
3221                        cpp_discard_flag, sv, CPPMINUS);
3222
3223         PL_doextract = FALSE;
3224
3225         DEBUG_P(PerlIO_printf(Perl_debug_log,
3226                               "PL_preprocess: cmd=\"%s\"\n",
3227                               SvPVX(cmd)));
3228
3229         PL_rsfp = PerlProc_popen(SvPVX(cmd), (char *)"r");
3230         SvREFCNT_dec(cmd);
3231         SvREFCNT_dec(cpp);
3232     }
3233     else if (!*scriptname) {
3234         forbid_setid("program input from stdin");
3235         PL_rsfp = PerlIO_stdin();
3236     }
3237     else {
3238         PL_rsfp = PerlIO_open(scriptname,PERL_SCRIPT_MODE);
3239 #       if defined(HAS_FCNTL) && defined(F_SETFD)
3240             if (PL_rsfp)
3241                 /* ensure close-on-exec */
3242                 fcntl(PerlIO_fileno(PL_rsfp),F_SETFD,1);
3243 #       endif
3244     }
3245 #endif /* IAMSUID */
3246     if (!PL_rsfp) {
3247         /* PSz 16 Sep 03  Keep neat error message */
3248         Perl_croak(aTHX_ "Can't open perl script \"%s\": %s\n",
3249                 CopFILE(PL_curcop), Strerror(errno));
3250     }
3251 }
3252
3253 /* Mention
3254  * I_SYSSTATVFS HAS_FSTATVFS
3255  * I_SYSMOUNT
3256  * I_STATFS     HAS_FSTATFS     HAS_GETFSSTAT
3257  * I_MNTENT     HAS_GETMNTENT   HAS_HASMNTOPT
3258  * here so that metaconfig picks them up. */
3259
3260 #ifdef IAMSUID
3261 STATIC int
3262 S_fd_on_nosuid_fs(pTHX_ int fd)
3263 {
3264 /* PSz 27 Feb 04
3265  * We used to do this as "plain" user (after swapping UIDs with setreuid);
3266  * but is needed also on machines without setreuid.
3267  * Seems safe enough to run as root.
3268  */
3269     int check_okay = 0; /* able to do all the required sys/libcalls */
3270     int on_nosuid  = 0; /* the fd is on a nosuid fs */
3271     /* PSz 12 Nov 03
3272      * Need to check noexec also: nosuid might not be set, the average
3273      * sysadmin would say that nosuid is irrelevant once he sets noexec.
3274      */
3275     int on_noexec  = 0; /* the fd is on a noexec fs */
3276
3277 /*
3278  * Preferred order: fstatvfs(), fstatfs(), ustat()+getmnt(), getmntent().
3279  * fstatvfs() is UNIX98.
3280  * fstatfs() is 4.3 BSD.
3281  * ustat()+getmnt() is pre-4.3 BSD.
3282  * getmntent() is O(number-of-mounted-filesystems) and can hang on
3283  * an irrelevant filesystem while trying to reach the right one.
3284  */
3285
3286 #undef FD_ON_NOSUID_CHECK_OKAY  /* found the syscalls to do the check? */
3287
3288 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
3289         defined(HAS_FSTATVFS)
3290 #   define FD_ON_NOSUID_CHECK_OKAY
3291     struct statvfs stfs;
3292
3293     check_okay = fstatvfs(fd, &stfs) == 0;
3294     on_nosuid  = check_okay && (stfs.f_flag  & ST_NOSUID);
3295 #ifdef ST_NOEXEC
3296     /* ST_NOEXEC certainly absent on AIX 5.1, and doesn't seem to be documented
3297        on platforms where it is present.  */
3298     on_noexec  = check_okay && (stfs.f_flag  & ST_NOEXEC);
3299 #endif
3300 #   endif /* fstatvfs */
3301
3302 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
3303         defined(PERL_MOUNT_NOSUID)      && \
3304         defined(PERL_MOUNT_NOEXEC)      && \
3305         defined(HAS_FSTATFS)            && \
3306         defined(HAS_STRUCT_STATFS)      && \
3307         defined(HAS_STRUCT_STATFS_F_FLAGS)
3308 #   define FD_ON_NOSUID_CHECK_OKAY
3309     struct statfs  stfs;
3310
3311     check_okay = fstatfs(fd, &stfs)  == 0;
3312     on_nosuid  = check_okay && (stfs.f_flags & PERL_MOUNT_NOSUID);
3313     on_noexec  = check_okay && (stfs.f_flags & PERL_MOUNT_NOEXEC);
3314 #   endif /* fstatfs */
3315
3316 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
3317         defined(PERL_MOUNT_NOSUID)      && \
3318         defined(PERL_MOUNT_NOEXEC)      && \
3319         defined(HAS_FSTAT)              && \
3320         defined(HAS_USTAT)              && \
3321         defined(HAS_GETMNT)             && \
3322         defined(HAS_STRUCT_FS_DATA)     && \
3323         defined(NOSTAT_ONE)
3324 #   define FD_ON_NOSUID_CHECK_OKAY
3325     Stat_t fdst;
3326
3327     if (fstat(fd, &fdst) == 0) {
3328         struct ustat us;
3329         if (ustat(fdst.st_dev, &us) == 0) {
3330             struct fs_data fsd;
3331             /* NOSTAT_ONE here because we're not examining fields which
3332              * vary between that case and STAT_ONE. */
3333             if (getmnt((int*)0, &fsd, (int)0, NOSTAT_ONE, us.f_fname) == 0) {
3334                 size_t cmplen = sizeof(us.f_fname);
3335                 if (sizeof(fsd.fd_req.path) < cmplen)
3336                     cmplen = sizeof(fsd.fd_req.path);
3337                 if (strnEQ(fsd.fd_req.path, us.f_fname, cmplen) &&
3338                     fdst.st_dev == fsd.fd_req.dev) {
3339                         check_okay = 1;
3340                         on_nosuid = fsd.fd_req.flags & PERL_MOUNT_NOSUID;
3341                         on_noexec = fsd.fd_req.flags & PERL_MOUNT_NOEXEC;
3342                     }
3343                 }
3344             }
3345         }
3346     }
3347 #   endif /* fstat+ustat+getmnt */
3348
3349 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
3350         defined(HAS_GETMNTENT)          && \
3351         defined(HAS_HASMNTOPT)          && \
3352         defined(MNTOPT_NOSUID)          && \
3353         defined(MNTOPT_NOEXEC)
3354 #   define FD_ON_NOSUID_CHECK_OKAY
3355     FILE                *mtab = fopen("/etc/mtab", "r");
3356     struct mntent       *entry;
3357     Stat_t              stb, fsb;
3358
3359     if (mtab && (fstat(fd, &stb) == 0)) {
3360         while (entry = getmntent(mtab)) {
3361             if (stat(entry->mnt_dir, &fsb) == 0
3362                 && fsb.st_dev == stb.st_dev)
3363             {
3364                 /* found the filesystem */
3365                 check_okay = 1;
3366                 if (hasmntopt(entry, MNTOPT_NOSUID))
3367                     on_nosuid = 1;
3368                 if (hasmntopt(entry, MNTOPT_NOEXEC))
3369                     on_noexec = 1;
3370                 break;
3371             } /* A single fs may well fail its stat(). */
3372         }
3373     }
3374     if (mtab)
3375         fclose(mtab);
3376 #   endif /* getmntent+hasmntopt */
3377
3378     if (!check_okay)
3379         Perl_croak(aTHX_ "Can't check filesystem of script \"%s\" for nosuid/noexec", PL_origfilename);
3380     if (on_nosuid)
3381         Perl_croak(aTHX_ "Setuid script \"%s\" on nosuid filesystem", PL_origfilename);
3382     if (on_noexec)
3383         Perl_croak(aTHX_ "Setuid script \"%s\" on noexec filesystem", PL_origfilename);
3384     return ((!check_okay) || on_nosuid || on_noexec);
3385 }
3386 #endif /* IAMSUID */
3387
3388 STATIC void
3389 S_validate_suid(pTHX_ const char *validarg, const char *scriptname)
3390 {
3391     dVAR;
3392 #ifdef IAMSUID
3393     /* int which; */
3394 #endif /* IAMSUID */
3395
3396     /* do we need to emulate setuid on scripts? */
3397
3398     /* This code is for those BSD systems that have setuid #! scripts disabled
3399      * in the kernel because of a security problem.  Merely defining DOSUID
3400      * in perl will not fix that problem, but if you have disabled setuid
3401      * scripts in the kernel, this will attempt to emulate setuid and setgid
3402      * on scripts that have those now-otherwise-useless bits set.  The setuid
3403      * root version must be called suidperl or sperlN.NNN.  If regular perl
3404      * discovers that it has opened a setuid script, it calls suidperl with
3405      * the same argv that it had.  If suidperl finds that the script it has
3406      * just opened is NOT setuid root, it sets the effective uid back to the
3407      * uid.  We don't just make perl setuid root because that loses the
3408      * effective uid we had before invoking perl, if it was different from the
3409      * uid.
3410      * PSz 27 Feb 04
3411      * Description/comments above do not match current workings:
3412      *   suidperl must be hardlinked to sperlN.NNN (that is what we exec);
3413      *   suidperl called with script open and name changed to /dev/fd/N/X;
3414      *   suidperl croaks if script is not setuid;
3415      *   making perl setuid would be a huge security risk (and yes, that
3416      *     would lose any euid we might have had).
3417      *
3418      * DOSUID must be defined in both perl and suidperl, and IAMSUID must
3419      * be defined in suidperl only.  suidperl must be setuid root.  The
3420      * Configure script will set this up for you if you want it.
3421      */
3422
3423 #ifdef DOSUID
3424     char *s, *s2;
3425
3426     if (PerlLIO_fstat(PerlIO_fileno(PL_rsfp),&PL_statbuf) < 0)  /* normal stat is insecure */
3427         Perl_croak(aTHX_ "Can't stat script \"%s\"",PL_origfilename);
3428     if (PL_statbuf.st_mode & (S_ISUID|S_ISGID)) {
3429         I32 len;
3430         STRLEN n_a;
3431
3432 #ifdef IAMSUID
3433         if (PL_fdscript < 0 || PL_suidscript != 1)
3434             Perl_croak(aTHX_ "Need (suid) fdscript in suidperl\n");     /* We already checked this */
3435         /* PSz 11 Nov 03
3436          * Since the script is opened by perl, not suidperl, some of these
3437          * checks are superfluous. Leaving them in probably does not lower
3438          * security(?!).
3439          */
3440         /* PSz 27 Feb 04
3441          * Do checks even for systems with no HAS_SETREUID.
3442          * We used to swap, then re-swap UIDs with
3443 #ifdef HAS_SETREUID
3444             if (setreuid(PL_euid,PL_uid) < 0
3445                 || PerlProc_getuid() != PL_euid || PerlProc_geteuid() != PL_uid)
3446                 Perl_croak(aTHX_ "Can't swap uid and euid");
3447 #endif
3448 #ifdef HAS_SETREUID
3449             if (setreuid(PL_uid,PL_euid) < 0
3450                 || PerlProc_getuid() != PL_uid || PerlProc_geteuid() != PL_euid)
3451                 Perl_croak(aTHX_ "Can't reswap uid and euid");
3452 #endif
3453          */
3454
3455         /* On this access check to make sure the directories are readable,
3456          * there is actually a small window that the user could use to make
3457          * filename point to an accessible directory.  So there is a faint
3458          * chance that someone could execute a setuid script down in a
3459          * non-accessible directory.  I don't know what to do about that.
3460          * But I don't think it's too important.  The manual lies when
3461          * it says access() is useful in setuid programs.
3462          *
3463          * So, access() is pretty useless... but not harmful... do anyway.
3464          */
3465         if (PerlLIO_access(CopFILE(PL_curcop),1)) { /*double check*/
3466             Perl_croak(aTHX_ "Can't access() script\n");
3467         }
3468
3469         /* If we can swap euid and uid, then we can determine access rights
3470          * with a simple stat of the file, and then compare device and
3471          * inode to make sure we did stat() on the same file we opened.
3472          * Then we just have to make sure he or she can execute it.
3473          *
3474          * PSz 24 Feb 04
3475          * As the script is opened by perl, not suidperl, we do not need to
3476          * care much about access rights.
3477          *
3478          * The 'script changed' check is needed, or we can get lied to
3479          * about $0 with e.g.
3480          *  suidperl /dev/fd/4//bin/x 4<setuidscript
3481          * Without HAS_SETREUID, is it safe to stat() as root?
3482          *
3483          * Are there any operating systems that pass /dev/fd/xxx for setuid
3484          * scripts, as suggested/described in perlsec(1)? Surely they do not
3485          * pass the script name as we do, so the "script changed" test would
3486          * fail for them... but we never get here with
3487          * SETUID_SCRIPTS_ARE_SECURE_NOW defined.
3488          *
3489          * This is one place where we must "lie" about return status: not
3490          * say if the stat() failed. We are doing this as root, and could
3491          * be tricked into reporting existence or not of files that the
3492          * "plain" user cannot even see.
3493          */
3494         {
3495             Stat_t tmpstatbuf;
3496             if (PerlLIO_stat(CopFILE(PL_curcop),&tmpstatbuf) < 0 ||
3497                 tmpstatbuf.st_dev != PL_statbuf.st_dev ||
3498                 tmpstatbuf.st_ino != PL_statbuf.st_ino) {
3499                 Perl_croak(aTHX_ "Setuid script changed\n");
3500             }
3501
3502         }
3503         if (!cando(S_IXUSR,FALSE,&PL_statbuf))          /* can real uid exec? */
3504             Perl_croak(aTHX_ "Real UID cannot exec script\n");
3505
3506         /* PSz 27 Feb 04
3507          * We used to do this check as the "plain" user (after swapping
3508          * UIDs). But the check for nosuid and noexec filesystem is needed,
3509          * and should be done even without HAS_SETREUID. (Maybe those
3510          * operating systems do not have such mount options anyway...)
3511          * Seems safe enough to do as root.
3512          */
3513 #if !defined(NO_NOSUID_CHECK)
3514         if (fd_on_nosuid_fs(PerlIO_fileno(PL_rsfp))) {
3515             Perl_croak(aTHX_ "Setuid script on nosuid or noexec filesystem\n");
3516         }
3517 #endif
3518 #endif /* IAMSUID */
3519
3520         if (!S_ISREG(PL_statbuf.st_mode)) {
3521             Perl_croak(aTHX_ "Setuid script not plain file\n");
3522         }
3523         if (PL_statbuf.st_mode & S_IWOTH)
3524             Perl_croak(aTHX_ "Setuid/gid script is writable by world");
3525         PL_doswitches = FALSE;          /* -s is insecure in suid */
3526         /* PSz 13 Nov 03  But -s was caught elsewhere ... so unsetting it here is useless(?!) */
3527         CopLINE_inc(PL_curcop);
3528         if (sv_gets(PL_linestr, PL_rsfp, 0) == Nullch ||
3529           strnNE(SvPV(PL_linestr,n_a),"#!",2) ) /* required even on Sys V */
3530             Perl_croak(aTHX_ "No #! line");
3531         s = SvPV(PL_linestr,n_a)+2;
3532         /* PSz 27 Feb 04 */
3533         /* Sanity check on line length */
3534         if (strlen(s) < 1 || strlen(s) > 4000)
3535             Perl_croak(aTHX_ "Very long #! line");
3536         /* Allow more than a single space after #! */
3537         while (isSPACE(*s)) s++;
3538         /* Sanity check on buffer end */
3539         while ((*s) && !isSPACE(*s)) s++;
3540         for (s2 = s;  (s2 > SvPV(PL_linestr,n_a)+2 &&
3541                        (isDIGIT(s2[-1]) || s2[-1] == '.' || s2[-1] == '_'
3542                         || s2[-1] == '-'));  s2--) ;
3543         /* Sanity check on buffer start */
3544         if ( (s2-4 < SvPV(PL_linestr,n_a)+2 || strnNE(s2-4,"perl",4)) &&
3545               (s-9 < SvPV(PL_linestr,n_a)+2 || strnNE(s-9,"perl",4)) )
3546             Perl_croak(aTHX_ "Not a perl script");
3547         while (*s == ' ' || *s == '\t') s++;
3548         /*
3549          * #! arg must be what we saw above.  They can invoke it by
3550          * mentioning suidperl explicitly, but they may not add any strange
3551          * arguments beyond what #! says if they do invoke suidperl that way.
3552          */
3553         /*
3554          * The way validarg was set up, we rely on the kernel to start
3555          * scripts with argv[1] set to contain all #! line switches (the
3556          * whole line).
3557          */
3558         /*
3559          * Check that we got all the arguments listed in the #! line (not
3560          * just that there are no extraneous arguments). Might not matter
3561          * much, as switches from #! line seem to be acted upon (also), and
3562          * so may be checked and trapped in perl. But, security checks must
3563          * be done in suidperl and not deferred to perl. Note that suidperl
3564          * does not get around to parsing (and checking) the switches on
3565          * the #! line (but execs perl sooner).
3566          * Allow (require) a trailing newline (which may be of two
3567          * characters on some architectures?) (but no other trailing
3568          * whitespace).
3569          */
3570         len = strlen(validarg);
3571         if (strEQ(validarg," PHOOEY ") ||
3572             strnNE(s,validarg,len) || !isSPACE(s[len]) ||
3573             !(strlen(s) == len+1 || (strlen(s) == len+2 && isSPACE(s[len+1]))))
3574             Perl_croak(aTHX_ "Args must match #! line");
3575
3576 #ifndef IAMSUID
3577         if (PL_fdscript < 0 &&
3578             PL_euid != PL_uid && (PL_statbuf.st_mode & S_ISUID) &&
3579             PL_euid == PL_statbuf.st_uid)
3580             if (!PL_do_undump)
3581                 Perl_croak(aTHX_ "YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!\n\
3582 FIX YOUR KERNEL, OR PUT A C WRAPPER AROUND THIS SCRIPT!\n");
3583 #endif /* IAMSUID */
3584
3585         if (PL_fdscript < 0 &&
3586             PL_euid) {  /* oops, we're not the setuid root perl */
3587             /* PSz 18 Feb 04
3588              * When root runs a setuid script, we do not go through the same
3589              * steps of execing sperl and then perl with fd scripts, but
3590              * simply set up UIDs within the same perl invocation; so do
3591              * not have the same checks (on options, whatever) that we have
3592              * for plain users. No problem really: would have to be a script
3593              * that does not actually work for plain users; and if root is
3594              * foolish and can be persuaded to run such an unsafe script, he
3595              * might run also non-setuid ones, and deserves what he gets.
3596              *
3597              * Or, we might drop the PL_euid check above (and rely just on
3598              * PL_fdscript to avoid loops), and do the execs
3599              * even for root.
3600              */
3601 #ifndef IAMSUID
3602             int which;
3603             /* PSz 11 Nov 03
3604              * Pass fd script to suidperl.
3605              * Exec suidperl, substituting fd script for scriptname.
3606              * Pass script name as "subdir" of fd, which perl will grok;
3607              * in fact will use that to distinguish this from "normal"
3608              * usage, see comments above.
3609              */
3610             PerlIO_rewind(PL_rsfp);
3611             PerlLIO_lseek(PerlIO_fileno(PL_rsfp),(Off_t)0,0);  /* just in case rewind didn't */
3612             /* PSz 27 Feb 04  Sanity checks on scriptname */
3613             if ((!scriptname) || (!*scriptname) ) {
3614                 Perl_croak(aTHX_ "No setuid script name\n");
3615             }
3616             if (*scriptname == '-') {
3617                 Perl_croak(aTHX_ "Setuid script name may not begin with dash\n");
3618                 /* Or we might confuse it with an option when replacing
3619                  * name in argument list, below (though we do pointer, not
3620                  * string, comparisons).
3621                  */
3622             }
3623             for (which = 1; PL_origargv[which] && PL_origargv[which] != scriptname; which++) ;
3624             if (!PL_origargv[which]) {
3625                 Perl_croak(aTHX_ "Can't change argv to have fd script\n");
3626             }
3627             PL_origargv[which] = savepv(Perl_form(aTHX_ "/dev/fd/%d/%s",
3628                                           PerlIO_fileno(PL_rsfp), PL_origargv[which]));
3629 #if defined(HAS_FCNTL) && defined(F_SETFD)
3630             fcntl(PerlIO_fileno(PL_rsfp),F_SETFD,0);    /* ensure no close-on-exec */
3631 #endif
3632             PERL_FPU_PRE_EXEC
3633             PerlProc_execv(Perl_form(aTHX_ "%s/sperl"PERL_FS_VER_FMT, BIN_EXP,
3634                                      (int)PERL_REVISION, (int)PERL_VERSION,
3635                                      (int)PERL_SUBVERSION), PL_origargv);
3636             PERL_FPU_POST_EXEC
3637 #endif /* IAMSUID */
3638             Perl_croak(aTHX_ "Can't do setuid (cannot exec sperl)\n");
3639         }
3640
3641         if (PL_statbuf.st_mode & S_ISGID && PL_statbuf.st_gid != PL_egid) {
3642 /* PSz 26 Feb 04
3643  * This seems back to front: we try HAS_SETEGID first; if not available
3644  * then try HAS_SETREGID; as a last chance we try HAS_SETRESGID. May be OK
3645  * in the sense that we only want to set EGID; but are there any machines
3646  * with either of the latter, but not the former? Same with UID, later.
3647  */
3648 #ifdef HAS_SETEGID
3649             (void)setegid(PL_statbuf.st_gid);
3650 #else
3651 #ifdef HAS_SETREGID
3652            (void)setregid((Gid_t)-1,PL_statbuf.st_gid);
3653 #else
3654 #ifdef HAS_SETRESGID
3655            (void)setresgid((Gid_t)-1,PL_statbuf.st_gid,(Gid_t)-1);
3656 #else
3657             PerlProc_setgid(PL_statbuf.st_gid);
3658 #endif
3659 #endif
3660 #endif
3661             if (PerlProc_getegid() != PL_statbuf.st_gid)
3662                 Perl_croak(aTHX_ "Can't do setegid!\n");
3663         }
3664         if (PL_statbuf.st_mode & S_ISUID) {
3665             if (PL_statbuf.st_uid != PL_euid)
3666 #ifdef HAS_SETEUID
3667                 (void)seteuid(PL_statbuf.st_uid);       /* all that for this */
3668 #else
3669 #ifdef HAS_SETREUID
3670                 (void)setreuid((Uid_t)-1,PL_statbuf.st_uid);
3671 #else
3672 #ifdef HAS_SETRESUID
3673                 (void)setresuid((Uid_t)-1,PL_statbuf.st_uid,(Uid_t)-1);
3674 #else
3675                 PerlProc_setuid(PL_statbuf.st_uid);
3676 #endif
3677 #endif
3678 #endif
3679             if (PerlProc_geteuid() != PL_statbuf.st_uid)
3680                 Perl_croak(aTHX_ "Can't do seteuid!\n");
3681         }
3682         else if (PL_uid) {                      /* oops, mustn't run as root */
3683 #ifdef HAS_SETEUID
3684           (void)seteuid((Uid_t)PL_uid);
3685 #else
3686 #ifdef HAS_SETREUID
3687           (void)setreuid((Uid_t)-1,(Uid_t)PL_uid);
3688 #else
3689 #ifdef HAS_SETRESUID
3690           (void)setresuid((Uid_t)-1,(Uid_t)PL_uid,(Uid_t)-1);
3691 #else
3692           PerlProc_setuid((Uid_t)PL_uid);
3693 #endif
3694 #endif
3695 #endif
3696             if (PerlProc_geteuid() != PL_uid)
3697                 Perl_croak(aTHX_ "Can't do seteuid!\n");
3698         }
3699         init_ids();
3700         if (!cando(S_IXUSR,TRUE,&PL_statbuf))
3701             Perl_croak(aTHX_ "Effective UID cannot exec script\n");     /* they can't do this */
3702     }
3703 #ifdef IAMSUID
3704     else if (PL_preprocess)     /* PSz 13 Nov 03  Caught elsewhere, useless(?!) here */
3705         Perl_croak(aTHX_ "-P not allowed for setuid/setgid script\n");
3706     else if (PL_fdscript < 0 || PL_suidscript != 1)
3707         /* PSz 13 Nov 03  Caught elsewhere, useless(?!) here */
3708         Perl_croak(aTHX_ "(suid) fdscript needed in suidperl\n");
3709     else {
3710 /* PSz 16 Sep 03  Keep neat error message */
3711         Perl_croak(aTHX_ "Script is not setuid/setgid in suidperl\n");
3712     }
3713
3714     /* We absolutely must clear out any saved ids here, so we */
3715     /* exec the real perl, substituting fd script for scriptname. */
3716     /* (We pass script name as "subdir" of fd, which perl will grok.) */
3717     /*
3718      * It might be thought that using setresgid and/or setresuid (changed to
3719      * set the saved IDs) above might obviate the need to exec, and we could
3720      * go on to "do the perl thing".
3721      *
3722      * Is there such a thing as "saved GID", and is that set for setuid (but
3723      * not setgid) execution like suidperl? Without exec, it would not be
3724      * cleared for setuid (but not setgid) scripts (or might need a dummy
3725      * setresgid).
3726      *
3727      * We need suidperl to do the exact same argument checking that perl
3728      * does. Thus it cannot be very small; while it could be significantly
3729      * smaller, it is safer (simpler?) to make it essentially the same
3730      * binary as perl (but they are not identical). - Maybe could defer that
3731      * check to the invoked perl, and suidperl be a tiny wrapper instead;
3732      * but prefer to do thorough checks in suidperl itself. Such deferral
3733      * would make suidperl security rely on perl, a design no-no.
3734      *
3735      * Setuid things should be short and simple, thus easy to understand and
3736      * verify. They should do their "own thing", without influence by
3737      * attackers. It may help if their internal execution flow is fixed,
3738      * regardless of platform: it may be best to exec anyway.
3739      *
3740      * Suidperl should at least be conceptually simple: a wrapper only,
3741      * never to do any real perl. Maybe we should put
3742      * #ifdef IAMSUID
3743      *         Perl_croak(aTHX_ "Suidperl should never do real perl\n");
3744      * #endif
3745      * into the perly bits.
3746      */
3747     PerlIO_rewind(PL_rsfp);
3748     PerlLIO_lseek(PerlIO_fileno(PL_rsfp),(Off_t)0,0);  /* just in case rewind didn't */
3749     /* PSz 11 Nov 03
3750      * Keep original arguments: suidperl already has fd script.
3751      */
3752 /*  for (which = 1; PL_origargv[which] && PL_origargv[which] != scriptname; which++) ;  */
3753 /*  if (!PL_origargv[which]) {                                          */
3754 /*      errno = EPERM;                                                  */
3755 /*      Perl_croak(aTHX_ "Permission denied\n");                        */
3756 /*  }                                                                   */
3757 /*  PL_origargv[which] = savepv(Perl_form(aTHX_ "/dev/fd/%d/%s",        */
3758 /*                                PerlIO_fileno(PL_rsfp), PL_origargv[which])); */
3759 #if defined(HAS_FCNTL) && defined(F_SETFD)
3760     fcntl(PerlIO_fileno(PL_rsfp),F_SETFD,0);    /* ensure no close-on-exec */
3761 #endif
3762     PERL_FPU_PRE_EXEC
3763     PerlProc_execv(Perl_form(aTHX_ "%s/perl"PERL_FS_VER_FMT, BIN_EXP,
3764                              (int)PERL_REVISION, (int)PERL_VERSION,
3765                              (int)PERL_SUBVERSION), PL_origargv);/* try again */
3766     PERL_FPU_POST_EXEC
3767     Perl_croak(aTHX_ "Can't do setuid (suidperl cannot exec perl)\n");
3768 #endif /* IAMSUID */
3769 #else /* !DOSUID */
3770     if (PL_euid != PL_uid || PL_egid != PL_gid) {       /* (suidperl doesn't exist, in fact) */
3771 #ifndef SETUID_SCRIPTS_ARE_SECURE_NOW
3772         PerlLIO_fstat(PerlIO_fileno(PL_rsfp),&PL_statbuf);      /* may be either wrapped or real suid */
3773         if ((PL_euid != PL_uid && PL_euid == PL_statbuf.st_uid && PL_statbuf.st_mode & S_ISUID)
3774             ||
3775             (PL_egid != PL_gid && PL_egid == PL_statbuf.st_gid && PL_statbuf.st_mode & S_ISGID)
3776            )
3777             if (!PL_do_undump)
3778                 Perl_croak(aTHX_ "YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!\n\
3779 FIX YOUR KERNEL, PUT A C WRAPPER AROUND THIS SCRIPT, OR USE -u AND UNDUMP!\n");
3780 #endif /* SETUID_SCRIPTS_ARE_SECURE_NOW */
3781         /* not set-id, must be wrapped */
3782     }
3783 #endif /* DOSUID */
3784     (void)validarg;
3785     (void)scriptname;
3786 }
3787
3788 STATIC void
3789 S_find_beginning(pTHX)
3790 {
3791     register char *s;
3792     register const char *s2;
3793 #ifdef MACOS_TRADITIONAL
3794     int maclines = 0;
3795 #endif
3796
3797     /* skip forward in input to the real script? */
3798
3799     forbid_setid("-x");
3800 #ifdef MACOS_TRADITIONAL
3801     /* Since the Mac OS does not honor #! arguments for us, we do it ourselves */
3802
3803     while (PL_doextract || gMacPerl_AlwaysExtract) {
3804         if ((s = sv_gets(PL_linestr, PL_rsfp, 0)) == Nullch) {
3805             if (!gMacPerl_AlwaysExtract)
3806                 Perl_croak(aTHX_ "No Perl script found in input\n");
3807
3808             if (PL_doextract)                   /* require explicit override ? */
3809                 if (!OverrideExtract(PL_origfilename))
3810                     Perl_croak(aTHX_ "User aborted script\n");
3811                 else
3812                     PL_doextract = FALSE;
3813
3814             /* Pater peccavi, file does not have #! */
3815             PerlIO_rewind(PL_rsfp);
3816
3817             break;
3818         }
3819 #else
3820     while (PL_doextract) {
3821         if ((s = sv_gets(PL_linestr, PL_rsfp, 0)) == Nullch)
3822             Perl_croak(aTHX_ "No Perl script found in input\n");
3823 #endif
3824         s2 = s;
3825         if (*s == '#' && s[1] == '!' && ((s = instr(s,"perl")) || (s = instr(s2,"PERL")))) {
3826             PerlIO_ungetc(PL_rsfp, '\n');               /* to keep line count right */
3827             PL_doextract = FALSE;
3828             while (*s && !(isSPACE (*s) || *s == '#')) s++;
3829             s2 = s;
3830             while (*s == ' ' || *s == '\t') s++;
3831             if (*s++ == '-') {
3832                 while (isDIGIT(s2[-1]) || s2[-1] == '-' || s2[-1] == '.'
3833                        || s2[-1] == '_') s2--;
3834                 if (strnEQ(s2-4,"perl",4))
3835                     /*SUPPRESS 530*/
3836                     while ((s = moreswitches(s)))
3837                         ;
3838             }
3839 #ifdef MACOS_TRADITIONAL
3840             /* We are always searching for the #!perl line in MacPerl,
3841              * so if we find it, still keep the line count correct
3842              * by counting lines we already skipped over
3843              */
3844             for (; maclines > 0 ; maclines--)
3845                 PerlIO_ungetc(PL_rsfp, '\n');
3846
3847             break;
3848
3849         /* gMacPerl_AlwaysExtract is false in MPW tool */
3850         } else if (gMacPerl_AlwaysExtract) {
3851             ++maclines;
3852 #endif
3853         }
3854     }
3855 }
3856
3857
3858 STATIC void
3859 S_init_ids(pTHX)
3860 {
3861     PL_uid = PerlProc_getuid();
3862     PL_euid = PerlProc_geteuid();
3863     PL_gid = PerlProc_getgid();
3864     PL_egid = PerlProc_getegid();
3865 #ifdef VMS
3866     PL_uid |= PL_gid << 16;
3867     PL_euid |= PL_egid << 16;
3868 #endif
3869     /* Should not happen: */
3870     CHECK_MALLOC_TAINT(PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
3871     PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
3872     /* BUG */
3873     /* PSz 27 Feb 04
3874      * Should go by suidscript, not uid!=euid: why disallow
3875      * system("ls") in scripts run from setuid things?
3876      * Or, is this run before we check arguments and set suidscript?
3877      * What about SETUID_SCRIPTS_ARE_SECURE_NOW: could we use fdscript then?
3878      * (We never have suidscript, can we be sure to have fdscript?)
3879      * Or must then go by UID checks? See comments in forbid_setid also.
3880      */
3881 }
3882
3883 /* This is used very early in the lifetime of the program,
3884  * before even the options are parsed, so PL_tainting has
3885  * not been initialized properly.  */
3886 bool
3887 Perl_doing_taint(int argc, char *argv[], char *envp[])
3888 {
3889 #ifndef PERL_IMPLICIT_SYS
3890     /* If we have PERL_IMPLICIT_SYS we can't call getuid() et alia
3891      * before we have an interpreter-- and the whole point of this
3892      * function is to be called at such an early stage.  If you are on
3893      * a system with PERL_IMPLICIT_SYS but you do have a concept of
3894      * "tainted because running with altered effective ids', you'll
3895      * have to add your own checks somewhere in here.  The two most
3896      * known samples of 'implicitness' are Win32 and NetWare, neither
3897      * of which has much of concept of 'uids'. */
3898     int uid  = PerlProc_getuid();
3899     int euid = PerlProc_geteuid();
3900     int gid  = PerlProc_getgid();
3901     int egid = PerlProc_getegid();
3902     (void)envp;
3903
3904 #ifdef VMS
3905     uid  |=  gid << 16;
3906     euid |= egid << 16;
3907 #endif
3908     if (uid && (euid != uid || egid != gid))
3909         return 1;
3910 #endif /* !PERL_IMPLICIT_SYS */
3911     /* This is a really primitive check; environment gets ignored only
3912      * if -T are the first chars together; otherwise one gets
3913      *  "Too late" message. */
3914     if ( argc > 1 && argv[1][0] == '-'
3915          && (argv[1][1] == 't' || argv[1][1] == 'T') )
3916         return 1;
3917     return 0;
3918 }
3919
3920 STATIC void
3921 S_forbid_setid(pTHX_ const char *s)
3922 {
3923 #ifdef SETUID_SCRIPTS_ARE_SECURE_NOW
3924     if (PL_euid != PL_uid)
3925         Perl_croak(aTHX_ "No %s allowed while running setuid", s);
3926     if (PL_egid != PL_gid)
3927         Perl_croak(aTHX_ "No %s allowed while running setgid", s);
3928 #endif /* SETUID_SCRIPTS_ARE_SECURE_NOW */
3929     /* PSz 29 Feb 04
3930      * Checks for UID/GID above "wrong": why disallow
3931      *   perl -e 'print "Hello\n"'
3932      * from within setuid things?? Simply drop them: replaced by
3933      * fdscript/suidscript and #ifdef IAMSUID checks below.
3934      *
3935      * This may be too late for command-line switches. Will catch those on
3936      * the #! line, after finding the script name and setting up
3937      * fdscript/suidscript. Note that suidperl does not get around to
3938      * parsing (and checking) the switches on the #! line, but checks that
3939      * the two sets are identical.
3940      *
3941      * With SETUID_SCRIPTS_ARE_SECURE_NOW, could we use fdscript, also or
3942      * instead, or would that be "too late"? (We never have suidscript, can
3943      * we be sure to have fdscript?)
3944      *
3945      * Catch things with suidscript (in descendant of suidperl), even with
3946      * right UID/GID. Was already checked in suidperl, with #ifdef IAMSUID,
3947      * below; but I am paranoid.
3948      *
3949      * Also see comments about root running a setuid script, elsewhere.
3950      */
3951     if (PL_suidscript >= 0)
3952         Perl_croak(aTHX_ "No %s allowed with (suid) fdscript", s);
3953 #ifdef IAMSUID
3954     /* PSz 11 Nov 03  Catch it in suidperl, always! */
3955     Perl_croak(aTHX_ "No %s allowed in suidperl", s);
3956 #endif /* IAMSUID */
3957 }
3958
3959 void
3960 Perl_init_debugger(pTHX)
3961 {
3962     HV *ostash = PL_curstash;
3963
3964     PL_curstash = PL_debstash;
3965     PL_dbargs = GvAV(gv_AVadd((gv_fetchpv("DB::args", GV_ADDMULTI, SVt_PVAV))));
3966     AvREAL_off(PL_dbargs);
3967     PL_DBgv = gv_fetchpv("DB::DB", GV_ADDMULTI, SVt_PVGV);
3968     PL_DBline = gv_fetchpv("DB::dbline", GV_ADDMULTI, SVt_PVAV);
3969     PL_DBsub = gv_HVadd(gv_fetchpv("DB::sub", GV_ADDMULTI, SVt_PVHV));
3970     PL_DBsingle = GvSV((gv_fetchpv("DB::single", GV_ADDMULTI, SVt_PV)));
3971     sv_setiv(PL_DBsingle, 0);
3972     PL_DBtrace = GvSV((gv_fetchpv("DB::trace", GV_ADDMULTI, SVt_PV)));
3973     sv_setiv(PL_DBtrace, 0);
3974     PL_DBsignal = GvSV((gv_fetchpv("DB::signal", GV_ADDMULTI, SVt_PV)));
3975     sv_setiv(PL_DBsignal, 0);
3976     PL_DBassertion = GvSV((gv_fetchpv("DB::assertion", GV_ADDMULTI, SVt_PV)));
3977     sv_setiv(PL_DBassertion, 0);
3978     PL_curstash = ostash;
3979 }
3980
3981 #ifndef STRESS_REALLOC
3982 #define REASONABLE(size) (size)
3983 #else
3984 #define REASONABLE(size) (1) /* unreasonable */
3985 #endif
3986
3987 void
3988 Perl_init_stacks(pTHX)
3989 {
3990     /* start with 128-item stack and 8K cxstack */
3991     PL_curstackinfo = new_stackinfo(REASONABLE(128),
3992                                  REASONABLE(8192/sizeof(PERL_CONTEXT) - 1));
3993     PL_curstackinfo->si_type = PERLSI_MAIN;
3994     PL_curstack = PL_curstackinfo->si_stack;
3995     PL_mainstack = PL_curstack;         /* remember in case we switch stacks */
3996
3997     PL_stack_base = AvARRAY(PL_curstack);
3998     PL_stack_sp = PL_stack_base;
3999     PL_stack_max = PL_stack_base + AvMAX(PL_curstack);
4000
4001     New(50,PL_tmps_stack,REASONABLE(128),SV*);
4002     PL_tmps_floor = -1;
4003     PL_tmps_ix = -1;
4004     PL_tmps_max = REASONABLE(128);
4005
4006     New(54,PL_markstack,REASONABLE(32),I32);
4007     PL_markstack_ptr = PL_markstack;
4008     PL_markstack_max = PL_markstack + REASONABLE(32);
4009
4010     SET_MARK_OFFSET;
4011
4012     New(54,PL_scopestack,REASONABLE(32),I32);
4013     PL_scopestack_ix = 0;
4014     PL_scopestack_max = REASONABLE(32);
4015
4016     New(54,PL_savestack,REASONABLE(128),ANY);
4017     PL_savestack_ix = 0;
4018     PL_savestack_max = REASONABLE(128);
4019 }
4020
4021 #undef REASONABLE
4022
4023 STATIC void
4024 S_nuke_stacks(pTHX)
4025 {
4026     while (PL_curstackinfo->si_next)
4027         PL_curstackinfo = PL_curstackinfo->si_next;
4028     while (PL_curstackinfo) {
4029         PERL_SI *p = PL_curstackinfo->si_prev;
4030         /* curstackinfo->si_stack got nuked by sv_free_arenas() */
4031         Safefree(PL_curstackinfo->si_cxstack);
4032         Safefree(PL_curstackinfo);
4033         PL_curstackinfo = p;
4034     }
4035     Safefree(PL_tmps_stack);
4036     Safefree(PL_markstack);
4037     Safefree(PL_scopestack);
4038     Safefree(PL_savestack);
4039 }
4040
4041 STATIC void
4042 S_init_lexer(pTHX)
4043 {
4044     PerlIO *tmpfp;
4045     tmpfp = PL_rsfp;
4046     PL_rsfp = Nullfp;
4047     lex_start(PL_linestr);
4048     PL_rsfp = tmpfp;
4049     PL_subname = newSVpvn("main",4);
4050 }
4051
4052 STATIC void
4053 S_init_predump_symbols(pTHX)
4054 {
4055     GV *tmpgv;
4056     IO *io;
4057
4058     sv_setpvn(get_sv("\"", TRUE), " ", 1);
4059     PL_stdingv = gv_fetchpv("STDIN",TRUE, SVt_PVIO);
4060     GvMULTI_on(PL_stdingv);
4061     io = GvIOp(PL_stdingv);
4062     IoTYPE(io) = IoTYPE_RDONLY;
4063     IoIFP(io) = PerlIO_stdin();
4064     tmpgv = gv_fetchpv("stdin",TRUE, SVt_PV);
4065     GvMULTI_on(tmpgv);
4066     GvIOp(tmpgv) = (IO*)SvREFCNT_inc(io);
4067
4068     tmpgv = gv_fetchpv("STDOUT",TRUE, SVt_PVIO);
4069     GvMULTI_on(tmpgv);
4070     io = GvIOp(tmpgv);
4071     IoTYPE(io) = IoTYPE_WRONLY;
4072     IoOFP(io) = IoIFP(io) = PerlIO_stdout();
4073     setdefout(tmpgv);
4074     tmpgv = gv_fetchpv("stdout",TRUE, SVt_PV);
4075     GvMULTI_on(tmpgv);
4076     GvIOp(tmpgv) = (IO*)SvREFCNT_inc(io);
4077
4078     PL_stderrgv = gv_fetchpv("STDERR",TRUE, SVt_PVIO);
4079     GvMULTI_on(PL_stderrgv);
4080     io = GvIOp(PL_stderrgv);
4081     IoTYPE(io) = IoTYPE_WRONLY;
4082     IoOFP(io) = IoIFP(io) = PerlIO_stderr();
4083     tmpgv = gv_fetchpv("stderr",TRUE, SVt_PV);
4084     GvMULTI_on(tmpgv);
4085     GvIOp(tmpgv) = (IO*)SvREFCNT_inc(io);
4086
4087     PL_statname = NEWSV(66,0);          /* last filename we did stat on */
4088
4089     if (PL_osname)
4090         Safefree(PL_osname);
4091     PL_osname = savepv(OSNAME);
4092 }
4093
4094 void
4095 Perl_init_argv_symbols(pTHX_ register int argc, register char **argv)
4096 {
4097     char *s;
4098     argc--,argv++;      /* skip name of script */
4099     if (PL_doswitches) {
4100         for (; argc > 0 && **argv == '-'; argc--,argv++) {
4101             if (!argv[0][1])
4102                 break;
4103             if (argv[0][1] == '-' && !argv[0][2]) {
4104                 argc--,argv++;
4105                 break;
4106             }
4107             if ((s = strchr(argv[0], '='))) {
4108                 *s++ = '\0';
4109                 sv_setpv(GvSV(gv_fetchpv(argv[0]+1,TRUE, SVt_PV)),s);
4110             }
4111             else
4112                 sv_setiv(GvSV(gv_fetchpv(argv[0]+1,TRUE, SVt_PV)),1);
4113         }
4114     }
4115     if ((PL_argvgv = gv_fetchpv("ARGV",TRUE, SVt_PVAV))) {
4116         GvMULTI_on(PL_argvgv);
4117         (void)gv_AVadd(PL_argvgv);
4118         av_clear(GvAVn(PL_argvgv));
4119         for (; argc > 0; argc--,argv++) {
4120             SV *sv = newSVpv(argv[0],0);
4121             av_push(GvAVn(PL_argvgv),sv);
4122             if (!(PL_unicode & PERL_UNICODE_LOCALE_FLAG) || PL_utf8locale) {
4123                  if (PL_unicode & PERL_UNICODE_ARGV_FLAG)
4124                       SvUTF8_on(sv);
4125             }
4126             if (PL_unicode & PERL_UNICODE_WIDESYSCALLS_FLAG) /* Sarathy? */
4127                  (void)sv_utf8_decode(sv);
4128         }
4129     }
4130 }
4131
4132 STATIC void
4133 S_init_postdump_symbols(pTHX_ register int argc, register char **argv, register char **env)
4134 {
4135     dVAR;
4136     GV* tmpgv;
4137
4138     PL_toptarget = NEWSV(0,0);
4139     sv_upgrade(PL_toptarget, SVt_PVFM);
4140     sv_setpvn(PL_toptarget, "", 0);
4141     PL_bodytarget = NEWSV(0,0);
4142     sv_upgrade(PL_bodytarget, SVt_PVFM);
4143     sv_setpvn(PL_bodytarget, "", 0);
4144     PL_formtarget = PL_bodytarget;
4145
4146     TAINT;
4147
4148     init_argv_symbols(argc,argv);
4149
4150     if ((tmpgv = gv_fetchpv("0",TRUE, SVt_PV))) {
4151 #ifdef MACOS_TRADITIONAL
4152         /* $0 is not majick on a Mac */
4153         sv_setpv(GvSV(tmpgv),MacPerl_MPWFileName(PL_origfilename));
4154 #else
4155         sv_setpv(GvSV(tmpgv),PL_origfilename);
4156         magicname("0", "0", 1);
4157 #endif
4158     }
4159     if ((PL_envgv = gv_fetchpv("ENV",TRUE, SVt_PVHV))) {
4160         HV *hv;
4161         GvMULTI_on(PL_envgv);
4162         hv = GvHVn(PL_envgv);
4163         hv_magic(hv, Nullgv, PERL_MAGIC_env);
4164 #ifndef PERL_MICRO
4165 #ifdef USE_ENVIRON_ARRAY
4166         /* Note that if the supplied env parameter is actually a copy
4167            of the global environ then it may now point to free'd memory
4168            if the environment has been modified since. To avoid this
4169            problem we treat env==NULL as meaning 'use the default'
4170         */
4171         if (!env)
4172             env = environ;
4173         if (env != environ
4174 #  ifdef USE_ITHREADS
4175             && PL_curinterp == aTHX
4176 #  endif
4177            )
4178         {
4179             environ[0] = Nullch;
4180         }
4181         if (env) {
4182           char** origenv = environ;
4183           char *s;
4184           SV *sv;
4185           for (; *env; env++) {
4186             if (!(s = strchr(*env,'=')) || s == *env)
4187                 continue;
4188 #if defined(MSDOS) && !defined(DJGPP)
4189             *s = '\0';
4190             (void)strupr(*env);
4191             *s = '=';
4192 #endif
4193             sv = newSVpv(s+1, 0);
4194             (void)hv_store(hv, *env, s - *env, sv, 0);
4195             if (env != environ)
4196                 mg_set(sv);
4197             if (origenv != environ) {
4198               /* realloc has shifted us */
4199               env = (env - origenv) + environ;
4200               origenv = environ;
4201             }
4202           }
4203       }
4204 #endif /* USE_ENVIRON_ARRAY */
4205 #endif /* !PERL_MICRO */
4206     }
4207     TAINT_NOT;
4208     if ((tmpgv = gv_fetchpv("$",TRUE, SVt_PV))) {
4209         SvREADONLY_off(GvSV(tmpgv));
4210         sv_setiv(GvSV(tmpgv), (IV)PerlProc_getpid());
4211         SvREADONLY_on(GvSV(tmpgv));
4212     }
4213 #ifdef THREADS_HAVE_PIDS
4214     PL_ppid = (IV)getppid();
4215 #endif
4216
4217     /* touch @F array to prevent spurious warnings 20020415 MJD */
4218     if (PL_minus_a) {
4219       (void) get_av("main::F", TRUE | GV_ADDMULTI);
4220     }
4221     /* touch @- and @+ arrays to prevent spurious warnings 20020415 MJD */
4222     (void) get_av("main::-", TRUE | GV_ADDMULTI);
4223     (void) get_av("main::+", TRUE | GV_ADDMULTI);
4224 }
4225
4226 STATIC void
4227 S_init_perllib(pTHX)
4228 {
4229     char *s;
4230     if (!PL_tainting) {
4231 #ifndef VMS
4232         s = PerlEnv_getenv("PERL5LIB");
4233         if (s)
4234             incpush(s, TRUE, TRUE, TRUE, FALSE);
4235         else
4236             incpush(PerlEnv_getenv("PERLLIB"), FALSE, FALSE, TRUE, FALSE);
4237 #else /* VMS */
4238         /* Treat PERL5?LIB as a possible search list logical name -- the
4239          * "natural" VMS idiom for a Unix path string.  We allow each
4240          * element to be a set of |-separated directories for compatibility.
4241          */
4242         char buf[256];
4243         int idx = 0;
4244         if (my_trnlnm("PERL5LIB",buf,0))
4245             do { incpush(buf,TRUE,TRUE,TRUE,FALSE); } while (my_trnlnm("PERL5LIB",buf,++idx));
4246         else
4247             while (my_trnlnm("PERLLIB",buf,idx++)) incpush(buf,FALSE,FALSE,TRUE,FALSE);
4248 #endif /* VMS */
4249     }
4250
4251 /* Use the ~-expanded versions of APPLLIB (undocumented),
4252     ARCHLIB PRIVLIB SITEARCH SITELIB VENDORARCH and VENDORLIB
4253 */
4254 #ifdef APPLLIB_EXP
4255     incpush(APPLLIB_EXP, TRUE, TRUE, TRUE, TRUE);
4256 #endif
4257
4258 #ifdef ARCHLIB_EXP
4259     incpush(ARCHLIB_EXP, FALSE, FALSE, TRUE, TRUE);
4260 #endif
4261 #ifdef MACOS_TRADITIONAL
4262     {
4263         Stat_t tmpstatbuf;
4264         SV * privdir = NEWSV(55, 0);
4265         char * macperl = PerlEnv_getenv("MACPERL");
4266
4267         if (!macperl)
4268             macperl = "";
4269
4270         Perl_sv_setpvf(aTHX_ privdir, "%slib:", macperl);
4271         if (PerlLIO_stat(SvPVX(privdir), &tmpstatbuf) >= 0 && S_ISDIR(tmpstatbuf.st_mode))
4272             incpush(SvPVX(privdir), TRUE, FALSE, TRUE, FALSE);
4273         Perl_sv_setpvf(aTHX_ privdir, "%ssite_perl:", macperl);
4274         if (PerlLIO_stat(SvPVX(privdir), &tmpstatbuf) >= 0 && S_ISDIR(tmpstatbuf.st_mode))
4275             incpush(SvPVX(privdir), TRUE, FALSE, TRUE, FALSE);
4276
4277         SvREFCNT_dec(privdir);
4278     }
4279     if (!PL_tainting)
4280         incpush(":", FALSE, FALSE, TRUE, FALSE);
4281 #else
4282 #ifndef PRIVLIB_EXP
4283 #  define PRIVLIB_EXP "/usr/local/lib/perl5:/usr/local/lib/perl"
4284 #endif
4285 #if defined(WIN32)
4286     incpush(PRIVLIB_EXP, TRUE, FALSE, TRUE, TRUE);
4287 #else
4288     incpush(PRIVLIB_EXP, FALSE, FALSE, TRUE, TRUE);
4289 #endif
4290
4291 #ifdef SITEARCH_EXP
4292     /* sitearch is always relative to sitelib on Windows for
4293      * DLL-based path intuition to work correctly */
4294 #  if !defined(WIN32)
4295     incpush(SITEARCH_EXP, FALSE, FALSE, TRUE, TRUE);
4296 #  endif
4297 #endif
4298
4299 #ifdef SITELIB_EXP
4300 #  if defined(WIN32)
4301     /* this picks up sitearch as well */
4302     incpush(SITELIB_EXP, TRUE, FALSE, TRUE, TRUE);
4303 #  else
4304     incpush(SITELIB_EXP, FALSE, FALSE, TRUE, TRUE);
4305 #  endif
4306 #endif
4307
4308 #ifdef SITELIB_STEM /* Search for version-specific dirs below here */
4309     incpush(SITELIB_STEM, FALSE, TRUE, TRUE, TRUE);
4310 #endif
4311
4312 #ifdef PERL_VENDORARCH_EXP
4313     /* vendorarch is always relative to vendorlib on Windows for
4314      * DLL-based path intuition to work correctly */
4315 #  if !defined(WIN32)
4316     incpush(PERL_VENDORARCH_EXP, FALSE, FALSE, TRUE, TRUE);
4317 #  endif
4318 #endif
4319
4320 #ifdef PERL_VENDORLIB_EXP
4321 #  if defined(WIN32)
4322     incpush(PERL_VENDORLIB_EXP, TRUE, FALSE, TRUE, TRUE);       /* this picks up vendorarch as well */
4323 #  else
4324     incpush(PERL_VENDORLIB_EXP, FALSE, FALSE, TRUE, TRUE);
4325 #  endif
4326 #endif
4327
4328 #ifdef PERL_VENDORLIB_STEM /* Search for version-specific dirs below here */
4329     incpush(PERL_VENDORLIB_STEM, FALSE, TRUE, TRUE, TRUE);
4330 #endif
4331
4332 #ifdef PERL_OTHERLIBDIRS
4333     incpush(PERL_OTHERLIBDIRS, TRUE, TRUE, TRUE, TRUE);
4334 #endif
4335
4336     if (!PL_tainting)
4337         incpush(".", FALSE, FALSE, TRUE, FALSE);
4338 #endif /* MACOS_TRADITIONAL */
4339 }
4340
4341 #if defined(DOSISH) || defined(EPOC) || defined(SYMBIAN)
4342 #    define PERLLIB_SEP ';'
4343 #else
4344 #  if defined(VMS)
4345 #    define PERLLIB_SEP '|'
4346 #  else
4347 #    if defined(MACOS_TRADITIONAL)
4348 #      define PERLLIB_SEP ','
4349 #    else
4350 #      define PERLLIB_SEP ':'
4351 #    endif
4352 #  endif
4353 #endif
4354 #ifndef PERLLIB_MANGLE
4355 #  define PERLLIB_MANGLE(s,n) (s)
4356 #endif
4357
4358 /* Push a directory onto @INC if it exists.
4359    Generate a new SV if we do this, to save needing to copy the SV we push
4360    onto @INC  */
4361 STATIC SV *
4362 S_incpush_if_exists(pTHX_ SV *dir)
4363 {
4364     Stat_t tmpstatbuf;
4365     if (PerlLIO_stat(SvPVX(dir), &tmpstatbuf) >= 0 &&
4366         S_ISDIR(tmpstatbuf.st_mode)) {
4367         av_push(GvAVn(PL_incgv), dir);
4368         dir = NEWSV(0,0);
4369     }
4370     return dir;
4371 }
4372
4373 STATIC void
4374 S_incpush(pTHX_ const char *dir, bool addsubdirs, bool addoldvers, bool usesep,
4375           bool canrelocate)
4376 {
4377     SV *subdir = Nullsv;
4378     const char *p = dir;
4379
4380     if (!p || !*p)
4381         return;
4382
4383     if (addsubdirs || addoldvers) {
4384         subdir = NEWSV(0,0);
4385     }
4386
4387     /* Break at all separators */
4388     while (p && *p) {
4389         SV *libdir = NEWSV(55,0);
4390         const char *s;
4391
4392         /* skip any consecutive separators */
4393         if (usesep) {
4394             while ( *p == PERLLIB_SEP ) {
4395                 /* Uncomment the next line for PATH semantics */
4396                 /* av_push(GvAVn(PL_incgv), newSVpvn(".", 1)); */
4397                 p++;
4398             }
4399         }
4400
4401         if ( usesep && (s = strchr(p, PERLLIB_SEP)) != Nullch ) {
4402             sv_setpvn(libdir, PERLLIB_MANGLE(p, (STRLEN)(s - p)),
4403                       (STRLEN)(s - p));
4404             p = s + 1;
4405         }
4406         else {
4407             sv_setpv(libdir, PERLLIB_MANGLE(p, 0));
4408             p = Nullch; /* break out */
4409         }
4410 #ifdef MACOS_TRADITIONAL
4411         if (!strchr(SvPVX(libdir), ':')) {
4412             char buf[256];
4413
4414             sv_setpv(libdir, MacPerl_CanonDir(SvPVX(libdir), buf, 0));
4415         }
4416         if (SvPVX(libdir)[SvCUR(libdir)-1] != ':')
4417             sv_catpv(libdir, ":");
4418 #endif
4419
4420         /* Do the if() outside the #ifdef to avoid warnings about an unused
4421            parameter.  */
4422         if (canrelocate) {
4423 #ifdef PERL_RELOCATABLE_INC
4424         /*
4425          * Relocatable include entries are marked with a leading .../
4426          *
4427          * The algorithm is
4428          * 0: Remove that leading ".../"
4429          * 1: Remove trailing executable name (anything after the last '/')
4430          *    from the perl path to give a perl prefix
4431          * Then
4432          * While the @INC element starts "../" and the prefix ends with a real
4433          * directory (ie not . or ..) chop that real directory off the prefix
4434          * and the leading "../" from the @INC element. ie a logical "../"
4435          * cleanup
4436          * Finally concatenate the prefix and the remainder of the @INC element
4437          * The intent is that /usr/local/bin/perl and .../../lib/perl5
4438          * generates /usr/local/lib/perl5
4439          */
4440             char *libpath = SvPVX(libdir);
4441             STRLEN libpath_len = SvCUR(libdir);
4442             if (libpath_len >= 4 && memEQ (libpath, ".../", 4)) {
4443                 /* Game on!  */
4444                 SV *caret_X = get_sv("\030", 0);
4445                 /* Going to use the SV just as a scratch buffer holding a C
4446                    string:  */
4447                 SV *prefix_sv;
4448                 char *prefix;
4449                 char *lastslash;
4450
4451                 /* $^X is *the* source of taint if tainting is on, hence
4452                    SvPOK() won't be true.  */
4453                 assert(caret_X);
4454                 assert(SvPOKp(caret_X));
4455                 prefix_sv = newSVpvn(SvPVX(caret_X), SvCUR(caret_X));
4456                 /* Firstly take off the leading .../
4457                    If all else fail we'll do the paths relative to the current
4458                    directory.  */
4459                 sv_chop(libdir, libpath + 4);
4460                 /* Don't use SvPV as we're intentionally bypassing taining,
4461                    mortal copies that the mg_get of tainting creates, and
4462                    corruption that seems to come via the save stack.
4463                    I guess that the save stack isn't correctly set up yet.  */
4464                 libpath = SvPVX(libdir);
4465                 libpath_len = SvCUR(libdir);
4466
4467                 /* This would work more efficiently with memrchr, but as it's
4468                    only a GNU extension we'd need to probe for it and
4469                    implement our own. Not hard, but maybe not worth it?  */
4470
4471                 prefix = SvPVX(prefix_sv);
4472                 lastslash = strrchr(prefix, '/');
4473
4474                 /* First time in with the *lastslash = '\0' we just wipe off
4475                    the trailing /perl from (say) /usr/foo/bin/perl
4476                 */
4477                 if (lastslash) {
4478                     SV *tempsv;
4479                     while ((*lastslash = '\0'), /* Do that, come what may.  */
4480                            (libpath_len >= 3 && memEQ(libpath, "../", 3)
4481                             && (lastslash = strrchr(prefix, '/')))) {
4482                         if (lastslash[1] == '\0'
4483                             || (lastslash[1] == '.'
4484                                 && (lastslash[2] == '/' /* ends "/."  */
4485                                     || (lastslash[2] == '/'
4486                                         && lastslash[3] == '/' /* or "/.."  */
4487                                         )))) {
4488                             /* Prefix ends "/" or "/." or "/..", any of which
4489                                are fishy, so don't do any more logical cleanup.
4490                             */
4491                             break;
4492                         }
4493                         /* Remove leading "../" from path  */
4494                         libpath += 3;
4495                         libpath_len -= 3;
4496                         /* Next iteration round the loop removes the last
4497                            directory name from prefix by writing a '\0' in
4498                            the while clause.  */
4499                     }
4500                     /* prefix has been terminated with a '\0' to the correct
4501                        length. libpath points somewhere into the libdir SV.
4502                        We need to join the 2 with '/' and drop the result into
4503                        libdir.  */
4504                     tempsv = Perl_newSVpvf(aTHX_ "%s/%s", prefix, libpath);
4505                     SvREFCNT_dec(libdir);
4506                     /* And this is the new libdir.  */
4507                     libdir = tempsv;
4508                     if (PL_tainting &&
4509                         (PL_uid != PL_euid || PL_gid != PL_egid)) {
4510                         /* Need to taint reloccated paths if running set ID  */
4511                         SvTAINTED_on(libdir);
4512                     }
4513                 }
4514                 SvREFCNT_dec(prefix_sv);
4515             }
4516 #endif
4517         }
4518         /*
4519          * BEFORE pushing libdir onto @INC we may first push version- and
4520          * archname-specific sub-directories.
4521          */
4522         if (addsubdirs || addoldvers) {
4523 #ifdef PERL_INC_VERSION_LIST
4524             /* Configure terminates PERL_INC_VERSION_LIST with a NULL */
4525             const char *incverlist[] = { PERL_INC_VERSION_LIST };
4526             const char **incver;
4527 #endif
4528 #ifdef VMS
4529             char *unix;
4530             STRLEN len;
4531
4532             if ((unix = tounixspec_ts(SvPV(libdir,len),Nullch)) != Nullch) {
4533                 len = strlen(unix);
4534                 while (unix[len-1] == '/') len--;  /* Cosmetic */
4535                 sv_usepvn(libdir,unix,len);
4536             }
4537             else
4538                 PerlIO_printf(Perl_error_log,
4539                               "Failed to unixify @INC element \"%s\"\n",
4540                               SvPV(libdir,len));
4541 #endif
4542             if (addsubdirs) {
4543 #ifdef MACOS_TRADITIONAL
4544 #define PERL_AV_SUFFIX_FMT      ""
4545 #define PERL_ARCH_FMT           "%s:"
4546 #define PERL_ARCH_FMT_PATH      PERL_FS_VER_FMT PERL_AV_SUFFIX_FMT
4547 #else
4548 #define PERL_AV_SUFFIX_FMT      "/"
4549 #define PERL_ARCH_FMT           "/%s"
4550 #define PERL_ARCH_FMT_PATH      PERL_AV_SUFFIX_FMT PERL_FS_VER_FMT
4551 #endif
4552                 /* .../version/archname if -d .../version/archname */
4553                 Perl_sv_setpvf(aTHX_ subdir, "%"SVf PERL_ARCH_FMT_PATH PERL_ARCH_FMT,
4554                                 libdir,
4555                                (int)PERL_REVISION, (int)PERL_VERSION,
4556                                (int)PERL_SUBVERSION, ARCHNAME);
4557                 subdir = S_incpush_if_exists(aTHX_ subdir);
4558
4559                 /* .../version if -d .../version */
4560                 Perl_sv_setpvf(aTHX_ subdir, "%"SVf PERL_ARCH_FMT_PATH, libdir,
4561                                (int)PERL_REVISION, (int)PERL_VERSION,
4562                                (int)PERL_SUBVERSION);
4563                 subdir = S_incpush_if_exists(aTHX_ subdir);
4564
4565                 /* .../archname if -d .../archname */
4566                 Perl_sv_setpvf(aTHX_ subdir, "%"SVf PERL_ARCH_FMT, libdir, ARCHNAME);
4567                 subdir = S_incpush_if_exists(aTHX_ subdir);
4568
4569             }
4570
4571 #ifdef PERL_INC_VERSION_LIST
4572             if (addoldvers) {
4573                 for (incver = incverlist; *incver; incver++) {
4574                     /* .../xxx if -d .../xxx */
4575                     Perl_sv_setpvf(aTHX_ subdir, "%"SVf PERL_ARCH_FMT, libdir, *incver);
4576                     subdir = S_incpush_if_exists(aTHX_ subdir);
4577                 }
4578             }
4579 #endif
4580         }
4581
4582         /* finally push this lib directory on the end of @INC */
4583         av_push(GvAVn(PL_incgv), libdir);
4584     }
4585     if (subdir) {
4586         assert (SvREFCNT(subdir) == 1);
4587         SvREFCNT_dec(subdir);
4588     }
4589 }
4590
4591 #ifdef USE_5005THREADS
4592 STATIC struct perl_thread *
4593 S_init_main_thread(pTHX)
4594 {
4595 #if !defined(PERL_IMPLICIT_CONTEXT)
4596     struct perl_thread *thr;
4597 #endif
4598     XPV *xpv;
4599
4600     Newz(53, thr, 1, struct perl_thread);
4601     PL_curcop = &PL_compiling;
4602     thr->interp = PERL_GET_INTERP;
4603     thr->cvcache = newHV();
4604     thr->threadsv = newAV();
4605     /* thr->threadsvp is set when find_threadsv is called */
4606     thr->specific = newAV();
4607     thr->flags = THRf_R_JOINABLE;
4608     MUTEX_INIT(&thr->mutex);
4609     /* Handcraft thrsv similarly to mess_sv */
4610     New(53, PL_thrsv, 1, SV);
4611     Newz(53, xpv, 1, XPV);
4612     SvFLAGS(PL_thrsv) = SVt_PV;
4613     SvANY(PL_thrsv) = (void*)xpv;
4614     SvREFCNT(PL_thrsv) = 1 << 30;       /* practically infinite */
4615     SvPV_set(PL_thrsvr, (char*)thr);
4616     SvCUR_set(PL_thrsv, sizeof(thr));
4617     SvLEN_set(PL_thrsv, sizeof(thr));
4618     *SvEND(PL_thrsv) = '\0';    /* in the trailing_nul field */
4619     thr->oursv = PL_thrsv;
4620     PL_chopset = " \n-";
4621     PL_dumpindent = 4;
4622
4623     MUTEX_LOCK(&PL_threads_mutex);
4624     PL_nthreads++;
4625     thr->tid = 0;
4626     thr->next = thr;
4627     thr->prev = thr;
4628     thr->thr_done = 0;
4629     MUTEX_UNLOCK(&PL_threads_mutex);
4630
4631 #ifdef HAVE_THREAD_INTERN
4632     Perl_init_thread_intern(thr);
4633 #endif
4634
4635 #ifdef SET_THREAD_SELF
4636     SET_THREAD_SELF(thr);
4637 #else
4638     thr->self = pthread_self();
4639 #endif /* SET_THREAD_SELF */
4640     PERL_SET_THX(thr);
4641
4642     /*
4643      * These must come after the thread self setting
4644      * because sv_setpvn does SvTAINT and the taint
4645      * fields thread selfness being set.
4646      */
4647     PL_toptarget = NEWSV(0,0);
4648     sv_upgrade(PL_toptarget, SVt_PVFM);
4649     sv_setpvn(PL_toptarget, "", 0);
4650     PL_bodytarget = NEWSV(0,0);
4651     sv_upgrade(PL_bodytarget, SVt_PVFM);
4652     sv_setpvn(PL_bodytarget, "", 0);
4653     PL_formtarget = PL_bodytarget;
4654     thr->errsv = newSVpvn("", 0);
4655     (void) find_threadsv("@");  /* Ensure $@ is initialised early */
4656
4657     PL_maxscream = -1;
4658     PL_peepp = MEMBER_TO_FPTR(Perl_peep);
4659     PL_regcompp = MEMBER_TO_FPTR(Perl_pregcomp);
4660     PL_regexecp = MEMBER_TO_FPTR(Perl_regexec_flags);
4661     PL_regint_start = MEMBER_TO_FPTR(Perl_re_intuit_start);
4662     PL_regint_string = MEMBER_TO_FPTR(Perl_re_intuit_string);
4663     PL_regfree = MEMBER_TO_FPTR(Perl_pregfree);
4664     PL_regindent = 0;
4665     PL_reginterp_cnt = 0;
4666
4667     return thr;
4668 }
4669 #endif /* USE_5005THREADS */
4670
4671 void
4672 Perl_call_list(pTHX_ I32 oldscope, AV *paramList)
4673 {
4674     dVAR;
4675     SV *atsv;
4676     const line_t oldline = CopLINE(PL_curcop);
4677     CV *cv;
4678     STRLEN len;
4679     int ret;
4680     dJMPENV;
4681
4682     while (av_len(paramList) >= 0) {
4683         cv = (CV*)av_shift(paramList);
4684         if (PL_savebegin) {
4685             if (paramList == PL_beginav) {
4686                 /* save PL_beginav for compiler */
4687                 if (! PL_beginav_save)
4688                     PL_beginav_save = newAV();
4689                 av_push(PL_beginav_save, (SV*)cv);
4690             }
4691             else if (paramList == PL_checkav) {
4692                 /* save PL_checkav for compiler */
4693                 if (! PL_checkav_save)
4694                     PL_checkav_save = newAV();
4695                 av_push(PL_checkav_save, (SV*)cv);
4696             }
4697         } else {
4698             SAVEFREESV(cv);
4699         }
4700         JMPENV_PUSH(ret);
4701         switch (ret) {
4702         case 0:
4703             call_list_body(cv);
4704             atsv = ERRSV;
4705             (void)SvPV(atsv, len);
4706             if (len) {
4707                 PL_curcop = &PL_compiling;
4708                 CopLINE_set(PL_curcop, oldline);
4709                 if (paramList == PL_beginav)
4710                     sv_catpv(atsv, "BEGIN failed--compilation aborted");
4711                 else
4712                     Perl_sv_catpvf(aTHX_ atsv,
4713                                    "%s failed--call queue aborted",
4714                                    paramList == PL_checkav ? "CHECK"
4715                                    : paramList == PL_initav ? "INIT"
4716                                    : "END");
4717                 while (PL_scopestack_ix > oldscope)
4718                     LEAVE;
4719                 JMPENV_POP;
4720                 Perl_croak(aTHX_ "%"SVf"", atsv);
4721             }
4722             break;
4723         case 1:
4724             STATUS_ALL_FAILURE;
4725             /* FALL THROUGH */
4726         case 2:
4727             /* my_exit() was called */
4728             while (PL_scopestack_ix > oldscope)
4729                 LEAVE;
4730             FREETMPS;
4731             PL_curstash = PL_defstash;
4732             PL_curcop = &PL_compiling;
4733             CopLINE_set(PL_curcop, oldline);
4734             JMPENV_POP;
4735             if (PL_statusvalue && !(PL_exit_flags & PERL_EXIT_EXPECTED)) {
4736                 if (paramList == PL_beginav)
4737                     Perl_croak(aTHX_ "BEGIN failed--compilation aborted");
4738                 else
4739                     Perl_croak(aTHX_ "%s failed--call queue aborted",
4740                                paramList == PL_checkav ? "CHECK"
4741                                : paramList == PL_initav ? "INIT"
4742                                : "END");
4743             }
4744             my_exit_jump();
4745             /* NOTREACHED */
4746         case 3:
4747             if (PL_restartop) {
4748                 PL_curcop = &PL_compiling;
4749                 CopLINE_set(PL_curcop, oldline);
4750                 JMPENV_JUMP(3);
4751             }
4752             PerlIO_printf(Perl_error_log, "panic: restartop\n");
4753             FREETMPS;
4754             break;
4755         }
4756         JMPENV_POP;
4757     }
4758 }
4759
4760 STATIC void *
4761 S_call_list_body(pTHX_ CV *cv)
4762 {
4763     PUSHMARK(PL_stack_sp);
4764     call_sv((SV*)cv, G_EVAL|G_DISCARD);
4765     return NULL;
4766 }
4767
4768 void
4769 Perl_my_exit(pTHX_ U32 status)
4770 {
4771     DEBUG_S(PerlIO_printf(Perl_debug_log, "my_exit: thread %p, status %lu\n",
4772                           thr, (unsigned long) status));
4773     switch (status) {
4774     case 0:
4775         STATUS_ALL_SUCCESS;
4776         break;
4777     case 1:
4778         STATUS_ALL_FAILURE;
4779         break;
4780     default:
4781         STATUS_NATIVE_SET(status);
4782         break;
4783     }
4784     my_exit_jump();
4785 }
4786
4787 void
4788 Perl_my_failure_exit(pTHX)
4789 {
4790 #ifdef VMS
4791     if (vaxc$errno & 1) {
4792         if (STATUS_NATIVE & 1)          /* fortuitiously includes "-1" */
4793             STATUS_NATIVE_SET(44);
4794     }
4795     else {
4796         if (!vaxc$errno)                /* unlikely */
4797             STATUS_NATIVE_SET(44);
4798         else
4799             STATUS_NATIVE_SET(vaxc$errno);
4800     }
4801 #else
4802     int exitstatus;
4803     if (errno & 255)
4804         STATUS_POSIX_SET(errno);
4805     else {
4806         exitstatus = STATUS_POSIX >> 8;
4807         if (exitstatus & 255)
4808             STATUS_POSIX_SET(exitstatus);
4809         else
4810             STATUS_POSIX_SET(255);
4811     }
4812 #endif
4813     my_exit_jump();
4814 }
4815
4816 STATIC void
4817 S_my_exit_jump(pTHX)
4818 {
4819     dVAR;
4820     register PERL_CONTEXT *cx;
4821     I32 gimme;
4822     SV **newsp;
4823
4824     if (PL_e_script) {
4825         SvREFCNT_dec(PL_e_script);
4826         PL_e_script = Nullsv;
4827     }
4828
4829     POPSTACK_TO(PL_mainstack);
4830     if (cxstack_ix >= 0) {
4831         if (cxstack_ix > 0)
4832             dounwind(0);
4833         POPBLOCK(cx,PL_curpm);
4834         LEAVE;
4835     }
4836
4837     JMPENV_JUMP(2);
4838 }
4839
4840 static I32
4841 read_e_script(pTHX_ int idx, SV *buf_sv, int maxlen)
4842 {
4843     char *p, *nl;
4844     (void)idx;
4845     (void)maxlen;
4846
4847     p  = SvPVX(PL_e_script);
4848     nl = strchr(p, '\n');
4849     nl = (nl) ? nl+1 : SvEND(PL_e_script);
4850     if (nl-p == 0) {
4851         filter_del(read_e_script);
4852         return 0;
4853     }
4854     sv_catpvn(buf_sv, p, nl-p);
4855     sv_chop(PL_e_script, nl);
4856     return 1;
4857 }