*/
#include "EXTERN.h"
+#define PERL_IN_PERL_C
#include "perl.h"
+#include "patchlevel.h" /* for local_patches */
/* XXX If this causes problems, set i_unistd=undef in the hint file. */
#ifdef I_UNISTD
#endif
#if !defined(STANDARD_C) && !defined(HAS_GETENV_PROTOTYPE)
-char *getenv _((char *)); /* Usually in <stdlib.h> */
+char *getenv (char *); /* Usually in <stdlib.h> */
#endif
+static I32 read_e_script(pTHXo_ int idx, SV *buf_sv, int maxlen);
+
#ifdef I_FCNTL
#include <fcntl.h>
#endif
#endif
#ifdef PERL_OBJECT
-static I32 read_e_script _((CPerlObj* pPerl, int idx, SV *buf_sv, int maxlen));
-#else
-static void find_beginning _((void));
-static void forbid_setid _((char *));
-static void incpush _((char *, int));
-static void init_interp _((void));
-static void init_ids _((void));
-static void init_debugger _((void));
-static void init_lexer _((void));
-static void init_main_stash _((void));
-static void *perl_parse_body _((va_list args));
-static void *perl_run_body _((va_list args));
-static void *perl_call_body _((va_list args));
-static void perl_call_xbody _((OP *myop, int is_eval));
-static void *call_list_body _((va_list args));
-#ifdef USE_THREADS
-static struct perl_thread * init_main_thread _((void));
-#endif /* USE_THREADS */
-static void init_perllib _((void));
-static void init_postdump_symbols _((int, char **, char **));
-static void init_predump_symbols _((void));
-static void my_exit_jump _((void)) __attribute__((noreturn));
-static void nuke_stacks _((void));
-static void open_script _((char *, bool, SV *, int *fd));
-static void usage _((char *));
-#ifdef IAMSUID
-static int fd_on_nosuid_fs _((int));
-#endif
-static void validate_suid _((char *, char*, int));
-static I32 read_e_script _((int idx, SV *buf_sv, int maxlen));
-#endif
-
-#ifdef PERL_OBJECT
CPerlObj* perl_alloc(IPerlMem* ipM, IPerlEnv* ipE, IPerlStdIO* ipStd,
- IPerlLIO* ipLIO, IPerlDir* ipD, IPerlSock* ipS, IPerlProc* ipP)
+ IPerlLIO* ipLIO, IPerlDir* ipD, IPerlSock* ipS, IPerlProc* ipP)
{
CPerlObj* pPerl = new(ipM) CPerlObj(ipM, ipE, ipStd, ipLIO, ipD, ipS, ipP);
if(pPerl != NULL)
PerlInterpreter *
perl_alloc(void)
{
- PerlInterpreter *sv_interp;
+ PerlInterpreter *my_perl;
- PL_curinterp = 0;
- New(53, sv_interp, 1, PerlInterpreter);
- return sv_interp;
+ /* New() needs interpreter, so call malloc() instead */
+ my_perl = (PerlInterpreter*)PerlMem_malloc(sizeof(PerlInterpreter));
+ PERL_SET_INTERP(my_perl);
+ return my_perl;
}
#endif /* PERL_OBJECT */
void
-#ifdef PERL_OBJECT
-perl_construct(void)
-#else
-perl_construct(register PerlInterpreter *sv_interp)
-#endif
+perl_construct(pTHXx)
{
#ifdef USE_THREADS
int i;
#ifndef FAKE_THREADS
- struct perl_thread *thr;
+ struct perl_thread *thr = NULL;
#endif /* FAKE_THREADS */
#endif /* USE_THREADS */
-#ifndef PERL_OBJECT
- if (!(PL_curinterp = sv_interp))
- return;
+#ifdef MULTIPLICITY
+ Zero(my_perl, 1, PerlInterpreter);
#endif
#ifdef MULTIPLICITY
- ++PL_ninterps;
- Zero(sv_interp, 1, PerlInterpreter);
+ init_interp();
+ PL_perl_destruct_level = 1;
+#else
+ if (PL_perl_destruct_level > 0)
+ init_interp();
#endif
/* Init the real globals (and main thread)? */
ALLOC_THREAD_KEY;
#else
if (pthread_key_create(&PL_thr_key, 0))
- croak("panic: pthread_key_create");
+ Perl_croak(aTHX_ "panic: pthread_key_create");
#endif
MUTEX_INIT(&PL_sv_mutex);
/*
thr = init_main_thread();
#endif /* USE_THREADS */
- PL_protect = FUNC_NAME_TO_PTR(default_protect); /* for exceptions */
+ PL_protect = MEMBER_TO_FPTR(Perl_default_protect); /* for exceptions */
PL_curcop = &PL_compiling; /* needed by ckWARN, right away */
/* TODO: */
/* PL_sighandlerp = sighandler; */
#else
- PL_sighandlerp = sighandler;
+ PL_sighandlerp = Perl_sighandler;
#endif
PL_pidstatus = newHV();
PL_nrs = newSVpvn("\n", 1);
PL_rs = SvREFCNT_inc(PL_nrs);
- init_stacks(ARGS);
-#ifdef MULTIPLICITY
- init_interp();
- PL_perl_destruct_level = 1;
-#else
- if (PL_perl_destruct_level > 0)
- init_interp();
-#endif
+ init_stacks();
init_ids();
PL_lex_state = LEX_NOTPARSING;
JMPENV_BOOTSTRAP;
STATUS_ALL_SUCCESS;
+ init_i18nl10n(1);
SET_NUMERIC_STANDARD();
#if defined(PERL_SUBVERSION) && PERL_SUBVERSION > 0
sprintf(PL_patchlevel, "%7.5f", (double) PERL_REVISION
}
void
-#ifdef PERL_OBJECT
-perl_destruct(void)
-#else
-perl_destruct(register PerlInterpreter *sv_interp)
-#endif
+perl_destruct(pTHXx)
{
dTHR;
int destruct_level; /* 0=none, 1=full, 2=full with checks */
HV *hv;
#ifdef USE_THREADS
Thread t;
+ dTHX;
#endif /* USE_THREADS */
-#ifndef PERL_OBJECT
- if (!(PL_curinterp = sv_interp))
- return;
-#endif
-
#ifdef USE_THREADS
#ifndef FAKE_THREADS
/* Pass 1 on any remaining threads: detach joinables, join zombies */
retry_cleanup:
MUTEX_LOCK(&PL_threads_mutex);
- DEBUG_S(PerlIO_printf(PerlIO_stderr(),
+ DEBUG_S(PerlIO_printf(Perl_debug_log,
"perl_destruct: waiting for %d threads...\n",
PL_nthreads - 1));
for (t = thr->next; t != thr; t = t->next) {
switch (ThrSTATE(t)) {
AV *av;
case THRf_ZOMBIE:
- DEBUG_S(PerlIO_printf(PerlIO_stderr(),
+ DEBUG_S(PerlIO_printf(Perl_debug_log,
"perl_destruct: joining zombie %p\n", t));
ThrSETSTATE(t, THRf_DEAD);
MUTEX_UNLOCK(&t->mutex);
MUTEX_UNLOCK(&PL_threads_mutex);
JOIN(t, &av);
SvREFCNT_dec((SV*)av);
- DEBUG_S(PerlIO_printf(PerlIO_stderr(),
+ DEBUG_S(PerlIO_printf(Perl_debug_log,
"perl_destruct: joined zombie %p OK\n", t));
goto retry_cleanup;
case THRf_R_JOINABLE:
- DEBUG_S(PerlIO_printf(PerlIO_stderr(),
+ DEBUG_S(PerlIO_printf(Perl_debug_log,
"perl_destruct: detaching thread %p\n", t));
ThrSETSTATE(t, THRf_R_DETACHED);
/*
MUTEX_UNLOCK(&t->mutex);
goto retry_cleanup;
default:
- DEBUG_S(PerlIO_printf(PerlIO_stderr(),
+ DEBUG_S(PerlIO_printf(Perl_debug_log,
"perl_destruct: ignoring %p (state %u)\n",
t, ThrSTATE(t)));
MUTEX_UNLOCK(&t->mutex);
/* Pass 2 on remaining threads: wait for the thread count to drop to one */
while (PL_nthreads > 1)
{
- DEBUG_S(PerlIO_printf(PerlIO_stderr(),
+ DEBUG_S(PerlIO_printf(Perl_debug_log,
"perl_destruct: final wait for %d threads\n",
PL_nthreads - 1));
COND_WAIT(&PL_nthreads_cond, &PL_threads_mutex);
}
/* At this point, we're the last thread */
MUTEX_UNLOCK(&PL_threads_mutex);
- DEBUG_S(PerlIO_printf(PerlIO_stderr(), "perl_destruct: armageddon has arrived\n"));
+ DEBUG_S(PerlIO_printf(Perl_debug_log, "perl_destruct: armageddon has arrived\n"));
MUTEX_DESTROY(&PL_threads_mutex);
COND_DESTROY(&PL_nthreads_cond);
#endif /* !defined(FAKE_THREADS) */
LEAVE;
FREETMPS;
-#ifdef MULTIPLICITY
- --PL_ninterps;
-#endif
-
/* We must account for everything. */
/* Destroy the main CV and syntax tree */
PL_warnhook = Nullsv;
SvREFCNT_dec(PL_diehook);
PL_diehook = Nullsv;
- SvREFCNT_dec(PL_parsehook);
- PL_parsehook = Nullsv;
/* call exit list functions */
while (PL_exitlistlen-- > 0)
- PL_exitlist[PL_exitlistlen].fn(PERL_OBJECT_THIS_ PL_exitlist[PL_exitlistlen].ptr);
+ PL_exitlist[PL_exitlistlen].fn(aTHXo_ PL_exitlist[PL_exitlistlen].ptr);
Safefree(PL_exitlist);
Safefree(PL_screamnext);
PL_screamnext = 0;
+ /* float buffer */
+ Safefree(PL_efloatbuf);
+ PL_efloatbuf = Nullch;
+ PL_efloatsize = 0;
+
/* startup and shutdown function lists */
SvREFCNT_dec(PL_beginav);
SvREFCNT_dec(PL_endav);
PL_argvgv = Nullgv;
PL_argvoutgv = Nullgv;
PL_stdingv = Nullgv;
+ PL_stderrgv = Nullgv;
PL_last_in_gv = Nullgv;
PL_replgv = Nullgv;
PL_defstash = 0;
SvREFCNT_dec(hv);
+ /* clear queued errors */
+ SvREFCNT_dec(PL_errors);
+ PL_errors = Nullsv;
+
FREETMPS;
- if (destruct_level >= 2) {
+ if (destruct_level >= 2 && ckWARN_d(WARN_INTERNAL)) {
if (PL_scopestack_ix != 0)
- warn("Unbalanced scopes: %ld more ENTERs than LEAVEs\n",
+ Perl_warner(aTHX_ WARN_INTERNAL,
+ "Unbalanced scopes: %ld more ENTERs than LEAVEs\n",
(long)PL_scopestack_ix);
if (PL_savestack_ix != 0)
- warn("Unbalanced saves: %ld more saves than restores\n",
+ Perl_warner(aTHX_ WARN_INTERNAL,
+ "Unbalanced saves: %ld more saves than restores\n",
(long)PL_savestack_ix);
if (PL_tmps_floor != -1)
- warn("Unbalanced tmps: %ld more allocs than frees\n",
+ Perl_warner(aTHX_ WARN_INTERNAL,"Unbalanced tmps: %ld more allocs than frees\n",
(long)PL_tmps_floor + 1);
if (cxstack_ix != -1)
- warn("Unbalanced context: %ld more PUSHes than POPs\n",
+ Perl_warner(aTHX_ WARN_INTERNAL,"Unbalanced context: %ld more PUSHes than POPs\n",
(long)cxstack_ix + 1);
}
array = HvARRAY(PL_strtab);
hent = array[0];
for (;;) {
- if (hent) {
- warn("Unbalanced string table refcount: (%d) for \"%s\"",
+ if (hent && ckWARN_d(WARN_INTERNAL)) {
+ Perl_warner(aTHX_ WARN_INTERNAL,
+ "Unbalanced string table refcount: (%d) for \"%s\"",
HeVAL(hent) - Nullsv, HeKEY(hent));
HeVAL(hent) = Nullsv;
hent = HeNEXT(hent);
}
SvREFCNT_dec(PL_strtab);
- if (PL_sv_count != 0)
- warn("Scalars leaked: %ld\n", (long)PL_sv_count);
+ if (PL_sv_count != 0 && ckWARN_d(WARN_INTERNAL))
+ Perl_warner(aTHX_ WARN_INTERNAL,"Scalars leaked: %ld\n", (long)PL_sv_count);
sv_free_arenas();
Safefree(PL_reg_start_tmp);
if (PL_reg_curpm)
Safefree(PL_reg_curpm);
+ Safefree(PL_reg_poscache);
Safefree(HeKEY_hek(&PL_hv_fetch_ent_mh));
Safefree(PL_op_mask);
nuke_stacks();
}
void
-#ifdef PERL_OBJECT
-perl_free(void)
-#else
-perl_free(PerlInterpreter *sv_interp)
-#endif
+perl_free(pTHXx)
{
-#ifdef PERL_OBJECT
- Safefree(this);
+#if defined(PERL_OBJECT)
+ PerlMem_free(this);
#else
- if (!(PL_curinterp = sv_interp))
- return;
- Safefree(sv_interp);
+ PerlMem_free(aTHXx);
#endif
}
void
-#ifdef PERL_OBJECT
-perl_atexit(void (*fn) (CPerlObj*,void *), void *ptr)
-#else
-perl_atexit(void (*fn) (void *), void *ptr)
-#endif
+Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr)
{
Renew(PL_exitlist, PL_exitlistlen+1, PerlExitListEntry);
PL_exitlist[PL_exitlistlen].fn = fn;
++PL_exitlistlen;
}
-#ifdef PERL_OBJECT
- typedef void (*xs_init_t)(CPerlObj*);
-#else
- typedef void (*xs_init_t)(void);
-#endif
-
int
-#ifdef PERL_OBJECT
-perl_parse(xs_init_t xsinit, int argc, char **argv, char **env)
-#else
-perl_parse(PerlInterpreter *sv_interp, xs_init_t xsinit, int argc, char **argv, char **env)
-#endif
+perl_parse(pTHXx_ XSINIT_t xsinit, int argc, char **argv, char **env)
{
dTHR;
I32 oldscope;
int ret;
+ dJMPENV;
+#ifdef USE_THREADS
+ dTHX;
+#endif
#ifdef SETUID_SCRIPTS_ARE_SECURE_NOW
#ifdef IAMSUID
#undef IAMSUID
- croak("suidperl is no longer needed since the kernel can now execute\n\
+ Perl_croak(aTHX_ "suidperl is no longer needed since the kernel can now execute\n\
setuid perl scripts securely.\n");
#endif
#endif
-#ifndef PERL_OBJECT
- if (!(PL_curinterp = sv_interp))
- return 255;
-#endif
-
#if defined(__DYNAMIC__) && (defined(NeXT) || defined(__NeXT__))
_dyld_lookup_and_bind
("__environ", (unsigned long *) &environ_pointer, NULL);
oldscope = PL_scopestack_ix;
PL_dowarn = G_WARN_OFF;
- CALLPROTECT(&ret, FUNC_NAME_TO_PTR(perl_parse_body), env, xsinit);
+ CALLPROTECT(aTHX_ pcur_env, &ret, MEMBER_TO_FPTR(S_parse_body),
+ env, xsinit);
switch (ret) {
case 0:
return 0;
LEAVE;
FREETMPS;
PL_curstash = PL_defstash;
- if (PL_endav)
+ if (PL_endav && !PL_minus_c)
call_list(oldscope, PL_endav);
return STATUS_NATIVE_EXPORT;
case 3:
- PerlIO_printf(PerlIO_stderr(), "panic: top_env\n");
+ PerlIO_printf(Perl_error_log, "panic: top_env\n");
return 1;
}
return 0;
}
STATIC void *
-perl_parse_body(va_list args)
+S_parse_body(pTHX_ va_list args)
{
dTHR;
int argc = PL_origargc;
register SV *sv;
register char *s;
- xs_init_t xsinit = va_arg(args, xs_init_t);
+ XSINIT_t xsinit = va_arg(args, XSINIT_t);
sv_setpvn(PL_linestr,"",0);
sv = newSVpvn("",0); /* first used for -I flags */
case 'e':
if (PL_euid != PL_uid || PL_egid != PL_gid)
- croak("No -e allowed in setuid scripts");
+ Perl_croak(aTHX_ "No -e allowed in setuid scripts");
if (!PL_e_script) {
PL_e_script = newSVpvn("",0);
filter_add(read_e_script, NULL);
argc--,argv++;
}
else
- croak("No code specified for -e");
+ Perl_croak(aTHX_ "No code specified for -e");
sv_catpv(PL_e_script, "\n");
break;
sv_catpv(PL_Sv,"\" Locally applied patches:\\n\",");
for (i = 1; i <= LOCAL_PATCH_COUNT; i++) {
if (PL_localpatches[i])
- sv_catpvf(PL_Sv,"q\" \t%s\n\",",PL_localpatches[i]);
+ Perl_sv_catpvf(aTHX_ PL_Sv,"q\" \t%s\n\",",PL_localpatches[i]);
}
}
#endif
- sv_catpvf(PL_Sv,"\" Built under %s\\n\"",OSNAME);
+ Perl_sv_catpvf(aTHX_ PL_Sv,"\" Built under %s\\n\"",OSNAME);
#ifdef __DATE__
# ifdef __TIME__
- sv_catpvf(PL_Sv,",\" Compiled at %s %s\\n\"",__DATE__,__TIME__);
+ Perl_sv_catpvf(aTHX_ PL_Sv,",\" Compiled at %s %s\\n\"",__DATE__,__TIME__);
# else
- sv_catpvf(PL_Sv,",\" Compiled on %s\\n\"",__DATE__);
+ Perl_sv_catpvf(aTHX_ PL_Sv,",\" Compiled on %s\\n\"",__DATE__);
# endif
#endif
sv_catpv(PL_Sv, "; \
s--;
/* FALL THROUGH */
default:
- croak("Unrecognized switch: -%s (-h will show valid options)",s);
+ Perl_croak(aTHX_ "Unrecognized switch: -%s (-h will show valid options)",s);
}
}
switch_end:
if (!*s)
break;
if (!strchr("DIMUdmw", *s))
- croak("Illegal switch in PERL5OPT: -%c", *s);
+ Perl_croak(aTHX_ "Illegal switch in PERL5OPT: -%c", *s);
s = moreswitches(s);
}
}
CvPADLIST(PL_compcv) = comppadlist;
boot_core_UNIVERSAL();
+ boot_core_xsutils();
if (xsinit)
- (*xsinit)(PERL_OBJECT_THIS); /* in case linked C routines want magical variables */
+ (*xsinit)(aTHXo); /* in case linked C routines want magical variables */
#if defined(VMS) || defined(WIN32) || defined(DJGPP)
init_os_extras();
#endif
+#ifdef USE_SOCKS
+ SOCKSinit(argv[0]);
+#endif
+
init_predump_symbols();
/* init_postdump_symbols not currently designed to be called */
/* more than once (ENV isn't cleared first, for example) */
PL_error_count = 0;
if (yyparse() || PL_error_count) {
if (PL_minus_c)
- croak("%s had compilation errors.\n", PL_origfilename);
+ Perl_croak(aTHX_ "%s had compilation errors.\n", PL_origfilename);
else {
- croak("Execution of %s aborted due to compilation errors.\n",
- PL_origfilename);
+ Perl_croak(aTHX_ "Execution of %s aborted due to compilation errors.\n",
+ PL_origfilename);
}
}
PL_curcop->cop_line = 0;
/* now that script is parsed, we can modify record separator */
SvREFCNT_dec(PL_rs);
PL_rs = SvREFCNT_inc(PL_nrs);
- sv_setsv(perl_get_sv("/", TRUE), PL_rs);
+ sv_setsv(get_sv("/", TRUE), PL_rs);
if (PL_do_undump)
my_unexec();
- if (ckWARN(WARN_ONCE))
+ if (isWARN_ONCE)
gv_check(PL_defstash);
LEAVE;
}
int
-#ifdef PERL_OBJECT
-perl_run(void)
-#else
-perl_run(PerlInterpreter *sv_interp)
-#endif
+perl_run(pTHXx)
{
dTHR;
I32 oldscope;
int ret;
-
-#ifndef PERL_OBJECT
- if (!(PL_curinterp = sv_interp))
- return 255;
+ dJMPENV;
+#ifdef USE_THREADS
+ dTHX;
#endif
oldscope = PL_scopestack_ix;
redo_body:
- CALLPROTECT(&ret, FUNC_NAME_TO_PTR(perl_run_body), oldscope);
+ CALLPROTECT(aTHX_ pcur_env, &ret, MEMBER_TO_FPTR(S_run_body), oldscope);
switch (ret) {
case 1:
cxstack_ix = -1; /* start context stack again */
LEAVE;
FREETMPS;
PL_curstash = PL_defstash;
- if (PL_endav)
+ if (PL_endav && !PL_minus_c)
call_list(oldscope, PL_endav);
#ifdef MYMALLOC
if (PerlEnv_getenv("PERL_DEBUG_MSTATS"))
POPSTACK_TO(PL_mainstack);
goto redo_body;
}
- PerlIO_printf(PerlIO_stderr(), "panic: restartop\n");
+ PerlIO_printf(Perl_error_log, "panic: restartop\n");
FREETMPS;
return 1;
}
}
STATIC void *
-perl_run_body(va_list args)
+S_run_body(pTHX_ va_list args)
{
dTHR;
I32 oldscope = va_arg(args, I32);
(unsigned long) thr));
if (PL_minus_c) {
- PerlIO_printf(PerlIO_stderr(), "%s syntax OK\n", PL_origfilename);
+ PerlIO_printf(Perl_error_log, "%s syntax OK\n", PL_origfilename);
my_exit(0);
}
if (PERLDB_SINGLE && PL_DBsingle)
if (PL_restartop) {
PL_op = PL_restartop;
PL_restartop = 0;
- CALLRUNOPS();
+ CALLRUNOPS(aTHX);
}
else if (PL_main_start) {
CvDEPTH(PL_main_cv) = 1;
PL_op = PL_main_start;
- CALLRUNOPS();
+ CALLRUNOPS(aTHX);
}
+ my_exit(0);
+ /* NOTREACHED */
return NULL;
}
SV*
-perl_get_sv(const char *name, I32 create)
+Perl_get_sv(pTHX_ const char *name, I32 create)
{
GV *gv;
#ifdef USE_THREADS
}
AV*
-perl_get_av(const char *name, I32 create)
+Perl_get_av(pTHX_ const char *name, I32 create)
{
GV* gv = gv_fetchpv(name, create, SVt_PVAV);
if (create)
}
HV*
-perl_get_hv(const char *name, I32 create)
+Perl_get_hv(pTHX_ const char *name, I32 create)
{
GV* gv = gv_fetchpv(name, create, SVt_PVHV);
if (create)
}
CV*
-perl_get_cv(const char *name, I32 create)
+Perl_get_cv(pTHX_ const char *name, I32 create)
{
GV* gv = gv_fetchpv(name, create, SVt_PVCV);
/* XXX unsafe for threads if eval_owner isn't held */
/* Be sure to refetch the stack pointer after calling these routines. */
I32
-perl_call_argv(const char *sub_name, I32 flags, register char **argv)
+Perl_call_argv(pTHX_ const char *sub_name, I32 flags, register char **argv)
/* See G_* flags in cop.h */
/* null terminated arg list */
}
PUTBACK;
}
- return perl_call_pv(sub_name, flags);
+ return call_pv(sub_name, flags);
}
I32
-perl_call_pv(const char *sub_name, I32 flags)
+Perl_call_pv(pTHX_ const char *sub_name, I32 flags)
/* name of the subroutine */
/* See G_* flags in cop.h */
{
- return perl_call_sv((SV*)perl_get_cv(sub_name, TRUE), flags);
+ return call_sv((SV*)get_cv(sub_name, TRUE), flags);
}
I32
-perl_call_method(const char *methname, I32 flags)
+Perl_call_method(pTHX_ const char *methname, I32 flags)
/* name of the subroutine */
/* See G_* flags in cop.h */
{
PL_op = &myop;
XPUSHs(sv_2mortal(newSVpv(methname,0)));
PUTBACK;
- pp_method(ARGS);
+ pp_method();
if(PL_op == &myop)
PL_op = Nullop;
- return perl_call_sv(*PL_stack_sp--, flags);
+ return call_sv(*PL_stack_sp--, flags);
}
/* May be called with any of a CV, a GV, or an SV containing the name. */
I32
-perl_call_sv(SV *sv, I32 flags)
+Perl_call_sv(pTHX_ SV *sv, I32 flags)
/* See G_* flags in cop.h */
{
bool oldcatch = CATCH_GET;
int ret;
OP* oldop = PL_op;
+ dJMPENV;
if (flags & G_DISCARD) {
ENTER;
if (!(flags & G_EVAL)) {
CATCH_SET(TRUE);
- perl_call_xbody((OP*)&myop, FALSE);
+ call_xbody((OP*)&myop, FALSE);
retval = PL_stack_sp - (PL_stack_base + oldmark);
CATCH_SET(FALSE);
}
PL_markstack_ptr++;
redo_body:
- CALLPROTECT(&ret, FUNC_NAME_TO_PTR(perl_call_body), (OP*)&myop, FALSE);
+ CALLPROTECT(aTHX_ pcur_env, &ret, MEMBER_TO_FPTR(S_call_body),
+ (OP*)&myop, FALSE);
switch (ret) {
case 0:
retval = PL_stack_sp - (PL_stack_base + oldmark);
PL_curstash = PL_defstash;
FREETMPS;
if (PL_statusvalue)
- croak("Callback called exit");
+ Perl_croak(aTHX_ "Callback called exit");
my_exit_jump();
/* NOTREACHED */
case 3:
}
STATIC void *
-perl_call_body(va_list args)
+S_call_body(pTHX_ va_list args)
{
OP *myop = va_arg(args, OP*);
int is_eval = va_arg(args, int);
- perl_call_xbody(myop, is_eval);
+ call_xbody(myop, is_eval);
return NULL;
}
STATIC void
-perl_call_xbody(OP *myop, int is_eval)
+S_call_xbody(pTHX_ OP *myop, int is_eval)
{
dTHR;
if (PL_op == myop) {
if (is_eval)
- PL_op = pp_entereval(ARGS);
+ PL_op = Perl_pp_entereval(aTHX);
else
- PL_op = pp_entersub(ARGS);
+ PL_op = Perl_pp_entersub(aTHX);
}
if (PL_op)
- CALLRUNOPS();
+ CALLRUNOPS(aTHX);
}
/* Eval a string. The G_EVAL flag is always assumed. */
I32
-perl_eval_sv(SV *sv, I32 flags)
+Perl_eval_sv(pTHX_ SV *sv, I32 flags)
/* See G_* flags in cop.h */
{
I32 oldscope;
int ret;
OP* oldop = PL_op;
+ dJMPENV;
if (flags & G_DISCARD) {
ENTER;
myop.op_flags |= OPf_SPECIAL;
redo_body:
- CALLPROTECT(&ret, FUNC_NAME_TO_PTR(perl_call_body), (OP*)&myop, TRUE);
+ CALLPROTECT(aTHX_ pcur_env, &ret, MEMBER_TO_FPTR(S_call_body),
+ (OP*)&myop, TRUE);
switch (ret) {
case 0:
retval = PL_stack_sp - (PL_stack_base + oldmark);
PL_curstash = PL_defstash;
FREETMPS;
if (PL_statusvalue)
- croak("Callback called exit");
+ Perl_croak(aTHX_ "Callback called exit");
my_exit_jump();
/* NOTREACHED */
case 3:
}
SV*
-perl_eval_pv(const char *p, I32 croak_on_error)
+Perl_eval_pv(pTHX_ const char *p, I32 croak_on_error)
{
dSP;
SV* sv = newSVpv(p, 0);
PUSHMARK(SP);
- perl_eval_sv(sv, G_SCALAR);
+ eval_sv(sv, G_SCALAR);
SvREFCNT_dec(sv);
SPAGAIN;
if (croak_on_error && SvTRUE(ERRSV)) {
STRLEN n_a;
- croak(SvPVx(ERRSV, n_a));
+ Perl_croak(aTHX_ SvPVx(ERRSV, n_a));
}
return sv;
/* Require a module. */
void
-perl_require_pv(const char *pv)
+Perl_require_pv(pTHX_ const char *pv)
{
SV* sv;
dSP;
sv_setpv(sv, "require '");
sv_catpv(sv, pv);
sv_catpv(sv, "'");
- perl_eval_sv(sv, G_DISCARD);
+ eval_sv(sv, G_DISCARD);
SPAGAIN;
POPSTACK;
}
void
-magicname(char *sym, char *name, I32 namlen)
+Perl_magicname(pTHX_ char *sym, char *name, I32 namlen)
{
register GV *gv;
}
STATIC void
-usage(char *name) /* XXX move this out into a module ? */
-
+S_usage(pTHX_ char *name) /* XXX move this out into a module ? */
{
/* This message really ought to be max 23 lines.
* Removed -h because the user already knows that opton. Others? */
/* This routine handles any switches that can be given during run */
char *
-moreswitches(char *s)
+Perl_moreswitches(pTHX_ char *s)
{
I32 numlen;
U32 rschar;
forbid_setid("-d");
s++;
if (*s == ':' || *s == '=') {
- my_setenv("PERL5DB", form("use Devel::%s;", ++s));
+ my_setenv("PERL5DB", Perl_form(aTHX_ "use Devel::%s;", ++s));
s += strlen(s);
}
if (!PL_perldb) {
}
return s;
case 'D':
+ {
#ifdef DEBUGGING
forbid_setid("-D");
if (isALPHA(s[1])) {
}
PL_debug |= 0x80000000;
#else
- warn("Recompile perl with -DDEBUGGING to use -D switch\n");
+ dTHR;
+ if (ckWARN_d(WARN_DEBUGGING))
+ Perl_warner(aTHX_ WARN_DEBUGGING,
+ "Recompile perl with -DDEBUGGING to use -D switch\n");
for (s++; isALNUM(*s); s++) ;
#endif
/*SUPPRESS 530*/
return s;
+ }
case 'h':
usage(PL_origargv[0]);
PerlProc_exit(0);
s = e;
}
else
- croak("No space allowed after -I");
+ Perl_croak(aTHX_ "No space allowed after -I");
return s;
case 'l':
PL_minus_l = TRUE;
sv_catpv(sv, start);
if (*(start-1) == 'm') {
if (*s != '\0')
- croak("Can't use '%c' after -mname", *s);
+ Perl_croak(aTHX_ "Can't use '%c' after -mname", *s);
sv_catpv( sv, " ()");
}
} else {
av_push(PL_preambleav, sv);
}
else
- croak("No space allowed after -%c", *(s-1));
+ Perl_croak(aTHX_ "No space allowed after -%c", *(s-1));
return s;
case 'n':
PL_minus_n = TRUE;
return s;
case 'T':
if (!PL_tainting)
- croak("Too late for \"-T\" option");
+ Perl_croak(aTHX_ "Too late for \"-T\" option");
s++;
return s;
case 'u':
return s+1;
/* FALL THROUGH */
default:
- croak("Can't emulate -%.1s on #! line",s);
+ Perl_croak(aTHX_ "Can't emulate -%.1s on #! line",s);
}
return Nullch;
}
/* Known to work with -DUNEXEC and using unexelf.c from GNU emacs-20.2 */
void
-my_unexec(void)
+Perl_my_unexec(pTHX)
{
#ifdef UNEXEC
SV* prog;
/* initialize curinterp */
STATIC void
-init_interp(void)
+S_init_interp(pTHX)
{
#ifdef PERL_OBJECT /* XXX kludge */
#else
# ifdef MULTIPLICITY
# define PERLVAR(var,type)
-# define PERLVARI(var,type,init) PL_curinterp->var = init;
-# define PERLVARIC(var,type,init) PL_curinterp->var = init;
+# define PERLVARA(var,n,type)
+# if defined(PERL_IMPLICIT_CONTEXT)
+# if defined(USE_THREADS)
+# define PERLVARI(var,type,init) PERL_GET_INTERP->var = init;
+# define PERLVARIC(var,type,init) PERL_GET_INTERP->var = init;
+# else /* !USE_THREADS */
+# define PERLVARI(var,type,init) aTHX->var = init;
+# define PERLVARIC(var,type,init) aTHX->var = init;
+# endif /* USE_THREADS */
+# else
+# define PERLVARI(var,type,init) PERL_GET_INTERP->var = init;
+# define PERLVARIC(var,type,init) PERL_GET_INTERP->var = init;
+# endif
# include "intrpvar.h"
# ifndef USE_THREADS
# include "thrdvar.h"
# endif
# undef PERLVAR
+# undef PERLVARA
# undef PERLVARI
# undef PERLVARIC
# else
# define PERLVAR(var,type)
+# define PERLVARA(var,n,type)
# define PERLVARI(var,type,init) PL_##var = init;
# define PERLVARIC(var,type,init) PL_##var = init;
# include "intrpvar.h"
# include "thrdvar.h"
# endif
# undef PERLVAR
+# undef PERLVARA
# undef PERLVARI
# undef PERLVARIC
# endif
}
STATIC void
-init_main_stash(void)
+S_init_main_stash(pTHX)
{
dTHR;
GV *gv;
GvMULTI_on(PL_errgv);
PL_replgv = gv_fetchpv("\022", TRUE, SVt_PV); /* ^R */
GvMULTI_on(PL_replgv);
- (void)form("%240s",""); /* Preallocate temp - for immediate signals. */
+ (void)Perl_form(aTHX_ "%240s",""); /* Preallocate temp - for immediate signals. */
sv_grow(ERRSV, 240); /* Preallocate - for immediate signals. */
sv_setpvn(ERRSV, "", 0);
PL_curstash = PL_defstash;
PL_debstash = GvHV(gv_fetchpv("DB::", GV_ADDMULTI, SVt_PVHV));
PL_globalstash = GvHV(gv_fetchpv("CORE::GLOBAL::", GV_ADDMULTI, SVt_PVHV));
/* We must init $/ before switches are processed. */
- sv_setpvn(perl_get_sv("/", TRUE), "\n", 1);
+ sv_setpvn(get_sv("/", TRUE), "\n", 1);
}
STATIC void
-open_script(char *scriptname, bool dosearch, SV *sv, int *fdscript)
+S_open_script(pTHX_ char *scriptname, bool dosearch, SV *sv, int *fdscript)
{
dTHR;
register char *s;
SV *cmd = NEWSV(0,0);
if (strEQ(cpp_cfg, "cppstdin"))
- sv_catpvf(cpp, "%s/", BIN_EXP);
+ Perl_sv_catpvf(aTHX_ cpp, "%s/", BIN_EXP);
sv_catpv(cpp, cpp_cfg);
sv_catpv(sv,"-I");
sv_catpv(sv,PRIVLIB_EXP);
#ifdef MSDOS
- sv_setpvf(cmd, "\
+ Perl_sv_setpvf(aTHX_ cmd, "\
sed %s -e \"/^[^#]/b\" \
-e \"/^#[ ]*include[ ]/b\" \
-e \"/^#[ ]*define[ ]/b\" \
(PL_doextract ? "-e \"1,/^#/d\n\"" : ""),
#else
# ifdef __OPEN_VM
- sv_setpvf(cmd, "\
+ Perl_sv_setpvf(aTHX_ cmd, "\
%s %s -e '/^[^#]/b' \
-e '/^#[ ]*include[ ]/b' \
-e '/^#[ ]*define[ ]/b' \
-e 's/^[ ]*#.*//' \
%s | %_ %_ %s",
# else
- sv_setpvf(cmd, "\
+ Perl_sv_setpvf(aTHX_ cmd, "\
%s %s -e '/^[^#]/b' \
-e '/^#[ ]*include[ ]/b' \
-e '/^#[ ]*define[ ]/b' \
#endif
#endif
if (PerlProc_geteuid() != PL_uid)
- croak("Can't do seteuid!\n");
+ Perl_croak(aTHX_ "Can't do seteuid!\n");
}
#endif /* IAMSUID */
PL_rsfp = PerlProc_popen(SvPVX(cmd), "r");
PL_statbuf.st_mode & (S_ISUID|S_ISGID))
{
/* try again */
- PerlProc_execv(form("%s/sperl%s", BIN_EXP, PL_patchlevel), PL_origargv);
- croak("Can't do setuid\n");
+ PerlProc_execv(Perl_form(aTHX_ "%s/sperl%s", BIN_EXP, PL_patchlevel), PL_origargv);
+ Perl_croak(aTHX_ "Can't do setuid\n");
}
#endif
#endif
- croak("Can't open perl script \"%s\": %s\n",
+ Perl_croak(aTHX_ "Can't open perl script \"%s\": %s\n",
SvPVX(GvSV(PL_curcop->cop_filegv)), Strerror(errno));
}
}
* here so that metaconfig picks them up. */
#ifdef IAMSUID
-static int
-fd_on_nosuid_fs(int fd)
+STATIC int
+S_fd_on_nosuid_fs(pTHX_ int fd)
{
int on_nosuid = 0;
int check_okay = 0;
# endif /* statfs */
# endif /* statvfs */
if (!check_okay)
- croak("Can't check filesystem of script \"%s\"", PL_origfilename);
+ Perl_croak(aTHX_ "Can't check filesystem of script \"%s\"", PL_origfilename);
return on_nosuid;
}
#endif /* IAMSUID */
STATIC void
-validate_suid(char *validarg, char *scriptname, int fdscript)
+S_validate_suid(pTHX_ char *validarg, char *scriptname, int fdscript)
{
int which;
char *s, *s2;
if (PerlLIO_fstat(PerlIO_fileno(PL_rsfp),&PL_statbuf) < 0) /* normal stat is insecure */
- croak("Can't stat script \"%s\"",PL_origfilename);
+ Perl_croak(aTHX_ "Can't stat script \"%s\"",PL_origfilename);
if (fdscript < 0 && PL_statbuf.st_mode & (S_ISUID|S_ISGID)) {
I32 len;
STRLEN n_a;
* it says access() is useful in setuid programs.
*/
if (PerlLIO_access(SvPVX(GvSV(PL_curcop->cop_filegv)),1)) /*double check*/
- croak("Permission denied");
+ Perl_croak(aTHX_ "Permission denied");
#else
/* If we can swap euid and uid, then we can determine access rights
* with a simple stat of the file, and then compare device and
# endif
#endif
|| PerlProc_getuid() != PL_euid || PerlProc_geteuid() != PL_uid)
- croak("Can't swap uid and euid"); /* really paranoid */
+ Perl_croak(aTHX_ "Can't swap uid and euid"); /* really paranoid */
if (PerlLIO_stat(SvPVX(GvSV(PL_curcop->cop_filegv)),&tmpstatbuf) < 0)
- croak("Permission denied"); /* testing full pathname here */
+ Perl_croak(aTHX_ "Permission denied"); /* testing full pathname here */
#if defined(IAMSUID) && !defined(NO_NOSUID_CHECK)
if (fd_on_nosuid_fs(PerlIO_fileno(PL_rsfp)))
- croak("Permission denied");
+ Perl_croak(aTHX_ "Permission denied");
#endif
if (tmpstatbuf.st_dev != PL_statbuf.st_dev ||
tmpstatbuf.st_ino != PL_statbuf.st_ino) {
(long)PL_statbuf.st_uid, (long)PL_statbuf.st_gid);
(void)PerlProc_pclose(PL_rsfp);
}
- croak("Permission denied\n");
+ Perl_croak(aTHX_ "Permission denied\n");
}
if (
#ifdef HAS_SETREUID
# endif
#endif
|| PerlProc_getuid() != PL_uid || PerlProc_geteuid() != PL_euid)
- croak("Can't reswap uid and euid");
+ Perl_croak(aTHX_ "Can't reswap uid and euid");
if (!cando(S_IXUSR,FALSE,&PL_statbuf)) /* can real uid exec? */
- croak("Permission denied\n");
+ Perl_croak(aTHX_ "Permission denied\n");
}
#endif /* HAS_SETREUID */
#endif /* IAMSUID */
if (!S_ISREG(PL_statbuf.st_mode))
- croak("Permission denied");
+ Perl_croak(aTHX_ "Permission denied");
if (PL_statbuf.st_mode & S_IWOTH)
- croak("Setuid/gid script is writable by world");
+ Perl_croak(aTHX_ "Setuid/gid script is writable by world");
PL_doswitches = FALSE; /* -s is insecure in suid */
PL_curcop->cop_line++;
if (sv_gets(PL_linestr, PL_rsfp, 0) == Nullch ||
strnNE(SvPV(PL_linestr,n_a),"#!",2) ) /* required even on Sys V */
- croak("No #! line");
+ Perl_croak(aTHX_ "No #! line");
s = SvPV(PL_linestr,n_a)+2;
if (*s == ' ') s++;
while (!isSPACE(*s)) s++;
for (s2 = s; (s2 > SvPV(PL_linestr,n_a)+2 &&
(isDIGIT(s2[-1]) || strchr("._-", s2[-1]))); s2--) ;
if (strnNE(s2-4,"perl",4) && strnNE(s-9,"perl",4)) /* sanity check */
- croak("Not a perl script");
+ Perl_croak(aTHX_ "Not a perl script");
while (*s == ' ' || *s == '\t') s++;
/*
* #! arg must be what we saw above. They can invoke it by
len = strlen(validarg);
if (strEQ(validarg," PHOOEY ") ||
strnNE(s,validarg,len) || !isSPACE(s[len]))
- croak("Args must match #! line");
+ Perl_croak(aTHX_ "Args must match #! line");
#ifndef IAMSUID
if (PL_euid != PL_uid && (PL_statbuf.st_mode & S_ISUID) &&
PL_euid == PL_statbuf.st_uid)
if (!PL_do_undump)
- croak("YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!\n\
+ Perl_croak(aTHX_ "YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!\n\
FIX YOUR KERNEL, PUT A C WRAPPER AROUND THIS SCRIPT, OR USE -u AND UNDUMP!\n");
#endif /* IAMSUID */
(void)PerlIO_close(PL_rsfp);
#ifndef IAMSUID
/* try again */
- PerlProc_execv(form("%s/sperl%s", BIN_EXP, PL_patchlevel), PL_origargv);
+ PerlProc_execv(Perl_form(aTHX_ "%s/sperl%s", BIN_EXP, PL_patchlevel), PL_origargv);
#endif
- croak("Can't do setuid\n");
+ Perl_croak(aTHX_ "Can't do setuid\n");
}
if (PL_statbuf.st_mode & S_ISGID && PL_statbuf.st_gid != PL_egid) {
#endif
#endif
if (PerlProc_getegid() != PL_statbuf.st_gid)
- croak("Can't do setegid!\n");
+ Perl_croak(aTHX_ "Can't do setegid!\n");
}
if (PL_statbuf.st_mode & S_ISUID) {
if (PL_statbuf.st_uid != PL_euid)
#endif
#endif
if (PerlProc_geteuid() != PL_statbuf.st_uid)
- croak("Can't do seteuid!\n");
+ Perl_croak(aTHX_ "Can't do seteuid!\n");
}
else if (PL_uid) { /* oops, mustn't run as root */
#ifdef HAS_SETEUID
#endif
#endif
if (PerlProc_geteuid() != PL_uid)
- croak("Can't do seteuid!\n");
+ Perl_croak(aTHX_ "Can't do seteuid!\n");
}
init_ids();
if (!cando(S_IXUSR,TRUE,&PL_statbuf))
- croak("Permission denied\n"); /* they can't do this */
+ Perl_croak(aTHX_ "Permission denied\n"); /* they can't do this */
}
#ifdef IAMSUID
else if (PL_preprocess)
- croak("-P not allowed for setuid/setgid script\n");
+ Perl_croak(aTHX_ "-P not allowed for setuid/setgid script\n");
else if (fdscript >= 0)
- croak("fd script not allowed in suidperl\n");
+ Perl_croak(aTHX_ "fd script not allowed in suidperl\n");
else
- croak("Script is not setuid/setgid in suidperl\n");
+ Perl_croak(aTHX_ "Script is not setuid/setgid in suidperl\n");
/* We absolutely must clear out any saved ids here, so we */
/* exec the real perl, substituting fd script for scriptname. */
PerlLIO_lseek(PerlIO_fileno(PL_rsfp),(Off_t)0,0); /* just in case rewind didn't */
for (which = 1; PL_origargv[which] && PL_origargv[which] != scriptname; which++) ;
if (!PL_origargv[which])
- croak("Permission denied");
- PL_origargv[which] = savepv(form("/dev/fd/%d/%s",
+ Perl_croak(aTHX_ "Permission denied");
+ PL_origargv[which] = savepv(Perl_form(aTHX_ "/dev/fd/%d/%s",
PerlIO_fileno(PL_rsfp), PL_origargv[which]));
#if defined(HAS_FCNTL) && defined(F_SETFD)
fcntl(PerlIO_fileno(PL_rsfp),F_SETFD,0); /* ensure no close-on-exec */
#endif
- PerlProc_execv(form("%s/perl%s", BIN_EXP, PL_patchlevel), PL_origargv);/* try again */
- croak("Can't do setuid\n");
+ PerlProc_execv(Perl_form(aTHX_ "%s/perl%s", BIN_EXP, PL_patchlevel), PL_origargv);/* try again */
+ Perl_croak(aTHX_ "Can't do setuid\n");
#endif /* IAMSUID */
#else /* !DOSUID */
if (PL_euid != PL_uid || PL_egid != PL_gid) { /* (suidperl doesn't exist, in fact) */
(PL_egid != PL_gid && PL_egid == PL_statbuf.st_gid && PL_statbuf.st_mode & S_ISGID)
)
if (!PL_do_undump)
- croak("YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!\n\
+ Perl_croak(aTHX_ "YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!\n\
FIX YOUR KERNEL, PUT A C WRAPPER AROUND THIS SCRIPT, OR USE -u AND UNDUMP!\n");
#endif /* SETUID_SCRIPTS_ARE_SECURE_NOW */
/* not set-id, must be wrapped */
}
STATIC void
-find_beginning(void)
+S_find_beginning(pTHX)
{
register char *s, *s2;
forbid_setid("-x");
while (PL_doextract) {
if ((s = sv_gets(PL_linestr, PL_rsfp, 0)) == Nullch)
- croak("No Perl script found in input\n");
+ Perl_croak(aTHX_ "No Perl script found in input\n");
if (*s == '#' && s[1] == '!' && (s = instr(s,"perl"))) {
PerlIO_ungetc(PL_rsfp, '\n'); /* to keep line count right */
PL_doextract = FALSE;
while (s = moreswitches(s)) ;
}
if (PL_cddir && PerlDir_chdir(PL_cddir) < 0)
- croak("Can't chdir to %s",PL_cddir);
+ Perl_croak(aTHX_ "Can't chdir to %s",PL_cddir);
}
}
}
STATIC void
-init_ids(void)
+S_init_ids(pTHX)
{
- PL_uid = (int)PerlProc_getuid();
- PL_euid = (int)PerlProc_geteuid();
- PL_gid = (int)PerlProc_getgid();
- PL_egid = (int)PerlProc_getegid();
+ PL_uid = PerlProc_getuid();
+ PL_euid = PerlProc_geteuid();
+ PL_gid = PerlProc_getgid();
+ PL_egid = PerlProc_getegid();
#ifdef VMS
PL_uid |= PL_gid << 16;
PL_euid |= PL_egid << 16;
}
STATIC void
-forbid_setid(char *s)
+S_forbid_setid(pTHX_ char *s)
{
if (PL_euid != PL_uid)
- croak("No %s allowed while running setuid", s);
+ Perl_croak(aTHX_ "No %s allowed while running setuid", s);
if (PL_egid != PL_gid)
- croak("No %s allowed while running setgid", s);
+ Perl_croak(aTHX_ "No %s allowed while running setgid", s);
}
-STATIC void
-init_debugger(void)
+void
+Perl_init_debugger(pTHX)
{
dTHR;
+ HV *ostash = PL_curstash;
+
PL_curstash = PL_debstash;
PL_dbargs = GvAV(gv_AVadd((gv_fetchpv("args", GV_ADDMULTI, SVt_PVAV))));
AvREAL_off(PL_dbargs);
PL_DBgv = gv_fetchpv("DB", GV_ADDMULTI, SVt_PVGV);
PL_DBline = gv_fetchpv("dbline", GV_ADDMULTI, SVt_PVAV);
PL_DBsub = gv_HVadd(gv_fetchpv("sub", GV_ADDMULTI, SVt_PVHV));
+ sv_upgrade(GvSV(PL_DBsub), SVt_IV); /* IVX accessed if PERLDB_SUB_NN */
PL_DBsingle = GvSV((gv_fetchpv("single", GV_ADDMULTI, SVt_PV)));
sv_setiv(PL_DBsingle, 0);
PL_DBtrace = GvSV((gv_fetchpv("trace", GV_ADDMULTI, SVt_PV)));
sv_setiv(PL_DBtrace, 0);
PL_DBsignal = GvSV((gv_fetchpv("signal", GV_ADDMULTI, SVt_PV)));
sv_setiv(PL_DBsignal, 0);
- PL_curstash = PL_defstash;
+ PL_curstash = ostash;
}
#ifndef STRESS_REALLOC
#endif
void
-init_stacks(ARGSproto)
+Perl_init_stacks(pTHX)
{
/* start with 128-item stack and 8K cxstack */
PL_curstackinfo = new_stackinfo(REASONABLE(128),
#undef REASONABLE
STATIC void
-nuke_stacks(void)
+S_nuke_stacks(pTHX)
{
dTHR;
while (PL_curstackinfo->si_next)
#endif
STATIC void
-init_lexer(void)
+S_init_lexer(pTHX)
{
#ifdef PERL_OBJECT
PerlIO *tmpfp;
}
STATIC void
-init_predump_symbols(void)
+S_init_predump_symbols(pTHX)
{
dTHR;
GV *tmpgv;
GV *othergv;
+ IO *io;
- sv_setpvn(perl_get_sv("\"", TRUE), " ", 1);
+ sv_setpvn(get_sv("\"", TRUE), " ", 1);
PL_stdingv = gv_fetchpv("STDIN",TRUE, SVt_PVIO);
GvMULTI_on(PL_stdingv);
- IoIFP(GvIOp(PL_stdingv)) = PerlIO_stdin();
+ io = GvIOp(PL_stdingv);
+ IoIFP(io) = PerlIO_stdin();
tmpgv = gv_fetchpv("stdin",TRUE, SVt_PV);
GvMULTI_on(tmpgv);
- GvIOp(tmpgv) = (IO*)SvREFCNT_inc(GvIOp(PL_stdingv));
+ GvIOp(tmpgv) = (IO*)SvREFCNT_inc(io);
tmpgv = gv_fetchpv("STDOUT",TRUE, SVt_PVIO);
GvMULTI_on(tmpgv);
- IoOFP(GvIOp(tmpgv)) = IoIFP(GvIOp(tmpgv)) = PerlIO_stdout();
+ io = GvIOp(tmpgv);
+ IoOFP(io) = IoIFP(io) = PerlIO_stdout();
setdefout(tmpgv);
tmpgv = gv_fetchpv("stdout",TRUE, SVt_PV);
GvMULTI_on(tmpgv);
- GvIOp(tmpgv) = (IO*)SvREFCNT_inc(GvIOp(PL_defoutgv));
+ GvIOp(tmpgv) = (IO*)SvREFCNT_inc(io);
- othergv = gv_fetchpv("STDERR",TRUE, SVt_PVIO);
- GvMULTI_on(othergv);
- IoOFP(GvIOp(othergv)) = IoIFP(GvIOp(othergv)) = PerlIO_stderr();
+ PL_stderrgv = gv_fetchpv("STDERR",TRUE, SVt_PVIO);
+ GvMULTI_on(PL_stderrgv);
+ io = GvIOp(PL_stderrgv);
+ IoOFP(io) = IoIFP(io) = PerlIO_stderr();
tmpgv = gv_fetchpv("stderr",TRUE, SVt_PV);
GvMULTI_on(tmpgv);
- GvIOp(tmpgv) = (IO*)SvREFCNT_inc(GvIOp(othergv));
+ GvIOp(tmpgv) = (IO*)SvREFCNT_inc(io);
PL_statname = NEWSV(66,0); /* last filename we did stat on */
}
STATIC void
-init_postdump_symbols(register int argc, register char **argv, register char **env)
+S_init_postdump_symbols(pTHX_ register int argc, register char **argv, register char **env)
{
dTHR;
char *s;
GvMULTI_on(PL_envgv);
hv = GvHVn(PL_envgv);
hv_magic(hv, PL_envgv, 'E');
-#ifndef VMS /* VMS doesn't have environ array */
+#if !defined( VMS) && !defined(EPOC) /* VMS doesn't have environ array */
/* Note that if the supplied env parameter is actually a copy
of the global environ then it may now point to free'd memory
if the environment has been modified since. To avoid this
}
STATIC void
-init_perllib(void)
+S_init_perllib(pTHX)
{
char *s;
if (!PL_tainting) {
incpush(SITELIB_EXP, FALSE);
#endif
#endif
+#if defined(PERL_VENDORLIB_EXP)
+#if defined(WIN32)
+ incpush(PERL_VENDORLIB_EXP, TRUE);
+#else
+ incpush(PERL_VENDORLIB_EXP, FALSE);
+#endif
+#endif
if (!PL_tainting)
incpush(".", FALSE);
}
#endif
STATIC void
-incpush(char *p, int addsubdirs)
+S_incpush(pTHX_ char *p, int addsubdirs)
{
SV *subdir = Nullsv;
sv_usepvn(libdir,unix,len);
}
else
- PerlIO_printf(PerlIO_stderr(),
+ PerlIO_printf(Perl_error_log,
"Failed to unixify @INC element \"%s\"\n",
SvPV(libdir,len));
#endif
#ifdef USE_THREADS
STATIC struct perl_thread *
-init_main_thread()
+S_init_main_thread(pTHX)
{
+#if !defined(PERL_IMPLICIT_CONTEXT)
struct perl_thread *thr;
+#endif
XPV *xpv;
Newz(53, thr, 1, struct perl_thread);
PL_curcop = &PL_compiling;
+ thr->interp = PERL_GET_INTERP;
thr->cvcache = newHV();
thr->threadsv = newAV();
/* thr->threadsvp is set when find_threadsv is called */
thr->specific = newAV();
- thr->errhv = newHV();
thr->flags = THRf_R_JOINABLE;
MUTEX_INIT(&thr->mutex);
/* Handcraft thrsv similarly to mess_sv */
MUTEX_UNLOCK(&PL_threads_mutex);
#ifdef HAVE_THREAD_INTERN
- init_thread_intern(thr);
+ Perl_init_thread_intern(thr);
#endif
#ifdef SET_THREAD_SELF
(void) find_threadsv("@"); /* Ensure $@ is initialised early */
PL_maxscream = -1;
- PL_regcompp = FUNC_NAME_TO_PTR(pregcomp);
- PL_regexecp = FUNC_NAME_TO_PTR(regexec_flags);
+ PL_regcompp = MEMBER_TO_FPTR(Perl_pregcomp);
+ PL_regexecp = MEMBER_TO_FPTR(Perl_regexec_flags);
+ PL_regint_start = MEMBER_TO_FPTR(Perl_re_intuit_start);
+ PL_regint_string = MEMBER_TO_FPTR(Perl_re_intuit_string);
+ PL_regfree = MEMBER_TO_FPTR(Perl_pregfree);
PL_regindent = 0;
PL_reginterp_cnt = 0;
#endif /* USE_THREADS */
void
-call_list(I32 oldscope, AV *paramList)
+Perl_call_list(pTHX_ I32 oldscope, AV *paramList)
{
dTHR;
SV *atsv = ERRSV;
CV *cv;
STRLEN len;
int ret;
+ dJMPENV;
while (AvFILL(paramList) >= 0) {
cv = (CV*)av_shift(paramList);
SAVEFREESV(cv);
- CALLPROTECT(&ret, FUNC_NAME_TO_PTR(call_list_body), cv);
+ CALLPROTECT(aTHX_ pcur_env, &ret, MEMBER_TO_FPTR(S_call_list_body), cv);
switch (ret) {
case 0:
(void)SvPV(atsv, len);
sv_catpv(atsv, "END failed--cleanup aborted");
while (PL_scopestack_ix > oldscope)
LEAVE;
- croak("%s", SvPVX(atsv));
+ Perl_croak(aTHX_ "%s", SvPVX(atsv));
}
break;
case 1:
LEAVE;
FREETMPS;
PL_curstash = PL_defstash;
- if (PL_endav)
+ if (PL_endav && !PL_minus_c)
call_list(oldscope, PL_endav);
PL_curcop = &PL_compiling;
PL_curcop->cop_line = oldline;
if (PL_statusvalue) {
if (paramList == PL_beginav)
- croak("BEGIN failed--compilation aborted");
+ Perl_croak(aTHX_ "BEGIN failed--compilation aborted");
else
- croak("END failed--cleanup aborted");
+ Perl_croak(aTHX_ "END failed--cleanup aborted");
}
my_exit_jump();
/* NOTREACHED */
PL_curcop->cop_line = oldline;
JMPENV_JUMP(3);
}
- PerlIO_printf(PerlIO_stderr(), "panic: restartop\n");
+ PerlIO_printf(Perl_error_log, "panic: restartop\n");
FREETMPS;
break;
}
}
STATIC void *
-call_list_body(va_list args)
+S_call_list_body(pTHX_ va_list args)
{
dTHR;
CV *cv = va_arg(args, CV*);
PUSHMARK(PL_stack_sp);
- perl_call_sv((SV*)cv, G_EVAL|G_DISCARD);
+ call_sv((SV*)cv, G_EVAL|G_DISCARD);
return NULL;
}
void
-my_exit(U32 status)
+Perl_my_exit(pTHX_ U32 status)
{
dTHR;
}
void
-my_failure_exit(void)
+Perl_my_failure_exit(pTHX)
{
#ifdef VMS
if (vaxc$errno & 1) {
}
STATIC void
-my_exit_jump(void)
+S_my_exit_jump(pTHX)
{
dTHR;
register PERL_CONTEXT *cx;
#ifdef PERL_OBJECT
#define NO_XSLOCKS
-#endif /* PERL_OBJECT */
-
#include "XSUB.h"
+#endif
static I32
-#ifdef PERL_OBJECT
-read_e_script(CPerlObj *pPerl, int idx, SV *buf_sv, int maxlen)
-#else
-read_e_script(int idx, SV *buf_sv, int maxlen)
-#endif
+read_e_script(pTHXo_ int idx, SV *buf_sv, int maxlen)
{
char *p, *nl;
p = SvPVX(PL_e_script);
https://perl5.git.perl.org / perl5.git / blobdiff