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