CV* startcv, I32 cx_ix));
static char*
-gv_ename(gv)
-GV* gv;
+gv_ename(GV *gv)
{
SV* tmpsv = sv_newmortal();
gv_efullname3(tmpsv, gv, Nullch);
}
static OP *
-no_fh_allowed(o)
-OP *o;
+no_fh_allowed(OP *o)
{
yyerror(form("Missing comma after first argument to %s function",
op_desc[o->op_type]));
}
static OP *
-too_few_arguments(o, name)
-OP* o;
-char* name;
+too_few_arguments(OP *o, char *name)
{
yyerror(form("Not enough arguments for %s", name));
return o;
}
static OP *
-too_many_arguments(o, name)
-OP *o;
-char* name;
+too_many_arguments(OP *o, char *name)
{
yyerror(form("Too many arguments for %s", name));
return o;
}
static void
-bad_type(n, t, name, kid)
-I32 n;
-char *t;
-char *name;
-OP *kid;
+bad_type(I32 n, char *t, char *name, OP *kid)
{
yyerror(form("Type of arg %d to %s must be %s (not %s)",
(int)n, name, t, op_desc[kid->op_type]));
}
void
-assertref(o)
-OP *o;
+assertref(OP *o)
{
int type = o->op_type;
if (type != OP_AELEM && type != OP_HELEM) {
/* "register" allocation */
PADOFFSET
-pad_allocmy(name)
-char *name;
+pad_allocmy(char *name)
{
dTHR;
PADOFFSET off;
}
croak("Can't use global %s in \"my\"",name);
}
- if (AvFILL(comppad_name) >= 0) {
+ if (dowarn && AvFILL(comppad_name) >= 0) {
SV **svp = AvARRAY(comppad_name);
for (off = AvFILL(comppad_name); off > comppad_name_floor; off--) {
if ((sv = svp[off])
}
PADOFFSET
-pad_findmy(name)
-char *name;
+pad_findmy(char *name)
{
dTHR;
I32 off;
}
void
-pad_leavemy(fill)
-I32 fill;
+pad_leavemy(I32 fill)
{
I32 off;
SV **svp = AvARRAY(comppad_name);
}
PADOFFSET
-pad_alloc(optype,tmptype)
-I32 optype;
-U32 tmptype;
+pad_alloc(I32 optype, U32 tmptype)
{
dTHR;
SV *sv;
}
void
-pad_reset()
+pad_reset(void)
{
dTHR;
register I32 po;
/* Destructor */
void
-op_free(o)
-OP *o;
+op_free(OP *o)
{
register OP *kid, *nextkid;
}
static void
-null(o)
-OP* o;
+null(OP *o)
{
if (o->op_type != OP_NULL && o->op_targ > 0)
pad_free(o->op_targ);
#define LINKLIST(o) ((o)->op_next ? (o)->op_next : linklist((OP*)o))
OP *
-linklist(o)
-OP *o;
+linklist(OP *o)
{
register OP *kid;
}
OP *
-scalarkids(o)
-OP *o;
+scalarkids(OP *o)
{
OP *kid;
if (o && o->op_flags & OPf_KIDS) {
}
static OP *
-scalarboolean(o)
-OP *o;
+scalarboolean(OP *o)
{
if (dowarn &&
o->op_type == OP_SASSIGN && cBINOPo->op_first->op_type == OP_CONST) {
+ dTHR;
line_t oldline = curcop->cop_line;
if (copline != NOLINE)
}
OP *
-scalar(o)
-OP *o;
+scalar(OP *o)
{
OP *kid;
else
scalar(kid);
}
- curcop = &compiling;
+ WITH_THR(curcop = &compiling);
break;
case OP_SCOPE:
case OP_LINESEQ:
else
scalar(kid);
}
- curcop = &compiling;
+ WITH_THR(curcop = &compiling);
break;
}
return o;
}
OP *
-scalarvoid(o)
-OP *o;
+scalarvoid(OP *o)
{
OP *kid;
char* useless = 0;
case OP_NEXTSTATE:
case OP_DBSTATE:
- curcop = ((COP*)o); /* for warning below */
+ WITH_THR(curcop = ((COP*)o)); /* for warning below */
break;
case OP_CONST:
case OP_NULL:
if (o->op_targ == OP_NEXTSTATE || o->op_targ == OP_DBSTATE)
- curcop = ((COP*)o); /* for warning below */
+ WITH_THR(curcop = ((COP*)o)); /* for warning below */
if (o->op_flags & OPf_STACKED)
break;
/* FALL THROUGH */
}
OP *
-listkids(o)
-OP *o;
+listkids(OP *o)
{
OP *kid;
if (o && o->op_flags & OPf_KIDS) {
}
OP *
-list(o)
-OP *o;
+list(OP *o)
{
OP *kid;
else
list(kid);
}
- curcop = &compiling;
+ WITH_THR(curcop = &compiling);
break;
case OP_SCOPE:
case OP_LINESEQ:
else
list(kid);
}
- curcop = &compiling;
+ WITH_THR(curcop = &compiling);
break;
case OP_REQUIRE:
/* all requires must return a boolean value */
}
OP *
-scalarseq(o)
-OP *o;
+scalarseq(OP *o)
{
OP *kid;
o->op_type == OP_LEAVE ||
o->op_type == OP_LEAVETRY)
{
+ dTHR;
for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling) {
if (kid->op_sibling) {
scalarvoid(kid);
}
static OP *
-modkids(o, type)
-OP *o;
-I32 type;
+modkids(OP *o, I32 type)
{
OP *kid;
if (o && o->op_flags & OPf_KIDS) {
static I32 modcount;
OP *
-mod(o, type)
-OP *o;
-I32 type;
+mod(OP *o, I32 type)
{
dTHR;
OP *kid;
switch (o->op_type) {
case OP_UNDEF:
+ modcount++;
return o;
case OP_CONST:
if (!(o->op_private & (OPpCONST_ARYBASE)))
case OP_RV2AV:
case OP_RV2HV:
+ if (!type && cUNOPo->op_first->op_type != OP_GV)
+ croak("Can't localize through a reference");
if (type == OP_REFGEN && o->op_flags & OPf_PARENS) {
modcount = 10000;
return o; /* Treat \(@foo) like ordinary list. */
break;
case OP_RV2SV:
if (!type && cUNOPo->op_first->op_type != OP_GV)
- croak("Can't localize a reference");
+ croak("Can't localize through a reference");
ref(cUNOPo->op_first, o->op_type);
/* FALL THROUGH */
case OP_GV:
}
static bool
-scalar_mod_type(o, type)
-OP *o;
-I32 type;
+scalar_mod_type(OP *o, I32 type)
{
switch (type) {
case OP_SASSIGN:
}
OP *
-refkids(o, type)
-OP *o;
-I32 type;
+refkids(OP *o, I32 type)
{
OP *kid;
if (o && o->op_flags & OPf_KIDS) {
}
OP *
-ref(o, type)
-OP *o;
-I32 type;
+ref(OP *o, I32 type)
{
OP *kid;
switch (o->op_type) {
case OP_ENTERSUB:
- if ((type == OP_DEFINED) &&
+ if ((type == OP_DEFINED || type == OP_LOCK) &&
!(o->op_flags & OPf_STACKED)) {
o->op_type = OP_RV2CV; /* entersub => rv2cv */
o->op_ppaddr = ppaddr[OP_RV2CV];
}
OP *
-my(o)
-OP *o;
+my(OP *o)
{
OP *kid;
I32 type;
}
OP *
-sawparens(o)
-OP *o;
+sawparens(OP *o)
{
if (o)
o->op_flags |= OPf_PARENS;
}
OP *
-bind_match(type, left, right)
-I32 type;
-OP *left;
-OP *right;
+bind_match(I32 type, OP *left, OP *right)
{
OP *o;
}
OP *
-invert(o)
-OP *o;
+invert(OP *o)
{
if (!o)
return o;
}
OP *
-scope(o)
-OP *o;
+scope(OP *o)
{
if (o) {
- if (o->op_flags & OPf_PARENS || perldb || tainting) {
+ if (o->op_flags & OPf_PARENS || PERLDB_NOOPT || tainting) {
o = prepend_elem(OP_LINESEQ, newOP(OP_ENTER, 0), o);
o->op_type = OP_LEAVE;
o->op_ppaddr = ppaddr[OP_LEAVE];
}
int
-block_start(full)
-int full;
+block_start(int full)
{
dTHR;
int retval = savestack_ix;
}
OP*
-block_end(floor, seq)
-I32 floor;
-OP* seq;
+block_end(I32 floor, OP *seq)
{
dTHR;
int needblockscope = hints & HINT_BLOCK_SCOPE;
}
void
-newPROG(o)
-OP *o;
+newPROG(OP *o)
{
dTHR;
if (in_eval) {
compcv = 0;
/* Register with debugger */
- if (perldb) {
+ if (PERLDB_INTER) {
CV *cv = perl_get_cv("DB::postponed", FALSE);
if (cv) {
dSP;
}
OP *
-localize(o, lex)
-OP *o;
-I32 lex;
+localize(OP *o, I32 lex)
{
if (o->op_flags & OPf_PARENS)
list(o);
}
OP *
-jmaybe(o)
-OP *o;
+jmaybe(OP *o)
{
if (o->op_type == OP_LIST) {
o = convert(OP_JOIN, 0,
}
OP *
-fold_constants(o)
-register OP *o;
+fold_constants(register OP *o)
{
dTHR;
register OP *curop;
if (!(opargs[type] & OA_FOLDCONST))
goto nope;
+ switch (type) {
+ case OP_SPRINTF:
+ case OP_UCFIRST:
+ case OP_LCFIRST:
+ case OP_UC:
+ case OP_LC:
+ if (o->op_private & OPpLOCALE)
+ goto nope;
+ }
+
if (error_count)
goto nope; /* Don't try to run w/ errors */
}
OP *
-gen_constant_list(o)
-register OP *o;
+gen_constant_list(register OP *o)
{
dTHR;
register OP *curop;
}
OP *
-convert(type, flags, o)
-I32 type;
-I32 flags;
-OP* o;
+convert(I32 type, I32 flags, OP *o)
{
OP *kid;
OP *last = 0;
/* List constructors */
OP *
-append_elem(type, first, last)
-I32 type;
-OP* first;
-OP* last;
+append_elem(I32 type, OP *first, OP *last)
{
if (!first)
return last;
}
OP *
-append_list(type, first, last)
-I32 type;
-LISTOP* first;
-LISTOP* last;
+append_list(I32 type, LISTOP *first, LISTOP *last)
{
if (!first)
return (OP*)last;
}
OP *
-prepend_elem(type, first, last)
-I32 type;
-OP* first;
-OP* last;
+prepend_elem(I32 type, OP *first, OP *last)
{
if (!first)
return last;
/* Constructors */
OP *
-newNULLLIST()
+newNULLLIST(void)
{
return newOP(OP_STUB, 0);
}
OP *
-force_list(o)
-OP *o;
+force_list(OP *o)
{
if (!o || o->op_type != OP_LIST)
o = newLISTOP(OP_LIST, 0, o, Nullop);
}
OP *
-newLISTOP(type, flags, first, last)
-I32 type;
-I32 flags;
-OP* first;
-OP* last;
+newLISTOP(I32 type, I32 flags, OP *first, OP *last)
{
LISTOP *listop;
}
OP *
-newOP(type, flags)
-I32 type;
-I32 flags;
+newOP(I32 type, I32 flags)
{
OP *o;
Newz(1101, o, 1, OP);
}
OP *
-newUNOP(type, flags, first)
-I32 type;
-I32 flags;
-OP* first;
+newUNOP(I32 type, I32 flags, OP *first)
{
UNOP *unop;
}
OP *
-newBINOP(type, flags, first, last)
-I32 type;
-I32 flags;
-OP* first;
-OP* last;
+newBINOP(I32 type, I32 flags, OP *first, OP *last)
{
BINOP *binop;
Newz(1101, binop, 1, BINOP);
}
OP *
-pmtrans(o, expr, repl)
-OP *o;
-OP *expr;
-OP *repl;
+pmtrans(OP *o, OP *expr, OP *repl)
{
SV *tstr = ((SVOP*)expr)->op_sv;
SV *rstr = ((SVOP*)repl)->op_sv;
register U8 *r = (U8*)SvPV(rstr, rlen);
register I32 i;
register I32 j;
- I32 delete;
+ I32 Delete;
I32 complement;
register short *tbl;
tbl = (short*)cPVOPo->op_pv;
complement = o->op_private & OPpTRANS_COMPLEMENT;
- delete = o->op_private & OPpTRANS_DELETE;
+ Delete = o->op_private & OPpTRANS_DELETE;
/* squash = o->op_private & OPpTRANS_SQUASH; */
if (complement) {
for (i = 0, j = 0; i < 256; i++) {
if (!tbl[i]) {
if (j >= rlen) {
- if (delete)
+ if (Delete)
tbl[i] = -2;
else if (rlen)
tbl[i] = r[j-1];
}
}
else {
- if (!rlen && !delete) {
+ if (!rlen && !Delete) {
r = t; rlen = tlen;
}
for (i = 0; i < 256; i++)
tbl[i] = -1;
for (i = 0, j = 0; i < tlen; i++,j++) {
if (j >= rlen) {
- if (delete) {
+ if (Delete) {
if (tbl[t[i]] == -1)
tbl[t[i]] = -2;
continue;
}
OP *
-newPMOP(type, flags)
-I32 type;
-I32 flags;
+newPMOP(I32 type, I32 flags)
{
dTHR;
PMOP *pmop;
}
OP *
-pmruntime(o, expr, repl)
-OP *o;
-OP *expr;
-OP *repl;
+pmruntime(OP *o, OP *expr, OP *repl)
{
PMOP *pm;
LOGOP *rcop;
if (o->op_type == OP_TRANS)
return pmtrans(o, expr, repl);
+ hints |= HINT_BLOCK_SCOPE;
pm = (PMOP*)o;
if (expr->op_type == OP_CONST) {
}
OP *
-newSVOP(type, flags, sv)
-I32 type;
-I32 flags;
-SV *sv;
+newSVOP(I32 type, I32 flags, SV *sv)
{
SVOP *svop;
Newz(1101, svop, 1, SVOP);
}
OP *
-newGVOP(type, flags, gv)
-I32 type;
-I32 flags;
-GV *gv;
+newGVOP(I32 type, I32 flags, GV *gv)
{
dTHR;
GVOP *gvop;
}
OP *
-newPVOP(type, flags, pv)
-I32 type;
-I32 flags;
-char *pv;
+newPVOP(I32 type, I32 flags, char *pv)
{
PVOP *pvop;
Newz(1101, pvop, 1, PVOP);
}
void
-package(o)
-OP *o;
+package(OP *o)
{
dTHR;
SV *sv;
}
void
-utilize(aver, floor, version, id, arg)
-int aver;
-I32 floor;
-OP *version;
-OP *id;
-OP *arg;
+utilize(int aver, I32 floor, OP *version, OP *id, OP *arg)
{
OP *pack;
OP *meth;
}
OP *
-newSLICEOP(flags, subscript, listval)
-I32 flags;
-OP *subscript;
-OP *listval;
+newSLICEOP(I32 flags, OP *subscript, OP *listval)
{
return newBINOP(OP_LSLICE, flags,
list(force_list(subscript)),
}
static I32
-list_assignment(o)
-register OP *o;
+list_assignment(register OP *o)
{
if (!o)
return TRUE;
}
OP *
-newASSIGNOP(flags, left, optype, right)
-I32 flags;
-OP *left;
-I32 optype;
-OP *right;
+newASSIGNOP(I32 flags, OP *left, I32 optype, OP *right)
{
OP *o;
}
OP *
-newSTATEOP(flags, label, o)
-I32 flags;
-char *label;
-OP *o;
+newSTATEOP(I32 flags, char *label, OP *o)
{
dTHR;
U32 seq = intro_my();
register COP *cop;
Newz(1101, cop, 1, COP);
- if (perldb && curcop->cop_line && curstash != debstash) {
+ if (PERLDB_LINE && curcop->cop_line && curstash != debstash) {
cop->op_type = OP_DBSTATE;
cop->op_ppaddr = ppaddr[ OP_DBSTATE ];
}
cop->cop_filegv = (GV*)SvREFCNT_inc(curcop->cop_filegv);
cop->cop_stash = curstash;
- if (perldb && curstash != debstash) {
+ if (PERLDB_LINE && curstash != debstash) {
SV **svp = av_fetch(GvAV(curcop->cop_filegv),(I32)cop->cop_line, FALSE);
if (svp && *svp != &sv_undef && !SvIOK(*svp)) {
(void)SvIOK_on(*svp);
/* "Introduce" my variables to visible status. */
U32
-intro_my()
+intro_my(void)
{
SV **svp;
SV *sv;
}
OP *
-newLOGOP(type, flags, first, other)
-I32 type;
-I32 flags;
-OP* first;
-OP* other;
+newLOGOP(I32 type, I32 flags, OP *first, OP *other)
{
dTHR;
LOGOP *logop;
}
OP *
-newCONDOP(flags, first, trueop, falseop)
-I32 flags;
-OP* first;
-OP* trueop;
-OP* falseop;
+newCONDOP(I32 flags, OP *first, OP *trueop, OP *falseop)
{
dTHR;
CONDOP *condop;
}
OP *
-newRANGE(flags, left, right)
-I32 flags;
-OP *left;
-OP *right;
+newRANGE(I32 flags, OP *left, OP *right)
{
dTHR;
CONDOP *condop;
}
OP *
-newLOOPOP(flags, debuggable, expr, block)
-I32 flags;
-I32 debuggable;
-OP *expr;
-OP *block;
+newLOOPOP(I32 flags, I32 debuggable, OP *expr, OP *block)
{
dTHR;
OP* listop;
if (expr) {
if (once && expr->op_type == OP_CONST && !SvTRUE(((SVOP*)expr)->op_sv))
return block; /* do {} while 0 does once */
- if (expr->op_type == OP_READLINE || expr->op_type == OP_GLOB) {
+ if (expr->op_type == OP_READLINE || expr->op_type == OP_GLOB
+ || (expr->op_type == OP_NULL && expr->op_targ == OP_GLOB)) {
expr = newUNOP(OP_DEFINED, 0,
newASSIGNOP(0, newSVREF(newGVOP(OP_GV, 0, defgv)), 0, expr) );
}
}
OP *
-newWHILEOP(flags, debuggable, loop, expr, block, cont)
-I32 flags;
-I32 debuggable;
-LOOP *loop;
-OP *expr;
-OP *block;
-OP *cont;
+newWHILEOP(I32 flags, I32 debuggable, LOOP *loop, I32 whileline, OP *expr, OP *block, OP *cont)
{
dTHR;
OP *redo;
OP *o;
OP *condop;
- if (expr && (expr->op_type == OP_READLINE || expr->op_type == OP_GLOB)) {
+ if (expr && (expr->op_type == OP_READLINE || expr->op_type == OP_GLOB
+ || (expr->op_type == OP_NULL && expr->op_targ == OP_GLOB))) {
expr = newUNOP(OP_DEFINED, 0,
newASSIGNOP(0, newSVREF(newGVOP(OP_GV, 0, defgv)), 0, expr) );
}
if (cont)
next = LINKLIST(cont);
- if (expr)
+ if (expr) {
cont = append_elem(OP_LINESEQ, cont, newOP(OP_UNSTACK, 0));
+ if ((line_t)whileline != NOLINE) {
+ copline = whileline;
+ cont = append_elem(OP_LINESEQ, cont,
+ newSTATEOP(0, Nullch, Nullop));
+ }
+ }
listop = append_list(OP_LINESEQ, (LISTOP*)block, (LISTOP*)cont);
redo = LINKLIST(listop);
#endif /* CAN_PROTOTYPE */
{
LOOP *loop;
+ OP *wop;
int padoff = 0;
I32 iterflags = 0;
- copline = forline;
if (sv) {
if (sv->op_type == OP_RV2SV) { /* symbol table variable */
sv->op_type = OP_RV2GV;
assert(!loop->op_next);
Renew(loop, 1, LOOP);
loop->op_targ = padoff;
- return newSTATEOP(0, label, newWHILEOP(flags, 1, loop,
- newOP(OP_ITER, 0), block, cont));
+ wop = newWHILEOP(flags, 1, loop, forline, newOP(OP_ITER, 0), block, cont);
+ copline = forline;
+ return newSTATEOP(0, label, wop);
}
OP*
-newLOOPEX(type, label)
-I32 type;
-OP* label;
+newLOOPEX(I32 type, OP *label)
{
dTHR;
OP *o;
}
void
-cv_undef(cv)
-CV *cv;
+cv_undef(CV *cv)
{
dTHR;
#ifdef USE_THREADS
Safefree(CvMUTEXP(cv));
CvMUTEXP(cv) = 0;
}
- if (CvCONDP(cv)) {
- COND_DESTROY(CvCONDP(cv));
- Safefree(CvCONDP(cv));
- CvCONDP(cv) = 0;
- }
#endif /* USE_THREADS */
if (!CvXSUB(cv) && CvROOT(cv)) {
SV** ppad;
I32 ix;
- PerlIO_printf(Perl_debug_log, "\tCV=0x%p (%s), OUTSIDE=0x%p (%s)\n",
+ PerlIO_printf(Perl_debug_log, "\tCV=0x%lx (%s), OUTSIDE=0x%lx (%s)\n",
cv,
(CvANON(cv) ? "ANON"
: (cv == main_cv) ? "MAIN"
for (ix = 1; ix <= AvFILL(pad_name); ix++) {
if (SvPOK(pname[ix]))
- PerlIO_printf(Perl_debug_log, "\t%4d. 0x%p (%s\"%s\" %ld-%ld)\n",
+ PerlIO_printf(Perl_debug_log, "\t%4d. 0x%lx (%s\"%s\" %ld-%ld)\n",
ix, ppad[ix],
SvFAKE(pname[ix]) ? "FAKE " : "",
SvPVX(pname[ix]),
#endif /* DEBUG_CLOSURES */
static CV *
-cv_clone2(proto, outside)
-CV* proto;
-CV* outside;
+cv_clone2(CV *proto, CV *outside)
{
dTHR;
AV* av;
#ifdef USE_THREADS
New(666, CvMUTEXP(cv), 1, perl_mutex);
MUTEX_INIT(CvMUTEXP(cv));
- New(666, CvCONDP(cv), 1, perl_cond);
- COND_INIT(CvCONDP(cv));
CvOWNER(cv) = 0;
#endif /* USE_THREADS */
CvFILEGV(cv) = CvFILEGV(proto);
}
CV *
-cv_clone(proto)
-CV* proto;
+cv_clone(CV *proto)
{
return cv_clone2(proto, CvOUTSIDE(proto));
}
void
-cv_ckproto(cv, gv, p)
-CV* cv;
-GV* gv;
-char* p;
+cv_ckproto(CV *cv, GV *gv, char *p)
{
if ((!p != !SvPOK(cv)) || (p && strNE(p, SvPVX(cv)))) {
SV* msg = sv_newmortal();
}
SV *
-cv_const_sv(cv)
-CV* cv;
+cv_const_sv(CV *cv)
{
OP *o;
SV *sv;
}
CV *
-newSUB(floor,o,proto,block)
-I32 floor;
-OP *o;
-OP *proto;
-OP *block;
+newSUB(I32 floor, OP *o, OP *proto, OP *block)
{
dTHR;
char *name = o ? SvPVx(cSVOPo->op_sv, na) : Nullch;
CvOWNER(cv) = 0;
New(666, CvMUTEXP(cv), 1, perl_mutex);
MUTEX_INIT(CvMUTEXP(cv));
- New(666, CvCONDP(cv), 1, perl_cond);
- COND_INIT(CvCONDP(cv));
#endif /* USE_THREADS */
if (ps)
if (name) {
char *s;
- if (perldb && curstash != debstash) {
+ if (PERLDB_SUBLINE && curstash != debstash) {
SV *sv = NEWSV(0,0);
SV *tmpstr = sv_newmortal();
static GV *db_postponed;
av_store(endav, 0, (SV *)cv);
GvCV(gv) = 0;
}
- else if (strEQ(s, "RESTART") && !error_count) {
- if (!restartav)
- restartav = newAV();
- av_push(restartav, SvREFCNT_inc(cv));
+ else if (strEQ(s, "INIT") && !error_count) {
+ if (!initav)
+ initav = newAV();
+ av_push(initav, SvREFCNT_inc(cv));
}
}
#endif
CV *
-newXS(name, subaddr, filename)
-char *name;
-void (*subaddr) _((CV*));
-char *filename;
+newXS(char *name, void (*subaddr) (CV *), char *filename)
{
dTHR;
GV *gv = gv_fetchpv(name ? name : "__ANON__", GV_ADDMULTI, SVt_PVCV);
#ifdef USE_THREADS
New(666, CvMUTEXP(cv), 1, perl_mutex);
MUTEX_INIT(CvMUTEXP(cv));
- New(666, CvCONDP(cv), 1, perl_cond);
- COND_INIT(CvCONDP(cv));
CvOWNER(cv) = 0;
#endif /* USE_THREADS */
CvFILEGV(cv) = gv_fetchfile(filename);
av_store(endav, 0, (SV *)cv);
GvCV(gv) = 0;
}
- else if (strEQ(s, "RESTART")) {
- if (!restartav)
- restartav = newAV();
- av_push(restartav, (SV *)cv);
+ else if (strEQ(s, "INIT")) {
+ if (!initav)
+ initav = newAV();
+ av_push(initav, (SV *)cv);
}
}
else
}
void
-newFORM(floor,o,block)
-I32 floor;
-OP *o;
-OP *block;
+newFORM(I32 floor, OP *o, OP *block)
{
dTHR;
register CV *cv;
}
OP *
-newANONLIST(o)
-OP* o;
+newANONLIST(OP *o)
{
return newUNOP(OP_REFGEN, 0,
mod(list(convert(OP_ANONLIST, 0, o)), OP_REFGEN));
}
OP *
-newANONHASH(o)
-OP* o;
+newANONHASH(OP *o)
{
return newUNOP(OP_REFGEN, 0,
mod(list(convert(OP_ANONHASH, 0, o)), OP_REFGEN));
}
OP *
-newANONSUB(floor, proto, block)
-I32 floor;
-OP *proto;
-OP *block;
+newANONSUB(I32 floor, OP *proto, OP *block)
{
return newUNOP(OP_REFGEN, 0,
newSVOP(OP_ANONCODE, 0, (SV*)newSUB(floor, 0, proto, block)));
}
OP *
-oopsAV(o)
-OP *o;
+oopsAV(OP *o)
{
switch (o->op_type) {
case OP_PADSV:
}
OP *
-oopsHV(o)
-OP *o;
+oopsHV(OP *o)
{
switch (o->op_type) {
case OP_PADSV:
}
OP *
-newAVREF(o)
-OP *o;
+newAVREF(OP *o)
{
if (o->op_type == OP_PADANY) {
o->op_type = OP_PADAV;
}
OP *
-newGVREF(type,o)
-I32 type;
-OP *o;
+newGVREF(I32 type, OP *o)
{
if (type == OP_MAPSTART)
return newUNOP(OP_NULL, 0, o);
}
OP *
-newHVREF(o)
-OP *o;
+newHVREF(OP *o)
{
if (o->op_type == OP_PADANY) {
o->op_type = OP_PADHV;
}
OP *
-oopsCV(o)
-OP *o;
+oopsCV(OP *o)
{
croak("NOT IMPL LINE %d",__LINE__);
/* STUB */
}
OP *
-newCVREF(flags, o)
-I32 flags;
-OP *o;
+newCVREF(I32 flags, OP *o)
{
return newUNOP(OP_RV2CV, flags, scalar(o));
}
OP *
-newSVREF(o)
-OP *o;
+newSVREF(OP *o)
{
if (o->op_type == OP_PADANY) {
o->op_type = OP_PADSV;
/* Check routines. */
OP *
-ck_anoncode(o)
-OP *o;
+ck_anoncode(OP *o)
{
PADOFFSET ix;
SV* name;
}
OP *
-ck_bitop(o)
-OP *o;
+ck_bitop(OP *o)
{
o->op_private = hints;
return o;
}
OP *
-ck_concat(o)
-OP *o;
+ck_concat(OP *o)
{
if (cUNOPo->op_first->op_type == OP_CONCAT)
o->op_flags |= OPf_STACKED;
}
OP *
-ck_spair(o)
-OP *o;
+ck_spair(OP *o)
{
if (o->op_flags & OPf_KIDS) {
OP* newop;
}
OP *
-ck_delete(o)
-OP *o;
+ck_delete(OP *o)
{
o = ck_fun(o);
o->op_private = 0;
}
OP *
-ck_eof(o)
-OP *o;
+ck_eof(OP *o)
{
I32 type = o->op_type;
if (cLISTOPo->op_first->op_type == OP_STUB) {
op_free(o);
o = newUNOP(type, OPf_SPECIAL,
- newGVOP(OP_GV, 0, gv_fetchpv("main'ARGV", TRUE, SVt_PVAV)));
+ newGVOP(OP_GV, 0, gv_fetchpv("main::ARGV", TRUE, SVt_PVAV)));
}
return ck_fun(o);
}
}
OP *
-ck_eval(o)
-OP *o;
+ck_eval(OP *o)
{
hints |= HINT_BLOCK_SCOPE;
if (o->op_flags & OPf_KIDS) {
}
OP *
-ck_exec(o)
-OP *o;
+ck_exec(OP *o)
{
OP *kid;
if (o->op_flags & OPf_STACKED) {
}
OP *
-ck_exists(o)
-OP *o;
+ck_exists(OP *o)
{
o = ck_fun(o);
if (o->op_flags & OPf_KIDS) {
}
OP *
-ck_gvconst(o)
-register OP *o;
+ck_gvconst(register OP *o)
{
o = fold_constants(o);
if (o->op_type == OP_CONST)
}
OP *
-ck_rvconst(o)
-register OP *o;
+ck_rvconst(register OP *o)
{
dTHR;
SVOP *kid = (SVOP*)cUNOPo->op_first;
}
OP *
-ck_ftst(o)
-OP *o;
+ck_ftst(OP *o)
{
dTHR;
I32 type = o->op_type;
else {
op_free(o);
if (type == OP_FTTTY)
- return newGVOP(type, OPf_REF, gv_fetchpv("main'STDIN", TRUE,
+ return newGVOP(type, OPf_REF, gv_fetchpv("main::STDIN", TRUE,
SVt_PVIO));
else
return newUNOP(type, 0, newSVREF(newGVOP(OP_GV, 0, defgv)));
}
OP *
-ck_fun(o)
-OP *o;
+ck_fun(OP *o)
{
dTHR;
register OP *kid;
}
OP *
-ck_glob(o)
-OP *o;
+ck_glob(OP *o)
{
- GV *gv = gv_fetchpv("glob", FALSE, SVt_PVCV);
+ GV *gv;
+
+ if ((o->op_flags & OPf_KIDS) && !cLISTOPo->op_first->op_sibling)
+ append_elem(OP_GLOB, o, newSVREF(newGVOP(OP_GV, 0, defgv)));
+
+ if (!((gv = gv_fetchpv("glob", FALSE, SVt_PVCV)) && GvIMPORTED_CV(gv)))
+ gv = gv_fetchpv("CORE::GLOBAL::glob", FALSE, SVt_PVCV);
if (gv && GvIMPORTED_CV(gv)) {
static int glob_index;
append_elem(OP_LIST, o,
scalar(newUNOP(OP_RV2CV, 0,
newGVOP(OP_GV, 0, gv)))));
- return ck_subr(o);
+ o = newUNOP(OP_NULL, 0, ck_subr(o));
+ o->op_targ = OP_GLOB; /* hint at what it used to be */
+ return o;
}
- if ((o->op_flags & OPf_KIDS) && !cLISTOPo->op_first->op_sibling)
- append_elem(OP_GLOB, o, newSVREF(newGVOP(OP_GV, 0, defgv)));
gv = newGVgen("main");
gv_IOadd(gv);
append_elem(OP_GLOB, o, newGVOP(OP_GV, 0, gv));
}
OP *
-ck_grep(o)
-OP *o;
+ck_grep(OP *o)
{
LOGOP *gwop;
OP *kid;
}
OP *
-ck_index(o)
-OP *o;
+ck_index(OP *o)
{
if (o->op_flags & OPf_KIDS) {
OP *kid = cLISTOPo->op_first->op_sibling; /* get past pushmark */
}
OP *
-ck_lengthconst(o)
-OP *o;
+ck_lengthconst(OP *o)
{
/* XXX length optimization goes here */
return ck_fun(o);
}
OP *
-ck_lfun(o)
-OP *o;
+ck_lfun(OP *o)
{
OPCODE type = o->op_type;
return modkids(ck_fun(o), type);
}
OP *
-ck_rfun(o)
-OP *o;
+ck_rfun(OP *o)
{
OPCODE type = o->op_type;
return refkids(ck_fun(o), type);
}
OP *
-ck_listiob(o)
-OP *o;
+ck_listiob(OP *o)
{
register OP *kid;
}
OP *
-ck_fun_locale(o)
-OP *o;
+ck_fun_locale(OP *o)
{
o = ck_fun(o);
}
OP *
-ck_scmp(o)
-OP *o;
+ck_scmp(OP *o)
{
o->op_private = 0;
#ifdef USE_LOCALE
}
OP *
-ck_match(o)
-OP *o;
+ck_match(OP *o)
{
o->op_private |= OPpRUNTIME;
return o;
}
OP *
-ck_null(o)
-OP *o;
+ck_null(OP *o)
{
return o;
}
OP *
-ck_repeat(o)
-OP *o;
+ck_repeat(OP *o)
{
if (cBINOPo->op_first->op_flags & OPf_PARENS) {
o->op_private |= OPpREPEAT_DOLIST;
}
OP *
-ck_require(o)
-OP *o;
+ck_require(OP *o)
{
if (o->op_flags & OPf_KIDS) { /* Shall we supply missing .pm? */
SVOP *kid = (SVOP*)cUNOPo->op_first;
}
OP *
-ck_retarget(o)
-OP *o;
+ck_retarget(OP *o)
{
croak("NOT IMPL LINE %d",__LINE__);
/* STUB */
}
OP *
-ck_select(o)
-OP *o;
+ck_select(OP *o)
{
OP* kid;
if (o->op_flags & OPf_KIDS) {
}
OP *
-ck_shift(o)
-OP *o;
+ck_shift(OP *o)
{
I32 type = o->op_type;
}
OP *
-ck_sort(o)
-OP *o;
+ck_sort(OP *o)
{
o->op_private = 0;
#ifdef USE_LOCALE
}
OP *
-ck_split(o)
-OP *o;
+ck_split(OP *o)
{
register OP *kid;
PMOP* pm;
}
OP *
-ck_subr(o)
-OP *o;
+ck_subr(OP *o)
{
dTHR;
OP *prev = ((cUNOPo->op_first->op_sibling)
}
}
o->op_private |= (hints & HINT_STRICT_REFS);
- if (perldb && curstash != debstash)
+ if (PERLDB_SUB && curstash != debstash)
o->op_private |= OPpENTERSUB_DB;
while (o2 != cvop) {
if (proto) {
prev = o2;
o2 = o2->op_sibling;
}
- if (proto && !optional && *proto == '$')
+ if (proto && !optional &&
+ (*proto && *proto != '@' && *proto != '%' && *proto != ';'))
return too_few_arguments(o, gv_ename(namegv));
return o;
}
OP *
-ck_svconst(o)
-OP *o;
+ck_svconst(OP *o)
{
SvREADONLY_on(cSVOPo->op_sv);
return o;
}
OP *
-ck_trunc(o)
-OP *o;
+ck_trunc(OP *o)
{
if (o->op_flags & OPf_KIDS) {
SVOP *kid = (SVOP*)cUNOPo->op_first;
/* A peephole optimizer. We visit the ops in the order they're to execute. */
void
-peep(o)
-register OP* o;
+peep(register OP *o)
{
dTHR;
register OP* oldop = 0;
o->op_seq = op_seqmax++;
break;
+ case OP_PADAV:
+ if (o->op_next->op_type == OP_RV2AV
+ && (o->op_next->op_flags && OPf_REF))
+ {
+ null(o->op_next);
+ o->op_next = o->op_next->op_next;
+ }
+ break;
+
+ case OP_PADHV:
+ if (o->op_next->op_type == OP_RV2HV
+ && (o->op_next->op_flags && OPf_REF))
+ {
+ null(o->op_next);
+ o->op_next = o->op_next->op_next;
+ }
+ break;
+
case OP_MAPWHILE:
case OP_GREPWHILE:
case OP_AND:
projects / p5sagit/p5-mst-13.2.git / blobdiff