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
fix bug in change#4515 (STOP blocks now see @ARGV like the rest)
[perl5.git] / op.c
CommitLineData
a0d0e21e 1/* op.c
79072805 2 *
4eb8286e 3 * Copyright (c) 1991-1999, Larry Wall
79072805
LW		 4 *
5 * You may distribute under the terms of either the GNU General Public
6 * License or the Artistic License, as specified in the README file.
7 *
a0d0e21e
LW		 8 */
9
10/*
11 * "You see: Mr. Drogo, he married poor Miss Primula Brandybuck. She was
12 * our Mr. Bilbo's first cousin on the mother's side (her mother being the
13 * youngest of the Old Took's daughters); and Mr. Drogo was his second
14 * cousin. So Mr. Frodo is his first *and* second cousin, once removed
15 * either way, as the saying is, if you follow me." --the Gaffer
79072805
LW		 16 */
17
18#include "EXTERN.h"
864dbfa3 19#define PERL_IN_OP_C
79072805 20#include "perl.h"
77ca0c92 21#include "keywords.h"
79072805 22
b7dc083c 23/* #define PL_OP_SLAB_ALLOC */
7934575e
GS		 24
25/* XXXXXX testing */
26#define OP_REFCNT_LOCK NOOP
27#define OP_REFCNT_UNLOCK NOOP
28#define OpREFCNT_set(o,n) NOOP
971a9dd3 29#define OpREFCNT_dec(o) ((o)->op_targ--)
7934575e 30
b7dc083c
NIS		 31#ifdef PL_OP_SLAB_ALLOC
32#define SLAB_SIZE 8192
33static char *PL_OpPtr = NULL;
34static int PL_OpSpace = 0;
35#define NewOp(m,var,c,type) do { if ((PL_OpSpace -= c*sizeof(type)) >= 0) \
36 var = (type *)(PL_OpPtr -= c*sizeof(type)); \
37 else \
38 var = (type *) Slab_Alloc(m,c*sizeof(type)); \
39 } while (0)
40
864dbfa3 41STATIC void *
cea2e8a9 42S_Slab_Alloc(pTHX_ int m, size_t sz)
b7dc083c
NIS		 43{
44 Newz(m,PL_OpPtr,SLAB_SIZE,char);
45 PL_OpSpace = SLAB_SIZE - sz;
46 return PL_OpPtr += PL_OpSpace;
47}
76e3520e 48
b7dc083c
NIS		 49#else
50#define NewOp(m, var, c, type) Newz(m, var, c, type)
51#endif
e50aee73 52/*
5dc0d613 53 * In the following definition, the ", Nullop" is just to make the compiler
a5f75d66 54 * think the expression is of the right type: croak actually does a Siglongjmp.
e50aee73 55 */
11343788 56#define CHECKOP(type,o) \
3280af22 57 ((PL_op_mask && PL_op_mask[type]) \
5dc0d613 58 ? ( op_free((OP*)o), \
cea2e8a9 59 Perl_croak(aTHX_ "%s trapped by operation mask", PL_op_desc[type]), \
28757baa 60 Nullop ) \
fc0dc3b3 61 : CALL_FPTR(PL_check[type])(aTHX_ (OP*)o))
e50aee73 62
c53d7c7d
HS		 63#define PAD_MAX 999999999
64
76e3520e 65STATIC char*
cea2e8a9 66S_gv_ename(pTHX_ GV *gv)
4633a7c4 67{
2d8e6c8d 68 STRLEN n_a;
4633a7c4 69 SV* tmpsv = sv_newmortal();
46fc3d4c 70 gv_efullname3(tmpsv, gv, Nullch);
2d8e6c8d 71 return SvPV(tmpsv,n_a);
4633a7c4
LW		 72}
73
76e3520e 74STATIC OP *
cea2e8a9 75S_no_fh_allowed(pTHX_ OP *o)
79072805 76{
cea2e8a9 77 yyerror(Perl_form(aTHX_ "Missing comma after first argument to %s function",
22c35a8c 78 PL_op_desc[o->op_type]));
11343788 79 return o;
79072805
LW		 80}
81
76e3520e 82STATIC OP *
cea2e8a9 83S_too_few_arguments(pTHX_ OP *o, char *name)
79072805 84{
cea2e8a9 85 yyerror(Perl_form(aTHX_ "Not enough arguments for %s", name));
11343788 86 return o;
79072805
LW		 87}
88
76e3520e 89STATIC OP *
cea2e8a9 90S_too_many_arguments(pTHX_ OP *o, char *name)
79072805 91{
cea2e8a9 92 yyerror(Perl_form(aTHX_ "Too many arguments for %s", name));
11343788 93 return o;
79072805
LW		 94}
95
76e3520e 96STATIC void
cea2e8a9 97S_bad_type(pTHX_ I32 n, char *t, char *name, OP *kid)
8990e307 98{
cea2e8a9 99 yyerror(Perl_form(aTHX_ "Type of arg %d to %s must be %s (not %s)",
22c35a8c 100 (int)n, name, t, PL_op_desc[kid->op_type]));
8990e307
LW		 101}
102
7a52d87a 103STATIC void
cea2e8a9 104S_no_bareword_allowed(pTHX_ OP *o)
7a52d87a 105{
5a844595
GS		 106 qerror(Perl_mess(aTHX_
107 "Bareword \"%s\" not allowed while \"strict subs\" in use",
108 SvPV_nolen(cSVOPo->op_sv)));
7a52d87a
GS		 109}
110
79072805
LW		 111/* "register" allocation */
112
113PADOFFSET
864dbfa3 114Perl_pad_allocmy(pTHX_ char *name)
93a17b20 115{
11343788 116 dTHR;
a0d0e21e
LW		 117 PADOFFSET off;
118 SV *sv;
119
834a4ddd 120 if (!(
77ca0c92 121 PL_in_my == KEY_our ||
834a4ddd
LW		 122 isALPHA(name[1]) ||
123 (PL_hints & HINT_UTF8 && (name[1] & 0xc0) == 0xc0) ||
77ca0c92 124 name[1] == '_' && (int)strlen(name) > 2 ))
834a4ddd 125 {
c4d0567e 126 if (!isPRINT(name[1]) || strchr("\t\n\r\f", name[1])) {
2b92dfce
GS		 127 /* 1999-02-27 mjd@plover.com */
128 char *p;
129 p = strchr(name, '\0');
130 /* The next block assumes the buffer is at least 205 chars
131 long. At present, it's always at least 256 chars. */
132 if (p-name > 200) {
133 strcpy(name+200, "...");
134 p = name+199;
135 }
136 else {
137 p[1] = '\0';
138 }
139 /* Move everything else down one character */
140 for (; p-name > 2; p--)
141 *p = *(p-1);
46fc3d4c 142 name[2] = toCTRL(name[1]);
143 name[1] = '^';
144 }
cea2e8a9 145 yyerror(Perl_form(aTHX_ "Can't use global %s in \"my\"",name));
a0d0e21e 146 }
599cee73 147 if (ckWARN(WARN_UNSAFE) && AvFILLp(PL_comppad_name) >= 0) {
3280af22
NIS		 148 SV **svp = AvARRAY(PL_comppad_name);
149 for (off = AvFILLp(PL_comppad_name); off > PL_comppad_name_floor; off--) {
b1cb66bf 150 if ((sv = svp[off])
3280af22 151 && sv != &PL_sv_undef
c53d7c7d 152 && (SvIVX(sv) == PAD_MAX || SvIVX(sv) == 0)
b1cb66bf 153 && strEQ(name, SvPVX(sv)))
154 {
cea2e8a9 155 Perl_warner(aTHX_ WARN_UNSAFE,
77ca0c92
LW		 156 "\"%s\" variable %s masks earlier declaration in same %s",
157 (PL_in_my == KEY_our ? "our" : "my"),
158 name,
159 (SvIVX(sv) == PAD_MAX ? "scope" : "statement"));
b1cb66bf 160 break;
161 }
162 }
163 }
a0d0e21e
LW		 164 off = pad_alloc(OP_PADSV, SVs_PADMY);
165 sv = NEWSV(1102,0);
93a17b20
LW		 166 sv_upgrade(sv, SVt_PVNV);
167 sv_setpv(sv, name);
3280af22 168 if (PL_in_my_stash) {
c750a3ec 169 if (*name != '$')
cea2e8a9 170 yyerror(Perl_form(aTHX_ "Can't declare class for non-scalar %s in \"my\"",
dce40276 171 name));
c750a3ec
MB		 172 SvOBJECT_on(sv);
173 (void)SvUPGRADE(sv, SVt_PVMG);
3280af22
NIS		 174 SvSTASH(sv) = (HV*)SvREFCNT_inc(PL_in_my_stash);
175 PL_sv_objcount++;
c750a3ec 176 }
77ca0c92
LW		 177 if (PL_in_my == KEY_our)
178 SvFLAGS(sv) |= SVpad_OUR;
3280af22 179 av_store(PL_comppad_name, off, sv);
65202027 180 SvNVX(sv) = (NV)PAD_MAX;
8990e307 181 SvIVX(sv) = 0; /* Not yet introduced--see newSTATEOP */
3280af22
NIS		 182 if (!PL_min_intro_pending)
183 PL_min_intro_pending = off;
184 PL_max_intro_pending = off;
93a17b20 185 if (*name == '@')
3280af22 186 av_store(PL_comppad, off, (SV*)newAV());
93a17b20 187 else if (*name == '%')
3280af22
NIS		 188 av_store(PL_comppad, off, (SV*)newHV());
189 SvPADMY_on(PL_curpad[off]);
93a17b20
LW		 190 return off;
191}
192
2680586e
GS		 193#define FINDLEX_NOSEARCH 1 /* don't search outer contexts */
194
76e3520e 195STATIC PADOFFSET
cea2e8a9 196S_pad_findlex(pTHX_ char *name, PADOFFSET newoff, U32 seq, CV* startcv,
864dbfa3 197 I32 cx_ix, I32 saweval, U32 flags)
93a17b20 198{
11343788 199 dTHR;
748a9306 200 CV *cv;
93a17b20
LW		 201 I32 off;
202 SV *sv;
93a17b20 203 register I32 i;
c09156bb 204 register PERL_CONTEXT *cx;
93a17b20 205
748a9306 206 for (cv = startcv; cv; cv = CvOUTSIDE(cv)) {
4fdae800 207 AV *curlist = CvPADLIST(cv);
208 SV **svp = av_fetch(curlist, 0, FALSE);
748a9306 209 AV *curname;
4fdae800 210
3280af22 211 if (!svp || *svp == &PL_sv_undef)
4633a7c4 212 continue;
748a9306
LW		 213 curname = (AV*)*svp;
214 svp = AvARRAY(curname);
93965878 215 for (off = AvFILLp(curname); off > 0; off--) {
748a9306 216 if ((sv = svp[off]) &&
3280af22 217 sv != &PL_sv_undef &&
748a9306 218 seq <= SvIVX(sv) &&
13826f2c 219 seq > I_32(SvNVX(sv)) &&
748a9306
LW		 220 strEQ(SvPVX(sv), name))
221 {
5f05dabc 222 I32 depth;
223 AV *oldpad;
224 SV *oldsv;
225
226 depth = CvDEPTH(cv);
227 if (!depth) {
9607fc9c 228 if (newoff) {
229 if (SvFAKE(sv))
230 continue;
4fdae800 231 return 0; /* don't clone from inactive stack frame */
9607fc9c 232 }
5f05dabc 233 depth = 1;
234 }
235 oldpad = (AV*)*av_fetch(curlist, depth, FALSE);
236 oldsv = *av_fetch(oldpad, off, TRUE);
748a9306 237 if (!newoff) { /* Not a mere clone operation. */
9607fc9c 238 SV *namesv = NEWSV(1103,0);
748a9306 239 newoff = pad_alloc(OP_PADSV, SVs_PADMY);
9607fc9c 240 sv_upgrade(namesv, SVt_PVNV);
241 sv_setpv(namesv, name);
3280af22 242 av_store(PL_comppad_name, newoff, namesv);
65202027 243 SvNVX(namesv) = (NV)PL_curcop->cop_seq;
c53d7c7d 244 SvIVX(namesv) = PAD_MAX; /* A ref, intro immediately */
9607fc9c 245 SvFAKE_on(namesv); /* A ref, not a real var */
77ca0c92
LW		 246 if (SvFLAGS(sv) & SVpad_OUR)/* An "our" variable */
247 SvFLAGS(namesv) |= SVpad_OUR;
87671ffc 248 if (SvOBJECT(sv)) { /* A typed var */
3d93dc8b
GS		 249 SvOBJECT_on(namesv);
250 (void)SvUPGRADE(namesv, SVt_PVMG);
87671ffc 251 SvSTASH(namesv) = (HV*)SvREFCNT_inc((SV*)SvSTASH(sv));
3d93dc8b
GS		 252 PL_sv_objcount++;
253 }
3280af22 254 if (CvANON(PL_compcv) || SvTYPE(PL_compcv) == SVt_PVFM) {
28757baa 255 /* "It's closures all the way down." */
3280af22 256 CvCLONE_on(PL_compcv);
54310121 257 if (cv == startcv) {
3280af22 258 if (CvANON(PL_compcv))
54310121 259 oldsv = Nullsv; /* no need to keep ref */
260 }
261 else {
28757baa 262 CV *bcv;
263 for (bcv = startcv;
264 bcv && bcv != cv && !CvCLONE(bcv);
6b35e009
GS		 265 bcv = CvOUTSIDE(bcv))
266 {
28757baa 267 if (CvANON(bcv))
268 CvCLONE_on(bcv);
269 else {
6b35e009
GS		 270 if (ckWARN(WARN_CLOSURE)
271 && !CvUNIQUE(bcv) && !CvUNIQUE(cv))
272 {
cea2e8a9 273 Perl_warner(aTHX_ WARN_CLOSURE,
44a8e56a 274 "Variable \"%s\" may be unavailable",
28757baa 275 name);
6b35e009 276 }
28757baa 277 break;
278 }
279 }
280 }
281 }
3280af22 282 else if (!CvUNIQUE(PL_compcv)) {
599cee73 283 if (ckWARN(WARN_CLOSURE) && !SvFAKE(sv) && !CvUNIQUE(cv))
cea2e8a9 284 Perl_warner(aTHX_ WARN_CLOSURE,
599cee73 285 "Variable \"%s\" will not stay shared", name);
5f05dabc 286 }
748a9306 287 }
3280af22 288 av_store(PL_comppad, newoff, SvREFCNT_inc(oldsv));
748a9306
LW		 289 return newoff;
290 }
93a17b20
LW		 291 }
292 }
293
2680586e
GS		 294 if (flags & FINDLEX_NOSEARCH)
295 return 0;
296
93a17b20
LW		 297 /* Nothing in current lexical context--try eval's context, if any.
298 * This is necessary to let the perldb get at lexically scoped variables.
299 * XXX This will also probably interact badly with eval tree caching.
300 */
301
748a9306 302 for (i = cx_ix; i >= 0; i--) {
93a17b20 303 cx = &cxstack[i];
6b35e009 304 switch (CxTYPE(cx)) {
93a17b20 305 default:
748a9306
LW		 306 if (i == 0 && saweval) {
307 seq = cxstack[saweval].blk_oldcop->cop_seq;
2680586e 308 return pad_findlex(name, newoff, seq, PL_main_cv, -1, saweval, 0);
748a9306 309 }
93a17b20
LW		 310 break;
311 case CXt_EVAL:
44a8e56a 312 switch (cx->blk_eval.old_op_type) {
313 case OP_ENTEREVAL:
6b35e009
GS		 314 if (CxREALEVAL(cx))
315 saweval = i;
44a8e56a 316 break;
317 case OP_REQUIRE:
318 /* require must have its own scope */
319 return 0;
320 }
93a17b20
LW		 321 break;
322 case CXt_SUB:
323 if (!saweval)
324 return 0;
325 cv = cx->blk_sub.cv;
3280af22 326 if (PL_debstash && CvSTASH(cv) == PL_debstash) { /* ignore DB'* scope */
748a9306 327 saweval = i; /* so we know where we were called from */
93a17b20 328 continue;
93a17b20 329 }
748a9306 330 seq = cxstack[saweval].blk_oldcop->cop_seq;
2680586e 331 return pad_findlex(name, newoff, seq, cv, i-1, saweval,FINDLEX_NOSEARCH);
93a17b20
LW		 332 }
333 }
334
748a9306
LW		 335 return 0;
336}
a0d0e21e 337
748a9306 338PADOFFSET
864dbfa3 339Perl_pad_findmy(pTHX_ char *name)
748a9306 340{
11343788 341 dTHR;
748a9306 342 I32 off;
54310121 343 I32 pendoff = 0;
748a9306 344 SV *sv;
3280af22
NIS		 345 SV **svp = AvARRAY(PL_comppad_name);
346 U32 seq = PL_cop_seqmax;
6b35e009 347 PERL_CONTEXT *cx;
33b8ce05 348 CV *outside;
748a9306 349
11343788
MB		 350#ifdef USE_THREADS
351 /*
352 * Special case to get lexical (and hence per-thread) @_.
353 * XXX I need to find out how to tell at parse-time whether use
354 * of @_ should refer to a lexical (from a sub) or defgv (global
355 * scope and maybe weird sub-ish things like formats). See
356 * startsub in perly.y. It's possible that @_ could be lexical
357 * (at least from subs) even in non-threaded perl.
358 */
359 if (strEQ(name, "@_"))
360 return 0; /* success. (NOT_IN_PAD indicates failure) */
361#endif /* USE_THREADS */
362
748a9306 363 /* The one we're looking for is probably just before comppad_name_fill. */
3280af22 364 for (off = AvFILLp(PL_comppad_name); off > 0; off--) {
a0d0e21e 365 if ((sv = svp[off]) &&
3280af22 366 sv != &PL_sv_undef &&
54310121 367 (!SvIVX(sv) ||
368 (seq <= SvIVX(sv) &&
369 seq > I_32(SvNVX(sv)))) &&
a0d0e21e
LW		 370 strEQ(SvPVX(sv), name))
371 {
77ca0c92 372 if (SvIVX(sv) || SvFLAGS(sv) & SVpad_OUR)
54310121 373 return (PADOFFSET)off;
374 pendoff = off; /* this pending def. will override import */
a0d0e21e
LW		 375 }
376 }
748a9306 377
33b8ce05
GS		 378 outside = CvOUTSIDE(PL_compcv);
379
380 /* Check if if we're compiling an eval'', and adjust seq to be the
381 * eval's seq number. This depends on eval'' having a non-null
382 * CvOUTSIDE() while it is being compiled. The eval'' itself is
1aff0e91
GS		 383 * identified by CvEVAL being true and CvGV being null. */
384 if (outside && CvEVAL(PL_compcv) && !CvGV(PL_compcv) && cxstack_ix >= 0) {
6b35e009
GS		 385 cx = &cxstack[cxstack_ix];
386 if (CxREALEVAL(cx))
387 seq = cx->blk_oldcop->cop_seq;
388 }
389
748a9306 390 /* See if it's in a nested scope */
2680586e 391 off = pad_findlex(name, 0, seq, outside, cxstack_ix, 0, 0);
54310121 392 if (off) {
393 /* If there is a pending local definition, this new alias must die */
394 if (pendoff)
3280af22 395 SvIVX(AvARRAY(PL_comppad_name)[off]) = seq;
11343788 396 return off; /* pad_findlex returns 0 for failure...*/
54310121 397 }
11343788 398 return NOT_IN_PAD; /* ...but we return NOT_IN_PAD for failure */
93a17b20
LW		 399}
400
401void
864dbfa3 402Perl_pad_leavemy(pTHX_ I32 fill)
93a17b20 403{
0453d815 404 dTHR;
93a17b20 405 I32 off;
3280af22 406 SV **svp = AvARRAY(PL_comppad_name);
93a17b20 407 SV *sv;
3280af22
NIS		 408 if (PL_min_intro_pending && fill < PL_min_intro_pending) {
409 for (off = PL_max_intro_pending; off >= PL_min_intro_pending; off--) {
0453d815
PM		 410 if ((sv = svp[off]) && sv != &PL_sv_undef && ckWARN_d(WARN_INTERNAL))
411 Perl_warner(aTHX_ WARN_INTERNAL, "%s never introduced", SvPVX(sv));
8990e307
LW		 412 }
413 }
414 /* "Deintroduce" my variables that are leaving with this scope. */
3280af22 415 for (off = AvFILLp(PL_comppad_name); off > fill; off--) {
c53d7c7d 416 if ((sv = svp[off]) && sv != &PL_sv_undef && SvIVX(sv) == PAD_MAX)
3280af22 417 SvIVX(sv) = PL_cop_seqmax;
93a17b20
LW		 418 }
419}
420
421PADOFFSET
864dbfa3 422Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype)
79072805 423{
11343788 424 dTHR;
79072805
LW		 425 SV *sv;
426 I32 retval;
427
3280af22 428 if (AvARRAY(PL_comppad) != PL_curpad)
cea2e8a9 429 Perl_croak(aTHX_ "panic: pad_alloc");
3280af22 430 if (PL_pad_reset_pending)
a0d0e21e 431 pad_reset();
ed6116ce 432 if (tmptype & SVs_PADMY) {
79072805 433 do {
3280af22 434 sv = *av_fetch(PL_comppad, AvFILLp(PL_comppad) + 1, TRUE);
ed6116ce 435 } while (SvPADBUSY(sv)); /* need a fresh one */
3280af22 436 retval = AvFILLp(PL_comppad);
79072805
LW		 437 }
438 else {
3280af22
NIS		 439 SV **names = AvARRAY(PL_comppad_name);
440 SSize_t names_fill = AvFILLp(PL_comppad_name);
bbce6d69 441 for (;;) {
442 /*
443 * "foreach" index vars temporarily become aliases to non-"my"
444 * values. Thus we must skip, not just pad values that are
445 * marked as current pad values, but also those with names.
446 */
3280af22
NIS		 447 if (++PL_padix <= names_fill &&
448 (sv = names[PL_padix]) && sv != &PL_sv_undef)
bbce6d69 449 continue;
3280af22 450 sv = *av_fetch(PL_comppad, PL_padix, TRUE);
743e66e6 451 if (!(SvFLAGS(sv) & (SVs_PADTMP|SVs_PADMY)) && !IS_PADGV(sv))
bbce6d69 452 break;
453 }
3280af22 454 retval = PL_padix;
79072805 455 }
8990e307 456 SvFLAGS(sv) |= tmptype;
3280af22 457 PL_curpad = AvARRAY(PL_comppad);
11343788 458#ifdef USE_THREADS
b900a521
JH		 459 DEBUG_X(PerlIO_printf(Perl_debug_log,
460 "0x%"UVxf" Pad 0x%"UVxf" alloc %ld for %s\n",
461 PTR2UV(thr), PTR2UV(PL_curpad),
22c35a8c 462 (long) retval, PL_op_name[optype]));
11343788 463#else
b900a521
JH		 464 DEBUG_X(PerlIO_printf(Perl_debug_log,
465 "Pad 0x%"UVxf" alloc %ld for %s\n",
466 PTR2UV(PL_curpad),
22c35a8c 467 (long) retval, PL_op_name[optype]));
11343788 468#endif /* USE_THREADS */
79072805
LW		 469 return (PADOFFSET)retval;
470}
471
472SV *
864dbfa3 473Perl_pad_sv(pTHX_ PADOFFSET po)
79072805 474{
11343788
MB		 475 dTHR;
476#ifdef USE_THREADS
b900a521 477 DEBUG_X(PerlIO_printf(Perl_debug_log,
f1dbda3d
JH		 478 "0x%"UVxf" Pad 0x%"UVxf" sv %"IVdf"\n",
479 PTR2UV(thr), PTR2UV(PL_curpad), (IV)po));
11343788 480#else
79072805 481 if (!po)
cea2e8a9 482 Perl_croak(aTHX_ "panic: pad_sv po");
97835f67
JH		 483 DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%"UVxf" sv %"IVdf"\n",
484 PTR2UV(PL_curpad), (IV)po));
11343788 485#endif /* USE_THREADS */
3280af22 486 return PL_curpad[po]; /* eventually we'll turn this into a macro */
79072805
LW		 487}
488
489void
864dbfa3 490Perl_pad_free(pTHX_ PADOFFSET po)
79072805 491{
11343788 492 dTHR;
3280af22 493 if (!PL_curpad)
a0d0e21e 494 return;
3280af22 495 if (AvARRAY(PL_comppad) != PL_curpad)
cea2e8a9 496 Perl_croak(aTHX_ "panic: pad_free curpad");
79072805 497 if (!po)
cea2e8a9 498 Perl_croak(aTHX_ "panic: pad_free po");
11343788 499#ifdef USE_THREADS
b900a521 500 DEBUG_X(PerlIO_printf(Perl_debug_log,
f1dbda3d
JH		 501 "0x%"UVxf" Pad 0x%"UVxf" free %"IVd"\n",
502 PTR2UV(thr), PTR2UV(PL_curpad), (IV)po));
11343788 503#else
97835f67
JH		 504 DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%"UVxf" free %"IVdf"\n",
505 PTR2UV(PL_curpad), (IV)po));
11343788 506#endif /* USE_THREADS */
3280af22
NIS		 507 if (PL_curpad[po] && PL_curpad[po] != &PL_sv_undef)
508 SvPADTMP_off(PL_curpad[po]);
509 if ((I32)po < PL_padix)
510 PL_padix = po - 1;
79072805
LW		 511}
512
513void
864dbfa3 514Perl_pad_swipe(pTHX_ PADOFFSET po)
79072805 515{
11343788 516 dTHR;
3280af22 517 if (AvARRAY(PL_comppad) != PL_curpad)
cea2e8a9 518 Perl_croak(aTHX_ "panic: pad_swipe curpad");
79072805 519 if (!po)
cea2e8a9 520 Perl_croak(aTHX_ "panic: pad_swipe po");
11343788 521#ifdef USE_THREADS
b900a521 522 DEBUG_X(PerlIO_printf(Perl_debug_log,
f1dbda3d
JH		 523 "0x%"UVxf" Pad 0x%"UVxf" swipe %"IVdf"\n",
524 PTR2UV(thr), PTR2UV(PL_curpad), (IV)po));
11343788 525#else
97835f67
JH		 526 DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%"UVxf" swipe %"IVdf"\n",
527 PTR2UV(PL_curpad), (IV)po));
11343788 528#endif /* USE_THREADS */
3280af22
NIS		 529 SvPADTMP_off(PL_curpad[po]);
530 PL_curpad[po] = NEWSV(1107,0);
531 SvPADTMP_on(PL_curpad[po]);
532 if ((I32)po < PL_padix)
533 PL_padix = po - 1;
79072805
LW		 534}
535
d9bb4600
GS		 536/* XXX pad_reset() is currently disabled because it results in serious bugs.
537 * It causes pad temp TARGs to be shared between OPs. Since TARGs are pushed
538 * on the stack by OPs that use them, there are several ways to get an alias
539 * to a shared TARG. Such an alias will change randomly and unpredictably.
540 * We avoid doing this until we can think of a Better Way.
541 * GSAR 97-10-29 */
79072805 542void
864dbfa3 543Perl_pad_reset(pTHX)
79072805 544{
d9bb4600 545#ifdef USE_BROKEN_PAD_RESET
11343788 546 dTHR;
79072805
LW		 547 register I32 po;
548
6b88bc9c 549 if (AvARRAY(PL_comppad) != PL_curpad)
cea2e8a9 550 Perl_croak(aTHX_ "panic: pad_reset curpad");
11343788 551#ifdef USE_THREADS
b900a521
JH		 552 DEBUG_X(PerlIO_printf(Perl_debug_log,
553 "0x%"UVxf" Pad 0x%"UVxf" reset\n",
554 PTR2UV(thr), PTR2UV(PL_curpad)));
11343788 555#else
b900a521
JH		 556 DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%"UVxf" reset\n",
557 PTR2UV(PL_curpad)));
11343788 558#endif /* USE_THREADS */
6b88bc9c
GS		 559 if (!PL_tainting) { /* Can't mix tainted and non-tainted temporaries. */
560 for (po = AvMAX(PL_comppad); po > PL_padix_floor; po--) {
561 if (PL_curpad[po] && !SvIMMORTAL(PL_curpad[po]))
562 SvPADTMP_off(PL_curpad[po]);
748a9306 563 }
6b88bc9c 564 PL_padix = PL_padix_floor;
79072805 565 }
d9bb4600 566#endif
3280af22 567 PL_pad_reset_pending = FALSE;
79072805
LW		 568}
569
a863c7d1 570#ifdef USE_THREADS
54b9620d 571/* find_threadsv is not reentrant */
a863c7d1 572PADOFFSET
864dbfa3 573Perl_find_threadsv(pTHX_ const char *name)
a863c7d1
MB		 574{
575 dTHR;
576 char *p;
577 PADOFFSET key;
554b3eca 578 SV **svp;
54b9620d 579 /* We currently only handle names of a single character */
533c011a 580 p = strchr(PL_threadsv_names, *name);
a863c7d1
MB		 581 if (!p)
582 return NOT_IN_PAD;
533c011a 583 key = p - PL_threadsv_names;
2d8e6c8d 584 MUTEX_LOCK(&thr->mutex);
54b9620d 585 svp = av_fetch(thr->threadsv, key, FALSE);
2d8e6c8d
GS		 586 if (svp)
587 MUTEX_UNLOCK(&thr->mutex);
588 else {
554b3eca 589 SV *sv = NEWSV(0, 0);
54b9620d 590 av_store(thr->threadsv, key, sv);
940cb80d 591 thr->threadsvp = AvARRAY(thr->threadsv);
2d8e6c8d 592 MUTEX_UNLOCK(&thr->mutex);
554b3eca
MB		 593 /*
594 * Some magic variables used to be automagically initialised
595 * in gv_fetchpv. Those which are now per-thread magicals get
596 * initialised here instead.
597 */
598 switch (*name) {
54b9620d
MB		 599 case '_':
600 break;
554b3eca
MB		 601 case ';':
602 sv_setpv(sv, "\034");
54b9620d 603 sv_magic(sv, 0, 0, name, 1);
554b3eca 604 break;
c277df42
IZ		 605 case '&':
606 case '`':
607 case '\'':
533c011a 608 PL_sawampersand = TRUE;
a3f914c5
GS		 609 /* FALL THROUGH */
610 case '1':
611 case '2':
612 case '3':
613 case '4':
614 case '5':
615 case '6':
616 case '7':
617 case '8':
618 case '9':
c277df42 619 SvREADONLY_on(sv);
d8b5173a 620 /* FALL THROUGH */
067391ea
GS		 621
622 /* XXX %! tied to Errno.pm needs to be added here.
623 * See gv_fetchpv(). */
624 /* case '!': */
625
54b9620d
MB		 626 default:
627 sv_magic(sv, 0, 0, name, 1);
554b3eca 628 }
bf49b057 629 DEBUG_S(PerlIO_printf(Perl_error_log,
54b9620d 630 "find_threadsv: new SV %p for $%s%c\n",
554b3eca
MB		 631 sv, (*name < 32) ? "^" : "",
632 (*name < 32) ? toCTRL(*name) : *name));
a863c7d1
MB		 633 }
634 return key;
635}
636#endif /* USE_THREADS */
637
79072805
LW		 638/* Destructor */
639
640void
864dbfa3 641Perl_op_free(pTHX_ OP *o)
79072805 642{
85e6fe83 643 register OP *kid, *nextkid;
acb36ea4 644 OPCODE type;
79072805 645
5dc0d613 646 if (!o || o->op_seq == (U16)-1)
79072805
LW		 647 return;
648
7934575e
GS		 649 if (o->op_private & OPpREFCOUNTED) {
650 switch (o->op_type) {
651 case OP_LEAVESUB:
652 case OP_LEAVESUBLV:
653 case OP_LEAVEEVAL:
654 case OP_LEAVE:
655 case OP_SCOPE:
656 case OP_LEAVEWRITE:
657 OP_REFCNT_LOCK;
658 if (OpREFCNT_dec(o)) {
659 OP_REFCNT_UNLOCK;
660 return;
661 }
971a9dd3 662 o->op_targ = 0; /* XXXXXX */
7934575e
GS		 663 OP_REFCNT_UNLOCK;
664 break;
665 default:
666 break;
667 }
668 }
669
11343788
MB		 670 if (o->op_flags & OPf_KIDS) {
671 for (kid = cUNOPo->op_first; kid; kid = nextkid) {
85e6fe83 672 nextkid = kid->op_sibling; /* Get before next freeing kid */
79072805 673 op_free(kid);
85e6fe83 674 }
79072805 675 }
acb36ea4
GS		 676 type = o->op_type;
677 if (type == OP_NULL)
678 type = o->op_targ;
679
680 /* COP* is not cleared by op_clear() so that we may track line
681 * numbers etc even after null() */
682 if (type == OP_NEXTSTATE || type == OP_SETSTATE || type == OP_DBSTATE)
683 cop_free((COP*)o);
684
685 op_clear(o);
686
687#ifdef PL_OP_SLAB_ALLOC
688 if ((char *) o == PL_OpPtr)
689 {
690 }
691#else
692 Safefree(o);
693#endif
694}
79072805 695
acb36ea4
GS		 696STATIC void
697S_op_clear(pTHX_ OP *o)
698{
11343788 699 switch (o->op_type) {
acb36ea4
GS		 700 case OP_NULL: /* Was holding old type, if any. */
701 case OP_ENTEREVAL: /* Was holding hints. */
702#ifdef USE_THREADS
703 case OP_THREADSV: /* Was holding index into thr->threadsv AV. */
704#endif
705 o->op_targ = 0;
a0d0e21e 706 break;
554b3eca 707#ifdef USE_THREADS
8dd3ba40
SM		 708 case OP_ENTERITER:
709 if (!(o->op_flags & OPf_SPECIAL))
710 break;
711 /* FALL THROUGH */
554b3eca 712#endif /* USE_THREADS */
a6006777 713 default:
ac4c12e7 714 if (!(o->op_flags & OPf_REF)
0b94c7bb 715 || (PL_check[o->op_type] != MEMBER_TO_FPTR(Perl_ck_ftst)))
a6006777 716 break;
717 /* FALL THROUGH */
463ee0b2 718 case OP_GVSV:
79072805 719 case OP_GV:
a6006777 720 case OP_AELEMFAST:
350de78d 721#ifdef USE_ITHREADS
971a9dd3
GS		 722 if (cPADOPo->op_padix > 0) {
723 if (PL_curpad) {
724 GV *gv = cGVOPo;
725 pad_swipe(cPADOPo->op_padix);
726 /* No GvIN_PAD_off(gv) here, because other references may still
727 * exist on the pad */
728 SvREFCNT_dec(gv);
729 }
730 cPADOPo->op_padix = 0;
731 }
350de78d 732#else
971a9dd3 733 SvREFCNT_dec(cSVOPo->op_sv);
7934575e 734 cSVOPo->op_sv = Nullsv;
350de78d 735#endif
79072805
LW		 736 break;
737 case OP_CONST:
11343788 738 SvREFCNT_dec(cSVOPo->op_sv);
acb36ea4 739 cSVOPo->op_sv = Nullsv;
79072805 740 break;
748a9306
LW		 741 case OP_GOTO:
742 case OP_NEXT:
743 case OP_LAST:
744 case OP_REDO:
11343788 745 if (o->op_flags & (OPf_SPECIAL|OPf_STACKED|OPf_KIDS))
748a9306
LW		 746 break;
747 /* FALL THROUGH */
a0d0e21e 748 case OP_TRANS:
acb36ea4 749 if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
a0ed51b3 750 SvREFCNT_dec(cSVOPo->op_sv);
acb36ea4
GS		 751 cSVOPo->op_sv = Nullsv;
752 }
753 else {
a0ed51b3 754 Safefree(cPVOPo->op_pv);
acb36ea4
GS		 755 cPVOPo->op_pv = Nullch;
756 }
a0d0e21e
LW		 757 break;
758 case OP_SUBST:
11343788 759 op_free(cPMOPo->op_pmreplroot);
971a9dd3 760 goto clear_pmop;
748a9306 761 case OP_PUSHRE:
971a9dd3
GS		 762#ifdef USE_ITHREADS
763 if ((PADOFFSET)cPMOPo->op_pmreplroot) {
764 if (PL_curpad) {
765 GV *gv = (GV*)PL_curpad[(PADOFFSET)cPMOPo->op_pmreplroot];
766 pad_swipe((PADOFFSET)cPMOPo->op_pmreplroot);
767 /* No GvIN_PAD_off(gv) here, because other references may still
768 * exist on the pad */
769 SvREFCNT_dec(gv);
770 }
771 }
772#else
773 SvREFCNT_dec((SV*)cPMOPo->op_pmreplroot);
774#endif
775 /* FALL THROUGH */
a0d0e21e 776 case OP_MATCH:
8782bef2 777 case OP_QR:
971a9dd3
GS		 778clear_pmop:
779 cPMOPo->op_pmreplroot = Nullop;
c277df42 780 ReREFCNT_dec(cPMOPo->op_pmregexp);
acb36ea4 781 cPMOPo->op_pmregexp = (REGEXP*)NULL;
a0d0e21e 782 break;
79072805
LW		 783 }
784
743e66e6 785 if (o->op_targ > 0) {
11343788 786 pad_free(o->op_targ);
743e66e6
GS		 787 o->op_targ = 0;
788 }
79072805
LW		 789}
790
76e3520e 791STATIC void
3eb57f73
HS		 792S_cop_free(pTHX_ COP* cop)
793{
794 Safefree(cop->cop_label);
57843af0
GS		 795#ifdef USE_ITHREADS
796 Safefree(CopFILE(cop)); /* XXXXX share in a pvtable? */
11faa288 797 Safefree(CopSTASHPV(cop)); /* XXXXX share in a pvtable? */
57843af0 798#else
11faa288 799 /* NOTE: COP.cop_stash is not refcounted */
cc49e20b 800 SvREFCNT_dec(CopFILEGV(cop));
57843af0 801#endif
0453d815 802 if (! specialWARN(cop->cop_warnings))
3eb57f73
HS		 803 SvREFCNT_dec(cop->cop_warnings);
804}
805
806STATIC void
cea2e8a9 807S_null(pTHX_ OP *o)
8990e307 808{
acb36ea4
GS		 809 if (o->op_type == OP_NULL)
810 return;
811 op_clear(o);
11343788
MB		 812 o->op_targ = o->op_type;
813 o->op_type = OP_NULL;
22c35a8c 814 o->op_ppaddr = PL_ppaddr[OP_NULL];
8990e307
LW		 815}
816
79072805
LW		 817/* Contextualizers */
818
463ee0b2 819#define LINKLIST(o) ((o)->op_next ? (o)->op_next : linklist((OP*)o))
79072805
LW		 820
821OP *
864dbfa3 822Perl_linklist(pTHX_ OP *o)
79072805
LW		 823{
824 register OP *kid;
825
11343788
MB		 826 if (o->op_next)
827 return o->op_next;
79072805
LW		 828
829 /* establish postfix order */
11343788
MB		 830 if (cUNOPo->op_first) {
831 o->op_next = LINKLIST(cUNOPo->op_first);
832 for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling) {
79072805
LW		 833 if (kid->op_sibling)
834 kid->op_next = LINKLIST(kid->op_sibling);
835 else
11343788 836 kid->op_next = o;
79072805
LW		 837 }
838 }
839 else
11343788 840 o->op_next = o;
79072805 841
11343788 842 return o->op_next;
79072805
LW		 843}
844
845OP *
864dbfa3 846Perl_scalarkids(pTHX_ OP *o)
79072805
LW		 847{
848 OP *kid;
11343788
MB		 849 if (o && o->op_flags & OPf_KIDS) {
850 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
79072805
LW		 851 scalar(kid);
852 }
11343788 853 return o;
79072805
LW		 854}
855
76e3520e 856STATIC OP *
cea2e8a9 857S_scalarboolean(pTHX_ OP *o)
8990e307 858{
d008e5eb 859 if (o->op_type == OP_SASSIGN && cBINOPo->op_first->op_type == OP_CONST) {
0f15f207 860 dTHR;
d008e5eb 861 if (ckWARN(WARN_SYNTAX)) {
57843af0 862 line_t oldline = CopLINE(PL_curcop);
a0d0e21e 863
d008e5eb 864 if (PL_copline != NOLINE)
57843af0 865 CopLINE_set(PL_curcop, PL_copline);
cea2e8a9 866 Perl_warner(aTHX_ WARN_SYNTAX, "Found = in conditional, should be ==");
57843af0 867 CopLINE_set(PL_curcop, oldline);
d008e5eb 868 }
a0d0e21e 869 }
11343788 870 return scalar(o);
8990e307
LW		 871}
872
873OP *
864dbfa3 874Perl_scalar(pTHX_ OP *o)
79072805
LW		 875{
876 OP *kid;
877
a0d0e21e 878 /* assumes no premature commitment */
3280af22 879 if (!o || (o->op_flags & OPf_WANT) || PL_error_count
5dc0d613 880 || o->op_type == OP_RETURN)
7e363e51 881 {
11343788 882 return o;
7e363e51 883 }
79072805 884
5dc0d613 885 o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_SCALAR;
79072805 886
11343788 887 switch (o->op_type) {
79072805 888 case OP_REPEAT:
11343788
MB		 889 if (o->op_private & OPpREPEAT_DOLIST)
890 null(((LISTOP*)cBINOPo->op_first)->op_first);
891 scalar(cBINOPo->op_first);
8990e307 892 break;
79072805
LW		 893 case OP_OR:
894 case OP_AND:
895 case OP_COND_EXPR:
11343788 896 for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
8990e307 897 scalar(kid);
79072805 898 break;
a0d0e21e 899 case OP_SPLIT:
11343788 900 if ((kid = cLISTOPo->op_first) && kid->op_type == OP_PUSHRE) {
a0d0e21e
LW		 901 if (!kPMOP->op_pmreplroot)
902 deprecate("implicit split to @_");
903 }
904 /* FALL THROUGH */
79072805 905 case OP_MATCH:
8782bef2 906 case OP_QR:
79072805
LW		 907 case OP_SUBST:
908 case OP_NULL:
8990e307 909 default:
11343788
MB		 910 if (o->op_flags & OPf_KIDS) {
911 for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling)
8990e307
LW		 912 scalar(kid);
913 }
79072805
LW		 914 break;
915 case OP_LEAVE:
916 case OP_LEAVETRY:
5dc0d613 917 kid = cLISTOPo->op_first;
54310121 918 scalar(kid);
919 while (kid = kid->op_sibling) {
920 if (kid->op_sibling)
921 scalarvoid(kid);
922 else
923 scalar(kid);
924 }
3280af22 925 WITH_THR(PL_curcop = &PL_compiling);
54310121 926 break;
748a9306 927 case OP_SCOPE:
79072805 928 case OP_LINESEQ:
8990e307 929 case OP_LIST:
11343788 930 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling) {
79072805
LW		 931 if (kid->op_sibling)
932 scalarvoid(kid);
933 else
934 scalar(kid);
935 }
3280af22 936 WITH_THR(PL_curcop = &PL_compiling);
79072805
LW		 937 break;
938 }
11343788 939 return o;
79072805
LW		 940}
941
942OP *
864dbfa3 943Perl_scalarvoid(pTHX_ OP *o)
79072805
LW		 944{
945 OP *kid;
8990e307
LW		 946 char* useless = 0;
947 SV* sv;
2ebea0a1
GS		 948 U8 want;
949
acb36ea4
GS		 950 if (o->op_type == OP_NEXTSTATE
951 || o->op_type == OP_SETSTATE
952 || o->op_type == OP_DBSTATE
953 || (o->op_type == OP_NULL && (o->op_targ == OP_NEXTSTATE
954 || o->op_targ == OP_SETSTATE
955 || o->op_targ == OP_DBSTATE)))
2ebea0a1
GS		 956 {
957 dTHR;
958 PL_curcop = (COP*)o; /* for warning below */
959 }
79072805 960
54310121 961 /* assumes no premature commitment */
2ebea0a1
GS		 962 want = o->op_flags & OPf_WANT;
963 if ((want && want != OPf_WANT_SCALAR) || PL_error_count
5dc0d613 964 || o->op_type == OP_RETURN)
7e363e51 965 {
11343788 966 return o;
7e363e51 967 }
79072805 968
b162f9ea 969 if ((o->op_private & OPpTARGET_MY)
7e363e51
GS		 970 && (PL_opargs[o->op_type] & OA_TARGLEX))/* OPp share the meaning */
971 {
b162f9ea 972 return scalar(o); /* As if inside SASSIGN */
7e363e51 973 }
b162f9ea 974
5dc0d613 975 o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_VOID;
79072805 976
11343788 977 switch (o->op_type) {
79072805 978 default:
22c35a8c 979 if (!(PL_opargs[o->op_type] & OA_FOLDCONST))
8990e307 980 break;
36477c24 981 /* FALL THROUGH */
982 case OP_REPEAT:
11343788 983 if (o->op_flags & OPf_STACKED)
8990e307 984 break;
5d82c453
GA		 985 goto func_ops;
986 case OP_SUBSTR:
987 if (o->op_private == 4)
988 break;
8990e307
LW		 989 /* FALL THROUGH */
990 case OP_GVSV:
991 case OP_WANTARRAY:
992 case OP_GV:
993 case OP_PADSV:
994 case OP_PADAV:
995 case OP_PADHV:
996 case OP_PADANY:
997 case OP_AV2ARYLEN:
8990e307 998 case OP_REF:
a0d0e21e
LW		 999 case OP_REFGEN:
1000 case OP_SREFGEN:
8990e307
LW		 1001 case OP_DEFINED:
1002 case OP_HEX:
1003 case OP_OCT:
1004 case OP_LENGTH:
8990e307
LW		 1005 case OP_VEC:
1006 case OP_INDEX:
1007 case OP_RINDEX:
1008 case OP_SPRINTF:
1009 case OP_AELEM:
1010 case OP_AELEMFAST:
1011 case OP_ASLICE:
8990e307
LW		 1012 case OP_HELEM:
1013 case OP_HSLICE:
1014 case OP_UNPACK:
1015 case OP_PACK:
8990e307
LW		 1016 case OP_JOIN:
1017 case OP_LSLICE:
1018 case OP_ANONLIST:
1019 case OP_ANONHASH:
1020 case OP_SORT:
1021 case OP_REVERSE:
1022 case OP_RANGE:
1023 case OP_FLIP:
1024 case OP_FLOP:
1025 case OP_CALLER:
1026 case OP_FILENO:
1027 case OP_EOF:
1028 case OP_TELL:
1029 case OP_GETSOCKNAME:
1030 case OP_GETPEERNAME:
1031 case OP_READLINK:
1032 case OP_TELLDIR:
1033 case OP_GETPPID:
1034 case OP_GETPGRP:
1035 case OP_GETPRIORITY:
1036 case OP_TIME:
1037 case OP_TMS:
1038 case OP_LOCALTIME:
1039 case OP_GMTIME:
1040 case OP_GHBYNAME:
1041 case OP_GHBYADDR:
1042 case OP_GHOSTENT:
1043 case OP_GNBYNAME:
1044 case OP_GNBYADDR:
1045 case OP_GNETENT:
1046 case OP_GPBYNAME:
1047 case OP_GPBYNUMBER:
1048 case OP_GPROTOENT:
1049 case OP_GSBYNAME:
1050 case OP_GSBYPORT:
1051 case OP_GSERVENT:
1052 case OP_GPWNAM:
1053 case OP_GPWUID:
1054 case OP_GGRNAM:
1055 case OP_GGRGID:
1056 case OP_GETLOGIN:
5d82c453 1057 func_ops:
11343788 1058 if (!(o->op_private & OPpLVAL_INTRO))
22c35a8c 1059 useless = PL_op_desc[o->op_type];
8990e307
LW		 1060 break;
1061
1062 case OP_RV2GV:
1063 case OP_RV2SV:
1064 case OP_RV2AV:
1065 case OP_RV2HV:
11343788
MB		 1066 if (!(o->op_private & OPpLVAL_INTRO) &&
1067 (!o->op_sibling || o->op_sibling->op_type != OP_READLINE))
8990e307
LW		 1068 useless = "a variable";
1069 break;
79072805
LW		 1070
1071 case OP_CONST:
11343788 1072 sv = cSVOPo->op_sv;
7a52d87a
GS		 1073 if (cSVOPo->op_private & OPpCONST_STRICT)
1074 no_bareword_allowed(o);
1075 else {
d008e5eb
GS		 1076 dTHR;
1077 if (ckWARN(WARN_VOID)) {
1078 useless = "a constant";
1079 if (SvNIOK(sv) && (SvNV(sv) == 0.0 || SvNV(sv) == 1.0))
1080 useless = 0;
1081 else if (SvPOK(sv)) {
1082 if (strnEQ(SvPVX(sv), "di", 2) ||
1083 strnEQ(SvPVX(sv), "ds", 2) ||
1084 strnEQ(SvPVX(sv), "ig", 2))
1085 useless = 0;
1086 }
8990e307
LW		 1087 }
1088 }
acb36ea4 1089 null(o); /* don't execute or even remember it */
79072805
LW		 1090 break;
1091
1092 case OP_POSTINC:
11343788 1093 o->op_type = OP_PREINC; /* pre-increment is faster */
22c35a8c 1094 o->op_ppaddr = PL_ppaddr[OP_PREINC];
79072805
LW		 1095 break;
1096
1097 case OP_POSTDEC:
11343788 1098 o->op_type = OP_PREDEC; /* pre-decrement is faster */
22c35a8c 1099 o->op_ppaddr = PL_ppaddr[OP_PREDEC];
79072805
LW		 1100 break;
1101
79072805
LW		 1102 case OP_OR:
1103 case OP_AND:
1104 case OP_COND_EXPR:
11343788 1105 for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
79072805
LW		 1106 scalarvoid(kid);
1107 break;
5aabfad6 1108
a0d0e21e 1109 case OP_NULL:
11343788 1110 if (o->op_flags & OPf_STACKED)
a0d0e21e 1111 break;
5aabfad6 1112 /* FALL THROUGH */
2ebea0a1
GS		 1113 case OP_NEXTSTATE:
1114 case OP_DBSTATE:
79072805
LW		 1115 case OP_ENTERTRY:
1116 case OP_ENTER:
1117 case OP_SCALAR:
11343788 1118 if (!(o->op_flags & OPf_KIDS))
79072805 1119 break;
54310121 1120 /* FALL THROUGH */
463ee0b2 1121 case OP_SCOPE:
79072805
LW		 1122 case OP_LEAVE:
1123 case OP_LEAVETRY:
a0d0e21e 1124 case OP_LEAVELOOP:
79072805 1125 case OP_LINESEQ:
79072805 1126 case OP_LIST:
11343788 1127 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
79072805
LW		 1128 scalarvoid(kid);
1129 break;
c90c0ff4 1130 case OP_ENTEREVAL:
5196be3e 1131 scalarkids(o);
c90c0ff4 1132 break;
5aabfad6 1133 case OP_REQUIRE:
c90c0ff4 1134 /* all requires must return a boolean value */
5196be3e
MB		 1135 o->op_flags &= ~OPf_WANT;
1136 return scalar(o);
a0d0e21e 1137 case OP_SPLIT:
11343788 1138 if ((kid = cLISTOPo->op_first) && kid->op_type == OP_PUSHRE) {
a0d0e21e
LW		 1139 if (!kPMOP->op_pmreplroot)
1140 deprecate("implicit split to @_");
1141 }
1142 break;
79072805 1143 }
d008e5eb
GS		 1144 if (useless) {
1145 dTHR;
1146 if (ckWARN(WARN_VOID))
cea2e8a9 1147 Perl_warner(aTHX_ WARN_VOID, "Useless use of %s in void context", useless);
d008e5eb 1148 }
11343788 1149 return o;
79072805
LW		 1150}
1151
1152OP *
864dbfa3 1153Perl_listkids(pTHX_ OP *o)
79072805
LW		 1154{
1155 OP *kid;
11343788
MB		 1156 if (o && o->op_flags & OPf_KIDS) {
1157 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
79072805
LW		 1158 list(kid);
1159 }
11343788 1160 return o;
79072805
LW		 1161}
1162
1163OP *
864dbfa3 1164Perl_list(pTHX_ OP *o)
79072805
LW		 1165{
1166 OP *kid;
1167
a0d0e21e 1168 /* assumes no premature commitment */
3280af22 1169 if (!o || (o->op_flags & OPf_WANT) || PL_error_count
5dc0d613 1170 || o->op_type == OP_RETURN)
7e363e51 1171 {
11343788 1172 return o;
7e363e51 1173 }
79072805 1174
b162f9ea 1175 if ((o->op_private & OPpTARGET_MY)
7e363e51
GS		 1176 && (PL_opargs[o->op_type] & OA_TARGLEX))/* OPp share the meaning */
1177 {
b162f9ea 1178 return o; /* As if inside SASSIGN */
7e363e51 1179 }
b162f9ea 1180
5dc0d613 1181 o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_LIST;
79072805 1182
11343788 1183 switch (o->op_type) {
79072805
LW		 1184 case OP_FLOP:
1185 case OP_REPEAT:
11343788 1186 list(cBINOPo->op_first);
79072805
LW		 1187 break;
1188 case OP_OR:
1189 case OP_AND:
1190 case OP_COND_EXPR:
11343788 1191 for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
79072805
LW		 1192 list(kid);
1193 break;
1194 default:
1195 case OP_MATCH:
8782bef2 1196 case OP_QR:
79072805
LW		 1197 case OP_SUBST:
1198 case OP_NULL:
11343788 1199 if (!(o->op_flags & OPf_KIDS))
79072805 1200 break;
11343788
MB		 1201 if (!o->op_next && cUNOPo->op_first->op_type == OP_FLOP) {
1202 list(cBINOPo->op_first);
1203 return gen_constant_list(o);
79072805
LW		 1204 }
1205 case OP_LIST:
11343788 1206 listkids(o);
79072805
LW		 1207 break;
1208 case OP_LEAVE:
1209 case OP_LEAVETRY:
5dc0d613 1210 kid = cLISTOPo->op_first;
54310121 1211 list(kid);
1212 while (kid = kid->op_sibling) {
1213 if (kid->op_sibling)
1214 scalarvoid(kid);
1215 else
1216 list(kid);
1217 }
3280af22 1218 WITH_THR(PL_curcop = &PL_compiling);
54310121 1219 break;
748a9306 1220 case OP_SCOPE:
79072805 1221 case OP_LINESEQ:
11343788 1222 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling) {
79072805
LW		 1223 if (kid->op_sibling)
1224 scalarvoid(kid);
1225 else
1226 list(kid);
1227 }
3280af22 1228 WITH_THR(PL_curcop = &PL_compiling);
79072805 1229 break;
c90c0ff4 1230 case OP_REQUIRE:
1231 /* all requires must return a boolean value */
5196be3e
MB		 1232 o->op_flags &= ~OPf_WANT;
1233 return scalar(o);
79072805 1234 }
11343788 1235 return o;
79072805
LW		 1236}
1237
1238OP *
864dbfa3 1239Perl_scalarseq(pTHX_ OP *o)
79072805
LW		 1240{
1241 OP *kid;
1242
11343788
MB		 1243 if (o) {
1244 if (o->op_type == OP_LINESEQ ||
1245 o->op_type == OP_SCOPE ||
1246 o->op_type == OP_LEAVE ||
1247 o->op_type == OP_LEAVETRY)
463ee0b2 1248 {
0f15f207 1249 dTHR;
11343788 1250 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling) {
ed6116ce 1251 if (kid->op_sibling) {
463ee0b2 1252 scalarvoid(kid);
ed6116ce 1253 }
463ee0b2 1254 }
3280af22 1255 PL_curcop = &PL_compiling;
79072805 1256 }
11343788 1257 o->op_flags &= ~OPf_PARENS;
3280af22 1258 if (PL_hints & HINT_BLOCK_SCOPE)
11343788 1259 o->op_flags |= OPf_PARENS;
79072805 1260 }
8990e307 1261 else
11343788
MB		 1262 o = newOP(OP_STUB, 0);
1263 return o;
79072805
LW		 1264}
1265
76e3520e 1266STATIC OP *
cea2e8a9 1267S_modkids(pTHX_ OP *o, I32 type)
79072805
LW		 1268{
1269 OP *kid;
11343788
MB		 1270 if (o && o->op_flags & OPf_KIDS) {
1271 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
463ee0b2 1272 mod(kid, type);
79072805 1273 }
11343788 1274 return o;
79072805
LW		 1275}
1276
79072805 1277OP *
864dbfa3 1278Perl_mod(pTHX_ OP *o, I32 type)
79072805 1279{
11343788 1280 dTHR;
79072805
LW		 1281 OP *kid;
1282 SV *sv;
2d8e6c8d 1283 STRLEN n_a;
79072805 1284
3280af22 1285 if (!o || PL_error_count)
11343788 1286 return o;
79072805 1287
b162f9ea 1288 if ((o->op_private & OPpTARGET_MY)
7e363e51
GS		 1289 && (PL_opargs[o->op_type] & OA_TARGLEX))/* OPp share the meaning */
1290 {
b162f9ea 1291 return o;
7e363e51 1292 }
b162f9ea 1293
11343788 1294 switch (o->op_type) {
68dc0745 1295 case OP_UNDEF:
3280af22 1296 PL_modcount++;
5dc0d613 1297 return o;
a0d0e21e 1298 case OP_CONST:
11343788 1299 if (!(o->op_private & (OPpCONST_ARYBASE)))
a0d0e21e 1300 goto nomod;
3280af22
NIS		 1301 if (PL_eval_start && PL_eval_start->op_type == OP_CONST) {
1302 PL_compiling.cop_arybase = (I32)SvIV(((SVOP*)PL_eval_start)->op_sv);
1303 PL_eval_start = 0;
a0d0e21e
LW		 1304 }
1305 else if (!type) {
3280af22
NIS		 1306 SAVEI32(PL_compiling.cop_arybase);
1307 PL_compiling.cop_arybase = 0;
a0d0e21e
LW		 1308 }
1309 else if (type == OP_REFGEN)
1310 goto nomod;
1311 else
cea2e8a9 1312 Perl_croak(aTHX_ "That use of $[ is unsupported");
a0d0e21e 1313 break;
5f05dabc 1314 case OP_STUB:
5196be3e 1315 if (o->op_flags & OPf_PARENS)
5f05dabc 1316 break;
1317 goto nomod;
a0d0e21e
LW		 1318 case OP_ENTERSUB:
1319 if ((type == OP_UNDEF || type == OP_REFGEN) &&
11343788
MB		 1320 !(o->op_flags & OPf_STACKED)) {
1321 o->op_type = OP_RV2CV; /* entersub => rv2cv */
22c35a8c 1322 o->op_ppaddr = PL_ppaddr[OP_RV2CV];
11343788
MB		 1323 assert(cUNOPo->op_first->op_type == OP_NULL);
1324 null(((LISTOP*)cUNOPo->op_first)->op_first);/* disable pushmark */
79072805
LW		 1325 break;
1326 }
cd06dffe
GS		 1327 else { /* lvalue subroutine call */
1328 o->op_private |= OPpLVAL_INTRO;
4978d6d9 1329 if (type == OP_GREPSTART || type == OP_ENTERSUB || type == OP_REFGEN) {
cd06dffe
GS		 1330 /* Backward compatibility mode: */
1331 o->op_private |= OPpENTERSUB_INARGS;
1332 break;
1333 }
1334 else { /* Compile-time error message: */
1335 OP *kid = cUNOPo->op_first;
1336 CV *cv;
1337 OP *okid;
1338
1339 if (kid->op_type == OP_PUSHMARK)
1340 goto skip_kids;
1341 if (kid->op_type != OP_NULL || kid->op_targ != OP_LIST)
1342 Perl_croak(aTHX_
1343 "panic: unexpected lvalue entersub "
1344 "args: type/targ %ld:%ld",
1345 (long)kid->op_type,kid->op_targ);
1346 kid = kLISTOP->op_first;
1347 skip_kids:
1348 while (kid->op_sibling)
1349 kid = kid->op_sibling;
1350 if (!(kid->op_type == OP_NULL && kid->op_targ == OP_RV2CV)) {
1351 /* Indirect call */
1352 if (kid->op_type == OP_METHOD_NAMED
1353 || kid->op_type == OP_METHOD)
1354 {
349fd7b7 1355 OP *newop;
cd06dffe
GS		 1356
1357 if (kid->op_sibling || kid->op_next != kid) {
1358 yyerror("panic: unexpected optree near method call");
1359 break;
1360 }
1361
349fd7b7
GS		 1362 NewOp(1101, newop, 1, OP);
1363 newop->op_type = OP_RV2CV;
1364 newop->op_ppaddr = PL_ppaddr[OP_RV2CV];
1365 newop->op_next = newop;
1366 kid->op_sibling = newop;
1367 newop->op_private |= OPpLVAL_INTRO;
cd06dffe
GS		 1368 break;
1369 }
1370
1371 if (kid->op_type != OP_RV2CV)
1372 Perl_croak(aTHX_
1373 "panic: unexpected lvalue entersub "
1374 "entry via type/targ %ld:%ld",
1375 (long)kid->op_type,kid->op_targ);
1376 kid->op_private |= OPpLVAL_INTRO;
1377 break; /* Postpone until runtime */
1378 }
1379
1380 okid = kid;
1381 kid = kUNOP->op_first;
1382 if (kid->op_type == OP_NULL && kid->op_targ == OP_RV2SV)
1383 kid = kUNOP->op_first;
1384 if (kid->op_type == OP_NULL)
1385 Perl_croak(aTHX_
1386 "Unexpected constant lvalue entersub "
1387 "entry via type/targ %ld:%ld",
1388 (long)kid->op_type,kid->op_targ);
1389 if (kid->op_type != OP_GV) {
1390 /* Restore RV2CV to check lvalueness */
1391 restore_2cv:
1392 if (kid->op_next && kid->op_next != kid) { /* Happens? */
1393 okid->op_next = kid->op_next;
1394 kid->op_next = okid;
1395 }
1396 else
1397 okid->op_next = Nullop;
1398 okid->op_type = OP_RV2CV;
1399 okid->op_targ = 0;
1400 okid->op_ppaddr = PL_ppaddr[OP_RV2CV];
1401 okid->op_private |= OPpLVAL_INTRO;
1402 break;
1403 }
1404
350de78d 1405 cv = GvCV(kGVOP);
cd06dffe
GS		 1406 if (!cv)
1407 goto restore_2cv;
1408 if (CvLVALUE(cv))
1409 break;
1410 }
1411 }
79072805
LW		 1412 /* FALL THROUGH */
1413 default:
a0d0e21e
LW		 1414 nomod:
1415 /* grep, foreach, subcalls, refgen */
1416 if (type == OP_GREPSTART || type == OP_ENTERSUB || type == OP_REFGEN)
1417 break;
cea2e8a9 1418 yyerror(Perl_form(aTHX_ "Can't modify %s in %s",
638bc118 1419 (o->op_type == OP_NULL && (o->op_flags & OPf_SPECIAL)
cd06dffe
GS		 1420 ? "do block"
1421 : (o->op_type == OP_ENTERSUB
1422 ? "non-lvalue subroutine call"
1423 : PL_op_desc[o->op_type])),
22c35a8c 1424 type ? PL_op_desc[type] : "local"));
11343788 1425 return o;
79072805 1426
a0d0e21e
LW		 1427 case OP_PREINC:
1428 case OP_PREDEC:
1429 case OP_POW:
1430 case OP_MULTIPLY:
1431 case OP_DIVIDE:
1432 case OP_MODULO:
1433 case OP_REPEAT:
1434 case OP_ADD:
1435 case OP_SUBTRACT:
1436 case OP_CONCAT:
1437 case OP_LEFT_SHIFT:
1438 case OP_RIGHT_SHIFT:
1439 case OP_BIT_AND:
1440 case OP_BIT_XOR:
1441 case OP_BIT_OR:
1442 case OP_I_MULTIPLY:
1443 case OP_I_DIVIDE:
1444 case OP_I_MODULO:
1445 case OP_I_ADD:
1446 case OP_I_SUBTRACT:
11343788 1447 if (!(o->op_flags & OPf_STACKED))
a0d0e21e 1448 goto nomod;
3280af22 1449 PL_modcount++;
a0d0e21e
LW		 1450 break;
1451
79072805 1452 case OP_COND_EXPR:
11343788 1453 for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
463ee0b2 1454 mod(kid, type);
79072805
LW		 1455 break;
1456
1457 case OP_RV2AV:
1458 case OP_RV2HV:
93af7a87 1459 if (!type && cUNOPo->op_first->op_type != OP_GV)
cea2e8a9 1460 Perl_croak(aTHX_ "Can't localize through a reference");
11343788 1461 if (type == OP_REFGEN && o->op_flags & OPf_PARENS) {
3280af22 1462 PL_modcount = 10000;
11343788 1463 return o; /* Treat \(@foo) like ordinary list. */
748a9306
LW		 1464 }
1465 /* FALL THROUGH */
79072805 1466 case OP_RV2GV:
5dc0d613 1467 if (scalar_mod_type(o, type))
3fe9a6f1 1468 goto nomod;
11343788 1469 ref(cUNOPo->op_first, o->op_type);
79072805
LW		 1470 /* FALL THROUGH */
1471 case OP_AASSIGN:
1472 case OP_ASLICE:
1473 case OP_HSLICE:
93a17b20
LW		 1474 case OP_NEXTSTATE:
1475 case OP_DBSTATE:
a0d0e21e
LW		 1476 case OP_REFGEN:
1477 case OP_CHOMP:
3280af22 1478 PL_modcount = 10000;
79072805 1479 break;
463ee0b2 1480 case OP_RV2SV:
11343788 1481 if (!type && cUNOPo->op_first->op_type != OP_GV)
cea2e8a9 1482 Perl_croak(aTHX_ "Can't localize through a reference");
aeea060c 1483 ref(cUNOPo->op_first, o->op_type);
463ee0b2 1484 /* FALL THROUGH */
79072805 1485 case OP_GV:
463ee0b2 1486 case OP_AV2ARYLEN:
3280af22 1487 PL_hints |= HINT_BLOCK_SCOPE;
463ee0b2 1488 case OP_SASSIGN:
bf4b1e52
GS		 1489 case OP_ANDASSIGN:
1490 case OP_ORASSIGN:
8990e307 1491 case OP_AELEMFAST:
3280af22 1492 PL_modcount++;
8990e307
LW		 1493 break;
1494
748a9306
LW		 1495 case OP_PADAV:
1496 case OP_PADHV:
3280af22 1497 PL_modcount = 10000;
5196be3e
MB		 1498 if (type == OP_REFGEN && o->op_flags & OPf_PARENS)
1499 return o; /* Treat \(@foo) like ordinary list. */
1500 if (scalar_mod_type(o, type))
3fe9a6f1 1501 goto nomod;
748a9306
LW		 1502 /* FALL THROUGH */
1503 case OP_PADSV:
3280af22 1504 PL_modcount++;
748a9306 1505 if (!type)
cea2e8a9 1506 Perl_croak(aTHX_ "Can't localize lexical variable %s",
2d8e6c8d 1507 SvPV(*av_fetch(PL_comppad_name, o->op_targ, 4), n_a));
463ee0b2
LW		 1508 break;
1509
554b3eca 1510#ifdef USE_THREADS
2faa37cc 1511 case OP_THREADSV:
533c011a 1512 PL_modcount++; /* XXX ??? */
554b3eca
MB		 1513 break;
1514#endif /* USE_THREADS */
1515
748a9306
LW		 1516 case OP_PUSHMARK:
1517 break;
a0d0e21e 1518
69969c6f
SB		 1519 case OP_KEYS:
1520 if (type != OP_SASSIGN)
1521 goto nomod;
5d82c453
GA		 1522 goto lvalue_func;
1523 case OP_SUBSTR:
1524 if (o->op_private == 4) /* don't allow 4 arg substr as lvalue */
1525 goto nomod;
5f05dabc 1526 /* FALL THROUGH */
a0d0e21e 1527 case OP_POS:
463ee0b2 1528 case OP_VEC:
5d82c453 1529 lvalue_func:
11343788
MB		 1530 pad_free(o->op_targ);
1531 o->op_targ = pad_alloc(o->op_type, SVs_PADMY);
5dc0d613 1532 assert(SvTYPE(PAD_SV(o->op_targ)) == SVt_NULL);
11343788
MB		 1533 if (o->op_flags & OPf_KIDS)
1534 mod(cBINOPo->op_first->op_sibling, type);
463ee0b2 1535 break;
a0d0e21e 1536
463ee0b2
LW		 1537 case OP_AELEM:
1538 case OP_HELEM:
11343788 1539 ref(cBINOPo->op_first, o->op_type);
68dc0745 1540 if (type == OP_ENTERSUB &&
5dc0d613
MB		 1541 !(o->op_private & (OPpLVAL_INTRO | OPpDEREF)))
1542 o->op_private |= OPpLVAL_DEFER;
3280af22 1543 PL_modcount++;
463ee0b2
LW		 1544 break;
1545
1546 case OP_SCOPE:
1547 case OP_LEAVE:
1548 case OP_ENTER:
11343788
MB		 1549 if (o->op_flags & OPf_KIDS)
1550 mod(cLISTOPo->op_last, type);
a0d0e21e
LW		 1551 break;
1552
1553 case OP_NULL:
638bc118
GS		 1554 if (o->op_flags & OPf_SPECIAL) /* do BLOCK */
1555 goto nomod;
1556 else if (!(o->op_flags & OPf_KIDS))
463ee0b2 1557 break;
11343788
MB		 1558 if (o->op_targ != OP_LIST) {
1559 mod(cBINOPo->op_first, type);
a0d0e21e
LW		 1560 break;
1561 }
1562 /* FALL THROUGH */
463ee0b2 1563 case OP_LIST:
11343788 1564 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
463ee0b2
LW		 1565 mod(kid, type);
1566 break;
1567 }
11343788 1568 o->op_flags |= OPf_MOD;
a0d0e21e
LW		 1569
1570 if (type == OP_AASSIGN || type == OP_SASSIGN)
11343788 1571 o->op_flags |= OPf_SPECIAL|OPf_REF;
a0d0e21e 1572 else if (!type) {
11343788
MB		 1573 o->op_private |= OPpLVAL_INTRO;
1574 o->op_flags &= ~OPf_SPECIAL;
3280af22 1575 PL_hints |= HINT_BLOCK_SCOPE;
463ee0b2 1576 }
a0d0e21e 1577 else if (type != OP_GREPSTART && type != OP_ENTERSUB)
11343788
MB		 1578 o->op_flags |= OPf_REF;
1579 return o;
463ee0b2
LW		 1580}
1581
864dbfa3 1582STATIC bool
cea2e8a9 1583S_scalar_mod_type(pTHX_ OP *o, I32 type)
3fe9a6f1 1584{
1585 switch (type) {
1586 case OP_SASSIGN:
5196be3e 1587 if (o->op_type == OP_RV2GV)
3fe9a6f1 1588 return FALSE;
1589 /* FALL THROUGH */
1590 case OP_PREINC:
1591 case OP_PREDEC:
1592 case OP_POSTINC:
1593 case OP_POSTDEC:
1594 case OP_I_PREINC:
1595 case OP_I_PREDEC:
1596 case OP_I_POSTINC:
1597 case OP_I_POSTDEC:
1598 case OP_POW:
1599 case OP_MULTIPLY:
1600 case OP_DIVIDE:
1601 case OP_MODULO:
1602 case OP_REPEAT:
1603 case OP_ADD:
1604 case OP_SUBTRACT:
1605 case OP_I_MULTIPLY:
1606 case OP_I_DIVIDE:
1607 case OP_I_MODULO:
1608 case OP_I_ADD:
1609 case OP_I_SUBTRACT:
1610 case OP_LEFT_SHIFT:
1611 case OP_RIGHT_SHIFT:
1612 case OP_BIT_AND:
1613 case OP_BIT_XOR:
1614 case OP_BIT_OR:
1615 case OP_CONCAT:
1616 case OP_SUBST:
1617 case OP_TRANS:
49e9fbe6
GS		 1618 case OP_READ:
1619 case OP_SYSREAD:
1620 case OP_RECV:
bf4b1e52
GS		 1621 case OP_ANDASSIGN:
1622 case OP_ORASSIGN:
3fe9a6f1 1623 return TRUE;
1624 default:
1625 return FALSE;
1626 }
1627}
1628
35cd451c 1629STATIC bool
cea2e8a9 1630S_is_handle_constructor(pTHX_ OP *o, I32 argnum)
35cd451c
GS		 1631{
1632 switch (o->op_type) {
1633 case OP_PIPE_OP:
1634 case OP_SOCKPAIR:
1635 if (argnum == 2)
1636 return TRUE;
1637 /* FALL THROUGH */
1638 case OP_SYSOPEN:
1639 case OP_OPEN:
ded8aa31 1640 case OP_SELECT: /* XXX c.f. SelectSaver.pm */
35cd451c
GS		 1641 case OP_SOCKET:
1642 case OP_OPEN_DIR:
1643 case OP_ACCEPT:
1644 if (argnum == 1)
1645 return TRUE;
1646 /* FALL THROUGH */
1647 default:
1648 return FALSE;
1649 }
1650}
1651
463ee0b2 1652OP *
864dbfa3 1653Perl_refkids(pTHX_ OP *o, I32 type)
463ee0b2
LW		 1654{
1655 OP *kid;
11343788
MB		 1656 if (o && o->op_flags & OPf_KIDS) {
1657 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
463ee0b2
LW		 1658 ref(kid, type);
1659 }
11343788 1660 return o;
463ee0b2
LW		 1661}
1662
1663OP *
864dbfa3 1664Perl_ref(pTHX_ OP *o, I32 type)
463ee0b2
LW		 1665{
1666 OP *kid;
463ee0b2 1667
3280af22 1668 if (!o || PL_error_count)
11343788 1669 return o;
463ee0b2 1670
11343788 1671 switch (o->op_type) {
a0d0e21e 1672 case OP_ENTERSUB:
e55aaa0e 1673 if ((type == OP_DEFINED || type == OP_LOCK) &&
11343788
MB		 1674 !(o->op_flags & OPf_STACKED)) {
1675 o->op_type = OP_RV2CV; /* entersub => rv2cv */
22c35a8c 1676 o->op_ppaddr = PL_ppaddr[OP_RV2CV];
11343788
MB		 1677 assert(cUNOPo->op_first->op_type == OP_NULL);
1678 null(((LISTOP*)cUNOPo->op_first)->op_first); /* disable pushmark */
1679 o->op_flags |= OPf_SPECIAL;
8990e307
LW		 1680 }
1681 break;
aeea060c 1682
463ee0b2 1683 case OP_COND_EXPR:
11343788 1684 for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
463ee0b2
LW		 1685 ref(kid, type);
1686 break;
8990e307 1687 case OP_RV2SV:
35cd451c
GS		 1688 if (type == OP_DEFINED)
1689 o->op_flags |= OPf_SPECIAL; /* don't create GV */
11343788 1690 ref(cUNOPo->op_first, o->op_type);
4633a7c4
LW		 1691 /* FALL THROUGH */
1692 case OP_PADSV:
5f05dabc 1693 if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV) {
5dc0d613
MB		 1694 o->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
1695 : type == OP_RV2HV ? OPpDEREF_HV
1696 : OPpDEREF_SV);
11343788 1697 o->op_flags |= OPf_MOD;
a0d0e21e 1698 }
8990e307
LW		 1699 break;
1700
2faa37cc 1701 case OP_THREADSV:
a863c7d1
MB		 1702 o->op_flags |= OPf_MOD; /* XXX ??? */
1703 break;
1704
463ee0b2
LW		 1705 case OP_RV2AV:
1706 case OP_RV2HV:
aeea060c 1707 o->op_flags |= OPf_REF;
8990e307 1708 /* FALL THROUGH */
463ee0b2 1709 case OP_RV2GV:
35cd451c
GS		 1710 if (type == OP_DEFINED)
1711 o->op_flags |= OPf_SPECIAL; /* don't create GV */
11343788 1712 ref(cUNOPo->op_first, o->op_type);
463ee0b2 1713 break;
8990e307 1714
463ee0b2
LW		 1715 case OP_PADAV:
1716 case OP_PADHV:
aeea060c 1717 o->op_flags |= OPf_REF;
79072805 1718 break;
aeea060c 1719
8990e307 1720 case OP_SCALAR:
79072805 1721 case OP_NULL:
11343788 1722 if (!(o->op_flags & OPf_KIDS))
463ee0b2 1723 break;
11343788 1724 ref(cBINOPo->op_first, type);
79072805
LW		 1725 break;
1726 case OP_AELEM:
1727 case OP_HELEM:
11343788 1728 ref(cBINOPo->op_first, o->op_type);
5f05dabc 1729 if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV) {
5dc0d613
MB		 1730 o->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
1731 : type == OP_RV2HV ? OPpDEREF_HV
1732 : OPpDEREF_SV);
11343788 1733 o->op_flags |= OPf_MOD;
8990e307 1734 }
79072805
LW		 1735 break;
1736
463ee0b2 1737 case OP_SCOPE:
79072805
LW		 1738 case OP_LEAVE:
1739 case OP_ENTER:
8990e307 1740 case OP_LIST:
11343788 1741 if (!(o->op_flags & OPf_KIDS))
79072805 1742 break;
11343788 1743 ref(cLISTOPo->op_last, type);
79072805 1744 break;
a0d0e21e
LW		 1745 default:
1746 break;
79072805 1747 }
11343788 1748 return scalar(o);
8990e307 1749
79072805
LW		 1750}
1751
09bef843
SB		 1752STATIC OP *
1753S_dup_attrlist(pTHX_ OP *o)
1754{
1755 OP *rop = Nullop;
1756
1757 /* An attrlist is either a simple OP_CONST or an OP_LIST with kids,
1758 * where the first kid is OP_PUSHMARK and the remaining ones
1759 * are OP_CONST. We need to push the OP_CONST values.
1760 */
1761 if (o->op_type == OP_CONST)
1762 rop = newSVOP(OP_CONST, o->op_flags, SvREFCNT_inc(cSVOPo->op_sv));
1763 else {
1764 assert((o->op_type == OP_LIST) && (o->op_flags & OPf_KIDS));
1765 for (o = cLISTOPo->op_first; o; o=o->op_sibling) {
1766 if (o->op_type == OP_CONST)
1767 rop = append_elem(OP_LIST, rop,
1768 newSVOP(OP_CONST, o->op_flags,
1769 SvREFCNT_inc(cSVOPo->op_sv)));
1770 }
1771 }
1772 return rop;
1773}
1774
1775STATIC void
1776S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs)
1777{
1778 OP *modname; /* for 'use' */
1779 SV *stashsv;
1780
1781 /* fake up C<use attributes $pkg,$rv,@attrs> */
1782 ENTER; /* need to protect against side-effects of 'use' */
1783 SAVEINT(PL_expect);
1784 if (stash && HvNAME(stash))
1785 stashsv = newSVpv(HvNAME(stash), 0);
1786 else
1787 stashsv = &PL_sv_no;
1788#define ATTRSMODULE "attributes"
1789 modname = newSVOP(OP_CONST, 0,
1790 newSVpvn(ATTRSMODULE, sizeof(ATTRSMODULE)-1));
1791 modname->op_private |= OPpCONST_BARE;
1792 /* that flag is required to make 'use' work right */
1793 utilize(1, start_subparse(FALSE, 0),
1794 Nullop, /* version */
1795 modname,
1796 prepend_elem(OP_LIST,
1797 newSVOP(OP_CONST, 0, stashsv),
1798 prepend_elem(OP_LIST,
1799 newSVOP(OP_CONST, 0, newRV(target)),
1800 dup_attrlist(attrs))));
1801 LEAVE;
1802}
1803
1804STATIC OP *
1805S_my_kid(pTHX_ OP *o, OP *attrs)
93a17b20
LW		 1806{
1807 OP *kid;
93a17b20
LW		 1808 I32 type;
1809
3280af22 1810 if (!o || PL_error_count)
11343788 1811 return o;
93a17b20 1812
11343788 1813 type = o->op_type;
93a17b20 1814 if (type == OP_LIST) {
11343788 1815 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
09bef843 1816 my_kid(kid, attrs);
dab48698 1817 } else if (type == OP_UNDEF) {
7766148a 1818 return o;
77ca0c92
LW		 1819 } else if (type == OP_RV2SV || /* "our" declaration */
1820 type == OP_RV2AV ||
1821 type == OP_RV2HV) { /* XXX does this let anything illegal in? */
1822 return o;
dab48698 1823 } else if (type != OP_PADSV &&
93a17b20
LW		 1824 type != OP_PADAV &&
1825 type != OP_PADHV &&
1826 type != OP_PUSHMARK)
1827 {
cea2e8a9 1828 yyerror(Perl_form(aTHX_ "Can't declare %s in my", PL_op_desc[o->op_type]));
11343788 1829 return o;
93a17b20 1830 }
09bef843
SB		 1831 else if (attrs && type != OP_PUSHMARK) {
1832 HV *stash;
1833 SV *padsv;
1834 SV **namesvp;
1835
1836 /* check for C<my Dog $spot> when deciding package */
1837 namesvp = av_fetch(PL_comppad_name, o->op_targ, FALSE);
1838 if (namesvp && *namesvp && SvOBJECT(*namesvp) && HvNAME(SvSTASH(*namesvp)))
1839 stash = SvSTASH(*namesvp);
1840 else
1841 stash = PL_curstash;
1842 padsv = PAD_SV(o->op_targ);
1843 apply_attrs(stash, padsv, attrs);
1844 }
11343788
MB		 1845 o->op_flags |= OPf_MOD;
1846 o->op_private |= OPpLVAL_INTRO;
1847 return o;
93a17b20
LW		 1848}
1849
1850OP *
09bef843
SB		 1851Perl_my_attrs(pTHX_ OP *o, OP *attrs)
1852{
1853 if (o->op_flags & OPf_PARENS)
1854 list(o);
1855 PL_in_my = FALSE;
1856 PL_in_my_stash = Nullhv;
1857 if (attrs)
1858 SAVEFREEOP(attrs);
1859 return my_kid(o, attrs);
1860}
1861
1862OP *
1863Perl_my(pTHX_ OP *o)
1864{
1865 return my_kid(o, Nullop);
1866}
1867
1868OP *
864dbfa3 1869Perl_sawparens(pTHX_ OP *o)
79072805
LW		 1870{
1871 if (o)
1872 o->op_flags |= OPf_PARENS;
1873 return o;
1874}
1875
1876OP *
864dbfa3 1877Perl_bind_match(pTHX_ I32 type, OP *left, OP *right)
79072805 1878{
d008e5eb 1879 dTHR;
11343788 1880 OP *o;
79072805 1881
599cee73
PM		 1882 if (ckWARN(WARN_UNSAFE) &&
1883 (left->op_type == OP_RV2AV ||
1884 left->op_type == OP_RV2HV ||
1885 left->op_type == OP_PADAV ||
1886 left->op_type == OP_PADHV)) {
22c35a8c 1887 char *desc = PL_op_desc[(right->op_type == OP_SUBST ||
599cee73
PM		 1888 right->op_type == OP_TRANS)
1889 ? right->op_type : OP_MATCH];
dff6d3cd
GS		 1890 const char *sample = ((left->op_type == OP_RV2AV ||
1891 left->op_type == OP_PADAV)
1892 ? "@array" : "%hash");
cea2e8a9 1893 Perl_warner(aTHX_ WARN_UNSAFE,
599cee73
PM		 1894 "Applying %s to %s will act on scalar(%s)",
1895 desc, sample, sample);
2ae324a7 1896 }
1897
79072805
LW		 1898 if (right->op_type == OP_MATCH ||
1899 right->op_type == OP_SUBST ||
1900 right->op_type == OP_TRANS) {
1901 right->op_flags |= OPf_STACKED;
1902 if (right->op_type != OP_MATCH)
463ee0b2 1903 left = mod(left, right->op_type);
79072805 1904 if (right->op_type == OP_TRANS)
11343788 1905 o = newBINOP(OP_NULL, OPf_STACKED, scalar(left), right);
79072805 1906 else
11343788 1907 o = prepend_elem(right->op_type, scalar(left), right);
79072805 1908 if (type == OP_NOT)
11343788
MB		 1909 return newUNOP(OP_NOT, 0, scalar(o));
1910 return o;
79072805
LW		 1911 }
1912 else
1913 return bind_match(type, left,
1914 pmruntime(newPMOP(OP_MATCH, 0), right, Nullop));
1915}
1916
1917OP *
864dbfa3 1918Perl_invert(pTHX_ OP *o)
79072805 1919{
11343788
MB		 1920 if (!o)
1921 return o;
79072805 1922 /* XXX need to optimize away NOT NOT here? Or do we let optimizer do it? */
11343788 1923 return newUNOP(OP_NOT, OPf_SPECIAL, scalar(o));
79072805
LW		 1924}
1925
1926OP *
864dbfa3 1927Perl_scope(pTHX_ OP *o)
79072805
LW		 1928{
1929 if (o) {
3280af22 1930 if (o->op_flags & OPf_PARENS || PERLDB_NOOPT || PL_tainting) {
463ee0b2
LW		 1931 o = prepend_elem(OP_LINESEQ, newOP(OP_ENTER, 0), o);
1932 o->op_type = OP_LEAVE;
22c35a8c 1933 o->op_ppaddr = PL_ppaddr[OP_LEAVE];
463ee0b2
LW		 1934 }
1935 else {
1936 if (o->op_type == OP_LINESEQ) {
1937 OP *kid;
1938 o->op_type = OP_SCOPE;
22c35a8c 1939 o->op_ppaddr = PL_ppaddr[OP_SCOPE];
c3ed7a6a
GS		 1940 kid = ((LISTOP*)o)->op_first;
1941 if (kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE)
1942 null(kid);
463ee0b2
LW		 1943 }
1944 else
748a9306 1945 o = newLISTOP(OP_SCOPE, 0, o, Nullop);
463ee0b2 1946 }
79072805
LW		 1947 }
1948 return o;
1949}
1950
b3ac6de7 1951void
864dbfa3 1952Perl_save_hints(pTHX)
b3ac6de7 1953{
3280af22
NIS		 1954 SAVEI32(PL_hints);
1955 SAVESPTR(GvHV(PL_hintgv));
1956 GvHV(PL_hintgv) = newHVhv(GvHV(PL_hintgv));
1957 SAVEFREESV(GvHV(PL_hintgv));
b3ac6de7
IZ		 1958}
1959
a0d0e21e 1960int
864dbfa3 1961Perl_block_start(pTHX_ int full)
79072805 1962{
11343788 1963 dTHR;
3280af22 1964 int retval = PL_savestack_ix;
b3ac6de7 1965
3280af22 1966 SAVEI32(PL_comppad_name_floor);
55497cff 1967 if (full) {
3280af22
NIS		 1968 if ((PL_comppad_name_fill = AvFILLp(PL_comppad_name)) > 0)
1969 PL_comppad_name_floor = PL_comppad_name_fill;
55497cff 1970 else
3280af22
NIS		 1971 PL_comppad_name_floor = 0;
1972 }
1973 SAVEI32(PL_min_intro_pending);
1974 SAVEI32(PL_max_intro_pending);
1975 PL_min_intro_pending = 0;
1976 SAVEI32(PL_comppad_name_fill);
1977 SAVEI32(PL_padix_floor);
1978 PL_padix_floor = PL_padix;
1979 PL_pad_reset_pending = FALSE;
b3ac6de7 1980 SAVEHINTS();
3280af22 1981 PL_hints &= ~HINT_BLOCK_SCOPE;
e24b16f9 1982 SAVEPPTR(PL_compiling.cop_warnings);
0453d815 1983 if (! specialWARN(PL_compiling.cop_warnings)) {
599cee73
PM		 1984 PL_compiling.cop_warnings = newSVsv(PL_compiling.cop_warnings) ;
1985 SAVEFREESV(PL_compiling.cop_warnings) ;
1986 }
1987
1988
a0d0e21e
LW		 1989 return retval;
1990}
1991
1992OP*
864dbfa3 1993Perl_block_end(pTHX_ I32 floor, OP *seq)
a0d0e21e 1994{
11343788 1995 dTHR;
3280af22 1996 int needblockscope = PL_hints & HINT_BLOCK_SCOPE;
a0d0e21e 1997 OP* retval = scalarseq(seq);
a0d0e21e 1998 LEAVE_SCOPE(floor);
3280af22 1999 PL_pad_reset_pending = FALSE;
e24b16f9 2000 PL_compiling.op_private = PL_hints;
a0d0e21e 2001 if (needblockscope)
3280af22
NIS		 2002 PL_hints |= HINT_BLOCK_SCOPE; /* propagate out */
2003 pad_leavemy(PL_comppad_name_fill);
2004 PL_cop_seqmax++;
a0d0e21e
LW		 2005 return retval;
2006}
2007
76e3520e 2008STATIC OP *
cea2e8a9 2009S_newDEFSVOP(pTHX)
54b9620d
MB		 2010{
2011#ifdef USE_THREADS
2012 OP *o = newOP(OP_THREADSV, 0);
2013 o->op_targ = find_threadsv("_");
2014 return o;
2015#else
3280af22 2016 return newSVREF(newGVOP(OP_GV, 0, PL_defgv));
54b9620d
MB		 2017#endif /* USE_THREADS */
2018}
2019
a0d0e21e 2020void
864dbfa3 2021Perl_newPROG(pTHX_ OP *o)
a0d0e21e 2022{
11343788 2023 dTHR;
3280af22 2024 if (PL_in_eval) {
b295d113
TH		 2025 if (PL_eval_root)
2026 return;
faef0170
HS		 2027 PL_eval_root = newUNOP(OP_LEAVEEVAL,
2028 ((PL_in_eval & EVAL_KEEPERR)
2029 ? OPf_SPECIAL : 0), o);
3280af22 2030 PL_eval_start = linklist(PL_eval_root);
7934575e
GS		 2031 PL_eval_root->op_private |= OPpREFCOUNTED;
2032 OpREFCNT_set(PL_eval_root, 1);
3280af22
NIS		 2033 PL_eval_root->op_next = 0;
2034 peep(PL_eval_start);
a0d0e21e
LW		 2035 }
2036 else {
5dc0d613 2037 if (!o)
a0d0e21e 2038 return;
3280af22
NIS		 2039 PL_main_root = scope(sawparens(scalarvoid(o)));
2040 PL_curcop = &PL_compiling;
2041 PL_main_start = LINKLIST(PL_main_root);
7934575e
GS		 2042 PL_main_root->op_private |= OPpREFCOUNTED;
2043 OpREFCNT_set(PL_main_root, 1);
3280af22
NIS		 2044 PL_main_root->op_next = 0;
2045 peep(PL_main_start);
2046 PL_compcv = 0;
3841441e 2047
4fdae800 2048 /* Register with debugger */
84902520 2049 if (PERLDB_INTER) {
864dbfa3 2050 CV *cv = get_cv("DB::postponed", FALSE);
3841441e
CS		 2051 if (cv) {
2052 dSP;
924508f0 2053 PUSHMARK(SP);
cc49e20b 2054 XPUSHs((SV*)CopFILEGV(&PL_compiling));
3841441e 2055 PUTBACK;
864dbfa3 2056 call_sv((SV*)cv, G_DISCARD);
3841441e
CS		 2057 }
2058 }
79072805 2059 }
79072805
LW		 2060}
2061
2062OP *
864dbfa3 2063Perl_localize(pTHX_ OP *o, I32 lex)
79072805
LW		 2064{
2065 if (o->op_flags & OPf_PARENS)
2066 list(o);
8990e307 2067 else {
d008e5eb 2068 dTHR;
599cee73 2069 if (ckWARN(WARN_PARENTHESIS) && PL_bufptr > PL_oldbufptr && PL_bufptr[-1] == ',') {
8990e307 2070 char *s;
834a4ddd 2071 for (s = PL_bufptr; *s && (isALNUM(*s) || (*s & 0x80) || strchr("@$%, ",*s)); s++) ;
a0d0e21e 2072 if (*s == ';' || *s == '=')
cea2e8a9 2073 Perl_warner(aTHX_ WARN_PARENTHESIS, "Parentheses missing around \"%s\" list",
599cee73 2074 lex ? "my" : "local");
8990e307
LW		 2075 }
2076 }
3280af22
NIS		 2077 PL_in_my = FALSE;
2078 PL_in_my_stash = Nullhv;
93a17b20
LW		 2079 if (lex)
2080 return my(o);
2081 else
463ee0b2 2082 return mod(o, OP_NULL); /* a bit kludgey */
79072805
LW		 2083}
2084
2085OP *
864dbfa3 2086Perl_jmaybe(pTHX_ OP *o)
79072805
LW		 2087{
2088 if (o->op_type == OP_LIST) {
554b3eca
MB		 2089 OP *o2;
2090#ifdef USE_THREADS
2faa37cc 2091 o2 = newOP(OP_THREADSV, 0);
54b9620d 2092 o2->op_targ = find_threadsv(";");
554b3eca
MB		 2093#else
2094 o2 = newSVREF(newGVOP(OP_GV, 0, gv_fetchpv(";", TRUE, SVt_PV))),
2095#endif /* USE_THREADS */
2096 o = convert(OP_JOIN, 0, prepend_elem(OP_LIST, o2, o));
79072805
LW		 2097 }
2098 return o;
2099}
2100
2101OP *
864dbfa3 2102Perl_fold_constants(pTHX_ register OP *o)
79072805 2103{
11343788 2104 dTHR;
79072805
LW		 2105 register OP *curop;
2106 I32 type = o->op_type;
748a9306 2107 SV *sv;
79072805 2108
22c35a8c 2109 if (PL_opargs[type] & OA_RETSCALAR)
79072805 2110 scalar(o);
b162f9ea 2111 if (PL_opargs[type] & OA_TARGET && !o->op_targ)
ed6116ce 2112 o->op_targ = pad_alloc(type, SVs_PADTMP);
79072805 2113
eac055e9
GS		 2114 /* integerize op, unless it happens to be C<-foo>.
2115 * XXX should pp_i_negate() do magic string negation instead? */
2116 if ((PL_opargs[type] & OA_OTHERINT) && (PL_hints & HINT_INTEGER)
2117 && !(type == OP_NEGATE && cUNOPo->op_first->op_type == OP_CONST
2118 && (cUNOPo->op_first->op_private & OPpCONST_BARE)))
2119 {
22c35a8c 2120 o->op_ppaddr = PL_ppaddr[type = ++(o->op_type)];
eac055e9 2121 }
85e6fe83 2122
22c35a8c 2123 if (!(PL_opargs[type] & OA_FOLDCONST))
79072805
LW		 2124 goto nope;
2125
de939608 2126 switch (type) {
7a52d87a
GS		 2127 case OP_NEGATE:
2128 /* XXX might want a ck_negate() for this */
2129 cUNOPo->op_first->op_private &= ~OPpCONST_STRICT;
2130 break;
de939608
CS		 2131 case OP_SPRINTF:
2132 case OP_UCFIRST:
2133 case OP_LCFIRST:
2134 case OP_UC:
2135 case OP_LC:
69dcf70c
MB		 2136 case OP_SLT:
2137 case OP_SGT:
2138 case OP_SLE:
2139 case OP_SGE:
2140 case OP_SCMP:
2141
de939608
CS		 2142 if (o->op_private & OPpLOCALE)
2143 goto nope;
2144 }
2145
3280af22 2146 if (PL_error_count)
a0d0e21e
LW		 2147 goto nope; /* Don't try to run w/ errors */
2148
79072805 2149 for (curop = LINKLIST(o); curop != o; curop = LINKLIST(curop)) {
11fa937b
GS		 2150 if ((curop->op_type != OP_CONST ||
2151 (curop->op_private & OPpCONST_BARE)) &&
7a52d87a
GS		 2152 curop->op_type != OP_LIST &&
2153 curop->op_type != OP_SCALAR &&
2154 curop->op_type != OP_NULL &&
2155 curop->op_type != OP_PUSHMARK)
2156 {
79072805
LW		 2157 goto nope;
2158 }
2159 }
2160
2161 curop = LINKLIST(o);
2162 o->op_next = 0;
533c011a 2163 PL_op = curop;
cea2e8a9 2164 CALLRUNOPS(aTHX);
3280af22 2165 sv = *(PL_stack_sp--);
748a9306 2166 if (o->op_targ && sv == PAD_SV(o->op_targ)) /* grab pad temp? */
79072805 2167 pad_swipe(o->op_targ);
748a9306
LW		 2168 else if (SvTEMP(sv)) { /* grab mortal temp? */
2169 (void)SvREFCNT_inc(sv);
2170 SvTEMP_off(sv);
85e6fe83 2171 }
79072805
LW		 2172 op_free(o);
2173 if (type == OP_RV2GV)
b1cb66bf 2174 return newGVOP(OP_GV, 0, (GV*)sv);
748a9306 2175 else {
ee580363
GS		 2176 /* try to smush double to int, but don't smush -2.0 to -2 */
2177 if ((SvFLAGS(sv) & (SVf_IOK|SVf_NOK|SVf_POK)) == SVf_NOK &&
2178 type != OP_NEGATE)
2179 {
748a9306 2180 IV iv = SvIV(sv);
65202027 2181 if ((NV)iv == SvNV(sv)) {
748a9306
LW		 2182 SvREFCNT_dec(sv);
2183 sv = newSViv(iv);
2184 }
b1cb66bf 2185 else
2186 SvIOK_off(sv); /* undo SvIV() damage */
748a9306
LW		 2187 }
2188 return newSVOP(OP_CONST, 0, sv);
2189 }
aeea060c 2190
79072805 2191 nope:
22c35a8c 2192 if (!(PL_opargs[type] & OA_OTHERINT))
79072805 2193 return o;
79072805 2194
3280af22 2195 if (!(PL_hints & HINT_INTEGER)) {
4bb9f687
GS		 2196 if (type == OP_MODULO
2197 || type == OP_DIVIDE
2198 || !(o->op_flags & OPf_KIDS))
2199 {
85e6fe83 2200 return o;
4bb9f687 2201 }
85e6fe83
LW		 2202
2203 for (curop = ((UNOP*)o)->op_first; curop; curop = curop->op_sibling) {
2204 if (curop->op_type == OP_CONST) {
b1cb66bf 2205 if (SvIOK(((SVOP*)curop)->op_sv))
85e6fe83
LW		 2206 continue;
2207 return o;
2208 }
22c35a8c 2209 if (PL_opargs[curop->op_type] & OA_RETINTEGER)
79072805
LW		 2210 continue;
2211 return o;
2212 }
22c35a8c 2213 o->op_ppaddr = PL_ppaddr[++(o->op_type)];
79072805
LW		 2214 }
2215
79072805
LW		 2216 return o;
2217}
2218
2219OP *
864dbfa3 2220Perl_gen_constant_list(pTHX_ register OP *o)
79072805 2221{
11343788 2222 dTHR;
79072805 2223 register OP *curop;
3280af22 2224 I32 oldtmps_floor = PL_tmps_floor;
79072805 2225
a0d0e21e 2226 list(o);
3280af22 2227 if (PL_error_count)
a0d0e21e
LW		 2228 return o; /* Don't attempt to run with errors */
2229
533c011a 2230 PL_op = curop = LINKLIST(o);
a0d0e21e 2231 o->op_next = 0;
cea2e8a9
GS		 2232 pp_pushmark();
2233 CALLRUNOPS(aTHX);
533c011a 2234 PL_op = curop;
cea2e8a9 2235 pp_anonlist();
3280af22 2236 PL_tmps_floor = oldtmps_floor;
79072805
LW		 2237
2238 o->op_type = OP_RV2AV;
22c35a8c 2239 o->op_ppaddr = PL_ppaddr[OP_RV2AV];
79072805 2240 curop = ((UNOP*)o)->op_first;
3280af22 2241 ((UNOP*)o)->op_first = newSVOP(OP_CONST, 0, SvREFCNT_inc(*PL_stack_sp--));
79072805 2242 op_free(curop);
79072805
LW		 2243 linklist(o);
2244 return list(o);
2245}
2246
2247OP *
864dbfa3 2248Perl_convert(pTHX_ I32 type, I32 flags, OP *o)
79072805
LW		 2249{
2250 OP *kid;
a0d0e21e 2251 OP *last = 0;
79072805 2252
11343788
MB		 2253 if (!o || o->op_type != OP_LIST)
2254 o = newLISTOP(OP_LIST, 0, o, Nullop);
748a9306 2255 else
5dc0d613 2256 o->op_flags &= ~OPf_WANT;
79072805 2257
22c35a8c 2258 if (!(PL_opargs[type] & OA_MARK))
11343788 2259 null(cLISTOPo->op_first);
8990e307 2260
11343788 2261 o->op_type = type;
22c35a8c 2262 o->op_ppaddr = PL_ppaddr[type];
11343788 2263 o->op_flags |= flags;
79072805 2264
11343788
MB		 2265 o = CHECKOP(type, o);
2266 if (o->op_type != type)
2267 return o;
79072805 2268
11343788 2269 if (cLISTOPo->op_children < 7) {
79072805 2270 /* XXX do we really need to do this if we're done appending?? */
11343788 2271 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
79072805 2272 last = kid;
11343788 2273 cLISTOPo->op_last = last; /* in case check substituted last arg */
79072805
LW		 2274 }
2275
11343788 2276 return fold_constants(o);
79072805
LW		 2277}
2278
2279/* List constructors */
2280
2281OP *
864dbfa3 2282Perl_append_elem(pTHX_ I32 type, OP *first, OP *last)
79072805
LW		 2283{
2284 if (!first)
2285 return last;
8990e307
LW		 2286
2287 if (!last)
79072805 2288 return first;
8990e307 2289
a0d0e21e
LW		 2290 if (first->op_type != type || type==OP_LIST && first->op_flags & OPf_PARENS)
2291 return newLISTOP(type, 0, first, last);
79072805 2292
a0d0e21e
LW		 2293 if (first->op_flags & OPf_KIDS)
2294 ((LISTOP*)first)->op_last->op_sibling = last;
2295 else {
2296 first->op_flags |= OPf_KIDS;
2297 ((LISTOP*)first)->op_first = last;
2298 }
2299 ((LISTOP*)first)->op_last = last;
2300 ((LISTOP*)first)->op_children++;
2301 return first;
79072805
LW		 2302}
2303
2304OP *
864dbfa3 2305Perl_append_list(pTHX_ I32 type, LISTOP *first, LISTOP *last)
79072805
LW		 2306{
2307 if (!first)
2308 return (OP*)last;
8990e307
LW		 2309
2310 if (!last)
79072805 2311 return (OP*)first;
8990e307
LW		 2312
2313 if (first->op_type != type)
79072805 2314 return prepend_elem(type, (OP*)first, (OP*)last);
8990e307
LW		 2315
2316 if (last->op_type != type)
79072805
LW		 2317 return append_elem(type, (OP*)first, (OP*)last);
2318
2319 first->op_last->op_sibling = last->op_first;
2320 first->op_last = last->op_last;
2321 first->op_children += last->op_children;
2322 if (first->op_children)
acb74605 2323 first->op_flags |= OPf_KIDS;
b7dc083c
NIS		 2324
2325#ifdef PL_OP_SLAB_ALLOC
2326#else
2327 Safefree(last);
2328#endif
79072805
LW		 2329 return (OP*)first;
2330}
2331
2332OP *
864dbfa3 2333Perl_prepend_elem(pTHX_ I32 type, OP *first, OP *last)
79072805
LW		 2334{
2335 if (!first)
2336 return last;
8990e307
LW		 2337
2338 if (!last)
79072805 2339 return first;
8990e307
LW		 2340
2341 if (last->op_type == type) {
2342 if (type == OP_LIST) { /* already a PUSHMARK there */
2343 first->op_sibling = ((LISTOP*)last)->op_first->op_sibling;
2344 ((LISTOP*)last)->op_first->op_sibling = first;
2345 }
2346 else {
2347 if (!(last->op_flags & OPf_KIDS)) {
2348 ((LISTOP*)last)->op_last = first;
2349 last->op_flags |= OPf_KIDS;
2350 }
2351 first->op_sibling = ((LISTOP*)last)->op_first;
2352 ((LISTOP*)last)->op_first = first;
79072805 2353 }
79072805
LW		 2354 ((LISTOP*)last)->op_children++;
2355 return last;
2356 }
2357
2358 return newLISTOP(type, 0, first, last);
2359}
2360
2361/* Constructors */
2362
2363OP *
864dbfa3 2364Perl_newNULLLIST(pTHX)
79072805 2365{
8990e307
LW		 2366 return newOP(OP_STUB, 0);
2367}
2368
2369OP *
864dbfa3 2370Perl_force_list(pTHX_ OP *o)
8990e307 2371{
11343788
MB		 2372 if (!o || o->op_type != OP_LIST)
2373 o = newLISTOP(OP_LIST, 0, o, Nullop);
2374 null(o);
2375 return o;
79072805
LW		 2376}
2377
2378OP *
864dbfa3 2379Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
79072805
LW		 2380{
2381 LISTOP *listop;
2382
b7dc083c 2383 NewOp(1101, listop, 1, LISTOP);
79072805
LW		 2384
2385 listop->op_type = type;
22c35a8c 2386 listop->op_ppaddr = PL_ppaddr[type];
79072805
LW		 2387 listop->op_children = (first != 0) + (last != 0);
2388 listop->op_flags = flags;
79072805
LW		 2389
2390 if (!last && first)
2391 last = first;
2392 else if (!first && last)
2393 first = last;
8990e307
LW		 2394 else if (first)
2395 first->op_sibling = last;
79072805
LW		 2396 listop->op_first = first;
2397 listop->op_last = last;
8990e307
LW		 2398 if (type == OP_LIST) {
2399 OP* pushop;
2400 pushop = newOP(OP_PUSHMARK, 0);
2401 pushop->op_sibling = first;
2402 listop->op_first = pushop;
2403 listop->op_flags |= OPf_KIDS;
2404 if (!last)
2405 listop->op_last = pushop;
2406 }
2407 else if (listop->op_children)
2408 listop->op_flags |= OPf_KIDS;
79072805
LW		 2409
2410 return (OP*)listop;
2411}
2412
2413OP *
864dbfa3 2414Perl_newOP(pTHX_ I32 type, I32 flags)
79072805 2415{
11343788 2416 OP *o;
b7dc083c 2417 NewOp(1101, o, 1, OP);
11343788 2418 o->op_type = type;
22c35a8c 2419 o->op_ppaddr = PL_ppaddr[type];
11343788 2420 o->op_flags = flags;
79072805 2421
11343788
MB		 2422 o->op_next = o;
2423 o->op_private = 0 + (flags >> 8);
22c35a8c 2424 if (PL_opargs[type] & OA_RETSCALAR)
11343788 2425 scalar(o);
22c35a8c 2426 if (PL_opargs[type] & OA_TARGET)
11343788
MB		 2427 o->op_targ = pad_alloc(type, SVs_PADTMP);
2428 return CHECKOP(type, o);
79072805
LW		 2429}
2430
2431OP *
864dbfa3 2432Perl_newUNOP(pTHX_ I32 type, I32 flags, OP *first)
79072805
LW		 2433{
2434 UNOP *unop;
2435
93a17b20 2436 if (!first)
aeea060c 2437 first = newOP(OP_STUB, 0);
22c35a8c 2438 if (PL_opargs[type] & OA_MARK)
8990e307 2439 first = force_list(first);
93a17b20 2440
b7dc083c 2441 NewOp(1101, unop, 1, UNOP);
79072805 2442 unop->op_type = type;
22c35a8c 2443 unop->op_ppaddr = PL_ppaddr[type];
79072805
LW		 2444 unop->op_first = first;
2445 unop->op_flags = flags | OPf_KIDS;
c07a80fd 2446 unop->op_private = 1 | (flags >> 8);
e50aee73 2447 unop = (UNOP*) CHECKOP(type, unop);
79072805
LW		 2448 if (unop->op_next)
2449 return (OP*)unop;
2450
a0d0e21e 2451 return fold_constants((OP *) unop);
79072805
LW		 2452}
2453
2454OP *
864dbfa3 2455Perl_newBINOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
79072805
LW		 2456{
2457 BINOP *binop;
b7dc083c 2458 NewOp(1101, binop, 1, BINOP);
79072805
LW		 2459
2460 if (!first)
2461 first = newOP(OP_NULL, 0);
2462
2463 binop->op_type = type;
22c35a8c 2464 binop->op_ppaddr = PL_ppaddr[type];
79072805
LW		 2465 binop->op_first = first;
2466 binop->op_flags = flags | OPf_KIDS;
2467 if (!last) {
2468 last = first;
c07a80fd 2469 binop->op_private = 1 | (flags >> 8);
79072805
LW		 2470 }
2471 else {
c07a80fd 2472 binop->op_private = 2 | (flags >> 8);
79072805
LW		 2473 first->op_sibling = last;
2474 }
2475
e50aee73 2476 binop = (BINOP*)CHECKOP(type, binop);
b162f9ea 2477 if (binop->op_next || binop->op_type != type)
79072805
LW		 2478 return (OP*)binop;
2479
7284ab6f 2480 binop->op_last = binop->op_first->op_sibling;
79072805 2481
a0d0e21e 2482 return fold_constants((OP *)binop);
79072805
LW		 2483}
2484
a0ed51b3
LW		 2485static int
2486utf8compare(const void *a, const void *b)
2487{
2488 int i;
2489 for (i = 0; i < 10; i++) {
2490 if ((*(U8**)a)[i] < (*(U8**)b)[i])
2491 return -1;
2492 if ((*(U8**)a)[i] > (*(U8**)b)[i])
2493 return 1;
2494 }
2495 return 0;
2496}
2497
79072805 2498OP *
864dbfa3 2499Perl_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
79072805 2500{
79072805
LW		 2501 SV *tstr = ((SVOP*)expr)->op_sv;
2502 SV *rstr = ((SVOP*)repl)->op_sv;
463ee0b2
LW		 2503 STRLEN tlen;
2504 STRLEN rlen;
ec49126f 2505 register U8 *t = (U8*)SvPV(tstr, tlen);
2506 register U8 *r = (U8*)SvPV(rstr, rlen);
79072805
LW		 2507 register I32 i;
2508 register I32 j;
a0ed51b3 2509 I32 del;
79072805 2510 I32 complement;
5d06d08e 2511 I32 squash;
79072805
LW		 2512 register short *tbl;
2513
11343788 2514 complement = o->op_private & OPpTRANS_COMPLEMENT;
a0ed51b3 2515 del = o->op_private & OPpTRANS_DELETE;
5d06d08e 2516 squash = o->op_private & OPpTRANS_SQUASH;
79072805 2517
a0ed51b3 2518 if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
79cb57f6 2519 SV* listsv = newSVpvn("# comment\n",10);
a0ed51b3
LW		 2520 SV* transv = 0;
2521 U8* tend = t + tlen;
2522 U8* rend = r + rlen;
2523 I32 ulen;
2524 U32 tfirst = 1;
2525 U32 tlast = 0;
2526 I32 tdiff;
2527 U32 rfirst = 1;
2528 U32 rlast = 0;
2529 I32 rdiff;
2530 I32 diff;
2531 I32 none = 0;
2532 U32 max = 0;
2533 I32 bits;
2534 I32 grows = 0;
2535 I32 havefinal = 0;
2536 U32 final;
2537 HV *hv;
2538 I32 from_utf = o->op_private & OPpTRANS_FROM_UTF;
2539 I32 to_utf = o->op_private & OPpTRANS_TO_UTF;
2540
2541 if (complement) {
2542 U8 tmpbuf[10];
2543 U8** cp;
2544 UV nextmin = 0;
2545 New(1109, cp, tlen, U8*);
2546 i = 0;
79cb57f6 2547 transv = newSVpvn("",0);
a0ed51b3
LW		 2548 while (t < tend) {
2549 cp[i++] = t;
2550 t += UTF8SKIP(t);
2551 if (*t == 0xff) {
2552 t++;
2553 t += UTF8SKIP(t);
2554 }
2555 }
2556 qsort(cp, i, sizeof(U8*), utf8compare);
2557 for (j = 0; j < i; j++) {
2558 U8 *s = cp[j];
2559 UV val = utf8_to_uv(s, &ulen);
2560 s += ulen;
2561 diff = val - nextmin;
2562 if (diff > 0) {
2563 t = uv_to_utf8(tmpbuf,nextmin);
dfe13c55 2564 sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
a0ed51b3
LW		 2565 if (diff > 1) {
2566 t = uv_to_utf8(tmpbuf, val - 1);
2567 sv_catpvn(transv, "\377", 1);
dfe13c55 2568 sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
a0ed51b3
LW		 2569 }
2570 }
2571 if (*s == 0xff)
2572 val = utf8_to_uv(s+1, &ulen);
2573 if (val >= nextmin)
2574 nextmin = val + 1;
2575 }
2576 t = uv_to_utf8(tmpbuf,nextmin);
dfe13c55 2577 sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
a0ed51b3
LW		 2578 t = uv_to_utf8(tmpbuf, 0x7fffffff);
2579 sv_catpvn(transv, "\377", 1);
dfe13c55
GS		 2580 sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
2581 t = (U8*)SvPVX(transv);
a0ed51b3
LW		 2582 tlen = SvCUR(transv);
2583 tend = t + tlen;
2584 }
2585 else if (!rlen && !del) {
2586 r = t; rlen = tlen; rend = tend;
4757a243
LW		 2587 }
2588 if (!squash) {
2589 if (to_utf && from_utf) { /* only counting characters */
2590 if (t == r || (tlen == rlen && memEQ(t, r, tlen)))
2591 o->op_private |= OPpTRANS_IDENTICAL;
2592 }
2593 else { /* straight latin-1 translation */
2594 if (tlen == 4 && memEQ(t, "\0\377\303\277", 4) &&
2595 rlen == 4 && memEQ(r, "\0\377\303\277", 4))
2596 o->op_private |= OPpTRANS_IDENTICAL;
2597 }
a0ed51b3
LW		 2598 }
2599
2600 while (t < tend || tfirst <= tlast) {
2601 /* see if we need more "t" chars */
2602 if (tfirst > tlast) {
2603 tfirst = (I32)utf8_to_uv(t, &ulen);
2604 t += ulen;
2605 if (t < tend && *t == 0xff) { /* illegal utf8 val indicates range */
2606 tlast = (I32)utf8_to_uv(++t, &ulen);
2607 t += ulen;
2608 }
2609 else
2610 tlast = tfirst;
2611 }
2612
2613 /* now see if we need more "r" chars */
2614 if (rfirst > rlast) {
2615 if (r < rend) {
2616 rfirst = (I32)utf8_to_uv(r, &ulen);
2617 r += ulen;
2618 if (r < rend && *r == 0xff) { /* illegal utf8 val indicates range */
2619 rlast = (I32)utf8_to_uv(++r, &ulen);
2620 r += ulen;
2621 }
2622 else
2623 rlast = rfirst;
2624 }
2625 else {
2626 if (!havefinal++)
2627 final = rlast;
2628 rfirst = rlast = 0xffffffff;
2629 }
2630 }
2631
2632 /* now see which range will peter our first, if either. */
2633 tdiff = tlast - tfirst;
2634 rdiff = rlast - rfirst;
2635
2636 if (tdiff <= rdiff)
2637 diff = tdiff;
2638 else
2639 diff = rdiff;
2640
2641 if (rfirst == 0xffffffff) {
2642 diff = tdiff; /* oops, pretend rdiff is infinite */
2643 if (diff > 0)
cea2e8a9 2644 Perl_sv_catpvf(aTHX_ listsv, "%04x\t%04x\tXXXX\n", tfirst, tlast);
a0ed51b3 2645 else
cea2e8a9 2646 Perl_sv_catpvf(aTHX_ listsv, "%04x\t\tXXXX\n", tfirst);
a0ed51b3
LW		 2647 }
2648 else {
2649 if (diff > 0)
cea2e8a9 2650 Perl_sv_catpvf(aTHX_ listsv, "%04x\t%04x\t%04x\n", tfirst, tfirst + diff, rfirst);
a0ed51b3 2651 else
cea2e8a9 2652 Perl_sv_catpvf(aTHX_ listsv, "%04x\t\t%04x\n", tfirst, rfirst);
a0ed51b3
LW		 2653
2654 if (rfirst + diff > max)
2655 max = rfirst + diff;
2656 rfirst += diff + 1;
2657 if (!grows) {
2658 if (rfirst <= 0x80)
2659 ;
2660 else if (rfirst <= 0x800)
2661 grows |= (tfirst < 0x80);
2662 else if (rfirst <= 0x10000)
2663 grows |= (tfirst < 0x800);
2664 else if (rfirst <= 0x200000)
2665 grows |= (tfirst < 0x10000);
2666 else if (rfirst <= 0x4000000)
2667 grows |= (tfirst < 0x200000);
2668 else if (rfirst <= 0x80000000)
2669 grows |= (tfirst < 0x4000000);
2670 }
2671 }
2672 tfirst += diff + 1;
2673 }
2674
2675 none = ++max;
2676 if (del)
2677 del = ++max;
2678
2679 if (max > 0xffff)
2680 bits = 32;
2681 else if (max > 0xff)
2682 bits = 16;
2683 else
2684 bits = 8;
2685
2686 cSVOPo->op_sv = (SV*)swash_init("utf8", "", listsv, bits, none);
2687 SvREFCNT_dec(listsv);
2688 if (transv)
2689 SvREFCNT_dec(transv);
2690
2691 if (!del && havefinal)
2692 (void)hv_store((HV*)SvRV((cSVOPo->op_sv)), "FINAL", 5, newSViv((IV)final), 0);
2693
2694 if (grows && to_utf)
2695 o->op_private |= OPpTRANS_GROWS;
2696
2697 op_free(expr);
2698 op_free(repl);
2699 return o;
2700 }
2701
2702 tbl = (short*)cPVOPo->op_pv;
79072805
LW		 2703 if (complement) {
2704 Zero(tbl, 256, short);
2705 for (i = 0; i < tlen; i++)
ec49126f 2706 tbl[t[i]] = -1;
79072805
LW		 2707 for (i = 0, j = 0; i < 256; i++) {
2708 if (!tbl[i]) {
2709 if (j >= rlen) {
a0ed51b3 2710 if (del)
79072805
LW		 2711 tbl[i] = -2;
2712 else if (rlen)
ec49126f 2713 tbl[i] = r[j-1];
79072805
LW		 2714 else
2715 tbl[i] = i;
2716 }
2717 else
ec49126f 2718 tbl[i] = r[j++];
79072805
LW		 2719 }
2720 }
2721 }
2722 else {
a0ed51b3 2723 if (!rlen && !del) {
79072805 2724 r = t; rlen = tlen;
5d06d08e 2725 if (!squash)
4757a243 2726 o->op_private |= OPpTRANS_IDENTICAL;
79072805
LW		 2727 }
2728 for (i = 0; i < 256; i++)
2729 tbl[i] = -1;
2730 for (i = 0, j = 0; i < tlen; i++,j++) {
2731 if (j >= rlen) {
a0ed51b3 2732 if (del) {
ec49126f 2733 if (tbl[t[i]] == -1)
2734 tbl[t[i]] = -2;
79072805
LW		 2735 continue;
2736 }
2737 --j;
2738 }
ec49126f 2739 if (tbl[t[i]] == -1)
2740 tbl[t[i]] = r[j];
79072805
LW		 2741 }
2742 }
2743 op_free(expr);
2744 op_free(repl);
2745
11343788 2746 return o;
79072805
LW		 2747}
2748
2749OP *
864dbfa3 2750Perl_newPMOP(pTHX_ I32 type, I32 flags)
79072805 2751{
11343788 2752 dTHR;
79072805
LW		 2753 PMOP *pmop;
2754
b7dc083c 2755 NewOp(1101, pmop, 1, PMOP);
79072805 2756 pmop->op_type = type;
22c35a8c 2757 pmop->op_ppaddr = PL_ppaddr[type];
79072805 2758 pmop->op_flags = flags;
c07a80fd 2759 pmop->op_private = 0 | (flags >> 8);
79072805 2760
3280af22 2761 if (PL_hints & HINT_RE_TAINT)
b3eb6a9b 2762 pmop->op_pmpermflags |= PMf_RETAINT;
3280af22 2763 if (PL_hints & HINT_LOCALE)
b3eb6a9b
GS		 2764 pmop->op_pmpermflags |= PMf_LOCALE;
2765 pmop->op_pmflags = pmop->op_pmpermflags;
36477c24 2766
79072805 2767 /* link into pm list */
3280af22
NIS		 2768 if (type != OP_TRANS && PL_curstash) {
2769 pmop->op_pmnext = HvPMROOT(PL_curstash);
2770 HvPMROOT(PL_curstash) = pmop;
79072805
LW		 2771 }
2772
2773 return (OP*)pmop;
2774}
2775
2776OP *
864dbfa3 2777Perl_pmruntime(pTHX_ OP *o, OP *expr, OP *repl)
79072805 2778{
5c0ca799 2779 dTHR;
79072805
LW		 2780 PMOP *pm;
2781 LOGOP *rcop;
ce862d02 2782 I32 repl_has_vars = 0;
79072805 2783
11343788
MB		 2784 if (o->op_type == OP_TRANS)
2785 return pmtrans(o, expr, repl);
79072805 2786
3280af22 2787 PL_hints |= HINT_BLOCK_SCOPE;
11343788 2788 pm = (PMOP*)o;
79072805
LW		 2789
2790 if (expr->op_type == OP_CONST) {
463ee0b2 2791 STRLEN plen;
79072805 2792 SV *pat = ((SVOP*)expr)->op_sv;
463ee0b2 2793 char *p = SvPV(pat, plen);
11343788 2794 if ((o->op_flags & OPf_SPECIAL) && strEQ(p, " ")) {
93a17b20 2795 sv_setpvn(pat, "\\s+", 3);
463ee0b2 2796 p = SvPV(pat, plen);
79072805
LW		 2797 pm->op_pmflags |= PMf_SKIPWHITE;
2798 }
cea2e8a9 2799 pm->op_pmregexp = CALLREGCOMP(aTHX_ p, p + plen, pm);
aeea060c 2800 if (strEQ("\\s+", pm->op_pmregexp->precomp))
85e6fe83 2801 pm->op_pmflags |= PMf_WHITE;
79072805
LW		 2802 op_free(expr);
2803 }
2804 else {
3280af22
NIS		 2805 if (pm->op_pmflags & PMf_KEEP || !(PL_hints & HINT_RE_EVAL))
2806 expr = newUNOP((!(PL_hints & HINT_RE_EVAL)
2cd61cdb
IZ		 2807 ? OP_REGCRESET
2808 : OP_REGCMAYBE),0,expr);
463ee0b2 2809
b7dc083c 2810 NewOp(1101, rcop, 1, LOGOP);
79072805 2811 rcop->op_type = OP_REGCOMP;
22c35a8c 2812 rcop->op_ppaddr = PL_ppaddr[OP_REGCOMP];
79072805 2813 rcop->op_first = scalar(expr);
3280af22 2814 rcop->op_flags |= ((PL_hints & HINT_RE_EVAL)
2cd61cdb
IZ		 2815 ? (OPf_SPECIAL | OPf_KIDS)
2816 : OPf_KIDS);
79072805 2817 rcop->op_private = 1;
11343788 2818 rcop->op_other = o;
79072805
LW		 2819
2820 /* establish postfix order */
3280af22 2821 if (pm->op_pmflags & PMf_KEEP || !(PL_hints & HINT_RE_EVAL)) {
463ee0b2
LW		 2822 LINKLIST(expr);
2823 rcop->op_next = expr;
2824 ((UNOP*)expr)->op_first->op_next = (OP*)rcop;
2825 }
2826 else {
2827 rcop->op_next = LINKLIST(expr);
2828 expr->op_next = (OP*)rcop;
2829 }
79072805 2830
11343788 2831 prepend_elem(o->op_type, scalar((OP*)rcop), o);
79072805
LW		 2832 }
2833
2834 if (repl) {
748a9306 2835 OP *curop;
0244c3a4 2836 if (pm->op_pmflags & PMf_EVAL) {
748a9306 2837 curop = 0;
57843af0
GS		 2838 if (CopLINE(PL_curcop) < PL_multi_end)
2839 CopLINE_set(PL_curcop, PL_multi_end);
0244c3a4 2840 }
554b3eca 2841#ifdef USE_THREADS
2faa37cc 2842 else if (repl->op_type == OP_THREADSV
554b3eca 2843 && strchr("&`'123456789+",
533c011a 2844 PL_threadsv_names[repl->op_targ]))
554b3eca
MB		 2845 {
2846 curop = 0;
2847 }
2848#endif /* USE_THREADS */
748a9306
LW		 2849 else if (repl->op_type == OP_CONST)
2850 curop = repl;
79072805 2851 else {
79072805
LW		 2852 OP *lastop = 0;
2853 for (curop = LINKLIST(repl); curop!=repl; curop = LINKLIST(curop)) {
22c35a8c 2854 if (PL_opargs[curop->op_type] & OA_DANGEROUS) {
554b3eca 2855#ifdef USE_THREADS
ce862d02
IZ		 2856 if (curop->op_type == OP_THREADSV) {
2857 repl_has_vars = 1;
be949f6f 2858 if (strchr("&`'123456789+", curop->op_private))
ce862d02 2859 break;
554b3eca
MB		 2860 }
2861#else
79072805 2862 if (curop->op_type == OP_GV) {
350de78d 2863 GV *gv = cGVOPx(curop);
ce862d02 2864 repl_has_vars = 1;
93a17b20 2865 if (strchr("&`'123456789+", *GvENAME(gv)))
79072805
LW		 2866 break;
2867 }
554b3eca 2868#endif /* USE_THREADS */
79072805
LW		 2869 else if (curop->op_type == OP_RV2CV)
2870 break;
2871 else if (curop->op_type == OP_RV2SV ||
2872 curop->op_type == OP_RV2AV ||
2873 curop->op_type == OP_RV2HV ||
2874 curop->op_type == OP_RV2GV) {
2875 if (lastop && lastop->op_type != OP_GV) /*funny deref?*/
2876 break;
2877 }
748a9306
LW		 2878 else if (curop->op_type == OP_PADSV ||
2879 curop->op_type == OP_PADAV ||
2880 curop->op_type == OP_PADHV ||
554b3eca 2881 curop->op_type == OP_PADANY) {
ce862d02 2882 repl_has_vars = 1;
748a9306 2883 }
1167e5da
SM		 2884 else if (curop->op_type == OP_PUSHRE)
2885 ; /* Okay here, dangerous in newASSIGNOP */
79072805
LW		 2886 else
2887 break;
2888 }
2889 lastop = curop;
2890 }
748a9306 2891 }
ce862d02
IZ		 2892 if (curop == repl
2893 && !(repl_has_vars
2894 && (!pm->op_pmregexp
2895 || pm->op_pmregexp->reganch & ROPT_EVAL_SEEN))) {
748a9306 2896 pm->op_pmflags |= PMf_CONST; /* const for long enough */
4633a7c4 2897 pm->op_pmpermflags |= PMf_CONST; /* const for long enough */
11343788 2898 prepend_elem(o->op_type, scalar(repl), o);
748a9306
LW		 2899 }
2900 else {
ce862d02
IZ		 2901 if (curop == repl && !pm->op_pmregexp) { /* Has variables. */
2902 pm->op_pmflags |= PMf_MAYBE_CONST;
2903 pm->op_pmpermflags |= PMf_MAYBE_CONST;
2904 }
b7dc083c 2905 NewOp(1101, rcop, 1, LOGOP);
748a9306 2906 rcop->op_type = OP_SUBSTCONT;
22c35a8c 2907 rcop->op_ppaddr = PL_ppaddr[OP_SUBSTCONT];
748a9306
LW		 2908 rcop->op_first = scalar(repl);
2909 rcop->op_flags |= OPf_KIDS;
2910 rcop->op_private = 1;
11343788 2911 rcop->op_other = o;
748a9306
LW		 2912
2913 /* establish postfix order */
2914 rcop->op_next = LINKLIST(repl);
2915 repl->op_next = (OP*)rcop;
2916
2917 pm->op_pmreplroot = scalar((OP*)rcop);
2918 pm->op_pmreplstart = LINKLIST(rcop);
2919 rcop->op_next = 0;
79072805
LW		 2920 }
2921 }
2922
2923 return (OP*)pm;
2924}
2925
2926OP *
864dbfa3 2927Perl_newSVOP(pTHX_ I32 type, I32 flags, SV *sv)
79072805
LW		 2928{
2929 SVOP *svop;
b7dc083c 2930 NewOp(1101, svop, 1, SVOP);
79072805 2931 svop->op_type = type;
22c35a8c 2932 svop->op_ppaddr = PL_ppaddr[type];
79072805
LW		 2933 svop->op_sv = sv;
2934 svop->op_next = (OP*)svop;
2935 svop->op_flags = flags;
22c35a8c 2936 if (PL_opargs[type] & OA_RETSCALAR)
463ee0b2 2937 scalar((OP*)svop);
22c35a8c 2938 if (PL_opargs[type] & OA_TARGET)
ed6116ce 2939 svop->op_targ = pad_alloc(type, SVs_PADTMP);
e50aee73 2940 return CHECKOP(type, svop);
79072805
LW		 2941}
2942
2943OP *
350de78d
GS		 2944Perl_newPADOP(pTHX_ I32 type, I32 flags, SV *sv)
2945{
2946 PADOP *padop;
2947 NewOp(1101, padop, 1, PADOP);
2948 padop->op_type = type;
2949 padop->op_ppaddr = PL_ppaddr[type];
2950 padop->op_padix = pad_alloc(type, SVs_PADTMP);
2951 PL_curpad[padop->op_padix] = sv;
2952 padop->op_next = (OP*)padop;
2953 padop->op_flags = flags;
2954 if (PL_opargs[type] & OA_RETSCALAR)
2955 scalar((OP*)padop);
2956 if (PL_opargs[type] & OA_TARGET)
2957 padop->op_targ = pad_alloc(type, SVs_PADTMP);
2958 return CHECKOP(type, padop);
2959}
2960
2961OP *
864dbfa3 2962Perl_newGVOP(pTHX_ I32 type, I32 flags, GV *gv)
79072805 2963{
11343788 2964 dTHR;
350de78d 2965#ifdef USE_ITHREADS
743e66e6 2966 GvIN_PAD_on(gv);
350de78d
GS		 2967 return newPADOP(type, flags, SvREFCNT_inc(gv));
2968#else
7934575e 2969 return newSVOP(type, flags, SvREFCNT_inc(gv));
350de78d 2970#endif
79072805
LW		 2971}
2972
2973OP *
864dbfa3 2974Perl_newPVOP(pTHX_ I32 type, I32 flags, char *pv)
79072805
LW		 2975{
2976 PVOP *pvop;
b7dc083c 2977 NewOp(1101, pvop, 1, PVOP);
79072805 2978 pvop->op_type = type;
22c35a8c 2979 pvop->op_ppaddr = PL_ppaddr[type];
79072805
LW		 2980 pvop->op_pv = pv;
2981 pvop->op_next = (OP*)pvop;
2982 pvop->op_flags = flags;
22c35a8c 2983 if (PL_opargs[type] & OA_RETSCALAR)
463ee0b2 2984 scalar((OP*)pvop);
22c35a8c 2985 if (PL_opargs[type] & OA_TARGET)
ed6116ce 2986 pvop->op_targ = pad_alloc(type, SVs_PADTMP);
e50aee73 2987 return CHECKOP(type, pvop);
79072805
LW		 2988}
2989
79072805 2990void
864dbfa3 2991Perl_package(pTHX_ OP *o)
79072805 2992{
11343788 2993 dTHR;
93a17b20 2994 SV *sv;
79072805 2995
3280af22
NIS		 2996 save_hptr(&PL_curstash);
2997 save_item(PL_curstname);
11343788 2998 if (o) {
463ee0b2
LW		 2999 STRLEN len;
3000 char *name;
11343788 3001 sv = cSVOPo->op_sv;
463ee0b2 3002 name = SvPV(sv, len);
3280af22
NIS		 3003 PL_curstash = gv_stashpvn(name,len,TRUE);
3004 sv_setpvn(PL_curstname, name, len);
11343788 3005 op_free(o);
93a17b20
LW		 3006 }
3007 else {
3280af22
NIS		 3008 sv_setpv(PL_curstname,"<none>");
3009 PL_curstash = Nullhv;
93a17b20 3010 }
7ad382f4 3011 PL_hints |= HINT_BLOCK_SCOPE;
3280af22
NIS		 3012 PL_copline = NOLINE;
3013 PL_expect = XSTATE;
79072805
LW		 3014}
3015
85e6fe83 3016void
864dbfa3 3017Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *id, OP *arg)
85e6fe83 3018{
a0d0e21e
LW		 3019 OP *pack;
3020 OP *meth;
3021 OP *rqop;
3022 OP *imop;
b1cb66bf 3023 OP *veop;
78ca652e 3024 GV *gv;
85e6fe83 3025
a0d0e21e 3026 if (id->op_type != OP_CONST)
cea2e8a9 3027 Perl_croak(aTHX_ "Module name must be constant");
85e6fe83 3028
b1cb66bf 3029 veop = Nullop;
3030
3031 if(version != Nullop) {
3032 SV *vesv = ((SVOP*)version)->op_sv;
3033
3034 if (arg == Nullop && !SvNIOK(vesv)) {
3035 arg = version;
3036 }
3037 else {
3038 OP *pack;
b1cb66bf 3039
3040 if (version->op_type != OP_CONST || !SvNIOK(vesv))
cea2e8a9 3041 Perl_croak(aTHX_ "Version number must be constant number");
b1cb66bf 3042
3043 /* Make copy of id so we don't free it twice */
3044 pack = newSVOP(OP_CONST, 0, newSVsv(((SVOP*)id)->op_sv));
3045
3046 /* Fake up a method call to VERSION */
b1cb66bf 3047 veop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
3048 append_elem(OP_LIST,
3049 prepend_elem(OP_LIST, pack, list(version)),
f5d5a27c
CS		 3050 newSVOP(OP_METHOD_NAMED, 0,
3051 newSVpvn("VERSION", 7))));
b1cb66bf 3052 }
3053 }
aeea060c 3054
a0d0e21e 3055 /* Fake up an import/unimport */
4633a7c4
LW		 3056 if (arg && arg->op_type == OP_STUB)
3057 imop = arg; /* no import on explicit () */
b1cb66bf 3058 else if(SvNIOK(((SVOP*)id)->op_sv)) {
3059 imop = Nullop; /* use 5.0; */
3060 }
4633a7c4
LW		 3061 else {
3062 /* Make copy of id so we don't free it twice */
3063 pack = newSVOP(OP_CONST, 0, newSVsv(((SVOP*)id)->op_sv));
4633a7c4 3064 imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
a0d0e21e
LW		 3065 append_elem(OP_LIST,
3066 prepend_elem(OP_LIST, pack, list(arg)),
f5d5a27c
CS		 3067 newSVOP(OP_METHOD_NAMED, 0,
3068 aver ? newSVpvn("import", 6)
3069 : newSVpvn("unimport", 8))));
4633a7c4
LW		 3070 }
3071
78ca652e
GS		 3072 /* Fake up a require, handle override, if any */
3073 gv = gv_fetchpv("require", FALSE, SVt_PVCV);
3074 if (!(gv && GvIMPORTED_CV(gv)))
3075 gv = gv_fetchpv("CORE::GLOBAL::require", FALSE, SVt_PVCV);
3076
3077 if (gv && GvIMPORTED_CV(gv)) {
3078 rqop = ck_subr(newUNOP(OP_ENTERSUB, OPf_STACKED,
3079 append_elem(OP_LIST, id,
3080 scalar(newUNOP(OP_RV2CV, 0,
3081 newGVOP(OP_GV, 0,
3082 gv))))));
3083 }
3084 else {
3085 rqop = newUNOP(OP_REQUIRE, 0, id);
3086 }
a0d0e21e
LW		 3087
3088 /* Fake up the BEGIN {}, which does its thing immediately. */
09bef843 3089 newATTRSUB(floor,
79cb57f6 3090 newSVOP(OP_CONST, 0, newSVpvn("BEGIN", 5)),
4633a7c4 3091 Nullop,
09bef843 3092 Nullop,
a0d0e21e 3093 append_elem(OP_LINESEQ,
b1cb66bf 3094 append_elem(OP_LINESEQ,
3095 newSTATEOP(0, Nullch, rqop),
3096 newSTATEOP(0, Nullch, veop)),
a0d0e21e 3097 newSTATEOP(0, Nullch, imop) ));
85e6fe83 3098
c305c6a0 3099 PL_hints |= HINT_BLOCK_SCOPE;
3280af22
NIS		 3100 PL_copline = NOLINE;
3101 PL_expect = XSTATE;
85e6fe83
LW		 3102}
3103
79072805 3104OP *
864dbfa3 3105Perl_dofile(pTHX_ OP *term)
78ca652e
GS		 3106{
3107 OP *doop;
3108 GV *gv;
3109
3110 gv = gv_fetchpv("do", FALSE, SVt_PVCV);
3111 if (!(gv && GvIMPORTED_CV(gv)))
3112 gv = gv_fetchpv("CORE::GLOBAL::do", FALSE, SVt_PVCV);
3113
3114 if (gv && GvIMPORTED_CV(gv)) {
3115 doop = ck_subr(newUNOP(OP_ENTERSUB, OPf_STACKED,
3116 append_elem(OP_LIST, term,
3117 scalar(newUNOP(OP_RV2CV, 0,
3118 newGVOP(OP_GV, 0,
3119 gv))))));
3120 }
3121 else {
3122 doop = newUNOP(OP_DOFILE, 0, scalar(term));
3123 }
3124 return doop;
3125}
3126
3127OP *
864dbfa3 3128Perl_newSLICEOP(pTHX_ I32 flags, OP *subscript, OP *listval)
79072805
LW		 3129{
3130 return newBINOP(OP_LSLICE, flags,
8990e307
LW		 3131 list(force_list(subscript)),
3132 list(force_list(listval)) );
79072805
LW		 3133}
3134
76e3520e 3135STATIC I32
cea2e8a9 3136S_list_assignment(pTHX_ register OP *o)
79072805 3137{
11343788 3138 if (!o)
79072805
LW		 3139 return TRUE;
3140
11343788
MB		 3141 if (o->op_type == OP_NULL && o->op_flags & OPf_KIDS)
3142 o = cUNOPo->op_first;
79072805 3143
11343788 3144 if (o->op_type == OP_COND_EXPR) {
1a67a97c
SM		 3145 I32 t = list_assignment(cLOGOPo->op_first->op_sibling);
3146 I32 f = list_assignment(cLOGOPo->op_first->op_sibling->op_sibling);
79072805
LW		 3147
3148 if (t && f)
3149 return TRUE;
3150 if (t || f)
3151 yyerror("Assignment to both a list and a scalar");
3152 return FALSE;
3153 }
3154
11343788
MB		 3155 if (o->op_type == OP_LIST || o->op_flags & OPf_PARENS ||
3156 o->op_type == OP_RV2AV || o->op_type == OP_RV2HV ||
3157 o->op_type == OP_ASLICE || o->op_type == OP_HSLICE)
79072805
LW		 3158 return TRUE;
3159
11343788 3160 if (o->op_type == OP_PADAV || o->op_type == OP_PADHV)
93a17b20
LW		 3161 return TRUE;
3162
11343788 3163 if (o->op_type == OP_RV2SV)
79072805
LW		 3164 return FALSE;
3165
3166 return FALSE;
3167}
3168
3169OP *
864dbfa3 3170Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right)
79072805 3171{
11343788 3172 OP *o;
79072805 3173
a0d0e21e
LW		 3174 if (optype) {
3175 if (optype == OP_ANDASSIGN || optype == OP_ORASSIGN) {
3176 return newLOGOP(optype, 0,
3177 mod(scalar(left), optype),
3178 newUNOP(OP_SASSIGN, 0, scalar(right)));
3179 }
3180 else {
3181 return newBINOP(optype, OPf_STACKED,
3182 mod(scalar(left), optype), scalar(right));
3183 }
3184 }
3185
79072805 3186 if (list_assignment(left)) {
6ee623d5 3187 dTHR;
3280af22
NIS		 3188 PL_modcount = 0;
3189 PL_eval_start = right; /* Grandfathering $[ assignment here. Bletch.*/
463ee0b2 3190 left = mod(left, OP_AASSIGN);
3280af22
NIS		 3191 if (PL_eval_start)
3192 PL_eval_start = 0;
748a9306 3193 else {
a0d0e21e
LW		 3194 op_free(left);
3195 op_free(right);
3196 return Nullop;
3197 }
11343788 3198 o = newBINOP(OP_AASSIGN, flags,
8990e307
LW		 3199 list(force_list(right)),
3200 list(force_list(left)) );
11343788 3201 o->op_private = 0 | (flags >> 8);
a0d0e21e 3202 if (!(left->op_private & OPpLVAL_INTRO)) {
79072805 3203 OP *curop;
11343788 3204 OP *lastop = o;
3280af22 3205 PL_generation++;
11343788 3206 for (curop = LINKLIST(o); curop != o; curop = LINKLIST(curop)) {
22c35a8c 3207 if (PL_opargs[curop->op_type] & OA_DANGEROUS) {
79072805 3208 if (curop->op_type == OP_GV) {
350de78d 3209 GV *gv = cGVOPx(curop);
3280af22 3210 if (gv == PL_defgv || SvCUR(gv) == PL_generation)
79072805 3211 break;
3280af22 3212 SvCUR(gv) = PL_generation;
79072805 3213 }
748a9306
LW		 3214 else if (curop->op_type == OP_PADSV ||
3215 curop->op_type == OP_PADAV ||
3216 curop->op_type == OP_PADHV ||
3217 curop->op_type == OP_PADANY) {
3280af22 3218 SV **svp = AvARRAY(PL_comppad_name);
8e07c86e 3219 SV *sv = svp[curop->op_targ];
3280af22 3220 if (SvCUR(sv) == PL_generation)
748a9306 3221 break;
3280af22 3222 SvCUR(sv) = PL_generation; /* (SvCUR not used any more) */
748a9306 3223 }
79072805
LW		 3224 else if (curop->op_type == OP_RV2CV)
3225 break;
3226 else if (curop->op_type == OP_RV2SV ||
3227 curop->op_type == OP_RV2AV ||
3228 curop->op_type == OP_RV2HV ||
3229 curop->op_type == OP_RV2GV) {
3230 if (lastop->op_type != OP_GV) /* funny deref? */
3231 break;
3232 }
1167e5da
SM		 3233 else if (curop->op_type == OP_PUSHRE) {
3234 if (((PMOP*)curop)->op_pmreplroot) {
3235 GV *gv = (GV*)((PMOP*)curop)->op_pmreplroot;
3280af22 3236 if (gv == PL_defgv || SvCUR(gv) == PL_generation)
1167e5da 3237 break;
3280af22 3238 SvCUR(gv) = PL_generation;
1167e5da
SM		 3239 }
3240 }
79072805
LW		 3241 else
3242 break;
3243 }
3244 lastop = curop;
3245 }
11343788
MB		 3246 if (curop != o)
3247 o->op_private = OPpASSIGN_COMMON;
79072805 3248 }
c07a80fd 3249 if (right && right->op_type == OP_SPLIT) {
3250 OP* tmpop;
3251 if ((tmpop = ((LISTOP*)right)->op_first) &&
3252 tmpop->op_type == OP_PUSHRE)
3253 {
3254 PMOP *pm = (PMOP*)tmpop;
3255 if (left->op_type == OP_RV2AV &&
3256 !(left->op_private & OPpLVAL_INTRO) &&
11343788 3257 !(o->op_private & OPpASSIGN_COMMON) )
c07a80fd 3258 {
3259 tmpop = ((UNOP*)left)->op_first;
3260 if (tmpop->op_type == OP_GV && !pm->op_pmreplroot) {
971a9dd3
GS		 3261#ifdef USE_ITHREADS
3262 pm->op_pmreplroot = (OP*)cPADOPx(tmpop)->op_padix;
3263 cPADOPx(tmpop)->op_padix = 0; /* steal it */
3264#else
3265 pm->op_pmreplroot = (OP*)cSVOPx(tmpop)->op_sv;
3266 cSVOPx(tmpop)->op_sv = Nullsv; /* steal it */
3267#endif
c07a80fd 3268 pm->op_pmflags |= PMf_ONCE;
11343788 3269 tmpop = cUNOPo->op_first; /* to list (nulled) */
c07a80fd 3270 tmpop = ((UNOP*)tmpop)->op_first; /* to pushmark */
3271 tmpop->op_sibling = Nullop; /* don't free split */
3272 right->op_next = tmpop->op_next; /* fix starting loc */
11343788 3273 op_free(o); /* blow off assign */
54310121 3274 right->op_flags &= ~OPf_WANT;
a5f75d66 3275 /* "I don't know and I don't care." */
c07a80fd 3276 return right;
3277 }
3278 }
3279 else {
3280af22 3280 if (PL_modcount < 10000 &&
c07a80fd 3281 ((LISTOP*)right)->op_last->op_type == OP_CONST)
3282 {
3283 SV *sv = ((SVOP*)((LISTOP*)right)->op_last)->op_sv;
3284 if (SvIVX(sv) == 0)
3280af22 3285 sv_setiv(sv, PL_modcount+1);
c07a80fd 3286 }
3287 }
3288 }
3289 }
11343788 3290 return o;
79072805
LW		 3291 }
3292 if (!right)
3293 right = newOP(OP_UNDEF, 0);
3294 if (right->op_type == OP_READLINE) {
3295 right->op_flags |= OPf_STACKED;
463ee0b2 3296 return newBINOP(OP_NULL, flags, mod(scalar(left), OP_SASSIGN), scalar(right));
79072805 3297 }
a0d0e21e 3298 else {
3280af22 3299 PL_eval_start = right; /* Grandfathering $[ assignment here. Bletch.*/
11343788 3300 o = newBINOP(OP_SASSIGN, flags,
463ee0b2 3301 scalar(right), mod(scalar(left), OP_SASSIGN) );
3280af22
NIS		 3302 if (PL_eval_start)
3303 PL_eval_start = 0;
748a9306 3304 else {
11343788 3305 op_free(o);
a0d0e21e
LW		 3306 return Nullop;
3307 }
3308 }
11343788 3309 return o;
79072805
LW		 3310}
3311
3312OP *
864dbfa3 3313Perl_newSTATEOP(pTHX_ I32 flags, char *label, OP *o)
79072805 3314{
11343788 3315 dTHR;
bbce6d69 3316 U32 seq = intro_my();
79072805
LW		 3317 register COP *cop;
3318
b7dc083c 3319 NewOp(1101, cop, 1, COP);
57843af0 3320 if (PERLDB_LINE && CopLINE(PL_curcop) && PL_curstash != PL_debstash) {
8990e307 3321 cop->op_type = OP_DBSTATE;
22c35a8c 3322 cop->op_ppaddr = PL_ppaddr[ OP_DBSTATE ];
8990e307
LW		 3323 }
3324 else {
3325 cop->op_type = OP_NEXTSTATE;
22c35a8c 3326 cop->op_ppaddr = PL_ppaddr[ OP_NEXTSTATE ];
8990e307 3327 }
79072805 3328 cop->op_flags = flags;
a0ed51b3 3329 cop->op_private = (PL_hints & HINT_UTF8);
ff0cee69 3330#ifdef NATIVE_HINTS
3331 cop->op_private |= NATIVE_HINTS;
3332#endif
e24b16f9 3333 PL_compiling.op_private = cop->op_private;
79072805
LW		 3334 cop->op_next = (OP*)cop;
3335
463ee0b2
LW		 3336 if (label) {
3337 cop->cop_label = label;
3280af22 3338 PL_hints |= HINT_BLOCK_SCOPE;
463ee0b2 3339 }
bbce6d69 3340 cop->cop_seq = seq;
3280af22 3341 cop->cop_arybase = PL_curcop->cop_arybase;
0453d815 3342 if (specialWARN(PL_curcop->cop_warnings))
599cee73
PM		 3343 cop->cop_warnings = PL_curcop->cop_warnings ;
3344 else
3345 cop->cop_warnings = newSVsv(PL_curcop->cop_warnings) ;
3346
79072805 3347
3280af22 3348 if (PL_copline == NOLINE)
57843af0 3349 CopLINE_set(cop, CopLINE(PL_curcop));
79072805 3350 else {
57843af0 3351 CopLINE_set(cop, PL_copline);
3280af22 3352 PL_copline = NOLINE;
79072805 3353 }
57843af0
GS		 3354#ifdef USE_ITHREADS
3355 CopFILE_set(cop, CopFILE(PL_curcop)); /* XXXXX share in a pvtable? */
3356#else
cc49e20b 3357 CopFILEGV_set(cop, (GV*)SvREFCNT_inc(CopFILEGV(PL_curcop)));
57843af0 3358#endif
11faa288 3359 CopSTASH_set(cop, PL_curstash);
79072805 3360
3280af22 3361 if (PERLDB_LINE && PL_curstash != PL_debstash) {
cc49e20b 3362 SV **svp = av_fetch(CopFILEAV(PL_curcop), (I32)CopLINE(cop), FALSE);
3280af22 3363 if (svp && *svp != &PL_sv_undef && !SvIOK(*svp)) {
a0d0e21e 3364 (void)SvIOK_on(*svp);
a5f75d66 3365 SvIVX(*svp) = 1;
971a9dd3
GS		 3366#ifndef USE_ITHREADS
3367 /* XXX This nameless kludge interferes with cloning SVs. :-(
3368 * What's more, it seems entirely redundant when considering
3369 * PL_DBsingle exists to do the same thing */
93a17b20 3370 SvSTASH(*svp) = (HV*)cop;
971a9dd3 3371#endif
93a17b20
LW		 3372 }
3373 }
3374
11343788 3375 return prepend_elem(OP_LINESEQ, (OP*)cop, o);
79072805
LW		 3376}
3377
bbce6d69 3378/* "Introduce" my variables to visible status. */
3379U32
864dbfa3 3380Perl_intro_my(pTHX)
bbce6d69 3381{
3382 SV **svp;
3383 SV *sv;
3384 I32 i;
3385
3280af22
NIS		 3386 if (! PL_min_intro_pending)
3387 return PL_cop_seqmax;
bbce6d69 3388
3280af22
NIS		 3389 svp = AvARRAY(PL_comppad_name);
3390 for (i = PL_min_intro_pending; i <= PL_max_intro_pending; i++) {
3391 if ((sv = svp[i]) && sv != &PL_sv_undef && !SvIVX(sv)) {
c53d7c7d 3392 SvIVX(sv) = PAD_MAX; /* Don't know scope end yet. */
65202027 3393 SvNVX(sv) = (NV)PL_cop_seqmax;
bbce6d69 3394 }
3395 }
3280af22
NIS		 3396 PL_min_intro_pending = 0;
3397 PL_comppad_name_fill = PL_max_intro_pending; /* Needn't search higher */
3398 return PL_cop_seqmax++;
bbce6d69 3399}
3400
79072805 3401OP *
864dbfa3 3402Perl_newLOGOP(pTHX_ I32 type, I32 flags, OP *first, OP *other)
79072805 3403{
883ffac3
CS		 3404 return new_logop(type, flags, &first, &other);
3405}
3406
3bd495df 3407STATIC OP *
cea2e8a9 3408S_new_logop(pTHX_ I32 type, I32 flags, OP** firstp, OP** otherp)
883ffac3 3409{
11343788 3410 dTHR;
79072805 3411 LOGOP *logop;
11343788 3412 OP *o;
883ffac3
CS		 3413 OP *first = *firstp;
3414 OP *other = *otherp;
79072805 3415
a0d0e21e
LW		 3416 if (type == OP_XOR) /* Not short circuit, but here by precedence. */
3417 return newBINOP(type, flags, scalar(first), scalar(other));
3418
8990e307 3419 scalarboolean(first);
79072805
LW		 3420 /* optimize "!a && b" to "a || b", and "!a || b" to "a && b" */
3421 if (first->op_type == OP_NOT && (first->op_flags & OPf_SPECIAL)) {
3422 if (type == OP_AND || type == OP_OR) {
3423 if (type == OP_AND)
3424 type = OP_OR;
3425 else
3426 type = OP_AND;
11343788 3427 o = first;
883ffac3 3428 first = *firstp = cUNOPo->op_first;
11343788
MB		 3429 if (o->op_next)
3430 first->op_next = o->op_next;
3431 cUNOPo->op_first = Nullop;
3432 op_free(o);
79072805
LW		 3433 }
3434 }
3435 if (first->op_type == OP_CONST) {
599cee73 3436 if (ckWARN(WARN_PRECEDENCE) && (first->op_private & OPpCONST_BARE))
cea2e8a9 3437 Perl_warner(aTHX_ WARN_PRECEDENCE, "Probable precedence problem on %s",
22c35a8c 3438 PL_op_desc[type]);
79072805
LW		 3439 if ((type == OP_AND) == (SvTRUE(((SVOP*)first)->op_sv))) {
3440 op_free(first);
883ffac3 3441 *firstp = Nullop;
79072805
LW		 3442 return other;
3443 }
3444 else {
3445 op_free(other);
883ffac3 3446 *otherp = Nullop;
79072805
LW		 3447 return first;
3448 }
3449 }
3450 else if (first->op_type == OP_WANTARRAY) {
3451 if (type == OP_AND)
3452 list(other);
3453 else
3454 scalar(other);
3455 }
599cee73 3456 else if (ckWARN(WARN_UNSAFE) && (first->op_flags & OPf_KIDS)) {
a6006777 3457 OP *k1 = ((UNOP*)first)->op_first;
3458 OP *k2 = k1->op_sibling;
3459 OPCODE warnop = 0;
3460 switch (first->op_type)
3461 {
3462 case OP_NULL:
3463 if (k2 && k2->op_type == OP_READLINE
3464 && (k2->op_flags & OPf_STACKED)
55d729e4 3465 && ((k1->op_flags & OPf_WANT) == OPf_WANT_SCALAR))
72b16652 3466 {
a6006777 3467 warnop = k2->op_type;
72b16652 3468 }
a6006777 3469 break;
3470
3471 case OP_SASSIGN:
68dc0745 3472 if (k1->op_type == OP_READDIR
3473 || k1->op_type == OP_GLOB
72b16652 3474 || (k1->op_type == OP_NULL && k1->op_targ == OP_GLOB)
68dc0745 3475 || k1->op_type == OP_EACH)
72b16652
GS		 3476 {
3477 warnop = ((k1->op_type == OP_NULL)
3478 ? k1->op_targ : k1->op_type);
3479 }
a6006777 3480 break;
3481 }
8ebc5c01 3482 if (warnop) {
57843af0
GS		 3483 line_t oldline = CopLINE(PL_curcop);
3484 CopLINE_set(PL_curcop, PL_copline);
cea2e8a9 3485 Perl_warner(aTHX_ WARN_UNSAFE,
599cee73 3486 "Value of %s%s can be \"0\"; test with defined()",
22c35a8c 3487 PL_op_desc[warnop],
68dc0745 3488 ((warnop == OP_READLINE || warnop == OP_GLOB)
3489 ? " construct" : "() operator"));
57843af0 3490 CopLINE_set(PL_curcop, oldline);
8ebc5c01 3491 }
a6006777 3492 }
79072805
LW		 3493
3494 if (!other)
3495 return first;
3496
a0d0e21e
LW		 3497 if (type == OP_ANDASSIGN || type == OP_ORASSIGN)
3498 other->op_private |= OPpASSIGN_BACKWARDS; /* other is an OP_SASSIGN */
3499
b7dc083c 3500 NewOp(1101, logop, 1, LOGOP);
79072805
LW		 3501
3502 logop->op_type = type;
22c35a8c 3503 logop->op_ppaddr = PL_ppaddr[type];
79072805
LW		 3504 logop->op_first = first;
3505 logop->op_flags = flags | OPf_KIDS;
3506 logop->op_other = LINKLIST(other);
c07a80fd 3507 logop->op_private = 1 | (flags >> 8);
79072805
LW		 3508
3509 /* establish postfix order */
3510 logop->op_next = LINKLIST(first);
3511 first->op_next = (OP*)logop;
3512 first->op_sibling = other;
3513
11343788
MB		 3514 o = newUNOP(OP_NULL, 0, (OP*)logop);
3515 other->op_next = o;
79072805 3516
11343788 3517 return o;
79072805
LW		 3518}
3519
3520OP *
864dbfa3 3521Perl_newCONDOP(pTHX_ I32 flags, OP *first, OP *trueop, OP *falseop)
79072805 3522{
11343788 3523 dTHR;
1a67a97c
SM		 3524 LOGOP *logop;
3525 OP *start;
11343788 3526 OP *o;
79072805 3527
b1cb66bf 3528 if (!falseop)
3529 return newLOGOP(OP_AND, 0, first, trueop);
3530 if (!trueop)
3531 return newLOGOP(OP_OR, 0, first, falseop);
79072805 3532
8990e307 3533 scalarboolean(first);
79072805
LW		 3534 if (first->op_type == OP_CONST) {
3535 if (SvTRUE(((SVOP*)first)->op_sv)) {
3536 op_free(first);
b1cb66bf 3537 op_free(falseop);
3538 return trueop;
79072805
LW		 3539 }
3540 else {
3541 op_free(first);
b1cb66bf 3542 op_free(trueop);
3543 return falseop;
79072805
LW		 3544 }
3545 }
3546 else if (first->op_type == OP_WANTARRAY) {
b1cb66bf 3547 list(trueop);
3548 scalar(falseop);
79072805 3549 }
1a67a97c
SM		 3550 NewOp(1101, logop, 1, LOGOP);
3551 logop->op_type = OP_COND_EXPR;
3552 logop->op_ppaddr = PL_ppaddr[OP_COND_EXPR];
3553 logop->op_first = first;
3554 logop->op_flags = flags | OPf_KIDS;
3555 logop->op_private = 1 | (flags >> 8);
3556 logop->op_other = LINKLIST(trueop);
3557 logop->op_next = LINKLIST(falseop);
79072805 3558
79072805
LW		 3559
3560 /* establish postfix order */
1a67a97c
SM		 3561 start = LINKLIST(first);
3562 first->op_next = (OP*)logop;
79072805 3563
b1cb66bf 3564 first->op_sibling = trueop;
3565 trueop->op_sibling = falseop;
1a67a97c 3566 o = newUNOP(OP_NULL, 0, (OP*)logop);
79072805 3567
1a67a97c 3568 trueop->op_next = falseop->op_next = o;
79072805 3569
1a67a97c 3570 o->op_next = start;
11343788 3571 return o;
79072805
LW		 3572}
3573
3574OP *
864dbfa3 3575Perl_newRANGE(pTHX_ I32 flags, OP *left, OP *right)
79072805 3576{
b35b2403 3577 dTHR;
1a67a97c 3578 LOGOP *range;
79072805
LW		 3579 OP *flip;
3580 OP *flop;
1a67a97c 3581 OP *leftstart;
11343788 3582 OP *o;
79072805 3583
1a67a97c 3584 NewOp(1101, range, 1, LOGOP);
79072805 3585
1a67a97c
SM		 3586 range->op_type = OP_RANGE;
3587 range->op_ppaddr = PL_ppaddr[OP_RANGE];
3588 range->op_first = left;
3589 range->op_flags = OPf_KIDS;
3590 leftstart = LINKLIST(left);
3591 range->op_other = LINKLIST(right);
3592 range->op_private = 1 | (flags >> 8);
79072805
LW		 3593
3594 left->op_sibling = right;
3595
1a67a97c
SM		 3596 range->op_next = (OP*)range;
3597 flip = newUNOP(OP_FLIP, flags, (OP*)range);
79072805 3598 flop = newUNOP(OP_FLOP, 0, flip);
11343788 3599 o = newUNOP(OP_NULL, 0, flop);
79072805 3600 linklist(flop);
1a67a97c 3601 range->op_next = leftstart;
79072805
LW		 3602
3603 left->op_next = flip;
3604 right->op_next = flop;
3605
1a67a97c
SM		 3606 range->op_targ = pad_alloc(OP_RANGE, SVs_PADMY);
3607 sv_upgrade(PAD_SV(range->op_targ), SVt_PVNV);
ed6116ce 3608 flip->op_targ = pad_alloc(OP_RANGE, SVs_PADMY);
79072805
LW		 3609 sv_upgrade(PAD_SV(flip->op_targ), SVt_PVNV);
3610
3611 flip->op_private = left->op_type == OP_CONST ? OPpFLIP_LINENUM : 0;
3612 flop->op_private = right->op_type == OP_CONST ? OPpFLIP_LINENUM : 0;
3613
11343788 3614 flip->op_next = o;
79072805 3615 if (!flip->op_private || !flop->op_private)
11343788 3616 linklist(o); /* blow off optimizer unless constant */
79072805 3617
11343788 3618 return o;
79072805
LW		 3619}
3620
3621OP *
864dbfa3 3622Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP *expr, OP *block)
79072805 3623{
11343788 3624 dTHR;
463ee0b2 3625 OP* listop;
11343788 3626 OP* o;
463ee0b2 3627 int once = block && block->op_flags & OPf_SPECIAL &&
a0d0e21e 3628 (block->op_type == OP_ENTERSUB || block->op_type == OP_NULL);
93a17b20 3629
463ee0b2
LW		 3630 if (expr) {
3631 if (once && expr->op_type == OP_CONST && !SvTRUE(((SVOP*)expr)->op_sv))
3632 return block; /* do {} while 0 does once */
fb73857a 3633 if (expr->op_type == OP_READLINE || expr->op_type == OP_GLOB
3634 || (expr->op_type == OP_NULL && expr->op_targ == OP_GLOB)) {
774d564b 3635 expr = newUNOP(OP_DEFINED, 0,
54b9620d 3636 newASSIGNOP(0, newDEFSVOP(), 0, expr) );
55d729e4
GS		 3637 } else if (expr->op_flags & OPf_KIDS) {
3638 OP *k1 = ((UNOP*)expr)->op_first;
3639 OP *k2 = (k1) ? k1->op_sibling : NULL;
3640 switch (expr->op_type) {
3641 case OP_NULL:
3642 if (k2 && k2->op_type == OP_READLINE
3643 && (k2->op_flags & OPf_STACKED)
3644 && ((k1->op_flags & OPf_WANT) == OPf_WANT_SCALAR))
3645 expr = newUNOP(OP_DEFINED, 0, expr);
3646 break;
3647
3648 case OP_SASSIGN:
3649 if (k1->op_type == OP_READDIR
3650 || k1->op_type == OP_GLOB
72b16652 3651 || (k1->op_type == OP_NULL && k1->op_targ == OP_NULL)
55d729e4
GS		 3652 || k1->op_type == OP_EACH)
3653 expr = newUNOP(OP_DEFINED, 0, expr);
3654 break;
3655 }
774d564b 3656 }
463ee0b2 3657 }
93a17b20 3658
8990e307 3659 listop = append_elem(OP_LINESEQ, block, newOP(OP_UNSTACK, 0));
883ffac3 3660 o = new_logop(OP_AND, 0, &expr, &listop);
463ee0b2 3661
883ffac3
CS		 3662 if (listop)
3663 ((LISTOP*)listop)->op_last->op_next = LINKLIST(o);
79072805 3664
11343788
MB		 3665 if (once && o != listop)
3666 o->op_next = ((LOGOP*)cUNOPo->op_first)->op_other;
79072805 3667
11343788
MB		 3668 if (o == listop)
3669 o = newUNOP(OP_NULL, 0, o); /* or do {} while 1 loses outer block */
748a9306 3670
11343788
MB		 3671 o->op_flags |= flags;
3672 o = scope(o);
3673 o->op_flags |= OPf_SPECIAL; /* suppress POPBLOCK curpm restoration*/
3674 return o;
79072805
LW		 3675}
3676
3677OP *
864dbfa3 3678Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP *loop, I32 whileline, OP *expr, OP *block, OP *cont)
79072805 3679{
11343788 3680 dTHR;
79072805
LW		 3681 OP *redo;
3682 OP *next = 0;
3683 OP *listop;
11343788 3684 OP *o;
79072805
LW		 3685 OP *condop;
3686
fb73857a 3687 if (expr && (expr->op_type == OP_READLINE || expr->op_type == OP_GLOB
3688 || (expr->op_type == OP_NULL && expr->op_targ == OP_GLOB))) {
748a9306 3689 expr = newUNOP(OP_DEFINED, 0,
54b9620d 3690 newASSIGNOP(0, newDEFSVOP(), 0, expr) );
55d729e4
GS		 3691 } else if (expr && (expr->op_flags & OPf_KIDS)) {
3692 OP *k1 = ((UNOP*)expr)->op_first;
3693 OP *k2 = (k1) ? k1->op_sibling : NULL;
3694 switch (expr->op_type) {
3695 case OP_NULL:
3696 if (k2 && k2->op_type == OP_READLINE
3697 && (k2->op_flags & OPf_STACKED)
3698 && ((k1->op_flags & OPf_WANT) == OPf_WANT_SCALAR))
3699 expr = newUNOP(OP_DEFINED, 0, expr);
3700 break;
3701
3702 case OP_SASSIGN:
3703 if (k1->op_type == OP_READDIR
3704 || k1->op_type == OP_GLOB
72b16652 3705 || (k1->op_type == OP_NULL && k1->op_targ == OP_GLOB)
55d729e4
GS		 3706 || k1->op_type == OP_EACH)
3707 expr = newUNOP(OP_DEFINED, 0, expr);
3708 break;
3709 }
748a9306 3710 }
79072805
LW		 3711
3712 if (!block)
3713 block = newOP(OP_NULL, 0);
3714
3715 if (cont)
3716 next = LINKLIST(cont);
fb73857a 3717 if (expr) {
79072805 3718 cont = append_elem(OP_LINESEQ, cont, newOP(OP_UNSTACK, 0));
fb73857a 3719 if ((line_t)whileline != NOLINE) {
3280af22 3720 PL_copline = whileline;
fb73857a 3721 cont = append_elem(OP_LINESEQ, cont,
3722 newSTATEOP(0, Nullch, Nullop));
3723 }
3724 }
79072805 3725
463ee0b2 3726 listop = append_list(OP_LINESEQ, (LISTOP*)block, (LISTOP*)cont);
79072805
LW		 3727 redo = LINKLIST(listop);
3728
3729 if (expr) {
3280af22 3730 PL_copline = whileline;
883ffac3
CS		 3731 scalar(listop);
3732 o = new_logop(OP_AND, 0, &expr, &listop);
11343788 3733 if (o == expr && o->op_type == OP_CONST && !SvTRUE(cSVOPo->op_sv)) {
85e6fe83 3734 op_free(expr); /* oops, it's a while (0) */
463ee0b2 3735 op_free((OP*)loop);
883ffac3 3736 return Nullop; /* listop already freed by new_logop */
463ee0b2 3737 }
883ffac3
CS		 3738 if (listop)
3739 ((LISTOP*)listop)->op_last->op_next = condop =
3740 (o == listop ? redo : LINKLIST(o));
79072805
LW		 3741 if (!next)
3742 next = condop;
3743 }
3744 else
11343788 3745 o = listop;
79072805
LW		 3746
3747 if (!loop) {
b7dc083c 3748 NewOp(1101,loop,1,LOOP);
79072805 3749 loop->op_type = OP_ENTERLOOP;
22c35a8c 3750 loop->op_ppaddr = PL_ppaddr[OP_ENTERLOOP];
79072805
LW		 3751 loop->op_private = 0;
3752 loop->op_next = (OP*)loop;
3753 }
3754
11343788 3755 o = newBINOP(OP_LEAVELOOP, 0, (OP*)loop, o);
79072805
LW		 3756
3757 loop->op_redoop = redo;
11343788 3758 loop->op_lastop = o;
79072805
LW		 3759
3760 if (next)
3761 loop->op_nextop = next;
3762 else
11343788 3763 loop->op_nextop = o;
79072805 3764
11343788
MB		 3765 o->op_flags |= flags;
3766 o->op_private |= (flags >> 8);
3767 return o;
79072805
LW		 3768}
3769
3770OP *
864dbfa3 3771Perl_newFOROP(pTHX_ I32 flags,char *label,line_t forline,OP *sv,OP *expr,OP *block,OP *cont)
79072805
LW		 3772{
3773 LOOP *loop;
b7dc083c 3774 LOOP *tmp;
fb73857a 3775 OP *wop;
85e6fe83 3776 int padoff = 0;
4633a7c4 3777 I32 iterflags = 0;
79072805 3778
79072805 3779 if (sv) {
85e6fe83 3780 if (sv->op_type == OP_RV2SV) { /* symbol table variable */
748a9306 3781 sv->op_type = OP_RV2GV;
22c35a8c 3782 sv->op_ppaddr = PL_ppaddr[OP_RV2GV];
79072805 3783 }
85e6fe83
LW		 3784 else if (sv->op_type == OP_PADSV) { /* private variable */
3785 padoff = sv->op_targ;
743e66e6 3786 sv->op_targ = 0;
85e6fe83
LW		 3787 op_free(sv);
3788 sv = Nullop;
3789 }
54b9620d
MB		 3790 else if (sv->op_type == OP_THREADSV) { /* per-thread variable */
3791 padoff = sv->op_targ;
743e66e6 3792 sv->op_targ = 0;
54b9620d
MB		 3793 iterflags |= OPf_SPECIAL;
3794 op_free(sv);
3795 sv = Nullop;
3796 }
79072805 3797 else
cea2e8a9 3798 Perl_croak(aTHX_ "Can't use %s for loop variable", PL_op_desc[sv->op_type]);
79072805
LW		 3799 }
3800 else {
54b9620d
MB		 3801#ifdef USE_THREADS
3802 padoff = find_threadsv("_");
3803 iterflags |= OPf_SPECIAL;
3804#else
3280af22 3805 sv = newGVOP(OP_GV, 0, PL_defgv);
54b9620d 3806#endif
79072805 3807 }
5f05dabc 3808 if (expr->op_type == OP_RV2AV || expr->op_type == OP_PADAV) {
89ea2908 3809 expr = mod(force_list(scalar(ref(expr, OP_ITER))), OP_GREPSTART);
4633a7c4
LW		 3810 iterflags |= OPf_STACKED;
3811 }
89ea2908
GA		 3812 else if (expr->op_type == OP_NULL &&
3813 (expr->op_flags & OPf_KIDS) &&
3814 ((BINOP*)expr)->op_first->op_type == OP_FLOP)
3815 {
3816 /* Basically turn for($x..$y) into the same as for($x,$y), but we
3817 * set the STACKED flag to indicate that these values are to be
3818 * treated as min/max values by 'pp_iterinit'.
3819 */
3820 UNOP* flip = (UNOP*)((UNOP*)((BINOP*)expr)->op_first)->op_first;
1a67a97c 3821 LOGOP* range = (LOGOP*) flip->op_first;
89ea2908
GA		 3822 OP* left = range->op_first;
3823 OP* right = left->op_sibling;
5152d7c7 3824 LISTOP* listop;
89ea2908
GA		 3825
3826 range->op_flags &= ~OPf_KIDS;
3827 range->op_first = Nullop;
3828
5152d7c7 3829 listop = (LISTOP*)newLISTOP(OP_LIST, 0, left, right);
1a67a97c
SM		 3830 listop->op_first->op_next = range->op_next;
3831 left->op_next = range->op_other;
5152d7c7
GS		 3832 right->op_next = (OP*)listop;
3833 listop->op_next = listop->op_first;
89ea2908
GA		 3834
3835 op_free(expr);
5152d7c7 3836 expr = (OP*)(listop);
89ea2908
GA		 3837 null(expr);
3838 iterflags |= OPf_STACKED;
3839 }
3840 else {
3841 expr = mod(force_list(expr), OP_GREPSTART);
3842 }
3843
3844
4633a7c4 3845 loop = (LOOP*)list(convert(OP_ENTERITER, iterflags,
89ea2908 3846 append_elem(OP_LIST, expr, scalar(sv))));
85e6fe83 3847 assert(!loop->op_next);
b7dc083c
NIS		 3848#ifdef PL_OP_SLAB_ALLOC
3849 NewOp(1234,tmp,1,LOOP);
3850 Copy(loop,tmp,1,LOOP);
3851 loop = tmp;
3852#else
85e6fe83 3853 Renew(loop, 1, LOOP);
b7dc083c 3854#endif
85e6fe83 3855 loop->op_targ = padoff;
fb73857a 3856 wop = newWHILEOP(flags, 1, loop, forline, newOP(OP_ITER, 0), block, cont);
3280af22 3857 PL_copline = forline;
fb73857a 3858 return newSTATEOP(0, label, wop);
79072805
LW		 3859}
3860
8990e307 3861OP*
864dbfa3 3862Perl_newLOOPEX(pTHX_ I32 type, OP *label)
8990e307 3863{
11343788
MB		 3864 dTHR;
3865 OP *o;
2d8e6c8d
GS		 3866 STRLEN n_a;
3867
8990e307 3868 if (type != OP_GOTO || label->op_type == OP_CONST) {
cdaebead
MB		 3869 /* "last()" means "last" */
3870 if (label->op_type == OP_STUB && (label->op_flags & OPf_PARENS))
3871 o = newOP(type, OPf_SPECIAL);
3872 else {
3873 o = newPVOP(type, 0, savepv(label->op_type == OP_CONST
2d8e6c8d 3874 ? SvPVx(((SVOP*)label)->op_sv, n_a)
cdaebead
MB		 3875 : ""));
3876 }
8990e307
LW		 3877 op_free(label);
3878 }
3879 else {
a0d0e21e
LW		 3880 if (label->op_type == OP_ENTERSUB)
3881 label = newUNOP(OP_REFGEN, 0, mod(label, OP_REFGEN));
11343788 3882 o = newUNOP(type, OPf_STACKED, label);
8990e307 3883 }
3280af22 3884 PL_hints |= HINT_BLOCK_SCOPE;
11343788 3885 return o;
8990e307
LW		 3886}
3887
79072805 3888void
864dbfa3 3889Perl_cv_undef(pTHX_ CV *cv)
79072805 3890{
11343788
MB		 3891 dTHR;
3892#ifdef USE_THREADS
e858de61
MB		 3893 if (CvMUTEXP(cv)) {
3894 MUTEX_DESTROY(CvMUTEXP(cv));
3895 Safefree(CvMUTEXP(cv));
3896 CvMUTEXP(cv) = 0;
3897 }
11343788
MB		 3898#endif /* USE_THREADS */
3899
a0d0e21e 3900 if (!CvXSUB(cv) && CvROOT(cv)) {
11343788
MB		 3901#ifdef USE_THREADS
3902 if (CvDEPTH(cv) || (CvOWNER(cv) && CvOWNER(cv) != thr))
cea2e8a9 3903 Perl_croak(aTHX_ "Can't undef active subroutine");
11343788 3904#else
a0d0e21e 3905 if (CvDEPTH(cv))
cea2e8a9 3906 Perl_croak(aTHX_ "Can't undef active subroutine");
11343788 3907#endif /* USE_THREADS */
8990e307 3908 ENTER;
a0d0e21e 3909
3280af22
NIS		 3910 SAVESPTR(PL_curpad);
3911 PL_curpad = 0;
a0d0e21e 3912
a5f75d66 3913 if (!CvCLONED(cv))
748a9306 3914 op_free(CvROOT(cv));
79072805 3915 CvROOT(cv) = Nullop;
8990e307 3916 LEAVE;
79072805 3917 }
1d5db326 3918 SvPOK_off((SV*)cv); /* forget prototype */
44a8e56a 3919 CvFLAGS(cv) = 0;
8e07c86e
AD		 3920 SvREFCNT_dec(CvGV(cv));
3921 CvGV(cv) = Nullgv;
3922 SvREFCNT_dec(CvOUTSIDE(cv));
3923 CvOUTSIDE(cv) = Nullcv;
3924 if (CvPADLIST(cv)) {
8ebc5c01 3925 /* may be during global destruction */
3926 if (SvREFCNT(CvPADLIST(cv))) {
93965878 3927 I32 i = AvFILLp(CvPADLIST(cv));
8ebc5c01 3928 while (i >= 0) {
3929 SV** svp = av_fetch(CvPADLIST(cv), i--, FALSE);
46fc3d4c 3930 SV* sv = svp ? *svp : Nullsv;
3931 if (!sv)
3932 continue;
3280af22
NIS		 3933 if (sv == (SV*)PL_comppad_name)
3934 PL_comppad_name = Nullav;
3935 else if (sv == (SV*)PL_comppad) {
3936 PL_comppad = Nullav;
3937 PL_curpad = Null(SV**);
46fc3d4c 3938 }
3939 SvREFCNT_dec(sv);
8ebc5c01 3940 }
3941 SvREFCNT_dec((SV*)CvPADLIST(cv));
8e07c86e 3942 }
8e07c86e
AD		 3943 CvPADLIST(cv) = Nullav;
3944 }
79072805
LW		 3945}
3946
743e66e6 3947#ifdef DEBUGGING
76e3520e 3948STATIC void
743e66e6 3949S_cv_dump(pTHX_ CV *cv)
5f05dabc 3950{
3951 CV *outside = CvOUTSIDE(cv);
3952 AV* padlist = CvPADLIST(cv);
4fdae800 3953 AV* pad_name;
3954 AV* pad;
3955 SV** pname;
3956 SV** ppad;
5f05dabc 3957 I32 ix;
3958
b900a521
JH		 3959 PerlIO_printf(Perl_debug_log,
3960 "\tCV=0x%"UVxf" (%s), OUTSIDE=0x%"UVxf" (%s)\n",
3961 PTR2UV(cv),
ab50184a 3962 (CvANON(cv) ? "ANON"
6b88bc9c 3963 : (cv == PL_main_cv) ? "MAIN"
33b8ce05 3964 : CvUNIQUE(cv) ? "UNIQUE"
44a8e56a 3965 : CvGV(cv) ? GvNAME(CvGV(cv)) : "UNDEFINED"),
b900a521 3966 PTR2UV(outside),
ab50184a
CS		 3967 (!outside ? "null"
3968 : CvANON(outside) ? "ANON"
6b88bc9c 3969 : (outside == PL_main_cv) ? "MAIN"
07055b4c 3970 : CvUNIQUE(outside) ? "UNIQUE"
44a8e56a 3971 : CvGV(outside) ? GvNAME(CvGV(outside)) : "UNDEFINED"));
5f05dabc 3972
4fdae800 3973 if (!padlist)
3974 return;
3975
3976 pad_name = (AV*)*av_fetch(padlist, 0, FALSE);
3977 pad = (AV*)*av_fetch(padlist, 1, FALSE);
3978 pname = AvARRAY(pad_name);
3979 ppad = AvARRAY(pad);
3980
93965878 3981 for (ix = 1; ix <= AvFILLp(pad_name); ix++) {
5f05dabc 3982 if (SvPOK(pname[ix]))
b900a521
JH		 3983 PerlIO_printf(Perl_debug_log,
3984 "\t%4d. 0x%"UVxf" (%s\"%s\" %"IVdf"-%"IVdf")\n",
3985 ix, PTR2UV(ppad[ix]),
4fdae800 3986 SvFAKE(pname[ix]) ? "FAKE " : "",
3987 SvPVX(pname[ix]),
b900a521
JH		 3988 (IV)I_32(SvNVX(pname[ix])),
3989 SvIVX(pname[ix]));
5f05dabc 3990 }
3991}
743e66e6 3992#endif /* DEBUGGING */
5f05dabc 3993
76e3520e 3994STATIC CV *
cea2e8a9 3995S_cv_clone2(pTHX_ CV *proto, CV *outside)
748a9306 3996{
11343788 3997 dTHR;
748a9306
LW		 3998 AV* av;
3999 I32 ix;
4000 AV* protopadlist = CvPADLIST(proto);
4001 AV* protopad_name = (AV*)*av_fetch(protopadlist, 0, FALSE);
4002 AV* protopad = (AV*)*av_fetch(protopadlist, 1, FALSE);
5f05dabc 4003 SV** pname = AvARRAY(protopad_name);
4004 SV** ppad = AvARRAY(protopad);
93965878
NIS		 4005 I32 fname = AvFILLp(protopad_name);
4006 I32 fpad = AvFILLp(protopad);
748a9306
LW		 4007 AV* comppadlist;
4008 CV* cv;
4009
07055b4c
CS		 4010 assert(!CvUNIQUE(proto));
4011
748a9306 4012 ENTER;
3280af22
NIS		 4013 SAVESPTR(PL_curpad);
4014 SAVESPTR(PL_comppad);
4015 SAVESPTR(PL_comppad_name);
4016 SAVESPTR(PL_compcv);
748a9306 4017
3280af22 4018 cv = PL_compcv = (CV*)NEWSV(1104,0);
fa83b5b6 4019 sv_upgrade((SV *)cv, SvTYPE(proto));
a5f75d66 4020 CvCLONED_on(cv);
5f05dabc 4021 if (CvANON(proto))
4022 CvANON_on(cv);
748a9306 4023
11343788 4024#ifdef USE_THREADS
12ca11f6 4025 New(666, CvMUTEXP(cv), 1, perl_mutex);
11343788 4026 MUTEX_INIT(CvMUTEXP(cv));
11343788
MB		 4027 CvOWNER(cv) = 0;
4028#endif /* USE_THREADS */
57843af0 4029 CvFILE(cv) = CvFILE(proto);
44a8e56a 4030 CvGV(cv) = (GV*)SvREFCNT_inc(CvGV(proto));
748a9306
LW		 4031 CvSTASH(cv) = CvSTASH(proto);
4032 CvROOT(cv) = CvROOT(proto);
4033 CvSTART(cv) = CvSTART(proto);
5f05dabc 4034 if (outside)
4035 CvOUTSIDE(cv) = (CV*)SvREFCNT_inc(outside);
748a9306 4036
68dc0745 4037 if (SvPOK(proto))
4038 sv_setpvn((SV*)cv, SvPVX(proto), SvCUR(proto));
4039
3280af22 4040 PL_comppad_name = newAV();
46fc3d4c 4041 for (ix = fname; ix >= 0; ix--)
3280af22 4042 av_store(PL_comppad_name, ix, SvREFCNT_inc(pname[ix]));
748a9306 4043
3280af22 4044 PL_comppad = newAV();
748a9306
LW		 4045
4046 comppadlist = newAV();
4047 AvREAL_off(comppadlist);
3280af22
NIS		 4048 av_store(comppadlist, 0, (SV*)PL_comppad_name);
4049 av_store(comppadlist, 1, (SV*)PL_comppad);
748a9306 4050 CvPADLIST(cv) = comppadlist;
3280af22
NIS		 4051 av_fill(PL_comppad, AvFILLp(protopad));
4052 PL_curpad = AvARRAY(PL_comppad);
748a9306
LW		 4053
4054 av = newAV(); /* will be @_ */
4055 av_extend(av, 0);
3280af22 4056 av_store(PL_comppad, 0, (SV*)av);
748a9306
LW		 4057 AvFLAGS(av) = AVf_REIFY;
4058
9607fc9c 4059 for (ix = fpad; ix > 0; ix--) {
4060 SV* namesv = (ix <= fname) ? pname[ix] : Nullsv;
3280af22 4061 if (namesv && namesv != &PL_sv_undef) {
aa689395 4062 char *name = SvPVX(namesv); /* XXX */
4063 if (SvFLAGS(namesv) & SVf_FAKE) { /* lexical from outside? */
4064 I32 off = pad_findlex(name, ix, SvIVX(namesv),
2680586e 4065 CvOUTSIDE(cv), cxstack_ix, 0, 0);
5f05dabc 4066 if (!off)
3280af22 4067 PL_curpad[ix] = SvREFCNT_inc(ppad[ix]);
5f05dabc 4068 else if (off != ix)
cea2e8a9 4069 Perl_croak(aTHX_ "panic: cv_clone: %s", name);
748a9306
LW		 4070 }
4071 else { /* our own lexical */
aa689395 4072 SV* sv;
5f05dabc 4073 if (*name == '&') {
4074 /* anon code -- we'll come back for it */
4075 sv = SvREFCNT_inc(ppad[ix]);
4076 }
4077 else if (*name == '@')
4078 sv = (SV*)newAV();
748a9306 4079 else if (*name == '%')
5f05dabc 4080 sv = (SV*)newHV();
748a9306 4081 else
5f05dabc 4082 sv = NEWSV(0,0);
4083 if (!SvPADBUSY(sv))
4084 SvPADMY_on(sv);
3280af22 4085 PL_curpad[ix] = sv;
748a9306
LW		 4086 }
4087 }
743e66e6
GS		 4088 else if (IS_PADGV(ppad[ix])) {
4089 PL_curpad[ix] = SvREFCNT_inc(ppad[ix]);
4090 }
748a9306 4091 else {
aa689395 4092 SV* sv = NEWSV(0,0);
748a9306 4093 SvPADTMP_on(sv);
3280af22 4094 PL_curpad[ix] = sv;
748a9306
LW		 4095 }
4096 }
4097
5f05dabc 4098 /* Now that vars are all in place, clone nested closures. */
4099
9607fc9c 4100 for (ix = fpad; ix > 0; ix--) {
4101 SV* namesv = (ix <= fname) ? pname[ix] : Nullsv;
aa689395 4102 if (namesv
3280af22 4103 && namesv != &PL_sv_undef
aa689395 4104 && !(SvFLAGS(namesv) & SVf_FAKE)
4105 && *SvPVX(namesv) == '&'
5f05dabc 4106 && CvCLONE(ppad[ix]))
4107 {
4108 CV *kid = cv_clone2((CV*)ppad[ix], cv);
4109 SvREFCNT_dec(ppad[ix]);
4110 CvCLONE_on(kid);
4111 SvPADMY_on(kid);
3280af22 4112 PL_curpad[ix] = (SV*)kid;
748a9306
LW		 4113 }
4114 }
4115
5f05dabc 4116#ifdef DEBUG_CLOSURES
ab50184a
CS		 4117 PerlIO_printf(Perl_debug_log, "Cloned inside:\n");
4118 cv_dump(outside);
4119 PerlIO_printf(Perl_debug_log, " from:\n");
5f05dabc 4120 cv_dump(proto);
ab50184a 4121 PerlIO_printf(Perl_debug_log, " to:\n");
5f05dabc 4122 cv_dump(cv);
4123#endif
4124
748a9306
LW		 4125 LEAVE;
4126 return cv;
4127}
4128
4129CV *
864dbfa3 4130Perl_cv_clone(pTHX_ CV *proto)
5f05dabc 4131{
b099ddc0
GS		 4132 CV *cv;
4133 MUTEX_LOCK(&PL_cred_mutex); /* XXX create separate mutex */
4134 cv = cv_clone2(proto, CvOUTSIDE(proto));
4135 MUTEX_UNLOCK(&PL_cred_mutex); /* XXX create separate mutex */
4136 return cv;
5f05dabc 4137}
4138
3fe9a6f1 4139void
864dbfa3 4140Perl_cv_ckproto(pTHX_ CV *cv, GV *gv, char *p)
3fe9a6f1 4141{
0453d815
PM		 4142 dTHR;
4143
f248d071 4144 if (((!p != !SvPOK(cv)) || (p && strNE(p, SvPVX(cv)))) && ckWARN_d(WARN_UNSAFE)) {
46fc3d4c 4145 SV* msg = sv_newmortal();
3fe9a6f1 4146 SV* name = Nullsv;
4147
4148 if (gv)
46fc3d4c 4149 gv_efullname3(name = sv_newmortal(), gv, Nullch);
4150 sv_setpv(msg, "Prototype mismatch:");
4151 if (name)
cea2e8a9 4152 Perl_sv_catpvf(aTHX_ msg, " sub %_", name);
3fe9a6f1 4153 if (SvPOK(cv))
cea2e8a9 4154 Perl_sv_catpvf(aTHX_ msg, " (%s)", SvPVX(cv));
46fc3d4c 4155 sv_catpv(msg, " vs ");
4156 if (p)
cea2e8a9 4157 Perl_sv_catpvf(aTHX_ msg, "(%s)", p);
46fc3d4c 4158 else
4159 sv_catpv(msg, "none");
0453d815 4160 Perl_warner(aTHX_ WARN_UNSAFE, "%_", msg);
3fe9a6f1 4161 }
4162}
4163
760ac839 4164SV *
864dbfa3 4165Perl_cv_const_sv(pTHX_ CV *cv)
760ac839 4166{
54310121 4167 if (!cv || !SvPOK(cv) || SvCUR(cv))
4168 return Nullsv;
fe5e78ed
GS		 4169 return op_const_sv(CvSTART(cv), cv);
4170}
760ac839 4171
fe5e78ed 4172SV *
864dbfa3 4173Perl_op_const_sv(pTHX_ OP *o, CV *cv)
fe5e78ed
GS		 4174{
4175 SV *sv = Nullsv;
4176
4177 if(!o)
4178 return Nullsv;
4179
4180 if(o->op_type == OP_LINESEQ && cLISTOPo->op_first)
4181 o = cLISTOPo->op_first->op_sibling;
4182
4183 for (; o; o = o->op_next) {
54310121 4184 OPCODE type = o->op_type;
fe5e78ed 4185
acb36ea4 4186 if (sv && o->op_next == o)
fe5e78ed 4187 return sv;
54310121 4188 if (type == OP_NEXTSTATE || type == OP_NULL || type == OP_PUSHMARK)
4189 continue;
4190 if (type == OP_LEAVESUB || type == OP_RETURN)
4191 break;
4192 if (sv)
4193 return Nullsv;
4194 if (type == OP_CONST)
5dc0d613 4195 sv = cSVOPo->op_sv;
fe5e78ed 4196 else if (type == OP_PADSV && cv) {
e858de61
MB		 4197 AV* padav = (AV*)(AvARRAY(CvPADLIST(cv))[1]);
4198 sv = padav ? AvARRAY(padav)[o->op_targ] : Nullsv;
5aabfad6 4199 if (!sv || (!SvREADONLY(sv) && SvREFCNT(sv) > 1))
54310121 4200 return Nullsv;
760ac839 4201 }
54310121 4202 else
4203 return Nullsv;
760ac839 4204 }
5aabfad6 4205 if (sv)
4206 SvREADONLY_on(sv);
760ac839
LW		 4207 return sv;
4208}
4209
09bef843
SB		 4210void
4211Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
4212{
4213 if (o)
4214 SAVEFREEOP(o);
4215 if (proto)
4216 SAVEFREEOP(proto);
4217 if (attrs)
4218 SAVEFREEOP(attrs);
4219 if (block)
4220 SAVEFREEOP(block);
4221 Perl_croak(aTHX_ "\"my sub\" not yet implemented");
4222}
4223
748a9306 4224CV *
864dbfa3 4225Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block)
79072805 4226{
09bef843
SB		 4227 return Perl_newATTRSUB(aTHX_ floor, o, proto, Nullop, block);
4228}
4229
4230CV *
4231Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
4232{
11343788 4233 dTHR;
2d8e6c8d
GS		 4234 STRLEN n_a;
4235 char *name = o ? SvPVx(cSVOPo->op_sv, n_a) : Nullch;
55d729e4 4236 GV *gv = gv_fetchpv(name ? name : "__ANON__",
09bef843
SB		 4237 GV_ADDMULTI | ((block || attrs) ? 0 : GV_NOINIT),
4238 SVt_PVCV);
2d8e6c8d 4239 char *ps = proto ? SvPVx(((SVOP*)proto)->op_sv, n_a) : Nullch;
a2008d6d 4240 register CV *cv=0;
a0d0e21e 4241 I32 ix;
79072805 4242
11343788 4243 if (o)
5dc0d613 4244 SAVEFREEOP(o);
3fe9a6f1 4245 if (proto)
4246 SAVEFREEOP(proto);
09bef843
SB		 4247 if (attrs)
4248 SAVEFREEOP(attrs);
3fe9a6f1 4249
09bef843 4250 if (SvTYPE(gv) != SVt_PVGV) { /* Maybe prototype now, and had at
55d729e4
GS		 4251 maximum a prototype before. */
4252 if (SvTYPE(gv) > SVt_NULL) {
0453d815 4253 if (!SvPOK((SV*)gv) && !(SvIOK((SV*)gv) && SvIVX((SV*)gv) == -1)
f248d071
GS		 4254 && ckWARN_d(WARN_UNSAFE))
4255 {
0453d815 4256 Perl_warner(aTHX_ WARN_UNSAFE, "Runaway prototype");
f248d071 4257 }
55d729e4
GS		 4258 cv_ckproto((CV*)gv, NULL, ps);
4259 }
4260 if (ps)
4261 sv_setpv((SV*)gv, ps);
4262 else
4263 sv_setiv((SV*)gv, -1);
3280af22
NIS		 4264 SvREFCNT_dec(PL_compcv);
4265 cv = PL_compcv = NULL;
4266 PL_sub_generation++;
55d729e4
GS		 4267 goto noblock;
4268 }
4269
68dc0745 4270 if (!name || GvCVGEN(gv))
4271 cv = Nullcv;
4272 else if (cv = GvCV(gv)) {
3fe9a6f1 4273 cv_ckproto(cv, gv, ps);
68dc0745 4274 /* already defined (or promised)? */
4275 if (CvROOT(cv) || CvXSUB(cv) || GvASSUMECV(gv)) {
4276 SV* const_sv;
fe5e78ed 4277 bool const_changed = TRUE;
09bef843 4278 if (!block && !attrs) {
aa689395 4279 /* just a "sub foo;" when &foo is already defined */
3280af22 4280 SAVEFREESV(PL_compcv);
aa689395 4281 goto done;
4282 }
7bac28a0 4283 /* ahem, death to those who redefine active sort subs */
3280af22 4284 if (PL_curstackinfo->si_type == PERLSI_SORT && PL_sortcop == CvSTART(cv))
cea2e8a9 4285 Perl_croak(aTHX_ "Can't redefine active sort subroutine %s", name);
09bef843
SB		 4286 if (!block)
4287 goto withattrs;
fe5e78ed
GS		 4288 if(const_sv = cv_const_sv(cv))
4289 const_changed = sv_cmp(const_sv, op_const_sv(block, Nullcv));
599cee73
PM		 4290 if ((const_sv && const_changed) || ckWARN(WARN_REDEFINE)
4291 && !(CvGV(cv) && GvSTASH(CvGV(cv))
2f34f9d4
IZ		 4292 && HvNAME(GvSTASH(CvGV(cv)))
4293 && strEQ(HvNAME(GvSTASH(CvGV(cv))),
4294 "autouse"))) {
57843af0
GS		 4295 line_t oldline = CopLINE(PL_curcop);
4296 CopLINE_set(PL_curcop, PL_copline);
cea2e8a9 4297 Perl_warner(aTHX_ WARN_REDEFINE,
599cee73 4298 const_sv ? "Constant subroutine %s redefined"
09bef843 4299 : "Subroutine %s redefined", name);
57843af0 4300 CopLINE_set(PL_curcop, oldline);
79072805 4301 }
8990e307 4302 SvREFCNT_dec(cv);
68dc0745 4303 cv = Nullcv;
79072805
LW		 4304 }
4305 }
09bef843
SB		 4306 withattrs:
4307 if (attrs) {
4308 HV *stash;
4309 SV *rcv;
4310
4311 /* Need to do a C<use attributes $stash_of_cv,\&cv,@attrs>
4312 * before we clobber PL_compcv.
4313 */
4314 if (cv && !block) {
4315 rcv = (SV*)cv;
4316 if (CvGV(cv) && GvSTASH(CvGV(cv)) && HvNAME(GvSTASH(CvGV(cv))))
4317 stash = GvSTASH(CvGV(cv));
4318 else if (CvSTASH(cv) && HvNAME(CvSTASH(cv)))
4319 stash = CvSTASH(cv);
4320 else
4321 stash = PL_curstash;
4322 }
4323 else {
4324 /* possibly about to re-define existing subr -- ignore old cv */
4325 rcv = (SV*)PL_compcv;
4326 if (name && GvSTASH(gv) && HvNAME(GvSTASH(gv)))
4327 stash = GvSTASH(gv);
4328 else
4329 stash = PL_curstash;
4330 }
4331 apply_attrs(stash, rcv, attrs);
4332 }
a0d0e21e 4333 if (cv) { /* must reuse cv if autoloaded */
09bef843
SB		 4334 if (!block) {
4335 /* got here with just attrs -- work done, so bug out */
4336 SAVEFREESV(PL_compcv);
4337 goto done;
4338 }
4633a7c4 4339 cv_undef(cv);
3280af22
NIS		 4340 CvFLAGS(cv) = CvFLAGS(PL_compcv);
4341 CvOUTSIDE(cv) = CvOUTSIDE(PL_compcv);
4342 CvOUTSIDE(PL_compcv) = 0;
4343 CvPADLIST(cv) = CvPADLIST(PL_compcv);
4344 CvPADLIST(PL_compcv) = 0;
4345 if (SvREFCNT(PL_compcv) > 1) /* XXX Make closures transit through stub. */
4346 CvOUTSIDE(PL_compcv) = (CV*)SvREFCNT_inc((SV*)cv);
4347 SvREFCNT_dec(PL_compcv);
a0d0e21e
LW		 4348 }
4349 else {
3280af22 4350 cv = PL_compcv;
44a8e56a 4351 if (name) {
4352 GvCV(gv) = cv;
4353 GvCVGEN(gv) = 0;
3280af22 4354 PL_sub_generation++;
44a8e56a 4355 }
a0d0e21e 4356 }
44a8e56a 4357 CvGV(cv) = (GV*)SvREFCNT_inc(gv);
57843af0 4358 CvFILE(cv) = CopFILE(PL_curcop);
3280af22 4359 CvSTASH(cv) = PL_curstash;
11343788
MB		 4360#ifdef USE_THREADS
4361 CvOWNER(cv) = 0;
1cfa4ec7 4362 if (!CvMUTEXP(cv)) {
f6aaf501 4363 New(666, CvMUTEXP(cv), 1, perl_mutex);
1cfa4ec7
GS		 4364 MUTEX_INIT(CvMUTEXP(cv));
4365 }
11343788 4366#endif /* USE_THREADS */
8990e307 4367
3fe9a6f1 4368 if (ps)
4369 sv_setpv((SV*)cv, ps);
4633a7c4 4370
3280af22 4371 if (PL_error_count) {
c07a80fd 4372 op_free(block);
4373 block = Nullop;
68dc0745 4374 if (name) {
4375 char *s = strrchr(name, ':');
4376 s = s ? s+1 : name;
6d4c2119
CS		 4377 if (strEQ(s, "BEGIN")) {
4378 char *not_safe =
4379 "BEGIN not safe after errors--compilation aborted";
faef0170 4380 if (PL_in_eval & EVAL_KEEPERR)
cea2e8a9 4381 Perl_croak(aTHX_ not_safe);
6d4c2119
CS		 4382 else {
4383 /* force display of errors found but not reported */
38a03e6e 4384 sv_catpv(ERRSV, not_safe);
cea2e8a9 4385 Perl_croak(aTHX_ "%s", SvPVx(ERRSV, n_a));
6d4c2119
CS		 4386 }
4387 }
68dc0745 4388 }
c07a80fd 4389 }
a0d0e21e 4390 if (!block) {
55d729e4 4391 noblock:
3280af22 4392 PL_copline = NOLINE;
a0d0e21e
LW		 4393 LEAVE_SCOPE(floor);
4394 return cv;
4395 }
4396
3280af22
NIS		 4397 if (AvFILLp(PL_comppad_name) < AvFILLp(PL_comppad))
4398 av_store(PL_comppad_name, AvFILLp(PL_comppad), Nullsv);
a0d0e21e 4399
54310121 4400 if (CvCLONE(cv)) {
3280af22
NIS		 4401 SV **namep = AvARRAY(PL_comppad_name);
4402 for (ix = AvFILLp(PL_comppad); ix > 0; ix--) {
54310121 4403 SV *namesv;
4404
743e66e6 4405 if (SvIMMORTAL(PL_curpad[ix]) || IS_PADGV(PL_curpad[ix]))
54310121 4406 continue;
4407 /*
4408 * The only things that a clonable function needs in its
4409 * pad are references to outer lexicals and anonymous subs.
4410 * The rest are created anew during cloning.
4411 */
4412 if (!((namesv = namep[ix]) != Nullsv &&
3280af22 4413 namesv != &PL_sv_undef &&
54310121 4414 (SvFAKE(namesv) ||
4415 *SvPVX(namesv) == '&')))
4416 {
3280af22
NIS		 4417 SvREFCNT_dec(PL_curpad[ix]);
4418 PL_curpad[ix] = Nullsv;
54310121 4419 }
4420 }
a0d0e21e 4421 }
54310121 4422 else {
4423 AV *av = newAV(); /* Will be @_ */
4424 av_extend(av, 0);
3280af22 4425 av_store(PL_comppad, 0, (SV*)av);
54310121 4426 AvFLAGS(av) = AVf_REIFY;
79072805 4427
3280af22 4428 for (ix = AvFILLp(PL_comppad); ix > 0; ix--) {
743e66e6 4429 if (SvIMMORTAL(PL_curpad[ix]) || IS_PADGV(PL_curpad[ix]))
54310121 4430 continue;
3280af22
NIS		 4431 if (!SvPADMY(PL_curpad[ix]))
4432 SvPADTMP_on(PL_curpad[ix]);
54310121 4433 }
4434 }
79072805 4435
7934575e 4436 if (CvLVALUE(cv)) {
cd06dffe
GS		 4437 CvROOT(cv) = newUNOP(OP_LEAVESUBLV, 0, scalarseq(block));
4438 }
4439 else {
4440 CvROOT(cv) = newUNOP(OP_LEAVESUB, 0, scalarseq(block));
4441 }
7934575e
GS		 4442 CvROOT(cv)->op_private |= OPpREFCOUNTED;
4443 OpREFCNT_set(CvROOT(cv), 1);
79072805
LW		 4444 CvSTART(cv) = LINKLIST(CvROOT(cv));
4445 CvROOT(cv)->op_next = 0;
4446 peep(CvSTART(cv));
93a17b20 4447
44a8e56a 4448 if (name) {
4449 char *s;
4450
3280af22 4451 if (PERLDB_SUBLINE && PL_curstash != PL_debstash) {
46fc3d4c 4452 SV *sv = NEWSV(0,0);
44a8e56a 4453 SV *tmpstr = sv_newmortal();
549bb64a 4454 GV *db_postponed = gv_fetchpv("DB::postponed", GV_ADDMULTI, SVt_PVHV);
44a8e56a 4455 CV *cv;
4456 HV *hv;
4457
cea2e8a9 4458 Perl_sv_setpvf(aTHX_ sv, "%_:%ld-%ld",
cc49e20b
GS		 4459 CopFILESV(PL_curcop),
4460 (long)PL_subline, (long)CopLINE(PL_curcop));
44a8e56a 4461 gv_efullname3(tmpstr, gv, Nullch);
3280af22 4462 hv_store(GvHV(PL_DBsub), SvPVX(tmpstr), SvCUR(tmpstr), sv, 0);
44a8e56a 4463 hv = GvHVn(db_postponed);
9607fc9c 4464 if (HvFILL(hv) > 0 && hv_exists(hv, SvPVX(tmpstr), SvCUR(tmpstr))
4465 && (cv = GvCV(db_postponed))) {
44a8e56a 4466 dSP;
924508f0 4467 PUSHMARK(SP);
44a8e56a 4468 XPUSHs(tmpstr);
4469 PUTBACK;
864dbfa3 4470 call_sv((SV*)cv, G_DISCARD);
44a8e56a 4471 }
4472 }
79072805 4473
44a8e56a 4474 if ((s = strrchr(name,':')))
28757baa 4475 s++;
4476 else
4477 s = name;
68dc0745 4478 if (strEQ(s, "BEGIN")) {
3280af22 4479 I32 oldscope = PL_scopestack_ix;
28757baa 4480 ENTER;
57843af0
GS		 4481 SAVECOPFILE(&PL_compiling);
4482 SAVECOPLINE(&PL_compiling);
3280af22
NIS		 4483 save_svref(&PL_rs);
4484 sv_setsv(PL_rs, PL_nrs);
28757baa 4485
3280af22
NIS		 4486 if (!PL_beginav)
4487 PL_beginav = newAV();
28757baa 4488 DEBUG_x( dump_sub(gv) );
3280af22 4489 av_push(PL_beginav, (SV *)cv);
28757baa 4490 GvCV(gv) = 0;
3280af22 4491 call_list(oldscope, PL_beginav);
a6006777 4492
3280af22 4493 PL_curcop = &PL_compiling;
a0ed51b3 4494 PL_compiling.op_private = PL_hints;
28757baa 4495 LEAVE;
4496 }
3280af22
NIS		 4497 else if (strEQ(s, "END") && !PL_error_count) {
4498 if (!PL_endav)
4499 PL_endav = newAV();
4500 av_unshift(PL_endav, 1);
4501 av_store(PL_endav, 0, (SV *)cv);
28757baa 4502 GvCV(gv) = 0;
4503 }
4f25aa18
GS		 4504 else if (strEQ(s, "STOP") && !PL_error_count) {
4505 if (!PL_stopav)
4506 PL_stopav = newAV();
4507 av_unshift(PL_stopav, 1);
4508 av_store(PL_stopav, 0, (SV *)cv);
4509 GvCV(gv) = 0;
4510 }
3280af22
NIS		 4511 else if (strEQ(s, "INIT") && !PL_error_count) {
4512 if (!PL_initav)
4513 PL_initav = newAV();
4514 av_push(PL_initav, SvREFCNT_inc(cv));
b7aad4fe 4515 GvCV(gv) = 0;
ae77835f 4516 }
79072805 4517 }
a6006777 4518
aa689395 4519 done:
3280af22 4520 PL_copline = NOLINE;
8990e307 4521 LEAVE_SCOPE(floor);
a0d0e21e 4522 return cv;
79072805
LW		 4523}
4524
b099ddc0 4525/* XXX unsafe for threads if eval_owner isn't held */
5476c433 4526void
864dbfa3 4527Perl_newCONSTSUB(pTHX_ HV *stash, char *name, SV *sv)
5476c433
JD		 4528{
4529 dTHR;
5476c433 4530
11faa288
GS		 4531 ENTER;
4532 SAVECOPLINE(PL_curcop);
4533 SAVEHINTS();
4534
4535 CopLINE_set(PL_curcop, PL_copline);
3280af22 4536 PL_hints &= ~HINT_BLOCK_SCOPE;
11faa288
GS		 4537
4538 if (stash) {
4539 SAVESPTR(PL_curstash);
4540 SAVECOPSTASH(PL_curcop);
4541 PL_curstash = stash;
4542#ifdef USE_ITHREADS
4543 CopSTASHPV(PL_curcop) = stash ? HvNAME(stash) : Nullch;
4544#else
4545 CopSTASH(PL_curcop) = stash;
4546#endif
4547 }
5476c433 4548
09bef843 4549 newATTRSUB(
be24f278 4550 start_subparse(FALSE, 0),
5476c433 4551 newSVOP(OP_CONST, 0, newSVpv(name,0)),
6b88bc9c 4552 newSVOP(OP_CONST, 0, &PL_sv_no), /* SvPV(&PL_sv_no) == "" -- GMB */
09bef843 4553 Nullop,
5476c433
JD		 4554 newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv))
4555 );
4556
11faa288 4557 LEAVE;
5476c433
JD		 4558}
4559
57d3b86d 4560CV *
864dbfa3 4561Perl_newXS(pTHX_ char *name, XSUBADDR_t subaddr, char *filename)
a0d0e21e 4562{
11343788 4563 dTHR;
44a8e56a 4564 GV *gv = gv_fetchpv(name ? name : "__ANON__", GV_ADDMULTI, SVt_PVCV);
79072805 4565 register CV *cv;
44a8e56a 4566
4567 if (cv = (name ? GvCV(gv) : Nullcv)) {
4568 if (GvCVGEN(gv)) {
4569 /* just a cached method */
4570 SvREFCNT_dec(cv);
4571 cv = 0;
4572 }
4573 else if (CvROOT(cv) || CvXSUB(cv) || GvASSUMECV(gv)) {
4574 /* already defined (or promised) */
599cee73 4575 if (ckWARN(WARN_REDEFINE) && !(CvGV(cv) && GvSTASH(CvGV(cv))
2f34f9d4
IZ		 4576 && HvNAME(GvSTASH(CvGV(cv)))
4577 && strEQ(HvNAME(GvSTASH(CvGV(cv))), "autouse"))) {
57843af0 4578 line_t oldline = CopLINE(PL_curcop);
51f6edd3 4579 if (PL_copline != NOLINE)
57843af0 4580 CopLINE_set(PL_curcop, PL_copline);
cea2e8a9 4581 Perl_warner(aTHX_ WARN_REDEFINE, "Subroutine %s redefined",name);
57843af0 4582 CopLINE_set(PL_curcop, oldline);
a0d0e21e
LW		 4583 }
4584 SvREFCNT_dec(cv);
4585 cv = 0;
79072805 4586 }
79072805 4587 }
44a8e56a 4588
4589 if (cv) /* must reuse cv if autoloaded */
4590 cv_undef(cv);
a0d0e21e
LW		 4591 else {
4592 cv = (CV*)NEWSV(1105,0);
4593 sv_upgrade((SV *)cv, SVt_PVCV);
44a8e56a 4594 if (name) {
4595 GvCV(gv) = cv;
4596 GvCVGEN(gv) = 0;
3280af22 4597 PL_sub_generation++;
44a8e56a 4598 }
a0d0e21e 4599 }
5196be3e 4600 CvGV(cv) = (GV*)SvREFCNT_inc(gv);
11343788 4601#ifdef USE_THREADS
12ca11f6 4602 New(666, CvMUTEXP(cv), 1, perl_mutex);
11343788 4603 MUTEX_INIT(CvMUTEXP(cv));
11343788
MB		 4604 CvOWNER(cv) = 0;
4605#endif /* USE_THREADS */
b195d487 4606 (void)gv_fetchfile(filename);
57843af0
GS		 4607 CvFILE(cv) = filename; /* NOTE: not copied, as it is expected to be
4608 an external constant string */
a0d0e21e 4609 CvXSUB(cv) = subaddr;
44a8e56a 4610
28757baa 4611 if (name) {
4612 char *s = strrchr(name,':');
4613 if (s)
4614 s++;
4615 else
4616 s = name;
4617 if (strEQ(s, "BEGIN")) {
3280af22
NIS		 4618 if (!PL_beginav)
4619 PL_beginav = newAV();
4620 av_push(PL_beginav, (SV *)cv);
44a8e56a 4621 GvCV(gv) = 0;
28757baa 4622 }
4623 else if (strEQ(s, "END")) {
3280af22
NIS		 4624 if (!PL_endav)
4625 PL_endav = newAV();
4626 av_unshift(PL_endav, 1);
4627 av_store(PL_endav, 0, (SV *)cv);
44a8e56a 4628 GvCV(gv) = 0;
28757baa 4629 }
4f25aa18
GS		 4630 else if (strEQ(s, "STOP")) {
4631 if (!PL_stopav)
4632 PL_stopav = newAV();
4633 av_unshift(PL_stopav, 1);
4634 av_store(PL_stopav, 0, (SV *)cv);
4635 GvCV(gv) = 0;
4636 }
7d07dbc2 4637 else if (strEQ(s, "INIT")) {
3280af22
NIS		 4638 if (!PL_initav)
4639 PL_initav = newAV();
4640 av_push(PL_initav, (SV *)cv);
f8f842e4 4641 GvCV(gv) = 0;
ae77835f 4642 }
28757baa 4643 }
8990e307 4644 else
a5f75d66 4645 CvANON_on(cv);
44a8e56a 4646
a0d0e21e 4647 return cv;
79072805
LW		 4648}
4649
4650void
864dbfa3 4651Perl_newFORM(pTHX_ I32 floor, OP *o, OP *block)
79072805 4652{
11343788 4653 dTHR;
79072805
LW		 4654 register CV *cv;
4655 char *name;
4656 GV *gv;
a0d0e21e 4657 I32 ix;
2d8e6c8d 4658 STRLEN n_a;
79072805 4659
11343788 4660 if (o)
2d8e6c8d 4661 name = SvPVx(cSVOPo->op_sv, n_a);
79072805
LW		 4662 else
4663 name = "STDOUT";
85e6fe83 4664 gv = gv_fetchpv(name,TRUE, SVt_PVFM);
a5f75d66 4665 GvMULTI_on(gv);
79072805 4666 if (cv = GvFORM(gv)) {
599cee73 4667 if (ckWARN(WARN_REDEFINE)) {
57843af0 4668 line_t oldline = CopLINE(PL_curcop);
79072805 4669
57843af0 4670 CopLINE_set(PL_curcop, PL_copline);
cea2e8a9 4671 Perl_warner(aTHX_ WARN_REDEFINE, "Format %s redefined",name);
57843af0 4672 CopLINE_set(PL_curcop, oldline);
79072805 4673 }
8990e307 4674 SvREFCNT_dec(cv);
79072805 4675 }
3280af22 4676 cv = PL_compcv;
79072805 4677 GvFORM(gv) = cv;
44a8e56a 4678 CvGV(cv) = (GV*)SvREFCNT_inc(gv);
57843af0 4679 CvFILE(cv) = CopFILE(PL_curcop);
79072805 4680
3280af22
NIS		 4681 for (ix = AvFILLp(PL_comppad); ix > 0; ix--) {
4682 if (!SvPADMY(PL_curpad[ix]) && !SvIMMORTAL(PL_curpad[ix]))
4683 SvPADTMP_on(PL_curpad[ix]);
a0d0e21e
LW		 4684 }
4685
79072805 4686 CvROOT(cv) = newUNOP(OP_LEAVEWRITE, 0, scalarseq(block));
7934575e
GS		 4687 CvROOT(cv)->op_private |= OPpREFCOUNTED;
4688 OpREFCNT_set(CvROOT(cv), 1);
79072805
LW		 4689 CvSTART(cv) = LINKLIST(CvROOT(cv));
4690 CvROOT(cv)->op_next = 0;
4691 peep(CvSTART(cv));
11343788 4692 op_free(o);
3280af22 4693 PL_copline = NOLINE;
8990e307 4694 LEAVE_SCOPE(floor);
79072805
LW		 4695}
4696
4697OP *
864dbfa3 4698Perl_newANONLIST(pTHX_ OP *o)
79072805 4699{
93a17b20 4700 return newUNOP(OP_REFGEN, 0,
11343788 4701 mod(list(convert(OP_ANONLIST, 0, o)), OP_REFGEN));
79072805
LW		 4702}
4703
4704OP *
864dbfa3 4705Perl_newANONHASH(pTHX_ OP *o)
79072805 4706{
93a17b20 4707 return newUNOP(OP_REFGEN, 0,
11343788 4708 mod(list(convert(OP_ANONHASH, 0, o)), OP_REFGEN));
a0d0e21e
LW		 4709}
4710
4711OP *
864dbfa3 4712Perl_newANONSUB(pTHX_ I32 floor, OP *proto, OP *block)
a0d0e21e 4713{
09bef843
SB		 4714 return newANONATTRSUB(floor, proto, Nullop, block);
4715}
4716
4717OP *
4718Perl_newANONATTRSUB(pTHX_ I32 floor, OP *proto, OP *attrs, OP *block)
4719{
a0d0e21e 4720 return newUNOP(OP_REFGEN, 0,
09bef843
SB		 4721 newSVOP(OP_ANONCODE, 0,
4722 (SV*)newATTRSUB(floor, 0, proto, attrs, block)));
79072805
LW		 4723}
4724
4725OP *
864dbfa3 4726Perl_oopsAV(pTHX_ OP *o)
79072805 4727{
ed6116ce
LW		 4728 switch (o->op_type) {
4729 case OP_PADSV:
4730 o->op_type = OP_PADAV;
22c35a8c 4731 o->op_ppaddr = PL_ppaddr[OP_PADAV];
51e247a3 4732 return ref(o, OP_RV2AV);
ed6116ce
LW		 4733
4734 case OP_RV2SV:
79072805 4735 o->op_type = OP_RV2AV;
22c35a8c 4736 o->op_ppaddr = PL_ppaddr[OP_RV2AV];
79072805 4737 ref(o, OP_RV2AV);
ed6116ce
LW		 4738 break;
4739
4740 default:
0453d815
PM		 4741 if (ckWARN_d(WARN_INTERNAL))
4742 Perl_warner(aTHX_ WARN_INTERNAL, "oops: oopsAV");
ed6116ce
LW		 4743 break;
4744 }
79072805
LW		 4745 return o;
4746}
4747
4748OP *
864dbfa3 4749Perl_oopsHV(pTHX_ OP *o)
79072805 4750{
0453d815 4751 dTHR;
0453d815 4752
ed6116ce
LW		 4753 switch (o->op_type) {
4754 case OP_PADSV:
4755 case OP_PADAV:
4756 o->op_type = OP_PADHV;
22c35a8c 4757 o->op_ppaddr = PL_ppaddr[OP_PADHV];
51e247a3 4758 return ref(o, OP_RV2HV);
ed6116ce
LW		 4759
4760 case OP_RV2SV:
4761 case OP_RV2AV:
79072805 4762 o->op_type = OP_RV2HV;
22c35a8c 4763 o->op_ppaddr = PL_ppaddr[OP_RV2HV];
79072805 4764 ref(o, OP_RV2HV);
ed6116ce
LW		 4765 break;
4766
4767 default:
0453d815
PM		 4768 if (ckWARN_d(WARN_INTERNAL))
4769 Perl_warner(aTHX_ WARN_INTERNAL, "oops: oopsHV");
ed6116ce
LW		 4770 break;
4771 }
79072805
LW		 4772 return o;
4773}
4774
4775OP *
864dbfa3 4776Perl_newAVREF(pTHX_ OP *o)
79072805 4777{
ed6116ce
LW		 4778 if (o->op_type == OP_PADANY) {
4779 o->op_type = OP_PADAV;
22c35a8c 4780 o->op_ppaddr = PL_ppaddr[OP_PADAV];
93a17b20 4781 return o;
ed6116ce 4782 }
79072805
LW		 4783 return newUNOP(OP_RV2AV, 0, scalar(o));
4784}
4785
4786OP *
864dbfa3 4787Perl_newGVREF(pTHX_ I32 type, OP *o)
79072805 4788{
82092f1d 4789 if (type == OP_MAPSTART || type == OP_GREPSTART || type == OP_SORT)
a0d0e21e 4790 return newUNOP(OP_NULL, 0, o);
748a9306 4791 return ref(newUNOP(OP_RV2GV, OPf_REF, o), type);
79072805
LW		 4792}
4793
4794OP *
864dbfa3 4795Perl_newHVREF(pTHX_ OP *o)
79072805 4796{
ed6116ce
LW		 4797 if (o->op_type == OP_PADANY) {
4798 o->op_type = OP_PADHV;
22c35a8c 4799 o->op_ppaddr = PL_ppaddr[OP_PADHV];
93a17b20 4800 return o;
ed6116ce 4801 }
79072805
LW		 4802 return newUNOP(OP_RV2HV, 0, scalar(o));
4803}
4804
4805OP *
864dbfa3 4806Perl_oopsCV(pTHX_ OP *o)
79072805 4807{
cea2e8a9 4808 Perl_croak(aTHX_ "NOT IMPL LINE %d",__LINE__);
79072805
LW		 4809 /* STUB */
4810 return o;
4811}
4812
4813OP *
864dbfa3 4814Perl_newCVREF(pTHX_ I32 flags, OP *o)
79072805 4815{
c07a80fd 4816 return newUNOP(OP_RV2CV, flags, scalar(o));
79072805
LW		 4817}
4818
4819OP *
864dbfa3 4820Perl_newSVREF(pTHX_ OP *o)
79072805 4821{
ed6116ce
LW		 4822 if (o->op_type == OP_PADANY) {
4823 o->op_type = OP_PADSV;
22c35a8c 4824 o->op_ppaddr = PL_ppaddr[OP_PADSV];
93a17b20 4825 return o;
ed6116ce 4826 }
224a4551
MB		 4827 else if (o->op_type == OP_THREADSV && !(o->op_flags & OPpDONE_SVREF)) {
4828 o->op_flags |= OPpDONE_SVREF;
a863c7d1 4829 return o;
224a4551 4830 }
79072805
LW		 4831 return newUNOP(OP_RV2SV, 0, scalar(o));
4832}
4833
4834/* Check routines. */
4835
4836OP *
cea2e8a9 4837Perl_ck_anoncode(pTHX_ OP *o)
5f05dabc 4838{
178c6305
CS		 4839 PADOFFSET ix;
4840 SV* name;
4841
4842 name = NEWSV(1106,0);
4843 sv_upgrade(name, SVt_PVNV);
4844 sv_setpvn(name, "&", 1);
4845 SvIVX(name) = -1;
4846 SvNVX(name) = 1;
5dc0d613 4847 ix = pad_alloc(o->op_type, SVs_PADMY);
3280af22
NIS		 4848 av_store(PL_comppad_name, ix, name);
4849 av_store(PL_comppad, ix, cSVOPo->op_sv);
5dc0d613
MB		 4850 SvPADMY_on(cSVOPo->op_sv);
4851 cSVOPo->op_sv = Nullsv;
4852 cSVOPo->op_targ = ix;
4853 return o;
5f05dabc 4854}
4855
4856OP *
cea2e8a9 4857Perl_ck_bitop(pTHX_ OP *o)
55497cff 4858{
3280af22 4859 o->op_private = PL_hints;
5dc0d613 4860 return o;
55497cff 4861}
4862
4863OP *
cea2e8a9 4864Perl_ck_concat(pTHX_ OP *o)
79072805 4865{
11343788
MB		 4866 if (cUNOPo->op_first->op_type == OP_CONCAT)
4867 o->op_flags |= OPf_STACKED;
4868 return o;
79072805
LW		 4869}
4870
4871OP *
cea2e8a9 4872Perl_ck_spair(pTHX_ OP *o)
79072805 4873{
11343788 4874 if (o->op_flags & OPf_KIDS) {
79072805 4875 OP* newop;
a0d0e21e 4876 OP* kid;
5dc0d613
MB		 4877 OPCODE type = o->op_type;
4878 o = modkids(ck_fun(o), type);
11343788 4879 kid = cUNOPo->op_first;
a0d0e21e
LW		 4880 newop = kUNOP->op_first->op_sibling;
4881 if (newop &&
4882 (newop->op_sibling ||
22c35a8c 4883 !(PL_opargs[newop->op_type] & OA_RETSCALAR) ||
a0d0e21e
LW		 4884 newop->op_type == OP_PADAV || newop->op_type == OP_PADHV ||
4885 newop->op_type == OP_RV2AV || newop->op_type == OP_RV2HV)) {
aeea060c 4886
11343788 4887 return o;
a0d0e21e
LW		 4888 }
4889 op_free(kUNOP->op_first);
4890 kUNOP->op_first = newop;
4891 }
22c35a8c 4892 o->op_ppaddr = PL_ppaddr[++o->op_type];
11343788 4893 return ck_fun(o);
a0d0e21e
LW		 4894}
4895
4896OP *
cea2e8a9 4897Perl_ck_delete(pTHX_ OP *o)
a0d0e21e 4898{
11343788 4899 o = ck_fun(o);
5dc0d613 4900 o->op_private = 0;
11343788
MB		 4901 if (o->op_flags & OPf_KIDS) {
4902 OP *kid = cUNOPo->op_first;
5f05dabc 4903 if (kid->op_type == OP_HSLICE)
5dc0d613 4904 o->op_private |= OPpSLICE;
5f05dabc 4905 else if (kid->op_type != OP_HELEM)
cea2e8a9 4906 Perl_croak(aTHX_ "%s argument is not a HASH element or slice",
22c35a8c 4907 PL_op_desc[o->op_type]);
a0d0e21e 4908 null(kid);
79072805 4909 }
11343788 4910 return o;
79072805
LW		 4911}
4912
4913OP *
cea2e8a9 4914Perl_ck_eof(pTHX_ OP *o)
79072805 4915{
11343788 4916 I32 type = o->op_type;
79072805 4917
11343788
MB		 4918 if (o->op_flags & OPf_KIDS) {
4919 if (cLISTOPo->op_first->op_type == OP_STUB) {
4920 op_free(o);
4921 o = newUNOP(type, OPf_SPECIAL,
d58bf5aa 4922 newGVOP(OP_GV, 0, gv_fetchpv("main::ARGV", TRUE, SVt_PVAV)));
8990e307 4923 }
11343788 4924 return ck_fun(o);
79072805 4925 }
11343788 4926 return o;
79072805
LW		 4927}
4928
4929OP *
cea2e8a9 4930Perl_ck_eval(pTHX_ OP *o)
79072805 4931{
3280af22 4932 PL_hints |= HINT_BLOCK_SCOPE;
11343788
MB		 4933 if (o->op_flags & OPf_KIDS) {
4934 SVOP *kid = (SVOP*)cUNOPo->op_first;
79072805 4935
93a17b20 4936 if (!kid) {
11343788
MB		 4937 o->op_flags &= ~OPf_KIDS;
4938 null(o);
79072805
LW		 4939 }
4940 else if (kid->op_type == OP_LINESEQ) {
4941 LOGOP *enter;
4942
11343788
MB		 4943 kid->op_next = o->op_next;
4944 cUNOPo->op_first = 0;
4945 op_free(o);
79072805 4946
b7dc083c 4947 NewOp(1101, enter, 1, LOGOP);
79072805 4948 enter->op_type = OP_ENTERTRY;
22c35a8c 4949 enter->op_ppaddr = PL_ppaddr[OP_ENTERTRY];
79072805
LW		 4950 enter->op_private = 0;
4951
4952 /* establish postfix order */
4953 enter->op_next = (OP*)enter;
4954
11343788
MB		 4955 o = prepend_elem(OP_LINESEQ, (OP*)enter, (OP*)kid);
4956 o->op_type = OP_LEAVETRY;
22c35a8c 4957 o->op_ppaddr = PL_ppaddr[OP_LEAVETRY];
11343788
MB		 4958 enter->op_other = o;
4959 return o;
79072805 4960 }
c7cc6f1c 4961 else
473986ff 4962 scalar((OP*)kid);
79072805
LW		 4963 }
4964 else {
11343788 4965 op_free(o);
54b9620d 4966 o = newUNOP(OP_ENTEREVAL, 0, newDEFSVOP());
79072805 4967 }
3280af22 4968 o->op_targ = (PADOFFSET)PL_hints;
11343788 4969 return o;
79072805
LW		 4970}
4971
4972OP *
cea2e8a9 4973Perl_ck_exec(pTHX_ OP *o)
79072805
LW		 4974{
4975 OP *kid;
11343788
MB		 4976 if (o->op_flags & OPf_STACKED) {
4977 o = ck_fun(o);
4978 kid = cUNOPo->op_first->op_sibling;
8990e307
LW		 4979 if (kid->op_type == OP_RV2GV)
4980 null(kid);
79072805 4981 }
463ee0b2 4982 else
11343788
MB		 4983 o = listkids(o);
4984 return o;
79072805
LW		 4985}
4986
4987OP *
cea2e8a9 4988Perl_ck_exists(pTHX_ OP *o)
5f05dabc 4989{
5196be3e
MB		 4990 o = ck_fun(o);
4991 if (o->op_flags & OPf_KIDS) {
4992 OP *kid = cUNOPo->op_first;
5f05dabc 4993 if (kid->op_type != OP_HELEM)
cea2e8a9 4994 Perl_croak(aTHX_ "%s argument is not a HASH element", PL_op_desc[o->op_type]);
5f05dabc 4995 null(kid);
4996 }
5196be3e 4997 return o;
5f05dabc 4998}
4999
22c35a8c 5000#if 0
5f05dabc 5001OP *
cea2e8a9 5002Perl_ck_gvconst(pTHX_ register OP *o)
79072805
LW		 5003{
5004 o = fold_constants(o);
5005 if (o->op_type == OP_CONST)
5006 o->op_type = OP_GV;
5007 return o;
5008}
22c35a8c 5009#endif
79072805
LW		 5010
5011OP *
cea2e8a9 5012Perl_ck_rvconst(pTHX_ register OP *o)
79072805 5013{
11343788
MB		 5014 dTHR;
5015 SVOP *kid = (SVOP*)cUNOPo->op_first;
85e6fe83 5016
3280af22 5017 o->op_private |= (PL_hints & HINT_STRICT_REFS);
79072805 5018 if (kid->op_type == OP_CONST) {
44a8e56a 5019 char *name;
5020 int iscv;
5021 GV *gv;
779c5bc9 5022 SV *kidsv = kid->op_sv;
2d8e6c8d 5023 STRLEN n_a;
44a8e56a 5024
779c5bc9
GS		 5025 /* Is it a constant from cv_const_sv()? */
5026 if (SvROK(kidsv) && SvREADONLY(kidsv)) {
5027 SV *rsv = SvRV(kidsv);
5028 int svtype = SvTYPE(rsv);
5029 char *badtype = Nullch;
5030
5031 switch (o->op_type) {
5032 case OP_RV2SV:
5033 if (svtype > SVt_PVMG)
5034 badtype = "a SCALAR";
5035 break;
5036 case OP_RV2AV:
5037 if (svtype != SVt_PVAV)
5038 badtype = "an ARRAY";
5039 break;
5040 case OP_RV2HV:
5041 if (svtype != SVt_PVHV) {
5042 if (svtype == SVt_PVAV) { /* pseudohash? */
5043 SV **ksv = av_fetch((AV*)rsv, 0, FALSE);
5044 if (ksv && SvROK(*ksv)
5045 && SvTYPE(SvRV(*ksv)) == SVt_PVHV)
5046 {
5047 break;
5048 }
5049 }
5050 badtype = "a HASH";
5051 }
5052 break;
5053 case OP_RV2CV:
5054 if (svtype != SVt_PVCV)
5055 badtype = "a CODE";
5056 break;
5057 }
5058 if (badtype)
cea2e8a9 5059 Perl_croak(aTHX_ "Constant is not %s reference", badtype);
779c5bc9
GS		 5060 return o;
5061 }
2d8e6c8d 5062 name = SvPV(kidsv, n_a);
3280af22 5063 if ((PL_hints & HINT_STRICT_REFS) && (kid->op_private & OPpCONST_BARE)) {
44a8e56a 5064 char *badthing = Nullch;
5dc0d613 5065 switch (o->op_type) {
44a8e56a 5066 case OP_RV2SV:
5067 badthing = "a SCALAR";
5068 break;
5069 case OP_RV2AV:
5070 badthing = "an ARRAY";
5071 break;
5072 case OP_RV2HV:
5073 badthing = "a HASH";
5074 break;
5075 }
5076 if (badthing)
cea2e8a9 5077 Perl_croak(aTHX_
44a8e56a 5078 "Can't use bareword (\"%s\") as %s ref while \"strict refs\" in use",
5079 name, badthing);
5080 }
93233ece
CS		 5081 /*
5082 * This is a little tricky. We only want to add the symbol if we
5083 * didn't add it in the lexer. Otherwise we get duplicate strict
5084 * warnings. But if we didn't add it in the lexer, we must at
5085 * least pretend like we wanted to add it even if it existed before,
5086 * or we get possible typo warnings. OPpCONST_ENTERED says
5087 * whether the lexer already added THIS instance of this symbol.
5088 */
5196be3e 5089 iscv = (o->op_type == OP_RV2CV) * 2;
93233ece 5090 do {
44a8e56a 5091 gv = gv_fetchpv(name,
748a9306 5092 iscv | !(kid->op_private & OPpCONST_ENTERED),
a0d0e21e
LW		 5093 iscv
5094 ? SVt_PVCV
11343788 5095 : o->op_type == OP_RV2SV
a0d0e21e 5096 ? SVt_PV
11343788 5097 : o->op_type == OP_RV2AV
a0d0e21e 5098 ? SVt_PVAV
11343788 5099 : o->op_type == OP_RV2HV
a0d0e21e
LW		 5100 ? SVt_PVHV
5101 : SVt_PVGV);
93233ece
CS		 5102 } while (!gv && !(kid->op_private & OPpCONST_ENTERED) && !iscv++);
5103 if (gv) {
5104 kid->op_type = OP_GV;
5105 SvREFCNT_dec(kid->op_sv);
350de78d
GS		 5106#ifdef USE_ITHREADS
5107 /* XXXXXX hack: dependence on sizeof(PADOP) <= sizeof(SVOP) */
5108 kPADOP->op_padix = pad_alloc(OP_GV, SVs_PADTMP);
743e66e6 5109 GvIN_PAD_on(gv);
350de78d
GS		 5110 PL_curpad[kPADOP->op_padix] = SvREFCNT_inc(gv);
5111#else
93233ece 5112 kid->op_sv = SvREFCNT_inc(gv);
350de78d 5113#endif
76cd736e 5114 kid->op_ppaddr = PL_ppaddr[OP_GV];
a0d0e21e 5115 }
79072805 5116 }
11343788 5117 return o;
79072805
LW		 5118}
5119
5120OP *
cea2e8a9 5121Perl_ck_ftst(pTHX_ OP *o)
79072805 5122{
11343788
MB		 5123 dTHR;
5124 I32 type = o->op_type;
79072805 5125
d0dca557
JD		 5126 if (o->op_flags & OPf_REF) {
5127 /* nothing */
5128 }
5129 else if (o->op_flags & OPf_KIDS && cUNOPo->op_first->op_type != OP_STUB) {
11343788 5130 SVOP *kid = (SVOP*)cUNOPo->op_first;
79072805
LW		 5131
5132 if (kid->op_type == OP_CONST && (kid->op_private & OPpCONST_BARE)) {
2d8e6c8d 5133 STRLEN n_a;
a0d0e21e 5134 OP *newop = newGVOP(type, OPf_REF,
2d8e6c8d 5135 gv_fetchpv(SvPVx(kid->op_sv, n_a), TRUE, SVt_PVIO));
11343788 5136 op_free(o);
d0dca557 5137 o = newop;
79072805
LW		 5138 }
5139 }
5140 else {
11343788 5141 op_free(o);
79072805 5142 if (type == OP_FTTTY)
d0dca557 5143 o = newGVOP(type, OPf_REF, gv_fetchpv("main::STDIN", TRUE,
85e6fe83 5144 SVt_PVIO));
79072805 5145 else
d0dca557 5146 o = newUNOP(type, 0, newDEFSVOP());
79072805 5147 }
d0dca557
JD		 5148#ifdef USE_LOCALE
5149 if (type == OP_FTTEXT || type == OP_FTBINARY) {
5150 o->op_private = 0;
5151 if (PL_hints & HINT_LOCALE)
5152 o->op_private |= OPpLOCALE;
5153 }
5154#endif
11343788 5155 return o;
79072805
LW		 5156}
5157
5158OP *
cea2e8a9 5159Perl_ck_fun(pTHX_ OP *o)
79072805 5160{
11343788 5161 dTHR;
79072805
LW		 5162 register OP *kid;
5163 OP **tokid;
5164 OP *sibl;
5165 I32 numargs = 0;
11343788 5166 int type = o->op_type;
22c35a8c 5167 register I32 oa = PL_opargs[type] >> OASHIFT;
aeea060c 5168
11343788 5169 if (o->op_flags & OPf_STACKED) {
79072805
LW		 5170 if ((oa & OA_OPTIONAL) && (oa >> 4) && !((oa >> 4) & OA_OPTIONAL))
5171 oa &= ~OA_OPTIONAL;
5172 else
11343788 5173 return no_fh_allowed(o);
79072805
LW		 5174 }
5175
11343788 5176 if (o->op_flags & OPf_KIDS) {
2d8e6c8d 5177 STRLEN n_a;
11343788
MB		 5178 tokid = &cLISTOPo->op_first;
5179 kid = cLISTOPo->op_first;
8990e307
LW		 5180 if (kid->op_type == OP_PUSHMARK ||
5181 kid->op_type == OP_NULL && kid->op_targ == OP_PUSHMARK)
5182 {
79072805
LW		 5183 tokid = &kid->op_sibling;
5184 kid = kid->op_sibling;
5185 }
22c35a8c 5186 if (!kid && PL_opargs[type] & OA_DEFGV)
54b9620d 5187 *tokid = kid = newDEFSVOP();
79072805
LW		 5188
5189 while (oa && kid) {
5190 numargs++;
5191 sibl = kid->op_sibling;
5192 switch (oa & 7) {
5193 case OA_SCALAR:
62c18ce2
GS		 5194 /* list seen where single (scalar) arg expected? */
5195 if (numargs == 1 && !(oa >> 4)
5196 && kid->op_type == OP_LIST && type != OP_SCALAR)
5197 {
5198 return too_many_arguments(o,PL_op_desc[type]);
5199 }
79072805
LW		 5200 scalar(kid);
5201 break;
5202 case OA_LIST:
5203 if (oa < 16) {
5204 kid = 0;
5205 continue;
5206 }
5207 else
5208 list(kid);
5209 break;
5210 case OA_AVREF:
5211 if (kid->op_type == OP_CONST &&
62c18ce2
GS		 5212 (kid->op_private & OPpCONST_BARE))
5213 {
2d8e6c8d 5214 char *name = SvPVx(((SVOP*)kid)->op_sv, n_a);
79072805 5215 OP *newop = newAVREF(newGVOP(OP_GV, 0,
85e6fe83 5216 gv_fetchpv(name, TRUE, SVt_PVAV) ));
b9c39e73 5217 if (ckWARN(WARN_SYNTAX))
cf2093f6 5218 Perl_warner(aTHX_ WARN_SYNTAX,
57def98f 5219 "Array @%s missing the @ in argument %"IVdf" of %s()",
cf2093f6 5220 name, (IV)numargs, PL_op_desc[type]);
79072805
LW		 5221 op_free(kid);
5222 kid = newop;
5223 kid->op_sibling = sibl;
5224 *tokid = kid;
5225 }
8990e307 5226 else if (kid->op_type != OP_RV2AV && kid->op_type != OP_PADAV)
35cd451c 5227 bad_type(numargs, "array", PL_op_desc[type], kid);
a0d0e21e 5228 mod(kid, type);
79072805
LW		 5229 break;
5230 case OA_HVREF:
5231 if (kid->op_type == OP_CONST &&
62c18ce2
GS		 5232 (kid->op_private & OPpCONST_BARE))
5233 {
2d8e6c8d 5234 char *name = SvPVx(((SVOP*)kid)->op_sv, n_a);
79072805 5235 OP *newop = newHVREF(newGVOP(OP_GV, 0,
85e6fe83 5236 gv_fetchpv(name, TRUE, SVt_PVHV) ));
b9c39e73 5237 if (ckWARN(WARN_SYNTAX))
cf2093f6 5238 Perl_warner(aTHX_ WARN_SYNTAX,
57def98f 5239 "Hash %%%s missing the %% in argument %"IVdf" of %s()",
cf2093f6 5240 name, (IV)numargs, PL_op_desc[type]);
79072805
LW		 5241 op_free(kid);
5242 kid = newop;
5243 kid->op_sibling = sibl;
5244 *tokid = kid;
5245 }
8990e307 5246 else if (kid->op_type != OP_RV2HV && kid->op_type != OP_PADHV)
35cd451c 5247 bad_type(numargs, "hash", PL_op_desc[type], kid);
a0d0e21e 5248 mod(kid, type);
79072805
LW		 5249 break;
5250 case OA_CVREF:
5251 {
a0d0e21e 5252 OP *newop = newUNOP(OP_NULL, 0, kid);
79072805
LW		 5253 kid->op_sibling = 0;
5254 linklist(kid);
5255 newop->op_next = newop;
5256 kid = newop;
5257 kid->op_sibling = sibl;
5258 *tokid = kid;
5259 }
5260 break;
5261 case OA_FILEREF:
c340be78 5262 if (kid->op_type != OP_GV && kid->op_type != OP_RV2GV) {
79072805 5263 if (kid->op_type == OP_CONST &&
62c18ce2
GS		 5264 (kid->op_private & OPpCONST_BARE))
5265 {
79072805 5266 OP *newop = newGVOP(OP_GV, 0,
2d8e6c8d 5267 gv_fetchpv(SvPVx(((SVOP*)kid)->op_sv, n_a), TRUE,
85e6fe83 5268 SVt_PVIO) );
79072805
LW		 5269 op_free(kid);
5270 kid = newop;
5271 }
1ea32a52
GS		 5272 else if (kid->op_type == OP_READLINE) {
5273 /* neophyte patrol: open(<FH>), close(<FH>) etc. */
5274 bad_type(numargs, "HANDLE", PL_op_desc[o->op_type], kid);
5275 }
79072805 5276 else {
35cd451c 5277 I32 flags = OPf_SPECIAL;
a6c40364 5278 I32 priv = 0;
35cd451c 5279 /* is this op a FH constructor? */
853846ea 5280 if (is_handle_constructor(o,numargs)) {
1d8d4d2a 5281 flags = 0;
853846ea
NIS		 5282 /* Set a flag to tell rv2gv to vivify
5283 * need to "prove" flag does not mean something
5284 * else already - NI-S 1999/05/07
5285 */
a6c40364 5286 priv = OPpDEREF;
1d8d4d2a
NIS		 5287#if 0
5288 /* Helps with open($array[$n],...)
5289 but is too simplistic - need to do selectively
5290 */
5291 mod(kid,type);
5292#endif
853846ea 5293 }
79072805 5294 kid->op_sibling = 0;
35cd451c 5295 kid = newUNOP(OP_RV2GV, flags, scalar(kid));
a6c40364
GS		 5296 if (priv) {
5297 kid->op_private |= priv;
1d8d4d2a 5298 }
79072805
LW		 5299 }
5300 kid->op_sibling = sibl;
5301 *tokid = kid;
5302 }
5303 scalar(kid);
5304 break;
5305 case OA_SCALARREF:
a0d0e21e 5306 mod(scalar(kid), type);
79072805
LW		 5307 break;
5308 }
5309 oa >>= 4;
5310 tokid = &kid->op_sibling;
5311 kid = kid->op_sibling;
5312 }
11343788 5313 o->op_private |= numargs;
79072805 5314 if (kid)
22c35a8c 5315 return too_many_arguments(o,PL_op_desc[o->op_type]);
11343788 5316 listkids(o);
79072805 5317 }
22c35a8c 5318 else if (PL_opargs[type] & OA_DEFGV) {
11343788 5319 op_free(o);
54b9620d 5320 return newUNOP(type, 0, newDEFSVOP());
a0d0e21e
LW		 5321 }
5322
79072805
LW		 5323 if (oa) {
5324 while (oa & OA_OPTIONAL)
5325 oa >>= 4;
5326 if (oa && oa != OA_LIST)
22c35a8c 5327 return too_few_arguments(o,PL_op_desc[o->op_type]);
79072805 5328 }
11343788 5329 return o;
79072805
LW		 5330}
5331
5332OP *
cea2e8a9 5333Perl_ck_glob(pTHX_ OP *o)
79072805 5334{
fb73857a 5335 GV *gv;
5336
1f2bfc8a 5337 if ((o->op_flags & OPf_KIDS) && !cLISTOPo->op_first->op_sibling)
54b9620d 5338 append_elem(OP_GLOB, o, newDEFSVOP());
fb73857a 5339
5340 if (!((gv = gv_fetchpv("glob", FALSE, SVt_PVCV)) && GvIMPORTED_CV(gv)))
5341 gv = gv_fetchpv("CORE::GLOBAL::glob", FALSE, SVt_PVCV);
b1cb66bf 5342
a7089531 5343#if defined(PERL_INTERNAL_GLOB) && !defined(MINIPERL_BUILD)
72b16652
GS		 5344 /* XXX this can be tightened up and made more failsafe. */
5345 if (!gv) {
5346 OP *modname = newSVOP(OP_CONST, 0, newSVpvn("File::Glob", 10));
5347 modname->op_private |= OPpCONST_BARE;
5348 ENTER;
5349 utilize(1, start_subparse(FALSE, 0), Nullop, modname,
5350 newSVOP(OP_CONST, 0, newSVpvn("globally", 8)));
5351 gv = gv_fetchpv("CORE::GLOBAL::glob", FALSE, SVt_PVCV);
5352 LEAVE;
5353 }
a7089531 5354#endif /* PERL_INTERNAL_GLOB && !MINIPERL_BUILD */
72b16652 5355
b1cb66bf 5356 if (gv && GvIMPORTED_CV(gv)) {
5196be3e 5357 append_elem(OP_GLOB, o,
80252599 5358 newSVOP(OP_CONST, 0, newSViv(PL_glob_index++)));
1f2bfc8a 5359 o->op_type = OP_LIST;
22c35a8c 5360 o->op_ppaddr = PL_ppaddr[OP_LIST];
1f2bfc8a 5361 cLISTOPo->op_first->op_type = OP_PUSHMARK;
22c35a8c 5362 cLISTOPo->op_first->op_ppaddr = PL_ppaddr[OP_PUSHMARK];
1f2bfc8a 5363 o = newUNOP(OP_ENTERSUB, OPf_STACKED,
aeea060c 5364 append_elem(OP_LIST, o,
1f2bfc8a
MB		 5365 scalar(newUNOP(OP_RV2CV, 0,
5366 newGVOP(OP_GV, 0, gv)))));
d58bf5aa
MB		 5367 o = newUNOP(OP_NULL, 0, ck_subr(o));
5368 o->op_targ = OP_GLOB; /* hint at what it used to be */
5369 return o;
b1cb66bf 5370 }
5371 gv = newGVgen("main");
a0d0e21e 5372 gv_IOadd(gv);
11343788
MB		 5373 append_elem(OP_GLOB, o, newGVOP(OP_GV, 0, gv));
5374 scalarkids(o);
5375 return ck_fun(o);
79072805
LW		 5376}
5377
5378OP *
cea2e8a9 5379Perl_ck_grep(pTHX_ OP *o)
79072805
LW		 5380{
5381 LOGOP *gwop;
5382 OP *kid;
11343788 5383 OPCODE type = o->op_type == OP_GREPSTART ? OP_GREPWHILE : OP_MAPWHILE;
79072805 5384
22c35a8c 5385 o->op_ppaddr = PL_ppaddr[OP_GREPSTART];
b7dc083c 5386 NewOp(1101, gwop, 1, LOGOP);
aeea060c 5387
11343788 5388 if (o->op_flags & OPf_STACKED) {
a0d0e21e 5389 OP* k;
11343788
MB		 5390 o = ck_sort(o);
5391 kid = cLISTOPo->op_first->op_sibling;
5392 for (k = cLISTOPo->op_first->op_sibling->op_next; k; k = k->op_next) {
a0d0e21e
LW		 5393 kid = k;
5394 }
5395 kid->op_next = (OP*)gwop;
11343788 5396 o->op_flags &= ~OPf_STACKED;
93a17b20 5397 }
11343788 5398 kid = cLISTOPo->op_first->op_sibling;
a0d0e21e
LW		 5399 if (type == OP_MAPWHILE)
5400 list(kid);
5401 else
5402 scalar(kid);
11343788 5403 o = ck_fun(o);
3280af22 5404 if (PL_error_count)
11343788 5405 return o;
aeea060c 5406 kid = cLISTOPo->op_first->op_sibling;
79072805 5407 if (kid->op_type != OP_NULL)
cea2e8a9 5408 Perl_croak(aTHX_ "panic: ck_grep");
79072805
LW		 5409 kid = kUNOP->op_first;
5410
a0d0e21e 5411 gwop->op_type = type;
22c35a8c 5412 gwop->op_ppaddr = PL_ppaddr[type];
11343788 5413 gwop->op_first = listkids(o);
79072805
LW		 5414 gwop->op_flags |= OPf_KIDS;
5415 gwop->op_private = 1;
5416 gwop->op_other = LINKLIST(kid);
a0d0e21e 5417 gwop->op_targ = pad_alloc(type, SVs_PADTMP);
79072805
LW		 5418 kid->op_next = (OP*)gwop;
5419
11343788 5420 kid = cLISTOPo->op_first->op_sibling;
a0d0e21e 5421 if (!kid || !kid->op_sibling)
22c35a8c 5422 return too_few_arguments(o,PL_op_desc[o->op_type]);
a0d0e21e
LW		 5423 for (kid = kid->op_sibling; kid; kid = kid->op_sibling)
5424 mod(kid, OP_GREPSTART);
5425
79072805
LW		 5426 return (OP*)gwop;
5427}
5428
5429OP *
cea2e8a9 5430Perl_ck_index(pTHX_ OP *o)
79072805 5431{
11343788
MB		 5432 if (o->op_flags & OPf_KIDS) {
5433 OP *kid = cLISTOPo->op_first->op_sibling; /* get past pushmark */
0b71040e
LW		 5434 if (kid)
5435 kid = kid->op_sibling; /* get past "big" */
79072805 5436 if (kid && kid->op_type == OP_CONST)
2779dcf1 5437 fbm_compile(((SVOP*)kid)->op_sv, 0);
79072805 5438 }
11343788 5439 return ck_fun(o);
79072805
LW		 5440}
5441
5442OP *
cea2e8a9 5443Perl_ck_lengthconst(pTHX_ OP *o)
79072805
LW		 5444{
5445 /* XXX length optimization goes here */
11343788 5446 return ck_fun(o);
79072805
LW		 5447}
5448
5449OP *
cea2e8a9 5450Perl_ck_lfun(pTHX_ OP *o)
79072805 5451{
5dc0d613
MB		 5452 OPCODE type = o->op_type;
5453 return modkids(ck_fun(o), type);
79072805
LW		 5454}
5455
5456OP *
cea2e8a9 5457Perl_ck_defined(pTHX_ OP *o) /* 19990527 MJD */
69794302 5458{
20ce7b12 5459 dTHR;
d0334bed
GS		 5460 if ((o->op_flags & OPf_KIDS) && ckWARN(WARN_DEPRECATED)) {
5461 switch (cUNOPo->op_first->op_type) {
5462 case OP_RV2AV:
7e291ef1 5463 break; /* Globals via GV can be undef */
d0334bed
GS		 5464 case OP_PADAV:
5465 case OP_AASSIGN: /* Is this a good idea? */
5466 Perl_warner(aTHX_ WARN_DEPRECATED,
f10b0346 5467 "defined(@array) is deprecated");
d0334bed
GS		 5468 Perl_warner(aTHX_ WARN_DEPRECATED,
5469 "(Maybe you should just omit the defined()?)\n");
69794302 5470 break;
d0334bed 5471 case OP_RV2HV:
7e291ef1 5472 break; /* Globals via GV can be undef */
d0334bed
GS		 5473 case OP_PADHV:
5474 Perl_warner(aTHX_ WARN_DEPRECATED,
f10b0346 5475 "defined(%hash) is deprecated");
d0334bed
GS		 5476 Perl_warner(aTHX_ WARN_DEPRECATED,
5477 "(Maybe you should just omit the defined()?)\n");
5478 break;
5479 default:
5480 /* no warning */
5481 break;
5482 }
69794302
MJD		 5483 }
5484 return ck_rfun(o);
5485}
5486
5487OP *
cea2e8a9 5488Perl_ck_rfun(pTHX_ OP *o)
8990e307 5489{
5dc0d613
MB		 5490 OPCODE type = o->op_type;
5491 return refkids(ck_fun(o), type);
8990e307
LW		 5492}
5493
5494OP *
cea2e8a9 5495Perl_ck_listiob(pTHX_ OP *o)
79072805
LW		 5496{
5497 register OP *kid;
aeea060c 5498
11343788 5499 kid = cLISTOPo->op_first;
79072805 5500 if (!kid) {
11343788
MB		 5501 o = force_list(o);
5502 kid = cLISTOPo->op_first;
79072805
LW		 5503 }
5504 if (kid->op_type == OP_PUSHMARK)
5505 kid = kid->op_sibling;
11343788 5506 if (kid && o->op_flags & OPf_STACKED)
79072805
LW		 5507 kid = kid->op_sibling;
5508 else if (kid && !kid->op_sibling) { /* print HANDLE; */
5509 if (kid->op_type == OP_CONST && kid->op_private & OPpCONST_BARE) {
11343788 5510 o->op_flags |= OPf_STACKED; /* make it a filehandle */
748a9306 5511 kid = newUNOP(OP_RV2GV, OPf_REF, scalar(kid));
11343788
MB		 5512 cLISTOPo->op_first->op_sibling = kid;
5513 cLISTOPo->op_last = kid;
79072805
LW		 5514 kid = kid->op_sibling;
5515 }
5516 }
5517
5518 if (!kid)
54b9620d 5519 append_elem(o->op_type, o, newDEFSVOP());
79072805 5520
5dc0d613 5521 o = listkids(o);
bbce6d69 5522
5dc0d613 5523 o->op_private = 0;
36477c24 5524#ifdef USE_LOCALE
3280af22 5525 if (PL_hints & HINT_LOCALE)
5dc0d613 5526 o->op_private |= OPpLOCALE;
bbce6d69 5527#endif
5528
5dc0d613 5529 return o;
bbce6d69 5530}
5531
5532OP *
cea2e8a9 5533Perl_ck_fun_locale(pTHX_ OP *o)
bbce6d69 5534{
5dc0d613 5535 o = ck_fun(o);
bbce6d69 5536
5dc0d613 5537 o->op_private = 0;
36477c24 5538#ifdef USE_LOCALE
3280af22 5539 if (PL_hints & HINT_LOCALE)
5dc0d613 5540 o->op_private |= OPpLOCALE;
bbce6d69 5541#endif
5542
5dc0d613 5543 return o;
bbce6d69 5544}
5545
5546OP *
b162f9ea
IZ		 5547Perl_ck_sassign(pTHX_ OP *o)
5548{
5549 OP *kid = cLISTOPo->op_first;
5550 /* has a disposable target? */
5551 if ((PL_opargs[kid->op_type] & OA_TARGLEX)
5552 && !(kid->op_flags & OPf_STACKED))
5553 {
5554 OP *kkid = kid->op_sibling;
5555
5556 /* Can just relocate the target. */
2c2d71f5
JH		 5557 if (kkid && kkid->op_type == OP_PADSV
5558 && !(kkid->op_private & OPpLVAL_INTRO))
5559 {
b162f9ea 5560 /* Concat has problems if target is equal to right arg. */
3dbf192b
IZ		 5561 if (kid->op_type == OP_CONCAT) {
5562 if (kLISTOP->op_first->op_sibling->op_type == OP_PADSV
5563 && kLISTOP->op_first->op_sibling->op_targ == kkid->op_targ)
5564 return o;
b162f9ea 5565 }
3dbf192b
IZ		 5566 else if (kid->op_type == OP_JOIN) {
5567 /* do_join has problems if the arguments coincide with target.
c212fd85
IZ		 5568 In fact the second argument *can* safely coincide,
5569 but ignore=pessimize this rare occasion. */
5570 OP *arg = kLISTOP->op_first->op_sibling; /* Skip PUSHMARK */
5571
5572 while (arg) {
5573 if (arg->op_type == OP_PADSV
5574 && arg->op_targ == kkid->op_targ)
5575 return o;
5576 arg = arg->op_sibling;
5577 }
5578 }
3dbf192b
IZ		 5579 else if (kid->op_type == OP_QUOTEMETA) {
5580 /* quotemeta has problems if the argument coincides with target. */
5581 if (kLISTOP->op_first->op_type == OP_PADSV
5582 && kLISTOP->op_first->op_targ == kkid->op_targ)
5583 return o;
5584 }
b162f9ea 5585 kid->op_targ = kkid->op_targ;
743e66e6 5586 kkid->op_targ = 0;
b162f9ea
IZ		 5587 /* Now we do not need PADSV and SASSIGN. */
5588 kid->op_sibling = o->op_sibling; /* NULL */
5589 cLISTOPo->op_first = NULL;
5590 op_free(o);
5591 op_free(kkid);
5592 kid->op_private |= OPpTARGET_MY; /* Used for context settings */
5593 return kid;
5594 }
5595 }
5596 return o;
5597}
5598
5599OP *
cea2e8a9 5600Perl_ck_scmp(pTHX_ OP *o)
bbce6d69 5601{
5dc0d613 5602 o->op_private = 0;
36477c24 5603#ifdef USE_LOCALE
3280af22 5604 if (PL_hints & HINT_LOCALE)
5dc0d613 5605 o->op_private |= OPpLOCALE;
bbce6d69 5606#endif
36477c24 5607
5dc0d613 5608 return o;
79072805
LW		 5609}
5610
5611OP *
cea2e8a9 5612Perl_ck_match(pTHX_ OP *o)
79072805 5613{
5dc0d613 5614 o->op_private |= OPpRUNTIME;
11343788 5615 return o;
79072805
LW		 5616}
5617
5618OP *
f5d5a27c
CS		 5619Perl_ck_method(pTHX_ OP *o)
5620{
5621 OP *kid = cUNOPo->op_first;
5622 if (kid->op_type == OP_CONST) {
5623 SV* sv = kSVOP->op_sv;
5624 if (!(strchr(SvPVX(sv), ':') || strchr(SvPVX(sv), '\''))) {
5625 OP *cmop;
5626 sv_upgrade(sv, SVt_PVIV);
5627 SvIOK_on(sv);
5628 PERL_HASH(SvUVX(sv), SvPVX(sv), SvCUR(sv));
5629 cmop = newSVOP(OP_METHOD_NAMED, 0, sv);
5630 kSVOP->op_sv = Nullsv;
5631 op_free(o);
5632 return cmop;
5633 }
5634 }
5635 return o;
5636}
5637
5638OP *
cea2e8a9 5639Perl_ck_null(pTHX_ OP *o)
79072805 5640{
11343788 5641 return o;
79072805
LW		 5642}
5643
5644OP *
cea2e8a9 5645Perl_ck_repeat(pTHX_ OP *o)
79072805 5646{
11343788
MB		 5647 if (cBINOPo->op_first->op_flags & OPf_PARENS) {
5648 o->op_private |= OPpREPEAT_DOLIST;
5649 cBINOPo->op_first = force_list(cBINOPo->op_first);
79072805
LW		 5650 }
5651 else
11343788
MB		 5652 scalar(o);
5653 return o;
79072805
LW		 5654}
5655
5656OP *
cea2e8a9 5657Perl_ck_require(pTHX_ OP *o)
8990e307 5658{
11343788
MB		 5659 if (o->op_flags & OPf_KIDS) { /* Shall we supply missing .pm? */
5660 SVOP *kid = (SVOP*)cUNOPo->op_first;
8990e307
LW		 5661
5662 if (kid->op_type == OP_CONST && (kid->op_private & OPpCONST_BARE)) {
8990e307 5663 char *s;
a0d0e21e
LW		 5664 for (s = SvPVX(kid->op_sv); *s; s++) {
5665 if (*s == ':' && s[1] == ':') {
5666 *s = '/';
1aef975c 5667 Move(s+2, s+1, strlen(s+2)+1, char);
a0d0e21e
LW		 5668 --SvCUR(kid->op_sv);
5669 }
8990e307 5670 }
a0d0e21e 5671 sv_catpvn(kid->op_sv, ".pm", 3);
8990e307
LW		 5672 }
5673 }
11343788 5674 return ck_fun(o);
8990e307
LW		 5675}
5676
22c35a8c 5677#if 0
8990e307 5678OP *
cea2e8a9 5679Perl_ck_retarget(pTHX_ OP *o)
79072805 5680{
cea2e8a9 5681 Perl_croak(aTHX_ "NOT IMPL LINE %d",__LINE__);
79072805 5682 /* STUB */
11343788 5683 return o;
79072805 5684}
22c35a8c 5685#endif
79072805
LW		 5686
5687OP *
cea2e8a9 5688Perl_ck_select(pTHX_ OP *o)
79072805 5689{
c07a80fd 5690 OP* kid;
11343788
MB		 5691 if (o->op_flags & OPf_KIDS) {
5692 kid = cLISTOPo->op_first->op_sibling; /* get past pushmark */
2304df62 5693 if (kid && kid->op_sibling) {
11343788 5694 o->op_type = OP_SSELECT;
22c35a8c 5695 o->op_ppaddr = PL_ppaddr[OP_SSELECT];
11343788
MB		 5696 o = ck_fun(o);
5697 return fold_constants(o);
79072805
LW		 5698 }
5699 }
11343788
MB		 5700 o = ck_fun(o);
5701 kid = cLISTOPo->op_first->op_sibling; /* get past pushmark */
c07a80fd 5702 if (kid && kid->op_type == OP_RV2GV)
5703 kid->op_private &= ~HINT_STRICT_REFS;
11343788 5704 return o;
79072805
LW		 5705}
5706
5707OP *
cea2e8a9 5708Perl_ck_shift(pTHX_ OP *o)
79072805 5709{
11343788 5710 I32 type = o->op_type;
79072805 5711
11343788 5712 if (!(o->op_flags & OPf_KIDS)) {
6d4ff0d2
MB		 5713 OP *argop;
5714
11343788 5715 op_free(o);
6d4ff0d2 5716#ifdef USE_THREADS
533c011a 5717 if (!CvUNIQUE(PL_compcv)) {
6d4ff0d2 5718 argop = newOP(OP_PADAV, OPf_REF);
6b88bc9c 5719 argop->op_targ = 0; /* PL_curpad[0] is @_ */
6d4ff0d2
MB		 5720 }
5721 else {
5722 argop = newUNOP(OP_RV2AV, 0,
5723 scalar(newGVOP(OP_GV, 0,
5724 gv_fetchpv("ARGV", TRUE, SVt_PVAV))));
5725 }
5726#else
5727 argop = newUNOP(OP_RV2AV, 0,
3280af22
NIS		 5728 scalar(newGVOP(OP_GV, 0, !CvUNIQUE(PL_compcv) ?
5729 PL_defgv : gv_fetchpv("ARGV", TRUE, SVt_PVAV))));
6d4ff0d2
MB		 5730#endif /* USE_THREADS */
5731 return newUNOP(type, 0, scalar(argop));
79072805 5732 }
11343788 5733 return scalar(modkids(ck_fun(o), type));
79072805
LW		 5734}
5735
5736OP *
cea2e8a9 5737Perl_ck_sort(pTHX_ OP *o)
79072805 5738{
5dc0d613 5739 o->op_private = 0;
36477c24 5740#ifdef USE_LOCALE
3280af22 5741 if (PL_hints & HINT_LOCALE)
5dc0d613 5742 o->op_private |= OPpLOCALE;
bbce6d69 5743#endif
5744
9ea6e965 5745 if (o->op_type == OP_SORT && o->op_flags & OPf_STACKED)
51a19bc0 5746 simplify_sort(o);
9c007264 5747 if (o->op_flags & OPf_STACKED) { /* may have been cleared */
11343788 5748 OP *kid = cLISTOPo->op_first->op_sibling; /* get past pushmark */
463ee0b2 5749 OP *k;
82092f1d 5750 kid = kUNOP->op_first; /* get past null */
79072805 5751
463ee0b2 5752 if (kid->op_type == OP_SCOPE || kid->op_type == OP_LEAVE) {
79072805 5753 linklist(kid);
463ee0b2
LW		 5754 if (kid->op_type == OP_SCOPE) {
5755 k = kid->op_next;
5756 kid->op_next = 0;
79072805 5757 }
463ee0b2 5758 else if (kid->op_type == OP_LEAVE) {
11343788 5759 if (o->op_type == OP_SORT) {
748a9306
LW		 5760 null(kid); /* wipe out leave */
5761 kid->op_next = kid;
463ee0b2 5762
748a9306
LW		 5763 for (k = kLISTOP->op_first->op_next; k; k = k->op_next) {
5764 if (k->op_next == kid)
5765 k->op_next = 0;
5766 }
463ee0b2 5767 }
748a9306
LW		 5768 else
5769 kid->op_next = 0; /* just disconnect the leave */
a0d0e21e 5770 k = kLISTOP->op_first;
463ee0b2 5771 }
a0d0e21e
LW		 5772 peep(k);
5773
11343788 5774 kid = cLISTOPo->op_first->op_sibling; /* get past pushmark */
11343788 5775 if (o->op_type == OP_SORT)
a0d0e21e
LW		 5776 kid->op_next = kid;
5777 else
5778 kid->op_next = k;
11343788 5779 o->op_flags |= OPf_SPECIAL;
79072805 5780 }
c6e96bcb
GS		 5781 else if (kid->op_type == OP_RV2SV || kid->op_type == OP_PADSV)
5782 null(cLISTOPo->op_first->op_sibling);
79072805 5783 }
bbce6d69 5784
11343788 5785 return o;
79072805 5786}
bda4119b
GS		 5787
5788STATIC void
cea2e8a9 5789S_simplify_sort(pTHX_ OP *o)
9c007264 5790{
51a19bc0 5791 dTHR;
9c007264
JH		 5792 register OP *kid = cLISTOPo->op_first->op_sibling; /* get past pushmark */
5793 OP *k;
5794 int reversed;
350de78d 5795 GV *gv;
9c007264
JH		 5796 if (!(o->op_flags & OPf_STACKED))
5797 return;
9ea6e965
GS		 5798 GvMULTI_on(gv_fetchpv("a", TRUE, SVt_PV));
5799 GvMULTI_on(gv_fetchpv("b", TRUE, SVt_PV));
82092f1d 5800 kid = kUNOP->op_first; /* get past null */
9c007264
JH		 5801 if (kid->op_type != OP_SCOPE)
5802 return;
5803 kid = kLISTOP->op_last; /* get past scope */
5804 switch(kid->op_type) {
5805 case OP_NCMP:
5806 case OP_I_NCMP:
5807 case OP_SCMP:
5808 break;
5809 default:
5810 return;
5811 }
5812 k = kid; /* remember this node*/
5813 if (kBINOP->op_first->op_type != OP_RV2SV)
5814 return;
5815 kid = kBINOP->op_first; /* get past cmp */
5816 if (kUNOP->op_first->op_type != OP_GV)
5817 return;
5818 kid = kUNOP->op_first; /* get past rv2sv */
350de78d
GS		 5819 gv = kGVOP;
5820 if (GvSTASH(gv) != PL_curstash)
9c007264 5821 return;
350de78d 5822 if (strEQ(GvNAME(gv), "a"))
9c007264 5823 reversed = 0;
350de78d 5824 else if(strEQ(GvNAME(gv), "b"))
9c007264
JH		 5825 reversed = 1;
5826 else
5827 return;
5828 kid = k; /* back to cmp */
5829 if (kBINOP->op_last->op_type != OP_RV2SV)
5830 return;
5831 kid = kBINOP->op_last; /* down to 2nd arg */
5832 if (kUNOP->op_first->op_type != OP_GV)
5833 return;
5834 kid = kUNOP->op_first; /* get past rv2sv */
350de78d
GS		 5835 gv = kGVOP;
5836 if (GvSTASH(gv) != PL_curstash
9c007264 5837 || ( reversed
350de78d
GS		 5838 ? strNE(GvNAME(gv), "a")
5839 : strNE(GvNAME(gv), "b")))
9c007264
JH		 5840 return;
5841 o->op_flags &= ~(OPf_STACKED | OPf_SPECIAL);
5842 if (reversed)
5843 o->op_private |= OPpSORT_REVERSE;
5844 if (k->op_type == OP_NCMP)
5845 o->op_private |= OPpSORT_NUMERIC;
5846 if (k->op_type == OP_I_NCMP)
5847 o->op_private |= OPpSORT_NUMERIC | OPpSORT_INTEGER;
e507f050
SM		 5848 kid = cLISTOPo->op_first->op_sibling;
5849 cLISTOPo->op_first->op_sibling = kid->op_sibling; /* bypass old block */
5850 op_free(kid); /* then delete it */
5851 cLISTOPo->op_children--;
9c007264 5852}
79072805
LW		 5853
5854OP *
cea2e8a9 5855Perl_ck_split(pTHX_ OP *o)
79072805
LW		 5856{
5857 register OP *kid;
aeea060c 5858
11343788
MB		 5859 if (o->op_flags & OPf_STACKED)
5860 return no_fh_allowed(o);
79072805 5861
11343788 5862 kid = cLISTOPo->op_first;
8990e307 5863 if (kid->op_type != OP_NULL)
cea2e8a9 5864 Perl_croak(aTHX_ "panic: ck_split");
8990e307 5865 kid = kid->op_sibling;
11343788
MB		 5866 op_free(cLISTOPo->op_first);
5867 cLISTOPo->op_first = kid;
85e6fe83 5868 if (!kid) {
79cb57f6 5869 cLISTOPo->op_first = kid = newSVOP(OP_CONST, 0, newSVpvn(" ", 1));
11343788 5870 cLISTOPo->op_last = kid; /* There was only one element previously */
85e6fe83 5871 }
79072805
LW		 5872
5873 if (kid->op_type != OP_MATCH) {
5874 OP *sibl = kid->op_sibling;
463ee0b2 5875 kid->op_sibling = 0;
79072805 5876 kid = pmruntime( newPMOP(OP_MATCH, OPf_SPECIAL), kid, Nullop);
11343788
MB		 5877 if (cLISTOPo->op_first == cLISTOPo->op_last)
5878 cLISTOPo->op_last = kid;
5879 cLISTOPo->op_first = kid;
79072805
LW		 5880 kid->op_sibling = sibl;
5881 }
5882
5883 kid->op_type = OP_PUSHRE;
22c35a8c 5884 kid->op_ppaddr = PL_ppaddr[OP_PUSHRE];
79072805
LW		 5885 scalar(kid);
5886
5887 if (!kid->op_sibling)
54b9620d 5888 append_elem(OP_SPLIT, o, newDEFSVOP());
79072805
LW		 5889
5890 kid = kid->op_sibling;
5891 scalar(kid);
5892
5893 if (!kid->op_sibling)
11343788 5894 append_elem(OP_SPLIT, o, newSVOP(OP_CONST, 0, newSViv(0)));
79072805
LW		 5895
5896 kid = kid->op_sibling;
5897 scalar(kid);
5898
5899 if (kid->op_sibling)
22c35a8c 5900 return too_many_arguments(o,PL_op_desc[o->op_type]);
79072805 5901
11343788 5902 return o;
79072805
LW		 5903}
5904
5905OP *
eb6e2d6f
GS		 5906Perl_ck_join(pTHX_ OP *o)
5907{
5908 if (ckWARN(WARN_SYNTAX)) {
5909 OP *kid = cLISTOPo->op_first->op_sibling;
5910 if (kid && kid->op_type == OP_MATCH) {
5911 char *pmstr = "STRING";
5912 if (kPMOP->op_pmregexp)
5913 pmstr = kPMOP->op_pmregexp->precomp;
5914 Perl_warner(aTHX_ WARN_SYNTAX,
5915 "/%s/ should probably be written as \"%s\"",
5916 pmstr, pmstr);
5917 }
5918 }
5919 return ck_fun(o);
5920}
5921
5922OP *
cea2e8a9 5923Perl_ck_subr(pTHX_ OP *o)
79072805 5924{
11343788
MB		 5925 dTHR;
5926 OP *prev = ((cUNOPo->op_first->op_sibling)
5927 ? cUNOPo : ((UNOP*)cUNOPo->op_first))->op_first;
5928 OP *o2 = prev->op_sibling;
4633a7c4
LW		 5929 OP *cvop;
5930 char *proto = 0;
5931 CV *cv = 0;
46fc3d4c 5932 GV *namegv = 0;
4633a7c4
LW		 5933 int optional = 0;
5934 I32 arg = 0;
2d8e6c8d 5935 STRLEN n_a;
4633a7c4 5936
d3011074 5937 o->op_private |= OPpENTERSUB_HASTARG;
11343788 5938 for (cvop = o2; cvop->op_sibling; cvop = cvop->op_sibling) ;
4633a7c4
LW		 5939 if (cvop->op_type == OP_RV2CV) {
5940 SVOP* tmpop;
11343788 5941 o->op_private |= (cvop->op_private & OPpENTERSUB_AMPER);
4633a7c4
LW		 5942 null(cvop); /* disable rv2cv */
5943 tmpop = (SVOP*)((UNOP*)cvop)->op_first;
76cd736e 5944 if (tmpop->op_type == OP_GV && !(o->op_private & OPpENTERSUB_AMPER)) {
350de78d
GS		 5945 GV *gv = cGVOPx(tmpop);
5946 cv = GvCVu(gv);
76cd736e
GS		 5947 if (!cv)
5948 tmpop->op_private |= OPpEARLY_CV;
5949 else if (SvPOK(cv)) {
350de78d 5950 namegv = CvANON(cv) ? gv : CvGV(cv);
2d8e6c8d 5951 proto = SvPV((SV*)cv, n_a);
46fc3d4c 5952 }
4633a7c4
LW		 5953 }
5954 }
f5d5a27c 5955 else if (cvop->op_type == OP_METHOD || cvop->op_type == OP_METHOD_NAMED) {
7a52d87a
GS		 5956 if (o2->op_type == OP_CONST)
5957 o2->op_private &= ~OPpCONST_STRICT;
58a40671
GS		 5958 else if (o2->op_type == OP_LIST) {
5959 OP *o = ((UNOP*)o2)->op_first->op_sibling;
5960 if (o && o->op_type == OP_CONST)
5961 o->op_private &= ~OPpCONST_STRICT;
5962 }
7a52d87a 5963 }
3280af22
NIS		 5964 o->op_private |= (PL_hints & HINT_STRICT_REFS);
5965 if (PERLDB_SUB && PL_curstash != PL_debstash)
11343788
MB		 5966 o->op_private |= OPpENTERSUB_DB;
5967 while (o2 != cvop) {
4633a7c4
LW		 5968 if (proto) {
5969 switch (*proto) {
5970 case '\0':
5dc0d613 5971 return too_many_arguments(o, gv_ename(namegv));
4633a7c4
LW		 5972 case ';':
5973 optional = 1;
5974 proto++;
5975 continue;
5976 case '$':
5977 proto++;
5978 arg++;
11343788 5979 scalar(o2);
4633a7c4
LW		 5980 break;
5981 case '%':
5982 case '@':
11343788 5983 list(o2);
4633a7c4
LW		 5984 arg++;
5985 break;
5986 case '&':
5987 proto++;
5988 arg++;
11343788 5989 if (o2->op_type != OP_REFGEN && o2->op_type != OP_UNDEF)
5dc0d613 5990 bad_type(arg, "block", gv_ename(namegv), o2);
4633a7c4
LW		 5991 break;
5992 case '*':
2ba6ecf4 5993 /* '*' allows any scalar type, including bareword */
4633a7c4
LW		 5994 proto++;
5995 arg++;
11343788 5996 if (o2->op_type == OP_RV2GV)
2ba6ecf4 5997 goto wrapref; /* autoconvert GLOB -> GLOBref */
7a52d87a
GS		 5998 else if (o2->op_type == OP_CONST)
5999 o2->op_private &= ~OPpCONST_STRICT;
9675f7ac
GS		 6000 else if (o2->op_type == OP_ENTERSUB) {
6001 /* accidental subroutine, revert to bareword */
6002 OP *gvop = ((UNOP*)o2)->op_first;
6003 if (gvop && gvop->op_type == OP_NULL) {
6004 gvop = ((UNOP*)gvop)->op_first;
6005 if (gvop) {
6006 for (; gvop->op_sibling; gvop = gvop->op_sibling)
6007 ;
6008 if (gvop &&
6009 (gvop->op_private & OPpENTERSUB_NOPAREN) &&
6010 (gvop = ((UNOP*)gvop)->op_first) &&
6011 gvop->op_type == OP_GV)
6012 {
350de78d 6013 GV *gv = cGVOPx(gvop);
9675f7ac 6014 OP *sibling = o2->op_sibling;
2692f720 6015 SV *n = newSVpvn("",0);
9675f7ac 6016 op_free(o2);
2692f720
GS		 6017 gv_fullname3(n, gv, "");
6018 if (SvCUR(n)>6 && strnEQ(SvPVX(n),"main::",6))
6019 sv_chop(n, SvPVX(n)+6);
6020 o2 = newSVOP(OP_CONST, 0, n);
9675f7ac
GS		 6021 prev->op_sibling = o2;
6022 o2->op_sibling = sibling;
6023 }
6024 }
6025 }
6026 }
2ba6ecf4
GS		 6027 scalar(o2);
6028 break;
4633a7c4
LW		 6029 case '\\':
6030 proto++;
6031 arg++;
6032 switch (*proto++) {
6033 case '*':
11343788 6034 if (o2->op_type != OP_RV2GV)
5dc0d613 6035 bad_type(arg, "symbol", gv_ename(namegv), o2);
4633a7c4
LW		 6036 goto wrapref;
6037 case '&':
11343788 6038 if (o2->op_type != OP_RV2CV)
5dc0d613 6039 bad_type(arg, "sub", gv_ename(namegv), o2);
4633a7c4
LW		 6040 goto wrapref;
6041 case '$':
386acf99
GS		 6042 if (o2->op_type != OP_RV2SV
6043 && o2->op_type != OP_PADSV
1c01eb51
GS		 6044 && o2->op_type != OP_HELEM
6045 && o2->op_type != OP_AELEM
386acf99
GS		 6046 && o2->op_type != OP_THREADSV)
6047 {
5dc0d613 6048 bad_type(arg, "scalar", gv_ename(namegv), o2);
386acf99 6049 }
4633a7c4
LW		 6050 goto wrapref;
6051 case '@':
11343788 6052 if (o2->op_type != OP_RV2AV && o2->op_type != OP_PADAV)
5dc0d613 6053 bad_type(arg, "array", gv_ename(namegv), o2);
4633a7c4
LW		 6054 goto wrapref;
6055 case '%':
11343788 6056 if (o2->op_type != OP_RV2HV && o2->op_type != OP_PADHV)
5dc0d613 6057 bad_type(arg, "hash", gv_ename(namegv), o2);
4633a7c4
LW		 6058 wrapref:
6059 {
11343788 6060 OP* kid = o2;
6fa846a0 6061 OP* sib = kid->op_sibling;
4633a7c4 6062 kid->op_sibling = 0;
6fa846a0
GS		 6063 o2 = newUNOP(OP_REFGEN, 0, kid);
6064 o2->op_sibling = sib;
e858de61 6065 prev->op_sibling = o2;
4633a7c4
LW		 6066 }
6067 break;
6068 default: goto oops;
6069 }
6070 break;
b1cb66bf 6071 case ' ':
6072 proto++;
6073 continue;
4633a7c4
LW		 6074 default:
6075 oops:
cea2e8a9 6076 Perl_croak(aTHX_ "Malformed prototype for %s: %s",
2d8e6c8d 6077 gv_ename(namegv), SvPV((SV*)cv, n_a));
4633a7c4
LW		 6078 }
6079 }
6080 else
11343788
MB		 6081 list(o2);
6082 mod(o2, OP_ENTERSUB);
6083 prev = o2;
6084 o2 = o2->op_sibling;
4633a7c4 6085 }
fb73857a 6086 if (proto && !optional &&
6087 (*proto && *proto != '@' && *proto != '%' && *proto != ';'))
5dc0d613 6088 return too_few_arguments(o, gv_ename(namegv));
11343788 6089 return o;
79072805
LW		 6090}
6091
6092OP *
cea2e8a9 6093Perl_ck_svconst(pTHX_ OP *o)
8990e307 6094{
11343788
MB		 6095 SvREADONLY_on(cSVOPo->op_sv);
6096 return o;
8990e307
LW		 6097}
6098
6099OP *
cea2e8a9 6100Perl_ck_trunc(pTHX_ OP *o)
79072805 6101{
11343788
MB		 6102 if (o->op_flags & OPf_KIDS) {
6103 SVOP *kid = (SVOP*)cUNOPo->op_first;
79072805 6104
a0d0e21e
LW		 6105 if (kid->op_type == OP_NULL)
6106 kid = (SVOP*)kid->op_sibling;
bb53490d
GS		 6107 if (kid && kid->op_type == OP_CONST &&
6108 (kid->op_private & OPpCONST_BARE))
6109 {
11343788 6110 o->op_flags |= OPf_SPECIAL;
bb53490d
GS		 6111 kid->op_private &= ~OPpCONST_STRICT;
6112 }
79072805 6113 }
11343788 6114 return ck_fun(o);
79072805
LW		 6115}
6116
463ee0b2
LW		 6117/* A peephole optimizer. We visit the ops in the order they're to execute. */
6118
79072805 6119void
864dbfa3 6120Perl_peep(pTHX_ register OP *o)
79072805 6121{
11343788 6122 dTHR;
79072805 6123 register OP* oldop = 0;
2d8e6c8d 6124 STRLEN n_a;
cd06dffe 6125 OP *last_composite = Nullop;
2d8e6c8d 6126
a0d0e21e 6127 if (!o || o->op_seq)
79072805 6128 return;
a0d0e21e 6129 ENTER;
462e5cf6 6130 SAVEOP();
3280af22 6131 SAVESPTR(PL_curcop);
a0d0e21e
LW		 6132 for (; o; o = o->op_next) {
6133 if (o->op_seq)
6134 break;
3280af22
NIS		 6135 if (!PL_op_seqmax)
6136 PL_op_seqmax++;
533c011a 6137 PL_op = o;
a0d0e21e 6138 switch (o->op_type) {
acb36ea4 6139 case OP_SETSTATE:
a0d0e21e
LW		 6140 case OP_NEXTSTATE:
6141 case OP_DBSTATE:
3280af22
NIS		 6142 PL_curcop = ((COP*)o); /* for warnings */
6143 o->op_seq = PL_op_seqmax++;
cd06dffe 6144 last_composite = Nullop;
a0d0e21e
LW		 6145 break;
6146
a0d0e21e 6147 case OP_CONST:
7a52d87a
GS		 6148 if (cSVOPo->op_private & OPpCONST_STRICT)
6149 no_bareword_allowed(o);
6150 /* FALL THROUGH */
a0d0e21e
LW		 6151 case OP_UC:
6152 case OP_UCFIRST:
6153 case OP_LC:
6154 case OP_LCFIRST:
ed7ab888
GS		 6155 if ( o->op_next && o->op_next->op_type == OP_STRINGIFY
6156 && !(o->op_next->op_private & OPpTARGET_MY) )
6157 null(o->op_next);
6158 o->op_seq = PL_op_seqmax++;
6159 break;
6160 case OP_CONCAT:
6161 case OP_JOIN:
a0d0e21e 6162 case OP_QUOTEMETA:
b162f9ea
IZ		 6163 if (o->op_next && o->op_next->op_type == OP_STRINGIFY) {
6164 if (o->op_next->op_private & OPpTARGET_MY) {
ed7ab888 6165 if ((o->op_flags & OPf_STACKED) /* chained concats */
b162f9ea
IZ		 6166 || (o->op_type == OP_CONCAT
6167 /* Concat has problems if target is equal to right arg. */
6168 && (((LISTOP*)o)->op_first->op_sibling->op_type
6169 == OP_PADSV)
6170 && (((LISTOP*)o)->op_first->op_sibling->op_targ
743e66e6
GS		 6171 == o->op_next->op_targ)))
6172 {
b162f9ea 6173 goto ignore_optimization;
cd06dffe
GS		 6174 }
6175 else {
b162f9ea 6176 o->op_targ = o->op_next->op_targ;
743e66e6 6177 o->op_next->op_targ = 0;
2c2d71f5 6178 o->op_private |= OPpTARGET_MY;
b162f9ea
IZ		 6179 }
6180 }
a0d0e21e 6181 null(o->op_next);
b162f9ea
IZ		 6182 }
6183 ignore_optimization:
3280af22 6184 o->op_seq = PL_op_seqmax++;
a0d0e21e 6185 break;
8990e307 6186 case OP_STUB:
54310121 6187 if ((o->op_flags & OPf_WANT) != OPf_WANT_LIST) {
3280af22 6188 o->op_seq = PL_op_seqmax++;
54310121 6189 break; /* Scalar stub must produce undef. List stub is noop */
8990e307 6190 }
748a9306 6191 goto nothin;
79072805 6192 case OP_NULL:
acb36ea4
GS		 6193 if (o->op_targ == OP_NEXTSTATE
6194 || o->op_targ == OP_DBSTATE
6195 || o->op_targ == OP_SETSTATE)
6196 {
3280af22 6197 PL_curcop = ((COP*)o);
acb36ea4 6198 }
748a9306 6199 goto nothin;
79072805 6200 case OP_SCALAR:
93a17b20 6201 case OP_LINESEQ:
463ee0b2 6202 case OP_SCOPE:
748a9306 6203 nothin:
a0d0e21e
LW		 6204 if (oldop && o->op_next) {
6205 oldop->op_next = o->op_next;
79072805
LW		 6206 continue;
6207 }
3280af22 6208 o->op_seq = PL_op_seqmax++;
79072805
LW		 6209 break;
6210
6211 case OP_GV:
a0d0e21e 6212 if (o->op_next->op_type == OP_RV2SV) {
5f05dabc 6213 if (!(o->op_next->op_private & OPpDEREF)) {
a0d0e21e
LW		 6214 null(o->op_next);
6215 o->op_private |= o->op_next->op_private & OPpLVAL_INTRO;
6216 o->op_next = o->op_next->op_next;
6217 o->op_type = OP_GVSV;
22c35a8c 6218 o->op_ppaddr = PL_ppaddr[OP_GVSV];
8990e307
LW		 6219 }
6220 }
a0d0e21e
LW		 6221 else if (o->op_next->op_type == OP_RV2AV) {
6222 OP* pop = o->op_next->op_next;
6223 IV i;
8990e307 6224 if (pop->op_type == OP_CONST &&
533c011a 6225 (PL_op = pop->op_next) &&
8990e307 6226 pop->op_next->op_type == OP_AELEM &&
a0d0e21e 6227 !(pop->op_next->op_private &
68dc0745 6228 (OPpLVAL_INTRO|OPpLVAL_DEFER|OPpDEREF)) &&
3280af22 6229 (i = SvIV(((SVOP*)pop)->op_sv) - PL_compiling.cop_arybase)
a0d0e21e 6230 <= 255 &&
8990e307
LW		 6231 i >= 0)
6232 {
350de78d 6233 GV *gv;
a0d0e21e 6234 null(o->op_next);
8990e307
LW		 6235 null(pop->op_next);
6236 null(pop);
a0d0e21e
LW		 6237 o->op_flags |= pop->op_next->op_flags & OPf_MOD;
6238 o->op_next = pop->op_next->op_next;
6239 o->op_type = OP_AELEMFAST;
22c35a8c 6240 o->op_ppaddr = PL_ppaddr[OP_AELEMFAST];
a0d0e21e 6241 o->op_private = (U8)i;
350de78d
GS		 6242 gv = cGVOPo;
6243 GvAVn(gv);
8990e307 6244 }
79072805 6245 }
76cd736e 6246 else if ((o->op_private & OPpEARLY_CV) && ckWARN(WARN_UNSAFE)) {
350de78d 6247 GV *gv = cGVOPo;
76cd736e
GS		 6248 if (SvTYPE(gv) == SVt_PVGV && GvCV(gv) && SvPVX(GvCV(gv))) {
6249 /* XXX could check prototype here instead of just carping */
6250 SV *sv = sv_newmortal();
6251 gv_efullname3(sv, gv, Nullch);
6252 Perl_warner(aTHX_ WARN_UNSAFE,
6253 "%s() called too early to check prototype",
6254 SvPV_nolen(sv));
6255 }
6256 }
6257
3280af22 6258 o->op_seq = PL_op_seqmax++;
79072805
LW		 6259 break;
6260
a0d0e21e 6261 case OP_MAPWHILE:
79072805
LW		 6262 case OP_GREPWHILE:
6263 case OP_AND:
6264 case OP_OR:
2c2d71f5
JH		 6265 case OP_ANDASSIGN:
6266 case OP_ORASSIGN:
1a67a97c
SM		 6267 case OP_COND_EXPR:
6268 case OP_RANGE:
3280af22 6269 o->op_seq = PL_op_seqmax++;
fd4d1407
IZ		 6270 while (cLOGOP->op_other->op_type == OP_NULL)
6271 cLOGOP->op_other = cLOGOP->op_other->op_next;
79072805
LW		 6272 peep(cLOGOP->op_other);
6273 break;
6274
79072805 6275 case OP_ENTERLOOP:
3280af22 6276 o->op_seq = PL_op_seqmax++;
79072805
LW		 6277 peep(cLOOP->op_redoop);
6278 peep(cLOOP->op_nextop);
6279 peep(cLOOP->op_lastop);
6280 break;
6281
8782bef2 6282 case OP_QR:
79072805
LW		 6283 case OP_MATCH:
6284 case OP_SUBST:
3280af22 6285 o->op_seq = PL_op_seqmax++;
a0d0e21e 6286 peep(cPMOP->op_pmreplstart);
79072805
LW		 6287 break;
6288
a0d0e21e 6289 case OP_EXEC:
3280af22 6290 o->op_seq = PL_op_seqmax++;
599cee73
PM		 6291 if (ckWARN(WARN_SYNTAX) && o->op_next
6292 && o->op_next->op_type == OP_NEXTSTATE) {
a0d0e21e 6293 if (o->op_next->op_sibling &&
20408e3c
GS		 6294 o->op_next->op_sibling->op_type != OP_EXIT &&
6295 o->op_next->op_sibling->op_type != OP_WARN &&
a0d0e21e 6296 o->op_next->op_sibling->op_type != OP_DIE) {
57843af0 6297 line_t oldline = CopLINE(PL_curcop);
a0d0e21e 6298
57843af0 6299 CopLINE_set(PL_curcop, CopLINE((COP*)o->op_next));
cea2e8a9
GS		 6300 Perl_warner(aTHX_ WARN_SYNTAX, "Statement unlikely to be reached");
6301 Perl_warner(aTHX_ WARN_SYNTAX, "(Maybe you meant system() when you said exec()?)\n");
57843af0 6302 CopLINE_set(PL_curcop, oldline);
a0d0e21e
LW		 6303 }
6304 }
6305 break;
aeea060c 6306
c750a3ec
MB		 6307 case OP_HELEM: {
6308 UNOP *rop;
6309 SV *lexname;
6310 GV **fields;
6311 SV **svp, **indsvp;
6312 I32 ind;
6313 char *key;
6314 STRLEN keylen;
aeea060c 6315
377b21bb 6316 if ((o->op_private & (OPpLVAL_INTRO))
c750a3ec
MB		 6317 || ((BINOP*)o)->op_last->op_type != OP_CONST)
6318 break;
6319 rop = (UNOP*)((BINOP*)o)->op_first;
6320 if (rop->op_type != OP_RV2HV || rop->op_first->op_type != OP_PADSV)
6321 break;
3280af22 6322 lexname = *av_fetch(PL_comppad_name, rop->op_first->op_targ, TRUE);
c750a3ec
MB		 6323 if (!SvOBJECT(lexname))
6324 break;
5196be3e 6325 fields = (GV**)hv_fetch(SvSTASH(lexname), "FIELDS", 6, FALSE);
c750a3ec
MB		 6326 if (!fields || !GvHV(*fields))
6327 break;
6328 svp = &((SVOP*)((BINOP*)o)->op_last)->op_sv;
6329 key = SvPV(*svp, keylen);
6330 indsvp = hv_fetch(GvHV(*fields), key, keylen, FALSE);
6331 if (!indsvp) {
88e9b055 6332 Perl_croak(aTHX_ "No such pseudo-hash field \"%s\" in variable %s of type %s",
2d8e6c8d 6333 key, SvPV(lexname, n_a), HvNAME(SvSTASH(lexname)));
c750a3ec
MB		 6334 }
6335 ind = SvIV(*indsvp);
6336 if (ind < 1)
cea2e8a9 6337 Perl_croak(aTHX_ "Bad index while coercing array into hash");
c750a3ec 6338 rop->op_type = OP_RV2AV;
22c35a8c 6339 rop->op_ppaddr = PL_ppaddr[OP_RV2AV];
c750a3ec 6340 o->op_type = OP_AELEM;
22c35a8c 6341 o->op_ppaddr = PL_ppaddr[OP_AELEM];
c750a3ec
MB		 6342 SvREFCNT_dec(*svp);
6343 *svp = newSViv(ind);
6344 break;
6345 }
6346
cd06dffe
GS		 6347 case OP_RV2AV:
6348 case OP_RV2HV:
6349 if (!(o->op_flags & OPf_WANT)
e1f15930
GS		 6350 || (o->op_flags & OPf_WANT) == OPf_WANT_LIST)
6351 {
cd06dffe 6352 last_composite = o;
e1f15930 6353 }
cd06dffe
GS		 6354 o->op_seq = PL_op_seqmax++;
6355 break;
6356
6357 case OP_RETURN:
970c4905 6358 if (o->op_next && o->op_next->op_type != OP_LEAVESUBLV) {
cd06dffe
GS		 6359 o->op_seq = PL_op_seqmax++;
6360 break;
6361 }
6362 /* FALL THROUGH */
6363
6364 case OP_LEAVESUBLV:
6365 if (last_composite) {
6366 OP *r = last_composite;
6367
6368 while (r->op_sibling)
6369 r = r->op_sibling;
6370 if (r->op_next == o
6371 || (r->op_next->op_type == OP_LIST
6372 && r->op_next->op_next == o))
6373 {
6374 if (last_composite->op_type == OP_RV2AV)
6375 yyerror("Lvalue subs returning arrays not implemented yet");
6376 else
6377 yyerror("Lvalue subs returning hashes not implemented yet");
6378 ;
6379 }
6380 }
6381 /* FALL THROUGH */
6382
79072805 6383 default:
3280af22 6384 o->op_seq = PL_op_seqmax++;
79072805
LW		 6385 break;
6386 }
a0d0e21e 6387 oldop = o;
79072805 6388 }
a0d0e21e 6389 LEAVE;
79072805 6390}
Unnamed repository; edit this file 'description' to name the repository.