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