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         const 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=0x%"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         /* we know that type == SVt_PVMG */
 948
 949         /* it could have accumulated taint magic */
 950         MAGIC* mg;
 951         MAGIC* moremagic;
 952         for (mg = SvMAGIC(PL_mess_sv); mg; mg = moremagic) {
 953             moremagic = mg->mg_moremagic;
 954             if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global
 955                 && mg->mg_len >= 0)
 956                 Safefree(mg->mg_ptr);
 957             Safefree(mg);
 958         }
 959
 960         /* we know that type >= SVt_PV */
 961         SvPV_free(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 static void
1010 #if defined(__GNUC__)
1011 __attribute__((destructor))
1012 #endif
1013 perl_fini(void)
1014 {
1015     dVAR;
1016     if (PL_curinterp)
1017         FREE_THREAD_KEY;
1018 }
1019
1020 #endif /* WIN32 */
1021 #endif /* THREADS */
1022
1023 void
1024 Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr)
1025 {
1026     Renew(PL_exitlist, PL_exitlistlen+1, PerlExitListEntry);
1027     PL_exitlist[PL_exitlistlen].fn = fn;
1028     PL_exitlist[PL_exitlistlen].ptr = ptr;
1029     ++PL_exitlistlen;
1030 }
1031
1032 #ifdef HAS_PROCSELFEXE
1033 /* This is a function so that we don't hold on to MAXPATHLEN
1034    bytes of stack longer than necessary
1035  */
1036 STATIC void
1037 S_procself_val(pTHX_ SV *sv, const char *arg0)
1038 {
1039     char buf[MAXPATHLEN];
1040     int len = readlink(PROCSELFEXE_PATH, buf, sizeof(buf) - 1);
1041
1042     /* On Playstation2 Linux V1.0 (kernel 2.2.1) readlink(/proc/self/exe)
1043        includes a spurious NUL which will cause $^X to fail in system
1044        or backticks (this will prevent extensions from being built and
1045        many tests from working). readlink is not meant to add a NUL.
1046        Normal readlink works fine.
1047      */
1048     if (len > 0 && buf[len-1] == '\0') {
1049       len--;
1050     }
1051
1052     /* FreeBSD's implementation is acknowledged to be imperfect, sometimes
1053        returning the text "unknown" from the readlink rather than the path
1054        to the executable (or returning an error from the readlink).  Any valid
1055        path has a '/' in it somewhere, so use that to validate the result.
1056        See http://www.freebsd.org/cgi/query-pr.cgi?pr=35703
1057     */
1058     if (len > 0 && memchr(buf, '/', len)) {
1059         sv_setpvn(sv,buf,len);
1060     }
1061     else {
1062         sv_setpv(sv,arg0);
1063     }
1064 }
1065 #endif /* HAS_PROCSELFEXE */
1066
1067 STATIC void
1068 S_set_caret_X(pTHX) {
1069     GV* tmpgv = gv_fetchpv("\030",TRUE, SVt_PV); /* $^X */
1070     if (tmpgv) {
1071 #ifdef HAS_PROCSELFEXE
1072         S_procself_val(aTHX_ GvSV(tmpgv), PL_origargv[0]);
1073 #else
1074 #ifdef OS2
1075         sv_setpv(GvSV(tmpgv), os2_execname(aTHX));
1076 #else
1077         sv_setpv(GvSV(tmpgv),PL_origargv[0]);
1078 #endif
1079 #endif
1080     }
1081 }
1082
1083 /*
1084 =for apidoc perl_parse
1085
1086 Tells a Perl interpreter to parse a Perl script.  See L<perlembed>.
1087
1088 =cut
1089 */
1090
1091 int
1092 perl_parse(pTHXx_ XSINIT_t xsinit, int argc, char **argv, char **env)
1093 {
1094     dVAR;
1095     I32 oldscope;
1096     int ret;
1097     dJMPENV;
1098
1099 #ifdef SETUID_SCRIPTS_ARE_SECURE_NOW
1100 #ifdef IAMSUID
1101 #undef IAMSUID
1102     Perl_croak(aTHX_ "suidperl is no longer needed since the kernel can now execute\n\
1103 setuid perl scripts securely.\n");
1104 #endif /* IAMSUID */
1105 #endif
1106
1107 #if defined(USE_HASH_SEED) || defined(USE_HASH_SEED_EXPLICIT)
1108     /* [perl #22371] Algorimic Complexity Attack on Perl 5.6.1, 5.8.0
1109      * This MUST be done before any hash stores or fetches take place.
1110      * If you set PL_rehash_seed (and assumedly also PL_rehash_seed_set)
1111      * yourself, it is your responsibility to provide a good random seed!
1112      * You can also define PERL_HASH_SEED in compile time, see hv.h. */
1113     if (!PL_rehash_seed_set)
1114          PL_rehash_seed = get_hash_seed();
1115     {
1116          char *s = PerlEnv_getenv("PERL_HASH_SEED_DEBUG");
1117
1118          if (s) {
1119               int i = atoi(s);
1120
1121               if (i == 1)
1122                    PerlIO_printf(Perl_debug_log, "HASH_SEED = %"UVuf"\n",
1123                                  PL_rehash_seed);
1124          }
1125     }
1126 #endif /* #if defined(USE_HASH_SEED) || defined(USE_HASH_SEED_EXPLICIT) */
1127
1128     PL_origargc = argc;
1129     PL_origargv = argv;
1130
1131     {
1132         /* Set PL_origalen be the sum of the contiguous argv[]
1133          * elements plus the size of the env in case that it is
1134          * contiguous with the argv[].  This is used in mg.c:Perl_magic_set()
1135          * as the maximum modifiable length of $0.  In the worst case
1136          * the area we are able to modify is limited to the size of
1137          * the original argv[0].  (See below for 'contiguous', though.)
1138          * --jhi */
1139          const char *s = NULL;
1140          int i;
1141          UV mask =
1142            ~(UV)(PTRSIZE == 4 ? 3 : PTRSIZE == 8 ? 7 : PTRSIZE == 16 ? 15 : 0);
1143          /* Do the mask check only if the args seem like aligned. */
1144          UV aligned =
1145            (mask < ~(UV)0) && ((PTR2UV(argv[0]) & mask) == PTR2UV(argv[0]));
1146
1147          /* See if all the arguments are contiguous in memory.  Note
1148           * that 'contiguous' is a loose term because some platforms
1149           * align the argv[] and the envp[].  If the arguments look
1150           * like non-aligned, assume that they are 'strictly' or
1151           * 'traditionally' contiguous.  If the arguments look like
1152           * aligned, we just check that they are within aligned
1153           * PTRSIZE bytes.  As long as no system has something bizarre
1154           * like the argv[] interleaved with some other data, we are
1155           * fine.  (Did I just evoke Murphy's Law?)  --jhi */
1156          if (PL_origargv && PL_origargc >= 1 && (s = PL_origargv[0])) {
1157               while (*s) s++;
1158               for (i = 1; i < PL_origargc; i++) {
1159                    if ((PL_origargv[i] == s + 1
1160 #ifdef OS2
1161                         || PL_origargv[i] == s + 2
1162 #endif
1163                             )
1164                        ||
1165                        (aligned &&
1166                         (PL_origargv[i] >  s &&
1167                          PL_origargv[i] <=
1168                          INT2PTR(char *, PTR2UV(s + PTRSIZE) & mask)))
1169                         )
1170                    {
1171                         s = PL_origargv[i];
1172                         while (*s) s++;
1173                    }
1174                    else
1175                         break;
1176               }
1177          }
1178          /* Can we grab env area too to be used as the area for $0? */
1179          if (PL_origenviron) {
1180               if ((PL_origenviron[0] == s + 1
1181 #ifdef OS2
1182                    || (PL_origenviron[0] == s + 9 && (s += 8))
1183 #endif
1184                   )
1185                   ||
1186                   (aligned &&
1187                    (PL_origenviron[0] >  s &&
1188                     PL_origenviron[0] <=
1189                     INT2PTR(char *, PTR2UV(s + PTRSIZE) & mask)))
1190                  )
1191               {
1192 #ifndef OS2
1193                    s = PL_origenviron[0];
1194                    while (*s) s++;
1195 #endif
1196                    my_setenv("NoNe  SuCh", Nullch);
1197                    /* Force copy of environment. */
1198                    for (i = 1; PL_origenviron[i]; i++) {
1199                         if (PL_origenviron[i] == s + 1
1200                             ||
1201                             (aligned &&
1202                              (PL_origenviron[i] >  s &&
1203                               PL_origenviron[i] <=
1204                               INT2PTR(char *, PTR2UV(s + PTRSIZE) & mask)))
1205                            )
1206                         {
1207                              s = PL_origenviron[i];
1208                              while (*s) s++;
1209                         }
1210                         else
1211                              break;
1212                    }
1213               }
1214          }
1215          PL_origalen = s - PL_origargv[0] + 1;
1216     }
1217
1218     if (PL_do_undump) {
1219
1220         /* Come here if running an undumped a.out. */
1221
1222         PL_origfilename = savepv(argv[0]);
1223         PL_do_undump = FALSE;
1224         cxstack_ix = -1;                /* start label stack again */
1225         init_ids();
1226         assert (!PL_tainted);
1227         TAINT;
1228         S_set_caret_X(aTHX);
1229         TAINT_NOT;
1230         init_postdump_symbols(argc,argv,env);
1231         return 0;
1232     }
1233
1234     if (PL_main_root) {
1235         op_free(PL_main_root);
1236         PL_main_root = Nullop;
1237     }
1238     PL_main_start = Nullop;
1239     SvREFCNT_dec(PL_main_cv);
1240     PL_main_cv = Nullcv;
1241
1242     time(&PL_basetime);
1243     oldscope = PL_scopestack_ix;
1244     PL_dowarn = G_WARN_OFF;
1245
1246     JMPENV_PUSH(ret);
1247     switch (ret) {
1248     case 0:
1249         parse_body(env,xsinit);
1250         if (PL_checkav)
1251             call_list(oldscope, PL_checkav);
1252         ret = 0;
1253         break;
1254     case 1:
1255         STATUS_ALL_FAILURE;
1256         /* FALL THROUGH */
1257     case 2:
1258         /* my_exit() was called */
1259         while (PL_scopestack_ix > oldscope)
1260             LEAVE;
1261         FREETMPS;
1262         PL_curstash = PL_defstash;
1263         if (PL_checkav)
1264             call_list(oldscope, PL_checkav);
1265         ret = STATUS_NATIVE_EXPORT;
1266         break;
1267     case 3:
1268         PerlIO_printf(Perl_error_log, "panic: top_env\n");
1269         ret = 1;
1270         break;
1271     }
1272     JMPENV_POP;
1273     return ret;
1274 }
1275
1276 STATIC void *
1277 S_parse_body(pTHX_ char **env, XSINIT_t xsinit)
1278 {
1279     dVAR;
1280     int argc = PL_origargc;
1281     char **argv = PL_origargv;
1282     const char *scriptname = NULL;
1283     VOL bool dosearch = FALSE;
1284     const char *validarg = "";
1285     register SV *sv;
1286     register char *s;
1287     const char *cddir = Nullch;
1288     bool minus_f = FALSE;
1289
1290     PL_fdscript = -1;
1291     PL_suidscript = -1;
1292     sv_setpvn(PL_linestr,"",0);
1293     sv = newSVpvn("",0);                /* first used for -I flags */
1294     SAVEFREESV(sv);
1295     init_main_stash();
1296
1297     for (argc--,argv++; argc > 0; argc--,argv++) {
1298         if (argv[0][0] != '-' || !argv[0][1])
1299             break;
1300 #ifdef DOSUID
1301     if (*validarg)
1302         validarg = " PHOOEY ";
1303     else
1304         validarg = argv[0];
1305     /*
1306      * Can we rely on the kernel to start scripts with argv[1] set to
1307      * contain all #! line switches (the whole line)? (argv[0] is set to
1308      * the interpreter name, argv[2] to the script name; argv[3] and
1309      * above may contain other arguments.)
1310      */
1311 #endif
1312         s = argv[0]+1;
1313       reswitch:
1314         switch (*s) {
1315         case 'C':
1316 #ifndef PERL_STRICT_CR
1317         case '\r':
1318 #endif
1319         case ' ':
1320         case '0':
1321         case 'F':
1322         case 'a':
1323         case 'c':
1324         case 'd':
1325         case 'D':
1326         case 'h':
1327         case 'i':
1328         case 'l':
1329         case 'M':
1330         case 'm':
1331         case 'n':
1332         case 'p':
1333         case 's':
1334         case 'u':
1335         case 'U':
1336         case 'v':
1337         case 'W':
1338         case 'X':
1339         case 'w':
1340         case 'A':
1341             if ((s = moreswitches(s)))
1342                 goto reswitch;
1343             break;
1344
1345         case 't':
1346             CHECK_MALLOC_TOO_LATE_FOR('t');
1347             if( !PL_tainting ) {
1348                  PL_taint_warn = TRUE;
1349                  PL_tainting = TRUE;
1350             }
1351             s++;
1352             goto reswitch;
1353         case 'T':
1354             CHECK_MALLOC_TOO_LATE_FOR('T');
1355             PL_tainting = TRUE;
1356             PL_taint_warn = FALSE;
1357             s++;
1358             goto reswitch;
1359
1360         case 'e':
1361 #ifdef MACOS_TRADITIONAL
1362             /* ignore -e for Dev:Pseudo argument */
1363             if (argv[1] && !strcmp(argv[1], "Dev:Pseudo"))
1364                 break;
1365 #endif
1366             forbid_setid("-e");
1367             if (!PL_e_script) {
1368                 PL_e_script = newSVpvn("",0);
1369                 filter_add(read_e_script, NULL);
1370             }
1371             if (*++s)
1372                 sv_catpv(PL_e_script, s);
1373             else if (argv[1]) {
1374                 sv_catpv(PL_e_script, argv[1]);
1375                 argc--,argv++;
1376             }
1377             else
1378                 Perl_croak(aTHX_ "No code specified for -e");
1379             sv_catpv(PL_e_script, "\n");
1380             break;
1381
1382         case 'f':
1383             minus_f = TRUE;
1384             s++;
1385             goto reswitch;
1386
1387         case 'I':       /* -I handled both here and in moreswitches() */
1388             forbid_setid("-I");
1389             if (!*++s && (s=argv[1]) != Nullch) {
1390                 argc--,argv++;
1391             }
1392             if (s && *s) {
1393                 char *p;
1394                 STRLEN len = strlen(s);
1395                 p = savepvn(s, len);
1396                 incpush(p, TRUE, TRUE, FALSE, FALSE);
1397                 sv_catpvn(sv, "-I", 2);
1398                 sv_catpvn(sv, p, len);
1399                 sv_catpvn(sv, " ", 1);
1400                 Safefree(p);
1401             }
1402             else
1403                 Perl_croak(aTHX_ "No directory specified for -I");
1404             break;
1405         case 'P':
1406             forbid_setid("-P");
1407             PL_preprocess = TRUE;
1408             s++;
1409             goto reswitch;
1410         case 'S':
1411             forbid_setid("-S");
1412             dosearch = TRUE;
1413             s++;
1414             goto reswitch;
1415         case 'V':
1416             if (!PL_preambleav)
1417                 PL_preambleav = newAV();
1418             av_push(PL_preambleav, newSVpv("use Config qw(myconfig config_vars)",0));
1419             if (*++s != ':')  {
1420                 STRLEN opts;
1421
1422                 PL_Sv = newSVpv("print myconfig();",0);
1423 #ifdef VMS
1424                 sv_catpv(PL_Sv,"print \"\\nCharacteristics of this PERLSHR image: \\n\",");
1425 #else
1426                 sv_catpv(PL_Sv,"print \"\\nCharacteristics of this binary (from libperl): \\n\",");
1427 #endif
1428                 opts = SvCUR(PL_Sv);
1429
1430                 sv_catpv(PL_Sv,"\"  Compile-time options:");
1431 #  ifdef DEBUGGING
1432                 sv_catpv(PL_Sv," DEBUGGING");
1433 #  endif
1434 #  ifdef MULTIPLICITY
1435                 sv_catpv(PL_Sv," MULTIPLICITY");
1436 #  endif
1437 #  ifdef USE_5005THREADS
1438                 sv_catpv(PL_Sv," USE_5005THREADS");
1439 #  endif
1440 #  ifdef USE_ITHREADS
1441                 sv_catpv(PL_Sv," USE_ITHREADS");
1442 #  endif
1443 #  ifdef USE_64_BIT_INT
1444                 sv_catpv(PL_Sv," USE_64_BIT_INT");
1445 #  endif
1446 #  ifdef USE_64_BIT_ALL
1447                 sv_catpv(PL_Sv," USE_64_BIT_ALL");
1448 #  endif
1449 #  ifdef USE_LONG_DOUBLE
1450                 sv_catpv(PL_Sv," USE_LONG_DOUBLE");
1451 #  endif
1452 #  ifdef USE_LARGE_FILES
1453                 sv_catpv(PL_Sv," USE_LARGE_FILES");
1454 #  endif
1455 #  ifdef USE_SOCKS
1456                 sv_catpv(PL_Sv," USE_SOCKS");
1457 #  endif
1458 #  ifdef USE_SITECUSTOMIZE
1459                 sv_catpv(PL_Sv," USE_SITECUSTOMIZE");
1460 #  endif
1461 #  ifdef PERL_IMPLICIT_CONTEXT
1462                 sv_catpv(PL_Sv," PERL_IMPLICIT_CONTEXT");
1463 #  endif
1464 #  ifdef PERL_IMPLICIT_SYS
1465                 sv_catpv(PL_Sv," PERL_IMPLICIT_SYS");
1466 #  endif
1467
1468                 while (SvCUR(PL_Sv) > opts+76) {
1469                     /* find last space after "options: " and before col 76 */
1470
1471                     const char *space;
1472                     char *pv = SvPV_nolen(PL_Sv);
1473                     const char c = pv[opts+76];
1474                     pv[opts+76] = '\0';
1475                     space = strrchr(pv+opts+26, ' ');
1476                     pv[opts+76] = c;
1477                     if (!space) break; /* "Can't happen" */
1478
1479                     /* break the line before that space */
1480
1481                     opts = space - pv;
1482                     sv_insert(PL_Sv, opts, 0,
1483                               "\\n                       ", 25);
1484                 }
1485
1486                 sv_catpv(PL_Sv,"\\n\",");
1487
1488 #if defined(LOCAL_PATCH_COUNT)
1489                 if (LOCAL_PATCH_COUNT > 0) {
1490                     int i;
1491                     sv_catpv(PL_Sv,"\"  Locally applied patches:\\n\",");
1492                     for (i = 1; i <= LOCAL_PATCH_COUNT; i++) {
1493                         if (PL_localpatches[i])
1494                             Perl_sv_catpvf(aTHX_ PL_Sv,"q%c\t%s\n%c,",
1495                                     0, PL_localpatches[i], 0);
1496                     }
1497                 }
1498 #endif
1499                 Perl_sv_catpvf(aTHX_ PL_Sv,"\"  Built under %s\\n\"",OSNAME);
1500 #ifdef __DATE__
1501 #  ifdef __TIME__
1502                 Perl_sv_catpvf(aTHX_ PL_Sv,",\"  Compiled at %s %s\\n\"",__DATE__,__TIME__);
1503 #  else
1504                 Perl_sv_catpvf(aTHX_ PL_Sv,",\"  Compiled on %s\\n\"",__DATE__);
1505 #  endif
1506 #endif
1507                 sv_catpv(PL_Sv, "; \
1508 $\"=\"\\n    \"; \
1509 @env = map { \"$_=\\\"$ENV{$_}\\\"\" } sort grep {/^PERL/} keys %ENV; ");
1510 #ifdef __CYGWIN__
1511                 sv_catpv(PL_Sv,"\
1512 push @env, \"CYGWIN=\\\"$ENV{CYGWIN}\\\"\";");
1513 #endif
1514                 sv_catpv(PL_Sv, "\
1515 print \"  \\%ENV:\\n    @env\\n\" if @env; \
1516 print \"  \\@INC:\\n    @INC\\n\";");
1517             }
1518             else {
1519                 PL_Sv = newSVpv("config_vars(qw(",0);
1520                 sv_catpv(PL_Sv, ++s);
1521                 sv_catpv(PL_Sv, "))");
1522                 s += strlen(s);
1523             }
1524             av_push(PL_preambleav, PL_Sv);
1525             scriptname = BIT_BUCKET;    /* don't look for script or read stdin */
1526             goto reswitch;
1527         case 'x':
1528             PL_doextract = TRUE;
1529             s++;
1530             if (*s)
1531                 cddir = s;
1532             break;
1533         case 0:
1534             break;
1535         case '-':
1536             if (!*++s || isSPACE(*s)) {
1537                 argc--,argv++;
1538                 goto switch_end;
1539             }
1540             /* catch use of gnu style long options */
1541             if (strEQ(s, "version")) {
1542                 s = (char *)"v";
1543                 goto reswitch;
1544             }
1545             if (strEQ(s, "help")) {
1546                 s = (char *)"h";
1547                 goto reswitch;
1548             }
1549             s--;
1550             /* FALL THROUGH */
1551         default:
1552             Perl_croak(aTHX_ "Unrecognized switch: -%s  (-h will show valid options)",s);
1553         }
1554     }
1555   switch_end:
1556
1557     if (
1558 #ifndef SECURE_INTERNAL_GETENV
1559         !PL_tainting &&
1560 #endif
1561         (s = PerlEnv_getenv("PERL5OPT")))
1562     {
1563         const char *popt = s;
1564         while (isSPACE(*s))
1565             s++;
1566         if (*s == '-' && *(s+1) == 'T') {
1567             CHECK_MALLOC_TOO_LATE_FOR('T');
1568             PL_tainting = TRUE;
1569             PL_taint_warn = FALSE;
1570         }
1571         else {
1572             char *popt_copy = Nullch;
1573             while (s && *s) {
1574                 char *d;
1575                 while (isSPACE(*s))
1576                     s++;
1577                 if (*s == '-') {
1578                     s++;
1579                     if (isSPACE(*s))
1580                         continue;
1581                 }
1582                 d = s;
1583                 if (!*s)
1584                     break;
1585                 if (!strchr("DIMUdmtwA", *s))
1586                     Perl_croak(aTHX_ "Illegal switch in PERL5OPT: -%c", *s);
1587                 while (++s && *s) {
1588                     if (isSPACE(*s)) {
1589                         if (!popt_copy) {
1590                             popt_copy = SvPVX(sv_2mortal(newSVpv(popt,0)));
1591                             s = popt_copy + (s - popt);
1592                             d = popt_copy + (d - popt);
1593                         }
1594                         *s++ = '\0';
1595                         break;
1596                     }
1597                 }
1598                 if (*d == 't') {
1599                     if( !PL_tainting ) {
1600                         PL_taint_warn = TRUE;
1601                         PL_tainting = TRUE;
1602                     }
1603                 } else {
1604                     moreswitches(d);
1605                 }
1606             }
1607         }
1608     }
1609
1610 #ifdef USE_SITECUSTOMIZE
1611     if (!minus_f) {
1612         if (!PL_preambleav)
1613             PL_preambleav = newAV();
1614         av_unshift(PL_preambleav, 1);
1615         (void)av_store(PL_preambleav, 0, Perl_newSVpvf(aTHX_ "BEGIN { do '%s/sitecustomize.pl' }", SITELIB_EXP));
1616     }
1617 #endif
1618
1619     if (PL_taint_warn && PL_dowarn != G_WARN_ALL_OFF) {
1620        PL_compiling.cop_warnings = newSVpvn(WARN_TAINTstring, WARNsize);
1621     }
1622
1623     if (!scriptname)
1624         scriptname = argv[0];
1625     if (PL_e_script) {
1626         argc++,argv--;
1627         scriptname = BIT_BUCKET;        /* don't look for script or read stdin */
1628     }
1629     else if (scriptname == Nullch) {
1630 #ifdef MSDOS
1631         if ( PerlLIO_isatty(PerlIO_fileno(PerlIO_stdin())) )
1632             moreswitches("h");
1633 #endif
1634         scriptname = "-";
1635     }
1636
1637     /* Set $^X early so that it can be used for relocatable paths in @INC  */
1638     assert (!PL_tainted);
1639     TAINT;
1640     S_set_caret_X(aTHX);
1641     TAINT_NOT;
1642     init_perllib();
1643
1644     open_script(scriptname,dosearch,sv);
1645
1646     validate_suid(validarg, scriptname);
1647
1648 #ifndef PERL_MICRO
1649 #if defined(SIGCHLD) || defined(SIGCLD)
1650     {
1651 #ifndef SIGCHLD
1652 #  define SIGCHLD SIGCLD
1653 #endif
1654         Sighandler_t sigstate = rsignal_state(SIGCHLD);
1655         if (sigstate == SIG_IGN) {
1656             if (ckWARN(WARN_SIGNAL))
1657                 Perl_warner(aTHX_ packWARN(WARN_SIGNAL),
1658                             "Can't ignore signal CHLD, forcing to default");
1659             (void)rsignal(SIGCHLD, (Sighandler_t)SIG_DFL);
1660         }
1661     }
1662 #endif
1663 #endif
1664
1665 #ifdef MACOS_TRADITIONAL
1666     if (PL_doextract || gMacPerl_AlwaysExtract) {
1667 #else
1668     if (PL_doextract) {
1669 #endif
1670         find_beginning();
1671         if (cddir && PerlDir_chdir( (char *)cddir ) < 0)
1672             Perl_croak(aTHX_ "Can't chdir to %s",cddir);
1673
1674     }
1675
1676     PL_main_cv = PL_compcv = (CV*)NEWSV(1104,0);
1677     sv_upgrade((SV *)PL_compcv, SVt_PVCV);
1678     CvUNIQUE_on(PL_compcv);
1679
1680     CvPADLIST(PL_compcv) = pad_new(0);
1681 #ifdef USE_5005THREADS
1682     CvOWNER(PL_compcv) = 0;
1683     New(666, CvMUTEXP(PL_compcv), 1, perl_mutex);
1684     MUTEX_INIT(CvMUTEXP(PL_compcv));
1685 #endif /* USE_5005THREADS */
1686
1687     boot_core_PerlIO();
1688     boot_core_UNIVERSAL();
1689     boot_core_xsutils();
1690
1691     if (xsinit)
1692         (*xsinit)(aTHX);        /* in case linked C routines want magical variables */
1693 #ifndef PERL_MICRO
1694 #if defined(VMS) || defined(WIN32) || defined(DJGPP) || defined(__CYGWIN__) || defined(EPOC)
1695     init_os_extras();
1696 #endif
1697 #endif
1698
1699 #ifdef USE_SOCKS
1700 #   ifdef HAS_SOCKS5_INIT
1701     socks5_init(argv[0]);
1702 #   else
1703     SOCKSinit(argv[0]);
1704 #   endif
1705 #endif
1706
1707     init_predump_symbols();
1708     /* init_postdump_symbols not currently designed to be called */
1709     /* more than once (ENV isn't cleared first, for example)     */
1710     /* But running with -u leaves %ENV & @ARGV undefined!    XXX */
1711     if (!PL_do_undump)
1712         init_postdump_symbols(argc,argv,env);
1713
1714     /* PL_unicode is turned on by -C, or by $ENV{PERL_UNICODE},
1715      * or explicitly in some platforms.
1716      * locale.c:Perl_init_i18nl10n() if the environment
1717      * look like the user wants to use UTF-8. */
1718 #if defined(SYMBIAN)
1719     PL_unicode = PERL_UNICODE_STD_FLAG; /* See PERL_SYMBIAN_CONSOLE_UTF8. */
1720 #endif
1721     if (PL_unicode) {
1722          /* Requires init_predump_symbols(). */
1723          if (!(PL_unicode & PERL_UNICODE_LOCALE_FLAG) || PL_utf8locale) {
1724               IO* io;
1725               PerlIO* fp;
1726               SV* sv;
1727
1728               /* Turn on UTF-8-ness on STDIN, STDOUT, STDERR
1729                * and the default open disciplines. */
1730               if ((PL_unicode & PERL_UNICODE_STDIN_FLAG) &&
1731                   PL_stdingv  && (io = GvIO(PL_stdingv)) &&
1732                   (fp = IoIFP(io)))
1733                    PerlIO_binmode(aTHX_ fp, IoTYPE(io), 0, ":utf8");
1734               if ((PL_unicode & PERL_UNICODE_STDOUT_FLAG) &&
1735                   PL_defoutgv && (io = GvIO(PL_defoutgv)) &&
1736                   (fp = IoOFP(io)))
1737                    PerlIO_binmode(aTHX_ fp, IoTYPE(io), 0, ":utf8");
1738               if ((PL_unicode & PERL_UNICODE_STDERR_FLAG) &&
1739                   PL_stderrgv && (io = GvIO(PL_stderrgv)) &&
1740                   (fp = IoOFP(io)))
1741                    PerlIO_binmode(aTHX_ fp, IoTYPE(io), 0, ":utf8");
1742               if ((PL_unicode & PERL_UNICODE_INOUT_FLAG) &&
1743                   (sv = GvSV(gv_fetchpv("\017PEN", TRUE, SVt_PV)))) {
1744                    U32 in  = PL_unicode & PERL_UNICODE_IN_FLAG;
1745                    U32 out = PL_unicode & PERL_UNICODE_OUT_FLAG;
1746                    if (in) {
1747                         if (out)
1748                              sv_setpvn(sv, ":utf8\0:utf8", 11);
1749                         else
1750                              sv_setpvn(sv, ":utf8\0", 6);
1751                    }
1752                    else if (out)
1753                         sv_setpvn(sv, "\0:utf8", 6);
1754                    SvSETMAGIC(sv);
1755               }
1756          }
1757     }
1758
1759     if ((s = PerlEnv_getenv("PERL_SIGNALS"))) {
1760          if (strEQ(s, "unsafe"))
1761               PL_signals |=  PERL_SIGNALS_UNSAFE_FLAG;
1762          else if (strEQ(s, "safe"))
1763               PL_signals &= ~PERL_SIGNALS_UNSAFE_FLAG;
1764          else
1765               Perl_croak(aTHX_ "PERL_SIGNALS illegal: \"%s\"", s);
1766     }
1767
1768     init_lexer();
1769
1770     /* now parse the script */
1771
1772     SETERRNO(0,SS_NORMAL);
1773     PL_error_count = 0;
1774 #ifdef MACOS_TRADITIONAL
1775     if (gMacPerl_SyntaxError = (yyparse() || PL_error_count)) {
1776         if (PL_minus_c)
1777             Perl_croak(aTHX_ "%s had compilation errors.\n", MacPerl_MPWFileName(PL_origfilename));
1778         else {
1779             Perl_croak(aTHX_ "Execution of %s aborted due to compilation errors.\n",
1780                        MacPerl_MPWFileName(PL_origfilename));
1781         }
1782     }
1783 #else
1784     if (yyparse() || PL_error_count) {
1785         if (PL_minus_c)
1786             Perl_croak(aTHX_ "%s had compilation errors.\n", PL_origfilename);
1787         else {
1788             Perl_croak(aTHX_ "Execution of %s aborted due to compilation errors.\n",
1789                        PL_origfilename);
1790         }
1791     }
1792 #endif
1793     CopLINE_set(PL_curcop, 0);
1794     PL_curstash = PL_defstash;
1795     PL_preprocess = FALSE;
1796     if (PL_e_script) {
1797         SvREFCNT_dec(PL_e_script);
1798         PL_e_script = Nullsv;
1799     }
1800
1801     if (PL_do_undump)
1802         my_unexec();
1803
1804     if (isWARN_ONCE) {
1805         SAVECOPFILE(PL_curcop);
1806         SAVECOPLINE(PL_curcop);
1807         gv_check(PL_defstash);
1808     }
1809
1810     LEAVE;
1811     FREETMPS;
1812
1813 #ifdef MYMALLOC
1814     if ((s=PerlEnv_getenv("PERL_DEBUG_MSTATS")) && atoi(s) >= 2)
1815         dump_mstats("after compilation:");
1816 #endif
1817
1818     ENTER;
1819     PL_restartop = 0;
1820     return NULL;
1821 }
1822
1823 /*
1824 =for apidoc perl_run
1825
1826 Tells a Perl interpreter to run.  See L<perlembed>.
1827
1828 =cut
1829 */
1830
1831 int
1832 perl_run(pTHXx)
1833 {
1834     I32 oldscope;
1835     int ret = 0;
1836     dJMPENV;
1837
1838     oldscope = PL_scopestack_ix;
1839 #ifdef VMS
1840     VMSISH_HUSHED = 0;
1841 #endif
1842
1843     JMPENV_PUSH(ret);
1844     switch (ret) {
1845     case 1:
1846         cxstack_ix = -1;                /* start context stack again */
1847         goto redo_body;
1848     case 0:                             /* normal completion */
1849  redo_body:
1850         run_body(oldscope);
1851         /* FALL THROUGH */
1852     case 2:                             /* my_exit() */
1853         while (PL_scopestack_ix > oldscope)
1854             LEAVE;
1855         FREETMPS;
1856         PL_curstash = PL_defstash;
1857         if (!(PL_exit_flags & PERL_EXIT_DESTRUCT_END) &&
1858             PL_endav && !PL_minus_c)
1859             call_list(oldscope, PL_endav);
1860 #ifdef MYMALLOC
1861         if (PerlEnv_getenv("PERL_DEBUG_MSTATS"))
1862             dump_mstats("after execution:  ");
1863 #endif
1864         ret = STATUS_NATIVE_EXPORT;
1865         break;
1866     case 3:
1867         if (PL_restartop) {
1868             POPSTACK_TO(PL_mainstack);
1869             goto redo_body;
1870         }
1871         PerlIO_printf(Perl_error_log, "panic: restartop\n");
1872         FREETMPS;
1873         ret = 1;
1874         break;
1875     }
1876
1877     JMPENV_POP;
1878     return ret;
1879 }
1880
1881
1882 STATIC void
1883 S_run_body(pTHX_ I32 oldscope)
1884 {
1885     DEBUG_r(PerlIO_printf(Perl_debug_log, "%s $` $& $' support.\n",
1886                     PL_sawampersand ? "Enabling" : "Omitting"));
1887
1888     if (!PL_restartop) {
1889         DEBUG_x(dump_all());
1890         if (!DEBUG_q_TEST)
1891           PERL_DEBUG(PerlIO_printf(Perl_debug_log, "\nEXECUTING...\n\n"));
1892         DEBUG_S(PerlIO_printf(Perl_debug_log, "main thread is 0x%"UVxf"\n",
1893                               PTR2UV(thr)));
1894
1895         if (PL_minus_c) {
1896 #ifdef MACOS_TRADITIONAL
1897             PerlIO_printf(Perl_error_log, "%s%s syntax OK\n",
1898                 (gMacPerl_ErrorFormat ? "# " : ""),
1899                 MacPerl_MPWFileName(PL_origfilename));
1900 #else
1901             PerlIO_printf(Perl_error_log, "%s syntax OK\n", PL_origfilename);
1902 #endif
1903             my_exit(0);
1904         }
1905         if (PERLDB_SINGLE && PL_DBsingle)
1906             sv_setiv(PL_DBsingle, 1);
1907         if (PL_initav)
1908             call_list(oldscope, PL_initav);
1909     }
1910
1911     /* do it */
1912
1913     if (PL_restartop) {
1914         PL_op = PL_restartop;
1915         PL_restartop = 0;
1916         CALLRUNOPS(aTHX);
1917     }
1918     else if (PL_main_start) {
1919         CvDEPTH(PL_main_cv) = 1;
1920         PL_op = PL_main_start;
1921         CALLRUNOPS(aTHX);
1922     }
1923     my_exit(0);
1924     /* NOTREACHED */
1925 }
1926
1927 /*
1928 =head1 SV Manipulation Functions
1929
1930 =for apidoc p||get_sv
1931
1932 Returns the SV of the specified Perl scalar.  If C<create> is set and the
1933 Perl variable does not exist then it will be created.  If C<create> is not
1934 set and the variable does not exist then NULL is returned.
1935
1936 =cut
1937 */
1938
1939 SV*
1940 Perl_get_sv(pTHX_ const char *name, I32 create)
1941 {
1942     GV *gv;
1943 #ifdef USE_5005THREADS
1944     if (name[1] == '\0' && !isALPHA(name[0])) {
1945         PADOFFSET tmp = find_threadsv(name);
1946         if (tmp != NOT_IN_PAD)
1947             return THREADSV(tmp);
1948     }
1949 #endif /* USE_5005THREADS */
1950     gv = gv_fetchpv(name, create, SVt_PV);
1951     if (gv)
1952         return GvSV(gv);
1953     return Nullsv;
1954 }
1955
1956 /*
1957 =head1 Array Manipulation Functions
1958
1959 =for apidoc p||get_av
1960
1961 Returns the AV of the specified Perl array.  If C<create> is set and the
1962 Perl variable does not exist then it will be created.  If C<create> is not
1963 set and the variable does not exist then NULL is returned.
1964
1965 =cut
1966 */
1967
1968 AV*
1969 Perl_get_av(pTHX_ const char *name, I32 create)
1970 {
1971     GV* gv = gv_fetchpv(name, create, SVt_PVAV);
1972     if (create)
1973         return GvAVn(gv);
1974     if (gv)
1975         return GvAV(gv);
1976     return Nullav;
1977 }
1978
1979 /*
1980 =head1 Hash Manipulation Functions
1981
1982 =for apidoc p||get_hv
1983
1984 Returns the HV of the specified Perl hash.  If C<create> is set and the
1985 Perl variable does not exist then it will be created.  If C<create> is not
1986 set and the variable does not exist then NULL is returned.
1987
1988 =cut
1989 */
1990
1991 HV*
1992 Perl_get_hv(pTHX_ const char *name, I32 create)
1993 {
1994     GV* gv = gv_fetchpv(name, create, SVt_PVHV);
1995     if (create)
1996         return GvHVn(gv);
1997     if (gv)
1998         return GvHV(gv);
1999     return Nullhv;
2000 }
2001
2002 /*
2003 =head1 CV Manipulation Functions
2004
2005 =for apidoc p||get_cv
2006
2007 Returns the CV of the specified Perl subroutine.  If C<create> is set and
2008 the Perl subroutine does not exist then it will be declared (which has the
2009 same effect as saying C<sub name;>).  If C<create> is not set and the
2010 subroutine does not exist then NULL is returned.
2011
2012 =cut
2013 */
2014
2015 CV*
2016 Perl_get_cv(pTHX_ const char *name, I32 create)
2017 {
2018     GV* gv = gv_fetchpv(name, create, SVt_PVCV);
2019     /* XXX unsafe for threads if eval_owner isn't held */
2020     /* XXX this is probably not what they think they're getting.
2021      * It has the same effect as "sub name;", i.e. just a forward
2022      * declaration! */
2023     if (create && !GvCVu(gv))
2024         return newSUB(start_subparse(FALSE, 0),
2025                       newSVOP(OP_CONST, 0, newSVpv(name,0)),
2026                       Nullop,
2027                       Nullop);
2028     if (gv)
2029         return GvCVu(gv);
2030     return Nullcv;
2031 }
2032
2033 /* Be sure to refetch the stack pointer after calling these routines. */
2034
2035 /*
2036
2037 =head1 Callback Functions
2038
2039 =for apidoc p||call_argv
2040
2041 Performs a callback to the specified Perl sub.  See L<perlcall>.
2042
2043 =cut
2044 */
2045
2046 I32
2047 Perl_call_argv(pTHX_ const char *sub_name, I32 flags, register char **argv)
2048
2049                         /* See G_* flags in cop.h */
2050                         /* null terminated arg list */
2051 {
2052     dSP;
2053
2054     PUSHMARK(SP);
2055     if (argv) {
2056         while (*argv) {
2057             XPUSHs(sv_2mortal(newSVpv(*argv,0)));
2058             argv++;
2059         }
2060         PUTBACK;
2061     }
2062     return call_pv(sub_name, flags);
2063 }
2064
2065 /*
2066 =for apidoc p||call_pv
2067
2068 Performs a callback to the specified Perl sub.  See L<perlcall>.
2069
2070 =cut
2071 */
2072
2073 I32
2074 Perl_call_pv(pTHX_ const char *sub_name, I32 flags)
2075                         /* name of the subroutine */
2076                         /* See G_* flags in cop.h */
2077 {
2078     return call_sv((SV*)get_cv(sub_name, TRUE), flags);
2079 }
2080
2081 /*
2082 =for apidoc p||call_method
2083
2084 Performs a callback to the specified Perl method.  The blessed object must
2085 be on the stack.  See L<perlcall>.
2086
2087 =cut
2088 */
2089
2090 I32
2091 Perl_call_method(pTHX_ const char *methname, I32 flags)
2092                         /* name of the subroutine */
2093                         /* See G_* flags in cop.h */
2094 {
2095     return call_sv(sv_2mortal(newSVpv(methname,0)), flags | G_METHOD);
2096 }
2097
2098 /* May be called with any of a CV, a GV, or an SV containing the name. */
2099 /*
2100 =for apidoc p||call_sv
2101
2102 Performs a callback to the Perl sub whose name is in the SV.  See
2103 L<perlcall>.
2104
2105 =cut
2106 */
2107
2108 I32
2109 Perl_call_sv(pTHX_ SV *sv, I32 flags)
2110                         /* See G_* flags in cop.h */
2111 {
2112     dVAR; dSP;
2113     LOGOP myop;         /* fake syntax tree node */
2114     UNOP method_op;
2115     I32 oldmark;
2116     volatile I32 retval = 0;
2117     I32 oldscope;
2118     bool oldcatch = CATCH_GET;
2119     int ret;
2120     OP* oldop = PL_op;
2121     dJMPENV;
2122
2123     if (flags & G_DISCARD) {
2124         ENTER;
2125         SAVETMPS;
2126     }
2127
2128     Zero(&myop, 1, LOGOP);
2129     myop.op_next = Nullop;
2130     if (!(flags & G_NOARGS))
2131         myop.op_flags |= OPf_STACKED;
2132     myop.op_flags |= ((flags & G_VOID) ? OPf_WANT_VOID :
2133                       (flags & G_ARRAY) ? OPf_WANT_LIST :
2134                       OPf_WANT_SCALAR);
2135     SAVEOP();
2136     PL_op = (OP*)&myop;
2137
2138     EXTEND(PL_stack_sp, 1);
2139     *++PL_stack_sp = sv;
2140     oldmark = TOPMARK;
2141     oldscope = PL_scopestack_ix;
2142
2143     if (PERLDB_SUB && PL_curstash != PL_debstash
2144            /* Handle first BEGIN of -d. */
2145           && (PL_DBcv || (PL_DBcv = GvCV(PL_DBsub)))
2146            /* Try harder, since this may have been a sighandler, thus
2147             * curstash may be meaningless. */
2148           && (SvTYPE(sv) != SVt_PVCV || CvSTASH((CV*)sv) != PL_debstash)
2149           && !(flags & G_NODEBUG))
2150         PL_op->op_private |= OPpENTERSUB_DB;
2151
2152     if (flags & G_METHOD) {
2153         Zero(&method_op, 1, UNOP);
2154         method_op.op_next = PL_op;
2155         method_op.op_ppaddr = PL_ppaddr[OP_METHOD];
2156         myop.op_ppaddr = PL_ppaddr[OP_ENTERSUB];
2157         PL_op = (OP*)&method_op;
2158     }
2159
2160     if (!(flags & G_EVAL)) {
2161         CATCH_SET(TRUE);
2162         call_body((OP*)&myop, FALSE);
2163         retval = PL_stack_sp - (PL_stack_base + oldmark);
2164         CATCH_SET(oldcatch);
2165     }
2166     else {
2167         myop.op_other = (OP*)&myop;
2168         PL_markstack_ptr--;
2169         /* we're trying to emulate pp_entertry() here */
2170         {
2171             register PERL_CONTEXT *cx;
2172             const I32 gimme = GIMME_V;
2173
2174             ENTER;
2175             SAVETMPS;
2176
2177             PUSHBLOCK(cx, (CXt_EVAL|CXp_TRYBLOCK), PL_stack_sp);
2178             PUSHEVAL(cx, 0, 0);
2179             PL_eval_root = PL_op;             /* Only needed so that goto works right. */
2180
2181             PL_in_eval = EVAL_INEVAL;
2182             if (flags & G_KEEPERR)
2183                 PL_in_eval |= EVAL_KEEPERR;
2184             else
2185                 sv_setpvn(ERRSV,"",0);
2186         }
2187         PL_markstack_ptr++;
2188
2189         JMPENV_PUSH(ret);
2190         switch (ret) {
2191         case 0:
2192  redo_body:
2193             call_body((OP*)&myop, FALSE);
2194             retval = PL_stack_sp - (PL_stack_base + oldmark);
2195             if (!(flags & G_KEEPERR))
2196                 sv_setpvn(ERRSV,"",0);
2197             break;
2198         case 1:
2199             STATUS_ALL_FAILURE;
2200             /* FALL THROUGH */
2201         case 2:
2202             /* my_exit() was called */
2203             PL_curstash = PL_defstash;
2204             FREETMPS;
2205             JMPENV_POP;
2206             if (PL_statusvalue && !(PL_exit_flags & PERL_EXIT_EXPECTED))
2207                 Perl_croak(aTHX_ "Callback called exit");
2208             my_exit_jump();
2209             /* NOTREACHED */
2210         case 3:
2211             if (PL_restartop) {
2212                 PL_op = PL_restartop;
2213                 PL_restartop = 0;
2214                 goto redo_body;
2215             }
2216             PL_stack_sp = PL_stack_base + oldmark;
2217             if (flags & G_ARRAY)
2218                 retval = 0;
2219             else {
2220                 retval = 1;
2221                 *++PL_stack_sp = &PL_sv_undef;
2222             }
2223             break;
2224         }
2225
2226         if (PL_scopestack_ix > oldscope) {
2227             SV **newsp;
2228             PMOP *newpm;
2229             I32 gimme;
2230             register PERL_CONTEXT *cx;
2231             I32 optype;
2232
2233             POPBLOCK(cx,newpm);
2234             POPEVAL(cx);
2235             PL_curpm = newpm;
2236             LEAVE;
2237         }
2238         JMPENV_POP;
2239     }
2240
2241     if (flags & G_DISCARD) {
2242         PL_stack_sp = PL_stack_base + oldmark;
2243         retval = 0;
2244         FREETMPS;
2245         LEAVE;
2246     }
2247     PL_op = oldop;
2248     return retval;
2249 }
2250
2251 STATIC void
2252 S_call_body(pTHX_ const OP *myop, bool is_eval)
2253 {
2254     if (PL_op == myop) {
2255         if (is_eval)
2256             PL_op = Perl_pp_entereval(aTHX);    /* this doesn't do a POPMARK */
2257         else
2258             PL_op = Perl_pp_entersub(aTHX);     /* this does */
2259     }
2260     if (PL_op)
2261         CALLRUNOPS(aTHX);
2262 }
2263
2264 /* Eval a string. The G_EVAL flag is always assumed. */
2265
2266 /*
2267 =for apidoc p||eval_sv
2268
2269 Tells Perl to C<eval> the string in the SV.
2270
2271 =cut
2272 */
2273
2274 I32
2275 Perl_eval_sv(pTHX_ SV *sv, I32 flags)
2276
2277                         /* See G_* flags in cop.h */
2278 {
2279     dSP;
2280     UNOP myop;          /* fake syntax tree node */
2281     volatile I32 oldmark = SP - PL_stack_base;
2282     volatile I32 retval = 0;
2283     I32 oldscope;
2284     int ret;
2285     OP* oldop = PL_op;
2286     dJMPENV;
2287
2288     if (flags & G_DISCARD) {
2289         ENTER;
2290         SAVETMPS;
2291     }
2292
2293     SAVEOP();
2294     PL_op = (OP*)&myop;
2295     Zero(PL_op, 1, UNOP);
2296     EXTEND(PL_stack_sp, 1);
2297     *++PL_stack_sp = sv;
2298     oldscope = PL_scopestack_ix;
2299
2300     if (!(flags & G_NOARGS))
2301         myop.op_flags = OPf_STACKED;
2302     myop.op_next = Nullop;
2303     myop.op_type = OP_ENTEREVAL;
2304     myop.op_flags |= ((flags & G_VOID) ? OPf_WANT_VOID :
2305                       (flags & G_ARRAY) ? OPf_WANT_LIST :
2306                       OPf_WANT_SCALAR);
2307     if (flags & G_KEEPERR)
2308         myop.op_flags |= OPf_SPECIAL;
2309
2310     /* fail now; otherwise we could fail after the JMPENV_PUSH but
2311      * before a PUSHEVAL, which corrupts the stack after a croak */
2312     TAINT_PROPER("eval_sv()");
2313
2314     JMPENV_PUSH(ret);
2315     switch (ret) {
2316     case 0:
2317  redo_body:
2318         call_body((OP*)&myop,TRUE);
2319         retval = PL_stack_sp - (PL_stack_base + oldmark);
2320         if (!(flags & G_KEEPERR))
2321             sv_setpvn(ERRSV,"",0);
2322         break;
2323     case 1:
2324         STATUS_ALL_FAILURE;
2325         /* FALL THROUGH */
2326     case 2:
2327         /* my_exit() was called */
2328         PL_curstash = PL_defstash;
2329         FREETMPS;
2330         JMPENV_POP;
2331         if (PL_statusvalue && !(PL_exit_flags & PERL_EXIT_EXPECTED))
2332             Perl_croak(aTHX_ "Callback called exit");
2333         my_exit_jump();
2334         /* NOTREACHED */
2335     case 3:
2336         if (PL_restartop) {
2337             PL_op = PL_restartop;
2338             PL_restartop = 0;
2339             goto redo_body;
2340         }
2341         PL_stack_sp = PL_stack_base + oldmark;
2342         if (flags & G_ARRAY)
2343             retval = 0;
2344         else {
2345             retval = 1;
2346             *++PL_stack_sp = &PL_sv_undef;
2347         }
2348         break;
2349     }
2350
2351     JMPENV_POP;
2352     if (flags & G_DISCARD) {
2353         PL_stack_sp = PL_stack_base + oldmark;
2354         retval = 0;
2355         FREETMPS;
2356         LEAVE;
2357     }
2358     PL_op = oldop;
2359     return retval;
2360 }
2361
2362 /*
2363 =for apidoc p||eval_pv
2364
2365 Tells Perl to C<eval> the given string and return an SV* result.
2366
2367 =cut
2368 */
2369
2370 SV*
2371 Perl_eval_pv(pTHX_ const char *p, I32 croak_on_error)
2372 {
2373     dSP;
2374     SV* sv = newSVpv(p, 0);
2375
2376     eval_sv(sv, G_SCALAR);
2377     SvREFCNT_dec(sv);
2378
2379     SPAGAIN;
2380     sv = POPs;
2381     PUTBACK;
2382
2383     if (croak_on_error && SvTRUE(ERRSV)) {
2384         STRLEN n_a;
2385         Perl_croak(aTHX_ SvPVx(ERRSV, n_a));
2386     }
2387
2388     return sv;
2389 }
2390
2391 /* Require a module. */
2392
2393 /*
2394 =head1 Embedding Functions
2395
2396 =for apidoc p||require_pv
2397
2398 Tells Perl to C<require> the file named by the string argument.  It is
2399 analogous to the Perl code C<eval "require '$file'">.  It's even
2400 implemented that way; consider using load_module instead.
2401
2402 =cut */
2403
2404 void
2405 Perl_require_pv(pTHX_ const char *pv)
2406 {
2407     SV* sv;
2408     dSP;
2409     PUSHSTACKi(PERLSI_REQUIRE);
2410     PUTBACK;
2411     sv = sv_newmortal();
2412     sv_setpv(sv, "require '");
2413     sv_catpv(sv, pv);
2414     sv_catpv(sv, "'");
2415     eval_sv(sv, G_DISCARD);
2416     SPAGAIN;
2417     POPSTACK;
2418 }
2419
2420 void
2421 Perl_magicname(pTHX_ const char *sym, const char *name, I32 namlen)
2422 {
2423     register GV *gv;
2424
2425     if ((gv = gv_fetchpv(sym,TRUE, SVt_PV)))
2426         sv_magic(GvSV(gv), (SV*)gv, PERL_MAGIC_sv, name, namlen);
2427 }
2428
2429 STATIC void
2430 S_usage(pTHX_ const char *name)         /* XXX move this out into a module ? */
2431 {
2432     /* This message really ought to be max 23 lines.
2433      * Removed -h because the user already knows that option. Others? */
2434
2435     static const char * const usage_msg[] = {
2436 "-0[octal]       specify record separator (\\0, if no argument)",
2437 "-A[name]        activate all/given assertions",
2438 "-a              autosplit mode with -n or -p (splits $_ into @F)",
2439 "-C[number/list] enables the listed Unicode features",
2440 "-c              check syntax only (runs BEGIN and CHECK blocks)",
2441 "-d[:debugger]   run program under debugger",
2442 "-D[number/list] set debugging flags (argument is a bit mask or alphabets)",
2443 "-e program      one line of program (several -e's allowed, omit programfile)",
2444 #ifdef USE_SITECUSTOMIZE
2445 "-f              don't do $sitelib/sitecustomize.pl at startup",
2446 #endif
2447 "-F/pattern/     split() pattern for -a switch (//'s are optional)",
2448 "-i[extension]   edit <> files in place (makes backup if extension supplied)",
2449 "-Idirectory     specify @INC/#include directory (several -I's allowed)",
2450 "-l[octal]       enable line ending processing, specifies line terminator",
2451 "-[mM][-]module  execute `use/no module...' before executing program",
2452 "-n              assume 'while (<>) { ... }' loop around program",
2453 "-p              assume loop like -n but print line also, like sed",
2454 "-P              run program through C preprocessor before compilation",
2455 "-s              enable rudimentary parsing for switches after programfile",
2456 "-S              look for programfile using PATH environment variable",
2457 "-t              enable tainting warnings",
2458 "-T              enable tainting checks",
2459 "-u              dump core after parsing program",
2460 "-U              allow unsafe operations",
2461 "-v              print version, subversion (includes VERY IMPORTANT perl info)",
2462 "-V[:variable]   print configuration summary (or a single Config.pm variable)",
2463 "-w              enable many useful warnings (RECOMMENDED)",
2464 "-W              enable all warnings",
2465 "-x[directory]   strip off text before #!perl line and perhaps cd to directory",
2466 "-X              disable all warnings",
2467 "\n",
2468 NULL
2469 };
2470     const char * const *p = usage_msg;
2471
2472     PerlIO_printf(PerlIO_stdout(),
2473                   "\nUsage: %s [switches] [--] [programfile] [arguments]",
2474                   name);
2475     while (*p)
2476         PerlIO_printf(PerlIO_stdout(), "\n  %s", *p++);
2477 }
2478
2479 /* convert a string of -D options (or digits) into an int.
2480  * sets *s to point to the char after the options */
2481
2482 #ifdef DEBUGGING
2483 int
2484 Perl_get_debug_opts(pTHX_ const char **s, bool givehelp)
2485 {
2486     static const char * const usage_msgd[] = {
2487       " Debugging flag values: (see also -d)",
2488       "  p  Tokenizing and parsing (with v, displays parse stack)",
2489       "  s  Stack snapshots (with v, displays all stacks)",
2490       "  l  Context (loop) stack processing",
2491       "  t  Trace execution",
2492       "  o  Method and overloading resolution",
2493       "  c  String/numeric conversions",
2494       "  P  Print profiling info, preprocessor command for -P, source file input state",
2495       "  m  Memory allocation",
2496       "  f  Format processing",
2497       "  r  Regular expression parsing and execution",
2498       "  x  Syntax tree dump",
2499       "  u  Tainting checks",
2500       "  H  Hash dump -- usurps values()",
2501       "  X  Scratchpad allocation",
2502       "  D  Cleaning up",
2503       "  S  Thread synchronization",
2504       "  T  Tokenising",
2505       "  R  Include reference counts of dumped variables (eg when using -Ds)",
2506       "  J  Do not s,t,P-debug (Jump over) opcodes within package DB",
2507       "  v  Verbose: use in conjunction with other flags",
2508       "  C  Copy On Write",
2509       "  A  Consistency checks on internal structures",
2510       "  q  quiet - currently only suppresses the 'EXECUTING' message",
2511       NULL
2512     };
2513     int i = 0;
2514     if (isALPHA(**s)) {
2515         /* if adding extra options, remember to update DEBUG_MASK */
2516         static const char debopts[] = "psltocPmfrxu HXDSTRJvCAq";
2517
2518         for (; isALNUM(**s); (*s)++) {
2519             const char *d = strchr(debopts,**s);
2520             if (d)
2521                 i |= 1 << (d - debopts);
2522             else if (ckWARN_d(WARN_DEBUGGING))
2523                 Perl_warner(aTHX_ packWARN(WARN_DEBUGGING),
2524                     "invalid option -D%c, use -D'' to see choices\n", **s);
2525         }
2526     }
2527     else if (isDIGIT(**s)) {
2528         i = atoi(*s);
2529         for (; isALNUM(**s); (*s)++) ;
2530     }
2531     else if (givehelp) {
2532       char **p = (char **)usage_msgd;
2533       while (*p) PerlIO_printf(PerlIO_stdout(), "%s\n", *p++);
2534     }
2535 #  ifdef EBCDIC
2536     if ((i & DEBUG_p_FLAG) && ckWARN_d(WARN_DEBUGGING))
2537         Perl_warner(aTHX_ packWARN(WARN_DEBUGGING),
2538                 "-Dp not implemented on this platform\n");
2539 #  endif
2540     return i;
2541 }
2542 #endif
2543
2544 /* This routine handles any switches that can be given during run */
2545
2546 char *
2547 Perl_moreswitches(pTHX_ char *s)
2548 {
2549     dVAR;
2550     UV rschar;
2551
2552     switch (*s) {
2553     case '0':
2554     {
2555          I32 flags = 0;
2556          STRLEN numlen;
2557
2558          SvREFCNT_dec(PL_rs);
2559          if (s[1] == 'x' && s[2]) {
2560               const char *e = s+=2;
2561               U8 *tmps;
2562
2563               while (*e)
2564                 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             STRLEN numlen;
2720             PL_ors_sv = newSVpvn("\n",1);
2721             numlen = 3 + (*s == '0');
2722             *SvPVX(PL_ors_sv) = (char)grok_oct(s, &numlen, &flags, NULL);
2723             s += numlen;
2724         }
2725         else {
2726             if (RsPARA(PL_rs)) {
2727                 PL_ors_sv = newSVpvn("\n\n",2);
2728             }
2729             else {
2730                 PL_ors_sv = newSVsv(PL_rs);
2731             }
2732         }
2733         return s;
2734     case 'A':
2735         forbid_setid("-A");
2736         if (!PL_preambleav)
2737             PL_preambleav = newAV();
2738         if (*++s) {
2739             SV *sv = newSVpv("use assertions::activate split(/,/,q", 0);
2740             sv_catpvn(sv, "\0", 1);     /* Use NUL as q//-delimiter. */
2741             sv_catpv(sv,s);
2742             sv_catpvn(sv, "\0)", 2);
2743             s+=strlen(s);
2744             av_push(PL_preambleav, sv);
2745         }
2746         else
2747             av_push(PL_preambleav, newSVpvn("use assertions::activate",24));
2748         return s;
2749     case 'M':
2750         forbid_setid("-M");     /* XXX ? */
2751         /* FALL THROUGH */
2752     case 'm':
2753         forbid_setid("-m");     /* XXX ? */
2754         if (*++s) {
2755             char *start;
2756             SV *sv;
2757             const char *use = "use ";
2758             /* -M-foo == 'no foo'       */
2759             if (*s == '-') { use = "no "; ++s; }
2760             sv = newSVpv(use,0);
2761             start = s;
2762             /* We allow -M'Module qw(Foo Bar)'  */
2763             while(isALNUM(*s) || *s==':') ++s;
2764             if (*s != '=') {
2765                 sv_catpv(sv, start);
2766                 if (*(start-1) == 'm') {
2767                     if (*s != '\0')
2768                         Perl_croak(aTHX_ "Can't use '%c' after -mname", *s);
2769                     sv_catpv( sv, " ()");
2770                 }
2771             } else {
2772                 if (s == start)
2773                     Perl_croak(aTHX_ "Module name required with -%c option",
2774                                s[-1]);
2775                 sv_catpvn(sv, start, s-start);
2776                 sv_catpv(sv, " split(/,/,q");
2777                 sv_catpvn(sv, "\0)", 1);        /* Use NUL as q//-delimiter. */
2778                 sv_catpv(sv, ++s);
2779                 sv_catpvn(sv,  "\0)", 2);
2780             }
2781             s += strlen(s);
2782             if (!PL_preambleav)
2783                 PL_preambleav = newAV();
2784             av_push(PL_preambleav, sv);
2785         }
2786         else
2787             Perl_croak(aTHX_ "Missing argument to -%c", *(s-1));
2788         return s;
2789     case 'n':
2790         PL_minus_n = TRUE;
2791         s++;
2792         return s;
2793     case 'p':
2794         PL_minus_p = TRUE;
2795         s++;
2796         return s;
2797     case 's':
2798         forbid_setid("-s");
2799         PL_doswitches = TRUE;
2800         s++;
2801         return s;
2802     case 't':
2803         if (!PL_tainting)
2804             TOO_LATE_FOR('t');
2805         s++;
2806         return s;
2807     case 'T':
2808         if (!PL_tainting)
2809             TOO_LATE_FOR('T');
2810         s++;
2811         return s;
2812     case 'u':
2813 #ifdef MACOS_TRADITIONAL
2814         Perl_croak(aTHX_ "Believe me, you don't want to use \"-u\" on a Macintosh");
2815 #endif
2816         PL_do_undump = TRUE;
2817         s++;
2818         return s;
2819     case 'U':
2820         PL_unsafe = TRUE;
2821         s++;
2822         return s;
2823     case 'v':
2824         if (!sv_derived_from(PL_patchlevel, "version"))
2825                 (void *)upg_version(PL_patchlevel);
2826 #if !defined(DGUX)
2827         PerlIO_printf(PerlIO_stdout(),
2828                 Perl_form(aTHX_ "\nThis is perl, v%"SVf" built for %s",
2829                     vstringify(PL_patchlevel),
2830                     ARCHNAME));
2831 #else /* DGUX */
2832 /* Adjust verbose output as in the perl that ships with the DG/UX OS from EMC */
2833         PerlIO_printf(PerlIO_stdout(),
2834                 Perl_form(aTHX_ "\nThis is perl, v%"SVf"\n",
2835                     vstringify(PL_patchlevel)));
2836         PerlIO_printf(PerlIO_stdout(),
2837                         Perl_form(aTHX_ "        built under %s at %s %s\n",
2838                                         OSNAME, __DATE__, __TIME__));
2839         PerlIO_printf(PerlIO_stdout(),
2840                         Perl_form(aTHX_ "        OS Specific Release: %s\n",
2841                                         OSVERS));
2842 #endif /* !DGUX */
2843
2844 #if defined(LOCAL_PATCH_COUNT)
2845         if (LOCAL_PATCH_COUNT > 0)
2846             PerlIO_printf(PerlIO_stdout(),
2847                           "\n(with %d registered patch%s, "
2848                           "see perl -V for more detail)",
2849                           (int)LOCAL_PATCH_COUNT,
2850                           (LOCAL_PATCH_COUNT!=1) ? "es" : "");
2851 #endif
2852
2853         PerlIO_printf(PerlIO_stdout(),
2854                       "\n\nCopyright 1987-2005, Larry Wall\n");
2855 #ifdef MACOS_TRADITIONAL
2856         PerlIO_printf(PerlIO_stdout(),
2857                       "\nMac OS port Copyright 1991-2002, Matthias Neeracher;\n"
2858                       "maintained by Chris Nandor\n");
2859 #endif
2860 #ifdef MSDOS
2861         PerlIO_printf(PerlIO_stdout(),
2862                       "\nMS-DOS port Copyright (c) 1989, 1990, Diomidis Spinellis\n");
2863 #endif
2864 #ifdef DJGPP
2865         PerlIO_printf(PerlIO_stdout(),
2866                       "djgpp v2 port (jpl5003c) by Hirofumi Watanabe, 1996\n"
2867                       "djgpp v2 port (perl5004+) by Laszlo Molnar, 1997-1999\n");
2868 #endif
2869 #ifdef OS2
2870         PerlIO_printf(PerlIO_stdout(),
2871                       "\n\nOS/2 port Copyright (c) 1990, 1991, Raymond Chen, Kai Uwe Rommel\n"
2872                       "Version 5 port Copyright (c) 1994-2002, Andreas Kaiser, Ilya Zakharevich\n");
2873 #endif
2874 #ifdef atarist
2875         PerlIO_printf(PerlIO_stdout(),
2876                       "atariST series port, ++jrb  bammi@cadence.com\n");
2877 #endif
2878 #ifdef __BEOS__
2879         PerlIO_printf(PerlIO_stdout(),
2880                       "BeOS port Copyright Tom Spindler, 1997-1999\n");
2881 #endif
2882 #ifdef MPE
2883         PerlIO_printf(PerlIO_stdout(),
2884                       "MPE/iX port Copyright by Mark Klein and Mark Bixby, 1996-2003\n");
2885 #endif
2886 #ifdef OEMVS
2887         PerlIO_printf(PerlIO_stdout(),
2888                       "MVS (OS390) port by Mortice Kern Systems, 1997-1999\n");
2889 #endif
2890 #ifdef __VOS__
2891         PerlIO_printf(PerlIO_stdout(),
2892                       "Stratus VOS port by Paul.Green@stratus.com, 1997-2002\n");
2893 #endif
2894 #ifdef __OPEN_VM
2895         PerlIO_printf(PerlIO_stdout(),
2896                       "VM/ESA port by Neale Ferguson, 1998-1999\n");
2897 #endif
2898 #ifdef POSIX_BC
2899         PerlIO_printf(PerlIO_stdout(),
2900                       "BS2000 (POSIX) port by Start Amadeus GmbH, 1998-1999\n");
2901 #endif
2902 #ifdef __MINT__
2903         PerlIO_printf(PerlIO_stdout(),
2904                       "MiNT port by Guido Flohr, 1997-1999\n");
2905 #endif
2906 #ifdef EPOC
2907         PerlIO_printf(PerlIO_stdout(),
2908                       "EPOC port by Olaf Flebbe, 1999-2002\n");
2909 #endif
2910 #ifdef UNDER_CE
2911         PerlIO_printf(PerlIO_stdout(),"WINCE port by Rainer Keuchel, 2001-2002\n");
2912         PerlIO_printf(PerlIO_stdout(),"Built on " __DATE__ " " __TIME__ "\n\n");
2913         wce_hitreturn();
2914 #endif
2915 #ifdef SYMBIAN
2916         PerlIO_printf(PerlIO_stdout(),
2917                       "Symbian port by Nokia, 2004-2005\n");
2918 #endif
2919 #ifdef BINARY_BUILD_NOTICE
2920         BINARY_BUILD_NOTICE;
2921 #endif
2922         PerlIO_printf(PerlIO_stdout(),
2923                       "\n\
2924 Perl may be copied only under the terms of either the Artistic License or the\n\
2925 GNU General Public License, which may be found in the Perl 5 source kit.\n\n\
2926 Complete documentation for Perl, including FAQ lists, should be found on\n\
2927 this system using `man perl' or `perldoc perl'.  If you have access to the\n\
2928 Internet, point your browser at http://www.perl.org/, the Perl Home Page.\n\n");
2929         my_exit(0);
2930     case 'w':
2931         if (! (PL_dowarn & G_WARN_ALL_MASK))
2932             PL_dowarn |= G_WARN_ON;
2933         s++;
2934         return s;
2935     case 'W':
2936         PL_dowarn = G_WARN_ALL_ON|G_WARN_ON;
2937         if (!specialWARN(PL_compiling.cop_warnings))
2938             SvREFCNT_dec(PL_compiling.cop_warnings);
2939         PL_compiling.cop_warnings = pWARN_ALL ;
2940         s++;
2941         return s;
2942     case 'X':
2943         PL_dowarn = G_WARN_ALL_OFF;
2944         if (!specialWARN(PL_compiling.cop_warnings))
2945             SvREFCNT_dec(PL_compiling.cop_warnings);
2946         PL_compiling.cop_warnings = pWARN_NONE ;
2947         s++;
2948         return s;
2949     case '*':
2950     case ' ':
2951         if (s[1] == '-')        /* Additional switches on #! line. */
2952             return s+2;
2953         break;
2954     case '-':
2955     case 0:
2956 #if defined(WIN32) || !defined(PERL_STRICT_CR)
2957     case '\r':
2958 #endif
2959     case '\n':
2960     case '\t':
2961         break;
2962 #ifdef ALTERNATE_SHEBANG
2963     case 'S':                   /* OS/2 needs -S on "extproc" line. */
2964         break;
2965 #endif
2966     case 'P':
2967         if (PL_preprocess)
2968             return s+1;
2969         /* FALL THROUGH */
2970     default:
2971         Perl_croak(aTHX_ "Can't emulate -%.1s on #! line",s);
2972     }
2973     return Nullch;
2974 }
2975
2976 /* compliments of Tom Christiansen */
2977
2978 /* unexec() can be found in the Gnu emacs distribution */
2979 /* Known to work with -DUNEXEC and using unexelf.c from GNU emacs-20.2 */
2980
2981 void
2982 Perl_my_unexec(pTHX)
2983 {
2984 #ifdef UNEXEC
2985     SV*    prog;
2986     SV*    file;
2987     int    status = 1;
2988     extern int etext;
2989
2990     prog = newSVpv(BIN_EXP, 0);
2991     sv_catpv(prog, "/perl");
2992     file = newSVpv(PL_origfilename, 0);
2993     sv_catpv(file, ".perldump");
2994
2995     unexec(SvPVX(file), SvPVX(prog), &etext, sbrk(0), 0);
2996     /* unexec prints msg to stderr in case of failure */
2997     PerlProc_exit(status);
2998 #else
2999 #  ifdef VMS
3000 #    include <lib$routines.h>
3001      lib$signal(SS$_DEBUG);  /* ssdef.h #included from vmsish.h */
3002 #  else
3003     ABORT();            /* for use with undump */
3004 #  endif
3005 #endif
3006 }
3007
3008 /* initialize curinterp */
3009 STATIC void
3010 S_init_interp(pTHX)
3011 {
3012
3013 #ifdef MULTIPLICITY
3014 #  define PERLVAR(var,type)
3015 #  define PERLVARA(var,n,type)
3016 #  if defined(PERL_IMPLICIT_CONTEXT)
3017 #    if defined(USE_5005THREADS)
3018 #      define PERLVARI(var,type,init)           PERL_GET_INTERP->var = init;
3019 #      define PERLVARIC(var,type,init)          PERL_GET_INTERP->var = init;
3020 #    else /* !USE_5005THREADS */
3021 #      define PERLVARI(var,type,init)           aTHX->var = init;
3022 #      define PERLVARIC(var,type,init)  aTHX->var = init;
3023 #    endif /* USE_5005THREADS */
3024 #  else
3025 #    define PERLVARI(var,type,init)     PERL_GET_INTERP->var = init;
3026 #    define PERLVARIC(var,type,init)    PERL_GET_INTERP->var = init;
3027 #  endif
3028 #  include "intrpvar.h"
3029 #  ifndef USE_5005THREADS
3030 #    include "thrdvar.h"
3031 #  endif
3032 #  undef PERLVAR
3033 #  undef PERLVARA
3034 #  undef PERLVARI
3035 #  undef PERLVARIC
3036 #else
3037 #  define PERLVAR(var,type)
3038 #  define PERLVARA(var,n,type)
3039 #  define PERLVARI(var,type,init)       PL_##var = init;
3040 #  define PERLVARIC(var,type,init)      PL_##var = init;
3041 #  include "intrpvar.h"
3042 #  ifndef USE_5005THREADS
3043 #    include "thrdvar.h"
3044 #  endif
3045 #  undef PERLVAR
3046 #  undef PERLVARA
3047 #  undef PERLVARI
3048 #  undef PERLVARIC
3049 #endif
3050
3051 }
3052
3053 STATIC void
3054 S_init_main_stash(pTHX)
3055 {
3056     GV *gv;
3057
3058     PL_curstash = PL_defstash = newHV();
3059     PL_curstname = newSVpvn("main",4);
3060     gv = gv_fetchpv("main::",TRUE, SVt_PVHV);
3061     SvREFCNT_dec(GvHV(gv));
3062     GvHV(gv) = (HV*)SvREFCNT_inc(PL_defstash);
3063     SvREADONLY_on(gv);
3064     Perl_hv_name_set(aTHX_ PL_defstash, "main", 4, 0);
3065     PL_incgv = gv_HVadd(gv_AVadd(gv_fetchpv("INC",TRUE, SVt_PVAV)));
3066     GvMULTI_on(PL_incgv);
3067     PL_hintgv = gv_fetchpv("\010",TRUE, SVt_PV); /* ^H */
3068     GvMULTI_on(PL_hintgv);
3069     PL_defgv = gv_fetchpv("_",TRUE, SVt_PVAV);
3070     PL_errgv = gv_HVadd(gv_fetchpv("@", TRUE, SVt_PV));
3071     GvMULTI_on(PL_errgv);
3072     PL_replgv = gv_fetchpv("\022", TRUE, SVt_PV); /* ^R */
3073     GvMULTI_on(PL_replgv);
3074     (void)Perl_form(aTHX_ "%240s","");  /* Preallocate temp - for immediate signals. */
3075     sv_grow(ERRSV, 240);        /* Preallocate - for immediate signals. */
3076     sv_setpvn(ERRSV, "", 0);
3077     PL_curstash = PL_defstash;
3078     CopSTASH_set(&PL_compiling, PL_defstash);
3079     PL_debstash = GvHV(gv_fetchpv("DB::", GV_ADDMULTI, SVt_PVHV));
3080     PL_globalstash = GvHV(gv_fetchpv("CORE::GLOBAL::", GV_ADDMULTI, SVt_PVHV));
3081     /* We must init $/ before switches are processed. */
3082     sv_setpvn(get_sv("/", TRUE), "\n", 1);
3083 }
3084
3085 /* PSz 18 Nov 03  fdscript now global but do not change prototype */
3086 STATIC void
3087 S_open_script(pTHX_ const char *scriptname, bool dosearch, SV *sv)
3088 {
3089 #ifndef IAMSUID
3090     const char *quote;
3091     const char *code;
3092     const char *cpp_discard_flag;
3093     const char *perl;
3094 #endif
3095     dVAR;
3096
3097     PL_fdscript = -1;
3098     PL_suidscript = -1;
3099
3100     if (PL_e_script) {
3101         PL_origfilename = savepvn("-e", 2);
3102     }
3103     else {
3104         /* if find_script() returns, it returns a malloc()-ed value */
3105         scriptname = PL_origfilename = find_script(scriptname, dosearch, NULL, 1);
3106
3107         if (strnEQ(scriptname, "/dev/fd/", 8) && isDIGIT(scriptname[8]) ) {
3108             const char *s = scriptname + 8;
3109             PL_fdscript = atoi(s);
3110             while (isDIGIT(*s))
3111                 s++;
3112             if (*s) {
3113                 /* PSz 18 Feb 04
3114                  * Tell apart "normal" usage of fdscript, e.g.
3115                  * with bash on FreeBSD:
3116                  *   perl <( echo '#!perl -DA'; echo 'print "$0\n"')
3117                  * from usage in suidperl.
3118                  * Does any "normal" usage leave garbage after the number???
3119                  * Is it a mistake to use a similar /dev/fd/ construct for
3120                  * suidperl?
3121                  */
3122                 PL_suidscript = 1;
3123                 /* PSz 20 Feb 04
3124                  * Be supersafe and do some sanity-checks.
3125                  * Still, can we be sure we got the right thing?
3126                  */
3127                 if (*s != '/') {
3128                     Perl_croak(aTHX_ "Wrong syntax (suid) fd script name \"%s\"\n", s);
3129                 }
3130                 if (! *(s+1)) {
3131                     Perl_croak(aTHX_ "Missing (suid) fd script name\n");
3132                 }
3133                 scriptname = savepv(s + 1);
3134                 Safefree(PL_origfilename);
3135                 PL_origfilename = (char *)scriptname;
3136             }
3137         }
3138     }
3139
3140     CopFILE_free(PL_curcop);
3141     CopFILE_set(PL_curcop, PL_origfilename);
3142     if (*PL_origfilename == '-' && PL_origfilename[1] == '\0')
3143         scriptname = (char *)"";
3144     if (PL_fdscript >= 0) {
3145         PL_rsfp = PerlIO_fdopen(PL_fdscript,PERL_SCRIPT_MODE);
3146 #       if defined(HAS_FCNTL) && defined(F_SETFD)
3147             if (PL_rsfp)
3148                 /* ensure close-on-exec */
3149                 fcntl(PerlIO_fileno(PL_rsfp),F_SETFD,1);
3150 #       endif
3151     }
3152 #ifdef IAMSUID
3153     else {
3154         Perl_croak(aTHX_ "sperl needs fd script\n"
3155                    "You should not call sperl directly; do you need to "
3156                    "change a #! line\nfrom sperl to perl?\n");
3157
3158 /* PSz 11 Nov 03
3159  * Do not open (or do other fancy stuff) while setuid.
3160  * Perl does the open, and hands script to suidperl on a fd;
3161  * suidperl only does some checks, sets up UIDs and re-execs
3162  * perl with that fd as it has always done.
3163  */
3164     }
3165     if (PL_suidscript != 1) {
3166         Perl_croak(aTHX_ "suidperl needs (suid) fd script\n");
3167     }
3168 #else /* IAMSUID */
3169     else if (PL_preprocess) {
3170         const char *cpp_cfg = CPPSTDIN;
3171         SV *cpp = newSVpvn("",0);
3172         SV *cmd = NEWSV(0,0);
3173
3174         if (cpp_cfg[0] == 0) /* PERL_MICRO? */
3175              Perl_croak(aTHX_ "Can't run with cpp -P with CPPSTDIN undefined");
3176         if (strEQ(cpp_cfg, "cppstdin"))
3177             Perl_sv_catpvf(aTHX_ cpp, "%s/", BIN_EXP);
3178         sv_catpv(cpp, cpp_cfg);
3179
3180 #       ifndef VMS
3181             sv_catpvn(sv, "-I", 2);
3182             sv_catpv(sv,PRIVLIB_EXP);
3183 #       endif
3184
3185         DEBUG_P(PerlIO_printf(Perl_debug_log,
3186                               "PL_preprocess: scriptname=\"%s\", cpp=\"%s\", sv=\"%s\", CPPMINUS=\"%s\"\n",
3187                               scriptname, SvPVX (cpp), SvPVX (sv), CPPMINUS));
3188
3189 #       if defined(MSDOS) || defined(WIN32) || defined(VMS)
3190             quote = "\"";
3191 #       else
3192             quote = "'";
3193 #       endif
3194
3195 #       ifdef VMS
3196             cpp_discard_flag = "";
3197 #       else
3198             cpp_discard_flag = "-C";
3199 #       endif
3200
3201 #       ifdef OS2
3202             perl = os2_execname(aTHX);
3203 #       else
3204             perl = PL_origargv[0];
3205 #       endif
3206
3207
3208         /* This strips off Perl comments which might interfere with
3209            the C pre-processor, including #!.  #line directives are
3210            deliberately stripped to avoid confusion with Perl's version
3211            of #line.  FWP played some golf with it so it will fit
3212            into VMS's 255 character buffer.
3213         */
3214         if( PL_doextract )
3215             code = "(1../^#!.*perl/i)|/^\\s*#(?!\\s*((ifn?|un)def|(el|end)?if|define|include|else|error|pragma)\\b)/||!($|=1)||print";
3216         else
3217             code = "/^\\s*#(?!\\s*((ifn?|un)def|(el|end)?if|define|include|else|error|pragma)\\b)/||!($|=1)||print";
3218
3219         Perl_sv_setpvf(aTHX_ cmd, "\
3220 %s -ne%s%s%s %s | %"SVf" %s %"SVf" %s",
3221                        perl, quote, code, quote, scriptname, cpp,
3222                        cpp_discard_flag, sv, CPPMINUS);
3223
3224         PL_doextract = FALSE;
3225
3226         DEBUG_P(PerlIO_printf(Perl_debug_log,
3227                               "PL_preprocess: cmd=\"%s\"\n",
3228                               SvPVX(cmd)));
3229
3230         PL_rsfp = PerlProc_popen(SvPVX(cmd), (char *)"r");
3231         SvREFCNT_dec(cmd);
3232         SvREFCNT_dec(cpp);
3233     }
3234     else if (!*scriptname) {
3235         forbid_setid("program input from stdin");
3236         PL_rsfp = PerlIO_stdin();
3237     }
3238     else {
3239         PL_rsfp = PerlIO_open(scriptname,PERL_SCRIPT_MODE);
3240 #       if defined(HAS_FCNTL) && defined(F_SETFD)
3241             if (PL_rsfp)
3242                 /* ensure close-on-exec */
3243                 fcntl(PerlIO_fileno(PL_rsfp),F_SETFD,1);
3244 #       endif
3245     }
3246 #endif /* IAMSUID */
3247     if (!PL_rsfp) {
3248         /* PSz 16 Sep 03  Keep neat error message */
3249         Perl_croak(aTHX_ "Can't open perl script \"%s\": %s\n",
3250                 CopFILE(PL_curcop), Strerror(errno));
3251     }
3252 }
3253
3254 /* Mention
3255  * I_SYSSTATVFS HAS_FSTATVFS
3256  * I_SYSMOUNT
3257  * I_STATFS     HAS_FSTATFS     HAS_GETFSSTAT
3258  * I_MNTENT     HAS_GETMNTENT   HAS_HASMNTOPT
3259  * here so that metaconfig picks them up. */
3260
3261 #ifdef IAMSUID
3262 STATIC int
3263 S_fd_on_nosuid_fs(pTHX_ int fd)
3264 {
3265 /* PSz 27 Feb 04
3266  * We used to do this as "plain" user (after swapping UIDs with setreuid);
3267  * but is needed also on machines without setreuid.
3268  * Seems safe enough to run as root.
3269  */
3270     int check_okay = 0; /* able to do all the required sys/libcalls */
3271     int on_nosuid  = 0; /* the fd is on a nosuid fs */
3272     /* PSz 12 Nov 03
3273      * Need to check noexec also: nosuid might not be set, the average
3274      * sysadmin would say that nosuid is irrelevant once he sets noexec.
3275      */
3276     int on_noexec  = 0; /* the fd is on a noexec fs */
3277
3278 /*
3279  * Preferred order: fstatvfs(), fstatfs(), ustat()+getmnt(), getmntent().
3280  * fstatvfs() is UNIX98.
3281  * fstatfs() is 4.3 BSD.
3282  * ustat()+getmnt() is pre-4.3 BSD.
3283  * getmntent() is O(number-of-mounted-filesystems) and can hang on
3284  * an irrelevant filesystem while trying to reach the right one.
3285  */
3286
3287 #undef FD_ON_NOSUID_CHECK_OKAY  /* found the syscalls to do the check? */
3288
3289 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
3290         defined(HAS_FSTATVFS)
3291 #   define FD_ON_NOSUID_CHECK_OKAY
3292     struct statvfs stfs;
3293
3294     check_okay = fstatvfs(fd, &stfs) == 0;
3295     on_nosuid  = check_okay && (stfs.f_flag  & ST_NOSUID);
3296 #ifdef ST_NOEXEC
3297     /* ST_NOEXEC certainly absent on AIX 5.1, and doesn't seem to be documented
3298        on platforms where it is present.  */
3299     on_noexec  = check_okay && (stfs.f_flag  & ST_NOEXEC);
3300 #endif
3301 #   endif /* fstatvfs */
3302
3303 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
3304         defined(PERL_MOUNT_NOSUID)      && \
3305         defined(PERL_MOUNT_NOEXEC)      && \
3306         defined(HAS_FSTATFS)            && \
3307         defined(HAS_STRUCT_STATFS)      && \
3308         defined(HAS_STRUCT_STATFS_F_FLAGS)
3309 #   define FD_ON_NOSUID_CHECK_OKAY
3310     struct statfs  stfs;
3311
3312     check_okay = fstatfs(fd, &stfs)  == 0;
3313     on_nosuid  = check_okay && (stfs.f_flags & PERL_MOUNT_NOSUID);
3314     on_noexec  = check_okay && (stfs.f_flags & PERL_MOUNT_NOEXEC);
3315 #   endif /* fstatfs */
3316
3317 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
3318         defined(PERL_MOUNT_NOSUID)      && \
3319         defined(PERL_MOUNT_NOEXEC)      && \
3320         defined(HAS_FSTAT)              && \
3321         defined(HAS_USTAT)              && \
3322         defined(HAS_GETMNT)             && \
3323         defined(HAS_STRUCT_FS_DATA)     && \
3324         defined(NOSTAT_ONE)
3325 #   define FD_ON_NOSUID_CHECK_OKAY
3326     Stat_t fdst;
3327
3328     if (fstat(fd, &fdst) == 0) {
3329         struct ustat us;
3330         if (ustat(fdst.st_dev, &us) == 0) {
3331             struct fs_data fsd;
3332             /* NOSTAT_ONE here because we're not examining fields which
3333              * vary between that case and STAT_ONE. */
3334             if (getmnt((int*)0, &fsd, (int)0, NOSTAT_ONE, us.f_fname) == 0) {
3335                 size_t cmplen = sizeof(us.f_fname);
3336                 if (sizeof(fsd.fd_req.path) < cmplen)
3337                     cmplen = sizeof(fsd.fd_req.path);
3338                 if (strnEQ(fsd.fd_req.path, us.f_fname, cmplen) &&
3339                     fdst.st_dev == fsd.fd_req.dev) {
3340                         check_okay = 1;
3341                         on_nosuid = fsd.fd_req.flags & PERL_MOUNT_NOSUID;
3342                         on_noexec = fsd.fd_req.flags & PERL_MOUNT_NOEXEC;
3343                     }
3344                 }
3345             }
3346         }
3347     }
3348 #   endif /* fstat+ustat+getmnt */
3349
3350 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
3351         defined(HAS_GETMNTENT)          && \
3352         defined(HAS_HASMNTOPT)          && \
3353         defined(MNTOPT_NOSUID)          && \
3354         defined(MNTOPT_NOEXEC)
3355 #   define FD_ON_NOSUID_CHECK_OKAY
3356     FILE                *mtab = fopen("/etc/mtab", "r");
3357     struct mntent       *entry;
3358     Stat_t              stb, fsb;
3359
3360     if (mtab && (fstat(fd, &stb) == 0)) {
3361         while (entry = getmntent(mtab)) {
3362             if (stat(entry->mnt_dir, &fsb) == 0
3363                 && fsb.st_dev == stb.st_dev)
3364             {
3365                 /* found the filesystem */
3366                 check_okay = 1;
3367                 if (hasmntopt(entry, MNTOPT_NOSUID))
3368                     on_nosuid = 1;
3369                 if (hasmntopt(entry, MNTOPT_NOEXEC))
3370                     on_noexec = 1;
3371                 break;
3372             } /* A single fs may well fail its stat(). */
3373         }
3374     }
3375     if (mtab)
3376         fclose(mtab);
3377 #   endif /* getmntent+hasmntopt */
3378
3379     if (!check_okay)
3380         Perl_croak(aTHX_ "Can't check filesystem of script \"%s\" for nosuid/noexec", PL_origfilename);
3381     if (on_nosuid)
3382         Perl_croak(aTHX_ "Setuid script \"%s\" on nosuid filesystem", PL_origfilename);
3383     if (on_noexec)
3384         Perl_croak(aTHX_ "Setuid script \"%s\" on noexec filesystem", PL_origfilename);
3385     return ((!check_okay) || on_nosuid || on_noexec);
3386 }
3387 #endif /* IAMSUID */
3388
3389 STATIC void
3390 S_validate_suid(pTHX_ const char *validarg, const char *scriptname)
3391 {
3392     dVAR;
3393 #ifdef IAMSUID
3394     /* int which; */
3395 #endif /* IAMSUID */
3396
3397     /* do we need to emulate setuid on scripts? */
3398
3399     /* This code is for those BSD systems that have setuid #! scripts disabled
3400      * in the kernel because of a security problem.  Merely defining DOSUID
3401      * in perl will not fix that problem, but if you have disabled setuid
3402      * scripts in the kernel, this will attempt to emulate setuid and setgid
3403      * on scripts that have those now-otherwise-useless bits set.  The setuid
3404      * root version must be called suidperl or sperlN.NNN.  If regular perl
3405      * discovers that it has opened a setuid script, it calls suidperl with
3406      * the same argv that it had.  If suidperl finds that the script it has
3407      * just opened is NOT setuid root, it sets the effective uid back to the
3408      * uid.  We don't just make perl setuid root because that loses the
3409      * effective uid we had before invoking perl, if it was different from the
3410      * uid.
3411      * PSz 27 Feb 04
3412      * Description/comments above do not match current workings:
3413      *   suidperl must be hardlinked to sperlN.NNN (that is what we exec);
3414      *   suidperl called with script open and name changed to /dev/fd/N/X;
3415      *   suidperl croaks if script is not setuid;
3416      *   making perl setuid would be a huge security risk (and yes, that
3417      *     would lose any euid we might have had).
3418      *
3419      * DOSUID must be defined in both perl and suidperl, and IAMSUID must
3420      * be defined in suidperl only.  suidperl must be setuid root.  The
3421      * Configure script will set this up for you if you want it.
3422      */
3423
3424 #ifdef DOSUID
3425     char *s, *s2;
3426
3427     if (PerlLIO_fstat(PerlIO_fileno(PL_rsfp),&PL_statbuf) < 0)  /* normal stat is insecure */
3428         Perl_croak(aTHX_ "Can't stat script \"%s\"",PL_origfilename);
3429     if (PL_statbuf.st_mode & (S_ISUID|S_ISGID)) {
3430         I32 len;
3431         STRLEN n_a;
3432
3433 #ifdef IAMSUID
3434         if (PL_fdscript < 0 || PL_suidscript != 1)
3435             Perl_croak(aTHX_ "Need (suid) fdscript in suidperl\n");     /* We already checked this */
3436         /* PSz 11 Nov 03
3437          * Since the script is opened by perl, not suidperl, some of these
3438          * checks are superfluous. Leaving them in probably does not lower
3439          * security(?!).
3440          */
3441         /* PSz 27 Feb 04
3442          * Do checks even for systems with no HAS_SETREUID.
3443          * We used to swap, then re-swap UIDs with
3444 #ifdef HAS_SETREUID
3445             if (setreuid(PL_euid,PL_uid) < 0
3446                 || PerlProc_getuid() != PL_euid || PerlProc_geteuid() != PL_uid)
3447                 Perl_croak(aTHX_ "Can't swap uid and euid");
3448 #endif
3449 #ifdef HAS_SETREUID
3450             if (setreuid(PL_uid,PL_euid) < 0
3451                 || PerlProc_getuid() != PL_uid || PerlProc_geteuid() != PL_euid)
3452                 Perl_croak(aTHX_ "Can't reswap uid and euid");
3453 #endif
3454          */
3455
3456         /* On this access check to make sure the directories are readable,
3457          * there is actually a small window that the user could use to make
3458          * filename point to an accessible directory.  So there is a faint
3459          * chance that someone could execute a setuid script down in a
3460          * non-accessible directory.  I don't know what to do about that.
3461          * But I don't think it's too important.  The manual lies when
3462          * it says access() is useful in setuid programs.
3463          *
3464          * So, access() is pretty useless... but not harmful... do anyway.
3465          */
3466         if (PerlLIO_access(CopFILE(PL_curcop),1)) { /*double check*/
3467             Perl_croak(aTHX_ "Can't access() script\n");
3468         }
3469
3470         /* If we can swap euid and uid, then we can determine access rights
3471          * with a simple stat of the file, and then compare device and
3472          * inode to make sure we did stat() on the same file we opened.
3473          * Then we just have to make sure he or she can execute it.
3474          *
3475          * PSz 24 Feb 04
3476          * As the script is opened by perl, not suidperl, we do not need to
3477          * care much about access rights.
3478          *
3479          * The 'script changed' check is needed, or we can get lied to
3480          * about $0 with e.g.
3481          *  suidperl /dev/fd/4//bin/x 4<setuidscript
3482          * Without HAS_SETREUID, is it safe to stat() as root?
3483          *
3484          * Are there any operating systems that pass /dev/fd/xxx for setuid
3485          * scripts, as suggested/described in perlsec(1)? Surely they do not
3486          * pass the script name as we do, so the "script changed" test would
3487          * fail for them... but we never get here with
3488          * SETUID_SCRIPTS_ARE_SECURE_NOW defined.
3489          *
3490          * This is one place where we must "lie" about return status: not
3491          * say if the stat() failed. We are doing this as root, and could
3492          * be tricked into reporting existence or not of files that the
3493          * "plain" user cannot even see.
3494          */
3495         {
3496             Stat_t tmpstatbuf;
3497             if (PerlLIO_stat(CopFILE(PL_curcop),&tmpstatbuf) < 0 ||
3498                 tmpstatbuf.st_dev != PL_statbuf.st_dev ||
3499                 tmpstatbuf.st_ino != PL_statbuf.st_ino) {
3500                 Perl_croak(aTHX_ "Setuid script changed\n");
3501             }
3502
3503         }
3504         if (!cando(S_IXUSR,FALSE,&PL_statbuf))          /* can real uid exec? */
3505             Perl_croak(aTHX_ "Real UID cannot exec script\n");
3506
3507         /* PSz 27 Feb 04
3508          * We used to do this check as the "plain" user (after swapping
3509          * UIDs). But the check for nosuid and noexec filesystem is needed,
3510          * and should be done even without HAS_SETREUID. (Maybe those
3511          * operating systems do not have such mount options anyway...)
3512          * Seems safe enough to do as root.
3513          */
3514 #if !defined(NO_NOSUID_CHECK)
3515         if (fd_on_nosuid_fs(PerlIO_fileno(PL_rsfp))) {
3516             Perl_croak(aTHX_ "Setuid script on nosuid or noexec filesystem\n");
3517         }
3518 #endif
3519 #endif /* IAMSUID */
3520
3521         if (!S_ISREG(PL_statbuf.st_mode)) {
3522             Perl_croak(aTHX_ "Setuid script not plain file\n");
3523         }
3524         if (PL_statbuf.st_mode & S_IWOTH)
3525             Perl_croak(aTHX_ "Setuid/gid script is writable by world");
3526         PL_doswitches = FALSE;          /* -s is insecure in suid */
3527         /* PSz 13 Nov 03  But -s was caught elsewhere ... so unsetting it here is useless(?!) */
3528         CopLINE_inc(PL_curcop);
3529         if (sv_gets(PL_linestr, PL_rsfp, 0) == Nullch ||
3530           strnNE(SvPV(PL_linestr,n_a),"#!",2) ) /* required even on Sys V */
3531             Perl_croak(aTHX_ "No #! line");
3532         s = SvPV(PL_linestr,n_a)+2;
3533         /* PSz 27 Feb 04 */
3534         /* Sanity check on line length */
3535         if (strlen(s) < 1 || strlen(s) > 4000)
3536             Perl_croak(aTHX_ "Very long #! line");
3537         /* Allow more than a single space after #! */
3538         while (isSPACE(*s)) s++;
3539         /* Sanity check on buffer end */
3540         while ((*s) && !isSPACE(*s)) s++;
3541         for (s2 = s;  (s2 > SvPV(PL_linestr,n_a)+2 &&
3542                        (isDIGIT(s2[-1]) || s2[-1] == '.' || s2[-1] == '_'
3543                         || s2[-1] == '-'));  s2--) ;
3544         /* Sanity check on buffer start */
3545         if ( (s2-4 < SvPV(PL_linestr,n_a)+2 || strnNE(s2-4,"perl",4)) &&
3546               (s-9 < SvPV(PL_linestr,n_a)+2 || strnNE(s-9,"perl",4)) )
3547             Perl_croak(aTHX_ "Not a perl script");
3548         while (*s == ' ' || *s == '\t') s++;
3549         /*
3550          * #! arg must be what we saw above.  They can invoke it by
3551          * mentioning suidperl explicitly, but they may not add any strange
3552          * arguments beyond what #! says if they do invoke suidperl that way.
3553          */
3554         /*
3555          * The way validarg was set up, we rely on the kernel to start
3556          * scripts with argv[1] set to contain all #! line switches (the
3557          * whole line).
3558          */
3559         /*
3560          * Check that we got all the arguments listed in the #! line (not
3561          * just that there are no extraneous arguments). Might not matter
3562          * much, as switches from #! line seem to be acted upon (also), and
3563          * so may be checked and trapped in perl. But, security checks must
3564          * be done in suidperl and not deferred to perl. Note that suidperl
3565          * does not get around to parsing (and checking) the switches on
3566          * the #! line (but execs perl sooner).
3567          * Allow (require) a trailing newline (which may be of two
3568          * characters on some architectures?) (but no other trailing
3569          * whitespace).
3570          */
3571         len = strlen(validarg);
3572         if (strEQ(validarg," PHOOEY ") ||
3573             strnNE(s,validarg,len) || !isSPACE(s[len]) ||
3574             !(strlen(s) == len+1 || (strlen(s) == len+2 && isSPACE(s[len+1]))))
3575             Perl_croak(aTHX_ "Args must match #! line");
3576
3577 #ifndef IAMSUID
3578         if (PL_fdscript < 0 &&
3579             PL_euid != PL_uid && (PL_statbuf.st_mode & S_ISUID) &&
3580             PL_euid == PL_statbuf.st_uid)
3581             if (!PL_do_undump)
3582                 Perl_croak(aTHX_ "YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!\n\
3583 FIX YOUR KERNEL, OR PUT A C WRAPPER AROUND THIS SCRIPT!\n");
3584 #endif /* IAMSUID */
3585
3586         if (PL_fdscript < 0 &&
3587             PL_euid) {  /* oops, we're not the setuid root perl */
3588             /* PSz 18 Feb 04
3589              * When root runs a setuid script, we do not go through the same
3590              * steps of execing sperl and then perl with fd scripts, but
3591              * simply set up UIDs within the same perl invocation; so do
3592              * not have the same checks (on options, whatever) that we have
3593              * for plain users. No problem really: would have to be a script
3594              * that does not actually work for plain users; and if root is
3595              * foolish and can be persuaded to run such an unsafe script, he
3596              * might run also non-setuid ones, and deserves what he gets.
3597              *
3598              * Or, we might drop the PL_euid check above (and rely just on
3599              * PL_fdscript to avoid loops), and do the execs
3600              * even for root.
3601              */
3602 #ifndef IAMSUID
3603             int which;
3604             /* PSz 11 Nov 03
3605              * Pass fd script to suidperl.
3606              * Exec suidperl, substituting fd script for scriptname.
3607              * Pass script name as "subdir" of fd, which perl will grok;
3608              * in fact will use that to distinguish this from "normal"
3609              * usage, see comments above.
3610              */
3611             PerlIO_rewind(PL_rsfp);
3612             PerlLIO_lseek(PerlIO_fileno(PL_rsfp),(Off_t)0,0);  /* just in case rewind didn't */
3613             /* PSz 27 Feb 04  Sanity checks on scriptname */
3614             if ((!scriptname) || (!*scriptname) ) {
3615                 Perl_croak(aTHX_ "No setuid script name\n");
3616             }
3617             if (*scriptname == '-') {
3618                 Perl_croak(aTHX_ "Setuid script name may not begin with dash\n");
3619                 /* Or we might confuse it with an option when replacing
3620                  * name in argument list, below (though we do pointer, not
3621                  * string, comparisons).
3622                  */
3623             }
3624             for (which = 1; PL_origargv[which] && PL_origargv[which] != scriptname; which++) ;
3625             if (!PL_origargv[which]) {
3626                 Perl_croak(aTHX_ "Can't change argv to have fd script\n");
3627             }
3628             PL_origargv[which] = savepv(Perl_form(aTHX_ "/dev/fd/%d/%s",
3629                                           PerlIO_fileno(PL_rsfp), PL_origargv[which]));
3630 #if defined(HAS_FCNTL) && defined(F_SETFD)
3631             fcntl(PerlIO_fileno(PL_rsfp),F_SETFD,0);    /* ensure no close-on-exec */
3632 #endif
3633             PERL_FPU_PRE_EXEC
3634             PerlProc_execv(Perl_form(aTHX_ "%s/sperl"PERL_FS_VER_FMT, BIN_EXP,
3635                                      (int)PERL_REVISION, (int)PERL_VERSION,
3636                                      (int)PERL_SUBVERSION), PL_origargv);
3637             PERL_FPU_POST_EXEC
3638 #endif /* IAMSUID */
3639             Perl_croak(aTHX_ "Can't do setuid (cannot exec sperl)\n");
3640         }
3641
3642         if (PL_statbuf.st_mode & S_ISGID && PL_statbuf.st_gid != PL_egid) {
3643 /* PSz 26 Feb 04
3644  * This seems back to front: we try HAS_SETEGID first; if not available
3645  * then try HAS_SETREGID; as a last chance we try HAS_SETRESGID. May be OK
3646  * in the sense that we only want to set EGID; but are there any machines
3647  * with either of the latter, but not the former? Same with UID, later.
3648  */
3649 #ifdef HAS_SETEGID
3650             (void)setegid(PL_statbuf.st_gid);
3651 #else
3652 #ifdef HAS_SETREGID
3653            (void)setregid((Gid_t)-1,PL_statbuf.st_gid);
3654 #else
3655 #ifdef HAS_SETRESGID
3656            (void)setresgid((Gid_t)-1,PL_statbuf.st_gid,(Gid_t)-1);
3657 #else
3658             PerlProc_setgid(PL_statbuf.st_gid);
3659 #endif
3660 #endif
3661 #endif
3662             if (PerlProc_getegid() != PL_statbuf.st_gid)
3663                 Perl_croak(aTHX_ "Can't do setegid!\n");
3664         }
3665         if (PL_statbuf.st_mode & S_ISUID) {
3666             if (PL_statbuf.st_uid != PL_euid)
3667 #ifdef HAS_SETEUID
3668                 (void)seteuid(PL_statbuf.st_uid);       /* all that for this */
3669 #else
3670 #ifdef HAS_SETREUID
3671                 (void)setreuid((Uid_t)-1,PL_statbuf.st_uid);
3672 #else
3673 #ifdef HAS_SETRESUID
3674                 (void)setresuid((Uid_t)-1,PL_statbuf.st_uid,(Uid_t)-1);
3675 #else
3676                 PerlProc_setuid(PL_statbuf.st_uid);
3677 #endif
3678 #endif
3679 #endif
3680             if (PerlProc_geteuid() != PL_statbuf.st_uid)
3681                 Perl_croak(aTHX_ "Can't do seteuid!\n");
3682         }
3683         else if (PL_uid) {                      /* oops, mustn't run as root */
3684 #ifdef HAS_SETEUID
3685           (void)seteuid((Uid_t)PL_uid);
3686 #else
3687 #ifdef HAS_SETREUID
3688           (void)setreuid((Uid_t)-1,(Uid_t)PL_uid);
3689 #else
3690 #ifdef HAS_SETRESUID
3691           (void)setresuid((Uid_t)-1,(Uid_t)PL_uid,(Uid_t)-1);
3692 #else
3693           PerlProc_setuid((Uid_t)PL_uid);
3694 #endif
3695 #endif
3696 #endif
3697             if (PerlProc_geteuid() != PL_uid)
3698                 Perl_croak(aTHX_ "Can't do seteuid!\n");
3699         }
3700         init_ids();
3701         if (!cando(S_IXUSR,TRUE,&PL_statbuf))
3702             Perl_croak(aTHX_ "Effective UID cannot exec script\n");     /* they can't do this */
3703     }
3704 #ifdef IAMSUID
3705     else if (PL_preprocess)     /* PSz 13 Nov 03  Caught elsewhere, useless(?!) here */
3706         Perl_croak(aTHX_ "-P not allowed for setuid/setgid script\n");
3707     else if (PL_fdscript < 0 || PL_suidscript != 1)
3708         /* PSz 13 Nov 03  Caught elsewhere, useless(?!) here */
3709         Perl_croak(aTHX_ "(suid) fdscript needed in suidperl\n");
3710     else {
3711 /* PSz 16 Sep 03  Keep neat error message */
3712         Perl_croak(aTHX_ "Script is not setuid/setgid in suidperl\n");
3713     }
3714
3715     /* We absolutely must clear out any saved ids here, so we */
3716     /* exec the real perl, substituting fd script for scriptname. */
3717     /* (We pass script name as "subdir" of fd, which perl will grok.) */
3718     /*
3719      * It might be thought that using setresgid and/or setresuid (changed to
3720      * set the saved IDs) above might obviate the need to exec, and we could
3721      * go on to "do the perl thing".
3722      *
3723      * Is there such a thing as "saved GID", and is that set for setuid (but
3724      * not setgid) execution like suidperl? Without exec, it would not be
3725      * cleared for setuid (but not setgid) scripts (or might need a dummy
3726      * setresgid).
3727      *
3728      * We need suidperl to do the exact same argument checking that perl
3729      * does. Thus it cannot be very small; while it could be significantly
3730      * smaller, it is safer (simpler?) to make it essentially the same
3731      * binary as perl (but they are not identical). - Maybe could defer that
3732      * check to the invoked perl, and suidperl be a tiny wrapper instead;
3733      * but prefer to do thorough checks in suidperl itself. Such deferral
3734      * would make suidperl security rely on perl, a design no-no.
3735      *
3736      * Setuid things should be short and simple, thus easy to understand and
3737      * verify. They should do their "own thing", without influence by
3738      * attackers. It may help if their internal execution flow is fixed,
3739      * regardless of platform: it may be best to exec anyway.
3740      *
3741      * Suidperl should at least be conceptually simple: a wrapper only,
3742      * never to do any real perl. Maybe we should put
3743      * #ifdef IAMSUID
3744      *         Perl_croak(aTHX_ "Suidperl should never do real perl\n");
3745      * #endif
3746      * into the perly bits.
3747      */
3748     PerlIO_rewind(PL_rsfp);
3749     PerlLIO_lseek(PerlIO_fileno(PL_rsfp),(Off_t)0,0);  /* just in case rewind didn't */
3750     /* PSz 11 Nov 03
3751      * Keep original arguments: suidperl already has fd script.
3752      */
3753 /*  for (which = 1; PL_origargv[which] && PL_origargv[which] != scriptname; which++) ;  */
3754 /*  if (!PL_origargv[which]) {                                          */
3755 /*      errno = EPERM;                                                  */
3756 /*      Perl_croak(aTHX_ "Permission denied\n");                        */
3757 /*  }                                                                   */
3758 /*  PL_origargv[which] = savepv(Perl_form(aTHX_ "/dev/fd/%d/%s",        */
3759 /*                                PerlIO_fileno(PL_rsfp), PL_origargv[which])); */
3760 #if defined(HAS_FCNTL) && defined(F_SETFD)
3761     fcntl(PerlIO_fileno(PL_rsfp),F_SETFD,0);    /* ensure no close-on-exec */
3762 #endif
3763     PERL_FPU_PRE_EXEC
3764     PerlProc_execv(Perl_form(aTHX_ "%s/perl"PERL_FS_VER_FMT, BIN_EXP,
3765                              (int)PERL_REVISION, (int)PERL_VERSION,
3766                              (int)PERL_SUBVERSION), PL_origargv);/* try again */
3767     PERL_FPU_POST_EXEC
3768     Perl_croak(aTHX_ "Can't do setuid (suidperl cannot exec perl)\n");
3769 #endif /* IAMSUID */
3770 #else /* !DOSUID */
3771     if (PL_euid != PL_uid || PL_egid != PL_gid) {       /* (suidperl doesn't exist, in fact) */
3772 #ifndef SETUID_SCRIPTS_ARE_SECURE_NOW
3773         PerlLIO_fstat(PerlIO_fileno(PL_rsfp),&PL_statbuf);      /* may be either wrapped or real suid */
3774         if ((PL_euid != PL_uid && PL_euid == PL_statbuf.st_uid && PL_statbuf.st_mode & S_ISUID)
3775             ||
3776             (PL_egid != PL_gid && PL_egid == PL_statbuf.st_gid && PL_statbuf.st_mode & S_ISGID)
3777            )
3778             if (!PL_do_undump)
3779                 Perl_croak(aTHX_ "YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!\n\
3780 FIX YOUR KERNEL, PUT A C WRAPPER AROUND THIS SCRIPT, OR USE -u AND UNDUMP!\n");
3781 #endif /* SETUID_SCRIPTS_ARE_SECURE_NOW */
3782         /* not set-id, must be wrapped */
3783     }
3784 #endif /* DOSUID */
3785     (void)validarg;
3786     (void)scriptname;
3787 }
3788
3789 STATIC void
3790 S_find_beginning(pTHX)
3791 {
3792     register char *s;
3793     register const char *s2;
3794 #ifdef MACOS_TRADITIONAL
3795     int maclines = 0;
3796 #endif
3797
3798     /* skip forward in input to the real script? */
3799
3800     forbid_setid("-x");
3801 #ifdef MACOS_TRADITIONAL
3802     /* Since the Mac OS does not honor #! arguments for us, we do it ourselves */
3803
3804     while (PL_doextract || gMacPerl_AlwaysExtract) {
3805         if ((s = sv_gets(PL_linestr, PL_rsfp, 0)) == Nullch) {
3806             if (!gMacPerl_AlwaysExtract)
3807                 Perl_croak(aTHX_ "No Perl script found in input\n");
3808
3809             if (PL_doextract)                   /* require explicit override ? */
3810                 if (!OverrideExtract(PL_origfilename))
3811                     Perl_croak(aTHX_ "User aborted script\n");
3812                 else
3813                     PL_doextract = FALSE;
3814
3815             /* Pater peccavi, file does not have #! */
3816             PerlIO_rewind(PL_rsfp);
3817
3818             break;
3819         }
3820 #else
3821     while (PL_doextract) {
3822         if ((s = sv_gets(PL_linestr, PL_rsfp, 0)) == Nullch)
3823             Perl_croak(aTHX_ "No Perl script found in input\n");
3824 #endif
3825         s2 = s;
3826         if (*s == '#' && s[1] == '!' && ((s = instr(s,"perl")) || (s = instr(s2,"PERL")))) {
3827             PerlIO_ungetc(PL_rsfp, '\n');               /* to keep line count right */
3828             PL_doextract = FALSE;
3829             while (*s && !(isSPACE (*s) || *s == '#')) s++;
3830             s2 = s;
3831             while (*s == ' ' || *s == '\t') s++;
3832             if (*s++ == '-') {
3833                 while (isDIGIT(s2[-1]) || s2[-1] == '-' || s2[-1] == '.'
3834                        || s2[-1] == '_') s2--;
3835                 if (strnEQ(s2-4,"perl",4))
3836                     /*SUPPRESS 530*/
3837                     while ((s = moreswitches(s)))
3838                         ;
3839             }
3840 #ifdef MACOS_TRADITIONAL
3841             /* We are always searching for the #!perl line in MacPerl,
3842              * so if we find it, still keep the line count correct
3843              * by counting lines we already skipped over
3844              */
3845             for (; maclines > 0 ; maclines--)
3846                 PerlIO_ungetc(PL_rsfp, '\n');
3847
3848             break;
3849
3850         /* gMacPerl_AlwaysExtract is false in MPW tool */
3851         } else if (gMacPerl_AlwaysExtract) {
3852             ++maclines;
3853 #endif
3854         }
3855     }
3856 }
3857
3858
3859 STATIC void
3860 S_init_ids(pTHX)
3861 {
3862     PL_uid = PerlProc_getuid();
3863     PL_euid = PerlProc_geteuid();
3864     PL_gid = PerlProc_getgid();
3865     PL_egid = PerlProc_getegid();
3866 #ifdef VMS
3867     PL_uid |= PL_gid << 16;
3868     PL_euid |= PL_egid << 16;
3869 #endif
3870     /* Should not happen: */
3871     CHECK_MALLOC_TAINT(PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
3872     PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
3873     /* BUG */
3874     /* PSz 27 Feb 04
3875      * Should go by suidscript, not uid!=euid: why disallow
3876      * system("ls") in scripts run from setuid things?
3877      * Or, is this run before we check arguments and set suidscript?
3878      * What about SETUID_SCRIPTS_ARE_SECURE_NOW: could we use fdscript then?
3879      * (We never have suidscript, can we be sure to have fdscript?)
3880      * Or must then go by UID checks? See comments in forbid_setid also.
3881      */
3882 }
3883
3884 /* This is used very early in the lifetime of the program,
3885  * before even the options are parsed, so PL_tainting has
3886  * not been initialized properly.  */
3887 bool
3888 Perl_doing_taint(int argc, char *argv[], char *envp[])
3889 {
3890 #ifndef PERL_IMPLICIT_SYS
3891     /* If we have PERL_IMPLICIT_SYS we can't call getuid() et alia
3892      * before we have an interpreter-- and the whole point of this
3893      * function is to be called at such an early stage.  If you are on
3894      * a system with PERL_IMPLICIT_SYS but you do have a concept of
3895      * "tainted because running with altered effective ids', you'll
3896      * have to add your own checks somewhere in here.  The two most
3897      * known samples of 'implicitness' are Win32 and NetWare, neither
3898      * of which has much of concept of 'uids'. */
3899     int uid  = PerlProc_getuid();
3900     int euid = PerlProc_geteuid();
3901     int gid  = PerlProc_getgid();
3902     int egid = PerlProc_getegid();
3903     (void)envp;
3904
3905 #ifdef VMS
3906     uid  |=  gid << 16;
3907     euid |= egid << 16;
3908 #endif
3909     if (uid && (euid != uid || egid != gid))
3910         return 1;
3911 #endif /* !PERL_IMPLICIT_SYS */
3912     /* This is a really primitive check; environment gets ignored only
3913      * if -T are the first chars together; otherwise one gets
3914      *  "Too late" message. */
3915     if ( argc > 1 && argv[1][0] == '-'
3916          && (argv[1][1] == 't' || argv[1][1] == 'T') )
3917         return 1;
3918     return 0;
3919 }
3920
3921 STATIC void
3922 S_forbid_setid(pTHX_ const char *s)
3923 {
3924 #ifdef SETUID_SCRIPTS_ARE_SECURE_NOW
3925     if (PL_euid != PL_uid)
3926         Perl_croak(aTHX_ "No %s allowed while running setuid", s);
3927     if (PL_egid != PL_gid)
3928         Perl_croak(aTHX_ "No %s allowed while running setgid", s);
3929 #endif /* SETUID_SCRIPTS_ARE_SECURE_NOW */
3930     /* PSz 29 Feb 04
3931      * Checks for UID/GID above "wrong": why disallow
3932      *   perl -e 'print "Hello\n"'
3933      * from within setuid things?? Simply drop them: replaced by
3934      * fdscript/suidscript and #ifdef IAMSUID checks below.
3935      *
3936      * This may be too late for command-line switches. Will catch those on
3937      * the #! line, after finding the script name and setting up
3938      * fdscript/suidscript. Note that suidperl does not get around to
3939      * parsing (and checking) the switches on the #! line, but checks that
3940      * the two sets are identical.
3941      *
3942      * With SETUID_SCRIPTS_ARE_SECURE_NOW, could we use fdscript, also or
3943      * instead, or would that be "too late"? (We never have suidscript, can
3944      * we be sure to have fdscript?)
3945      *
3946      * Catch things with suidscript (in descendant of suidperl), even with
3947      * right UID/GID. Was already checked in suidperl, with #ifdef IAMSUID,
3948      * below; but I am paranoid.
3949      *
3950      * Also see comments about root running a setuid script, elsewhere.
3951      */
3952     if (PL_suidscript >= 0)
3953         Perl_croak(aTHX_ "No %s allowed with (suid) fdscript", s);
3954 #ifdef IAMSUID
3955     /* PSz 11 Nov 03  Catch it in suidperl, always! */
3956     Perl_croak(aTHX_ "No %s allowed in suidperl", s);
3957 #endif /* IAMSUID */
3958 }
3959
3960 void
3961 Perl_init_debugger(pTHX)
3962 {
3963     HV *ostash = PL_curstash;
3964
3965     PL_curstash = PL_debstash;
3966     PL_dbargs = GvAV(gv_AVadd((gv_fetchpv("DB::args", GV_ADDMULTI, SVt_PVAV))));
3967     AvREAL_off(PL_dbargs);
3968     PL_DBgv = gv_fetchpv("DB::DB", GV_ADDMULTI, SVt_PVGV);
3969     PL_DBline = gv_fetchpv("DB::dbline", GV_ADDMULTI, SVt_PVAV);
3970     PL_DBsub = gv_HVadd(gv_fetchpv("DB::sub", GV_ADDMULTI, SVt_PVHV));
3971     PL_DBsingle = GvSV((gv_fetchpv("DB::single", GV_ADDMULTI, SVt_PV)));
3972     sv_setiv(PL_DBsingle, 0);
3973     PL_DBtrace = GvSV((gv_fetchpv("DB::trace", GV_ADDMULTI, SVt_PV)));
3974     sv_setiv(PL_DBtrace, 0);
3975     PL_DBsignal = GvSV((gv_fetchpv("DB::signal", GV_ADDMULTI, SVt_PV)));
3976     sv_setiv(PL_DBsignal, 0);
3977     PL_DBassertion = GvSV((gv_fetchpv("DB::assertion", GV_ADDMULTI, SVt_PV)));
3978     sv_setiv(PL_DBassertion, 0);
3979     PL_curstash = ostash;
3980 }
3981
3982 #ifndef STRESS_REALLOC
3983 #define REASONABLE(size) (size)
3984 #else
3985 #define REASONABLE(size) (1) /* unreasonable */
3986 #endif
3987
3988 void
3989 Perl_init_stacks(pTHX)
3990 {
3991     /* start with 128-item stack and 8K cxstack */
3992     PL_curstackinfo = new_stackinfo(REASONABLE(128),
3993                                  REASONABLE(8192/sizeof(PERL_CONTEXT) - 1));
3994     PL_curstackinfo->si_type = PERLSI_MAIN;
3995     PL_curstack = PL_curstackinfo->si_stack;
3996     PL_mainstack = PL_curstack;         /* remember in case we switch stacks */
3997
3998     PL_stack_base = AvARRAY(PL_curstack);
3999     PL_stack_sp = PL_stack_base;
4000     PL_stack_max = PL_stack_base + AvMAX(PL_curstack);
4001
4002     New(50,PL_tmps_stack,REASONABLE(128),SV*);
4003     PL_tmps_floor = -1;
4004     PL_tmps_ix = -1;
4005     PL_tmps_max = REASONABLE(128);
4006
4007     New(54,PL_markstack,REASONABLE(32),I32);
4008     PL_markstack_ptr = PL_markstack;
4009     PL_markstack_max = PL_markstack + REASONABLE(32);
4010
4011     SET_MARK_OFFSET;
4012
4013     New(54,PL_scopestack,REASONABLE(32),I32);
4014     PL_scopestack_ix = 0;
4015     PL_scopestack_max = REASONABLE(32);
4016
4017     New(54,PL_savestack,REASONABLE(128),ANY);
4018     PL_savestack_ix = 0;
4019     PL_savestack_max = REASONABLE(128);
4020 }
4021
4022 #undef REASONABLE
4023
4024 STATIC void
4025 S_nuke_stacks(pTHX)
4026 {
4027     while (PL_curstackinfo->si_next)
4028         PL_curstackinfo = PL_curstackinfo->si_next;
4029     while (PL_curstackinfo) {
4030         PERL_SI *p = PL_curstackinfo->si_prev;
4031         /* curstackinfo->si_stack got nuked by sv_free_arenas() */
4032         Safefree(PL_curstackinfo->si_cxstack);
4033         Safefree(PL_curstackinfo);
4034         PL_curstackinfo = p;
4035     }
4036     Safefree(PL_tmps_stack);
4037     Safefree(PL_markstack);
4038     Safefree(PL_scopestack);
4039     Safefree(PL_savestack);
4040 }
4041
4042 STATIC void
4043 S_init_lexer(pTHX)
4044 {
4045     PerlIO *tmpfp;
4046     tmpfp = PL_rsfp;
4047     PL_rsfp = Nullfp;
4048     lex_start(PL_linestr);
4049     PL_rsfp = tmpfp;
4050     PL_subname = newSVpvn("main",4);
4051 }
4052
4053 STATIC void
4054 S_init_predump_symbols(pTHX)
4055 {
4056     GV *tmpgv;
4057     IO *io;
4058
4059     sv_setpvn(get_sv("\"", TRUE), " ", 1);
4060     PL_stdingv = gv_fetchpv("STDIN",TRUE, SVt_PVIO);
4061     GvMULTI_on(PL_stdingv);
4062     io = GvIOp(PL_stdingv);
4063     IoTYPE(io) = IoTYPE_RDONLY;
4064     IoIFP(io) = PerlIO_stdin();
4065     tmpgv = gv_fetchpv("stdin",TRUE, SVt_PV);
4066     GvMULTI_on(tmpgv);
4067     GvIOp(tmpgv) = (IO*)SvREFCNT_inc(io);
4068
4069     tmpgv = gv_fetchpv("STDOUT",TRUE, SVt_PVIO);
4070     GvMULTI_on(tmpgv);
4071     io = GvIOp(tmpgv);
4072     IoTYPE(io) = IoTYPE_WRONLY;
4073     IoOFP(io) = IoIFP(io) = PerlIO_stdout();
4074     setdefout(tmpgv);
4075     tmpgv = gv_fetchpv("stdout",TRUE, SVt_PV);
4076     GvMULTI_on(tmpgv);
4077     GvIOp(tmpgv) = (IO*)SvREFCNT_inc(io);
4078
4079     PL_stderrgv = gv_fetchpv("STDERR",TRUE, SVt_PVIO);
4080     GvMULTI_on(PL_stderrgv);
4081     io = GvIOp(PL_stderrgv);
4082     IoTYPE(io) = IoTYPE_WRONLY;
4083     IoOFP(io) = IoIFP(io) = PerlIO_stderr();
4084     tmpgv = gv_fetchpv("stderr",TRUE, SVt_PV);
4085     GvMULTI_on(tmpgv);
4086     GvIOp(tmpgv) = (IO*)SvREFCNT_inc(io);
4087
4088     PL_statname = NEWSV(66,0);          /* last filename we did stat on */
4089
4090     if (PL_osname)
4091         Safefree(PL_osname);
4092     PL_osname = savepv(OSNAME);
4093 }
4094
4095 void
4096 Perl_init_argv_symbols(pTHX_ register int argc, register char **argv)
4097 {
4098     char *s;
4099     argc--,argv++;      /* skip name of script */
4100     if (PL_doswitches) {
4101         for (; argc > 0 && **argv == '-'; argc--,argv++) {
4102             if (!argv[0][1])
4103                 break;
4104             if (argv[0][1] == '-' && !argv[0][2]) {
4105                 argc--,argv++;
4106                 break;
4107             }
4108             if ((s = strchr(argv[0], '='))) {
4109                 *s++ = '\0';
4110                 sv_setpv(GvSV(gv_fetchpv(argv[0]+1,TRUE, SVt_PV)),s);
4111             }
4112             else
4113                 sv_setiv(GvSV(gv_fetchpv(argv[0]+1,TRUE, SVt_PV)),1);
4114         }
4115     }
4116     if ((PL_argvgv = gv_fetchpv("ARGV",TRUE, SVt_PVAV))) {
4117         GvMULTI_on(PL_argvgv);
4118         (void)gv_AVadd(PL_argvgv);
4119         av_clear(GvAVn(PL_argvgv));
4120         for (; argc > 0; argc--,argv++) {
4121             SV *sv = newSVpv(argv[0],0);
4122             av_push(GvAVn(PL_argvgv),sv);
4123             if (!(PL_unicode & PERL_UNICODE_LOCALE_FLAG) || PL_utf8locale) {
4124                  if (PL_unicode & PERL_UNICODE_ARGV_FLAG)
4125                       SvUTF8_on(sv);
4126             }
4127             if (PL_unicode & PERL_UNICODE_WIDESYSCALLS_FLAG) /* Sarathy? */
4128                  (void)sv_utf8_decode(sv);
4129         }
4130     }
4131 }
4132
4133 STATIC void
4134 S_init_postdump_symbols(pTHX_ register int argc, register char **argv, register char **env)
4135 {
4136     dVAR;
4137     GV* tmpgv;
4138
4139     PL_toptarget = NEWSV(0,0);
4140     sv_upgrade(PL_toptarget, SVt_PVFM);
4141     sv_setpvn(PL_toptarget, "", 0);
4142     PL_bodytarget = NEWSV(0,0);
4143     sv_upgrade(PL_bodytarget, SVt_PVFM);
4144     sv_setpvn(PL_bodytarget, "", 0);
4145     PL_formtarget = PL_bodytarget;
4146
4147     TAINT;
4148
4149     init_argv_symbols(argc,argv);
4150
4151     if ((tmpgv = gv_fetchpv("0",TRUE, SVt_PV))) {
4152 #ifdef MACOS_TRADITIONAL
4153         /* $0 is not majick on a Mac */
4154         sv_setpv(GvSV(tmpgv),MacPerl_MPWFileName(PL_origfilename));
4155 #else
4156         sv_setpv(GvSV(tmpgv),PL_origfilename);
4157         magicname("0", "0", 1);
4158 #endif
4159     }
4160     if ((PL_envgv = gv_fetchpv("ENV",TRUE, SVt_PVHV))) {
4161         HV *hv;
4162         GvMULTI_on(PL_envgv);
4163         hv = GvHVn(PL_envgv);
4164         hv_magic(hv, Nullgv, PERL_MAGIC_env);
4165 #ifndef PERL_MICRO
4166 #ifdef USE_ENVIRON_ARRAY
4167         /* Note that if the supplied env parameter is actually a copy
4168            of the global environ then it may now point to free'd memory
4169            if the environment has been modified since. To avoid this
4170            problem we treat env==NULL as meaning 'use the default'
4171         */
4172         if (!env)
4173             env = environ;
4174         if (env != environ
4175 #  ifdef USE_ITHREADS
4176             && PL_curinterp == aTHX
4177 #  endif
4178            )
4179         {
4180             environ[0] = Nullch;
4181         }
4182         if (env) {
4183           char** origenv = environ;
4184           char *s;
4185           SV *sv;
4186           for (; *env; env++) {
4187             if (!(s = strchr(*env,'=')) || s == *env)
4188                 continue;
4189 #if defined(MSDOS) && !defined(DJGPP)
4190             *s = '\0';
4191             (void)strupr(*env);
4192             *s = '=';
4193 #endif
4194             sv = newSVpv(s+1, 0);
4195             (void)hv_store(hv, *env, s - *env, sv, 0);
4196             if (env != environ)
4197                 mg_set(sv);
4198             if (origenv != environ) {
4199               /* realloc has shifted us */
4200               env = (env - origenv) + environ;
4201               origenv = environ;
4202             }
4203           }
4204       }
4205 #endif /* USE_ENVIRON_ARRAY */
4206 #endif /* !PERL_MICRO */
4207     }
4208     TAINT_NOT;
4209     if ((tmpgv = gv_fetchpv("$",TRUE, SVt_PV))) {
4210         SvREADONLY_off(GvSV(tmpgv));
4211         sv_setiv(GvSV(tmpgv), (IV)PerlProc_getpid());
4212         SvREADONLY_on(GvSV(tmpgv));
4213     }
4214 #ifdef THREADS_HAVE_PIDS
4215     PL_ppid = (IV)getppid();
4216 #endif
4217
4218     /* touch @F array to prevent spurious warnings 20020415 MJD */
4219     if (PL_minus_a) {
4220       (void) get_av("main::F", TRUE | GV_ADDMULTI);
4221     }
4222     /* touch @- and @+ arrays to prevent spurious warnings 20020415 MJD */
4223     (void) get_av("main::-", TRUE | GV_ADDMULTI);
4224     (void) get_av("main::+", TRUE | GV_ADDMULTI);
4225 }
4226
4227 STATIC void
4228 S_init_perllib(pTHX)
4229 {
4230     char *s;
4231     if (!PL_tainting) {
4232 #ifndef VMS
4233         s = PerlEnv_getenv("PERL5LIB");
4234         if (s)
4235             incpush(s, TRUE, TRUE, TRUE, FALSE);
4236         else
4237             incpush(PerlEnv_getenv("PERLLIB"), FALSE, FALSE, TRUE, FALSE);
4238 #else /* VMS */
4239         /* Treat PERL5?LIB as a possible search list logical name -- the
4240          * "natural" VMS idiom for a Unix path string.  We allow each
4241          * element to be a set of |-separated directories for compatibility.
4242          */
4243         char buf[256];
4244         int idx = 0;
4245         if (my_trnlnm("PERL5LIB",buf,0))
4246             do { incpush(buf,TRUE,TRUE,TRUE,FALSE); } while (my_trnlnm("PERL5LIB",buf,++idx));
4247         else
4248             while (my_trnlnm("PERLLIB",buf,idx++)) incpush(buf,FALSE,FALSE,TRUE,FALSE);
4249 #endif /* VMS */
4250     }
4251
4252 /* Use the ~-expanded versions of APPLLIB (undocumented),
4253     ARCHLIB PRIVLIB SITEARCH SITELIB VENDORARCH and VENDORLIB
4254 */
4255 #ifdef APPLLIB_EXP
4256     incpush(APPLLIB_EXP, TRUE, TRUE, TRUE, TRUE);
4257 #endif
4258
4259 #ifdef ARCHLIB_EXP
4260     incpush(ARCHLIB_EXP, FALSE, FALSE, TRUE, TRUE);
4261 #endif
4262 #ifdef MACOS_TRADITIONAL
4263     {
4264         Stat_t tmpstatbuf;
4265         SV * privdir = NEWSV(55, 0);
4266         char * macperl = PerlEnv_getenv("MACPERL");
4267
4268         if (!macperl)
4269             macperl = "";
4270
4271         Perl_sv_setpvf(aTHX_ privdir, "%slib:", macperl);
4272         if (PerlLIO_stat(SvPVX(privdir), &tmpstatbuf) >= 0 && S_ISDIR(tmpstatbuf.st_mode))
4273             incpush(SvPVX(privdir), TRUE, FALSE, TRUE, FALSE);
4274         Perl_sv_setpvf(aTHX_ privdir, "%ssite_perl:", macperl);
4275         if (PerlLIO_stat(SvPVX(privdir), &tmpstatbuf) >= 0 && S_ISDIR(tmpstatbuf.st_mode))
4276             incpush(SvPVX(privdir), TRUE, FALSE, TRUE, FALSE);
4277
4278         SvREFCNT_dec(privdir);
4279     }
4280     if (!PL_tainting)
4281         incpush(":", FALSE, FALSE, TRUE, FALSE);
4282 #else
4283 #ifndef PRIVLIB_EXP
4284 #  define PRIVLIB_EXP "/usr/local/lib/perl5:/usr/local/lib/perl"
4285 #endif
4286 #if defined(WIN32)
4287     incpush(PRIVLIB_EXP, TRUE, FALSE, TRUE, TRUE);
4288 #else
4289     incpush(PRIVLIB_EXP, FALSE, FALSE, TRUE, TRUE);
4290 #endif
4291
4292 #ifdef SITEARCH_EXP
4293     /* sitearch is always relative to sitelib on Windows for
4294      * DLL-based path intuition to work correctly */
4295 #  if !defined(WIN32)
4296     incpush(SITEARCH_EXP, FALSE, FALSE, TRUE, TRUE);
4297 #  endif
4298 #endif
4299
4300 #ifdef SITELIB_EXP
4301 #  if defined(WIN32)
4302     /* this picks up sitearch as well */
4303     incpush(SITELIB_EXP, TRUE, FALSE, TRUE, TRUE);
4304 #  else
4305     incpush(SITELIB_EXP, FALSE, FALSE, TRUE, TRUE);
4306 #  endif
4307 #endif
4308
4309 #ifdef SITELIB_STEM /* Search for version-specific dirs below here */
4310     incpush(SITELIB_STEM, FALSE, TRUE, TRUE, TRUE);
4311 #endif
4312
4313 #ifdef PERL_VENDORARCH_EXP
4314     /* vendorarch is always relative to vendorlib on Windows for
4315      * DLL-based path intuition to work correctly */
4316 #  if !defined(WIN32)
4317     incpush(PERL_VENDORARCH_EXP, FALSE, FALSE, TRUE, TRUE);
4318 #  endif
4319 #endif
4320
4321 #ifdef PERL_VENDORLIB_EXP
4322 #  if defined(WIN32)
4323     incpush(PERL_VENDORLIB_EXP, TRUE, FALSE, TRUE, TRUE);       /* this picks up vendorarch as well */
4324 #  else
4325     incpush(PERL_VENDORLIB_EXP, FALSE, FALSE, TRUE, TRUE);
4326 #  endif
4327 #endif
4328
4329 #ifdef PERL_VENDORLIB_STEM /* Search for version-specific dirs below here */
4330     incpush(PERL_VENDORLIB_STEM, FALSE, TRUE, TRUE, TRUE);
4331 #endif
4332
4333 #ifdef PERL_OTHERLIBDIRS
4334     incpush(PERL_OTHERLIBDIRS, TRUE, TRUE, TRUE, TRUE);
4335 #endif
4336
4337     if (!PL_tainting)
4338         incpush(".", FALSE, FALSE, TRUE, FALSE);
4339 #endif /* MACOS_TRADITIONAL */
4340 }
4341
4342 #if defined(DOSISH) || defined(EPOC) || defined(SYMBIAN)
4343 #    define PERLLIB_SEP ';'
4344 #else
4345 #  if defined(VMS)
4346 #    define PERLLIB_SEP '|'
4347 #  else
4348 #    if defined(MACOS_TRADITIONAL)
4349 #      define PERLLIB_SEP ','
4350 #    else
4351 #      define PERLLIB_SEP ':'
4352 #    endif
4353 #  endif
4354 #endif
4355 #ifndef PERLLIB_MANGLE
4356 #  define PERLLIB_MANGLE(s,n) (s)
4357 #endif
4358
4359 /* Push a directory onto @INC if it exists.
4360    Generate a new SV if we do this, to save needing to copy the SV we push
4361    onto @INC  */
4362 STATIC SV *
4363 S_incpush_if_exists(pTHX_ SV *dir)
4364 {
4365     Stat_t tmpstatbuf;
4366     if (PerlLIO_stat(SvPVX(dir), &tmpstatbuf) >= 0 &&
4367         S_ISDIR(tmpstatbuf.st_mode)) {
4368         av_push(GvAVn(PL_incgv), dir);
4369         dir = NEWSV(0,0);
4370     }
4371     return dir;
4372 }
4373
4374 STATIC void
4375 S_incpush(pTHX_ const char *dir, bool addsubdirs, bool addoldvers, bool usesep,
4376           bool canrelocate)
4377 {
4378     SV *subdir = Nullsv;
4379     const char *p = dir;
4380
4381     if (!p || !*p)
4382         return;
4383
4384     if (addsubdirs || addoldvers) {
4385         subdir = NEWSV(0,0);
4386     }
4387
4388     /* Break at all separators */
4389     while (p && *p) {
4390         SV *libdir = NEWSV(55,0);
4391         const char *s;
4392
4393         /* skip any consecutive separators */
4394         if (usesep) {
4395             while ( *p == PERLLIB_SEP ) {
4396                 /* Uncomment the next line for PATH semantics */
4397                 /* av_push(GvAVn(PL_incgv), newSVpvn(".", 1)); */
4398                 p++;
4399             }
4400         }
4401
4402         if ( usesep && (s = strchr(p, PERLLIB_SEP)) != Nullch ) {
4403             sv_setpvn(libdir, PERLLIB_MANGLE(p, (STRLEN)(s - p)),
4404                       (STRLEN)(s - p));
4405             p = s + 1;
4406         }
4407         else {
4408             sv_setpv(libdir, PERLLIB_MANGLE(p, 0));
4409             p = Nullch; /* break out */
4410         }
4411 #ifdef MACOS_TRADITIONAL
4412         if (!strchr(SvPVX(libdir), ':')) {
4413             char buf[256];
4414
4415             sv_setpv(libdir, MacPerl_CanonDir(SvPVX(libdir), buf, 0));
4416         }
4417         if (SvPVX(libdir)[SvCUR(libdir)-1] != ':')
4418             sv_catpv(libdir, ":");
4419 #endif
4420
4421         /* Do the if() outside the #ifdef to avoid warnings about an unused
4422            parameter.  */
4423         if (canrelocate) {
4424 #ifdef PERL_RELOCATABLE_INC
4425         /*
4426          * Relocatable include entries are marked with a leading .../
4427          *
4428          * The algorithm is
4429          * 0: Remove that leading ".../"
4430          * 1: Remove trailing executable name (anything after the last '/')
4431          *    from the perl path to give a perl prefix
4432          * Then
4433          * While the @INC element starts "../" and the prefix ends with a real
4434          * directory (ie not . or ..) chop that real directory off the prefix
4435          * and the leading "../" from the @INC element. ie a logical "../"
4436          * cleanup
4437          * Finally concatenate the prefix and the remainder of the @INC element
4438          * The intent is that /usr/local/bin/perl and .../../lib/perl5
4439          * generates /usr/local/lib/perl5
4440          */
4441             char *libpath = SvPVX(libdir);
4442             STRLEN libpath_len = SvCUR(libdir);
4443             if (libpath_len >= 4 && memEQ (libpath, ".../", 4)) {
4444                 /* Game on!  */
4445                 SV *caret_X = get_sv("\030", 0);
4446                 /* Going to use the SV just as a scratch buffer holding a C
4447                    string:  */
4448                 SV *prefix_sv;
4449                 char *prefix;
4450                 char *lastslash;
4451
4452                 /* $^X is *the* source of taint if tainting is on, hence
4453                    SvPOK() won't be true.  */
4454                 assert(caret_X);
4455                 assert(SvPOKp(caret_X));
4456                 prefix_sv = newSVpvn(SvPVX(caret_X), SvCUR(caret_X));
4457                 /* Firstly take off the leading .../
4458                    If all else fail we'll do the paths relative to the current
4459                    directory.  */
4460                 sv_chop(libdir, libpath + 4);
4461                 /* Don't use SvPV as we're intentionally bypassing taining,
4462                    mortal copies that the mg_get of tainting creates, and
4463                    corruption that seems to come via the save stack.
4464                    I guess that the save stack isn't correctly set up yet.  */
4465                 libpath = SvPVX(libdir);
4466                 libpath_len = SvCUR(libdir);
4467
4468                 /* This would work more efficiently with memrchr, but as it's
4469                    only a GNU extension we'd need to probe for it and
4470                    implement our own. Not hard, but maybe not worth it?  */
4471
4472                 prefix = SvPVX(prefix_sv);
4473                 lastslash = strrchr(prefix, '/');
4474
4475                 /* First time in with the *lastslash = '\0' we just wipe off
4476                    the trailing /perl from (say) /usr/foo/bin/perl
4477                 */
4478                 if (lastslash) {
4479                     SV *tempsv;
4480                     while ((*lastslash = '\0'), /* Do that, come what may.  */
4481                            (libpath_len >= 3 && memEQ(libpath, "../", 3)
4482                             && (lastslash = strrchr(prefix, '/')))) {
4483                         if (lastslash[1] == '\0'
4484                             || (lastslash[1] == '.'
4485                                 && (lastslash[2] == '/' /* ends "/."  */
4486                                     || (lastslash[2] == '/'
4487                                         && lastslash[3] == '/' /* or "/.."  */
4488                                         )))) {
4489                             /* Prefix ends "/" or "/." or "/..", any of which
4490                                are fishy, so don't do any more logical cleanup.
4491                             */
4492                             break;
4493                         }
4494                         /* Remove leading "../" from path  */
4495                         libpath += 3;
4496                         libpath_len -= 3;
4497                         /* Next iteration round the loop removes the last
4498                            directory name from prefix by writing a '\0' in
4499                            the while clause.  */
4500                     }
4501                     /* prefix has been terminated with a '\0' to the correct
4502                        length. libpath points somewhere into the libdir SV.
4503                        We need to join the 2 with '/' and drop the result into
4504                        libdir.  */
4505                     tempsv = Perl_newSVpvf(aTHX_ "%s/%s", prefix, libpath);
4506                     SvREFCNT_dec(libdir);
4507                     /* And this is the new libdir.  */
4508                     libdir = tempsv;
4509                     if (PL_tainting &&
4510                         (PL_uid != PL_euid || PL_gid != PL_egid)) {
4511                         /* Need to taint reloccated paths if running set ID  */
4512                         SvTAINTED_on(libdir);
4513                     }
4514                 }
4515                 SvREFCNT_dec(prefix_sv);
4516             }
4517 #endif
4518         }
4519         /*
4520          * BEFORE pushing libdir onto @INC we may first push version- and
4521          * archname-specific sub-directories.
4522          */
4523         if (addsubdirs || addoldvers) {
4524 #ifdef PERL_INC_VERSION_LIST
4525             /* Configure terminates PERL_INC_VERSION_LIST with a NULL */
4526             const char *incverlist[] = { PERL_INC_VERSION_LIST };
4527             const char **incver;
4528 #endif
4529 #ifdef VMS
4530             char *unix;
4531             STRLEN len;
4532
4533             if ((unix = tounixspec_ts(SvPV(libdir,len),Nullch)) != Nullch) {
4534                 len = strlen(unix);
4535                 while (unix[len-1] == '/') len--;  /* Cosmetic */
4536                 sv_usepvn(libdir,unix,len);
4537             }
4538             else
4539                 PerlIO_printf(Perl_error_log,
4540                               "Failed to unixify @INC element \"%s\"\n",
4541                               SvPV(libdir,len));
4542 #endif
4543             if (addsubdirs) {
4544 #ifdef MACOS_TRADITIONAL
4545 #define PERL_AV_SUFFIX_FMT      ""
4546 #define PERL_ARCH_FMT           "%s:"
4547 #define PERL_ARCH_FMT_PATH      PERL_FS_VER_FMT PERL_AV_SUFFIX_FMT
4548 #else
4549 #define PERL_AV_SUFFIX_FMT      "/"
4550 #define PERL_ARCH_FMT           "/%s"
4551 #define PERL_ARCH_FMT_PATH      PERL_AV_SUFFIX_FMT PERL_FS_VER_FMT
4552 #endif
4553                 /* .../version/archname if -d .../version/archname */
4554                 Perl_sv_setpvf(aTHX_ subdir, "%"SVf PERL_ARCH_FMT_PATH PERL_ARCH_FMT,
4555                                 libdir,
4556                                (int)PERL_REVISION, (int)PERL_VERSION,
4557                                (int)PERL_SUBVERSION, ARCHNAME);
4558                 subdir = S_incpush_if_exists(aTHX_ subdir);
4559
4560                 /* .../version if -d .../version */
4561                 Perl_sv_setpvf(aTHX_ subdir, "%"SVf PERL_ARCH_FMT_PATH, libdir,
4562                                (int)PERL_REVISION, (int)PERL_VERSION,
4563                                (int)PERL_SUBVERSION);
4564                 subdir = S_incpush_if_exists(aTHX_ subdir);
4565
4566                 /* .../archname if -d .../archname */
4567                 Perl_sv_setpvf(aTHX_ subdir, "%"SVf PERL_ARCH_FMT, libdir, ARCHNAME);
4568                 subdir = S_incpush_if_exists(aTHX_ subdir);
4569
4570             }
4571
4572 #ifdef PERL_INC_VERSION_LIST
4573             if (addoldvers) {
4574                 for (incver = incverlist; *incver; incver++) {
4575                     /* .../xxx if -d .../xxx */
4576                     Perl_sv_setpvf(aTHX_ subdir, "%"SVf PERL_ARCH_FMT, libdir, *incver);
4577                     subdir = S_incpush_if_exists(aTHX_ subdir);
4578                 }
4579             }
4580 #endif
4581         }
4582
4583         /* finally push this lib directory on the end of @INC */
4584         av_push(GvAVn(PL_incgv), libdir);
4585     }
4586     if (subdir) {
4587         assert (SvREFCNT(subdir) == 1);
4588         SvREFCNT_dec(subdir);
4589     }
4590 }
4591
4592 #ifdef USE_5005THREADS
4593 STATIC struct perl_thread *
4594 S_init_main_thread(pTHX)
4595 {
4596 #if !defined(PERL_IMPLICIT_CONTEXT)
4597     struct perl_thread *thr;
4598 #endif
4599     XPV *xpv;
4600
4601     Newz(53, thr, 1, struct perl_thread);
4602     PL_curcop = &PL_compiling;
4603     thr->interp = PERL_GET_INTERP;
4604     thr->cvcache = newHV();
4605     thr->threadsv = newAV();
4606     /* thr->threadsvp is set when find_threadsv is called */
4607     thr->specific = newAV();
4608     thr->flags = THRf_R_JOINABLE;
4609     MUTEX_INIT(&thr->mutex);
4610     /* Handcraft thrsv similarly to mess_sv */
4611     New(53, PL_thrsv, 1, SV);
4612     Newz(53, xpv, 1, XPV);
4613     SvFLAGS(PL_thrsv) = SVt_PV;
4614     SvANY(PL_thrsv) = (void*)xpv;
4615     SvREFCNT(PL_thrsv) = 1 << 30;       /* practically infinite */
4616     SvPV_set(PL_thrsvr, (char*)thr);
4617     SvCUR_set(PL_thrsv, sizeof(thr));
4618     SvLEN_set(PL_thrsv, sizeof(thr));
4619     *SvEND(PL_thrsv) = '\0';    /* in the trailing_nul field */
4620     thr->oursv = PL_thrsv;
4621     PL_chopset = " \n-";
4622     PL_dumpindent = 4;
4623
4624     MUTEX_LOCK(&PL_threads_mutex);
4625     PL_nthreads++;
4626     thr->tid = 0;
4627     thr->next = thr;
4628     thr->prev = thr;
4629     thr->thr_done = 0;
4630     MUTEX_UNLOCK(&PL_threads_mutex);
4631
4632 #ifdef HAVE_THREAD_INTERN
4633     Perl_init_thread_intern(thr);
4634 #endif
4635
4636 #ifdef SET_THREAD_SELF
4637     SET_THREAD_SELF(thr);
4638 #else
4639     thr->self = pthread_self();
4640 #endif /* SET_THREAD_SELF */
4641     PERL_SET_THX(thr);
4642
4643     /*
4644      * These must come after the thread self setting
4645      * because sv_setpvn does SvTAINT and the taint
4646      * fields thread selfness being set.
4647      */
4648     PL_toptarget = NEWSV(0,0);
4649     sv_upgrade(PL_toptarget, SVt_PVFM);
4650     sv_setpvn(PL_toptarget, "", 0);
4651     PL_bodytarget = NEWSV(0,0);
4652     sv_upgrade(PL_bodytarget, SVt_PVFM);
4653     sv_setpvn(PL_bodytarget, "", 0);
4654     PL_formtarget = PL_bodytarget;
4655     thr->errsv = newSVpvn("", 0);
4656     (void) find_threadsv("@");  /* Ensure $@ is initialised early */
4657
4658     PL_maxscream = -1;
4659     PL_peepp = MEMBER_TO_FPTR(Perl_peep);
4660     PL_regcompp = MEMBER_TO_FPTR(Perl_pregcomp);
4661     PL_regexecp = MEMBER_TO_FPTR(Perl_regexec_flags);
4662     PL_regint_start = MEMBER_TO_FPTR(Perl_re_intuit_start);
4663     PL_regint_string = MEMBER_TO_FPTR(Perl_re_intuit_string);
4664     PL_regfree = MEMBER_TO_FPTR(Perl_pregfree);
4665     PL_regindent = 0;
4666     PL_reginterp_cnt = 0;
4667
4668     return thr;
4669 }
4670 #endif /* USE_5005THREADS */
4671
4672 void
4673 Perl_call_list(pTHX_ I32 oldscope, AV *paramList)
4674 {
4675     dVAR;
4676     SV *atsv;
4677     const line_t oldline = CopLINE(PL_curcop);
4678     CV *cv;
4679     STRLEN len;
4680     int ret;
4681     dJMPENV;
4682
4683     while (av_len(paramList) >= 0) {
4684         cv = (CV*)av_shift(paramList);
4685         if (PL_savebegin) {
4686             if (paramList == PL_beginav) {
4687                 /* save PL_beginav for compiler */
4688                 if (! PL_beginav_save)
4689                     PL_beginav_save = newAV();
4690                 av_push(PL_beginav_save, (SV*)cv);
4691             }
4692             else if (paramList == PL_checkav) {
4693                 /* save PL_checkav for compiler */
4694                 if (! PL_checkav_save)
4695                     PL_checkav_save = newAV();
4696                 av_push(PL_checkav_save, (SV*)cv);
4697             }
4698         } else {
4699             SAVEFREESV(cv);
4700         }
4701         JMPENV_PUSH(ret);
4702         switch (ret) {
4703         case 0:
4704             call_list_body(cv);
4705             atsv = ERRSV;
4706             (void)SvPV(atsv, len);
4707             if (len) {
4708                 PL_curcop = &PL_compiling;
4709                 CopLINE_set(PL_curcop, oldline);
4710                 if (paramList == PL_beginav)
4711                     sv_catpv(atsv, "BEGIN failed--compilation aborted");
4712                 else
4713                     Perl_sv_catpvf(aTHX_ atsv,
4714                                    "%s failed--call queue aborted",
4715                                    paramList == PL_checkav ? "CHECK"
4716                                    : paramList == PL_initav ? "INIT"
4717                                    : "END");
4718                 while (PL_scopestack_ix > oldscope)
4719                     LEAVE;
4720                 JMPENV_POP;
4721                 Perl_croak(aTHX_ "%"SVf"", atsv);
4722             }
4723             break;
4724         case 1:
4725             STATUS_ALL_FAILURE;
4726             /* FALL THROUGH */
4727         case 2:
4728             /* my_exit() was called */
4729             while (PL_scopestack_ix > oldscope)
4730                 LEAVE;
4731             FREETMPS;
4732             PL_curstash = PL_defstash;
4733             PL_curcop = &PL_compiling;
4734             CopLINE_set(PL_curcop, oldline);
4735             JMPENV_POP;
4736             if (PL_statusvalue && !(PL_exit_flags & PERL_EXIT_EXPECTED)) {
4737                 if (paramList == PL_beginav)
4738                     Perl_croak(aTHX_ "BEGIN failed--compilation aborted");
4739                 else
4740                     Perl_croak(aTHX_ "%s failed--call queue aborted",
4741                                paramList == PL_checkav ? "CHECK"
4742                                : paramList == PL_initav ? "INIT"
4743                                : "END");
4744             }
4745             my_exit_jump();
4746             /* NOTREACHED */
4747         case 3:
4748             if (PL_restartop) {
4749                 PL_curcop = &PL_compiling;
4750                 CopLINE_set(PL_curcop, oldline);
4751                 JMPENV_JUMP(3);
4752             }
4753             PerlIO_printf(Perl_error_log, "panic: restartop\n");
4754             FREETMPS;
4755             break;
4756         }
4757         JMPENV_POP;
4758     }
4759 }
4760
4761 STATIC void *
4762 S_call_list_body(pTHX_ CV *cv)
4763 {
4764     PUSHMARK(PL_stack_sp);
4765     call_sv((SV*)cv, G_EVAL|G_DISCARD);
4766     return NULL;
4767 }
4768
4769 void
4770 Perl_my_exit(pTHX_ U32 status)
4771 {
4772     DEBUG_S(PerlIO_printf(Perl_debug_log, "my_exit: thread %p, status %lu\n",
4773                           thr, (unsigned long) status));
4774     switch (status) {
4775     case 0:
4776         STATUS_ALL_SUCCESS;
4777         break;
4778     case 1:
4779         STATUS_ALL_FAILURE;
4780         break;
4781     default:
4782         STATUS_NATIVE_SET(status);
4783         break;
4784     }
4785     my_exit_jump();
4786 }
4787
4788 void
4789 Perl_my_failure_exit(pTHX)
4790 {
4791 #ifdef VMS
4792     if (vaxc$errno & 1) {
4793         if (STATUS_NATIVE & 1)          /* fortuitiously includes "-1" */
4794             STATUS_NATIVE_SET(44);
4795     }
4796     else {
4797         if (!vaxc$errno)                /* unlikely */
4798             STATUS_NATIVE_SET(44);
4799         else
4800             STATUS_NATIVE_SET(vaxc$errno);
4801     }
4802 #else
4803     int exitstatus;
4804     if (errno & 255)
4805         STATUS_UNIX_SET(errno);
4806     else {
4807         exitstatus = STATUS_UNIX >> 8;
4808         if (exitstatus & 255)
4809             STATUS_UNIX_SET(exitstatus);
4810         else
4811             STATUS_UNIX_SET(255);
4812     }
4813 #endif
4814     my_exit_jump();
4815 }
4816
4817 STATIC void
4818 S_my_exit_jump(pTHX)
4819 {
4820     dVAR;
4821     register PERL_CONTEXT *cx;
4822     I32 gimme;
4823     SV **newsp;
4824
4825     if (PL_e_script) {
4826         SvREFCNT_dec(PL_e_script);
4827         PL_e_script = Nullsv;
4828     }
4829
4830     POPSTACK_TO(PL_mainstack);
4831     if (cxstack_ix >= 0) {
4832         if (cxstack_ix > 0)
4833             dounwind(0);
4834         POPBLOCK(cx,PL_curpm);
4835         LEAVE;
4836     }
4837
4838     JMPENV_JUMP(2);
4839 }
4840
4841 static I32
4842 read_e_script(pTHX_ int idx, SV *buf_sv, int maxlen)
4843 {
4844     char *p, *nl;
4845     (void)idx;
4846     (void)maxlen;
4847
4848     p  = SvPVX(PL_e_script);
4849     nl = strchr(p, '\n');
4850     nl = (nl) ? nl+1 : SvEND(PL_e_script);
4851     if (nl-p == 0) {
4852         filter_del(read_e_script);
4853         return 0;
4854     }
4855     sv_catpvn(buf_sv, p, nl-p);
4856     sv_chop(PL_e_script, nl);
4857     return 1;
4858 }
4859
4860 /*
4861  * Local variables:
4862  * c-indentation-style: bsd
4863  * c-basic-offset: 4
4864  * indent-tabs-mode: t
4865  * End:
4866  *
4867  * ex: set ts=8 sts=4 sw=4 noet:
4868  */