perl.c

   1 /*    perl.c
   2  *
   3  *    Copyright (c) 1987-2001 Larry Wall
   4  *
   5  *    You may distribute under the terms of either the GNU General Public
   6  *    License or the Artistic License, as specified in the README file.
   7  *
   8  */
   9
  10 /*
  11  * "A ship then new they built for him/of mithril and of elven glass" --Bilbo
  12  */
  13
  14 #include "EXTERN.h"
  15 #define PERL_IN_PERL_C
  16 #include "perl.h"
  17 #include "patchlevel.h"                 /* for local_patches */
  18
  19 /* XXX If this causes problems, set i_unistd=undef in the hint file.  */
  20 #ifdef I_UNISTD
  21 #include <unistd.h>
  22 #endif
  23
  24 #if !defined(STANDARD_C) && !defined(HAS_GETENV_PROTOTYPE)
  25 char *getenv (char *); /* Usually in <stdlib.h> */
  26 #endif
  27
  28 static I32 read_e_script(pTHXo_ int idx, SV *buf_sv, int maxlen);
  29
  30 #ifdef IAMSUID
  31 #ifndef DOSUID
  32 #define DOSUID
  33 #endif
  34 #endif
  35
  36 #ifdef SETUID_SCRIPTS_ARE_SECURE_NOW
  37 #ifdef DOSUID
  38 #undef DOSUID
  39 #endif
  40 #endif
  41
  42 #ifdef PERL_OBJECT
  43 #define perl_construct  Perl_construct
  44 #define perl_parse      Perl_parse
  45 #define perl_run        Perl_run
  46 #define perl_destruct   Perl_destruct
  47 #define perl_free       Perl_free
  48 #endif
  49
  50 #if defined(USE_THREADS)
  51 #  define INIT_TLS_AND_INTERP \
  52     STMT_START {                                \
  53         if (!PL_curinterp) {                    \
  54             PERL_SET_INTERP(my_perl);           \
  55             INIT_THREADS;                       \
  56             ALLOC_THREAD_KEY;                   \
  57         }                                       \
  58     } STMT_END
  59 #else
  60 #  if defined(USE_ITHREADS)
  61 #  define INIT_TLS_AND_INTERP \
  62     STMT_START {                                \
  63         if (!PL_curinterp) {                    \
  64             PERL_SET_INTERP(my_perl);           \
  65             INIT_THREADS;                       \
  66             ALLOC_THREAD_KEY;                   \
  67             PERL_SET_THX(my_perl);              \
  68             OP_REFCNT_INIT;                     \
  69         }                                       \
  70         else {                                  \
  71             PERL_SET_THX(my_perl);              \
  72         }                                       \
  73     } STMT_END
  74 #  else
  75 #  define INIT_TLS_AND_INTERP \
  76     STMT_START {                                \
  77         if (!PL_curinterp) {                    \
  78             PERL_SET_INTERP(my_perl);           \
  79         }                                       \
  80         PERL_SET_THX(my_perl);                  \
  81     } STMT_END
  82 #  endif
  83 #endif
  84
  85 #ifdef PERL_IMPLICIT_SYS
  86 PerlInterpreter *
  87 perl_alloc_using(struct IPerlMem* ipM, struct IPerlMem* ipMS,
  88                  struct IPerlMem* ipMP, struct IPerlEnv* ipE,
  89                  struct IPerlStdIO* ipStd, struct IPerlLIO* ipLIO,
  90                  struct IPerlDir* ipD, struct IPerlSock* ipS,
  91                  struct IPerlProc* ipP)
  92 {
  93     PerlInterpreter *my_perl;
  94 #ifdef PERL_OBJECT
  95     my_perl = (PerlInterpreter*)new(ipM) CPerlObj(ipM, ipMS, ipMP, ipE, ipStd,
  96                                                   ipLIO, ipD, ipS, ipP);
  97     INIT_TLS_AND_INTERP;
  98 #else
  99     /* New() needs interpreter, so call malloc() instead */
 100     my_perl = (PerlInterpreter*)(*ipM->pMalloc)(ipM, sizeof(PerlInterpreter));
 101     INIT_TLS_AND_INTERP;
 102     Zero(my_perl, 1, PerlInterpreter);
 103     PL_Mem = ipM;
 104     PL_MemShared = ipMS;
 105     PL_MemParse = ipMP;
 106     PL_Env = ipE;
 107     PL_StdIO = ipStd;
 108     PL_LIO = ipLIO;
 109     PL_Dir = ipD;
 110     PL_Sock = ipS;
 111     PL_Proc = ipP;
 112 #endif
 113
 114     return my_perl;
 115 }
 116 #else
 117
 118 /*
 119 =for apidoc perl_alloc
 120
 121 Allocates a new Perl interpreter.  See L<perlembed>.
 122
 123 =cut
 124 */
 125
 126 PerlInterpreter *
 127 perl_alloc(void)
 128 {
 129     PerlInterpreter *my_perl;
 130
 131     /* New() needs interpreter, so call malloc() instead */
 132     my_perl = (PerlInterpreter*)PerlMem_malloc(sizeof(PerlInterpreter));
 133
 134     INIT_TLS_AND_INTERP;
 135     Zero(my_perl, 1, PerlInterpreter);
 136     return my_perl;
 137 }
 138 #endif /* PERL_IMPLICIT_SYS */
 139
 140 /*
 141 =for apidoc perl_construct
 142
 143 Initializes a new Perl interpreter.  See L<perlembed>.
 144
 145 =cut
 146 */
 147
 148 void
 149 perl_construct(pTHXx)
 150 {
 151 #ifdef USE_THREADS
 152 #ifndef FAKE_THREADS
 153     struct perl_thread *thr = NULL;
 154 #endif /* FAKE_THREADS */
 155 #endif /* USE_THREADS */
 156
 157 #ifdef MULTIPLICITY
 158     init_interp();
 159     PL_perl_destruct_level = 1;
 160 #else
 161    if (PL_perl_destruct_level > 0)
 162        init_interp();
 163 #endif
 164
 165    /* Init the real globals (and main thread)? */
 166     if (!PL_linestr) {
 167 #ifdef USE_THREADS
 168         MUTEX_INIT(&PL_sv_mutex);
 169         /*
 170          * Safe to use basic SV functions from now on (though
 171          * not things like mortals or tainting yet).
 172          */
 173         MUTEX_INIT(&PL_eval_mutex);
 174         COND_INIT(&PL_eval_cond);
 175         MUTEX_INIT(&PL_threads_mutex);
 176         COND_INIT(&PL_nthreads_cond);
 177 #  ifdef EMULATE_ATOMIC_REFCOUNTS
 178         MUTEX_INIT(&PL_svref_mutex);
 179 #  endif /* EMULATE_ATOMIC_REFCOUNTS */
 180
 181         MUTEX_INIT(&PL_cred_mutex);
 182         MUTEX_INIT(&PL_sv_lock_mutex);
 183         MUTEX_INIT(&PL_fdpid_mutex);
 184
 185         thr = init_main_thread();
 186 #endif /* USE_THREADS */
 187
 188 #ifdef PERL_FLEXIBLE_EXCEPTIONS
 189         PL_protect = MEMBER_TO_FPTR(Perl_default_protect); /* for exceptions */
 190 #endif
 191
 192         PL_curcop = &PL_compiling;      /* needed by ckWARN, right away */
 193
 194         PL_linestr = NEWSV(65,79);
 195         sv_upgrade(PL_linestr,SVt_PVIV);
 196
 197         if (!SvREADONLY(&PL_sv_undef)) {
 198             /* set read-only and try to insure than we wont see REFCNT==0
 199                very often */
 200
 201             SvREADONLY_on(&PL_sv_undef);
 202             SvREFCNT(&PL_sv_undef) = (~(U32)0)/2;
 203
 204             sv_setpv(&PL_sv_no,PL_No);
 205             SvNV(&PL_sv_no);
 206             SvREADONLY_on(&PL_sv_no);
 207             SvREFCNT(&PL_sv_no) = (~(U32)0)/2;
 208
 209             sv_setpv(&PL_sv_yes,PL_Yes);
 210             SvNV(&PL_sv_yes);
 211             SvREADONLY_on(&PL_sv_yes);
 212             SvREFCNT(&PL_sv_yes) = (~(U32)0)/2;
 213         }
 214
 215 #ifdef PERL_OBJECT
 216         /* TODO: */
 217         /* PL_sighandlerp = sighandler; */
 218 #else
 219         PL_sighandlerp = Perl_sighandler;
 220 #endif
 221         PL_pidstatus = newHV();
 222
 223 #ifdef MSDOS
 224         /*
 225          * There is no way we can refer to them from Perl so close them to save
 226          * space.  The other alternative would be to provide STDAUX and STDPRN
 227          * filehandles.
 228          */
 229         (void)PerlIO_close(PerlIO_importFILE(stdaux, 0));
 230         (void)PerlIO_close(PerlIO_importFILE(stdprn, 0));
 231 #endif
 232     }
 233
 234     PL_nrs = newSVpvn("\n", 1);
 235     PL_rs = SvREFCNT_inc(PL_nrs);
 236
 237     init_stacks();
 238
 239     init_ids();
 240     PL_lex_state = LEX_NOTPARSING;
 241
 242     JMPENV_BOOTSTRAP;
 243     STATUS_ALL_SUCCESS;
 244
 245     init_i18nl10n(1);
 246     SET_NUMERIC_STANDARD();
 247
 248     {
 249         U8 *s;
 250         PL_patchlevel = NEWSV(0,4);
 251         (void)SvUPGRADE(PL_patchlevel, SVt_PVNV);
 252         if (PERL_REVISION > 127 || PERL_VERSION > 127 || PERL_SUBVERSION > 127)
 253             SvGROW(PL_patchlevel, UTF8_MAXLEN*3+1);
 254         s = (U8*)SvPVX(PL_patchlevel);
 255         /* Build version strings using "native" characters */
 256         s = uvchr_to_utf8(s, (UV)PERL_REVISION);
 257         s = uvchr_to_utf8(s, (UV)PERL_VERSION);
 258         s = uvchr_to_utf8(s, (UV)PERL_SUBVERSION);
 259         *s = '\0';
 260         SvCUR_set(PL_patchlevel, s - (U8*)SvPVX(PL_patchlevel));
 261         SvPOK_on(PL_patchlevel);
 262         SvNVX(PL_patchlevel) = (NV)PERL_REVISION
 263                                 + ((NV)PERL_VERSION / (NV)1000)
 264 #if defined(PERL_SUBVERSION) && PERL_SUBVERSION > 0
 265                                 + ((NV)PERL_SUBVERSION / (NV)1000000)
 266 #endif
 267                                 ;
 268         SvNOK_on(PL_patchlevel);        /* dual valued */
 269         SvUTF8_on(PL_patchlevel);
 270         SvREADONLY_on(PL_patchlevel);
 271     }
 272
 273 #if defined(LOCAL_PATCH_COUNT)
 274     PL_localpatches = local_patches;    /* For possible -v */
 275 #endif
 276
 277 #ifdef HAVE_INTERP_INTERN
 278     sys_intern_init();
 279 #endif
 280
 281     PerlIO_init();                      /* Hook to IO system */
 282
 283     PL_fdpid = newAV();                 /* for remembering popen pids by fd */
 284     PL_modglobal = newHV();             /* pointers to per-interpreter module globals */
 285     PL_errors = newSVpvn("",0);
 286 #ifdef USE_ITHREADS
 287         PL_regex_padav = newAV();
 288 #endif
 289 #ifdef USE_REENTRANT_API
 290     New(31337, PL_reentrant_buffer,1, REBUF);
 291     New(31337, PL_reentrant_buffer->tmbuff,1, struct tm);
 292 #endif
 293     ENTER;
 294 }
 295
 296 /*
 297 =for apidoc perl_destruct
 298
 299 Shuts down a Perl interpreter.  See L<perlembed>.
 300
 301 =cut
 302 */
 303
 304 void
 305 perl_destruct(pTHXx)
 306 {
 307     int destruct_level;  /* 0=none, 1=full, 2=full with checks */
 308     HV *hv;
 309 #ifdef USE_THREADS
 310     Thread t;
 311     dTHX;
 312 #endif /* USE_THREADS */
 313
 314     /* wait for all pseudo-forked children to finish */
 315     PERL_WAIT_FOR_CHILDREN;
 316
 317 #ifdef USE_THREADS
 318 #ifndef FAKE_THREADS
 319     /* Pass 1 on any remaining threads: detach joinables, join zombies */
 320   retry_cleanup:
 321     MUTEX_LOCK(&PL_threads_mutex);
 322     DEBUG_S(PerlIO_printf(Perl_debug_log,
 323                           "perl_destruct: waiting for %d threads...\n",
 324                           PL_nthreads - 1));
 325     for (t = thr->next; t != thr; t = t->next) {
 326         MUTEX_LOCK(&t->mutex);
 327         switch (ThrSTATE(t)) {
 328             AV *av;
 329         case THRf_ZOMBIE:
 330             DEBUG_S(PerlIO_printf(Perl_debug_log,
 331                                   "perl_destruct: joining zombie %p\n", t));
 332             ThrSETSTATE(t, THRf_DEAD);
 333             MUTEX_UNLOCK(&t->mutex);
 334             PL_nthreads--;
 335             /*
 336              * The SvREFCNT_dec below may take a long time (e.g. av
 337              * may contain an object scalar whose destructor gets
 338              * called) so we have to unlock threads_mutex and start
 339              * all over again.
 340              */
 341             MUTEX_UNLOCK(&PL_threads_mutex);
 342             JOIN(t, &av);
 343             SvREFCNT_dec((SV*)av);
 344             DEBUG_S(PerlIO_printf(Perl_debug_log,
 345                                   "perl_destruct: joined zombie %p OK\n", t));
 346             goto retry_cleanup;
 347         case THRf_R_JOINABLE:
 348             DEBUG_S(PerlIO_printf(Perl_debug_log,
 349                                   "perl_destruct: detaching thread %p\n", t));
 350             ThrSETSTATE(t, THRf_R_DETACHED);
 351             /*
 352              * We unlock threads_mutex and t->mutex in the opposite order
 353              * from which we locked them just so that DETACH won't
 354              * deadlock if it panics. It's only a breach of good style
 355              * not a bug since they are unlocks not locks.
 356              */
 357             MUTEX_UNLOCK(&PL_threads_mutex);
 358             DETACH(t);
 359             MUTEX_UNLOCK(&t->mutex);
 360             goto retry_cleanup;
 361         default:
 362             DEBUG_S(PerlIO_printf(Perl_debug_log,
 363                                   "perl_destruct: ignoring %p (state %u)\n",
 364                                   t, ThrSTATE(t)));
 365             MUTEX_UNLOCK(&t->mutex);
 366             /* fall through and out */
 367         }
 368     }
 369     /* We leave the above "Pass 1" loop with threads_mutex still locked */
 370
 371     /* Pass 2 on remaining threads: wait for the thread count to drop to one */
 372     while (PL_nthreads > 1)
 373     {
 374         DEBUG_S(PerlIO_printf(Perl_debug_log,
 375                               "perl_destruct: final wait for %d threads\n",
 376                               PL_nthreads - 1));
 377         COND_WAIT(&PL_nthreads_cond, &PL_threads_mutex);
 378     }
 379     /* At this point, we're the last thread */
 380     MUTEX_UNLOCK(&PL_threads_mutex);
 381     DEBUG_S(PerlIO_printf(Perl_debug_log, "perl_destruct: armageddon has arrived\n"));
 382     MUTEX_DESTROY(&PL_threads_mutex);
 383     COND_DESTROY(&PL_nthreads_cond);
 384     PL_nthreads--;
 385 #endif /* !defined(FAKE_THREADS) */
 386 #endif /* USE_THREADS */
 387
 388     destruct_level = PL_perl_destruct_level;
 389 #ifdef DEBUGGING
 390     {
 391         char *s;
 392         if ((s = PerlEnv_getenv("PERL_DESTRUCT_LEVEL"))) {
 393             int i = atoi(s);
 394             if (destruct_level < i)
 395                 destruct_level = i;
 396         }
 397     }
 398 #endif
 399
 400     LEAVE;
 401     FREETMPS;
 402
 403
 404     /* We must account for everything.  */
 405
 406     /* Destroy the main CV and syntax tree */
 407     if (PL_main_root) {
 408         PL_curpad = AvARRAY(PL_comppad);
 409         op_free(PL_main_root);
 410         PL_main_root = Nullop;
 411     }
 412     PL_curcop = &PL_compiling;
 413     PL_main_start = Nullop;
 414     SvREFCNT_dec(PL_main_cv);
 415     PL_main_cv = Nullcv;
 416     PL_dirty = TRUE;
 417
 418     /* Tell PerlIO we are about to tear things apart in case
 419        we have layers which are using resources that should
 420        be cleaned up now.
 421      */
 422
 423     PerlIO_destruct(aTHX);
 424
 425     if (PL_sv_objcount) {
 426         /*
 427          * Try to destruct global references.  We do this first so that the
 428          * destructors and destructees still exist.  Some sv's might remain.
 429          * Non-referenced objects are on their own.
 430          */
 431         sv_clean_objs();
 432     }
 433
 434     /* unhook hooks which will soon be, or use, destroyed data */
 435     SvREFCNT_dec(PL_warnhook);
 436     PL_warnhook = Nullsv;
 437     SvREFCNT_dec(PL_diehook);
 438     PL_diehook = Nullsv;
 439
 440     /* call exit list functions */
 441     while (PL_exitlistlen-- > 0)
 442         PL_exitlist[PL_exitlistlen].fn(aTHXo_ PL_exitlist[PL_exitlistlen].ptr);
 443
 444     Safefree(PL_exitlist);
 445
 446     if (destruct_level == 0){
 447
 448         DEBUG_P(debprofdump());
 449
 450         /* The exit() function will do everything that needs doing. */
 451         return;
 452     }
 453
 454     /* jettison our possibly duplicated environment */
 455
 456 #ifdef USE_ENVIRON_ARRAY
 457     if (environ != PL_origenviron) {
 458         I32 i;
 459
 460         for (i = 0; environ[i]; i++)
 461             safesysfree(environ[i]);
 462         /* Must use safesysfree() when working with environ. */
 463         safesysfree(environ);
 464
 465         environ = PL_origenviron;
 466     }
 467 #endif
 468
 469 #ifdef USE_ITHREADS
 470     /* the syntax tree is shared between clones
 471      * so op_free(PL_main_root) only ReREFCNT_dec's
 472      * REGEXPs in the parent interpreter
 473      * we need to manually ReREFCNT_dec for the clones
 474      */
 475     {
 476         I32 i = AvFILLp(PL_regex_padav) + 1;
 477         SV **ary = AvARRAY(PL_regex_padav);
 478
 479         while (i) {
 480             REGEXP *re = (REGEXP *)SvIVX(ary[--i]);
 481             if (re && (re->refcnt > 0)) {
 482                 ReREFCNT_dec(re);
 483             }
 484         }
 485     }
 486     SvREFCNT_dec(PL_regex_padav);
 487     PL_regex_padav = Nullav;
 488     PL_regex_pad = NULL;
 489 #endif
 490
 491     /* loosen bonds of global variables */
 492
 493     if(PL_rsfp) {
 494         (void)PerlIO_close(PL_rsfp);
 495         PL_rsfp = Nullfp;
 496     }
 497
 498     /* Filters for program text */
 499     SvREFCNT_dec(PL_rsfp_filters);
 500     PL_rsfp_filters = Nullav;
 501
 502     /* switches */
 503     PL_preprocess   = FALSE;
 504     PL_minus_n      = FALSE;
 505     PL_minus_p      = FALSE;
 506     PL_minus_l      = FALSE;
 507     PL_minus_a      = FALSE;
 508     PL_minus_F      = FALSE;
 509     PL_doswitches   = FALSE;
 510     PL_dowarn       = G_WARN_OFF;
 511     PL_doextract    = FALSE;
 512     PL_sawampersand = FALSE;    /* must save all match strings */
 513     PL_unsafe       = FALSE;
 514
 515     Safefree(PL_inplace);
 516     PL_inplace = Nullch;
 517     SvREFCNT_dec(PL_patchlevel);
 518
 519     if (PL_e_script) {
 520         SvREFCNT_dec(PL_e_script);
 521         PL_e_script = Nullsv;
 522     }
 523
 524     while (--PL_origargc >= 0) {
 525         Safefree(PL_origargv[PL_origargc]);
 526     }
 527     Safefree(PL_origargv);
 528
 529     /* magical thingies */
 530
 531     SvREFCNT_dec(PL_ofs_sv);    /* $, */
 532     PL_ofs_sv = Nullsv;
 533
 534     SvREFCNT_dec(PL_ors_sv);    /* $\ */
 535     PL_ors_sv = Nullsv;
 536
 537     SvREFCNT_dec(PL_rs);        /* $/ */
 538     PL_rs = Nullsv;
 539
 540     SvREFCNT_dec(PL_nrs);       /* $/ helper */
 541     PL_nrs = Nullsv;
 542
 543     PL_multiline = 0;           /* $* */
 544     Safefree(PL_osname);        /* $^O */
 545     PL_osname = Nullch;
 546
 547     SvREFCNT_dec(PL_statname);
 548     PL_statname = Nullsv;
 549     PL_statgv = Nullgv;
 550
 551     /* defgv, aka *_ should be taken care of elsewhere */
 552
 553     /* clean up after study() */
 554     SvREFCNT_dec(PL_lastscream);
 555     PL_lastscream = Nullsv;
 556     Safefree(PL_screamfirst);
 557     PL_screamfirst = 0;
 558     Safefree(PL_screamnext);
 559     PL_screamnext  = 0;
 560
 561     /* float buffer */
 562     Safefree(PL_efloatbuf);
 563     PL_efloatbuf = Nullch;
 564     PL_efloatsize = 0;
 565
 566     /* startup and shutdown function lists */
 567     SvREFCNT_dec(PL_beginav);
 568     SvREFCNT_dec(PL_endav);
 569     SvREFCNT_dec(PL_checkav);
 570     SvREFCNT_dec(PL_initav);
 571     PL_beginav = Nullav;
 572     PL_endav = Nullav;
 573     PL_checkav = Nullav;
 574     PL_initav = Nullav;
 575
 576     /* shortcuts just get cleared */
 577     PL_envgv = Nullgv;
 578     PL_incgv = Nullgv;
 579     PL_hintgv = Nullgv;
 580     PL_errgv = Nullgv;
 581     PL_argvgv = Nullgv;
 582     PL_argvoutgv = Nullgv;
 583     PL_stdingv = Nullgv;
 584     PL_stderrgv = Nullgv;
 585     PL_last_in_gv = Nullgv;
 586     PL_replgv = Nullgv;
 587     PL_debstash = Nullhv;
 588
 589     /* reset so print() ends up where we expect */
 590     setdefout(Nullgv);
 591
 592     SvREFCNT_dec(PL_argvout_stack);
 593     PL_argvout_stack = Nullav;
 594
 595     SvREFCNT_dec(PL_modglobal);
 596     PL_modglobal = Nullhv;
 597     SvREFCNT_dec(PL_preambleav);
 598     PL_preambleav = Nullav;
 599     SvREFCNT_dec(PL_subname);
 600     PL_subname = Nullsv;
 601     SvREFCNT_dec(PL_linestr);
 602     PL_linestr = Nullsv;
 603     SvREFCNT_dec(PL_pidstatus);
 604     PL_pidstatus = Nullhv;
 605     SvREFCNT_dec(PL_toptarget);
 606     PL_toptarget = Nullsv;
 607     SvREFCNT_dec(PL_bodytarget);
 608     PL_bodytarget = Nullsv;
 609     PL_formtarget = Nullsv;
 610
 611     /* free locale stuff */
 612 #ifdef USE_LOCALE_COLLATE
 613     Safefree(PL_collation_name);
 614     PL_collation_name = Nullch;
 615 #endif
 616
 617 #ifdef USE_LOCALE_NUMERIC
 618     Safefree(PL_numeric_name);
 619     PL_numeric_name = Nullch;
 620     SvREFCNT_dec(PL_numeric_radix_sv);
 621 #endif
 622
 623     /* clear utf8 character classes */
 624     SvREFCNT_dec(PL_utf8_alnum);
 625     SvREFCNT_dec(PL_utf8_alnumc);
 626     SvREFCNT_dec(PL_utf8_ascii);
 627     SvREFCNT_dec(PL_utf8_alpha);
 628     SvREFCNT_dec(PL_utf8_space);
 629     SvREFCNT_dec(PL_utf8_cntrl);
 630     SvREFCNT_dec(PL_utf8_graph);
 631     SvREFCNT_dec(PL_utf8_digit);
 632     SvREFCNT_dec(PL_utf8_upper);
 633     SvREFCNT_dec(PL_utf8_lower);
 634     SvREFCNT_dec(PL_utf8_print);
 635     SvREFCNT_dec(PL_utf8_punct);
 636     SvREFCNT_dec(PL_utf8_xdigit);
 637     SvREFCNT_dec(PL_utf8_mark);
 638     SvREFCNT_dec(PL_utf8_toupper);
 639     SvREFCNT_dec(PL_utf8_tolower);
 640     PL_utf8_alnum       = Nullsv;
 641     PL_utf8_alnumc      = Nullsv;
 642     PL_utf8_ascii       = Nullsv;
 643     PL_utf8_alpha       = Nullsv;
 644     PL_utf8_space       = Nullsv;
 645     PL_utf8_cntrl       = Nullsv;
 646     PL_utf8_graph       = Nullsv;
 647     PL_utf8_digit       = Nullsv;
 648     PL_utf8_upper       = Nullsv;
 649     PL_utf8_lower       = Nullsv;
 650     PL_utf8_print       = Nullsv;
 651     PL_utf8_punct       = Nullsv;
 652     PL_utf8_xdigit      = Nullsv;
 653     PL_utf8_mark        = Nullsv;
 654     PL_utf8_toupper     = Nullsv;
 655     PL_utf8_totitle     = Nullsv;
 656     PL_utf8_tolower     = Nullsv;
 657
 658     if (!specialWARN(PL_compiling.cop_warnings))
 659         SvREFCNT_dec(PL_compiling.cop_warnings);
 660     PL_compiling.cop_warnings = Nullsv;
 661     if (!specialCopIO(PL_compiling.cop_io))
 662         SvREFCNT_dec(PL_compiling.cop_io);
 663     PL_compiling.cop_io = Nullsv;
 664 #ifdef USE_ITHREADS
 665     Safefree(CopFILE(&PL_compiling));
 666     CopFILE(&PL_compiling) = Nullch;
 667     Safefree(CopSTASHPV(&PL_compiling));
 668 #else
 669     SvREFCNT_dec(CopFILEGV(&PL_compiling));
 670     CopFILEGV(&PL_compiling) = Nullgv;
 671     /* cop_stash is not refcounted */
 672 #endif
 673
 674     /* Prepare to destruct main symbol table.  */
 675
 676     hv = PL_defstash;
 677     PL_defstash = 0;
 678     SvREFCNT_dec(hv);
 679     SvREFCNT_dec(PL_curstname);
 680     PL_curstname = Nullsv;
 681
 682     /* clear queued errors */
 683     SvREFCNT_dec(PL_errors);
 684     PL_errors = Nullsv;
 685
 686     FREETMPS;
 687     if (destruct_level >= 2 && ckWARN_d(WARN_INTERNAL)) {
 688         if (PL_scopestack_ix != 0)
 689             Perl_warner(aTHX_ WARN_INTERNAL,
 690                  "Unbalanced scopes: %ld more ENTERs than LEAVEs\n",
 691                  (long)PL_scopestack_ix);
 692         if (PL_savestack_ix != 0)
 693             Perl_warner(aTHX_ WARN_INTERNAL,
 694                  "Unbalanced saves: %ld more saves than restores\n",
 695                  (long)PL_savestack_ix);
 696         if (PL_tmps_floor != -1)
 697             Perl_warner(aTHX_ WARN_INTERNAL,"Unbalanced tmps: %ld more allocs than frees\n",
 698                  (long)PL_tmps_floor + 1);
 699         if (cxstack_ix != -1)
 700             Perl_warner(aTHX_ WARN_INTERNAL,"Unbalanced context: %ld more PUSHes than POPs\n",
 701                  (long)cxstack_ix + 1);
 702     }
 703
 704     /* Now absolutely destruct everything, somehow or other, loops or no. */
 705     SvFLAGS(PL_fdpid) |= SVTYPEMASK;            /* don't clean out pid table now */
 706     SvFLAGS(PL_strtab) |= SVTYPEMASK;           /* don't clean out strtab now */
 707
 708     /* the 2 is for PL_fdpid and PL_strtab */
 709     while (PL_sv_count > 2 && sv_clean_all())
 710         ;
 711
 712     SvFLAGS(PL_fdpid) &= ~SVTYPEMASK;
 713     SvFLAGS(PL_fdpid) |= SVt_PVAV;
 714     SvFLAGS(PL_strtab) &= ~SVTYPEMASK;
 715     SvFLAGS(PL_strtab) |= SVt_PVHV;
 716
 717     AvREAL_off(PL_fdpid);               /* no surviving entries */
 718     SvREFCNT_dec(PL_fdpid);             /* needed in io_close() */
 719     PL_fdpid = Nullav;
 720
 721 #ifdef HAVE_INTERP_INTERN
 722     sys_intern_clear();
 723 #endif
 724
 725     /* Destruct the global string table. */
 726     {
 727         /* Yell and reset the HeVAL() slots that are still holding refcounts,
 728          * so that sv_free() won't fail on them.
 729          */
 730         I32 riter;
 731         I32 max;
 732         HE *hent;
 733         HE **array;
 734
 735         riter = 0;
 736         max = HvMAX(PL_strtab);
 737         array = HvARRAY(PL_strtab);
 738         hent = array[0];
 739         for (;;) {
 740             if (hent && ckWARN_d(WARN_INTERNAL)) {
 741                 Perl_warner(aTHX_ WARN_INTERNAL,
 742                      "Unbalanced string table refcount: (%d) for \"%s\"",
 743                      HeVAL(hent) - Nullsv, HeKEY(hent));
 744                 HeVAL(hent) = Nullsv;
 745                 hent = HeNEXT(hent);
 746             }
 747             if (!hent) {
 748                 if (++riter > max)
 749                     break;
 750                 hent = array[riter];
 751             }
 752         }
 753     }
 754     SvREFCNT_dec(PL_strtab);
 755
 756 #ifdef USE_ITHREADS
 757     /* free the pointer table used for cloning */
 758     ptr_table_free(PL_ptr_table);
 759 #endif
 760
 761     /* free special SVs */
 762
 763     SvREFCNT(&PL_sv_yes) = 0;
 764     sv_clear(&PL_sv_yes);
 765     SvANY(&PL_sv_yes) = NULL;
 766     SvFLAGS(&PL_sv_yes) = 0;
 767
 768     SvREFCNT(&PL_sv_no) = 0;
 769     sv_clear(&PL_sv_no);
 770     SvANY(&PL_sv_no) = NULL;
 771     SvFLAGS(&PL_sv_no) = 0;
 772
 773     SvREFCNT(&PL_sv_undef) = 0;
 774     SvREADONLY_off(&PL_sv_undef);
 775
 776     if (PL_sv_count != 0 && ckWARN_d(WARN_INTERNAL))
 777         Perl_warner(aTHX_ WARN_INTERNAL,"Scalars leaked: %ld\n", (long)PL_sv_count);
 778
 779     Safefree(PL_origfilename);
 780     Safefree(PL_reg_start_tmp);
 781     if (PL_reg_curpm)
 782         Safefree(PL_reg_curpm);
 783     Safefree(PL_reg_poscache);
 784     Safefree(HeKEY_hek(&PL_hv_fetch_ent_mh));
 785     Safefree(PL_op_mask);
 786     Safefree(PL_psig_ptr);
 787     Safefree(PL_psig_name);
 788     Safefree(PL_bitcount);
 789     Safefree(PL_psig_pend);
 790     nuke_stacks();
 791     PL_hints = 0;               /* Reset hints. Should hints be per-interpreter ? */
 792
 793     DEBUG_P(debprofdump());
 794 #ifdef USE_THREADS
 795     MUTEX_DESTROY(&PL_strtab_mutex);
 796     MUTEX_DESTROY(&PL_sv_mutex);
 797     MUTEX_DESTROY(&PL_eval_mutex);
 798     MUTEX_DESTROY(&PL_cred_mutex);
 799     MUTEX_DESTROY(&PL_fdpid_mutex);
 800     COND_DESTROY(&PL_eval_cond);
 801 #ifdef EMULATE_ATOMIC_REFCOUNTS
 802     MUTEX_DESTROY(&PL_svref_mutex);
 803 #endif /* EMULATE_ATOMIC_REFCOUNTS */
 804
 805     /* As the penultimate thing, free the non-arena SV for thrsv */
 806     Safefree(SvPVX(PL_thrsv));
 807     Safefree(SvANY(PL_thrsv));
 808     Safefree(PL_thrsv);
 809     PL_thrsv = Nullsv;
 810 #endif /* USE_THREADS */
 811
 812 #ifdef USE_REENTRANT_API
 813     Safefree(PL_reentrant_buffer->tmbuff);
 814     Safefree(PL_reentrant_buffer);
 815 #endif
 816
 817     sv_free_arenas();
 818
 819     /* As the absolutely last thing, free the non-arena SV for mess() */
 820
 821     if (PL_mess_sv) {
 822         /* it could have accumulated taint magic */
 823         if (SvTYPE(PL_mess_sv) >= SVt_PVMG) {
 824             MAGIC* mg;
 825             MAGIC* moremagic;
 826             for (mg = SvMAGIC(PL_mess_sv); mg; mg = moremagic) {
 827                 moremagic = mg->mg_moremagic;
 828                 if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global
 829                                                 && mg->mg_len >= 0)
 830                     Safefree(mg->mg_ptr);
 831                 Safefree(mg);
 832             }
 833         }
 834         /* we know that type >= SVt_PV */
 835         (void)SvOOK_off(PL_mess_sv);
 836         Safefree(SvPVX(PL_mess_sv));
 837         Safefree(SvANY(PL_mess_sv));
 838         Safefree(PL_mess_sv);
 839         PL_mess_sv = Nullsv;
 840     }
 841 }
 842
 843 /*
 844 =for apidoc perl_free
 845
 846 Releases a Perl interpreter.  See L<perlembed>.
 847
 848 =cut
 849 */
 850
 851 void
 852 perl_free(pTHXx)
 853 {
 854 #if defined(PERL_OBJECT)
 855     PerlMem_free(this);
 856 #else
 857 #  if defined(WIN32) || defined(NETWARE)
 858 #  if defined(PERL_IMPLICIT_SYS)
 859     #ifdef NETWARE
 860                 void *host = nw_internal_host;
 861         #else
 862                 void *host = w32_internal_host;
 863         #endif
 864         #ifndef NETWARE
 865         if (PerlProc_lasthost()) {
 866         PerlIO_cleanup();
 867         }
 868         #endif
 869     PerlMem_free(aTHXx);
 870         #ifdef NETWARE
 871                 nw5_delete_internal_host(host);
 872         #else
 873                 win32_delete_internal_host(host);
 874         #endif
 875 #else
 876     PerlIO_cleanup();
 877     PerlMem_free(aTHXx);
 878 #endif
 879 #  else
 880     PerlMem_free(aTHXx);
 881 #  endif
 882 #endif
 883 }
 884
 885 void
 886 Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr)
 887 {
 888     Renew(PL_exitlist, PL_exitlistlen+1, PerlExitListEntry);
 889     PL_exitlist[PL_exitlistlen].fn = fn;
 890     PL_exitlist[PL_exitlistlen].ptr = ptr;
 891     ++PL_exitlistlen;
 892 }
 893
 894 /*
 895 =for apidoc perl_parse
 896
 897 Tells a Perl interpreter to parse a Perl script.  See L<perlembed>.
 898
 899 =cut
 900 */
 901
 902 int
 903 perl_parse(pTHXx_ XSINIT_t xsinit, int argc, char **argv, char **env)
 904 {
 905     I32 oldscope;
 906     int ret;
 907     dJMPENV;
 908 #ifdef USE_THREADS
 909     dTHX;
 910 #endif
 911
 912 #ifdef SETUID_SCRIPTS_ARE_SECURE_NOW
 913 #ifdef IAMSUID
 914 #undef IAMSUID
 915     Perl_croak(aTHX_ "suidperl is no longer needed since the kernel can now execute\n\
 916 setuid perl scripts securely.\n");
 917 #endif
 918 #endif
 919
 920 #if defined(__DYNAMIC__) && (defined(NeXT) || defined(__NeXT__))
 921     _dyld_lookup_and_bind
 922         ("__environ", (unsigned long *) &environ_pointer, NULL);
 923 #endif /* environ */
 924
 925     PL_origargc = argc;
 926     {
 927         /* we copy rather than point to argv
 928          * since perl_clone will copy and perl_destruct
 929          * has no way of knowing if we've made a copy or
 930          * just point to argv
 931          */
 932         int i = PL_origargc;
 933         New(0, PL_origargv, i+1, char*);
 934         PL_origargv[i] = '\0';
 935         while (i-- > 0) {
 936             PL_origargv[i] = savepv(argv[i]);
 937         }
 938     }
 939
 940 #ifdef  USE_ENVIRON_ARRAY
 941     PL_origenviron = environ;
 942 #endif
 943
 944     if (PL_do_undump) {
 945
 946         /* Come here if running an undumped a.out. */
 947
 948         PL_origfilename = savepv(argv[0]);
 949         PL_do_undump = FALSE;
 950         cxstack_ix = -1;                /* start label stack again */
 951         init_ids();
 952         init_postdump_symbols(argc,argv,env);
 953         return 0;
 954     }
 955
 956     if (PL_main_root) {
 957         PL_curpad = AvARRAY(PL_comppad);
 958         op_free(PL_main_root);
 959         PL_main_root = Nullop;
 960     }
 961     PL_main_start = Nullop;
 962     SvREFCNT_dec(PL_main_cv);
 963     PL_main_cv = Nullcv;
 964
 965     time(&PL_basetime);
 966     oldscope = PL_scopestack_ix;
 967     PL_dowarn = G_WARN_OFF;
 968
 969 #ifdef PERL_FLEXIBLE_EXCEPTIONS
 970     CALLPROTECT(aTHX_ pcur_env, &ret, MEMBER_TO_FPTR(S_vparse_body), env, xsinit);
 971 #else
 972     JMPENV_PUSH(ret);
 973 #endif
 974     switch (ret) {
 975     case 0:
 976 #ifndef PERL_FLEXIBLE_EXCEPTIONS
 977         parse_body(env,xsinit);
 978 #endif
 979         if (PL_checkav)
 980             call_list(oldscope, PL_checkav);
 981         ret = 0;
 982         break;
 983     case 1:
 984         STATUS_ALL_FAILURE;
 985         /* FALL THROUGH */
 986     case 2:
 987         /* my_exit() was called */
 988         while (PL_scopestack_ix > oldscope)
 989             LEAVE;
 990         FREETMPS;
 991         PL_curstash = PL_defstash;
 992         if (PL_checkav)
 993             call_list(oldscope, PL_checkav);
 994         ret = STATUS_NATIVE_EXPORT;
 995         break;
 996     case 3:
 997         PerlIO_printf(Perl_error_log, "panic: top_env\n");
 998         ret = 1;
 999         break;
1000     }
1001     JMPENV_POP;
1002     return ret;
1003 }
1004
1005 #ifdef PERL_FLEXIBLE_EXCEPTIONS
1006 STATIC void *
1007 S_vparse_body(pTHX_ va_list args)
1008 {
1009     char **env = va_arg(args, char**);
1010     XSINIT_t xsinit = va_arg(args, XSINIT_t);
1011
1012     return parse_body(env, xsinit);
1013 }
1014 #endif
1015
1016 STATIC void *
1017 S_parse_body(pTHX_ char **env, XSINIT_t xsinit)
1018 {
1019     int argc = PL_origargc;
1020     char **argv = PL_origargv;
1021     char *scriptname = NULL;
1022     int fdscript = -1;
1023     VOL bool dosearch = FALSE;
1024     char *validarg = "";
1025     AV* comppadlist;
1026     register SV *sv;
1027     register char *s;
1028     char *popts, *cddir = Nullch;
1029
1030     sv_setpvn(PL_linestr,"",0);
1031     sv = newSVpvn("",0);                /* first used for -I flags */
1032     SAVEFREESV(sv);
1033     init_main_stash();
1034
1035     for (argc--,argv++; argc > 0; argc--,argv++) {
1036         if (argv[0][0] != '-' || !argv[0][1])
1037             break;
1038 #ifdef DOSUID
1039     if (*validarg)
1040         validarg = " PHOOEY ";
1041     else
1042         validarg = argv[0];
1043 #endif
1044         s = argv[0]+1;
1045       reswitch:
1046         switch (*s) {
1047         case 'C':
1048 #ifdef  WIN32
1049             win32_argv2utf8(argc-1, argv+1);
1050             /* FALL THROUGH */
1051 #endif
1052 #ifndef PERL_STRICT_CR
1053         case '\r':
1054 #endif
1055         case ' ':
1056         case '0':
1057         case 'F':
1058         case 'a':
1059         case 'c':
1060         case 'd':
1061         case 'D':
1062         case 'h':
1063         case 'i':
1064         case 'l':
1065         case 'M':
1066         case 'm':
1067         case 'n':
1068         case 'p':
1069         case 's':
1070         case 'u':
1071         case 'U':
1072         case 'v':
1073         case 'W':
1074         case 'X':
1075         case 'w':
1076             if ((s = moreswitches(s)))
1077                 goto reswitch;
1078             break;
1079
1080         case 'T':
1081             PL_tainting = TRUE;
1082             s++;
1083             goto reswitch;
1084
1085         case 'e':
1086 #ifdef MACOS_TRADITIONAL
1087             /* ignore -e for Dev:Pseudo argument */
1088             if (argv[1] && !strcmp(argv[1], "Dev:Pseudo"))
1089                 break;
1090 #endif
1091             if (PL_euid != PL_uid || PL_egid != PL_gid)
1092                 Perl_croak(aTHX_ "No -e allowed in setuid scripts");
1093             if (!PL_e_script) {
1094                 PL_e_script = newSVpvn("",0);
1095                 filter_add(read_e_script, NULL);
1096             }
1097             if (*++s)
1098                 sv_catpv(PL_e_script, s);
1099             else if (argv[1]) {
1100                 sv_catpv(PL_e_script, argv[1]);
1101                 argc--,argv++;
1102             }
1103             else
1104                 Perl_croak(aTHX_ "No code specified for -e");
1105             sv_catpv(PL_e_script, "\n");
1106             break;
1107
1108         case 'I':       /* -I handled both here and in moreswitches() */
1109             forbid_setid("-I");
1110             if (!*++s && (s=argv[1]) != Nullch) {
1111                 argc--,argv++;
1112             }
1113             if (s && *s) {
1114                 char *p;
1115                 STRLEN len = strlen(s);
1116                 p = savepvn(s, len);
1117                 incpush(p, TRUE, TRUE);
1118                 sv_catpvn(sv, "-I", 2);
1119                 sv_catpvn(sv, p, len);
1120                 sv_catpvn(sv, " ", 1);
1121                 Safefree(p);
1122             }
1123             else
1124                 Perl_croak(aTHX_ "No directory specified for -I");
1125             break;
1126         case 'P':
1127             forbid_setid("-P");
1128             PL_preprocess = TRUE;
1129             s++;
1130             goto reswitch;
1131         case 'S':
1132             forbid_setid("-S");
1133             dosearch = TRUE;
1134             s++;
1135             goto reswitch;
1136         case 'V':
1137             if (!PL_preambleav)
1138                 PL_preambleav = newAV();
1139             av_push(PL_preambleav, newSVpv("use Config qw(myconfig config_vars)",0));
1140             if (*++s != ':')  {
1141                 PL_Sv = newSVpv("print myconfig();",0);
1142 #ifdef VMS
1143                 sv_catpv(PL_Sv,"print \"\\nCharacteristics of this PERLSHR image: \\n\",");
1144 #else
1145                 sv_catpv(PL_Sv,"print \"\\nCharacteristics of this binary (from libperl): \\n\",");
1146 #endif
1147                 sv_catpv(PL_Sv,"\"  Compile-time options:");
1148 #  ifdef DEBUGGING
1149                 sv_catpv(PL_Sv," DEBUGGING");
1150 #  endif
1151 #  ifdef MULTIPLICITY
1152                 sv_catpv(PL_Sv," MULTIPLICITY");
1153 #  endif
1154 #  ifdef USE_THREADS
1155                 sv_catpv(PL_Sv," USE_THREADS");
1156 #  endif
1157 #  ifdef USE_ITHREADS
1158                 sv_catpv(PL_Sv," USE_ITHREADS");
1159 #  endif
1160 #  ifdef USE_64_BIT_INT
1161                 sv_catpv(PL_Sv," USE_64_BIT_INT");
1162 #  endif
1163 #  ifdef USE_64_BIT_ALL
1164                 sv_catpv(PL_Sv," USE_64_BIT_ALL");
1165 #  endif
1166 #  ifdef USE_LONG_DOUBLE
1167                 sv_catpv(PL_Sv," USE_LONG_DOUBLE");
1168 #  endif
1169 #  ifdef USE_LARGE_FILES
1170                 sv_catpv(PL_Sv," USE_LARGE_FILES");
1171 #  endif
1172 #  ifdef USE_SOCKS
1173                 sv_catpv(PL_Sv," USE_SOCKS");
1174 #  endif
1175 #  ifdef PERL_OBJECT
1176                 sv_catpv(PL_Sv," PERL_OBJECT");
1177 #  endif
1178 #  ifdef PERL_IMPLICIT_CONTEXT
1179                 sv_catpv(PL_Sv," PERL_IMPLICIT_CONTEXT");
1180 #  endif
1181 #  ifdef PERL_IMPLICIT_SYS
1182                 sv_catpv(PL_Sv," PERL_IMPLICIT_SYS");
1183 #  endif
1184                 sv_catpv(PL_Sv,"\\n\",");
1185
1186 #if defined(LOCAL_PATCH_COUNT)
1187                 if (LOCAL_PATCH_COUNT > 0) {
1188                     int i;
1189                     sv_catpv(PL_Sv,"\"  Locally applied patches:\\n\",");
1190                     for (i = 1; i <= LOCAL_PATCH_COUNT; i++) {
1191                         if (PL_localpatches[i])
1192                             Perl_sv_catpvf(aTHX_ PL_Sv,"q\"  \t%s\n\",",PL_localpatches[i]);
1193                     }
1194                 }
1195 #endif
1196                 Perl_sv_catpvf(aTHX_ PL_Sv,"\"  Built under %s\\n\"",OSNAME);
1197 #ifdef __DATE__
1198 #  ifdef __TIME__
1199                 Perl_sv_catpvf(aTHX_ PL_Sv,",\"  Compiled at %s %s\\n\"",__DATE__,__TIME__);
1200 #  else
1201                 Perl_sv_catpvf(aTHX_ PL_Sv,",\"  Compiled on %s\\n\"",__DATE__);
1202 #  endif
1203 #endif
1204                 sv_catpv(PL_Sv, "; \
1205 $\"=\"\\n    \"; \
1206 @env = map { \"$_=\\\"$ENV{$_}\\\"\" } sort grep {/^PERL/} keys %ENV; ");
1207 #ifdef __CYGWIN__
1208                 sv_catpv(PL_Sv,"\
1209 push @env, \"CYGWIN=\\\"$ENV{CYGWIN}\\\"\";");
1210 #endif
1211                 sv_catpv(PL_Sv, "\
1212 print \"  \\%ENV:\\n    @env\\n\" if @env; \
1213 print \"  \\@INC:\\n    @INC\\n\";");
1214             }
1215             else {
1216                 PL_Sv = newSVpv("config_vars(qw(",0);
1217                 sv_catpv(PL_Sv, ++s);
1218                 sv_catpv(PL_Sv, "))");
1219                 s += strlen(s);
1220             }
1221             av_push(PL_preambleav, PL_Sv);
1222             scriptname = BIT_BUCKET;    /* don't look for script or read stdin */
1223             goto reswitch;
1224         case 'x':
1225             PL_doextract = TRUE;
1226             s++;
1227             if (*s)
1228                 cddir = s;
1229             break;
1230         case 0:
1231             break;
1232         case '-':
1233             if (!*++s || isSPACE(*s)) {
1234                 argc--,argv++;
1235                 goto switch_end;
1236             }
1237             /* catch use of gnu style long options */
1238             if (strEQ(s, "version")) {
1239                 s = "v";
1240                 goto reswitch;
1241             }
1242             if (strEQ(s, "help")) {
1243                 s = "h";
1244                 goto reswitch;
1245             }
1246             s--;
1247             /* FALL THROUGH */
1248         default:
1249             Perl_croak(aTHX_ "Unrecognized switch: -%s  (-h will show valid options)",s);
1250         }
1251     }
1252   switch_end:
1253
1254     if (
1255 #ifndef SECURE_INTERNAL_GETENV
1256         !PL_tainting &&
1257 #endif
1258         (popts = PerlEnv_getenv("PERL5OPT")))
1259     {
1260         s = savepv(popts);
1261         while (isSPACE(*s))
1262             s++;
1263         if (*s == '-' && *(s+1) == 'T')
1264             PL_tainting = TRUE;
1265         else {
1266             while (s && *s) {
1267                 char *d;
1268                 while (isSPACE(*s))
1269                     s++;
1270                 if (*s == '-') {
1271                     s++;
1272                     if (isSPACE(*s))
1273                         continue;
1274                 }
1275                 d = s;
1276                 if (!*s)
1277                     break;
1278                 if (!strchr("DIMUdmw", *s))
1279                     Perl_croak(aTHX_ "Illegal switch in PERL5OPT: -%c", *s);
1280                 while (++s && *s) {
1281                     if (isSPACE(*s)) {
1282                         *s++ = '\0';
1283                         break;
1284                     }
1285                 }
1286                 moreswitches(d);
1287             }
1288         }
1289     }
1290
1291     if (!scriptname)
1292         scriptname = argv[0];
1293     if (PL_e_script) {
1294         argc++,argv--;
1295         scriptname = BIT_BUCKET;        /* don't look for script or read stdin */
1296     }
1297     else if (scriptname == Nullch) {
1298 #ifdef MSDOS
1299         if ( PerlLIO_isatty(PerlIO_fileno(PerlIO_stdin())) )
1300             moreswitches("h");
1301 #endif
1302         scriptname = "-";
1303     }
1304
1305     init_perllib();
1306
1307     open_script(scriptname,dosearch,sv,&fdscript);
1308
1309     validate_suid(validarg, scriptname,fdscript);
1310
1311 #ifndef PERL_MICRO
1312 #if defined(SIGCHLD) || defined(SIGCLD)
1313     {
1314 #ifndef SIGCHLD
1315 #  define SIGCHLD SIGCLD
1316 #endif
1317         Sighandler_t sigstate = rsignal_state(SIGCHLD);
1318         if (sigstate == SIG_IGN) {
1319             if (ckWARN(WARN_SIGNAL))
1320                 Perl_warner(aTHX_ WARN_SIGNAL,
1321                             "Can't ignore signal CHLD, forcing to default");
1322             (void)rsignal(SIGCHLD, (Sighandler_t)SIG_DFL);
1323         }
1324     }
1325 #endif
1326 #endif
1327
1328 #ifdef MACOS_TRADITIONAL
1329     if (PL_doextract || gMacPerl_AlwaysExtract) {
1330 #else
1331     if (PL_doextract) {
1332 #endif
1333         find_beginning();
1334         if (cddir && PerlDir_chdir(cddir) < 0)
1335             Perl_croak(aTHX_ "Can't chdir to %s",cddir);
1336
1337     }
1338
1339     PL_main_cv = PL_compcv = (CV*)NEWSV(1104,0);
1340     sv_upgrade((SV *)PL_compcv, SVt_PVCV);
1341     CvUNIQUE_on(PL_compcv);
1342
1343     PL_comppad = newAV();
1344     av_push(PL_comppad, Nullsv);
1345     PL_curpad = AvARRAY(PL_comppad);
1346     PL_comppad_name = newAV();
1347     PL_comppad_name_fill = 0;
1348     PL_min_intro_pending = 0;
1349     PL_padix = 0;
1350 #ifdef USE_THREADS
1351     av_store(PL_comppad_name, 0, newSVpvn("@_", 2));
1352     PL_curpad[0] = (SV*)newAV();
1353     SvPADMY_on(PL_curpad[0]);   /* XXX Needed? */
1354     CvOWNER(PL_compcv) = 0;
1355     New(666, CvMUTEXP(PL_compcv), 1, perl_mutex);
1356     MUTEX_INIT(CvMUTEXP(PL_compcv));
1357 #endif /* USE_THREADS */
1358
1359     comppadlist = newAV();
1360     AvREAL_off(comppadlist);
1361     av_store(comppadlist, 0, (SV*)PL_comppad_name);
1362     av_store(comppadlist, 1, (SV*)PL_comppad);
1363     CvPADLIST(PL_compcv) = comppadlist;
1364
1365     boot_core_PerlIO();
1366     boot_core_UNIVERSAL();
1367 #ifndef PERL_MICRO
1368     boot_core_xsutils();
1369 #endif
1370
1371     if (xsinit)
1372         (*xsinit)(aTHXo);       /* in case linked C routines want magical variables */
1373 #ifndef PERL_MICRO
1374 #if defined(VMS) || defined(WIN32) || defined(DJGPP) || defined(__CYGWIN__) || defined(EPOC)
1375     init_os_extras();
1376 #endif
1377 #endif
1378
1379 #ifdef USE_SOCKS
1380 #   ifdef HAS_SOCKS5_INIT
1381     socks5_init(argv[0]);
1382 #   else
1383     SOCKSinit(argv[0]);
1384 #   endif
1385 #endif
1386
1387     init_predump_symbols();
1388     /* init_postdump_symbols not currently designed to be called */
1389     /* more than once (ENV isn't cleared first, for example)     */
1390     /* But running with -u leaves %ENV & @ARGV undefined!    XXX */
1391     if (!PL_do_undump)
1392         init_postdump_symbols(argc,argv,env);
1393
1394     init_lexer();
1395
1396     /* now parse the script */
1397
1398     SETERRNO(0,SS$_NORMAL);
1399     PL_error_count = 0;
1400 #ifdef MACOS_TRADITIONAL
1401     if (gMacPerl_SyntaxError = (yyparse() || PL_error_count)) {
1402         if (PL_minus_c)
1403             Perl_croak(aTHX_ "%s had compilation errors.\n", MacPerl_MPWFileName(PL_origfilename));
1404         else {
1405             Perl_croak(aTHX_ "Execution of %s aborted due to compilation errors.\n",
1406                        MacPerl_MPWFileName(PL_origfilename));
1407         }
1408     }
1409 #else
1410     if (yyparse() || PL_error_count) {
1411         if (PL_minus_c)
1412             Perl_croak(aTHX_ "%s had compilation errors.\n", PL_origfilename);
1413         else {
1414             Perl_croak(aTHX_ "Execution of %s aborted due to compilation errors.\n",
1415                        PL_origfilename);
1416         }
1417     }
1418 #endif
1419     CopLINE_set(PL_curcop, 0);
1420     PL_curstash = PL_defstash;
1421     PL_preprocess = FALSE;
1422     if (PL_e_script) {
1423         SvREFCNT_dec(PL_e_script);
1424         PL_e_script = Nullsv;
1425     }
1426
1427     /* now that script is parsed, we can modify record separator */
1428     SvREFCNT_dec(PL_rs);
1429     PL_rs = SvREFCNT_inc(PL_nrs);
1430     sv_setsv(get_sv("/", TRUE), PL_rs);
1431     if (PL_do_undump)
1432         my_unexec();
1433
1434     if (isWARN_ONCE) {
1435         SAVECOPFILE(PL_curcop);
1436         SAVECOPLINE(PL_curcop);
1437         gv_check(PL_defstash);
1438     }
1439
1440     LEAVE;
1441     FREETMPS;
1442
1443 #ifdef MYMALLOC
1444     if ((s=PerlEnv_getenv("PERL_DEBUG_MSTATS")) && atoi(s) >= 2)
1445         dump_mstats("after compilation:");
1446 #endif
1447
1448     ENTER;
1449     PL_restartop = 0;
1450     return NULL;
1451 }
1452
1453 /*
1454 =for apidoc perl_run
1455
1456 Tells a Perl interpreter to run.  See L<perlembed>.
1457
1458 =cut
1459 */
1460
1461 int
1462 perl_run(pTHXx)
1463 {
1464     I32 oldscope;
1465     int ret = 0;
1466     dJMPENV;
1467 #ifdef USE_THREADS
1468     dTHX;
1469 #endif
1470
1471     oldscope = PL_scopestack_ix;
1472
1473 #ifdef PERL_FLEXIBLE_EXCEPTIONS
1474  redo_body:
1475     CALLPROTECT(aTHX_ pcur_env, &ret, MEMBER_TO_FPTR(S_vrun_body), oldscope);
1476 #else
1477     JMPENV_PUSH(ret);
1478 #endif
1479     switch (ret) {
1480     case 1:
1481         cxstack_ix = -1;                /* start context stack again */
1482         goto redo_body;
1483     case 0:                             /* normal completion */
1484 #ifndef PERL_FLEXIBLE_EXCEPTIONS
1485  redo_body:
1486         run_body(oldscope);
1487 #endif
1488         /* FALL THROUGH */
1489     case 2:                             /* my_exit() */
1490         while (PL_scopestack_ix > oldscope)
1491             LEAVE;
1492         FREETMPS;
1493         PL_curstash = PL_defstash;
1494         if (PL_endav && !PL_minus_c)
1495             call_list(oldscope, PL_endav);
1496 #ifdef MYMALLOC
1497         if (PerlEnv_getenv("PERL_DEBUG_MSTATS"))
1498             dump_mstats("after execution:  ");
1499 #endif
1500         ret = STATUS_NATIVE_EXPORT;
1501         break;
1502     case 3:
1503         if (PL_restartop) {
1504             POPSTACK_TO(PL_mainstack);
1505             goto redo_body;
1506         }
1507         PerlIO_printf(Perl_error_log, "panic: restartop\n");
1508         FREETMPS;
1509         ret = 1;
1510         break;
1511     }
1512
1513     JMPENV_POP;
1514     return ret;
1515 }
1516
1517 #ifdef PERL_FLEXIBLE_EXCEPTIONS
1518 STATIC void *
1519 S_vrun_body(pTHX_ va_list args)
1520 {
1521     I32 oldscope = va_arg(args, I32);
1522
1523     return run_body(oldscope);
1524 }
1525 #endif
1526
1527
1528 STATIC void *
1529 S_run_body(pTHX_ I32 oldscope)
1530 {
1531     DEBUG_r(PerlIO_printf(Perl_debug_log, "%s $` $& $' support.\n",
1532                     PL_sawampersand ? "Enabling" : "Omitting"));
1533
1534     if (!PL_restartop) {
1535         DEBUG_x(dump_all());
1536         DEBUG(PerlIO_printf(Perl_debug_log, "\nEXECUTING...\n\n"));
1537         DEBUG_S(PerlIO_printf(Perl_debug_log, "main thread is 0x%"UVxf"\n",
1538                               PTR2UV(thr)));
1539
1540         if (PL_minus_c) {
1541 #ifdef MACOS_TRADITIONAL
1542             PerlIO_printf(Perl_error_log, "%s syntax OK\n", MacPerl_MPWFileName(PL_origfilename));
1543 #else
1544             PerlIO_printf(Perl_error_log, "%s syntax OK\n", PL_origfilename);
1545 #endif
1546             my_exit(0);
1547         }
1548         if (PERLDB_SINGLE && PL_DBsingle)
1549             sv_setiv(PL_DBsingle, 1);
1550         if (PL_initav)
1551             call_list(oldscope, PL_initav);
1552     }
1553
1554     /* do it */
1555
1556     if (PL_restartop) {
1557         PL_op = PL_restartop;
1558         PL_restartop = 0;
1559         CALLRUNOPS(aTHX);
1560     }
1561     else if (PL_main_start) {
1562         CvDEPTH(PL_main_cv) = 1;
1563         PL_op = PL_main_start;
1564         CALLRUNOPS(aTHX);
1565     }
1566
1567     my_exit(0);
1568     /* NOTREACHED */
1569     return NULL;
1570 }
1571
1572 /*
1573 =for apidoc p||get_sv
1574
1575 Returns the SV of the specified Perl scalar.  If C<create> is set and the
1576 Perl variable does not exist then it will be created.  If C<create> is not
1577 set and the variable does not exist then NULL is returned.
1578
1579 =cut
1580 */
1581
1582 SV*
1583 Perl_get_sv(pTHX_ const char *name, I32 create)
1584 {
1585     GV *gv;
1586 #ifdef USE_THREADS
1587     if (name[1] == '\0' && !isALPHA(name[0])) {
1588         PADOFFSET tmp = find_threadsv(name);
1589         if (tmp != NOT_IN_PAD)
1590             return THREADSV(tmp);
1591     }
1592 #endif /* USE_THREADS */
1593     gv = gv_fetchpv(name, create, SVt_PV);
1594     if (gv)
1595         return GvSV(gv);
1596     return Nullsv;
1597 }
1598
1599 /*
1600 =for apidoc p||get_av
1601
1602 Returns the AV of the specified Perl array.  If C<create> is set and the
1603 Perl variable does not exist then it will be created.  If C<create> is not
1604 set and the variable does not exist then NULL is returned.
1605
1606 =cut
1607 */
1608
1609 AV*
1610 Perl_get_av(pTHX_ const char *name, I32 create)
1611 {
1612     GV* gv = gv_fetchpv(name, create, SVt_PVAV);
1613     if (create)
1614         return GvAVn(gv);
1615     if (gv)
1616         return GvAV(gv);
1617     return Nullav;
1618 }
1619
1620 /*
1621 =for apidoc p||get_hv
1622
1623 Returns the HV of the specified Perl hash.  If C<create> is set and the
1624 Perl variable does not exist then it will be created.  If C<create> is not
1625 set and the variable does not exist then NULL is returned.
1626
1627 =cut
1628 */
1629
1630 HV*
1631 Perl_get_hv(pTHX_ const char *name, I32 create)
1632 {
1633     GV* gv = gv_fetchpv(name, create, SVt_PVHV);
1634     if (create)
1635         return GvHVn(gv);
1636     if (gv)
1637         return GvHV(gv);
1638     return Nullhv;
1639 }
1640
1641 /*
1642 =for apidoc p||get_cv
1643
1644 Returns the CV of the specified Perl subroutine.  If C<create> is set and
1645 the Perl subroutine does not exist then it will be declared (which has the
1646 same effect as saying C<sub name;>).  If C<create> is not set and the
1647 subroutine does not exist then NULL is returned.
1648
1649 =cut
1650 */
1651
1652 CV*
1653 Perl_get_cv(pTHX_ const char *name, I32 create)
1654 {
1655     GV* gv = gv_fetchpv(name, create, SVt_PVCV);
1656     /* XXX unsafe for threads if eval_owner isn't held */
1657     /* XXX this is probably not what they think they're getting.
1658      * It has the same effect as "sub name;", i.e. just a forward
1659      * declaration! */
1660     if (create && !GvCVu(gv))
1661         return newSUB(start_subparse(FALSE, 0),
1662                       newSVOP(OP_CONST, 0, newSVpv(name,0)),
1663                       Nullop,
1664                       Nullop);
1665     if (gv)
1666         return GvCVu(gv);
1667     return Nullcv;
1668 }
1669
1670 /* Be sure to refetch the stack pointer after calling these routines. */
1671
1672 /*
1673 =for apidoc p||call_argv
1674
1675 Performs a callback to the specified Perl sub.  See L<perlcall>.
1676
1677 =cut
1678 */
1679
1680 I32
1681 Perl_call_argv(pTHX_ const char *sub_name, I32 flags, register char **argv)
1682
1683                         /* See G_* flags in cop.h */
1684                         /* null terminated arg list */
1685 {
1686     dSP;
1687
1688     PUSHMARK(SP);
1689     if (argv) {
1690         while (*argv) {
1691             XPUSHs(sv_2mortal(newSVpv(*argv,0)));
1692             argv++;
1693         }
1694         PUTBACK;
1695     }
1696     return call_pv(sub_name, flags);
1697 }
1698
1699 /*
1700 =for apidoc p||call_pv
1701
1702 Performs a callback to the specified Perl sub.  See L<perlcall>.
1703
1704 =cut
1705 */
1706
1707 I32
1708 Perl_call_pv(pTHX_ const char *sub_name, I32 flags)
1709                         /* name of the subroutine */
1710                         /* See G_* flags in cop.h */
1711 {
1712     return call_sv((SV*)get_cv(sub_name, TRUE), flags);
1713 }
1714
1715 /*
1716 =for apidoc p||call_method
1717
1718 Performs a callback to the specified Perl method.  The blessed object must
1719 be on the stack.  See L<perlcall>.
1720
1721 =cut
1722 */
1723
1724 I32
1725 Perl_call_method(pTHX_ const char *methname, I32 flags)
1726                         /* name of the subroutine */
1727                         /* See G_* flags in cop.h */
1728 {
1729     return call_sv(sv_2mortal(newSVpv(methname,0)), flags | G_METHOD);
1730 }
1731
1732 /* May be called with any of a CV, a GV, or an SV containing the name. */
1733 /*
1734 =for apidoc p||call_sv
1735
1736 Performs a callback to the Perl sub whose name is in the SV.  See
1737 L<perlcall>.
1738
1739 =cut
1740 */
1741
1742 I32
1743 Perl_call_sv(pTHX_ SV *sv, I32 flags)
1744                         /* See G_* flags in cop.h */
1745 {
1746     dSP;
1747     LOGOP myop;         /* fake syntax tree node */
1748     UNOP method_op;
1749     I32 oldmark;
1750     volatile I32 retval = 0;
1751     I32 oldscope;
1752     bool oldcatch = CATCH_GET;
1753     int ret;
1754     OP* oldop = PL_op;
1755     dJMPENV;
1756
1757     if (flags & G_DISCARD) {
1758         ENTER;
1759         SAVETMPS;
1760     }
1761
1762     Zero(&myop, 1, LOGOP);
1763     myop.op_next = Nullop;
1764     if (!(flags & G_NOARGS))
1765         myop.op_flags |= OPf_STACKED;
1766     myop.op_flags |= ((flags & G_VOID) ? OPf_WANT_VOID :
1767                       (flags & G_ARRAY) ? OPf_WANT_LIST :
1768                       OPf_WANT_SCALAR);
1769     SAVEOP();
1770     PL_op = (OP*)&myop;
1771
1772     EXTEND(PL_stack_sp, 1);
1773     *++PL_stack_sp = sv;
1774     oldmark = TOPMARK;
1775     oldscope = PL_scopestack_ix;
1776
1777     if (PERLDB_SUB && PL_curstash != PL_debstash
1778            /* Handle first BEGIN of -d. */
1779           && (PL_DBcv || (PL_DBcv = GvCV(PL_DBsub)))
1780            /* Try harder, since this may have been a sighandler, thus
1781             * curstash may be meaningless. */
1782           && (SvTYPE(sv) != SVt_PVCV || CvSTASH((CV*)sv) != PL_debstash)
1783           && !(flags & G_NODEBUG))
1784         PL_op->op_private |= OPpENTERSUB_DB;
1785
1786     if (flags & G_METHOD) {
1787         Zero(&method_op, 1, UNOP);
1788         method_op.op_next = PL_op;
1789         method_op.op_ppaddr = PL_ppaddr[OP_METHOD];
1790         myop.op_ppaddr = PL_ppaddr[OP_ENTERSUB];
1791         PL_op = (OP*)&method_op;
1792     }
1793
1794     if (!(flags & G_EVAL)) {
1795         CATCH_SET(TRUE);
1796         call_body((OP*)&myop, FALSE);
1797         retval = PL_stack_sp - (PL_stack_base + oldmark);
1798         CATCH_SET(oldcatch);
1799     }
1800     else {
1801         myop.op_other = (OP*)&myop;
1802         PL_markstack_ptr--;
1803         /* we're trying to emulate pp_entertry() here */
1804         {
1805             register PERL_CONTEXT *cx;
1806             I32 gimme = GIMME_V;
1807
1808             ENTER;
1809             SAVETMPS;
1810
1811             push_return(Nullop);
1812             PUSHBLOCK(cx, (CXt_EVAL|CXp_TRYBLOCK), PL_stack_sp);
1813             PUSHEVAL(cx, 0, 0);
1814             PL_eval_root = PL_op;             /* Only needed so that goto works right. */
1815
1816             PL_in_eval = EVAL_INEVAL;
1817             if (flags & G_KEEPERR)
1818                 PL_in_eval |= EVAL_KEEPERR;
1819             else
1820                 sv_setpv(ERRSV,"");
1821         }
1822         PL_markstack_ptr++;
1823
1824 #ifdef PERL_FLEXIBLE_EXCEPTIONS
1825  redo_body:
1826         CALLPROTECT(aTHX_ pcur_env, &ret, MEMBER_TO_FPTR(S_vcall_body),
1827                     (OP*)&myop, FALSE);
1828 #else
1829         JMPENV_PUSH(ret);
1830 #endif
1831         switch (ret) {
1832         case 0:
1833 #ifndef PERL_FLEXIBLE_EXCEPTIONS
1834  redo_body:
1835             call_body((OP*)&myop, FALSE);
1836 #endif
1837             retval = PL_stack_sp - (PL_stack_base + oldmark);
1838             if (!(flags & G_KEEPERR))
1839                 sv_setpv(ERRSV,"");
1840             break;
1841         case 1:
1842             STATUS_ALL_FAILURE;
1843             /* FALL THROUGH */
1844         case 2:
1845             /* my_exit() was called */
1846             PL_curstash = PL_defstash;
1847             FREETMPS;
1848             JMPENV_POP;
1849             if (PL_statusvalue && !(PL_exit_flags & PERL_EXIT_EXPECTED))
1850                 Perl_croak(aTHX_ "Callback called exit");
1851             my_exit_jump();
1852             /* NOTREACHED */
1853         case 3:
1854             if (PL_restartop) {
1855                 PL_op = PL_restartop;
1856                 PL_restartop = 0;
1857                 goto redo_body;
1858             }
1859             PL_stack_sp = PL_stack_base + oldmark;
1860             if (flags & G_ARRAY)
1861                 retval = 0;
1862             else {
1863                 retval = 1;
1864                 *++PL_stack_sp = &PL_sv_undef;
1865             }
1866             break;
1867         }
1868
1869         if (PL_scopestack_ix > oldscope) {
1870             SV **newsp;
1871             PMOP *newpm;
1872             I32 gimme;
1873             register PERL_CONTEXT *cx;
1874             I32 optype;
1875
1876             POPBLOCK(cx,newpm);
1877             POPEVAL(cx);
1878             pop_return();
1879             PL_curpm = newpm;
1880             LEAVE;
1881         }
1882         JMPENV_POP;
1883     }
1884
1885     if (flags & G_DISCARD) {
1886         PL_stack_sp = PL_stack_base + oldmark;
1887         retval = 0;
1888         FREETMPS;
1889         LEAVE;
1890     }
1891     PL_op = oldop;
1892     return retval;
1893 }
1894
1895 #ifdef PERL_FLEXIBLE_EXCEPTIONS
1896 STATIC void *
1897 S_vcall_body(pTHX_ va_list args)
1898 {
1899     OP *myop = va_arg(args, OP*);
1900     int is_eval = va_arg(args, int);
1901
1902     call_body(myop, is_eval);
1903     return NULL;
1904 }
1905 #endif
1906
1907 STATIC void
1908 S_call_body(pTHX_ OP *myop, int is_eval)
1909 {
1910     if (PL_op == myop) {
1911         if (is_eval)
1912             PL_op = Perl_pp_entereval(aTHX);    /* this doesn't do a POPMARK */
1913         else
1914             PL_op = Perl_pp_entersub(aTHX);     /* this does */
1915     }
1916     if (PL_op)
1917         CALLRUNOPS(aTHX);
1918 }
1919
1920 /* Eval a string. The G_EVAL flag is always assumed. */
1921
1922 /*
1923 =for apidoc p||eval_sv
1924
1925 Tells Perl to C<eval> the string in the SV.
1926
1927 =cut
1928 */
1929
1930 I32
1931 Perl_eval_sv(pTHX_ SV *sv, I32 flags)
1932
1933                         /* See G_* flags in cop.h */
1934 {
1935     dSP;
1936     UNOP myop;          /* fake syntax tree node */
1937     volatile I32 oldmark = SP - PL_stack_base;
1938     volatile I32 retval = 0;
1939     I32 oldscope;
1940     int ret;
1941     OP* oldop = PL_op;
1942     dJMPENV;
1943
1944     if (flags & G_DISCARD) {
1945         ENTER;
1946         SAVETMPS;
1947     }
1948
1949     SAVEOP();
1950     PL_op = (OP*)&myop;
1951     Zero(PL_op, 1, UNOP);
1952     EXTEND(PL_stack_sp, 1);
1953     *++PL_stack_sp = sv;
1954     oldscope = PL_scopestack_ix;
1955
1956     if (!(flags & G_NOARGS))
1957         myop.op_flags = OPf_STACKED;
1958     myop.op_next = Nullop;
1959     myop.op_type = OP_ENTEREVAL;
1960     myop.op_flags |= ((flags & G_VOID) ? OPf_WANT_VOID :
1961                       (flags & G_ARRAY) ? OPf_WANT_LIST :
1962                       OPf_WANT_SCALAR);
1963     if (flags & G_KEEPERR)
1964         myop.op_flags |= OPf_SPECIAL;
1965
1966 #ifdef PERL_FLEXIBLE_EXCEPTIONS
1967  redo_body:
1968     CALLPROTECT(aTHX_ pcur_env, &ret, MEMBER_TO_FPTR(S_vcall_body),
1969                 (OP*)&myop, TRUE);
1970 #else
1971     JMPENV_PUSH(ret);
1972 #endif
1973     switch (ret) {
1974     case 0:
1975 #ifndef PERL_FLEXIBLE_EXCEPTIONS
1976  redo_body:
1977         call_body((OP*)&myop,TRUE);
1978 #endif
1979         retval = PL_stack_sp - (PL_stack_base + oldmark);
1980         if (!(flags & G_KEEPERR))
1981             sv_setpv(ERRSV,"");
1982         break;
1983     case 1:
1984         STATUS_ALL_FAILURE;
1985         /* FALL THROUGH */
1986     case 2:
1987         /* my_exit() was called */
1988         PL_curstash = PL_defstash;
1989         FREETMPS;
1990         JMPENV_POP;
1991         if (PL_statusvalue && !(PL_exit_flags & PERL_EXIT_EXPECTED))
1992             Perl_croak(aTHX_ "Callback called exit");
1993         my_exit_jump();
1994         /* NOTREACHED */
1995     case 3:
1996         if (PL_restartop) {
1997             PL_op = PL_restartop;
1998             PL_restartop = 0;
1999             goto redo_body;
2000         }
2001         PL_stack_sp = PL_stack_base + oldmark;
2002         if (flags & G_ARRAY)
2003             retval = 0;
2004         else {
2005             retval = 1;
2006             *++PL_stack_sp = &PL_sv_undef;
2007         }
2008         break;
2009     }
2010
2011     JMPENV_POP;
2012     if (flags & G_DISCARD) {
2013         PL_stack_sp = PL_stack_base + oldmark;
2014         retval = 0;
2015         FREETMPS;
2016         LEAVE;
2017     }
2018     PL_op = oldop;
2019     return retval;
2020 }
2021
2022 /*
2023 =for apidoc p||eval_pv
2024
2025 Tells Perl to C<eval> the given string and return an SV* result.
2026
2027 =cut
2028 */
2029
2030 SV*
2031 Perl_eval_pv(pTHX_ const char *p, I32 croak_on_error)
2032 {
2033     dSP;
2034     SV* sv = newSVpv(p, 0);
2035
2036     eval_sv(sv, G_SCALAR);
2037     SvREFCNT_dec(sv);
2038
2039     SPAGAIN;
2040     sv = POPs;
2041     PUTBACK;
2042
2043     if (croak_on_error && SvTRUE(ERRSV)) {
2044         STRLEN n_a;
2045         Perl_croak(aTHX_ SvPVx(ERRSV, n_a));
2046     }
2047
2048     return sv;
2049 }
2050
2051 /* Require a module. */
2052
2053 /*
2054 =for apidoc p||require_pv
2055
2056 Tells Perl to C<require> the file named by the string argument.  It is
2057 analogous to the Perl code C<eval "require '$file'">.  It's even
2058 implemented that way; consider using Perl_load_module instead.
2059
2060 =cut */
2061
2062 void
2063 Perl_require_pv(pTHX_ const char *pv)
2064 {
2065     SV* sv;
2066     dSP;
2067     PUSHSTACKi(PERLSI_REQUIRE);
2068     PUTBACK;
2069     sv = sv_newmortal();
2070     sv_setpv(sv, "require '");
2071     sv_catpv(sv, pv);
2072     sv_catpv(sv, "'");
2073     eval_sv(sv, G_DISCARD);
2074     SPAGAIN;
2075     POPSTACK;
2076 }
2077
2078 void
2079 Perl_magicname(pTHX_ char *sym, char *name, I32 namlen)
2080 {
2081     register GV *gv;
2082
2083     if ((gv = gv_fetchpv(sym,TRUE, SVt_PV)))
2084         sv_magic(GvSV(gv), (SV*)gv, PERL_MAGIC_sv, name, namlen);
2085 }
2086
2087 STATIC void
2088 S_usage(pTHX_ char *name)               /* XXX move this out into a module ? */
2089 {
2090     /* This message really ought to be max 23 lines.
2091      * Removed -h because the user already knows that option. Others? */
2092
2093     static char *usage_msg[] = {
2094 "-0[octal]       specify record separator (\\0, if no argument)",
2095 "-a              autosplit mode with -n or -p (splits $_ into @F)",
2096 "-C              enable native wide character system interfaces",
2097 "-c              check syntax only (runs BEGIN and CHECK blocks)",
2098 "-d[:debugger]   run program under debugger",
2099 "-D[number/list] set debugging flags (argument is a bit mask or alphabets)",
2100 "-e 'command'    one line of program (several -e's allowed, omit programfile)",
2101 "-F/pattern/     split() pattern for -a switch (//'s are optional)",
2102 "-i[extension]   edit <> files in place (makes backup if extension supplied)",
2103 "-Idirectory     specify @INC/#include directory (several -I's allowed)",
2104 "-l[octal]       enable line ending processing, specifies line terminator",
2105 "-[mM][-]module  execute `use/no module...' before executing program",
2106 "-n              assume 'while (<>) { ... }' loop around program",
2107 "-p              assume loop like -n but print line also, like sed",
2108 "-P              run program through C preprocessor before compilation",
2109 "-s              enable rudimentary parsing for switches after programfile",
2110 "-S              look for programfile using PATH environment variable",
2111 "-T              enable tainting checks",
2112 "-u              dump core after parsing program",
2113 "-U              allow unsafe operations",
2114 "-v              print version, subversion (includes VERY IMPORTANT perl info)",
2115 "-V[:variable]   print configuration summary (or a single Config.pm variable)",
2116 "-w              enable many useful warnings (RECOMMENDED)",
2117 "-W              enable all warnings",
2118 "-X              disable all warnings",
2119 "-x[directory]   strip off text before #!perl line and perhaps cd to directory",
2120 "\n",
2121 NULL
2122 };
2123     char **p = usage_msg;
2124
2125     PerlIO_printf(PerlIO_stdout(),
2126                   "\nUsage: %s [switches] [--] [programfile] [arguments]",
2127                   name);
2128     while (*p)
2129         PerlIO_printf(PerlIO_stdout(), "\n  %s", *p++);
2130 }
2131
2132 /* This routine handles any switches that can be given during run */
2133
2134 char *
2135 Perl_moreswitches(pTHX_ char *s)
2136 {
2137     STRLEN numlen;
2138     U32 rschar;
2139
2140     switch (*s) {
2141     case '0':
2142     {
2143         numlen = 0;                     /* disallow underscores */
2144         rschar = (U32)scan_oct(s, 4, &numlen);
2145         SvREFCNT_dec(PL_nrs);
2146         if (rschar & ~((U8)~0))
2147             PL_nrs = &PL_sv_undef;
2148         else if (!rschar && numlen >= 2)
2149             PL_nrs = newSVpvn("", 0);
2150         else {
2151             char ch = rschar;
2152             PL_nrs = newSVpvn(&ch, 1);
2153         }
2154         return s + numlen;
2155     }
2156     case 'C':
2157         PL_widesyscalls = TRUE;
2158         s++;
2159         return s;
2160     case 'F':
2161         PL_minus_F = TRUE;
2162         PL_splitstr = savepv(s + 1);
2163         s += strlen(s);
2164         return s;
2165     case 'a':
2166         PL_minus_a = TRUE;
2167         s++;
2168         return s;
2169     case 'c':
2170         PL_minus_c = TRUE;
2171         s++;
2172         return s;
2173     case 'd':
2174         forbid_setid("-d");
2175         s++;
2176         /* The following permits -d:Mod to accepts arguments following an =
2177            in the fashion that -MSome::Mod does. */
2178         if (*s == ':' || *s == '=') {
2179             char *start;
2180             SV *sv;
2181             sv = newSVpv("use Devel::", 0);
2182             start = ++s;
2183             /* We now allow -d:Module=Foo,Bar */
2184             while(isALNUM(*s) || *s==':') ++s;
2185             if (*s != '=')
2186                 sv_catpv(sv, start);
2187             else {
2188                 sv_catpvn(sv, start, s-start);
2189                 sv_catpv(sv, " split(/,/,q{");
2190                 sv_catpv(sv, ++s);
2191                 sv_catpv(sv,    "})");
2192             }
2193             s += strlen(s);
2194             my_setenv("PERL5DB", SvPV(sv, PL_na));
2195         }
2196         if (!PL_perldb) {
2197             PL_perldb = PERLDB_ALL;
2198             init_debugger();
2199         }
2200         return s;
2201     case 'D':
2202     {
2203 #ifdef DEBUGGING
2204         forbid_setid("-D");
2205         if (isALPHA(s[1])) {
2206             /* if adding extra options, remember to update DEBUG_MASK */
2207             static char debopts[] = "psltocPmfrxuLHXDSTR";
2208             char *d;
2209
2210             for (s++; *s && (d = strchr(debopts,*s)); s++)
2211                 PL_debug |= 1 << (d - debopts);
2212         }
2213         else {
2214             PL_debug = atoi(s+1);
2215             for (s++; isDIGIT(*s); s++) ;
2216         }
2217         PL_debug |= DEBUG_TOP_FLAG;
2218 #else
2219         if (ckWARN_d(WARN_DEBUGGING))
2220             Perl_warner(aTHX_ WARN_DEBUGGING,
2221                    "Recompile perl with -DDEBUGGING to use -D switch\n");
2222         for (s++; isALNUM(*s); s++) ;
2223 #endif
2224         /*SUPPRESS 530*/
2225         return s;
2226     }
2227     case 'h':
2228         usage(PL_origargv[0]);
2229         PerlProc_exit(0);
2230     case 'i':
2231         if (PL_inplace)
2232             Safefree(PL_inplace);
2233         PL_inplace = savepv(s+1);
2234         /*SUPPRESS 530*/
2235         for (s = PL_inplace; *s && !isSPACE(*s); s++) ;
2236         if (*s) {
2237             *s++ = '\0';
2238             if (*s == '-')      /* Additional switches on #! line. */
2239                 s++;
2240         }
2241         return s;
2242     case 'I':   /* -I handled both here and in parse_perl() */
2243         forbid_setid("-I");
2244         ++s;
2245         while (*s && isSPACE(*s))
2246             ++s;
2247         if (*s) {
2248             char *e, *p;
2249             p = s;
2250             /* ignore trailing spaces (possibly followed by other switches) */
2251             do {
2252                 for (e = p; *e && !isSPACE(*e); e++) ;
2253                 p = e;
2254                 while (isSPACE(*p))
2255                     p++;
2256             } while (*p && *p != '-');
2257             e = savepvn(s, e-s);
2258             incpush(e, TRUE, TRUE);
2259             Safefree(e);
2260             s = p;
2261             if (*s == '-')
2262                 s++;
2263         }
2264         else
2265             Perl_croak(aTHX_ "No directory specified for -I");
2266         return s;
2267     case 'l':
2268         PL_minus_l = TRUE;
2269         s++;
2270         if (PL_ors_sv) {
2271             SvREFCNT_dec(PL_ors_sv);
2272             PL_ors_sv = Nullsv;
2273         }
2274         if (isDIGIT(*s)) {
2275             PL_ors_sv = newSVpvn("\n",1);
2276             numlen = 0;                 /* disallow underscores */
2277             *SvPVX(PL_ors_sv) = (char)scan_oct(s, 3 + (*s == '0'), &numlen);
2278             s += numlen;
2279         }
2280         else {
2281             if (RsPARA(PL_nrs)) {
2282                 PL_ors_sv = newSVpvn("\n\n",2);
2283             }
2284             else {
2285                 PL_ors_sv = newSVsv(PL_nrs);
2286             }
2287         }
2288         return s;
2289     case 'M':
2290         forbid_setid("-M");     /* XXX ? */
2291         /* FALL THROUGH */
2292     case 'm':
2293         forbid_setid("-m");     /* XXX ? */
2294         if (*++s) {
2295             char *start;
2296             SV *sv;
2297             char *use = "use ";
2298             /* -M-foo == 'no foo'       */
2299             if (*s == '-') { use = "no "; ++s; }
2300             sv = newSVpv(use,0);
2301             start = s;
2302             /* We allow -M'Module qw(Foo Bar)'  */
2303             while(isALNUM(*s) || *s==':') ++s;
2304             if (*s != '=') {
2305                 sv_catpv(sv, start);
2306                 if (*(start-1) == 'm') {
2307                     if (*s != '\0')
2308                         Perl_croak(aTHX_ "Can't use '%c' after -mname", *s);
2309                     sv_catpv( sv, " ()");
2310                 }
2311             } else {
2312                 if (s == start)
2313                     Perl_croak(aTHX_ "Module name required with -%c option",
2314                                s[-1]);
2315                 sv_catpvn(sv, start, s-start);
2316                 sv_catpv(sv, " split(/,/,q{");
2317                 sv_catpv(sv, ++s);
2318                 sv_catpv(sv,    "})");
2319             }
2320             s += strlen(s);
2321             if (!PL_preambleav)
2322                 PL_preambleav = newAV();
2323             av_push(PL_preambleav, sv);
2324         }
2325         else
2326             Perl_croak(aTHX_ "No space allowed after -%c", *(s-1));
2327         return s;
2328     case 'n':
2329         PL_minus_n = TRUE;
2330         s++;
2331         return s;
2332     case 'p':
2333         PL_minus_p = TRUE;
2334         s++;
2335         return s;
2336     case 's':
2337         forbid_setid("-s");
2338         PL_doswitches = TRUE;
2339         s++;
2340         return s;
2341     case 'T':
2342         if (!PL_tainting)
2343             Perl_croak(aTHX_ "Too late for \"-T\" option");
2344         s++;
2345         return s;
2346     case 'u':
2347 #ifdef MACOS_TRADITIONAL
2348         Perl_croak(aTHX_ "Believe me, you don't want to use \"-u\" on a Macintosh");
2349 #endif
2350         PL_do_undump = TRUE;
2351         s++;
2352         return s;
2353     case 'U':
2354         PL_unsafe = TRUE;
2355         s++;
2356         return s;
2357     case 'v':
2358 #if !defined(DGUX)
2359         PerlIO_printf(PerlIO_stdout(),
2360                       Perl_form(aTHX_ "\nThis is perl, v%"VDf" built for %s",
2361                                 PL_patchlevel, ARCHNAME));
2362 #else /* DGUX */
2363 /* Adjust verbose output as in the perl that ships with the DG/UX OS from EMC */
2364         PerlIO_printf(PerlIO_stdout(),
2365                         Perl_form(aTHX_ "\nThis is perl, version %vd\n", PL_patchlevel));
2366         PerlIO_printf(PerlIO_stdout(),
2367                         Perl_form(aTHX_ "        built under %s at %s %s\n",
2368                                         OSNAME, __DATE__, __TIME__));
2369         PerlIO_printf(PerlIO_stdout(),
2370                         Perl_form(aTHX_ "        OS Specific Release: %s\n",
2371                                         OSVERS));
2372 #endif /* !DGUX */
2373
2374 #if defined(LOCAL_PATCH_COUNT)
2375         if (LOCAL_PATCH_COUNT > 0)
2376             PerlIO_printf(PerlIO_stdout(),
2377                           "\n(with %d registered patch%s, "
2378                           "see perl -V for more detail)",
2379                           (int)LOCAL_PATCH_COUNT,
2380                           (LOCAL_PATCH_COUNT!=1) ? "es" : "");
2381 #endif
2382
2383         PerlIO_printf(PerlIO_stdout(),
2384                       "\n\nCopyright 1987-2001, Larry Wall\n");
2385 #ifdef MACOS_TRADITIONAL
2386         PerlIO_printf(PerlIO_stdout(),
2387                       "\nMac OS port Copyright (c) 1991-2001, Matthias Neeracher\n");
2388 #endif
2389 #ifdef MSDOS
2390         PerlIO_printf(PerlIO_stdout(),
2391                       "\nMS-DOS port Copyright (c) 1989, 1990, Diomidis Spinellis\n");
2392 #endif
2393 #ifdef DJGPP
2394         PerlIO_printf(PerlIO_stdout(),
2395                       "djgpp v2 port (jpl5003c) by Hirofumi Watanabe, 1996\n"
2396                       "djgpp v2 port (perl5004+) by Laszlo Molnar, 1997-1999\n");
2397 #endif
2398 #ifdef OS2
2399         PerlIO_printf(PerlIO_stdout(),
2400                       "\n\nOS/2 port Copyright (c) 1990, 1991, Raymond Chen, Kai Uwe Rommel\n"
2401                       "Version 5 port Copyright (c) 1994-1999, Andreas Kaiser, Ilya Zakharevich\n");
2402 #endif
2403 #ifdef atarist
2404         PerlIO_printf(PerlIO_stdout(),
2405                       "atariST series port, ++jrb  bammi@cadence.com\n");
2406 #endif
2407 #ifdef __BEOS__
2408         PerlIO_printf(PerlIO_stdout(),
2409                       "BeOS port Copyright Tom Spindler, 1997-1999\n");
2410 #endif
2411 #ifdef MPE
2412         PerlIO_printf(PerlIO_stdout(),
2413                       "MPE/iX port Copyright by Mark Klein and Mark Bixby, 1996-2001\n");
2414 #endif
2415 #ifdef OEMVS
2416         PerlIO_printf(PerlIO_stdout(),
2417                       "MVS (OS390) port by Mortice Kern Systems, 1997-1999\n");
2418 #endif
2419 #ifdef __VOS__
2420         PerlIO_printf(PerlIO_stdout(),
2421                       "Stratus VOS port by Paul_Green@stratus.com, 1997-1999\n");
2422 #endif
2423 #ifdef __OPEN_VM
2424         PerlIO_printf(PerlIO_stdout(),
2425                       "VM/ESA port by Neale Ferguson, 1998-1999\n");
2426 #endif
2427 #ifdef POSIX_BC
2428         PerlIO_printf(PerlIO_stdout(),
2429                       "BS2000 (POSIX) port by Start Amadeus GmbH, 1998-1999\n");
2430 #endif
2431 #ifdef __MINT__
2432         PerlIO_printf(PerlIO_stdout(),
2433                       "MiNT port by Guido Flohr, 1997-1999\n");
2434 #endif
2435 #ifdef EPOC
2436         PerlIO_printf(PerlIO_stdout(),
2437                       "EPOC port by Olaf Flebbe, 1999-2000\n");
2438 #endif
2439 #ifdef UNDER_CE
2440         printf("WINCE port by Rainer Keuchel, 2001\n");
2441         printf("Built on " __DATE__ " " __TIME__ "\n\n");
2442         wce_hitreturn();
2443 #endif
2444 #ifdef BINARY_BUILD_NOTICE
2445         BINARY_BUILD_NOTICE;
2446 #endif
2447         PerlIO_printf(PerlIO_stdout(),
2448                       "\n\
2449 Perl may be copied only under the terms of either the Artistic License or the\n\
2450 GNU General Public License, which may be found in the Perl 5 source kit.\n\n\
2451 Complete documentation for Perl, including FAQ lists, should be found on\n\
2452 this system using `man perl' or `perldoc perl'.  If you have access to the\n\
2453 Internet, point your browser at http://www.perl.com/, the Perl Home Page.\n\n");
2454         PerlProc_exit(0);
2455     case 'w':
2456         if (! (PL_dowarn & G_WARN_ALL_MASK))
2457             PL_dowarn |= G_WARN_ON;
2458         s++;
2459         return s;
2460     case 'W':
2461         PL_dowarn = G_WARN_ALL_ON|G_WARN_ON;
2462         PL_compiling.cop_warnings = pWARN_ALL ;
2463         s++;
2464         return s;
2465     case 'X':
2466         PL_dowarn = G_WARN_ALL_OFF;
2467         PL_compiling.cop_warnings = pWARN_NONE ;
2468         s++;
2469         return s;
2470     case '*':
2471     case ' ':
2472         if (s[1] == '-')        /* Additional switches on #! line. */
2473             return s+2;
2474         break;
2475     case '-':
2476     case 0:
2477 #if defined(WIN32) || !defined(PERL_STRICT_CR)
2478     case '\r':
2479 #endif
2480     case '\n':
2481     case '\t':
2482         break;
2483 #ifdef ALTERNATE_SHEBANG
2484     case 'S':                   /* OS/2 needs -S on "extproc" line. */
2485         break;
2486 #endif
2487     case 'P':
2488         if (PL_preprocess)
2489             return s+1;
2490         /* FALL THROUGH */
2491     default:
2492         Perl_croak(aTHX_ "Can't emulate -%.1s on #! line",s);
2493     }
2494     return Nullch;
2495 }
2496
2497 /* compliments of Tom Christiansen */
2498
2499 /* unexec() can be found in the Gnu emacs distribution */
2500 /* Known to work with -DUNEXEC and using unexelf.c from GNU emacs-20.2 */
2501
2502 void
2503 Perl_my_unexec(pTHX)
2504 {
2505 #ifdef UNEXEC
2506     SV*    prog;
2507     SV*    file;
2508     int    status = 1;
2509     extern int etext;
2510
2511     prog = newSVpv(BIN_EXP, 0);
2512     sv_catpv(prog, "/perl");
2513     file = newSVpv(PL_origfilename, 0);
2514     sv_catpv(file, ".perldump");
2515
2516     unexec(SvPVX(file), SvPVX(prog), &etext, sbrk(0), 0);
2517     /* unexec prints msg to stderr in case of failure */
2518     PerlProc_exit(status);
2519 #else
2520 #  ifdef VMS
2521 #    include <lib$routines.h>
2522      lib$signal(SS$_DEBUG);  /* ssdef.h #included from vmsish.h */
2523 #  else
2524     ABORT();            /* for use with undump */
2525 #  endif
2526 #endif
2527 }
2528
2529 /* initialize curinterp */
2530 STATIC void
2531 S_init_interp(pTHX)
2532 {
2533
2534 #ifdef PERL_OBJECT              /* XXX kludge */
2535 #define I_REINIT \
2536   STMT_START {                          \
2537     PL_chopset          = " \n-";       \
2538     PL_copline          = NOLINE;       \
2539     PL_curcop           = &PL_compiling;\
2540     PL_curcopdb         = NULL;         \
2541     PL_dbargs           = 0;            \
2542     PL_dumpindent       = 4;            \
2543     PL_laststatval      = -1;           \
2544     PL_laststype        = OP_STAT;      \
2545     PL_maxscream        = -1;           \
2546     PL_maxsysfd         = MAXSYSFD;     \
2547     PL_statname         = Nullsv;       \
2548     PL_tmps_floor       = -1;           \
2549     PL_tmps_ix          = -1;           \
2550     PL_op_mask          = NULL;         \
2551     PL_laststatval      = -1;           \
2552     PL_laststype        = OP_STAT;      \
2553     PL_mess_sv          = Nullsv;       \
2554     PL_splitstr         = " ";          \
2555     PL_generation       = 100;          \
2556     PL_exitlist         = NULL;         \
2557     PL_exitlistlen      = 0;            \
2558     PL_regindent        = 0;            \
2559     PL_in_clean_objs    = FALSE;        \
2560     PL_in_clean_all     = FALSE;        \
2561     PL_profiledata      = NULL;         \
2562     PL_rsfp             = Nullfp;       \
2563     PL_rsfp_filters     = Nullav;       \
2564     PL_dirty            = FALSE;        \
2565   } STMT_END
2566     I_REINIT;
2567 #else
2568 #  ifdef MULTIPLICITY
2569 #    define PERLVAR(var,type)
2570 #    define PERLVARA(var,n,type)
2571 #    if defined(PERL_IMPLICIT_CONTEXT)
2572 #      if defined(USE_THREADS)
2573 #        define PERLVARI(var,type,init)         PERL_GET_INTERP->var = init;
2574 #        define PERLVARIC(var,type,init)        PERL_GET_INTERP->var = init;
2575 #      else /* !USE_THREADS */
2576 #        define PERLVARI(var,type,init)         aTHX->var = init;
2577 #        define PERLVARIC(var,type,init)        aTHX->var = init;
2578 #      endif /* USE_THREADS */
2579 #    else
2580 #      define PERLVARI(var,type,init)   PERL_GET_INTERP->var = init;
2581 #      define PERLVARIC(var,type,init)  PERL_GET_INTERP->var = init;
2582 #    endif
2583 #    include "intrpvar.h"
2584 #    ifndef USE_THREADS
2585 #      include "thrdvar.h"
2586 #    endif
2587 #    undef PERLVAR
2588 #    undef PERLVARA
2589 #    undef PERLVARI
2590 #    undef PERLVARIC
2591 #  else
2592 #    define PERLVAR(var,type)
2593 #    define PERLVARA(var,n,type)
2594 #    define PERLVARI(var,type,init)     PL_##var = init;
2595 #    define PERLVARIC(var,type,init)    PL_##var = init;
2596 #    include "intrpvar.h"
2597 #    ifndef USE_THREADS
2598 #      include "thrdvar.h"
2599 #    endif
2600 #    undef PERLVAR
2601 #    undef PERLVARA
2602 #    undef PERLVARI
2603 #    undef PERLVARIC
2604 #  endif
2605 #endif
2606
2607 }
2608
2609 STATIC void
2610 S_init_main_stash(pTHX)
2611 {
2612     GV *gv;
2613
2614     /* Note that strtab is a rather special HV.  Assumptions are made
2615        about not iterating on it, and not adding tie magic to it.
2616        It is properly deallocated in perl_destruct() */
2617     PL_strtab = newHV();
2618 #ifdef USE_THREADS
2619     MUTEX_INIT(&PL_strtab_mutex);
2620 #endif
2621     HvSHAREKEYS_off(PL_strtab);                 /* mandatory */
2622     hv_ksplit(PL_strtab, 512);
2623
2624     PL_curstash = PL_defstash = newHV();
2625     PL_curstname = newSVpvn("main",4);
2626     gv = gv_fetchpv("main::",TRUE, SVt_PVHV);
2627     SvREFCNT_dec(GvHV(gv));
2628     GvHV(gv) = (HV*)SvREFCNT_inc(PL_defstash);
2629     SvREADONLY_on(gv);
2630     HvNAME(PL_defstash) = savepv("main");
2631     PL_incgv = gv_HVadd(gv_AVadd(gv_fetchpv("INC",TRUE, SVt_PVAV)));
2632     GvMULTI_on(PL_incgv);
2633     PL_hintgv = gv_fetchpv("\010",TRUE, SVt_PV); /* ^H */
2634     GvMULTI_on(PL_hintgv);
2635     PL_defgv = gv_fetchpv("_",TRUE, SVt_PVAV);
2636     PL_errgv = gv_HVadd(gv_fetchpv("@", TRUE, SVt_PV));
2637     GvMULTI_on(PL_errgv);
2638     PL_replgv = gv_fetchpv("\022", TRUE, SVt_PV); /* ^R */
2639     GvMULTI_on(PL_replgv);
2640     (void)Perl_form(aTHX_ "%240s","");  /* Preallocate temp - for immediate signals. */
2641     sv_grow(ERRSV, 240);        /* Preallocate - for immediate signals. */
2642     sv_setpvn(ERRSV, "", 0);
2643     PL_curstash = PL_defstash;
2644     CopSTASH_set(&PL_compiling, PL_defstash);
2645     PL_debstash = GvHV(gv_fetchpv("DB::", GV_ADDMULTI, SVt_PVHV));
2646     PL_globalstash = GvHV(gv_fetchpv("CORE::GLOBAL::", GV_ADDMULTI, SVt_PVHV));
2647     PL_nullstash = GvHV(gv_fetchpv("<none>::", GV_ADDMULTI, SVt_PVHV));
2648     /* We must init $/ before switches are processed. */
2649     sv_setpvn(get_sv("/", TRUE), "\n", 1);
2650 }
2651
2652 STATIC void
2653 S_open_script(pTHX_ char *scriptname, bool dosearch, SV *sv, int *fdscript)
2654 {
2655     *fdscript = -1;
2656
2657     if (PL_e_script) {
2658         PL_origfilename = savepv("-e");
2659     }
2660     else {
2661         /* if find_script() returns, it returns a malloc()-ed value */
2662         PL_origfilename = scriptname = find_script(scriptname, dosearch, NULL, 1);
2663
2664         if (strnEQ(scriptname, "/dev/fd/", 8) && isDIGIT(scriptname[8]) ) {
2665             char *s = scriptname + 8;
2666             *fdscript = atoi(s);
2667             while (isDIGIT(*s))
2668                 s++;
2669             if (*s) {
2670                 scriptname = savepv(s + 1);
2671                 Safefree(PL_origfilename);
2672                 PL_origfilename = scriptname;
2673             }
2674         }
2675     }
2676
2677 #ifdef USE_ITHREADS
2678     Safefree(CopFILE(PL_curcop));
2679 #else
2680     SvREFCNT_dec(CopFILEGV(PL_curcop));
2681 #endif
2682     CopFILE_set(PL_curcop, PL_origfilename);
2683     if (strEQ(PL_origfilename,"-"))
2684         scriptname = "";
2685     if (*fdscript >= 0) {
2686         PL_rsfp = PerlIO_fdopen(*fdscript,PERL_SCRIPT_MODE);
2687 #if defined(HAS_FCNTL) && defined(F_SETFD)
2688         if (PL_rsfp)
2689             fcntl(PerlIO_fileno(PL_rsfp),F_SETFD,1);  /* ensure close-on-exec */
2690 #endif
2691     }
2692     else if (PL_preprocess) {
2693         char *cpp_cfg = CPPSTDIN;
2694         SV *cpp = newSVpvn("",0);
2695         SV *cmd = NEWSV(0,0);
2696
2697         if (strEQ(cpp_cfg, "cppstdin"))
2698             Perl_sv_catpvf(aTHX_ cpp, "%s/", BIN_EXP);
2699         sv_catpv(cpp, cpp_cfg);
2700
2701         sv_catpvn(sv, "-I", 2);
2702         sv_catpv(sv,PRIVLIB_EXP);
2703
2704         DEBUG_P(PerlIO_printf(Perl_debug_log,
2705                               "PL_preprocess: scriptname=\"%s\", cpp=\"%s\", sv=\"%s\", CPPMINUS=\"%s\"\n",
2706                               scriptname, SvPVX (cpp), SvPVX (sv), CPPMINUS));
2707 #if defined(MSDOS) || defined(WIN32)
2708         Perl_sv_setpvf(aTHX_ cmd, "\
2709 sed %s -e \"/^[^#]/b\" \
2710  -e \"/^#[      ]*include[      ]/b\" \
2711  -e \"/^#[      ]*define[       ]/b\" \
2712  -e \"/^#[      ]*if[   ]/b\" \
2713  -e \"/^#[      ]*ifdef[        ]/b\" \
2714  -e \"/^#[      ]*ifndef[       ]/b\" \
2715  -e \"/^#[      ]*else/b\" \
2716  -e \"/^#[      ]*elif[         ]/b\" \
2717  -e \"/^#[      ]*undef[        ]/b\" \
2718  -e \"/^#[      ]*endif/b\" \
2719  -e \"s/^#.*//\" \
2720  %s | %"SVf" -C %"SVf" %s",
2721           (PL_doextract ? "-e \"1,/^#/d\n\"" : ""),
2722 #else
2723 #  ifdef __OPEN_VM
2724         Perl_sv_setpvf(aTHX_ cmd, "\
2725 %s %s -e '/^[^#]/b' \
2726  -e '/^#[       ]*include[      ]/b' \
2727  -e '/^#[       ]*define[       ]/b' \
2728  -e '/^#[       ]*if[   ]/b' \
2729  -e '/^#[       ]*ifdef[        ]/b' \
2730  -e '/^#[       ]*ifndef[       ]/b' \
2731  -e '/^#[       ]*else/b' \
2732  -e '/^#[       ]*elif[         ]/b' \
2733  -e '/^#[       ]*undef[        ]/b' \
2734  -e '/^#[       ]*endif/b' \
2735  -e 's/^[       ]*#.*//' \
2736  %s | %"SVf" %"SVf" %s",
2737 #  else
2738         Perl_sv_setpvf(aTHX_ cmd, "\
2739 %s %s -e '/^[^#]/b' \
2740  -e '/^#[       ]*include[      ]/b' \
2741  -e '/^#[       ]*define[       ]/b' \
2742  -e '/^#[       ]*if[   ]/b' \
2743  -e '/^#[       ]*ifdef[        ]/b' \
2744  -e '/^#[       ]*ifndef[       ]/b' \
2745  -e '/^#[       ]*else/b' \
2746  -e '/^#[       ]*elif[         ]/b' \
2747  -e '/^#[       ]*undef[        ]/b' \
2748  -e '/^#[       ]*endif/b' \
2749  -e 's/^[       ]*#.*//' \
2750  %s | %"SVf" -C %"SVf" %s",
2751 #  endif
2752 #ifdef LOC_SED
2753           LOC_SED,
2754 #else
2755           "sed",
2756 #endif
2757           (PL_doextract ? "-e '1,/^#/d\n'" : ""),
2758 #endif
2759           scriptname, cpp, sv, CPPMINUS);
2760         PL_doextract = FALSE;
2761 #ifdef IAMSUID                          /* actually, this is caught earlier */
2762         if (PL_euid != PL_uid && !PL_euid) {    /* if running suidperl */
2763 #ifdef HAS_SETEUID
2764             (void)seteuid(PL_uid);              /* musn't stay setuid root */
2765 #else
2766 #ifdef HAS_SETREUID
2767             (void)setreuid((Uid_t)-1, PL_uid);
2768 #else
2769 #ifdef HAS_SETRESUID
2770             (void)setresuid((Uid_t)-1, PL_uid, (Uid_t)-1);
2771 #else
2772             PerlProc_setuid(PL_uid);
2773 #endif
2774 #endif
2775 #endif
2776             if (PerlProc_geteuid() != PL_uid)
2777                 Perl_croak(aTHX_ "Can't do seteuid!\n");
2778         }
2779 #endif /* IAMSUID */
2780         PL_rsfp = PerlProc_popen(SvPVX(cmd), "r");
2781         SvREFCNT_dec(cmd);
2782         SvREFCNT_dec(cpp);
2783     }
2784     else if (!*scriptname) {
2785         forbid_setid("program input from stdin");
2786         PL_rsfp = PerlIO_stdin();
2787     }
2788     else {
2789         PL_rsfp = PerlIO_open(scriptname,PERL_SCRIPT_MODE);
2790 #if defined(HAS_FCNTL) && defined(F_SETFD)
2791         if (PL_rsfp)
2792             fcntl(PerlIO_fileno(PL_rsfp),F_SETFD,1);  /* ensure close-on-exec */
2793 #endif
2794     }
2795     if (!PL_rsfp) {
2796 #ifdef DOSUID
2797 #ifndef IAMSUID         /* in case script is not readable before setuid */
2798         if (PL_euid &&
2799             PerlLIO_stat(CopFILE(PL_curcop),&PL_statbuf) >= 0 &&
2800             PL_statbuf.st_mode & (S_ISUID|S_ISGID))
2801         {
2802             /* try again */
2803             PerlProc_execv(Perl_form(aTHX_ "%s/sperl"PERL_FS_VER_FMT, BIN_EXP,
2804                                      (int)PERL_REVISION, (int)PERL_VERSION,
2805                                      (int)PERL_SUBVERSION), PL_origargv);
2806             Perl_croak(aTHX_ "Can't do setuid\n");
2807         }
2808 #endif
2809 #endif
2810 #ifdef IAMSUID
2811         errno = EPERM;
2812         Perl_croak(aTHX_ "Can't open perl script: %s\n",
2813                    Strerror(errno));
2814 #else
2815         Perl_croak(aTHX_ "Can't open perl script \"%s\": %s\n",
2816                    CopFILE(PL_curcop), Strerror(errno));
2817 #endif
2818     }
2819 }
2820
2821 /* Mention
2822  * I_SYSSTATVFS HAS_FSTATVFS
2823  * I_SYSMOUNT
2824  * I_STATFS     HAS_FSTATFS     HAS_GETFSSTAT
2825  * I_MNTENT     HAS_GETMNTENT   HAS_HASMNTOPT
2826  * here so that metaconfig picks them up. */
2827
2828 #ifdef IAMSUID
2829 STATIC int
2830 S_fd_on_nosuid_fs(pTHX_ int fd)
2831 {
2832     int check_okay = 0; /* able to do all the required sys/libcalls */
2833     int on_nosuid  = 0; /* the fd is on a nosuid fs */
2834 /*
2835  * Preferred order: fstatvfs(), fstatfs(), ustat()+getmnt(), getmntent().
2836  * fstatvfs() is UNIX98.
2837  * fstatfs() is 4.3 BSD.
2838  * ustat()+getmnt() is pre-4.3 BSD.
2839  * getmntent() is O(number-of-mounted-filesystems) and can hang on
2840  * an irrelevant filesystem while trying to reach the right one.
2841  */
2842
2843 #undef FD_ON_NOSUID_CHECK_OKAY  /* found the syscalls to do the check? */
2844
2845 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
2846         defined(HAS_FSTATVFS)
2847 #   define FD_ON_NOSUID_CHECK_OKAY
2848     struct statvfs stfs;
2849
2850     check_okay = fstatvfs(fd, &stfs) == 0;
2851     on_nosuid  = check_okay && (stfs.f_flag  & ST_NOSUID);
2852 #   endif /* fstatvfs */
2853
2854 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
2855         defined(PERL_MOUNT_NOSUID)      && \
2856         defined(HAS_FSTATFS)            && \
2857         defined(HAS_STRUCT_STATFS)      && \
2858         defined(HAS_STRUCT_STATFS_F_FLAGS)
2859 #   define FD_ON_NOSUID_CHECK_OKAY
2860     struct statfs  stfs;
2861
2862     check_okay = fstatfs(fd, &stfs)  == 0;
2863     on_nosuid  = check_okay && (stfs.f_flags & PERL_MOUNT_NOSUID);
2864 #   endif /* fstatfs */
2865
2866 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
2867         defined(PERL_MOUNT_NOSUID)      && \
2868         defined(HAS_FSTAT)              && \
2869         defined(HAS_USTAT)              && \
2870         defined(HAS_GETMNT)             && \
2871         defined(HAS_STRUCT_FS_DATA)     && \
2872         defined(NOSTAT_ONE)
2873 #   define FD_ON_NOSUID_CHECK_OKAY
2874     struct stat fdst;
2875
2876     if (fstat(fd, &fdst) == 0) {
2877         struct ustat us;
2878         if (ustat(fdst.st_dev, &us) == 0) {
2879             struct fs_data fsd;
2880             /* NOSTAT_ONE here because we're not examining fields which
2881              * vary between that case and STAT_ONE. */
2882             if (getmnt((int*)0, &fsd, (int)0, NOSTAT_ONE, us.f_fname) == 0) {
2883                 size_t cmplen = sizeof(us.f_fname);
2884                 if (sizeof(fsd.fd_req.path) < cmplen)
2885                     cmplen = sizeof(fsd.fd_req.path);
2886                 if (strnEQ(fsd.fd_req.path, us.f_fname, cmplen) &&
2887                     fdst.st_dev == fsd.fd_req.dev) {
2888                         check_okay = 1;
2889                         on_nosuid = fsd.fd_req.flags & PERL_MOUNT_NOSUID;
2890                     }
2891                 }
2892             }
2893         }
2894     }
2895 #   endif /* fstat+ustat+getmnt */
2896
2897 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
2898         defined(HAS_GETMNTENT)          && \
2899         defined(HAS_HASMNTOPT)          && \
2900         defined(MNTOPT_NOSUID)
2901 #   define FD_ON_NOSUID_CHECK_OKAY
2902     FILE                *mtab = fopen("/etc/mtab", "r");
2903     struct mntent       *entry;
2904     struct stat         stb, fsb;
2905
2906     if (mtab && (fstat(fd, &stb) == 0)) {
2907         while (entry = getmntent(mtab)) {
2908             if (stat(entry->mnt_dir, &fsb) == 0
2909                 && fsb.st_dev == stb.st_dev)
2910             {
2911                 /* found the filesystem */
2912                 check_okay = 1;
2913                 if (hasmntopt(entry, MNTOPT_NOSUID))
2914                     on_nosuid = 1;
2915                 break;
2916             } /* A single fs may well fail its stat(). */
2917         }
2918     }
2919     if (mtab)
2920         fclose(mtab);
2921 #   endif /* getmntent+hasmntopt */
2922
2923     if (!check_okay)
2924         Perl_croak(aTHX_ "Can't check filesystem of script \"%s\" for nosuid", PL_origfilename);
2925     return on_nosuid;
2926 }
2927 #endif /* IAMSUID */
2928
2929 STATIC void
2930 S_validate_suid(pTHX_ char *validarg, char *scriptname, int fdscript)
2931 {
2932 #ifdef IAMSUID
2933     int which;
2934 #endif
2935
2936     /* do we need to emulate setuid on scripts? */
2937
2938     /* This code is for those BSD systems that have setuid #! scripts disabled
2939      * in the kernel because of a security problem.  Merely defining DOSUID
2940      * in perl will not fix that problem, but if you have disabled setuid
2941      * scripts in the kernel, this will attempt to emulate setuid and setgid
2942      * on scripts that have those now-otherwise-useless bits set.  The setuid
2943      * root version must be called suidperl or sperlN.NNN.  If regular perl
2944      * discovers that it has opened a setuid script, it calls suidperl with
2945      * the same argv that it had.  If suidperl finds that the script it has
2946      * just opened is NOT setuid root, it sets the effective uid back to the
2947      * uid.  We don't just make perl setuid root because that loses the
2948      * effective uid we had before invoking perl, if it was different from the
2949      * uid.
2950      *
2951      * DOSUID must be defined in both perl and suidperl, and IAMSUID must
2952      * be defined in suidperl only.  suidperl must be setuid root.  The
2953      * Configure script will set this up for you if you want it.
2954      */
2955
2956 #ifdef DOSUID
2957     char *s, *s2;
2958
2959     if (PerlLIO_fstat(PerlIO_fileno(PL_rsfp),&PL_statbuf) < 0)  /* normal stat is insecure */
2960         Perl_croak(aTHX_ "Can't stat script \"%s\"",PL_origfilename);
2961     if (fdscript < 0 && PL_statbuf.st_mode & (S_ISUID|S_ISGID)) {
2962         I32 len;
2963         STRLEN n_a;
2964
2965 #ifdef IAMSUID
2966 #ifndef HAS_SETREUID
2967         /* On this access check to make sure the directories are readable,
2968          * there is actually a small window that the user could use to make
2969          * filename point to an accessible directory.  So there is a faint
2970          * chance that someone could execute a setuid script down in a
2971          * non-accessible directory.  I don't know what to do about that.
2972          * But I don't think it's too important.  The manual lies when
2973          * it says access() is useful in setuid programs.
2974          */
2975         if (PerlLIO_access(CopFILE(PL_curcop),1)) /*double check*/
2976             Perl_croak(aTHX_ "Permission denied");
2977 #else
2978         /* If we can swap euid and uid, then we can determine access rights
2979          * with a simple stat of the file, and then compare device and
2980          * inode to make sure we did stat() on the same file we opened.
2981          * Then we just have to make sure he or she can execute it.
2982          */
2983         {
2984             struct stat tmpstatbuf;
2985
2986             if (
2987 #ifdef HAS_SETREUID
2988                 setreuid(PL_euid,PL_uid) < 0
2989 #else
2990 # if HAS_SETRESUID
2991                 setresuid(PL_euid,PL_uid,(Uid_t)-1) < 0
2992 # endif
2993 #endif
2994                 || PerlProc_getuid() != PL_euid || PerlProc_geteuid() != PL_uid)
2995                 Perl_croak(aTHX_ "Can't swap uid and euid");    /* really paranoid */
2996             if (PerlLIO_stat(CopFILE(PL_curcop),&tmpstatbuf) < 0)
2997                 Perl_croak(aTHX_ "Permission denied");  /* testing full pathname here */
2998 #if defined(IAMSUID) && !defined(NO_NOSUID_CHECK)
2999             if (fd_on_nosuid_fs(PerlIO_fileno(PL_rsfp)))
3000                 Perl_croak(aTHX_ "Permission denied");
3001 #endif
3002             if (tmpstatbuf.st_dev != PL_statbuf.st_dev ||
3003                 tmpstatbuf.st_ino != PL_statbuf.st_ino) {
3004                 (void)PerlIO_close(PL_rsfp);
3005                 Perl_croak(aTHX_ "Permission denied\n");
3006             }
3007             if (
3008 #ifdef HAS_SETREUID
3009               setreuid(PL_uid,PL_euid) < 0
3010 #else
3011 # if defined(HAS_SETRESUID)
3012               setresuid(PL_uid,PL_euid,(Uid_t)-1) < 0
3013 # endif
3014 #endif
3015               || PerlProc_getuid() != PL_uid || PerlProc_geteuid() != PL_euid)
3016                 Perl_croak(aTHX_ "Can't reswap uid and euid");
3017             if (!cando(S_IXUSR,FALSE,&PL_statbuf))              /* can real uid exec? */
3018                 Perl_croak(aTHX_ "Permission denied\n");
3019         }
3020 #endif /* HAS_SETREUID */
3021 #endif /* IAMSUID */
3022
3023         if (!S_ISREG(PL_statbuf.st_mode))
3024             Perl_croak(aTHX_ "Permission denied");
3025         if (PL_statbuf.st_mode & S_IWOTH)
3026             Perl_croak(aTHX_ "Setuid/gid script is writable by world");
3027         PL_doswitches = FALSE;          /* -s is insecure in suid */
3028         CopLINE_inc(PL_curcop);
3029         if (sv_gets(PL_linestr, PL_rsfp, 0) == Nullch ||
3030           strnNE(SvPV(PL_linestr,n_a),"#!",2) ) /* required even on Sys V */
3031             Perl_croak(aTHX_ "No #! line");
3032         s = SvPV(PL_linestr,n_a)+2;
3033         if (*s == ' ') s++;
3034         while (!isSPACE(*s)) s++;
3035         for (s2 = s;  (s2 > SvPV(PL_linestr,n_a)+2 &&
3036                        (isDIGIT(s2[-1]) || strchr("._-", s2[-1])));  s2--) ;
3037         if (strnNE(s2-4,"perl",4) && strnNE(s-9,"perl",4))  /* sanity check */
3038             Perl_croak(aTHX_ "Not a perl script");
3039         while (*s == ' ' || *s == '\t') s++;
3040         /*
3041          * #! arg must be what we saw above.  They can invoke it by
3042          * mentioning suidperl explicitly, but they may not add any strange
3043          * arguments beyond what #! says if they do invoke suidperl that way.
3044          */
3045         len = strlen(validarg);
3046         if (strEQ(validarg," PHOOEY ") ||
3047             strnNE(s,validarg,len) || !isSPACE(s[len]))
3048             Perl_croak(aTHX_ "Args must match #! line");
3049
3050 #ifndef IAMSUID
3051         if (PL_euid != PL_uid && (PL_statbuf.st_mode & S_ISUID) &&
3052             PL_euid == PL_statbuf.st_uid)
3053             if (!PL_do_undump)
3054                 Perl_croak(aTHX_ "YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!\n\
3055 FIX YOUR KERNEL, PUT A C WRAPPER AROUND THIS SCRIPT, OR USE -u AND UNDUMP!\n");
3056 #endif /* IAMSUID */
3057
3058         if (PL_euid) {  /* oops, we're not the setuid root perl */
3059             (void)PerlIO_close(PL_rsfp);
3060 #ifndef IAMSUID
3061             /* try again */
3062             PerlProc_execv(Perl_form(aTHX_ "%s/sperl"PERL_FS_VER_FMT, BIN_EXP,
3063                                      (int)PERL_REVISION, (int)PERL_VERSION,
3064                                      (int)PERL_SUBVERSION), PL_origargv);
3065 #endif
3066             Perl_croak(aTHX_ "Can't do setuid\n");
3067         }
3068
3069         if (PL_statbuf.st_mode & S_ISGID && PL_statbuf.st_gid != PL_egid) {
3070 #ifdef HAS_SETEGID
3071             (void)setegid(PL_statbuf.st_gid);
3072 #else
3073 #ifdef HAS_SETREGID
3074            (void)setregid((Gid_t)-1,PL_statbuf.st_gid);
3075 #else
3076 #ifdef HAS_SETRESGID
3077            (void)setresgid((Gid_t)-1,PL_statbuf.st_gid,(Gid_t)-1);
3078 #else
3079             PerlProc_setgid(PL_statbuf.st_gid);
3080 #endif
3081 #endif
3082 #endif
3083             if (PerlProc_getegid() != PL_statbuf.st_gid)
3084                 Perl_croak(aTHX_ "Can't do setegid!\n");
3085         }
3086         if (PL_statbuf.st_mode & S_ISUID) {
3087             if (PL_statbuf.st_uid != PL_euid)
3088 #ifdef HAS_SETEUID
3089                 (void)seteuid(PL_statbuf.st_uid);       /* all that for this */
3090 #else
3091 #ifdef HAS_SETREUID
3092                 (void)setreuid((Uid_t)-1,PL_statbuf.st_uid);
3093 #else
3094 #ifdef HAS_SETRESUID
3095                 (void)setresuid((Uid_t)-1,PL_statbuf.st_uid,(Uid_t)-1);
3096 #else
3097                 PerlProc_setuid(PL_statbuf.st_uid);
3098 #endif
3099 #endif
3100 #endif
3101             if (PerlProc_geteuid() != PL_statbuf.st_uid)
3102                 Perl_croak(aTHX_ "Can't do seteuid!\n");
3103         }
3104         else if (PL_uid) {                      /* oops, mustn't run as root */
3105 #ifdef HAS_SETEUID
3106           (void)seteuid((Uid_t)PL_uid);
3107 #else
3108 #ifdef HAS_SETREUID
3109           (void)setreuid((Uid_t)-1,(Uid_t)PL_uid);
3110 #else
3111 #ifdef HAS_SETRESUID
3112           (void)setresuid((Uid_t)-1,(Uid_t)PL_uid,(Uid_t)-1);
3113 #else
3114           PerlProc_setuid((Uid_t)PL_uid);
3115 #endif
3116 #endif
3117 #endif
3118             if (PerlProc_geteuid() != PL_uid)
3119                 Perl_croak(aTHX_ "Can't do seteuid!\n");
3120         }
3121         init_ids();
3122         if (!cando(S_IXUSR,TRUE,&PL_statbuf))
3123             Perl_croak(aTHX_ "Permission denied\n");    /* they can't do this */
3124     }
3125 #ifdef IAMSUID
3126     else if (PL_preprocess)
3127         Perl_croak(aTHX_ "-P not allowed for setuid/setgid script\n");
3128     else if (fdscript >= 0)
3129         Perl_croak(aTHX_ "fd script not allowed in suidperl\n");
3130     else
3131         Perl_croak(aTHX_ "Script is not setuid/setgid in suidperl\n");
3132
3133     /* We absolutely must clear out any saved ids here, so we */
3134     /* exec the real perl, substituting fd script for scriptname. */
3135     /* (We pass script name as "subdir" of fd, which perl will grok.) */
3136     PerlIO_rewind(PL_rsfp);
3137     PerlLIO_lseek(PerlIO_fileno(PL_rsfp),(Off_t)0,0);  /* just in case rewind didn't */
3138     for (which = 1; PL_origargv[which] && PL_origargv[which] != scriptname; which++) ;
3139     if (!PL_origargv[which])
3140         Perl_croak(aTHX_ "Permission denied");
3141     PL_origargv[which] = savepv(Perl_form(aTHX_ "/dev/fd/%d/%s",
3142                                   PerlIO_fileno(PL_rsfp), PL_origargv[which]));
3143 #if defined(HAS_FCNTL) && defined(F_SETFD)
3144     fcntl(PerlIO_fileno(PL_rsfp),F_SETFD,0);    /* ensure no close-on-exec */
3145 #endif
3146     PerlProc_execv(Perl_form(aTHX_ "%s/perl"PERL_FS_VER_FMT, BIN_EXP,
3147                              (int)PERL_REVISION, (int)PERL_VERSION,
3148                              (int)PERL_SUBVERSION), PL_origargv);/* try again */
3149     Perl_croak(aTHX_ "Can't do setuid\n");
3150 #endif /* IAMSUID */
3151 #else /* !DOSUID */
3152     if (PL_euid != PL_uid || PL_egid != PL_gid) {       /* (suidperl doesn't exist, in fact) */
3153 #ifndef SETUID_SCRIPTS_ARE_SECURE_NOW
3154         PerlLIO_fstat(PerlIO_fileno(PL_rsfp),&PL_statbuf);      /* may be either wrapped or real suid */
3155         if ((PL_euid != PL_uid && PL_euid == PL_statbuf.st_uid && PL_statbuf.st_mode & S_ISUID)
3156             ||
3157             (PL_egid != PL_gid && PL_egid == PL_statbuf.st_gid && PL_statbuf.st_mode & S_ISGID)
3158            )
3159             if (!PL_do_undump)
3160                 Perl_croak(aTHX_ "YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!\n\
3161 FIX YOUR KERNEL, PUT A C WRAPPER AROUND THIS SCRIPT, OR USE -u AND UNDUMP!\n");
3162 #endif /* SETUID_SCRIPTS_ARE_SECURE_NOW */
3163         /* not set-id, must be wrapped */
3164     }
3165 #endif /* DOSUID */
3166 }
3167
3168 STATIC void
3169 S_find_beginning(pTHX)
3170 {
3171     register char *s, *s2;
3172
3173     /* skip forward in input to the real script? */
3174
3175     forbid_setid("-x");
3176 #ifdef MACOS_TRADITIONAL
3177     /* Since the Mac OS does not honor #! arguments for us, we do it ourselves */
3178
3179     while (PL_doextract || gMacPerl_AlwaysExtract) {
3180         if ((s = sv_gets(PL_linestr, PL_rsfp, 0)) == Nullch) {
3181             if (!gMacPerl_AlwaysExtract)
3182                 Perl_croak(aTHX_ "No Perl script found in input\n");
3183
3184             if (PL_doextract)                   /* require explicit override ? */
3185                 if (!OverrideExtract(PL_origfilename))
3186                     Perl_croak(aTHX_ "User aborted script\n");
3187                 else
3188                     PL_doextract = FALSE;
3189
3190             /* Pater peccavi, file does not have #! */
3191             PerlIO_rewind(PL_rsfp);
3192
3193             break;
3194         }
3195 #else
3196     while (PL_doextract) {
3197         if ((s = sv_gets(PL_linestr, PL_rsfp, 0)) == Nullch)
3198             Perl_croak(aTHX_ "No Perl script found in input\n");
3199 #endif
3200         s2 = s;
3201         if (*s == '#' && s[1] == '!' && ((s = instr(s,"perl")) || (s = instr(s2,"PERL")))) {
3202             PerlIO_ungetc(PL_rsfp, '\n');               /* to keep line count right */
3203             PL_doextract = FALSE;
3204             while (*s && !(isSPACE (*s) || *s == '#')) s++;
3205             s2 = s;
3206             while (*s == ' ' || *s == '\t') s++;
3207             if (*s++ == '-') {
3208                 while (isDIGIT(s2[-1]) || strchr("-._", s2[-1])) s2--;
3209                 if (strnEQ(s2-4,"perl",4))
3210                     /*SUPPRESS 530*/
3211                     while ((s = moreswitches(s)))
3212                         ;
3213             }
3214 #ifdef MACOS_TRADITIONAL
3215             break;
3216 #endif
3217         }
3218     }
3219 }
3220
3221
3222 STATIC void
3223 S_init_ids(pTHX)
3224 {
3225     PL_uid = PerlProc_getuid();
3226     PL_euid = PerlProc_geteuid();
3227     PL_gid = PerlProc_getgid();
3228     PL_egid = PerlProc_getegid();
3229 #ifdef VMS
3230     PL_uid |= PL_gid << 16;
3231     PL_euid |= PL_egid << 16;
3232 #endif
3233     PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
3234 }
3235
3236 STATIC void
3237 S_forbid_setid(pTHX_ char *s)
3238 {
3239     if (PL_euid != PL_uid)
3240         Perl_croak(aTHX_ "No %s allowed while running setuid", s);
3241     if (PL_egid != PL_gid)
3242         Perl_croak(aTHX_ "No %s allowed while running setgid", s);
3243 }
3244
3245 void
3246 Perl_init_debugger(pTHX)
3247 {
3248     HV *ostash = PL_curstash;
3249
3250     PL_curstash = PL_debstash;
3251     PL_dbargs = GvAV(gv_AVadd((gv_fetchpv("args", GV_ADDMULTI, SVt_PVAV))));
3252     AvREAL_off(PL_dbargs);
3253     PL_DBgv = gv_fetchpv("DB", GV_ADDMULTI, SVt_PVGV);
3254     PL_DBline = gv_fetchpv("dbline", GV_ADDMULTI, SVt_PVAV);
3255     PL_DBsub = gv_HVadd(gv_fetchpv("sub", GV_ADDMULTI, SVt_PVHV));
3256     sv_upgrade(GvSV(PL_DBsub), SVt_IV); /* IVX accessed if PERLDB_SUB_NN */
3257     PL_DBsingle = GvSV((gv_fetchpv("single", GV_ADDMULTI, SVt_PV)));
3258     sv_setiv(PL_DBsingle, 0);
3259     PL_DBtrace = GvSV((gv_fetchpv("trace", GV_ADDMULTI, SVt_PV)));
3260     sv_setiv(PL_DBtrace, 0);
3261     PL_DBsignal = GvSV((gv_fetchpv("signal", GV_ADDMULTI, SVt_PV)));
3262     sv_setiv(PL_DBsignal, 0);
3263     PL_curstash = ostash;
3264 }
3265
3266 #ifndef STRESS_REALLOC
3267 #define REASONABLE(size) (size)
3268 #else
3269 #define REASONABLE(size) (1) /* unreasonable */
3270 #endif
3271
3272 void
3273 Perl_init_stacks(pTHX)
3274 {
3275     /* start with 128-item stack and 8K cxstack */
3276     PL_curstackinfo = new_stackinfo(REASONABLE(128),
3277                                  REASONABLE(8192/sizeof(PERL_CONTEXT) - 1));
3278     PL_curstackinfo->si_type = PERLSI_MAIN;
3279     PL_curstack = PL_curstackinfo->si_stack;
3280     PL_mainstack = PL_curstack;         /* remember in case we switch stacks */
3281
3282     PL_stack_base = AvARRAY(PL_curstack);
3283     PL_stack_sp = PL_stack_base;
3284     PL_stack_max = PL_stack_base + AvMAX(PL_curstack);
3285
3286     New(50,PL_tmps_stack,REASONABLE(128),SV*);
3287     PL_tmps_floor = -1;
3288     PL_tmps_ix = -1;
3289     PL_tmps_max = REASONABLE(128);
3290
3291     New(54,PL_markstack,REASONABLE(32),I32);
3292     PL_markstack_ptr = PL_markstack;
3293     PL_markstack_max = PL_markstack + REASONABLE(32);
3294
3295     SET_MARK_OFFSET;
3296
3297     New(54,PL_scopestack,REASONABLE(32),I32);
3298     PL_scopestack_ix = 0;
3299     PL_scopestack_max = REASONABLE(32);
3300
3301     New(54,PL_savestack,REASONABLE(128),ANY);
3302     PL_savestack_ix = 0;
3303     PL_savestack_max = REASONABLE(128);
3304
3305     New(54,PL_retstack,REASONABLE(16),OP*);
3306     PL_retstack_ix = 0;
3307     PL_retstack_max = REASONABLE(16);
3308 }
3309
3310 #undef REASONABLE
3311
3312 STATIC void
3313 S_nuke_stacks(pTHX)
3314 {
3315     while (PL_curstackinfo->si_next)
3316         PL_curstackinfo = PL_curstackinfo->si_next;
3317     while (PL_curstackinfo) {
3318         PERL_SI *p = PL_curstackinfo->si_prev;
3319         /* curstackinfo->si_stack got nuked by sv_free_arenas() */
3320         Safefree(PL_curstackinfo->si_cxstack);
3321         Safefree(PL_curstackinfo);
3322         PL_curstackinfo = p;
3323     }
3324     Safefree(PL_tmps_stack);
3325     Safefree(PL_markstack);
3326     Safefree(PL_scopestack);
3327     Safefree(PL_savestack);
3328     Safefree(PL_retstack);
3329 }
3330
3331 #ifndef PERL_OBJECT
3332 static PerlIO *tmpfp;  /* moved outside init_lexer() because of UNICOS bug */
3333 #endif
3334
3335 STATIC void
3336 S_init_lexer(pTHX)
3337 {
3338 #ifdef PERL_OBJECT
3339         PerlIO *tmpfp;
3340 #endif
3341     tmpfp = PL_rsfp;
3342     PL_rsfp = Nullfp;
3343     lex_start(PL_linestr);
3344     PL_rsfp = tmpfp;
3345     PL_subname = newSVpvn("main",4);
3346 }
3347
3348 STATIC void
3349 S_init_predump_symbols(pTHX)
3350 {
3351     GV *tmpgv;
3352     IO *io;
3353
3354     sv_setpvn(get_sv("\"", TRUE), " ", 1);
3355     PL_stdingv = gv_fetchpv("STDIN",TRUE, SVt_PVIO);
3356     GvMULTI_on(PL_stdingv);
3357     io = GvIOp(PL_stdingv);
3358     IoTYPE(io) = IoTYPE_RDONLY;
3359     IoIFP(io) = PerlIO_stdin();
3360     tmpgv = gv_fetchpv("stdin",TRUE, SVt_PV);
3361     GvMULTI_on(tmpgv);
3362     GvIOp(tmpgv) = (IO*)SvREFCNT_inc(io);
3363
3364     tmpgv = gv_fetchpv("STDOUT",TRUE, SVt_PVIO);
3365     GvMULTI_on(tmpgv);
3366     io = GvIOp(tmpgv);
3367     IoTYPE(io) = IoTYPE_WRONLY;
3368     IoOFP(io) = IoIFP(io) = PerlIO_stdout();
3369     setdefout(tmpgv);
3370     tmpgv = gv_fetchpv("stdout",TRUE, SVt_PV);
3371     GvMULTI_on(tmpgv);
3372     GvIOp(tmpgv) = (IO*)SvREFCNT_inc(io);
3373
3374     PL_stderrgv = gv_fetchpv("STDERR",TRUE, SVt_PVIO);
3375     GvMULTI_on(PL_stderrgv);
3376     io = GvIOp(PL_stderrgv);
3377     IoTYPE(io) = IoTYPE_WRONLY;
3378     IoOFP(io) = IoIFP(io) = PerlIO_stderr();
3379     tmpgv = gv_fetchpv("stderr",TRUE, SVt_PV);
3380     GvMULTI_on(tmpgv);
3381     GvIOp(tmpgv) = (IO*)SvREFCNT_inc(io);
3382
3383     PL_statname = NEWSV(66,0);          /* last filename we did stat on */
3384
3385     if (PL_osname)
3386         Safefree(PL_osname);
3387     PL_osname = savepv(OSNAME);
3388 }
3389
3390 STATIC void
3391 S_init_postdump_symbols(pTHX_ register int argc, register char **argv, register char **env)
3392 {
3393     char *s;
3394     SV *sv;
3395     GV* tmpgv;
3396 #ifdef NEED_ENVIRON_DUP_FOR_MODIFY
3397     char **dup_env_base = 0;
3398     int dup_env_count = 0;
3399 #endif
3400
3401     argc--,argv++;      /* skip name of script */
3402     if (PL_doswitches) {
3403         for (; argc > 0 && **argv == '-'; argc--,argv++) {
3404             if (!argv[0][1])
3405                 break;
3406             if (argv[0][1] == '-' && !argv[0][2]) {
3407                 argc--,argv++;
3408                 break;
3409             }
3410             if ((s = strchr(argv[0], '='))) {
3411                 *s++ = '\0';
3412                 sv_setpv(GvSV(gv_fetchpv(argv[0]+1,TRUE, SVt_PV)),s);
3413             }
3414             else
3415                 sv_setiv(GvSV(gv_fetchpv(argv[0]+1,TRUE, SVt_PV)),1);
3416         }
3417     }
3418     PL_toptarget = NEWSV(0,0);
3419     sv_upgrade(PL_toptarget, SVt_PVFM);
3420     sv_setpvn(PL_toptarget, "", 0);
3421     PL_bodytarget = NEWSV(0,0);
3422     sv_upgrade(PL_bodytarget, SVt_PVFM);
3423     sv_setpvn(PL_bodytarget, "", 0);
3424     PL_formtarget = PL_bodytarget;
3425
3426     TAINT;
3427     if ((tmpgv = gv_fetchpv("0",TRUE, SVt_PV))) {
3428 #ifdef MACOS_TRADITIONAL
3429         /* $0 is not majick on a Mac */
3430         sv_setpv(GvSV(tmpgv),MacPerl_MPWFileName(PL_origfilename));
3431 #else
3432         sv_setpv(GvSV(tmpgv),PL_origfilename);
3433         magicname("0", "0", 1);
3434 #endif
3435     }
3436     if ((tmpgv = gv_fetchpv("\030",TRUE, SVt_PV)))
3437 #ifdef OS2
3438         sv_setpv(GvSV(tmpgv), os2_execname(aTHX));
3439 #else
3440         sv_setpv(GvSV(tmpgv),PL_origargv[0]);
3441 #endif
3442     if ((PL_argvgv = gv_fetchpv("ARGV",TRUE, SVt_PVAV))) {
3443         GvMULTI_on(PL_argvgv);
3444         (void)gv_AVadd(PL_argvgv);
3445         av_clear(GvAVn(PL_argvgv));
3446         for (; argc > 0; argc--,argv++) {
3447             SV *sv = newSVpv(argv[0],0);
3448             av_push(GvAVn(PL_argvgv),sv);
3449             if (PL_widesyscalls)
3450                 (void)sv_utf8_decode(sv);
3451         }
3452     }
3453     if ((PL_envgv = gv_fetchpv("ENV",TRUE, SVt_PVHV))) {
3454         HV *hv;
3455         GvMULTI_on(PL_envgv);
3456         hv = GvHVn(PL_envgv);
3457         hv_magic(hv, Nullgv, PERL_MAGIC_env);
3458 #ifdef USE_ENVIRON_ARRAY
3459         /* Note that if the supplied env parameter is actually a copy
3460            of the global environ then it may now point to free'd memory
3461            if the environment has been modified since. To avoid this
3462            problem we treat env==NULL as meaning 'use the default'
3463         */
3464         if (!env)
3465             env = environ;
3466         if (env != environ)
3467             environ[0] = Nullch;
3468 #ifdef NEED_ENVIRON_DUP_FOR_MODIFY
3469         {
3470             char **env_base;
3471             for (env_base = env; *env; env++)
3472                 dup_env_count++;
3473             if ((dup_env_base = (char **)
3474                  safesysmalloc( sizeof(char *) * (dup_env_count+1) ))) {
3475                 char **dup_env;
3476                 for (env = env_base, dup_env = dup_env_base;
3477                      *env;
3478                      env++, dup_env++) {
3479                     /* With environ one needs to use safesysmalloc(). */
3480                     *dup_env = safesysmalloc(strlen(*env) + 1);
3481                     (void)strcpy(*dup_env, *env);
3482                 }
3483                 *dup_env = Nullch;
3484                 env = dup_env_base;
3485             } /* else what? */
3486         }
3487 #endif /* NEED_ENVIRON_DUP_FOR_MODIFY */
3488         if (env)
3489           for (; *env; env++) {
3490             if (!(s = strchr(*env,'=')))
3491                 continue;
3492             *s++ = '\0';
3493 #if defined(MSDOS)
3494             (void)strupr(*env);
3495 #endif
3496             sv = newSVpv(s--,0);
3497             (void)hv_store(hv, *env, s - *env, sv, 0);
3498             *s = '=';
3499           }
3500 #ifdef NEED_ENVIRON_DUP_FOR_MODIFY
3501         if (dup_env_base) {
3502             char **dup_env;
3503             for (dup_env = dup_env_base; *dup_env; dup_env++)
3504                 safesysfree(*dup_env);
3505             safesysfree(dup_env_base);
3506         }
3507 #endif /* NEED_ENVIRON_DUP_FOR_MODIFY */
3508 #endif /* USE_ENVIRON_ARRAY */
3509     }
3510     TAINT_NOT;
3511     if ((tmpgv = gv_fetchpv("$",TRUE, SVt_PV)))
3512         sv_setiv(GvSV(tmpgv), (IV)PerlProc_getpid());
3513 }
3514
3515 STATIC void
3516 S_init_perllib(pTHX)
3517 {
3518     char *s;
3519     if (!PL_tainting) {
3520 #ifndef VMS
3521         s = PerlEnv_getenv("PERL5LIB");
3522         if (s)
3523             incpush(s, TRUE, TRUE);
3524         else
3525             incpush(PerlEnv_getenv("PERLLIB"), FALSE, FALSE);
3526 #else /* VMS */
3527         /* Treat PERL5?LIB as a possible search list logical name -- the
3528          * "natural" VMS idiom for a Unix path string.  We allow each
3529          * element to be a set of |-separated directories for compatibility.
3530          */
3531         char buf[256];
3532         int idx = 0;
3533         if (my_trnlnm("PERL5LIB",buf,0))
3534             do { incpush(buf,TRUE,TRUE); } while (my_trnlnm("PERL5LIB",buf,++idx));
3535         else
3536             while (my_trnlnm("PERLLIB",buf,idx++)) incpush(buf,FALSE,FALSE);
3537 #endif /* VMS */
3538     }
3539
3540 /* Use the ~-expanded versions of APPLLIB (undocumented),
3541     ARCHLIB PRIVLIB SITEARCH SITELIB VENDORARCH and VENDORLIB
3542 */
3543 #ifdef APPLLIB_EXP
3544     incpush(APPLLIB_EXP, TRUE, TRUE);
3545 #endif
3546
3547 #ifdef ARCHLIB_EXP
3548     incpush(ARCHLIB_EXP, FALSE, FALSE);
3549 #endif
3550 #ifdef MACOS_TRADITIONAL
3551     {
3552         struct stat tmpstatbuf;
3553         SV * privdir = NEWSV(55, 0);
3554         char * macperl = PerlEnv_getenv("MACPERL");
3555
3556         if (!macperl)
3557             macperl = "";
3558
3559         Perl_sv_setpvf(aTHX_ privdir, "%slib:", macperl);
3560         if (PerlLIO_stat(SvPVX(privdir), &tmpstatbuf) >= 0 && S_ISDIR(tmpstatbuf.st_mode))
3561             incpush(SvPVX(privdir), TRUE, FALSE);
3562         Perl_sv_setpvf(aTHX_ privdir, "%ssite_perl:", macperl);
3563         if (PerlLIO_stat(SvPVX(privdir), &tmpstatbuf) >= 0 && S_ISDIR(tmpstatbuf.st_mode))
3564             incpush(SvPVX(privdir), TRUE, FALSE);
3565
3566         SvREFCNT_dec(privdir);
3567     }
3568     if (!PL_tainting)
3569         incpush(":", FALSE, FALSE);
3570 #else
3571 #ifndef PRIVLIB_EXP
3572 #  define PRIVLIB_EXP "/usr/local/lib/perl5:/usr/local/lib/perl"
3573 #endif
3574 #if defined(WIN32)
3575     incpush(PRIVLIB_EXP, TRUE, FALSE);
3576 #else
3577     incpush(PRIVLIB_EXP, FALSE, FALSE);
3578 #endif
3579
3580 #ifdef SITEARCH_EXP
3581     /* sitearch is always relative to sitelib on Windows for
3582      * DLL-based path intuition to work correctly */
3583 #  if !defined(WIN32)
3584     incpush(SITEARCH_EXP, FALSE, FALSE);
3585 #  endif
3586 #endif
3587
3588 #ifdef SITELIB_EXP
3589 #  if defined(WIN32)
3590     incpush(SITELIB_EXP, TRUE, FALSE);  /* this picks up sitearch as well */
3591 #  else
3592     incpush(SITELIB_EXP, FALSE, FALSE);
3593 #  endif
3594 #endif
3595
3596 #ifdef SITELIB_STEM /* Search for version-specific dirs below here */
3597     incpush(SITELIB_STEM, FALSE, TRUE);
3598 #endif
3599
3600 #ifdef PERL_VENDORARCH_EXP
3601     /* vendorarch is always relative to vendorlib on Windows for
3602      * DLL-based path intuition to work correctly */
3603 #  if !defined(WIN32)
3604     incpush(PERL_VENDORARCH_EXP, FALSE, FALSE);
3605 #  endif
3606 #endif
3607
3608 #ifdef PERL_VENDORLIB_EXP
3609 #  if defined(WIN32)
3610     incpush(PERL_VENDORLIB_EXP, TRUE, FALSE);   /* this picks up vendorarch as well */
3611 #  else
3612     incpush(PERL_VENDORLIB_EXP, FALSE, FALSE);
3613 #  endif
3614 #endif
3615
3616 #ifdef PERL_VENDORLIB_STEM /* Search for version-specific dirs below here */
3617     incpush(PERL_VENDORLIB_STEM, FALSE, TRUE);
3618 #endif
3619
3620 #ifdef PERL_OTHERLIBDIRS
3621     incpush(PERL_OTHERLIBDIRS, TRUE, TRUE);
3622 #endif
3623
3624     if (!PL_tainting)
3625         incpush(".", FALSE, FALSE);
3626 #endif /* MACOS_TRADITIONAL */
3627 }
3628
3629 #if defined(DOSISH) || defined(EPOC)
3630 #    define PERLLIB_SEP ';'
3631 #else
3632 #  if defined(VMS)
3633 #    define PERLLIB_SEP '|'
3634 #  else
3635 #    if defined(MACOS_TRADITIONAL)
3636 #      define PERLLIB_SEP ','
3637 #    else
3638 #      define PERLLIB_SEP ':'
3639 #    endif
3640 #  endif
3641 #endif
3642 #ifndef PERLLIB_MANGLE
3643 #  define PERLLIB_MANGLE(s,n) (s)
3644 #endif
3645
3646 STATIC void
3647 S_incpush(pTHX_ char *p, int addsubdirs, int addoldvers)
3648 {
3649     SV *subdir = Nullsv;
3650
3651     if (!p || !*p)
3652         return;
3653
3654     if (addsubdirs || addoldvers) {
3655         subdir = sv_newmortal();
3656     }
3657
3658     /* Break at all separators */
3659     while (p && *p) {
3660         SV *libdir = NEWSV(55,0);
3661         char *s;
3662
3663         /* skip any consecutive separators */
3664         while ( *p == PERLLIB_SEP ) {
3665             /* Uncomment the next line for PATH semantics */
3666             /* av_push(GvAVn(PL_incgv), newSVpvn(".", 1)); */
3667             p++;
3668         }
3669
3670         if ( (s = strchr(p, PERLLIB_SEP)) != Nullch ) {
3671             sv_setpvn(libdir, PERLLIB_MANGLE(p, (STRLEN)(s - p)),
3672                       (STRLEN)(s - p));
3673             p = s + 1;
3674         }
3675         else {
3676             sv_setpv(libdir, PERLLIB_MANGLE(p, 0));
3677             p = Nullch; /* break out */
3678         }
3679 #ifdef MACOS_TRADITIONAL
3680         if (!strchr(SvPVX(libdir), ':'))
3681             sv_insert(libdir, 0, 0, ":", 1);
3682         if (SvPVX(libdir)[SvCUR(libdir)-1] != ':')
3683             sv_catpv(libdir, ":");
3684 #endif
3685
3686         /*
3687          * BEFORE pushing libdir onto @INC we may first push version- and
3688          * archname-specific sub-directories.
3689          */
3690         if (addsubdirs || addoldvers) {
3691 #ifdef PERL_INC_VERSION_LIST
3692             /* Configure terminates PERL_INC_VERSION_LIST with a NULL */
3693             const char *incverlist[] = { PERL_INC_VERSION_LIST };
3694             const char **incver;
3695 #endif
3696             struct stat tmpstatbuf;
3697 #ifdef VMS
3698             char *unix;
3699             STRLEN len;
3700
3701             if ((unix = tounixspec_ts(SvPV(libdir,len),Nullch)) != Nullch) {
3702                 len = strlen(unix);
3703                 while (unix[len-1] == '/') len--;  /* Cosmetic */
3704                 sv_usepvn(libdir,unix,len);
3705             }
3706             else
3707                 PerlIO_printf(Perl_error_log,
3708                               "Failed to unixify @INC element \"%s\"\n",
3709                               SvPV(libdir,len));
3710 #endif
3711             if (addsubdirs) {
3712 #ifdef MACOS_TRADITIONAL
3713 #define PERL_AV_SUFFIX_FMT      ""
3714 #define PERL_ARCH_FMT           "%s:"
3715 #define PERL_ARCH_FMT_PATH      PERL_FS_VER_FMT PERL_AV_SUFFIX_FMT
3716 #else
3717 #define PERL_AV_SUFFIX_FMT      "/"
3718 #define PERL_ARCH_FMT           "/%s"
3719 #define PERL_ARCH_FMT_PATH      PERL_AV_SUFFIX_FMT PERL_FS_VER_FMT
3720 #endif
3721                 /* .../version/archname if -d .../version/archname */
3722                 Perl_sv_setpvf(aTHX_ subdir, "%"SVf PERL_ARCH_FMT_PATH PERL_ARCH_FMT,
3723                                 libdir,
3724                                (int)PERL_REVISION, (int)PERL_VERSION,
3725                                (int)PERL_SUBVERSION, ARCHNAME);
3726                 if (PerlLIO_stat(SvPVX(subdir), &tmpstatbuf) >= 0 &&
3727                       S_ISDIR(tmpstatbuf.st_mode))
3728                     av_push(GvAVn(PL_incgv), newSVsv(subdir));
3729
3730                 /* .../version if -d .../version */
3731                 Perl_sv_setpvf(aTHX_ subdir, "%"SVf PERL_ARCH_FMT_PATH, libdir,
3732                                (int)PERL_REVISION, (int)PERL_VERSION,
3733                                (int)PERL_SUBVERSION);
3734                 if (PerlLIO_stat(SvPVX(subdir), &tmpstatbuf) >= 0 &&
3735                       S_ISDIR(tmpstatbuf.st_mode))
3736                     av_push(GvAVn(PL_incgv), newSVsv(subdir));
3737
3738                 /* .../archname if -d .../archname */
3739                 Perl_sv_setpvf(aTHX_ subdir, "%"SVf PERL_ARCH_FMT, libdir, ARCHNAME);
3740                 if (PerlLIO_stat(SvPVX(subdir), &tmpstatbuf) >= 0 &&
3741                       S_ISDIR(tmpstatbuf.st_mode))
3742                     av_push(GvAVn(PL_incgv), newSVsv(subdir));
3743             }
3744
3745 #ifdef PERL_INC_VERSION_LIST
3746             if (addoldvers) {
3747                 for (incver = incverlist; *incver; incver++) {
3748                     /* .../xxx if -d .../xxx */
3749                     Perl_sv_setpvf(aTHX_ subdir, "%"SVf PERL_ARCH_FMT, libdir, *incver);
3750                     if (PerlLIO_stat(SvPVX(subdir), &tmpstatbuf) >= 0 &&
3751                           S_ISDIR(tmpstatbuf.st_mode))
3752                         av_push(GvAVn(PL_incgv), newSVsv(subdir));
3753                 }
3754             }
3755 #endif
3756         }
3757
3758         /* finally push this lib directory on the end of @INC */
3759         av_push(GvAVn(PL_incgv), libdir);
3760     }
3761 }
3762
3763 #ifdef USE_THREADS
3764 STATIC struct perl_thread *
3765 S_init_main_thread(pTHX)
3766 {
3767 #if !defined(PERL_IMPLICIT_CONTEXT)
3768     struct perl_thread *thr;
3769 #endif
3770     XPV *xpv;
3771
3772     Newz(53, thr, 1, struct perl_thread);
3773     PL_curcop = &PL_compiling;
3774     thr->interp = PERL_GET_INTERP;
3775     thr->cvcache = newHV();
3776     thr->threadsv = newAV();
3777     /* thr->threadsvp is set when find_threadsv is called */
3778     thr->specific = newAV();
3779     thr->flags = THRf_R_JOINABLE;
3780     MUTEX_INIT(&thr->mutex);
3781     /* Handcraft thrsv similarly to mess_sv */
3782     New(53, PL_thrsv, 1, SV);
3783     Newz(53, xpv, 1, XPV);
3784     SvFLAGS(PL_thrsv) = SVt_PV;
3785     SvANY(PL_thrsv) = (void*)xpv;
3786     SvREFCNT(PL_thrsv) = 1 << 30;       /* practically infinite */
3787     SvPVX(PL_thrsv) = (char*)thr;
3788     SvCUR_set(PL_thrsv, sizeof(thr));
3789     SvLEN_set(PL_thrsv, sizeof(thr));
3790     *SvEND(PL_thrsv) = '\0';    /* in the trailing_nul field */
3791     thr->oursv = PL_thrsv;
3792     PL_chopset = " \n-";
3793     PL_dumpindent = 4;
3794
3795     MUTEX_LOCK(&PL_threads_mutex);
3796     PL_nthreads++;
3797     thr->tid = 0;
3798     thr->next = thr;
3799     thr->prev = thr;
3800     thr->thr_done = 0;
3801     MUTEX_UNLOCK(&PL_threads_mutex);
3802
3803 #ifdef HAVE_THREAD_INTERN
3804     Perl_init_thread_intern(thr);
3805 #endif
3806
3807 #ifdef SET_THREAD_SELF
3808     SET_THREAD_SELF(thr);
3809 #else
3810     thr->self = pthread_self();
3811 #endif /* SET_THREAD_SELF */
3812     PERL_SET_THX(thr);
3813
3814     /*
3815      * These must come after the thread self setting
3816      * because sv_setpvn does SvTAINT and the taint
3817      * fields thread selfness being set.
3818      */
3819     PL_toptarget = NEWSV(0,0);
3820     sv_upgrade(PL_toptarget, SVt_PVFM);
3821     sv_setpvn(PL_toptarget, "", 0);
3822     PL_bodytarget = NEWSV(0,0);
3823     sv_upgrade(PL_bodytarget, SVt_PVFM);
3824     sv_setpvn(PL_bodytarget, "", 0);
3825     PL_formtarget = PL_bodytarget;
3826     thr->errsv = newSVpvn("", 0);
3827     (void) find_threadsv("@");  /* Ensure $@ is initialised early */
3828
3829     PL_maxscream = -1;
3830     PL_peepp = MEMBER_TO_FPTR(Perl_peep);
3831     PL_regcompp = MEMBER_TO_FPTR(Perl_pregcomp);
3832     PL_regexecp = MEMBER_TO_FPTR(Perl_regexec_flags);
3833     PL_regint_start = MEMBER_TO_FPTR(Perl_re_intuit_start);
3834     PL_regint_string = MEMBER_TO_FPTR(Perl_re_intuit_string);
3835     PL_regfree = MEMBER_TO_FPTR(Perl_pregfree);
3836     PL_regindent = 0;
3837     PL_reginterp_cnt = 0;
3838
3839     return thr;
3840 }
3841 #endif /* USE_THREADS */
3842
3843 void
3844 Perl_call_list(pTHX_ I32 oldscope, AV *paramList)
3845 {
3846     SV *atsv;
3847     line_t oldline = CopLINE(PL_curcop);
3848     CV *cv;
3849     STRLEN len;
3850     int ret;
3851     dJMPENV;
3852
3853     while (AvFILL(paramList) >= 0) {
3854         cv = (CV*)av_shift(paramList);
3855         if ((PL_minus_c & 0x10) && (paramList == PL_beginav)) {
3856                 /* save PL_beginav for compiler */
3857             if (! PL_beginav_save)
3858                 PL_beginav_save = newAV();
3859             av_push(PL_beginav_save, (SV*)cv);
3860         } else {
3861             SAVEFREESV(cv);
3862         }
3863 #ifdef PERL_FLEXIBLE_EXCEPTIONS
3864         CALLPROTECT(aTHX_ pcur_env, &ret, MEMBER_TO_FPTR(S_vcall_list_body), cv);
3865 #else
3866         JMPENV_PUSH(ret);
3867 #endif
3868         switch (ret) {
3869         case 0:
3870 #ifndef PERL_FLEXIBLE_EXCEPTIONS
3871             call_list_body(cv);
3872 #endif
3873             atsv = ERRSV;
3874             (void)SvPV(atsv, len);
3875             if (len) {
3876                 STRLEN n_a;
3877                 PL_curcop = &PL_compiling;
3878                 CopLINE_set(PL_curcop, oldline);
3879                 if (paramList == PL_beginav)
3880                     sv_catpv(atsv, "BEGIN failed--compilation aborted");
3881                 else
3882                     Perl_sv_catpvf(aTHX_ atsv,
3883                                    "%s failed--call queue aborted",
3884                                    paramList == PL_checkav ? "CHECK"
3885                                    : paramList == PL_initav ? "INIT"
3886                                    : "END");
3887                 while (PL_scopestack_ix > oldscope)
3888                     LEAVE;
3889                 JMPENV_POP;
3890                 Perl_croak(aTHX_ "%s", SvPVx(atsv, n_a));
3891             }
3892             break;
3893         case 1:
3894             STATUS_ALL_FAILURE;
3895             /* FALL THROUGH */
3896         case 2:
3897             /* my_exit() was called */
3898             while (PL_scopestack_ix > oldscope)
3899                 LEAVE;
3900             FREETMPS;
3901             PL_curstash = PL_defstash;
3902             PL_curcop = &PL_compiling;
3903             CopLINE_set(PL_curcop, oldline);
3904             JMPENV_POP;
3905             if (PL_statusvalue && !(PL_exit_flags & PERL_EXIT_EXPECTED)) {
3906                 if (paramList == PL_beginav)
3907                     Perl_croak(aTHX_ "BEGIN failed--compilation aborted");
3908                 else
3909                     Perl_croak(aTHX_ "%s failed--call queue aborted",
3910                                paramList == PL_checkav ? "CHECK"
3911                                : paramList == PL_initav ? "INIT"
3912                                : "END");
3913             }
3914             my_exit_jump();
3915             /* NOTREACHED */
3916         case 3:
3917             if (PL_restartop) {
3918                 PL_curcop = &PL_compiling;
3919                 CopLINE_set(PL_curcop, oldline);
3920                 JMPENV_JUMP(3);
3921             }
3922             PerlIO_printf(Perl_error_log, "panic: restartop\n");
3923             FREETMPS;
3924             break;
3925         }
3926         JMPENV_POP;
3927     }
3928 }
3929
3930 #ifdef PERL_FLEXIBLE_EXCEPTIONS
3931 STATIC void *
3932 S_vcall_list_body(pTHX_ va_list args)
3933 {
3934     CV *cv = va_arg(args, CV*);
3935     return call_list_body(cv);
3936 }
3937 #endif
3938
3939 STATIC void *
3940 S_call_list_body(pTHX_ CV *cv)
3941 {
3942     PUSHMARK(PL_stack_sp);
3943     call_sv((SV*)cv, G_EVAL|G_DISCARD);
3944     return NULL;
3945 }
3946
3947 void
3948 Perl_my_exit(pTHX_ U32 status)
3949 {
3950     DEBUG_S(PerlIO_printf(Perl_debug_log, "my_exit: thread %p, status %lu\n",
3951                           thr, (unsigned long) status));
3952     switch (status) {
3953     case 0:
3954         STATUS_ALL_SUCCESS;
3955         break;
3956     case 1:
3957         STATUS_ALL_FAILURE;
3958         break;
3959     default:
3960         STATUS_NATIVE_SET(status);
3961         break;
3962     }
3963     my_exit_jump();
3964 }
3965
3966 void
3967 Perl_my_failure_exit(pTHX)
3968 {
3969 #ifdef VMS
3970     if (vaxc$errno & 1) {
3971         if (STATUS_NATIVE & 1)          /* fortuitiously includes "-1" */
3972             STATUS_NATIVE_SET(44);
3973     }
3974     else {
3975         if (!vaxc$errno && errno)       /* unlikely */
3976             STATUS_NATIVE_SET(44);
3977         else
3978             STATUS_NATIVE_SET(vaxc$errno);
3979     }
3980 #else
3981     int exitstatus;
3982     if (errno & 255)
3983         STATUS_POSIX_SET(errno);
3984     else {
3985         exitstatus = STATUS_POSIX >> 8;
3986         if (exitstatus & 255)
3987             STATUS_POSIX_SET(exitstatus);
3988         else
3989             STATUS_POSIX_SET(255);
3990     }
3991 #endif
3992     my_exit_jump();
3993 }
3994
3995 STATIC void
3996 S_my_exit_jump(pTHX)
3997 {
3998     register PERL_CONTEXT *cx;
3999     I32 gimme;
4000     SV **newsp;
4001
4002     if (PL_e_script) {
4003         SvREFCNT_dec(PL_e_script);
4004         PL_e_script = Nullsv;
4005     }
4006
4007     POPSTACK_TO(PL_mainstack);
4008     if (cxstack_ix >= 0) {
4009         if (cxstack_ix > 0)
4010             dounwind(0);
4011         POPBLOCK(cx,PL_curpm);
4012         LEAVE;
4013     }
4014
4015     JMPENV_JUMP(2);
4016 }
4017
4018 #ifdef PERL_OBJECT
4019 #include "XSUB.h"
4020 #endif
4021
4022 static I32
4023 read_e_script(pTHXo_ int idx, SV *buf_sv, int maxlen)
4024 {
4025     char *p, *nl;
4026     p  = SvPVX(PL_e_script);
4027     nl = strchr(p, '\n');
4028     nl = (nl) ? nl+1 : SvEND(PL_e_script);
4029     if (nl-p == 0) {
4030         filter_del(read_e_script);
4031         return 0;
4032     }
4033     sv_catpvn(buf_sv, p, nl-p);
4034     sv_chop(PL_e_script, nl);
4035     return 1;
4036 }