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